Wrap v8natives.js into a function.

tools/jsmin.py

 #!/usr/bin/python2.4
 
 # 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 82 matching lines @@
     declarations.  (These last two must be on one line including the opening
     curly brace of the function for their variables to be renamed).
 
     Args:
       m: The match object returned by re.search.
 
     Returns:
       The string that should replace the match in the rewritten program.
     """
     matched_text = m.group(0)
+
+    if matched_text.startswith("`") and matched_text.endswith("`"):
+      return re.sub(r"\$\{([\w$%]+)\}",
+                    lambda m: '${' + self.FindNewName(m.group(1)) + '}',
+                    matched_text)
+
     if matched_text == "{":
       self.Push()
       return matched_text
     if matched_text == "}":
       self.Pop()
       return matched_text
     if re.match("[\"'/]", matched_text):
       return matched_text
     m = re.match(r"var ", matched_text)
     if m:
@@ skipping 32 matching lines @@
       The new name of the variable.
     """
     new_identifier = ""
     # Variable names that end in _ are member variables of the global object,
     # so they can be visible from code in a different scope.  We leave them
     # alone.
     if var_name in self.map:
       return self.map[var_name]
     if self.nesting == 0:
       return var_name
+    # Do not rename arguments object.
+    if var_name == 'arguments':
+      return 'arguments'
     while True:
       identifier_first_char = self.identifier_counter % 52
       identifier_second_char = self.identifier_counter // 52
       new_identifier = self.CharFromNumber(identifier_first_char)
       if identifier_second_char != 0:
         new_identifier = (
             self.CharFromNumber(identifier_second_char - 1) + new_identifier)
       self.identifier_counter += 1
       if not new_identifier in self.seen_identifiers:
         break
@@ skipping 12 matching lines @@
 
     Returns:
       The string that should be inserted instead of the matched text.
     """
     entire_match = m.group(0)
     replacement = m.group(1)
     if re.match(r"'.*'$", entire_match):
       return entire_match
     if re.match(r'".*"$', entire_match):
       return entire_match
+    if re.match(r"`.*`$", entire_match):
+      return entire_match
     if re.match(r"/.+/$", entire_match):
       return entire_match
     return replacement
 
   def JSMinify(self, text):
     """The main entry point.  Takes a text and returns a compressed version.
 
     The compressed version hopefully does the same thing.  Line breaks are
     preserved.
 
@@ skipping 23 matching lines @@
           line = line[:m.start()]
           self.in_comment = True
 
       # Strip leading and trailing spaces.
       line = re.sub(r"^ +", "", line)
       line = re.sub(r" +$", "", line)
       # A regexp that matches a literal string surrounded by "double quotes".
       # This regexp can handle embedded backslash-escaped characters including
       # embedded backslash-escaped double quotes.
       double_quoted_string = r'"(?:[^"\\]|\\.)*"'
-      # A regexp that matches a literal string surrounded by 'double quotes'.
+      # A regexp that matches a literal string surrounded by 'single quotes'.
       single_quoted_string = r"'(?:[^'\\]|\\.)*'"
+      # A regexp that matches a template string
+      template_string = r"`(?:[^'\\]|\\.)*`"
       # A regexp that matches a regexp literal surrounded by /slashes/.
       # Don't allow a regexp to have a ) before the first ( since that's a
       # syntax error and it's probably just two unrelated slashes.
       # Also don't allow it to come after anything that can only be the
       # end of a primary expression.
       slash_quoted_regexp = r"(?<![\w$'\")\]])/(?:(?=\()|(?:[^()/\\]|\\.)+)(?:\([^/\\]|\\.)*/"
       # Replace multiple spaces with a single space.
       line = re.sub("|".join([double_quoted_string,
                               single_quoted_string,
+                              template_string,
                               slash_quoted_regexp,
                               "( )+"]),
                     self.RemoveSpaces,
                     line)
       # Strip single spaces unless they have an identifier character both before
       # and after the space.  % and $ are counted as identifier characters.
       line = re.sub("|".join([double_quoted_string,
                               single_quoted_string,
+                              template_string,
                               slash_quoted_regexp,
                               r"(?<![a-zA-Z_0-9$%]) | (?![a-zA-Z_0-9$%])()"]),
                     self.RemoveSpaces,
                     line)
       # Collect keywords and identifiers that are already in use.
       if self.nesting == 0:
         re.sub(r"([a-zA-Z0-9_$%]+)", self.LookAtIdentifier, line)
       function_declaration_regexp = (
           r"\bfunction"              # Function definition keyword...
           r"( [\w$%]+)?"             # ...optional function name...
           r"\([\w$%,]+\)\{")         # ...argument declarations.
       # Unfortunately the keyword-value syntax { key:value } makes the key look
       # like a variable where in fact it is a literal string.  We use the
       # presence or absence of a question mark to try to distinguish between
       # this case and the ternary operator: "condition ? iftrue : iffalse".
       if re.search(r"\?", line):
         block_trailing_colon = r""
       else:
         block_trailing_colon = r"(?![:\w$%])"
       # Variable use.  Cannot follow a period precede a colon.
       variable_use_regexp = r"(?<![.\w$%])[\w$%]+" + block_trailing_colon
       line = re.sub("|".join([double_quoted_string,
                               single_quoted_string,
+                              template_string,
                               slash_quoted_regexp,
                               r"\{",                  # Curly braces.
                               r"\}",
                               r"\bvar [\w$%,]+",      # var declarations.
                               function_declaration_regexp,
                               variable_use_regexp]),
                     self.Declaration,
                     line)
       new_lines.append(line)
 
     return "\n".join(new_lines) + "\n"