Move inline macro definition from typedarray.js to macros.py

tools/js2c.py

 #!/usr/bin/env python
 #
 # Copyright 2012 the V8 project authors. All rights reserved.
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
 #
 #     * Redistributions of source code must retain the above copyright
 #       notice, this list of conditions and the following disclaimer.
 #     * Redistributions in binary form must reproduce the above
@@ skipping 50 matching lines @@
 
 def ReadFile(filename):
   file = open(filename, "rt")
   try:
     lines = file.read()
   finally:
     file.close()
   return lines
 
 
-def ReadLines(filename):
-  result = []
-  for line in open(filename, "rt"):
-    if '#' in line:
-      line = line[:line.index('#')]
-    line = line.strip()
-    if len(line) > 0:
-      result.append(line)
-  return result
-
-
 def LoadConfigFrom(name):
   import ConfigParser
   config = ConfigParser.ConfigParser()
   config.read(name)
   return config
 
 
 def ParseValue(string):
   string = string.strip()
   if string.startswith('[') and string.endswith(']'):
@@ skipping 80 matching lines @@
 class PythonMacro:
   def __init__(self, args, fun):
     self.args = args
     self.fun = fun
   def expand(self, mapping):
     args = []
     for arg in self.args:
       args.append(mapping[arg])
     return str(self.fun(*args))
 
+
 CONST_PATTERN = re.compile(r'^const\s+([a-zA-Z0-9_]+)\s*=\s*([^;]*);$')
 MACRO_PATTERN = re.compile(r'^macro\s+([a-zA-Z0-9_]+)\s*\(([^)]*)\)\s*=\s*([^;]*);$')
+MACRO_START_PATTERN = re.compile(r'macro\s+([a-zA-Z0-9_]+)\s*\(([^)]*)\)\s*\n')
+MACRO_END_PATTERN = re.compile(r'endmacro\s*\n')
 PYTHON_MACRO_PATTERN = re.compile(r'^python\s+macro\s+([a-zA-Z0-9_]+)\s*\(([^)]*)\)\s*=\s*([^;]*);$')
 
 
-def ReadMacros(lines):
+def ReadMacros(contents):
   constants = []
   macros = []
+
+  multiple_line_macros = []
+  pos = 0
+  while True:
+    macro_start_match = MACRO_START_PATTERN.search(contents, pos)
+    if macro_start_match is None:
+      # no more multiple line macros
+      break
+    name = macro_start_match.group(1)
+    args = [match.strip() for match in macro_start_match.group(2).split(',')]
+    macro_end_match = MACRO_END_PATTERN.search(contents, macro_start_match.end());
+    if macro_end_match is None:
+      raise ("Macro %s unclosed in %s" % (name, 'macros.py'))
+    body = contents[macro_start_match.end():macro_end_match.start()]
+
+    # remove multiple line macro definition
+    contents = contents[:macro_start_match.start()] + contents[macro_end_match.end():]
+    # record multiple line macro definition
+    multiple_line_macros.append((re.compile("\\b%s\\(" % name), TextMacro(args, body)))
+    # advance position to where the multiple line macro defintion was
+    pos = macro_start_match.start()
+
+  lines = contents.split('\n')
   for line in lines:
     hash = line.find('#')
     if hash != -1: line = line[:hash]
     line = line.strip()
     if len(line) is 0: continue
     const_match = CONST_PATTERN.match(line)
     if const_match:
       name = const_match.group(1)
       value = const_match.group(2).strip()
       constants.append((re.compile("\\b%s\\b" % name), value))
     else:
       macro_match = MACRO_PATTERN.match(line)
       if macro_match:
         name = macro_match.group(1)
         args = [match.strip() for match in macro_match.group(2).split(',')]
         body = macro_match.group(3).strip()
         macros.append((re.compile("\\b%s\\(" % name), TextMacro(args, body)))
       else:
         python_match = PYTHON_MACRO_PATTERN.match(line)
         if python_match:
           name = python_match.group(1)
           args = [match.strip() for match in python_match.group(2).split(',')]
           body = python_match.group(3).strip()
           fun = eval("lambda " + ",".join(args) + ': ' + body)
           macros.append((re.compile("\\b%s\\(" % name), PythonMacro(args, fun)))
         else:
           raise ("Illegal line: " + line)
+
+  # append multiple line macros to macros so that they will be expanded first
+  for m in multiple_line_macros:
+    macros.append(m)
+
   return (constants, macros)
 
-INLINE_MACRO_PATTERN = re.compile(r'macro\s+([a-zA-Z0-9_]+)\s*\(([^)]*)\)\s*\n')
-INLINE_MACRO_END_PATTERN = re.compile(r'endmacro\s*\n')
-
-def ExpandInlineMacros(lines, filename):
-  pos = 0
-  while True:
-    macro_match = INLINE_MACRO_PATTERN.search(lines, pos)
-    if macro_match is None:
-      # no more macros
-      return lines
-    name = macro_match.group(1)
-    args = [match.strip() for match in macro_match.group(2).split(',')]
-    end_macro_match = INLINE_MACRO_END_PATTERN.search(lines, macro_match.end());
-    if end_macro_match is None:
-      raise ("Macro %s unclosed in %s" % (name, filename))
-    body = lines[macro_match.end():end_macro_match.start()]
-
-    # remove macro definition
-    lines = lines[:macro_match.start()] + lines[end_macro_match.end():]
-    name_pattern = re.compile("\\b%s\\(" % name)
-    macro = TextMacro(args, body)
-
-    # advance position to where the macro defintion was
-    pos = macro_match.start()
-
-    def non_expander(s):
-      return s
-    lines = ExpandMacroDefinition(lines, pos, name_pattern, macro, non_expander)
 
 HEADER_TEMPLATE = """\
 // Copyright 2011 Google Inc. All Rights Reserved.
 
 // This file was generated from .js source files by GYP.  If you
 // want to make changes to this file you should either change the
 // javascript source files or the GYP script.
 
 #include "v8.h"
 #include "natives.h"
@@ skipping 81 matching lines @@
 
 def JS2C(source, target, env):
   ids = []
   debugger_ids = []
   modules = []
   # Locate the macros file name.
   consts = []
   macros = []
   for s in source:
     if 'macros.py' == (os.path.split(str(s))[1]):
-      (consts, macros) = ReadMacros(ReadLines(str(s)))
+      (consts, macros) = ReadMacros(ReadFile(str(s)))
     else:
       modules.append(s)
 
   minifier = jsmin.JavaScriptMinifier()
 
   module_offset = 0
   all_sources = []
   for module in modules:
     filename = str(module)
     debugger = filename.endswith('-debugger.js')
     lines = ReadFile(filename)
+    lines = ExpandMacros(lines, macros)
     lines = ExpandConstants(lines, consts)
-    lines = ExpandMacros(lines, macros)
     lines = RemoveCommentsAndTrailingWhitespace(lines)
-    lines = ExpandInlineMacros(lines, filename)
     Validate(lines, filename)
     lines = minifier.JSMinify(lines)
     id = (os.path.split(filename)[1])[:-3]
     if debugger: id = id[:-9]
     raw_length = len(lines)
     if debugger:
       debugger_ids.append((id, raw_length, module_offset))
     else:
       ids.append((id, raw_length, module_offset))
     all_sources.append(lines)
@@ skipping 49 matching lines @@
 
 def main():
   natives = sys.argv[1]
   type = sys.argv[2]
   compression = sys.argv[3]
   source_files = sys.argv[4:]
   JS2C(source_files, [natives], { 'TYPE': type, 'COMPRESSION': compression })
 
 if __name__ == "__main__":
   main()