Fix an assert in the parser that fails if extensions code using 'eval'...

tools/js2c.py

 #!/usr/bin/env python
 #
 # Copyright 2006-2008 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 27 matching lines @@
 def ToCArray(lines):
   result = []
   for chr in lines:
     value = ord(chr)
     assert value < 128
     result.append(str(value))
   result.append("0")
   return ", ".join(result)
 
 
+def RemoveCommentsAndTrailingWhitespace(lines):
+  lines = re.sub(r'//.*\n', '\n', lines) # end-of-line comments
+  lines = re.sub(re.compile(r'/\*.*?\*/', re.DOTALL), '', lines) # comments.
+  lines = re.sub(r'\s+\n+', '\n', lines) # trailing whitespace
+  return lines
+
+
 def CompressScript(lines, do_jsmin):
   # If we're not expecting this code to be user visible, we can run it through
   # a more aggressive minifier.
   if do_jsmin:
     return jsmin.jsmin(lines)
 
   # Remove stuff from the source that we don't want to appear when
   # people print the source code using Function.prototype.toString().
   # Note that we could easily compress the scripts mode but don't
   # since we want it to remain readable.
-  lines = re.sub('//.*\n', '\n', lines) # end-of-line comments
-  lines = re.sub(re.compile(r'/\*.*?\*/', re.DOTALL), '', lines) # comments.
-  lines = re.sub('\s+\n+', '\n', lines) # trailing whitespace
+  lines = RemoveCommentsAndTrailingWhitespace(lines)
   return lines
 
 
 def ReadFile(filename):
   file = open(filename, "rt")
   try:
     lines = file.read()
   finally:
     file.close()
   return lines
@@ skipping 18 matching lines @@
 
 
 def ParseValue(string):
   string = string.strip()
   if string.startswith('[') and string.endswith(']'):
     return string.lstrip('[').rstrip(']').split()
   else:
     return string
 
 
+EVAL_PATTERN = re.compile(r'\beval\s*\(');
+WITH_PATTERN = re.compile(r'\bwith\s*\(');
+
+
+def Validate(lines, file):
+  lines = RemoveCommentsAndTrailingWhitespace(lines)
+  # Because of simplified context setup, eval and with is not
+  # allowed in the natives files.
+  eval_match = EVAL_PATTERN.search(lines)
+  if eval_match:
+    raise ("Eval disallowed in natives: " + file)

[Christian Plesner Hansen, 2009/08/31 12:42:45]

The formatting operator % should be used for string formatting in python:

"Eval disallowed in natives: %s" % file

+  with_match = WITH_PATTERN.search(lines)
+  if with_match:
+    raise ("With statements disallowed in natives: " + file)
+
+
 def ExpandConstants(lines, constants):
   for key, value in constants.items():
     lines = lines.replace(key, str(value))
   return lines
 
 
 def ExpandMacros(lines, macros):
   for name, macro in macros.items():
     start = lines.find(name + '(', 0)
     while start != -1:
@@ skipping 39 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('^const\s+([a-zA-Z0-9_]+)\s*=\s*([^;]*);$')
-MACRO_PATTERN = re.compile('^macro\s+([a-zA-Z0-9_]+)\s*\(([^)]*)\)\s*=\s*([^;]*);$')
-PYTHON_MACRO_PATTERN = re.compile('^python\s+macro\s+([a-zA-Z0-9_]+)\s*\(([^)]*)\)\s*=\s*([^;]*);$')
+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*([^;]*);$')
+PYTHON_MACRO_PATTERN = re.compile(r'^python\s+macro\s+([a-zA-Z0-9_]+)\s*\(([^)]*)\)\s*=\s*([^;]*);$')
 
 def ReadMacros(lines):
   constants = { }
   macros = { }
   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)
@@ skipping 98 matching lines @@
   for s in source:
     if 'macros.py' == (os.path.split(str(s))[1]):
       (consts, macros) = ReadMacros(ReadLines(str(s)))
     else:
       modules.append(s)
 
   # Build source code lines
   source_lines = [ ]
   source_lines_empty = []
   for s in modules:
     delay = str(s).endswith('-delay.js')

[Christian Plesner Hansen, 2009/08/31 12:42:45]

We use str(s) so many places here -- maybe do something like

for module in modules:
  filename = str(module)
  ...

     lines = ReadFile(str(s))
     do_jsmin = lines.find('// jsminify this file, js2c: jsmin') != -1
     lines = ExpandConstants(lines, consts)
     lines = ExpandMacros(lines, macros)
+    Validate(lines, str(s))
     lines = CompressScript(lines, do_jsmin)
     data = ToCArray(lines)
     id = (os.path.split(str(s))[1])[:-3]
     if delay: id = id[:-6]
     if delay:
       delay_ids.append((id, len(lines)))
     else:
       ids.append((id, len(lines)))
     source_lines.append(SOURCE_DECLARATION % { 'id': id, 'data': data })
     source_lines_empty.append(SOURCE_DECLARATION % { 'id': id, 'data': 0 })
-  
+
   # Build delay support functions
   get_index_cases = [ ]
   get_script_source_cases = [ ]
   get_script_name_cases = [ ]
 
   i = 0
   for (id, length) in delay_ids:
     native_name = "native %s.js" % id
     get_index_cases.append(GET_DELAY_INDEX_CASE % { 'id': id, 'i': i })
     get_script_source_cases.append(GET_DELAY_SCRIPT_SOURCE_CASE % {
@@ skipping 51 matching lines @@
 
 def main():
   natives = sys.argv[1]
   natives_empty = sys.argv[2]
   type = sys.argv[3]
   source_files = sys.argv[4:]
   JS2C(source_files, [natives, natives_empty], { 'TYPE': type })
 
 if __name__ == "__main__":
   main()