PageRenderTime 184ms CodeModel.GetById 23ms RepoModel.GetById 0ms app.codeStats 0ms

/edk2/BaseTools/Scripts/ConvertMasmToNasm.py

https://gitlab.com/envieidoc/Clover
Python | 986 lines | 951 code | 18 blank | 17 comment | 11 complexity | 49b20aeeeb3f96b3f2e0df6fa221d621 MD5 | raw file
    

  1. # @file ConvertMasmToNasm.py

    2. 

  2. # This script assists with conversion of MASM assembly syntax to NASM

    3. 

  3. #

    4. 

  4. #  Copyright (c) 2007 - 2014, Intel Corporation. All rights reserved.<BR>

    5. 

  5. #

    6. 

  6. #  This program and the accompanying materials

    7. 

  7. #  are licensed and made available under the terms and conditions of the BSD License

    8. 

  8. #  which accompanies this distribution.  The full text of the license may be found at

    9. 

  9. #  http://opensource.org/licenses/bsd-license.php

    10. 

  10. #

    11. 

  11. #  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

    12. 

  12. #  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

    13. 

  13. #

    14. 

  14. 

    15. 

  15. #

    16. 

  16. # Import Modules

    17. 

  17. #

    18. 

  18. import os.path

    19. 

  19. import re

    20. 

  20. import StringIO

    21. 

  21. import subprocess

    22. 

  22. import sys

    23. 

  23. from optparse import OptionParser

    24. 

  24. 

    25. 

  25. 

    26. 

  26. class UnsupportedConversion(Exception):

    27. 

  27.     pass

    28. 

  28. 

    29. 

  29. 

    30. 

  30. class NoSourceFile(Exception):

    31. 

  31.     pass

    32. 

  32. 

    33. 

  33. 

    34. 

  34. class UnsupportedArch(Exception):

    35. 

  35.     unsupported = ('aarch64', 'arm', 'ebc', 'ipf')

    36. 

  36. 

    37. 

  37. 

    38. 

  38. class CommonUtils:

    39. 

  39. 

    40. 

  40.     # Version and Copyright

    41. 

  41.     VersionNumber = "0.01"

    42. 

  42.     __version__ = "%prog Version " + VersionNumber

    43. 

  43.     __copyright__ = "Copyright (c) 2007 - 2014, Intel Corporation. All rights reserved."

    44. 

  44.     __usage__ = "%prog [options] source.asm [destination.nasm]"

    45. 

  45. 

    46. 

  46.     def __init__(self, clone=None):

    47. 

  47.         if clone is None:

    48. 

  48.             (self.Opt, self.Args) = self.ProcessCommandLine()

    49. 

  49.         else:

    50. 

  50.             (self.Opt, self.Args) = (clone.Opt, clone.Args)

    51. 

  51. 

    52. 

  52.         self.unsupportedSyntaxSeen = False

    53. 

  53.         self.src = self.Args[0]

    54. 

  54.         assert(os.path.exists(self.src))

    55. 

  55.         self.dirmode = os.path.isdir(self.src)

    56. 

  56.         srcExt = os.path.splitext(self.src)[1]

    57. 

  57.         assert (self.dirmode or srcExt != '.nasm')

    58. 

  58.         self.infmode = not self.dirmode and srcExt == '.inf'

    59. 

  59.         self.diff = self.Opt.diff

    60. 

  60.         self.git = self.Opt.git

    61. 

  61.         self.force = self.Opt.force

    62. 

  62. 

    63. 

  63.         if clone is None:

    64. 

  64.             self.rootdir = os.getcwd()

    65. 

  65.             self.DetectGit()

    66. 

  66.         else:

    67. 

  67.             self.rootdir = clone.rootdir

    68. 

  68.             self.gitdir = clone.gitdir

    69. 

  69.             self.gitemail = clone.gitemail

    70. 

  70. 

    71. 

  71.     def ProcessCommandLine(self):

    72. 

  72.         Parser = OptionParser(description=self.__copyright__,

    73. 

  73.                               version=self.__version__,

    74. 

  74.                               prog=sys.argv[0],

    75. 

  75.                               usage=self.__usage__

    76. 

  76.                               )

    77. 

  77.         Parser.add_option("-q", "--quiet", action="store_true", type=None,

    78. 

  78.                           help="Disable all messages except FATAL ERRORS.")

    79. 

  79.         Parser.add_option("--git", action="store_true", type=None,

    80. 

  80.                           help="Use git to create commits for each file converted")

    81. 

  81.         Parser.add_option("--diff", action="store_true", type=None,

    82. 

  82.                           help="Show diff of conversion")

    83. 

  83.         Parser.add_option("-f", "--force", action="store_true", type=None,

    84. 

  84.                           help="Force conversion even if unsupported")

    85. 

  85. 

    86. 

  86.         (Opt, Args) = Parser.parse_args()

    87. 

  87. 

    88. 

  88.         if not Opt.quiet:

    89. 

  89.             print self.__copyright__

    90. 

  90.             Parser.print_version()

    91. 

  91. 

    92. 

  92.         return (Opt, Args)

    93. 

  93. 

    94. 

  94.     def RootRelative(self, path):

    95. 

  95.         result = path

    96. 

  96.         if result.startswith(self.rootdir):

    97. 

  97.             result = result[len(self.rootdir):]

    98. 

  98.             while len(result) > 0 and result[0] in '/\\':

    99. 

  99.                 result = result[1:]

    100. 

  100.         return result

    101. 

  101. 

    102. 

  102.     def MatchAndSetMo(self, regexp, string):

    103. 

  103.         self.mo = regexp.match(string)

    104. 

  104.         return self.mo is not None

    105. 

  105. 

    106. 

  106.     def SearchAndSetMo(self, regexp, string):

    107. 

  107.         self.mo = regexp.search(string)

    108. 

  108.         return self.mo is not None

    109. 

  109. 

    110. 

  110.     def ReplacePreserveSpacing(self, string, find, replace):

    111. 

  111.         if len(find) >= len(replace):

    112. 

  112.             padded = replace + (' ' * (len(find) - len(replace)))

    113. 

  113.             return string.replace(find, padded)

    114. 

  114.         elif find.find(replace) >= 0:

    115. 

  115.             return string.replace(find, replace)

    116. 

  116.         else:

    117. 

  117.             lenDiff = len(replace) - len(find)

    118. 

  118.             result = string

    119. 

  119.             for i in range(lenDiff, -1, -1):

    120. 

  120.                 padded = find + (' ' * i)

    121. 

  121.                 result = result.replace(padded, replace)

    122. 

  122.             return result

    123. 

  123. 

    124. 

  124.     def DetectGit(self):

    125. 

  125.         lastpath = os.path.realpath(self.src)

    126. 

  126.         self.gitdir = None

    127. 

  127.         while True:

    128. 

  128.             path = os.path.split(lastpath)[0]

    129. 

  129.             if path == lastpath:

    130. 

  130.                 return

    131. 

  131.             candidate = os.path.join(path, '.git')

    132. 

  132.             if os.path.isdir(candidate):

    133. 

  133.                 self.gitdir = candidate

    134. 

  134.                 self.gitemail = self.FormatGitEmailAddress()

    135. 

  135.                 return

    136. 

  136.             lastpath = path

    137. 

  137. 

    138. 

  138.     def FormatGitEmailAddress(self):

    139. 

  139.         if not self.git or not self.gitdir:

    140. 

  140.             return ''

    141. 

  141. 

    142. 

  142.         cmd = ('git', 'config', 'user.name')

    143. 

  143.         name = self.RunAndCaptureOutput(cmd).strip()

    144. 

  144.         cmd = ('git', 'config', 'user.email')

    145. 

  145.         email = self.RunAndCaptureOutput(cmd).strip()

    146. 

  146.         if name.find(',') >= 0:

    147. 

  147.             name = '"' + name + '"'

    148. 

  148.         return name + ' <' + email + '>'

    149. 

  149. 

    150. 

  150.     def RunAndCaptureOutput(self, cmd, checkExitCode=True, pipeIn=None):

    151. 

  151.         if pipeIn:

    152. 

  152.             subpStdin = subprocess.PIPE

    153. 

  153.         else:

    154. 

  154.             subpStdin = None

    155. 

  155.         p = subprocess.Popen(args=cmd, stdout=subprocess.PIPE, stdin=subpStdin)

    156. 

  156.         (stdout, stderr) = p.communicate(pipeIn)

    157. 

  157.         if checkExitCode:

    158. 

  158.             if p.returncode != 0:

    159. 

  159.                 print 'command:', ' '.join(cmd)

    160. 

  160.                 print 'stdout:', stdout

    161. 

  161.                 print 'stderr:', stderr

    162. 

  162.                 print 'return:', p.returncode

    163. 

  163.             assert p.returncode == 0

    164. 

  164.         return stdout

    165. 

  165. 

    166. 

  166.     def FileUpdated(self, path):

    167. 

  167.         if not self.git or not self.gitdir:

    168. 

  168.             return

    169. 

  169. 

    170. 

  170.         cmd = ('git', 'add', path)

    171. 

  171.         self.RunAndCaptureOutput(cmd)

    172. 

  172. 

    173. 

  173.     def FileAdded(self, path):

    174. 

  174.         self.FileUpdated(path)

    175. 

  175. 

    176. 

  176.     def RemoveFile(self, path):

    177. 

  177.         if not self.git or not self.gitdir:

    178. 

  178.             return

    179. 

  179. 

    180. 

  180.         cmd = ('git', 'rm', path)

    181. 

  181.         self.RunAndCaptureOutput(cmd)

    182. 

  182. 

    183. 

  183.     def FileConversionFinished(self, pkg, module, src, dst):

    184. 

  184.         if not self.git or not self.gitdir:

    185. 

  185.             return

    186. 

  186. 

    187. 

  187.         if not self.Opt.quiet:

    188. 

  188.             print 'Committing: Conversion of', dst

    189. 

  189. 

    190. 

  190.         prefix = ' '.join(filter(lambda a: a, [pkg, module]))

    191. 

  191.         message = ''

    192. 

  192.         if self.unsupportedSyntaxSeen:

    193. 

  193.             message += 'ERROR! '

    194. 

  194.         message += '%s: Convert %s to NASM\n' % (prefix, src)

    195. 

  195.         message += '\n'

    196. 

  196.         message += 'The %s script was used to convert\n' % sys.argv[0]

    197. 

  197.         message += '%s to %s\n' % (src, dst)

    198. 

  198.         message += '\n'

    199. 

  199.         message += 'Contributed-under: TianoCore Contribution Agreement 1.0\n'

    200. 

  200.         message += 'Signed-off-by: %s\n' % self.gitemail

    201. 

  201. 

    202. 

  202.         cmd = ('git', 'commit', '-F', '-')

    203. 

  203.         self.RunAndCaptureOutput(cmd, pipeIn=message)

    204. 

  204. 

    205. 

  205. 

    206. 

  206. class ConvertAsmFile(CommonUtils):

    207. 

  207. 

    208. 

  208.     def __init__(self, src, dst, clone):

    209. 

  209.         CommonUtils.__init__(self, clone)

    210. 

  210.         self.ConvertAsmFile(src, dst)

    211. 

  211.         self.FileAdded(dst)

    212. 

  212.         self.RemoveFile(src)

    213. 

  213. 

    214. 

  214.     def ConvertAsmFile(self, inputFile, outputFile=None):

    215. 

  215.         self.globals = set()

    216. 

  216.         self.unsupportedSyntaxSeen = False

    217. 

  217.         self.inputFilename = inputFile

    218. 

  218.         if not outputFile:

    219. 

  219.             outputFile = os.path.splitext(inputFile)[0] + '.nasm'

    220. 

  220.         self.outputFilename = outputFile

    221. 

  221. 

    222. 

  222.         fullSrc = os.path.realpath(inputFile)

    223. 

  223.         srcParentDir = os.path.basename(os.path.split(fullSrc)[0])

    224. 

  224.         maybeArch = srcParentDir.lower()

    225. 

  225.         if maybeArch in UnsupportedArch.unsupported:

    226. 

  226.             raise UnsupportedArch

    227. 

  227.         self.ia32 = maybeArch == 'ia32'

    228. 

  228.         self.x64 = maybeArch == 'x64'

    229. 

  229. 

    230. 

  230.         self.inputFileBase = os.path.basename(self.inputFilename)

    231. 

  231.         self.outputFileBase = os.path.basename(self.outputFilename)

    232. 

  232.         if self.outputFilename == '-' and not self.diff:

    233. 

  233.             self.output = sys.stdout

    234. 

  234.         else:

    235. 

  235.             self.output = StringIO.StringIO()

    236. 

  236.         if not self.Opt.quiet:

    237. 

  237.             dirpath, src = os.path.split(self.inputFilename)

    238. 

  238.             dirpath = self.RootRelative(dirpath)

    239. 

  239.             dst = os.path.basename(self.outputFilename)

    240. 

  240.             print 'Converting:', dirpath, src, '->', dst

    241. 

  241.         lines = open(self.inputFilename).readlines()

    242. 

  242.         self.Convert(lines)

    243. 

  243.         if self.outputFilename == '-':

    244. 

  244.             if self.diff:

    245. 

  245.                 sys.stdout.write(self.output.getvalue())

    246. 

  246.                 self.output.close()

    247. 

  247.         else:

    248. 

  248.             f = open(self.outputFilename, 'wb')

    249. 

  249.             f.write(self.output.getvalue())

    250. 

  250.             f.close()

    251. 

  251.             self.output.close()

    252. 

  252. 

    253. 

  253.     endOfLineRe = re.compile(r'''

    254. 

  254.                                  \s* ( ; .* )? \n $

    255. 

  255.                              ''',

    256. 

  256.                              re.VERBOSE | re.MULTILINE

    257. 

  257.                              )

    258. 

  258.     begOfLineRe = re.compile(r'''

    259. 

  259.                                  \s*

    260. 

  260.                              ''',

    261. 

  261.                              re.VERBOSE

    262. 

  262.                              )

    263. 

  263. 

    264. 

  264.     def Convert(self, lines):

    265. 

  265.         self.proc = None

    266. 

  266.         self.anonLabelCount = -1

    267. 

  267.         output = self.output

    268. 

  268.         self.oldAsmEmptyLineCount = 0

    269. 

  269.         self.newAsmEmptyLineCount = 0

    270. 

  270.         for line in lines:

    271. 

  271.             mo = self.begOfLineRe.search(line)

    272. 

  272.             assert mo is not None

    273. 

  273.             self.indent = mo.group()

    274. 

  274.             lineWithoutBeginning = line[len(self.indent):]

    275. 

  275.             mo = self.endOfLineRe.search(lineWithoutBeginning)

    276. 

  276.             if mo is None:

    277. 

  277.                 endOfLine = ''

    278. 

  278.             else:

    279. 

  279.                 endOfLine = mo.group()

    280. 

  280.             oldAsm = line[len(self.indent):len(line) - len(endOfLine)]

    281. 

  281.             self.originalLine = line.rstrip()

    282. 

  282.             if line.strip() == '':

    283. 

  283.                 self.oldAsmEmptyLineCount += 1

    284. 

  284.             self.TranslateAsm(oldAsm, endOfLine)

    285. 

  285.             if line.strip() != '':

    286. 

  286.                 self.oldAsmEmptyLineCount = 0

    287. 

  287. 

    288. 

  288.     procDeclRe = re.compile(r'''

    289. 

  289.                                 ([\w@][\w@0-9]*) \s+

    290. 

  290.                                 PROC

    291. 

  291.                                 (?: \s+ NEAR | FAR )?

    292. 

  292.                                 (?: \s+ C )?

    293. 

  293.                                 (?: \s+ (PUBLIC | PRIVATE) )?

    294. 

  294.                                 (?: \s+ USES ( (?: \s+ \w[\w0-9]* )+ ) )?

    295. 

  295.                                 \s* $

    296. 

  296.                             ''',

    297. 

  297.                             re.VERBOSE | re.IGNORECASE

    298. 

  298.                             )

    299. 

  299. 

    300. 

  300.     procEndRe = re.compile(r'''

    301. 

  301.                                ([\w@][\w@0-9]*) \s+

    302. 

  302.                                ENDP

    303. 

  303.                                \s* $

    304. 

  304.                            ''',

    305. 

  305.                            re.VERBOSE | re.IGNORECASE

    306. 

  306.                            )

    307. 

  307. 

    308. 

  308.     varAndTypeSubRe = r' (?: [\w@][\w@0-9]* ) (?: \s* : \s* \w+ )? '

    309. 

  309.     publicRe = re.compile(r'''

    310. 

  310.                               PUBLIC \s+

    311. 

  311.                               ( %s (?: \s* , \s* %s )* )

    312. 

  312.                               \s* $

    313. 

  313.                           ''' % (varAndTypeSubRe, varAndTypeSubRe),

    314. 

  314.                           re.VERBOSE | re.IGNORECASE

    315. 

  315.                           )

    316. 

  316. 

    317. 

  317.     varAndTypeSubRe = re.compile(varAndTypeSubRe, re.VERBOSE | re.IGNORECASE)

    318. 

  318. 

    319. 

  319.     macroDeclRe = re.compile(r'''

    320. 

  320.                                  ([\w@][\w@0-9]*) \s+

    321. 

  321.                                  MACRO

    322. 

  322.                                  \s* $

    323. 

  323.                              ''',

    324. 

  324.                              re.VERBOSE | re.IGNORECASE

    325. 

  325.                              )

    326. 

  326. 

    327. 

  327.     sectionDeclRe = re.compile(r'''

    328. 

  328.                                    ([\w@][\w@0-9]*) \s+

    329. 

  329.                                    ( SECTION | ENDS )

    330. 

  330.                                    \s* $

    331. 

  331.                                ''',

    332. 

  332.                                re.VERBOSE | re.IGNORECASE

    333. 

  333.                                )

    334. 

  334. 

    335. 

  335.     externRe = re.compile(r'''

    336. 

  336.                               EXTE?RN \s+ (?: C \s+ )?

    337. 

  337.                               ([\w@][\w@0-9]*) \s* : \s* (\w+)

    338. 

  338.                               \s* $

    339. 

  339.                            ''',

    340. 

  340.                           re.VERBOSE | re.IGNORECASE

    341. 

  341.                           )

    342. 

  342. 

    343. 

  343.     externdefRe = re.compile(r'''

    344. 

  344.                                  EXTERNDEF \s+ (?: C \s+ )?

    345. 

  345.                                  ([\w@][\w@0-9]*) \s* : \s* (\w+)

    346. 

  346.                                  \s* $

    347. 

  347.                              ''',

    348. 

  348.                              re.VERBOSE | re.IGNORECASE

    349. 

  349.                              )

    350. 

  350. 

    351. 

  351.     protoRe = re.compile(r'''

    352. 

  352.                              ([\w@][\w@0-9]*) \s+

    353. 

  353.                              PROTO

    354. 

  354.                              (?: \s+ .* )?

    355. 

  355.                              \s* $

    356. 

  356.                          ''',

    357. 

  357.                          re.VERBOSE | re.IGNORECASE

    358. 

  358.                          )

    359. 

  359. 

    360. 

  360.     defineDataRe = re.compile(r'''

    361. 

  361.                                   ([\w@][\w@0-9]*) \s+

    362. 

  362.                                   ( db | dw | dd | dq ) \s+

    363. 

  363.                                   ( .*? )

    364. 

  364.                                   \s* $

    365. 

  365.                               ''',

    366. 

  366.                               re.VERBOSE | re.IGNORECASE

    367. 

  367.                               )

    368. 

  368. 

    369. 

  369.     equRe = re.compile(r'''

    370. 

  370.                            ([\w@][\w@0-9]*) \s+ EQU \s+ (\S.*?)

    371. 

  371.                            \s* $

    372. 

  372.                        ''',

    373. 

  373.                        re.VERBOSE | re.IGNORECASE

    374. 

  374.                        )

    375. 

  375. 

    376. 

  376.     ignoreRe = re.compile(r'''

    377. 

  377.                               \. (?: const |

    378. 

  378.                                      mmx |

    379. 

  379.                                      model |

    380. 

  380.                                      xmm |

    381. 

  381.                                      x?list |

    382. 

  382.                                      [3-6]86p?

    383. 

  383.                                  ) |

    384. 

  384.                               page

    385. 

  385.                               (?: \s+ .* )?

    386. 

  386.                               \s* $

    387. 

  387.                           ''',

    388. 

  388.                           re.VERBOSE | re.IGNORECASE

    389. 

  389.                           )

    390. 

  390. 

    391. 

  391.     whitespaceRe = re.compile(r'\s+', re.MULTILINE)

    392. 

  392. 

    393. 

  393.     def TranslateAsm(self, oldAsm, endOfLine):

    394. 

  394.         assert(oldAsm.strip() == oldAsm)

    395. 

  395. 

    396. 

  396.         endOfLine = endOfLine.replace(self.inputFileBase, self.outputFileBase)

    397. 

  397. 

    398. 

  398.         oldOp = oldAsm.split()

    399. 

  399.         if len(oldOp) >= 1:

    400. 

  400.             oldOp = oldOp[0]

    401. 

  401.         else:

    402. 

  402.             oldOp = ''

    403. 

  403. 

    404. 

  404.         if oldAsm == '':

    405. 

  405.             newAsm = oldAsm

    406. 

  406.             self.EmitAsmWithComment(oldAsm, newAsm, endOfLine)

    407. 

  407.         elif oldOp in ('#include', ):

    408. 

  408.             newAsm = oldAsm

    409. 

  409.             self.EmitLine(oldAsm + endOfLine)

    410. 

  410.         elif oldOp.lower() in ('end', 'title', 'text'):

    411. 

  411.             newAsm = ''

    412. 

  412.             self.EmitAsmWithComment(oldAsm, newAsm, endOfLine)

    413. 

  413.         elif oldAsm.lower() == '@@:':

    414. 

  414.             self.anonLabelCount += 1

    415. 

  415.             self.EmitLine(self.anonLabel(self.anonLabelCount) + ':')

    416. 

  416.         elif self.MatchAndSetMo(self.ignoreRe, oldAsm):

    417. 

  417.             newAsm = ''

    418. 

  418.             self.EmitAsmWithComment(oldAsm, newAsm, endOfLine)

    419. 

  419.         elif oldAsm.lower() == 'ret':

    420. 

  420.             for i in range(len(self.uses) - 1, -1, -1):

    421. 

  421.                 register = self.uses[i]

    422. 

  422.                 self.EmitNewContent('pop     ' + register)

    423. 

  423.             newAsm = 'ret'

    424. 

  424.             self.EmitAsmWithComment(oldAsm, newAsm, endOfLine)

    425. 

  425.             self.uses = tuple()

    426. 

  426.         elif oldOp.lower() == 'lea':

    427. 

  427.             newAsm = self.ConvertLea(oldAsm)

    428. 

  428.             self.EmitAsmWithComment(oldAsm, newAsm, endOfLine)

    429. 

  429.         elif oldAsm.lower() == 'end':

    430. 

  430.             newAsm = ''

    431. 

  431.             self.EmitAsmWithComment(oldAsm, newAsm, endOfLine)

    432. 

  432.             self.uses = tuple()

    433. 

  433.         elif self.MatchAndSetMo(self.equRe, oldAsm):

    434. 

  434.             equ = self.mo.group(1)

    435. 

  435.             newAsm = '%%define %s %s' % (equ, self.mo.group(2))

    436. 

  436.             self.EmitAsmWithComment(oldAsm, newAsm, endOfLine)

    437. 

  437.         elif self.MatchAndSetMo(self.externRe, oldAsm) or \

    438. 

  438.                 self.MatchAndSetMo(self.protoRe, oldAsm):

    439. 

  439.             extern = self.mo.group(1)

    440. 

  440.             self.NewGlobal(extern)

    441. 

  441.             newAsm = 'extern ' + extern

    442. 

  442.             self.EmitAsmWithComment(oldAsm, newAsm, endOfLine)

    443. 

  443.         elif self.MatchAndSetMo(self.externdefRe, oldAsm):

    444. 

  444.             newAsm = ''

    445. 

  445.             self.EmitAsmWithComment(oldAsm, newAsm, endOfLine)

    446. 

  446.         elif self.MatchAndSetMo(self.macroDeclRe, oldAsm):

    447. 

  447.             newAsm = '%%macro %s 0' % self.mo.group(1)

    448. 

  448.             self.EmitAsmWithComment(oldAsm, newAsm, endOfLine)

    449. 

  449.         elif oldOp.lower() == 'endm':

    450. 

  450.             newAsm = r'%endmacro'

    451. 

  451.             self.EmitAsmWithComment(oldAsm, newAsm, endOfLine)

    452. 

  452.         elif self.MatchAndSetMo(self.sectionDeclRe, oldAsm):

    453. 

  453.             name = self.mo.group(1)

    454. 

  454.             ty = self.mo.group(2)

    455. 

  455.             if ty.lower() == 'section':

    456. 

  456.                 newAsm = '.' + name

    457. 

  457.             else:

    458. 

  458.                 newAsm = ''

    459. 

  459.             self.EmitAsmWithComment(oldAsm, newAsm, endOfLine)

    460. 

  460.         elif self.MatchAndSetMo(self.procDeclRe, oldAsm):

    461. 

  461.             proc = self.proc = self.mo.group(1)

    462. 

  462.             visibility = self.mo.group(2)

    463. 

  463.             if visibility is None:

    464. 

  464.                 visibility = ''

    465. 

  465.             else:

    466. 

  466.                 visibility = visibility.lower()

    467. 

  467.             if visibility != 'private':

    468. 

  468.                 self.NewGlobal(self.proc)

    469. 

  469.                 proc = 'ASM_PFX(' + proc + ')'

    470. 

  470.                 self.EmitNewContent('global ' + proc)

    471. 

  471.             newAsm = proc + ':'

    472. 

  472.             self.EmitAsmWithComment(oldAsm, newAsm, endOfLine)

    473. 

  473.             uses = self.mo.group(3)

    474. 

  474.             if uses is not None:

    475. 

  475.                 uses = filter(None, uses.split())

    476. 

  476.             else:

    477. 

  477.                 uses = tuple()

    478. 

  478.             self.uses = uses

    479. 

  479.             for register in self.uses:

    480. 

  480.                 self.EmitNewContent('    push    ' + register)

    481. 

  481.         elif self.MatchAndSetMo(self.procEndRe, oldAsm):

    482. 

  482.             newAsm = ''

    483. 

  483.             self.EmitAsmWithComment(oldAsm, newAsm, endOfLine)

    484. 

  484.         elif self.MatchAndSetMo(self.publicRe, oldAsm):

    485. 

  485.             publics = re.findall(self.varAndTypeSubRe, self.mo.group(1))

    486. 

  486.             publics = map(lambda p: p.split(':')[0].strip(), publics)

    487. 

  487.             for i in range(len(publics) - 1):

    488. 

  488.                 name = publics[i]

    489. 

  489.                 self.EmitNewContent('global ASM_PFX(%s)' % publics[i])

    490. 

  490.                 self.NewGlobal(name)

    491. 

  491.             name = publics[-1]

    492. 

  492.             self.NewGlobal(name)

    493. 

  493.             newAsm = 'global ASM_PFX(%s)' % name

    494. 

  494.             self.EmitAsmWithComment(oldAsm, newAsm, endOfLine)

    495. 

  495.         elif self.MatchAndSetMo(self.defineDataRe, oldAsm):

    496. 

  496.             name = self.mo.group(1)

    497. 

  497.             ty = self.mo.group(2)

    498. 

  498.             value = self.mo.group(3)

    499. 

  499.             if value == '?':

    500. 

  500.                 value = 0

    501. 

  501.             newAsm = '%s: %s %s' % (name, ty, value)

    502. 

  502.             newAsm = self.CommonConversions(newAsm)

    503. 

  503.             self.EmitAsmWithComment(oldAsm, newAsm, endOfLine)

    504. 

  504.         else:

    505. 

  505.             newAsm = self.CommonConversions(oldAsm)

    506. 

  506.             self.EmitAsmWithComment(oldAsm, newAsm, endOfLine)

    507. 

  507. 

    508. 

  508.     def NewGlobal(self, name):

    509. 

  509.         regex = re.compile(r'(?<![_\w\d])(?<!ASM_PFX\()(' + re.escape(name) +

    510. 

  510.                            r')(?![_\w\d])')

    511. 

  511.         self.globals.add(regex)

    512. 

  512. 

    513. 

  513.     def ConvertAnonymousLabels(self, oldAsm):

    514. 

  514.         newAsm = oldAsm

    515. 

  515.         anonLabel = self.anonLabel(self.anonLabelCount)

    516. 

  516.         newAsm = newAsm.replace('@b', anonLabel)

    517. 

  517.         newAsm = newAsm.replace('@B', anonLabel)

    518. 

  518.         anonLabel = self.anonLabel(self.anonLabelCount + 1)

    519. 

  519.         newAsm = newAsm.replace('@f', anonLabel)

    520. 

  520.         newAsm = newAsm.replace('@F', anonLabel)

    521. 

  521.         return newAsm

    522. 

  522. 

    523. 

  523.     def anonLabel(self, count):

    524. 

  524.         return '.%d' % count

    525. 

  525. 

    526. 

  526.     def EmitString(self, string):

    527. 

  527.         self.output.write(string)

    528. 

  528. 

    529. 

  529.     def EmitLineWithDiff(self, old, new):

    530. 

  530.         newLine = (self.indent + new).rstrip()

    531. 

  531.         if self.diff:

    532. 

  532.             if old is None:

    533. 

  533.                 print '+%s' % newLine

    534. 

  534.             elif newLine != old:

    535. 

  535.                 print '-%s' % old

    536. 

  536.                 print '+%s' % newLine

    537. 

  537.             else:

    538. 

  538.                 print '', newLine

    539. 

  539.         if newLine != '':

    540. 

  540.             self.newAsmEmptyLineCount = 0

    541. 

  541.         self.EmitString(newLine + '\r\n')

    542. 

  542. 

    543. 

  543.     def EmitLine(self, string):

    544. 

  544.         self.EmitLineWithDiff(self.originalLine, string)

    545. 

  545. 

    546. 

  546.     def EmitNewContent(self, string):

    547. 

  547.         self.EmitLineWithDiff(None, string)

    548. 

  548. 

    549. 

  549.     def EmitAsmReplaceOp(self, oldAsm, oldOp, newOp, endOfLine):

    550. 

  550.         newAsm = oldAsm.replace(oldOp, newOp, 1)

    551. 

  551.         self.EmitAsmWithComment(oldAsm, newAsm, endOfLine)

    552. 

  552. 

    553. 

  553.     hexNumRe = re.compile(r'0*((?=[\da-f])\d*(?<=\d)[\da-f]*)h', re.IGNORECASE)

    554. 

  554. 

    555. 

  555.     def EmitAsmWithComment(self, oldAsm, newAsm, endOfLine):

    556. 

  556.         for glblRe in self.globals:

    557. 

  557.             newAsm = glblRe.sub(r'ASM_PFX(\1)', newAsm)

    558. 

  558. 

    559. 

  559.         newAsm = self.hexNumRe.sub(r'0x\1', newAsm)

    560. 

  560. 

    561. 

  561.         newLine = newAsm + endOfLine

    562. 

  562.         emitNewLine = ((newLine.strip() != '') or

    563. 

  563.                        ((oldAsm + endOfLine).strip() == ''))

    564. 

  564.         if emitNewLine and newLine.strip() == '':

    565. 

  565.             self.newAsmEmptyLineCount += 1

    566. 

  566.             if self.newAsmEmptyLineCount > 1:

    567. 

  567.                 emitNewLine = False

    568. 

  568.         if emitNewLine:

    569. 

  569.             self.EmitLine(newLine.rstrip())

    570. 

  570.         elif self.diff:

    571. 

  571.             print '-%s' % self.originalLine

    572. 

  572. 

    573. 

  573.     leaRe = re.compile(r'''

    574. 

  574.                            (lea \s+) ([\w@][\w@0-9]*) \s* , \s* (\S (?:.*\S)?)

    575. 

  575.                            \s* $

    576. 

  576.                        ''',

    577. 

  577.                        re.VERBOSE | re.IGNORECASE

    578. 

  578.                        )

    579. 

  579. 

    580. 

  580.     def ConvertLea(self, oldAsm):

    581. 

  581.         newAsm = oldAsm

    582. 

  582.         if self.MatchAndSetMo(self.leaRe, oldAsm):

    583. 

  583.             lea = self.mo.group(1)

    584. 

  584.             dst = self.mo.group(2)

    585. 

  585.             src = self.mo.group(3)

    586. 

  586.             if src.find('[') < 0:

    587. 

  587.                 src = '[' + src + ']'

    588. 

  588.             newAsm = lea + dst + ', ' + src

    589. 

  589.         newAsm = self.CommonConversions(newAsm)

    590. 

  590.         return newAsm

    591. 

  591. 

    592. 

  592.     ptrRe = re.compile(r'''

    593. 

  593.                            (?<! \S )

    594. 

  594.                            ([dfq]?word|byte) \s+ (?: ptr ) (\s*)

    595. 

  595.                            (?= [[\s] )

    596. 

  596.                        ''',

    597. 

  597.                        re.VERBOSE | re.IGNORECASE

    598. 

  598.                        )

    599. 

  599. 

    600. 

  600.     def ConvertPtr(self, oldAsm):

    601. 

  601.         newAsm = oldAsm

    602. 

  602.         while self.SearchAndSetMo(self.ptrRe, newAsm):

    603. 

  603.             ty = self.mo.group(1)

    604. 

  604.             if ty.lower() == 'fword':

    605. 

  605.                 ty = ''

    606. 

  606.             else:

    607. 

  607.                 ty += self.mo.group(2)

    608. 

  608.             newAsm = newAsm[:self.mo.start(0)] + ty + newAsm[self.mo.end(0):]

    609. 

  609.         return newAsm

    610. 

  610. 

    611. 

  611.     labelByteRe = re.compile(r'''

    612. 

  612.                                  (?: \s+ label \s+ (?: [dfq]?word | byte ) )

    613. 

  613.                                  (?! \S )

    614. 

  614.                              ''',

    615. 

  615.                              re.VERBOSE | re.IGNORECASE

    616. 

  616.                              )

    617. 

  617. 

    618. 

  618.     def ConvertLabelByte(self, oldAsm):

    619. 

  619.         newAsm = oldAsm

    620. 

  620.         if self.SearchAndSetMo(self.labelByteRe, newAsm):

    621. 

  621.             newAsm = newAsm[:self.mo.start(0)] + ':' + newAsm[self.mo.end(0):]

    622. 

  622.         return newAsm

    623. 

  623. 

    624. 

  624.     unaryBitwiseOpRe = re.compile(r'''

    625. 

  625.                                       ( NOT )

    626. 

  626.                                       (?= \s+ \S )

    627. 

  627.                                   ''',

    628. 

  628.                                   re.VERBOSE | re.IGNORECASE

    629. 

  629.                                   )

    630. 

  630.     binaryBitwiseOpRe = re.compile(r'''

    631. 

  631.                                        ( \S \s+ )

    632. 

  632.                                        ( AND | OR | SHL | SHR )

    633. 

  633.                                        (?= \s+ \S )

    634. 

  634.                                    ''',

    635. 

  635.                                    re.VERBOSE | re.IGNORECASE

    636. 

  636.                                    )

    637. 

  637.     bitwiseOpReplacements = {

    638. 

  638.         'not': '~',

    639. 

  639.         'and': '&',

    640. 

  640.         'shl': '<<',

    641. 

  641.         'shr': '>>',

    642. 

  642.         'or': '|',

    643. 

  643.     }

    644. 

  644. 

    645. 

  645.     def ConvertBitwiseOp(self, oldAsm):

    646. 

  646.         newAsm = oldAsm

    647. 

  647.         while self.SearchAndSetMo(self.binaryBitwiseOpRe, newAsm):

    648. 

  648.             prefix = self.mo.group(1)

    649. 

  649.             op = self.bitwiseOpReplacements[self.mo.group(2).lower()]

    650. 

  650.             newAsm = newAsm[:self.mo.start(0)] + prefix + op + \

    651. 

  651.                 newAsm[self.mo.end(0):]

    652. 

  652.         while self.SearchAndSetMo(self.unaryBitwiseOpRe, newAsm):

    653. 

  653.             op = self.bitwiseOpReplacements[self.mo.group(1).lower()]

    654. 

  654.             newAsm = newAsm[:self.mo.start(0)] + op + newAsm[self.mo.end(0):]

    655. 

  655.         return newAsm

    656. 

  656. 

    657. 

  657.     sectionRe = re.compile(r'''

    658. 

  658.                                \. ( code |

    659. 

  659.                                     data

    660. 

  660.                                   )

    661. 

  661.                                (?: \s+ .* )?

    662. 

  662.                                \s* $

    663. 

  663.                            ''',

    664. 

  664.                            re.VERBOSE | re.IGNORECASE

    665. 

  665.                            )

    666. 

  666. 

    667. 

  667.     segmentRe = re.compile(r'''

    668. 

  668.                                ( code |

    669. 

  669.                                  data )

    670. 

  670.                                (?: \s+ SEGMENT )

    671. 

  671.                                (?: \s+ .* )?

    672. 

  672.                                \s* $

    673. 

  673.                            ''',

    674. 

  674.                            re.VERBOSE | re.IGNORECASE

    675. 

  675.                            )

    676. 

  676. 

    677. 

  677.     def ConvertSection(self, oldAsm):

    678. 

  678.         newAsm = oldAsm

    679. 

  679.         if self.MatchAndSetMo(self.sectionRe, newAsm) or \

    680. 

  680.            self.MatchAndSetMo(self.segmentRe, newAsm):

    681. 

  681.             name = self.mo.group(1).lower()

    682. 

  682.             if name == 'code':

    683. 

  683.                 if self.x64:

    684. 

  684.                     self.EmitLine('DEFAULT REL')

    685. 

  685.                 name = 'text'

    686. 

  686.             newAsm = 'SECTION .' + name

    687. 

  687.         return newAsm

    688. 

  688. 

    689. 

  689.     fwordRe = re.compile(r'''

    690. 

  690.                              (?<! \S )

    691. 

  691.                              fword

    692. 

  692.                              (?! \S )

    693. 

  693.                          ''',

    694. 

  694.                          re.VERBOSE | re.IGNORECASE

    695. 

  695.                          )

    696. 

  696. 

    697. 

  697.     def FwordUnsupportedCheck(self, oldAsm):

    698. 

  698.         newAsm = oldAsm

    699. 

  699.         if self.SearchAndSetMo(self.fwordRe, newAsm):

    700. 

  700.             newAsm = self.Unsupported(newAsm, 'fword used')

    701. 

  701.         return newAsm

    702. 

  702. 

    703. 

  703.     __common_conversion_routines__ = (

    704. 

  704.         ConvertAnonymousLabels,

    705. 

  705.         ConvertPtr,

    706. 

  706.         FwordUnsupportedCheck,

    707. 

  707.         ConvertBitwiseOp,

    708. 

  708.         ConvertLabelByte,

    709. 

  709.         ConvertSection,

    710. 

  710.     )

    711. 

  711. 

    712. 

  712.     def CommonConversions(self, oldAsm):

    713. 

  713.         newAsm = oldAsm

    714. 

  714.         for conv in self.__common_conversion_routines__:

    715. 

  715.             newAsm = conv(self, newAsm)

    716. 

  716.         return newAsm

    717. 

  717. 

    718. 

  718.     def Unsupported(self, asm, message=None):

    719. 

  719.         if not self.force:

    720. 

  720.             raise UnsupportedConversion

    721. 

  721. 

    722. 

  722.         self.unsupportedSyntaxSeen = True

    723. 

  723.         newAsm = '%error conversion unsupported'

    724. 

  724.         if message:

    725. 

  725.             newAsm += '; ' + message

    726. 

  726.         newAsm += ': ' + asm

    727. 

  727.         return newAsm

    728. 

  728. 

    729. 

  729. 

    730. 

  730. class ConvertInfFile(CommonUtils):

    731. 

  731. 

    732. 

  732.     def __init__(self, inf, clone):

    733. 

  733.         CommonUtils.__init__(self, clone)

    734. 

  734.         self.inf = inf

    735. 

  735.         self.ScanInfAsmFiles()

    736. 

  736.         if self.infmode:

    737. 

  737.             self.ConvertInfAsmFiles()

    738. 

  738. 

    739. 

  739.     infSrcRe = re.compile(r'''

    740. 

  740.                               \s*

    741. 

  741.                               ( [\w@][\w@0-9/]* \.(asm|s) )

    742. 

  742.                               \s* (?: \| [^#]* )?

    743. 

  743.                               \s* (?: \# .* )?

    744. 

  744.                               $

    745. 

  745.                           ''',

    746. 

  746.                           re.VERBOSE | re.IGNORECASE

    747. 

  747.                           )

    748. 

  748. 

    749. 

  749.     def GetInfAsmFileMapping(self):

    750. 

  750.         srcToDst = {'order': []}

    751. 

  751.         for line in self.lines:

    752. 

  752.             line = line.rstrip()

    753. 

  753.             if self.MatchAndSetMo(self.infSrcRe, line):

    754. 

  754.                 src = self.mo.group(1)

    755. 

  755.                 srcExt = self.mo.group(2)

    756. 

  756.                 dst = os.path.splitext(src)[0] + '.nasm'

    757. 

  757.                 if src not in srcToDst:

    758. 

  758.                     srcToDst[src] = dst

    759. 

  759.                     srcToDst['order'].append(src)

    760. 

  760.         return srcToDst

    761. 

  761. 

    762. 

  762.     def ScanInfAsmFiles(self):

    763. 

  763.         src = self.inf

    764. 

  764.         assert os.path.isfile(src)

    765. 

  765.         f = open(src)

    766. 

  766.         self.lines = f.readlines()

    767. 

  767.         f.close()

    768. 

  768. 

    769. 

  769.         path = os.path.realpath(self.inf)

    770. 

  770.         (self.dir, inf) = os.path.split(path)

    771. 

  771.         parent = os.path.normpath(self.dir)

    772. 

  772.         (lastpath, self.moduleName) = os.path.split(parent)

    773. 

  773.         self.packageName = None

    774. 

  774.         while True:

    775. 

  775.             lastpath = os.path.normpath(lastpath)

    776. 

  776.             (parent, basename) = os.path.split(lastpath)

    777. 

  777.             if parent == lastpath:

    778. 

  778.                 break

    779. 

  779.             if basename.endswith('Pkg'):

    780. 

  780.                 self.packageName = basename

    781. 

  781.                 break

    782. 

  782.             lastpath = parent

    783. 

  783. 

    784. 

  784.         self.srcToDst = self.GetInfAsmFileMapping()

    785. 

  785. 

    786. 

  786.         self.dstToSrc = {'order': []}

    787. 

  787.         for src in self.srcToDst['order']:

    788. 

  788.             srcExt = os.path.splitext(src)[1]

    789. 

  789.             dst = self.srcToDst[src]

    790. 

  790.             if dst not in self.dstToSrc:

    791. 

  791.                 self.dstToSrc[dst] = [src]

    792. 

  792.                 self.dstToSrc['order'].append(dst)

    793. 

  793.             else:

    794. 

  794.                 self.dstToSrc[dst].append(src)

    795. 

  795. 

    796. 

  796.     def __len__(self):

    797. 

  797.         return len(self.dstToSrc['order'])

    798. 

  798. 

    799. 

  799.     def __iter__(self):

    800. 

  800.         return iter(self.dstToSrc['order'])

    801. 

  801. 

    802. 

  802.     def ConvertInfAsmFiles(self):

    803. 

  803.         notConverted = []

    804. 

  804.         unsupportedArchCount = 0

    805. 

  805.         for dst in self:

    806. 

  806.             didSomething = False

    807. 

  807.             fileChanged = self.UpdateInfAsmFile(dst)

    808. 

  808.             try:

    809. 

  809.                 self.UpdateInfAsmFile(dst)

    810. 

  810.                 didSomething = True

    811. 

  811.             except UnsupportedConversion:

    812. 

  812.                 if not self.Opt.quiet:

    813. 

  813.                     print 'MASM=>NASM conversion unsupported for', dst

    814. 

  814.                 notConverted.append(dst)

    815. 

  815.             except NoSourceFile:

    816. 

  816.                 if not self.Opt.quiet:

    817. 

  817.                     print 'Source file missing for', reldst

    818. 

  818.                 notConverted.append(dst)

    819. 

  819.             except UnsupportedArch:

    820. 

  820.                 unsupportedArchCount += 1

    821. 

  821.             else:

    822. 

  822.                 if didSomething:

    823. 

  823.                     self.ConversionFinished(dst)

    824. 

  824.         if len(notConverted) > 0 and not self.Opt.quiet:

    825. 

  825.             for dst in notConverted:

    826. 

  826.                 reldst = self.RootRelative(dst)

    827. 

  827.                 print 'Unabled to convert', reldst

    828. 

  828.         if unsupportedArchCount > 0 and not self.Opt.quiet:

    829. 

  829.             print 'Skipped', unsupportedArchCount, 'files based on architecture'

    830. 

  830. 

    831. 

  831.     def UpdateInfAsmFile(self, dst, IgnoreMissingAsm=False):

    832. 

  832.         infPath = os.path.split(os.path.realpath(self.inf))[0]

    833. 

  833.         asmSrc = os.path.splitext(dst)[0] + '.asm'

    834. 

  834.         fullSrc = os.path.join(infPath, asmSrc)

    835. 

  835.         fullDst = os.path.join(infPath, dst)

    836. 

  836.         srcParentDir = os.path.basename(os.path.split(fullSrc)[0])

    837. 

  837.         if srcParentDir.lower() in UnsupportedArch.unsupported:

    838. 

  838.             raise UnsupportedArch

    839. 

  839.         elif not os.path.exists(fullSrc):

    840. 

  840.             if not IgnoreMissingAsm:

    841. 

  841.                 raise NoSourceFile

    842. 

  842.         else:  # not os.path.exists(fullDst):

    843. 

  843.             conv = ConvertAsmFile(fullSrc, fullDst, self)

    844. 

  844.             self.unsupportedSyntaxSeen = conv.unsupportedSyntaxSeen

    845. 

  845. 

    846. 

  846.         lastLine = ''

    847. 

  847.         fileChanged = False

    848. 

  848.         for i in range(len(self.lines)):

    849. 

  849.             line = self.lines[i].rstrip()

    850. 

  850.             updatedLine = line

    851. 

  851.             for src in self.dstToSrc[dst]:

    852. 

  852.                 assert self.srcToDst[src] == dst

    853. 

  853.                 updatedLine = self.ReplacePreserveSpacing(

    854. 

  854.                     updatedLine, src, dst)

    855. 

  855. 

    856. 

  856.             lineChanged = updatedLine != line

    857. 

  857.             if lineChanged:

    858. 

  858.                 if lastLine.strip() == updatedLine.strip():

    859. 

  859.                     self.lines[i] = None

    860. 

  860.                 else:

    861. 

  861.                     self.lines[i] = updatedLine + '\r\n'

    862. 

  862. 

    863. 

  863.             if self.diff:

    864. 

  864.                 if lineChanged:

    865. 

  865.                     print '-%s' % line

    866. 

  866.                     if self.lines[i] is not None:

    867. 

  867.                         print '+%s' % updatedLine

    868. 

  868.                 else:

    869. 

  869.                     print '', line

    870. 

  870. 

    871. 

  871.             fileChanged |= lineChanged

    872. 

  872.             if self.lines[i] is not None:

    873. 

  873.                 lastLine = self.lines[i]

    874. 

  874. 

    875. 

  875.         if fileChanged:

    876. 

  876.             self.lines = filter(lambda l: l is not None, self.lines)

    877. 

  877. 

    878. 

  878.         for src in self.dstToSrc[dst]:

    879. 

  879.             if not src.endswith('.asm'):

    880. 

  880.                 fullSrc = os.path.join(infPath, src)

    881. 

  881.                 if os.path.exists(fullSrc):

    882. 

  882.                     self.RemoveFile(fullSrc)

    883. 

  883. 

    884. 

  884.         if fileChanged:

    885. 

  885.             f = open(self.inf, 'wb')

    886. 

  886.             f.writelines(self.lines)

    887. 

  887.             f.close()

    888. 

  888.             self.FileUpdated(self.inf)

    889. 

  889. 

    890. 

  890.     def ConversionFinished(self, dst):

    891. 

  891.         asmSrc = os.path.splitext(dst)[0] + '.asm'

    892. 

  892.         self.FileConversionFinished(

    893. 

  893.             self.packageName, self.moduleName, asmSrc, dst)

    894. 

  894. 

    895. 

  895. 

    896. 

  896. class ConvertInfFiles(CommonUtils):

    897. 

  897. 

    898. 

  898.     def __init__(self, infs, clone):

    899. 

  899.         CommonUtils.__init__(self, clone)

    900. 

  900.         infs = map(lambda i: ConvertInfFile(i, self), infs)

    901. 

  901.         infs = filter(lambda i: len(i) > 0, infs)

    902. 

  902.         dstToInfs = {'order': []}

    903. 

  903.         for inf in infs:

    904. 

  904.             for dst in inf:

    905. 

  905.                 fulldst = os.path.realpath(os.path.join(inf.dir, dst))

    906. 

  906.                 pair = (inf, dst)

    907. 

  907.                 if fulldst in dstToInfs:

    908. 

  908.                     dstToInfs[fulldst].append(pair)

    909. 

  909.                 else:

    910. 

  910.                     dstToInfs['order'].append(fulldst)

    911. 

  911.                     dstToInfs[fulldst] = [pair]

    912. 

  912. 

    913. 

  913.         notConverted = []

    914. 

  914.         unsupportedArchCount = 0

    915. 

  915.         for dst in dstToInfs['order']:

    916. 

  916.             didSomething = False

    917. 

  917.             try:

    918. 

  918.                 for inf, reldst in dstToInfs[dst]:

    919. 

  919.                     inf.UpdateInfAsmFile(reldst, IgnoreMissingAsm=didSomething)

    920. 

  920.                     didSomething = True

    921. 

  921.             except UnsupportedConversion:

    922. 

  922.                 if not self.Opt.quiet:

    923. 

  923.                     print 'MASM=>NASM conversion unsupported for', reldst

    924. 

  924.                 notConverted.append(dst)

    925. 

  925.             except NoSourceFile:

    926. 

  926.                 if not self.Opt.quiet:

    927. 

  927.                     print 'Source file missing for', reldst

    928. 

  928.                 notConverted.append(dst)

    929. 

  929.             except UnsupportedArch:

    930. 

  930.                 unsupportedArchCount += 1

    931. 

  931.             else:

    932. 

  932.                 if didSomething:

    933. 

  933.                     inf.ConversionFinished(reldst)

    934. 

  934.         if len(notConverted) > 0 and not self.Opt.quiet:

    935. 

  935.             for dst in notConverted:

    936. 

  936.                 reldst = self.RootRelative(dst)

    937. 

  937.                 print 'Unabled to convert', reldst

    938. 

  938.         if unsupportedArchCount > 0 and not self.Opt.quiet:

    939. 

  939.             print 'Skipped', unsupportedArchCount, 'files based on architecture'

    940. 

  940. 

    941. 

  941. 

    942. 

  942. class ConvertDirectories(CommonUtils):

    943. 

  943. 

    944. 

  944.     def __init__(self, paths, clone):

    945. 

  945.         CommonUtils.__init__(self, clone)

    946. 

  946.         self.paths = paths

    947. 

  947.         self.ConvertInfAndAsmFiles()

    948. 

  948. 

    949. 

  949.     def ConvertInfAndAsmFiles(self):

    950. 

  950.         infs = list()

    951. 

  951.         for path in self.paths:

    952. 

  952.             assert(os.path.exists(path))

    953. 

  953.         for path in self.paths:

    954. 

  954.             for root, dirs, files in os.walk(path):

    955. 

  955.                 for d in ('.svn', '.git'):

    956. 

  956.                     if d in dirs:

    957. 

  957.                         dirs.remove(d)

    958. 

  958.                 for f in files:

    959. 

  959.                     if f.lower().endswith('.inf'):

    960. 

  960.                         inf = os.path.realpath(os.path.join(root, f))

    961. 

  961.                         infs.append(inf)

    962. 

  962. 

    963. 

  963.         ConvertInfFiles(infs, self)

    964. 

  964. 

    965. 

  965. 

    966. 

  966. class ConvertAsmApp(CommonUtils):

    967. 

  967. 

    968. 

  968.     def __init__(self):

    969. 

  969.         CommonUtils.__init__(self)

    970. 

  970. 

    971. 

  971.         numArgs = len(self.Args)

    972. 

  972.         assert(numArgs >= 1)

    973. 

  973.         if self.infmode:

    974. 

  974.             ConvertInfFiles(self.Args, self)

    975. 

  975.         elif self.dirmode:

    976. 

  976.             ConvertDirectories(self.Args, self)

    977. 

  977.         elif not self.dirmode:

    978. 

  978.             assert(numArgs <= 2)

    979. 

  979.             src = self.Args[0]

    980. 

  980.             if numArgs > 1:

    981. 

  981.                 dst = self.Args[1]

    982. 

  982.             else:

    983. 

  983.                 dst = None

    984. 

  984.             ConvertAsmFile(src, dst, self)

    985. 

  985. 

    986. 

  986. ConvertAsmApp()

    987. 

  987.