Start migrating error message templates to the runtime.

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 51 matching lines @@
   file = open(filename, "rt")
   try:
     lines = file.read()
   finally:
     file.close()
   return lines
 
 
 EVAL_PATTERN = re.compile(r'\beval\s*\(')
 WITH_PATTERN = re.compile(r'\bwith\s*\(')
+INVALID_ERROR_MESSAGE_PATTERN = re.compile(r'Make\w*Error\((k\w+),')
 
 def Validate(lines):
   # Because of simplified context setup, eval and with is not
   # allowed in the natives files.
   if EVAL_PATTERN.search(lines):
     raise Error("Eval disallowed in natives.")
   if WITH_PATTERN.search(lines):
     raise Error("With statements disallowed in natives.")
-
+  invalid_error = INVALID_ERROR_MESSAGE_PATTERN.search(lines)
+  if invalid_error:
+    raise Error("Unknown error message template '%s'" % invalid_error.group(1))
   # Pass lines through unchanged.
   return lines
 
 
 def ExpandConstants(lines, constants):
   for key, value in constants:
     lines = key.sub(str(value), lines)
   return lines
 
 
@@ skipping 90 matching lines @@
         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 Error("Illegal line: " + line)
   return (constants, macros)
 
+
+TEMPLATE_PATTERN = re.compile(r'^\s+T\(([a-zA-Z]+), ".+"\)')
+
+def ReadMessageTemplates(lines):
+  templates = []
+  index = 0
+  for line in lines.split('\n'):
+    template_match = TEMPLATE_PATTERN.match(line)
+    if template_match:
+      name = "k%s" % template_match.group(1)
+      value = index
+      index = index + 1
+      templates.append((re.compile("\\b%s\\b" % name), value))
+  return templates
+
 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):
   pos = 0
   while True:
     macro_match = INLINE_MACRO_PATTERN.search(lines, pos)
     if macro_match is None:
       # no more macros
       return lines
@@ skipping 103 matching lines @@
 GET_SCRIPT_SOURCE_CASE = """\
     if (index == %(i)i) return Vector<const char>(sources + %(offset)i, %(source_length)i);
 """
 
 
 GET_SCRIPT_NAME_CASE = """\
     if (index == %(i)i) return Vector<const char>("%(name)s", %(length)i);
 """
 
 
-def BuildFilterChain(macro_filename):
+def BuildFilterChain(macro_filename, message_template_file):
   """Build the chain of filter functions to be applied to the sources.
 
   Args:
     macro_filename: Name of the macro file, if any.
 
   Returns:
     A function (string -> string) that reads a source file and processes it.
   """
   filter_chain = [ReadFile]
 
   if macro_filename:
     (consts, macros) = ReadMacros(ReadFile(macro_filename))
     filter_chain.append(lambda l: ExpandConstants(l, consts))
     filter_chain.append(lambda l: ExpandMacros(l, macros))
 
+  if message_template_file:
+    message_templates = ReadMessageTemplates(ReadFile(message_template_file))
+    filter_chain.append(lambda l: ExpandConstants(l, message_templates))
+
   filter_chain.extend([
     RemoveCommentsAndTrailingWhitespace,
     ExpandInlineMacros,
     ExpandInlineConstants,
     Validate,
     jsmin.JavaScriptMinifier().JSMinify
   ])
 
   def chain(f1, f2):
     return lambda x: f2(f1(x))
 
   return reduce(chain, filter_chain)
 
 
 class Sources:
   def __init__(self):
     self.names = []
     self.modules = []
     self.is_debugger_id = []
 
 
 def IsDebuggerFile(filename):
   return filename.endswith("-debugger.js")
 
 def IsMacroFile(filename):
   return filename.endswith("macros.py")
 
+def IsMessageTemplateFile(filename):
+  return filename.endswith("messages.h")
+
 
 def PrepareSources(source_files):
   """Read, prepare and assemble the list of source files.
 
   Args:
     sources: List of Javascript-ish source files. A file named macros.py
         will be treated as a list of macros.
 
   Returns:
     An instance of Sources.
   """
   macro_file = None
   macro_files = filter(IsMacroFile, source_files)
   assert len(macro_files) in [0, 1]
   if macro_files:
     source_files.remove(macro_files[0])
     macro_file = macro_files[0]
 
-  filters = BuildFilterChain(macro_file)
+  message_template_file = None
+  message_template_files = filter(IsMessageTemplateFile, source_files)
+  assert len(message_template_files) in [0, 1]
+  if message_template_files:
+    source_files.remove(message_template_files[0])
+    message_template_file = message_template_files[0]
+
+  filters = BuildFilterChain(macro_file, message_template_file)
 
   # Sort 'debugger' sources first.
   source_files = sorted(source_files,
                         lambda l,r: IsDebuggerFile(r) - IsDebuggerFile(l))
 
   result = Sources()
   for source in source_files:
     try:
       lines = filters(source)
     except Error as e:
@@ skipping 139 matching lines @@
       out.cc: C code to be generated.
       type: type parameter for NativesCollection template.
       sources.js: JS internal sources or macros.py.""")
   (options, args) = parser.parse_args()
 
   JS2C(args[2:], args[0], args[1], options.raw, options.startup_blob)
 
 
 if __name__ == "__main__":
   main()