tools/js2c.py

   1 #!/usr/bin/env python
   2 #
   3 # Copyright 2006-2008 the V8 project authors. All rights reserved.
   4 # Redistribution and use in source and binary forms, with or without
   5 # modification, are permitted provided that the following conditions are
   6 # met:
   7 #
   8 #     * Redistributions of source code must retain the above copyright
   9 #       notice, this list of conditions and the following disclaimer.
  10 #     * Redistributions in binary form must reproduce the above
  11 #       copyright notice, this list of conditions and the following
  12 #       disclaimer in the documentation and/or other materials provided
  13 #       with the distribution.
  14 #     * Neither the name of Google Inc. nor the names of its
  15 #       contributors may be used to endorse or promote products derived
  16 #       from this software without specific prior written permission.
  17 #
  18 # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  19 # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  20 # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  21 # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  22 # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  23 # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  24 # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25 # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  26 # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  28 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29
  30 # This is a utility for converting JavaScript source code into C-style
  31 # char arrays. It is used for embedded JavaScript code in the V8
  32 # library.
  33
  34 import os
  35 from os.path import dirname
  36 import re
  37 import sys
  38 import string
  39
  40 sys.path.append(dirname(__file__) + "/../deps/v8/tools");
  41 import jsmin
  42
  43
  44 def ToCArray(filename, lines):
  45   result = []
  46   row = 1
  47   col = 0
  48   for chr in lines:
  49     col += 1
  50     if chr == "\n" or chr == "\r":
  51       row += 1
  52       col = 0
  53
  54     value = ord(chr)
  55
  56     if value >= 128:
  57       print 'non-ascii value ' + filename + ':' + str(row) + ':' + str(col)
  58       sys.exit(1);
  59
  60     result.append(str(value))
  61   result.append("0")
  62   return ", ".join(result)
  63
  64
  65 def CompressScript(lines, do_jsmin):
  66   # If we're not expecting this code to be user visible, we can run it through
  67   # a more aggressive minifier.
  68   if do_jsmin:
  69     minifier = JavaScriptMinifier()
  70     return minifier.JSMinify(lines)
  71
  72   # Remove stuff from the source that we don't want to appear when
  73   # people print the source code using Function.prototype.toString().
  74   # Note that we could easily compress the scripts mode but don't
  75   # since we want it to remain readable.
  76   #lines = re.sub('//.*\n', '\n', lines) # end-of-line comments
  77   #lines = re.sub(re.compile(r'/\*.*?\*/', re.DOTALL), '', lines) # comments.
  78   #lines = re.sub('\s+\n+', '\n', lines) # trailing whitespace
  79   return lines
  80
  81
  82 def ReadFile(filename):
  83   file = open(filename, "rt")
  84   try:
  85     lines = file.read()
  86   finally:
  87     file.close()
  88   return lines
  89
  90
  91 def ReadLines(filename):
  92   result = []
  93   for line in open(filename, "rt"):
  94     if '#' in line:
  95       line = line[:line.index('#')]
  96     line = line.strip()
  97     if len(line) > 0:
  98       result.append(line)
  99   return result
 100
 101
 102 def LoadConfigFrom(name):
 103   import ConfigParser
 104   config = ConfigParser.ConfigParser()
 105   config.read(name)
 106   return config
 107
 108
 109 def ParseValue(string):
 110   string = string.strip()
 111   if string.startswith('[') and string.endswith(']'):
 112     return string.lstrip('[').rstrip(']').split()
 113   else:
 114     return string
 115
 116
 117 def ExpandConstants(lines, constants):
 118   for key, value in constants.items():
 119     lines = lines.replace(key, str(value))
 120   return lines
 121
 122
 123 def ExpandMacros(lines, macros):
 124   for name, macro in macros.items():
 125     start = lines.find(name + '(', 0)
 126     while start != -1:
 127       # Scan over the arguments
 128       assert lines[start + len(name)] == '('
 129       height = 1
 130       end = start + len(name) + 1
 131       last_match = end
 132       arg_index = 0
 133       mapping = { }
 134       def add_arg(str):
 135         # Remember to expand recursively in the arguments
 136         replacement = ExpandMacros(str.strip(), macros)
 137         mapping[macro.args[arg_index]] = replacement
 138       while end < len(lines) and height > 0:
 139         # We don't count commas at higher nesting levels.
 140         if lines[end] == ',' and height == 1:
 141           add_arg(lines[last_match:end])
 142           last_match = end + 1
 143         elif lines[end] in ['(', '{', '[']:
 144           height = height + 1
 145         elif lines[end] in [')', '}', ']']:
 146           height = height - 1
 147         end = end + 1
 148       # Remember to add the last match.
 149       add_arg(lines[last_match:end-1])
 150       result = macro.expand(mapping)
 151       # Replace the occurrence of the macro with the expansion
 152       lines = lines[:start] + result + lines[end:]
 153       start = lines.find(name + '(', start)
 154   return lines
 155
 156
 157 class TextMacro:
 158   def __init__(self, args, body):
 159     self.args = args
 160     self.body = body
 161   def expand(self, mapping):
 162     result = self.body
 163     for key, value in mapping.items():
 164         result = result.replace(key, value)
 165     return result
 166
 167 class PythonMacro:
 168   def __init__(self, args, fun):
 169     self.args = args
 170     self.fun = fun
 171   def expand(self, mapping):
 172     args = []
 173     for arg in self.args:
 174       args.append(mapping[arg])
 175     return str(self.fun(*args))
 176
 177 CONST_PATTERN = re.compile('^const\s+([a-zA-Z0-9_]+)\s*=\s*([^;]*);$')
 178 MACRO_PATTERN = re.compile('^macro\s+([a-zA-Z0-9_]+)\s*\(([^)]*)\)\s*=\s*([^;]*);$')
 179 PYTHON_MACRO_PATTERN = re.compile('^python\s+macro\s+([a-zA-Z0-9_]+)\s*\(([^)]*)\)\s*=\s*([^;]*);$')
 180
 181 def ReadMacros(lines):
 182   constants = { }
 183   macros = { }
 184   for line in lines:
 185     hash = line.find('#')
 186     if hash != -1: line = line[:hash]
 187     line = line.strip()
 188     if len(line) is 0: continue
 189     const_match = CONST_PATTERN.match(line)
 190     if const_match:
 191       name = const_match.group(1)
 192       value = const_match.group(2).strip()
 193       constants[name] = value
 194     else:
 195       macro_match = MACRO_PATTERN.match(line)
 196       if macro_match:
 197         name = macro_match.group(1)
 198         args = map(string.strip, macro_match.group(2).split(','))
 199         body = macro_match.group(3).strip()
 200         macros[name] = TextMacro(args, body)
 201       else:
 202         python_match = PYTHON_MACRO_PATTERN.match(line)
 203         if python_match:
 204           name = python_match.group(1)
 205           args = map(string.strip, python_match.group(2).split(','))
 206           body = python_match.group(3).strip()
 207           fun = eval("lambda " + ",".join(args) + ': ' + body)
 208           macros[name] = PythonMacro(args, fun)
 209         else:
 210           raise Exception("Illegal line: " + line)
 211   return (constants, macros)
 212
 213
 214 HEADER_TEMPLATE = """\
 215 #ifndef node_natives_h
 216 #define node_natives_h
 217 namespace node {
 218
 219 %(source_lines)s\
 220
 221 struct _native {
 222   const char* name;
 223   const char* source;
 224   size_t source_len;
 225 };
 226
 227 static const struct _native natives[] = {
 228
 229 %(native_lines)s\
 230
 231   { NULL, NULL, 0 } /* sentinel */
 232
 233 };
 234
 235 }
 236 #endif
 237 """
 238
 239
 240 NATIVE_DECLARATION = """\
 241   { "%(id)s", %(id)s_native, sizeof(%(id)s_native)-1 },
 242 """
 243
 244 SOURCE_DECLARATION = """\
 245   const char %(id)s_native[] = { %(data)s };
 246 """
 247
 248
 249 GET_DELAY_INDEX_CASE = """\
 250     if (strcmp(name, "%(id)s") == 0) return %(i)i;
 251 """
 252
 253
 254 GET_DELAY_SCRIPT_SOURCE_CASE = """\
 255     if (index == %(i)i) return Vector<const char>(%(id)s, %(length)i);
 256 """
 257
 258
 259 GET_DELAY_SCRIPT_NAME_CASE = """\
 260     if (index == %(i)i) return Vector<const char>("%(name)s", %(length)i);
 261 """
 262
 263 def JS2C(source, target):
 264   ids = []
 265   delay_ids = []
 266   modules = []
 267   # Locate the macros file name.
 268   consts = {}
 269   macros = {}
 270   macro_lines = []
 271
 272   for s in source:
 273     if (os.path.split(str(s))[1]).endswith('macros.py'):
 274       macro_lines.extend(ReadLines(str(s)))
 275     else:
 276       modules.append(s)
 277
 278   # Process input from all *macro.py files
 279   (consts, macros) = ReadMacros(macro_lines)
 280
 281   # Build source code lines
 282   source_lines = [ ]
 283   source_lines_empty = []
 284
 285   native_lines = []
 286
 287   for s in modules:
 288     delay = str(s).endswith('-delay.js')
 289     lines = ReadFile(str(s))
 290     do_jsmin = lines.find('// jsminify this file, js2c: jsmin') != -1
 291
 292     lines = ExpandConstants(lines, consts)
 293     lines = ExpandMacros(lines, macros)
 294     lines = CompressScript(lines, do_jsmin)
 295     data = ToCArray(s, lines)
 296     id = os.path.basename(str(s)).split('.')[0]
 297     if delay: id = id[:-6]
 298     if delay:
 299       delay_ids.append((id, len(lines)))
 300     else:
 301       ids.append((id, len(lines)))
 302     source_lines.append(SOURCE_DECLARATION % { 'id': id, 'data': data })
 303     source_lines_empty.append(SOURCE_DECLARATION % { 'id': id, 'data': 0 })
 304     native_lines.append(NATIVE_DECLARATION % { 'id': id })
 305
 306   # Build delay support functions
 307   get_index_cases = [ ]
 308   get_script_source_cases = [ ]
 309   get_script_name_cases = [ ]
 310
 311   i = 0
 312   for (id, length) in delay_ids:
 313     native_name = "native %s.js" % id
 314     get_index_cases.append(GET_DELAY_INDEX_CASE % { 'id': id, 'i': i })
 315     get_script_source_cases.append(GET_DELAY_SCRIPT_SOURCE_CASE % {
 316       'id': id,
 317       'length': length,
 318       'i': i
 319     })
 320     get_script_name_cases.append(GET_DELAY_SCRIPT_NAME_CASE % {
 321       'name': native_name,
 322       'length': len(native_name),
 323       'i': i
 324     });
 325     i = i + 1
 326
 327   for (id, length) in ids:
 328     native_name = "native %s.js" % id
 329     get_index_cases.append(GET_DELAY_INDEX_CASE % { 'id': id, 'i': i })
 330     get_script_source_cases.append(GET_DELAY_SCRIPT_SOURCE_CASE % {
 331       'id': id,
 332       'length': length,
 333       'i': i
 334     })
 335     get_script_name_cases.append(GET_DELAY_SCRIPT_NAME_CASE % {
 336       'name': native_name,
 337       'length': len(native_name),
 338       'i': i
 339     });
 340     i = i + 1
 341
 342   # Emit result
 343   output = open(str(target[0]), "w")
 344   output.write(HEADER_TEMPLATE % {
 345     'builtin_count': len(ids) + len(delay_ids),
 346     'delay_count': len(delay_ids),
 347     'source_lines': "\n".join(source_lines),
 348     'native_lines': "\n".join(native_lines),
 349     'get_index_cases': "".join(get_index_cases),
 350     'get_script_source_cases': "".join(get_script_source_cases),
 351     'get_script_name_cases': "".join(get_script_name_cases)
 352   })
 353   output.close()
 354
 355   if len(target) > 1:
 356     output = open(str(target[1]), "w")
 357     output.write(HEADER_TEMPLATE % {
 358       'builtin_count': len(ids) + len(delay_ids),
 359       'delay_count': len(delay_ids),
 360       'source_lines': "\n".join(source_lines_empty),
 361       'get_index_cases': "".join(get_index_cases),
 362       'get_script_source_cases': "".join(get_script_source_cases),
 363       'get_script_name_cases': "".join(get_script_name_cases)
 364     })
 365     output.close()
 366
 367 def main():
 368   natives = sys.argv[1]
 369   source_files = sys.argv[2:]
 370   JS2C(source_files, [natives])
 371
 372 if __name__ == "__main__":
 373   main()