BaseTools/Scripts/ConvertMasmToNasm.py

   1 # @file ConvertMasmToNasm.py
   2 # This script assists with conversion of MASM assembly syntax to NASM
   3 #
   4 #  Copyright (c) 2007 - 2014, Intel Corporation. All rights reserved.<BR>
   5 #
   6 #  This program and the accompanying materials
   7 #  are licensed and made available under the terms and conditions of the BSD License
   8 #  which accompanies this distribution.  The full text of the license may be found at
   9 #  http://opensource.org/licenses/bsd-license.php
  10 #
  11 #  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  12 #  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  13 #
  14
  15 #
  16 # Import Modules
  17 #
  18 import os.path
  19 import re
  20 import StringIO
  21 import subprocess
  22 import sys
  23 from optparse import OptionParser
  24
  25
  26 class UnsupportedConversion(Exception):
  27     pass
  28
  29
  30 class NoSourceFile(Exception):
  31     pass
  32
  33
  34 class UnsupportedArch(Exception):
  35     unsupported = ('aarch64', 'arm', 'ebc', 'ipf')
  36
  37
  38 class CommonUtils:
  39
  40     # Version and Copyright
  41     VersionNumber = "0.01"
  42     __version__ = "%prog Version " + VersionNumber
  43     __copyright__ = "Copyright (c) 2007 - 2014, Intel Corporation. All rights reserved."
  44     __usage__ = "%prog [options] source.asm [destination.nasm]"
  45
  46     def __init__(self, clone=None):
  47         if clone is None:
  48             (self.Opt, self.Args) = self.ProcessCommandLine()
  49         else:
  50             (self.Opt, self.Args) = (clone.Opt, clone.Args)
  51
  52         self.unsupportedSyntaxSeen = False
  53         self.src = self.Args[0]
  54         assert(os.path.exists(self.src))
  55         self.dirmode = os.path.isdir(self.src)
  56         srcExt = os.path.splitext(self.src)[1]
  57         assert (self.dirmode or srcExt != '.nasm')
  58         self.infmode = not self.dirmode and srcExt == '.inf'
  59         self.diff = self.Opt.diff
  60         self.git = self.Opt.git
  61         self.force = self.Opt.force
  62
  63         if clone is None:
  64             self.rootdir = os.getcwd()
  65             self.DetectGit()
  66         else:
  67             self.rootdir = clone.rootdir
  68             self.gitdir = clone.gitdir
  69             self.gitemail = clone.gitemail
  70
  71     def ProcessCommandLine(self):
  72         Parser = OptionParser(description=self.__copyright__,
  73                               version=self.__version__,
  74                               prog=sys.argv[0],
  75                               usage=self.__usage__
  76                               )
  77         Parser.add_option("-q", "--quiet", action="store_true", type=None,
  78                           help="Disable all messages except FATAL ERRORS.")
  79         Parser.add_option("--git", action="store_true", type=None,
  80                           help="Use git to create commits for each file converted")
  81         Parser.add_option("--diff", action="store_true", type=None,
  82                           help="Show diff of conversion")
  83         Parser.add_option("-f", "--force", action="store_true", type=None,
  84                           help="Force conversion even if unsupported")
  85
  86         (Opt, Args) = Parser.parse_args()
  87
  88         if not Opt.quiet:
  89             print self.__copyright__
  90             Parser.print_version()
  91
  92         return (Opt, Args)
  93
  94     def RootRelative(self, path):
  95         result = path
  96         if result.startswith(self.rootdir):
  97             result = result[len(self.rootdir):]
  98             while len(result) > 0 and result[0] in '/\\':
  99                 result = result[1:]
 100         return result
 101
 102     def MatchAndSetMo(self, regexp, string):
 103         self.mo = regexp.match(string)
 104         return self.mo is not None
 105
 106     def SearchAndSetMo(self, regexp, string):
 107         self.mo = regexp.search(string)
 108         return self.mo is not None
 109
 110     def ReplacePreserveSpacing(self, string, find, replace):
 111         if len(find) >= len(replace):
 112             padded = replace + (' ' * (len(find) - len(replace)))
 113             return string.replace(find, padded)
 114         elif find.find(replace) >= 0:
 115             return string.replace(find, replace)
 116         else:
 117             lenDiff = len(replace) - len(find)
 118             result = string
 119             for i in range(lenDiff, -1, -1):
 120                 padded = find + (' ' * i)
 121                 result = result.replace(padded, replace)
 122             return result
 123
 124     def DetectGit(self):
 125         lastpath = os.path.realpath(self.src)
 126         self.gitdir = None
 127         while True:
 128             path = os.path.split(lastpath)[0]
 129             if path == lastpath:
 130                 return
 131             candidate = os.path.join(path, '.git')
 132             if os.path.isdir(candidate):
 133                 self.gitdir = candidate
 134                 self.gitemail = self.FormatGitEmailAddress()
 135                 return
 136             lastpath = path
 137
 138     def FormatGitEmailAddress(self):
 139         if not self.git or not self.gitdir:
 140             return ''
 141
 142         cmd = ('git', 'config', 'user.name')
 143         name = self.RunAndCaptureOutput(cmd).strip()
 144         cmd = ('git', 'config', 'user.email')
 145         email = self.RunAndCaptureOutput(cmd).strip()
 146         if name.find(',') >= 0:
 147             name = '"' + name + '"'
 148         return name + ' <' + email + '>'
 149
 150     def RunAndCaptureOutput(self, cmd, checkExitCode=True, pipeIn=None):
 151         if pipeIn:
 152             subpStdin = subprocess.PIPE
 153         else:
 154             subpStdin = None
 155         p = subprocess.Popen(args=cmd, stdout=subprocess.PIPE, stdin=subpStdin)
 156         (stdout, stderr) = p.communicate(pipeIn)
 157         if checkExitCode:
 158             if p.returncode != 0:
 159                 print 'command:', ' '.join(cmd)
 160                 print 'stdout:', stdout
 161                 print 'stderr:', stderr
 162                 print 'return:', p.returncode
 163             assert p.returncode == 0
 164         return stdout
 165
 166     def FileUpdated(self, path):
 167         if not self.git or not self.gitdir:
 168             return
 169
 170         cmd = ('git', 'add', path)
 171         self.RunAndCaptureOutput(cmd)
 172
 173     def FileAdded(self, path):
 174         self.FileUpdated(path)
 175
 176     def RemoveFile(self, path):
 177         if not self.git or not self.gitdir:
 178             return
 179
 180         cmd = ('git', 'rm', path)
 181         self.RunAndCaptureOutput(cmd)
 182
 183     def FileConversionFinished(self, pkg, module, src, dst):
 184         if not self.git or not self.gitdir:
 185             return
 186
 187         if not self.Opt.quiet:
 188             print 'Committing: Conversion of', dst
 189
 190         prefix = ' '.join(filter(lambda a: a, [pkg, module]))
 191         message = ''
 192         if self.unsupportedSyntaxSeen:
 193             message += 'ERROR! '
 194         message += '%s: Convert %s to NASM\n' % (prefix, src)
 195         message += '\n'
 196         message += 'The %s script was used to convert\n' % sys.argv[0]
 197         message += '%s to %s\n' % (src, dst)
 198         message += '\n'
 199         message += 'Contributed-under: TianoCore Contribution Agreement 1.0\n'
 200         message += 'Signed-off-by: %s\n' % self.gitemail
 201
 202         cmd = ('git', 'commit', '-F', '-')
 203         self.RunAndCaptureOutput(cmd, pipeIn=message)
 204
 205
 206 class ConvertAsmFile(CommonUtils):
 207
 208     def __init__(self, src, dst, clone):
 209         CommonUtils.__init__(self, clone)
 210         self.ConvertAsmFile(src, dst)
 211         self.FileAdded(dst)
 212         self.RemoveFile(src)
 213
 214     def ConvertAsmFile(self, inputFile, outputFile=None):
 215         self.globals = set()
 216         self.unsupportedSyntaxSeen = False
 217         self.inputFilename = inputFile
 218         if not outputFile:
 219             outputFile = os.path.splitext(inputFile)[0] + '.nasm'
 220         self.outputFilename = outputFile
 221
 222         fullSrc = os.path.realpath(inputFile)
 223         srcParentDir = os.path.basename(os.path.split(fullSrc)[0])
 224         maybeArch = srcParentDir.lower()
 225         if maybeArch in UnsupportedArch.unsupported:
 226             raise UnsupportedArch
 227         self.ia32 = maybeArch == 'ia32'
 228         self.x64 = maybeArch == 'x64'
 229
 230         self.inputFileBase = os.path.basename(self.inputFilename)
 231         self.outputFileBase = os.path.basename(self.outputFilename)
 232         if self.outputFilename == '-' and not self.diff:
 233             self.output = sys.stdout
 234         else:
 235             self.output = StringIO.StringIO()
 236         if not self.Opt.quiet:
 237             dirpath, src = os.path.split(self.inputFilename)
 238             dirpath = self.RootRelative(dirpath)
 239             dst = os.path.basename(self.outputFilename)
 240             print 'Converting:', dirpath, src, '->', dst
 241         lines = open(self.inputFilename).readlines()
 242         self.Convert(lines)
 243         if self.outputFilename == '-':
 244             if self.diff:
 245                 sys.stdout.write(self.output.getvalue())
 246                 self.output.close()
 247         else:
 248             f = open(self.outputFilename, 'wb')
 249             f.write(self.output.getvalue())
 250             f.close()
 251             self.output.close()
 252
 253     endOfLineRe = re.compile(r'''
 254                                  \s* ( ; .* )? \n $
 255                              ''',
 256                              re.VERBOSE | re.MULTILINE
 257                              )
 258     begOfLineRe = re.compile(r'''
 259                                  \s*
 260                              ''',
 261                              re.VERBOSE
 262                              )
 263
 264     def Convert(self, lines):
 265         self.proc = None
 266         self.anonLabelCount = -1
 267         output = self.output
 268         self.oldAsmEmptyLineCount = 0
 269         self.newAsmEmptyLineCount = 0
 270         for line in lines:
 271             mo = self.begOfLineRe.search(line)
 272             assert mo is not None
 273             self.indent = mo.group()
 274             lineWithoutBeginning = line[len(self.indent):]
 275             mo = self.endOfLineRe.search(lineWithoutBeginning)
 276             if mo is None:
 277                 endOfLine = ''
 278             else:
 279                 endOfLine = mo.group()
 280             oldAsm = line[len(self.indent):len(line) - len(endOfLine)]
 281             self.originalLine = line.rstrip()
 282             if line.strip() == '':
 283                 self.oldAsmEmptyLineCount += 1
 284             self.TranslateAsm(oldAsm, endOfLine)
 285             if line.strip() != '':
 286                 self.oldAsmEmptyLineCount = 0
 287
 288     procDeclRe = re.compile(r'''
 289                                 ([\w@][\w@0-9]*) \s+
 290                                 PROC
 291                                 (?: \s+ NEAR | FAR )?
 292                                 (?: \s+ C )?
 293                                 (?: \s+ (PUBLIC | PRIVATE) )?
 294                                 (?: \s+ USES ( (?: \s+ \w[\w0-9]* )+ ) )?
 295                                 \s* $
 296                             ''',
 297                             re.VERBOSE | re.IGNORECASE
 298                             )
 299
 300     procEndRe = re.compile(r'''
 301                                ([\w@][\w@0-9]*) \s+
 302                                ENDP
 303                                \s* $
 304                            ''',
 305                            re.VERBOSE | re.IGNORECASE
 306                            )
 307
 308     varAndTypeSubRe = r' (?: [\w@][\w@0-9]* ) (?: \s* : \s* \w+ )? '
 309     publicRe = re.compile(r'''
 310                               PUBLIC \s+
 311                               ( %s (?: \s* , \s* %s )* )
 312                               \s* $
 313                           ''' % (varAndTypeSubRe, varAndTypeSubRe),
 314                           re.VERBOSE | re.IGNORECASE
 315                           )
 316
 317     varAndTypeSubRe = re.compile(varAndTypeSubRe, re.VERBOSE | re.IGNORECASE)
 318
 319     macroDeclRe = re.compile(r'''
 320                                  ([\w@][\w@0-9]*) \s+
 321                                  MACRO
 322                                  \s* $
 323                              ''',
 324                              re.VERBOSE | re.IGNORECASE
 325                              )
 326
 327     sectionDeclRe = re.compile(r'''
 328                                    ([\w@][\w@0-9]*) \s+
 329                                    ( SECTION | ENDS )
 330                                    \s* $
 331                                ''',
 332                                re.VERBOSE | re.IGNORECASE
 333                                )
 334
 335     externRe = re.compile(r'''
 336                               EXTE?RN \s+ (?: C \s+ )?
 337                               ([\w@][\w@0-9]*) \s* : \s* (\w+)
 338                               \s* $
 339                            ''',
 340                           re.VERBOSE | re.IGNORECASE
 341                           )
 342
 343     externdefRe = re.compile(r'''
 344                                  EXTERNDEF \s+ (?: C \s+ )?
 345                                  ([\w@][\w@0-9]*) \s* : \s* (\w+)
 346                                  \s* $
 347                              ''',
 348                              re.VERBOSE | re.IGNORECASE
 349                              )
 350
 351     protoRe = re.compile(r'''
 352                              ([\w@][\w@0-9]*) \s+
 353                              PROTO
 354                              (?: \s+ .* )?
 355                              \s* $
 356                          ''',
 357                          re.VERBOSE | re.IGNORECASE
 358                          )
 359
 360     defineDataRe = re.compile(r'''
 361                                   ([\w@][\w@0-9]*) \s+
 362                                   ( db | dw | dd | dq ) \s+
 363                                   ( .*? )
 364                                   \s* $
 365                               ''',
 366                               re.VERBOSE | re.IGNORECASE
 367                               )
 368
 369     equRe = re.compile(r'''
 370                            ([\w@][\w@0-9]*) \s+ EQU \s+ (\S.*?)
 371                            \s* $
 372                        ''',
 373                        re.VERBOSE | re.IGNORECASE
 374                        )
 375
 376     ignoreRe = re.compile(r'''
 377                               \. (?: const |
 378                                      mmx |
 379                                      model |
 380                                      xmm |
 381                                      x?list |
 382                                      [3-6]86p?
 383                                  ) |
 384                               page
 385                               (?: \s+ .* )?
 386                               \s* $
 387                           ''',
 388                           re.VERBOSE | re.IGNORECASE
 389                           )
 390
 391     whitespaceRe = re.compile(r'\s+', re.MULTILINE)
 392
 393     def TranslateAsm(self, oldAsm, endOfLine):
 394         assert(oldAsm.strip() == oldAsm)
 395
 396         endOfLine = endOfLine.replace(self.inputFileBase, self.outputFileBase)
 397
 398         oldOp = oldAsm.split()
 399         if len(oldOp) >= 1:
 400             oldOp = oldOp[0]
 401         else:
 402             oldOp = ''
 403
 404         if oldAsm == '':
 405             newAsm = oldAsm
 406             self.EmitAsmWithComment(oldAsm, newAsm, endOfLine)
 407         elif oldOp in ('#include', ):
 408             newAsm = oldAsm
 409             self.EmitLine(oldAsm + endOfLine)
 410         elif oldOp.lower() in ('end', 'title', 'text'):
 411             newAsm = ''
 412             self.EmitAsmWithComment(oldAsm, newAsm, endOfLine)
 413         elif oldAsm.lower() == '@@:':
 414             self.anonLabelCount += 1
 415             self.EmitLine(self.anonLabel(self.anonLabelCount) + ':')
 416         elif self.MatchAndSetMo(self.ignoreRe, oldAsm):
 417             newAsm = ''
 418             self.EmitAsmWithComment(oldAsm, newAsm, endOfLine)
 419         elif oldAsm.lower() == 'ret':
 420             for i in range(len(self.uses) - 1, -1, -1):
 421                 register = self.uses[i]
 422                 self.EmitNewContent('pop     ' + register)
 423             newAsm = 'ret'
 424             self.EmitAsmWithComment(oldAsm, newAsm, endOfLine)
 425             self.uses = tuple()
 426         elif oldOp.lower() == 'lea':
 427             newAsm = self.ConvertLea(oldAsm)
 428             self.EmitAsmWithComment(oldAsm, newAsm, endOfLine)
 429         elif oldAsm.lower() == 'end':
 430             newAsm = ''
 431             self.EmitAsmWithComment(oldAsm, newAsm, endOfLine)
 432             self.uses = tuple()
 433         elif self.MatchAndSetMo(self.equRe, oldAsm):
 434             equ = self.mo.group(1)
 435             newAsm = '%%define %s %s' % (equ, self.mo.group(2))
 436             self.EmitAsmWithComment(oldAsm, newAsm, endOfLine)
 437         elif self.MatchAndSetMo(self.externRe, oldAsm) or \
 438                 self.MatchAndSetMo(self.protoRe, oldAsm):
 439             extern = self.mo.group(1)
 440             self.NewGlobal(extern)
 441             newAsm = 'extern ' + extern
 442             self.EmitAsmWithComment(oldAsm, newAsm, endOfLine)
 443         elif self.MatchAndSetMo(self.externdefRe, oldAsm):
 444             newAsm = ''
 445             self.EmitAsmWithComment(oldAsm, newAsm, endOfLine)
 446         elif self.MatchAndSetMo(self.macroDeclRe, oldAsm):
 447             newAsm = '%%macro %s 0' % self.mo.group(1)
 448             self.EmitAsmWithComment(oldAsm, newAsm, endOfLine)
 449         elif oldOp.lower() == 'endm':
 450             newAsm = r'%endmacro'
 451             self.EmitAsmWithComment(oldAsm, newAsm, endOfLine)
 452         elif self.MatchAndSetMo(self.sectionDeclRe, oldAsm):
 453             name = self.mo.group(1)
 454             ty = self.mo.group(2)
 455             if ty.lower() == 'section':
 456                 newAsm = '.' + name
 457             else:
 458                 newAsm = ''
 459             self.EmitAsmWithComment(oldAsm, newAsm, endOfLine)
 460         elif self.MatchAndSetMo(self.procDeclRe, oldAsm):
 461             proc = self.proc = self.mo.group(1)
 462             visibility = self.mo.group(2)
 463             if visibility is None:
 464                 visibility = ''
 465             else:
 466                 visibility = visibility.lower()
 467             if visibility != 'private':
 468                 self.NewGlobal(self.proc)
 469                 proc = 'ASM_PFX(' + proc + ')'
 470                 self.EmitNewContent('global ' + proc)
 471             newAsm = proc + ':'
 472             self.EmitAsmWithComment(oldAsm, newAsm, endOfLine)
 473             uses = self.mo.group(3)
 474             if uses is not None:
 475                 uses = filter(None, uses.split())
 476             else:
 477                 uses = tuple()
 478             self.uses = uses
 479             for register in self.uses:
 480                 self.EmitNewContent('    push    ' + register)
 481         elif self.MatchAndSetMo(self.procEndRe, oldAsm):
 482             newAsm = ''
 483             self.EmitAsmWithComment(oldAsm, newAsm, endOfLine)
 484         elif self.MatchAndSetMo(self.publicRe, oldAsm):
 485             publics = re.findall(self.varAndTypeSubRe, self.mo.group(1))
 486             publics = map(lambda p: p.split(':')[0].strip(), publics)
 487             for i in range(len(publics) - 1):
 488                 name = publics[i]
 489                 self.EmitNewContent('global ASM_PFX(%s)' % publics[i])
 490                 self.NewGlobal(name)
 491             name = publics[-1]
 492             self.NewGlobal(name)
 493             newAsm = 'global ASM_PFX(%s)' % name
 494             self.EmitAsmWithComment(oldAsm, newAsm, endOfLine)
 495         elif self.MatchAndSetMo(self.defineDataRe, oldAsm):
 496             name = self.mo.group(1)
 497             ty = self.mo.group(2)
 498             value = self.mo.group(3)
 499             if value == '?':
 500                 value = 0
 501             newAsm = '%s: %s %s' % (name, ty, value)
 502             newAsm = self.CommonConversions(newAsm)
 503             self.EmitAsmWithComment(oldAsm, newAsm, endOfLine)
 504         else:
 505             newAsm = self.CommonConversions(oldAsm)
 506             self.EmitAsmWithComment(oldAsm, newAsm, endOfLine)
 507
 508     def NewGlobal(self, name):
 509         regex = re.compile(r'(?<![_\w\d])(?<!ASM_PFX\()(' + re.escape(name) +
 510                            r')(?![_\w\d])')
 511         self.globals.add(regex)
 512
 513     def ConvertAnonymousLabels(self, oldAsm):
 514         newAsm = oldAsm
 515         anonLabel = self.anonLabel(self.anonLabelCount)
 516         newAsm = newAsm.replace('@b', anonLabel)
 517         newAsm = newAsm.replace('@B', anonLabel)
 518         anonLabel = self.anonLabel(self.anonLabelCount + 1)
 519         newAsm = newAsm.replace('@f', anonLabel)
 520         newAsm = newAsm.replace('@F', anonLabel)
 521         return newAsm
 522
 523     def anonLabel(self, count):
 524         return '.%d' % count
 525
 526     def EmitString(self, string):
 527         self.output.write(string)
 528
 529     def EmitLineWithDiff(self, old, new):
 530         newLine = (self.indent + new).rstrip()
 531         if self.diff:
 532             if old is None:
 533                 print '+%s' % newLine
 534             elif newLine != old:
 535                 print '-%s' % old
 536                 print '+%s' % newLine
 537             else:
 538                 print '', newLine
 539         if newLine != '':
 540             self.newAsmEmptyLineCount = 0
 541         self.EmitString(newLine + '\r\n')
 542
 543     def EmitLine(self, string):
 544         self.EmitLineWithDiff(self.originalLine, string)
 545
 546     def EmitNewContent(self, string):
 547         self.EmitLineWithDiff(None, string)
 548
 549     def EmitAsmReplaceOp(self, oldAsm, oldOp, newOp, endOfLine):
 550         newAsm = oldAsm.replace(oldOp, newOp, 1)
 551         self.EmitAsmWithComment(oldAsm, newAsm, endOfLine)
 552
 553     hexNumRe = re.compile(r'0*((?=[\da-f])\d*(?<=\d)[\da-f]*)h', re.IGNORECASE)
 554
 555     def EmitAsmWithComment(self, oldAsm, newAsm, endOfLine):
 556         for glblRe in self.globals:
 557             newAsm = glblRe.sub(r'ASM_PFX(\1)', newAsm)
 558
 559         newAsm = self.hexNumRe.sub(r'0x\1', newAsm)
 560
 561         newLine = newAsm + endOfLine
 562         emitNewLine = ((newLine.strip() != '') or
 563                        ((oldAsm + endOfLine).strip() == ''))
 564         if emitNewLine and newLine.strip() == '':
 565             self.newAsmEmptyLineCount += 1
 566             if self.newAsmEmptyLineCount > 1:
 567                 emitNewLine = False
 568         if emitNewLine:
 569             self.EmitLine(newLine.rstrip())
 570         elif self.diff:
 571             print '-%s' % self.originalLine
 572
 573     leaRe = re.compile(r'''
 574                            (lea \s+) ([\w@][\w@0-9]*) \s* , \s* (\S (?:.*\S)?)
 575                            \s* $
 576                        ''',
 577                        re.VERBOSE | re.IGNORECASE
 578                        )
 579
 580     def ConvertLea(self, oldAsm):
 581         newAsm = oldAsm
 582         if self.MatchAndSetMo(self.leaRe, oldAsm):
 583             lea = self.mo.group(1)
 584             dst = self.mo.group(2)
 585             src = self.mo.group(3)
 586             if src.find('[') < 0:
 587                 src = '[' + src + ']'
 588             newAsm = lea + dst + ', ' + src
 589         newAsm = self.CommonConversions(newAsm)
 590         return newAsm
 591
 592     ptrRe = re.compile(r'''
 593                            (?<! \S )
 594                            ([dfq]?word|byte) \s+ (?: ptr ) (\s*)
 595                            (?= [[\s] )
 596                        ''',
 597                        re.VERBOSE | re.IGNORECASE
 598                        )
 599
 600     def ConvertPtr(self, oldAsm):
 601         newAsm = oldAsm
 602         while self.SearchAndSetMo(self.ptrRe, newAsm):
 603             ty = self.mo.group(1)
 604             if ty.lower() == 'fword':
 605                 ty = ''
 606             else:
 607                 ty += self.mo.group(2)
 608             newAsm = newAsm[:self.mo.start(0)] + ty + newAsm[self.mo.end(0):]
 609         return newAsm
 610
 611     labelByteRe = re.compile(r'''
 612                                  (?: \s+ label \s+ (?: [dfq]?word | byte ) )
 613                                  (?! \S )
 614                              ''',
 615                              re.VERBOSE | re.IGNORECASE
 616                              )
 617
 618     def ConvertLabelByte(self, oldAsm):
 619         newAsm = oldAsm
 620         if self.SearchAndSetMo(self.labelByteRe, newAsm):
 621             newAsm = newAsm[:self.mo.start(0)] + ':' + newAsm[self.mo.end(0):]
 622         return newAsm
 623
 624     unaryBitwiseOpRe = re.compile(r'''
 625                                       ( NOT )
 626                                       (?= \s+ \S )
 627                                   ''',
 628                                   re.VERBOSE | re.IGNORECASE
 629                                   )
 630     binaryBitwiseOpRe = re.compile(r'''
 631                                        ( \S \s+ )
 632                                        ( AND | OR | SHL | SHR )
 633                                        (?= \s+ \S )
 634                                    ''',
 635                                    re.VERBOSE | re.IGNORECASE
 636                                    )
 637     bitwiseOpReplacements = {
 638         'not': '~',
 639         'and': '&',
 640         'shl': '<<',
 641         'shr': '>>',
 642         'or': '|',
 643     }
 644
 645     def ConvertBitwiseOp(self, oldAsm):
 646         newAsm = oldAsm
 647         while self.SearchAndSetMo(self.binaryBitwiseOpRe, newAsm):
 648             prefix = self.mo.group(1)
 649             op = self.bitwiseOpReplacements[self.mo.group(2).lower()]
 650             newAsm = newAsm[:self.mo.start(0)] + prefix + op + \
 651                 newAsm[self.mo.end(0):]
 652         while self.SearchAndSetMo(self.unaryBitwiseOpRe, newAsm):
 653             op = self.bitwiseOpReplacements[self.mo.group(1).lower()]
 654             newAsm = newAsm[:self.mo.start(0)] + op + newAsm[self.mo.end(0):]
 655         return newAsm
 656
 657     sectionRe = re.compile(r'''
 658                                \. ( code |
 659                                     data
 660                                   )
 661                                (?: \s+ .* )?
 662                                \s* $
 663                            ''',
 664                            re.VERBOSE | re.IGNORECASE
 665                            )
 666
 667     segmentRe = re.compile(r'''
 668                                ( code |
 669                                  data )
 670                                (?: \s+ SEGMENT )
 671                                (?: \s+ .* )?
 672                                \s* $
 673                            ''',
 674                            re.VERBOSE | re.IGNORECASE
 675                            )
 676
 677     def ConvertSection(self, oldAsm):
 678         newAsm = oldAsm
 679         if self.MatchAndSetMo(self.sectionRe, newAsm) or \
 680            self.MatchAndSetMo(self.segmentRe, newAsm):
 681             name = self.mo.group(1).lower()
 682             if name == 'code':
 683                 if self.x64:
 684                     self.EmitLine('DEFAULT REL')
 685                 name = 'text'
 686             newAsm = 'SECTION .' + name
 687         return newAsm
 688
 689     fwordRe = re.compile(r'''
 690                              (?<! \S )
 691                              fword
 692                              (?! \S )
 693                          ''',
 694                          re.VERBOSE | re.IGNORECASE
 695                          )
 696
 697     def FwordUnsupportedCheck(self, oldAsm):
 698         newAsm = oldAsm
 699         if self.SearchAndSetMo(self.fwordRe, newAsm):
 700             newAsm = self.Unsupported(newAsm, 'fword used')
 701         return newAsm
 702
 703     __common_conversion_routines__ = (
 704         ConvertAnonymousLabels,
 705         ConvertPtr,
 706         FwordUnsupportedCheck,
 707         ConvertBitwiseOp,
 708         ConvertLabelByte,
 709         ConvertSection,
 710     )
 711
 712     def CommonConversions(self, oldAsm):
 713         newAsm = oldAsm
 714         for conv in self.__common_conversion_routines__:
 715             newAsm = conv(self, newAsm)
 716         return newAsm
 717
 718     def Unsupported(self, asm, message=None):
 719         if not self.force:
 720             raise UnsupportedConversion
 721
 722         self.unsupportedSyntaxSeen = True
 723         newAsm = '%error conversion unsupported'
 724         if message:
 725             newAsm += '; ' + message
 726         newAsm += ': ' + asm
 727         return newAsm
 728
 729
 730 class ConvertInfFile(CommonUtils):
 731
 732     def __init__(self, inf, clone):
 733         CommonUtils.__init__(self, clone)
 734         self.inf = inf
 735         self.ScanInfAsmFiles()
 736         if self.infmode:
 737             self.ConvertInfAsmFiles()
 738
 739     infSrcRe = re.compile(r'''
 740                               \s*
 741                               ( [\w@][\w@0-9/]* \.(asm|s) )
 742                               \s* (?: \| [^#]* )?
 743                               \s* (?: \# .* )?
 744                               $
 745                           ''',
 746                           re.VERBOSE | re.IGNORECASE
 747                           )
 748
 749     def GetInfAsmFileMapping(self):
 750         srcToDst = {'order': []}
 751         for line in self.lines:
 752             line = line.rstrip()
 753             if self.MatchAndSetMo(self.infSrcRe, line):
 754                 src = self.mo.group(1)
 755                 srcExt = self.mo.group(2)
 756                 dst = os.path.splitext(src)[0] + '.nasm'
 757                 if src not in srcToDst:
 758                     srcToDst[src] = dst
 759                     srcToDst['order'].append(src)
 760         return srcToDst
 761
 762     def ScanInfAsmFiles(self):
 763         src = self.inf
 764         assert os.path.isfile(src)
 765         f = open(src)
 766         self.lines = f.readlines()
 767         f.close()
 768
 769         path = os.path.realpath(self.inf)
 770         (self.dir, inf) = os.path.split(path)
 771         parent = os.path.normpath(self.dir)
 772         (lastpath, self.moduleName) = os.path.split(parent)
 773         self.packageName = None
 774         while True:
 775             lastpath = os.path.normpath(lastpath)
 776             (parent, basename) = os.path.split(lastpath)
 777             if parent == lastpath:
 778                 break
 779             if basename.endswith('Pkg'):
 780                 self.packageName = basename
 781                 break
 782             lastpath = parent
 783
 784         self.srcToDst = self.GetInfAsmFileMapping()
 785
 786         self.dstToSrc = {'order': []}
 787         for src in self.srcToDst['order']:
 788             srcExt = os.path.splitext(src)[1]
 789             dst = self.srcToDst[src]
 790             if dst not in self.dstToSrc:
 791                 self.dstToSrc[dst] = [src]
 792                 self.dstToSrc['order'].append(dst)
 793             else:
 794                 self.dstToSrc[dst].append(src)
 795
 796     def __len__(self):
 797         return len(self.dstToSrc['order'])
 798
 799     def __iter__(self):
 800         return iter(self.dstToSrc['order'])
 801
 802     def ConvertInfAsmFiles(self):
 803         notConverted = []
 804         unsupportedArchCount = 0
 805         for dst in self:
 806             didSomething = False
 807             fileChanged = self.UpdateInfAsmFile(dst)
 808             try:
 809                 self.UpdateInfAsmFile(dst)
 810                 didSomething = True
 811             except UnsupportedConversion:
 812                 if not self.Opt.quiet:
 813                     print 'MASM=>NASM conversion unsupported for', dst
 814                 notConverted.append(dst)
 815             except NoSourceFile:
 816                 if not self.Opt.quiet:
 817                     print 'Source file missing for', reldst
 818                 notConverted.append(dst)
 819             except UnsupportedArch:
 820                 unsupportedArchCount += 1
 821             else:
 822                 if didSomething:
 823                     self.ConversionFinished(dst)
 824         if len(notConverted) > 0 and not self.Opt.quiet:
 825             for dst in notConverted:
 826                 reldst = self.RootRelative(dst)
 827                 print 'Unabled to convert', reldst
 828         if unsupportedArchCount > 0 and not self.Opt.quiet:
 829             print 'Skipped', unsupportedArchCount, 'files based on architecture'
 830
 831     def UpdateInfAsmFile(self, dst, IgnoreMissingAsm=False):
 832         infPath = os.path.split(os.path.realpath(self.inf))[0]
 833         asmSrc = os.path.splitext(dst)[0] + '.asm'
 834         fullSrc = os.path.join(infPath, asmSrc)
 835         fullDst = os.path.join(infPath, dst)
 836         srcParentDir = os.path.basename(os.path.split(fullSrc)[0])
 837         if srcParentDir.lower() in UnsupportedArch.unsupported:
 838             raise UnsupportedArch
 839         elif not os.path.exists(fullSrc):
 840             if not IgnoreMissingAsm:
 841                 raise NoSourceFile
 842         else:  # not os.path.exists(fullDst):
 843             conv = ConvertAsmFile(fullSrc, fullDst, self)
 844             self.unsupportedSyntaxSeen = conv.unsupportedSyntaxSeen
 845
 846         lastLine = ''
 847         fileChanged = False
 848         for i in range(len(self.lines)):
 849             line = self.lines[i].rstrip()
 850             updatedLine = line
 851             for src in self.dstToSrc[dst]:
 852                 assert self.srcToDst[src] == dst
 853                 updatedLine = self.ReplacePreserveSpacing(
 854                     updatedLine, src, dst)
 855
 856             lineChanged = updatedLine != line
 857             if lineChanged:
 858                 if lastLine.strip() == updatedLine.strip():
 859                     self.lines[i] = None
 860                 else:
 861                     self.lines[i] = updatedLine + '\r\n'
 862
 863             if self.diff:
 864                 if lineChanged:
 865                     print '-%s' % line
 866                     if self.lines[i] is not None:
 867                         print '+%s' % updatedLine
 868                 else:
 869                     print '', line
 870
 871             fileChanged |= lineChanged
 872             if self.lines[i] is not None:
 873                 lastLine = self.lines[i]
 874
 875         if fileChanged:
 876             self.lines = filter(lambda l: l is not None, self.lines)
 877
 878         for src in self.dstToSrc[dst]:
 879             if not src.endswith('.asm'):
 880                 fullSrc = os.path.join(infPath, src)
 881                 if os.path.exists(fullSrc):
 882                     self.RemoveFile(fullSrc)
 883
 884         if fileChanged:
 885             f = open(self.inf, 'wb')
 886             f.writelines(self.lines)
 887             f.close()
 888             self.FileUpdated(self.inf)
 889
 890     def ConversionFinished(self, dst):
 891         asmSrc = os.path.splitext(dst)[0] + '.asm'
 892         self.FileConversionFinished(
 893             self.packageName, self.moduleName, asmSrc, dst)
 894
 895
 896 class ConvertInfFiles(CommonUtils):
 897
 898     def __init__(self, infs, clone):
 899         CommonUtils.__init__(self, clone)
 900         infs = map(lambda i: ConvertInfFile(i, self), infs)
 901         infs = filter(lambda i: len(i) > 0, infs)
 902         dstToInfs = {'order': []}
 903         for inf in infs:
 904             for dst in inf:
 905                 fulldst = os.path.realpath(os.path.join(inf.dir, dst))
 906                 pair = (inf, dst)
 907                 if fulldst in dstToInfs:
 908                     dstToInfs[fulldst].append(pair)
 909                 else:
 910                     dstToInfs['order'].append(fulldst)
 911                     dstToInfs[fulldst] = [pair]
 912
 913         notConverted = []
 914         unsupportedArchCount = 0
 915         for dst in dstToInfs['order']:
 916             didSomething = False
 917             try:
 918                 for inf, reldst in dstToInfs[dst]:
 919                     inf.UpdateInfAsmFile(reldst, IgnoreMissingAsm=didSomething)
 920                     didSomething = True
 921             except UnsupportedConversion:
 922                 if not self.Opt.quiet:
 923                     print 'MASM=>NASM conversion unsupported for', reldst
 924                 notConverted.append(dst)
 925             except NoSourceFile:
 926                 if not self.Opt.quiet:
 927                     print 'Source file missing for', reldst
 928                 notConverted.append(dst)
 929             except UnsupportedArch:
 930                 unsupportedArchCount += 1
 931             else:
 932                 if didSomething:
 933                     inf.ConversionFinished(reldst)
 934         if len(notConverted) > 0 and not self.Opt.quiet:
 935             for dst in notConverted:
 936                 reldst = self.RootRelative(dst)
 937                 print 'Unabled to convert', reldst
 938         if unsupportedArchCount > 0 and not self.Opt.quiet:
 939             print 'Skipped', unsupportedArchCount, 'files based on architecture'
 940
 941
 942 class ConvertDirectories(CommonUtils):
 943
 944     def __init__(self, paths, clone):
 945         CommonUtils.__init__(self, clone)
 946         self.paths = paths
 947         self.ConvertInfAndAsmFiles()
 948
 949     def ConvertInfAndAsmFiles(self):
 950         infs = list()
 951         for path in self.paths:
 952             assert(os.path.exists(path))
 953         for path in self.paths:
 954             for root, dirs, files in os.walk(path):
 955                 for d in ('.svn', '.git'):
 956                     if d in dirs:
 957                         dirs.remove(d)
 958                 for f in files:
 959                     if f.lower().endswith('.inf'):
 960                         inf = os.path.realpath(os.path.join(root, f))
 961                         infs.append(inf)
 962
 963         ConvertInfFiles(infs, self)
 964
 965
 966 class ConvertAsmApp(CommonUtils):
 967
 968     def __init__(self):
 969         CommonUtils.__init__(self)
 970
 971         numArgs = len(self.Args)
 972         assert(numArgs >= 1)
 973         if self.infmode:
 974             ConvertInfFiles(self.Args, self)
 975         elif self.dirmode:
 976             ConvertDirectories(self.Args, self)
 977         elif not self.dirmode:
 978             assert(numArgs <= 2)
 979             src = self.Args[0]
 980             if numArgs > 1:
 981                 dst = self.Args[1]
 982             else:
 983                 dst = None
 984             ConvertAsmFile(src, dst, self)
 985
 986 ConvertAsmApp()