• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1#!/usr/bin/env python
2#
3# Copyright 2012 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
34import os, re, sys, string
35import optparse
36import jsmin
37import bz2
38import textwrap
39
40
41class Error(Exception):
42  def __init__(self, msg):
43    Exception.__init__(self, msg)
44
45
46def ToCArray(byte_sequence):
47  result = []
48  for chr in byte_sequence:
49    result.append(str(ord(chr)))
50  joined = ", ".join(result)
51  return textwrap.fill(joined, 80)
52
53
54def RemoveCommentsAndTrailingWhitespace(lines):
55  lines = re.sub(r'//.*\n', '\n', lines) # end-of-line comments
56  lines = re.sub(re.compile(r'/\*.*?\*/', re.DOTALL), '', lines) # comments.
57  lines = re.sub(r'\s+\n+', '\n', lines) # trailing whitespace
58  return lines
59
60
61def ReadFile(filename):
62  file = open(filename, "rt")
63  try:
64    lines = file.read()
65  finally:
66    file.close()
67  return lines
68
69
70EVAL_PATTERN = re.compile(r'\beval\s*\(')
71WITH_PATTERN = re.compile(r'\bwith\s*\(')
72
73def Validate(lines):
74  # Because of simplified context setup, eval and with is not
75  # allowed in the natives files.
76  if EVAL_PATTERN.search(lines):
77    raise Error("Eval disallowed in natives.")
78  if WITH_PATTERN.search(lines):
79    raise Error("With statements disallowed in natives.")
80
81  # Pass lines through unchanged.
82  return lines
83
84
85def ExpandConstants(lines, constants):
86  for key, value in constants:
87    lines = key.sub(str(value), lines)
88  return lines
89
90
91def ExpandMacroDefinition(lines, pos, name_pattern, macro, expander):
92  pattern_match = name_pattern.search(lines, pos)
93  while pattern_match is not None:
94    # Scan over the arguments
95    height = 1
96    start = pattern_match.start()
97    end = pattern_match.end()
98    assert lines[end - 1] == '('
99    last_match = end
100    arg_index = [0]  # Wrap state into array, to work around Python "scoping"
101    mapping = { }
102    def add_arg(str):
103      # Remember to expand recursively in the arguments
104      replacement = expander(str.strip())
105      mapping[macro.args[arg_index[0]]] = replacement
106      arg_index[0] += 1
107    while end < len(lines) and height > 0:
108      # We don't count commas at higher nesting levels.
109      if lines[end] == ',' and height == 1:
110        add_arg(lines[last_match:end])
111        last_match = end + 1
112      elif lines[end] in ['(', '{', '[']:
113        height = height + 1
114      elif lines[end] in [')', '}', ']']:
115        height = height - 1
116      end = end + 1
117    # Remember to add the last match.
118    add_arg(lines[last_match:end-1])
119    result = macro.expand(mapping)
120    # Replace the occurrence of the macro with the expansion
121    lines = lines[:start] + result + lines[end:]
122    pattern_match = name_pattern.search(lines, start + len(result))
123  return lines
124
125def ExpandMacros(lines, macros):
126  # We allow macros to depend on the previously declared macros, but
127  # we don't allow self-dependecies or recursion.
128  for name_pattern, macro in reversed(macros):
129    def expander(s):
130      return ExpandMacros(s, macros)
131    lines = ExpandMacroDefinition(lines, 0, name_pattern, macro, expander)
132  return lines
133
134class TextMacro:
135  def __init__(self, args, body):
136    self.args = args
137    self.body = body
138  def expand(self, mapping):
139    result = self.body
140    for key, value in mapping.items():
141        result = result.replace(key, value)
142    return result
143
144class PythonMacro:
145  def __init__(self, args, fun):
146    self.args = args
147    self.fun = fun
148  def expand(self, mapping):
149    args = []
150    for arg in self.args:
151      args.append(mapping[arg])
152    return str(self.fun(*args))
153
154CONST_PATTERN = re.compile(r'^const\s+([a-zA-Z0-9_]+)\s*=\s*([^;]*);$')
155MACRO_PATTERN = re.compile(r'^macro\s+([a-zA-Z0-9_]+)\s*\(([^)]*)\)\s*=\s*([^;]*);$')
156PYTHON_MACRO_PATTERN = re.compile(r'^python\s+macro\s+([a-zA-Z0-9_]+)\s*\(([^)]*)\)\s*=\s*([^;]*);$')
157
158
159def ReadMacros(lines):
160  constants = []
161  macros = []
162  for line in lines.split('\n'):
163    hash = line.find('#')
164    if hash != -1: line = line[:hash]
165    line = line.strip()
166    if len(line) is 0: continue
167    const_match = CONST_PATTERN.match(line)
168    if const_match:
169      name = const_match.group(1)
170      value = const_match.group(2).strip()
171      constants.append((re.compile("\\b%s\\b" % name), value))
172    else:
173      macro_match = MACRO_PATTERN.match(line)
174      if macro_match:
175        name = macro_match.group(1)
176        args = [match.strip() for match in macro_match.group(2).split(',')]
177        body = macro_match.group(3).strip()
178        macros.append((re.compile("\\b%s\\(" % name), TextMacro(args, body)))
179      else:
180        python_match = PYTHON_MACRO_PATTERN.match(line)
181        if python_match:
182          name = python_match.group(1)
183          args = [match.strip() for match in python_match.group(2).split(',')]
184          body = python_match.group(3).strip()
185          fun = eval("lambda " + ",".join(args) + ': ' + body)
186          macros.append((re.compile("\\b%s\\(" % name), PythonMacro(args, fun)))
187        else:
188          raise Error("Illegal line: " + line)
189  return (constants, macros)
190
191INLINE_MACRO_PATTERN = re.compile(r'macro\s+([a-zA-Z0-9_]+)\s*\(([^)]*)\)\s*\n')
192INLINE_MACRO_END_PATTERN = re.compile(r'endmacro\s*\n')
193
194def ExpandInlineMacros(lines):
195  pos = 0
196  while True:
197    macro_match = INLINE_MACRO_PATTERN.search(lines, pos)
198    if macro_match is None:
199      # no more macros
200      return lines
201    name = macro_match.group(1)
202    args = [match.strip() for match in macro_match.group(2).split(',')]
203    end_macro_match = INLINE_MACRO_END_PATTERN.search(lines, macro_match.end());
204    if end_macro_match is None:
205      raise Error("Macro %s unclosed" % name)
206    body = lines[macro_match.end():end_macro_match.start()]
207
208    # remove macro definition
209    lines = lines[:macro_match.start()] + lines[end_macro_match.end():]
210    name_pattern = re.compile("\\b%s\\(" % name)
211    macro = TextMacro(args, body)
212
213    # advance position to where the macro defintion was
214    pos = macro_match.start()
215
216    def non_expander(s):
217      return s
218    lines = ExpandMacroDefinition(lines, pos, name_pattern, macro, non_expander)
219
220
221HEADER_TEMPLATE = """\
222// Copyright 2011 Google Inc. All Rights Reserved.
223
224// This file was generated from .js source files by GYP.  If you
225// want to make changes to this file you should either change the
226// javascript source files or the GYP script.
227
228#include "src/v8.h"
229#include "src/natives.h"
230#include "src/utils.h"
231
232namespace v8 {
233namespace internal {
234
235%(sources_declaration)s\
236
237%(raw_sources_declaration)s\
238
239  template <>
240  int NativesCollection<%(type)s>::GetBuiltinsCount() {
241    return %(builtin_count)i;
242  }
243
244  template <>
245  int NativesCollection<%(type)s>::GetDebuggerCount() {
246    return %(debugger_count)i;
247  }
248
249  template <>
250  int NativesCollection<%(type)s>::GetIndex(const char* name) {
251%(get_index_cases)s\
252    return -1;
253  }
254
255  template <>
256  int NativesCollection<%(type)s>::GetRawScriptsSize() {
257    return %(raw_total_length)i;
258  }
259
260  template <>
261  Vector<const char> NativesCollection<%(type)s>::GetRawScriptSource(int index) {
262%(get_raw_script_source_cases)s\
263    return Vector<const char>("", 0);
264  }
265
266  template <>
267  Vector<const char> NativesCollection<%(type)s>::GetScriptName(int index) {
268%(get_script_name_cases)s\
269    return Vector<const char>("", 0);
270  }
271
272  template <>
273  Vector<const byte> NativesCollection<%(type)s>::GetScriptsSource() {
274    return Vector<const byte>(sources, %(total_length)i);
275  }
276
277  template <>
278  void NativesCollection<%(type)s>::SetRawScriptsSource(Vector<const char> raw_source) {
279    ASSERT(%(raw_total_length)i == raw_source.length());
280    raw_sources = raw_source.start();
281  }
282
283}  // internal
284}  // v8
285"""
286
287SOURCES_DECLARATION = """\
288  static const byte sources[] = { %s };
289"""
290
291
292RAW_SOURCES_COMPRESSION_DECLARATION = """\
293  static const char* raw_sources = NULL;
294"""
295
296
297RAW_SOURCES_DECLARATION = """\
298  static const char* raw_sources = reinterpret_cast<const char*>(sources);
299"""
300
301
302GET_INDEX_CASE = """\
303    if (strcmp(name, "%(id)s") == 0) return %(i)i;
304"""
305
306
307GET_RAW_SCRIPT_SOURCE_CASE = """\
308    if (index == %(i)i) return Vector<const char>(raw_sources + %(offset)i, %(raw_length)i);
309"""
310
311
312GET_SCRIPT_NAME_CASE = """\
313    if (index == %(i)i) return Vector<const char>("%(name)s", %(length)i);
314"""
315
316
317def BuildFilterChain(macro_filename):
318  """Build the chain of filter functions to be applied to the sources.
319
320  Args:
321    macro_filename: Name of the macro file, if any.
322
323  Returns:
324    A function (string -> string) that reads a source file and processes it.
325  """
326  filter_chain = [ReadFile]
327
328  if macro_filename:
329    (consts, macros) = ReadMacros(ReadFile(macro_filename))
330    filter_chain.append(lambda l: ExpandConstants(l, consts))
331    filter_chain.append(lambda l: ExpandMacros(l, macros))
332
333  filter_chain.extend([
334    RemoveCommentsAndTrailingWhitespace,
335    ExpandInlineMacros,
336    Validate,
337    jsmin.JavaScriptMinifier().JSMinify
338  ])
339
340  def chain(f1, f2):
341    return lambda x: f2(f1(x))
342
343  return reduce(chain, filter_chain)
344
345
346class Sources:
347  def __init__(self):
348    self.names = []
349    self.modules = []
350    self.is_debugger_id = []
351
352
353def IsDebuggerFile(filename):
354  return filename.endswith("-debugger.js")
355
356def IsMacroFile(filename):
357  return filename.endswith("macros.py")
358
359
360def PrepareSources(source_files):
361  """Read, prepare and assemble the list of source files.
362
363  Args:
364    sources: List of Javascript-ish source files. A file named macros.py
365        will be treated as a list of macros.
366
367  Returns:
368    An instance of Sources.
369  """
370  macro_file = None
371  macro_files = filter(IsMacroFile, source_files)
372  assert len(macro_files) in [0, 1]
373  if macro_files:
374    source_files.remove(macro_files[0])
375    macro_file = macro_files[0]
376
377  filters = BuildFilterChain(macro_file)
378
379  # Sort 'debugger' sources first.
380  source_files = sorted(source_files,
381                        lambda l,r: IsDebuggerFile(r) - IsDebuggerFile(l))
382
383  result = Sources()
384  for source in source_files:
385    try:
386      lines = filters(source)
387    except Error as e:
388      raise Error("In file %s:\n%s" % (source, str(e)))
389
390    result.modules.append(lines);
391
392    is_debugger = IsDebuggerFile(source)
393    result.is_debugger_id.append(is_debugger);
394
395    name = os.path.basename(source)[:-3]
396    result.names.append(name if not is_debugger else name[:-9]);
397  return result
398
399
400def BuildMetadata(sources, source_bytes, native_type, omit):
401  """Build the meta data required to generate a libaries file.
402
403  Args:
404    sources: A Sources instance with the prepared sources.
405    source_bytes: A list of source bytes.
406        (The concatenation of all sources; might be compressed.)
407    native_type: The parameter for the NativesCollection template.
408    omit: bool, whether we should omit the sources in the output.
409
410  Returns:
411    A dictionary for use with HEADER_TEMPLATE.
412  """
413  total_length = len(source_bytes)
414  raw_sources = "".join(sources.modules)
415
416  # The sources are expected to be ASCII-only.
417  assert not filter(lambda value: ord(value) >= 128, raw_sources)
418
419  # Loop over modules and build up indices into the source blob:
420  get_index_cases = []
421  get_script_name_cases = []
422  get_raw_script_source_cases = []
423  offset = 0
424  for i in xrange(len(sources.modules)):
425    native_name = "native %s.js" % sources.names[i]
426    d = {
427        "i": i,
428        "id": sources.names[i],
429        "name": native_name,
430        "length": len(native_name),
431        "offset": offset,
432        "raw_length": len(sources.modules[i]),
433    }
434    get_index_cases.append(GET_INDEX_CASE % d)
435    get_script_name_cases.append(GET_SCRIPT_NAME_CASE % d)
436    get_raw_script_source_cases.append(GET_RAW_SCRIPT_SOURCE_CASE % d)
437    offset += len(sources.modules[i])
438  assert offset == len(raw_sources)
439
440  # If we have the raw sources we can declare them accordingly.
441  have_raw_sources = source_bytes == raw_sources and not omit
442  raw_sources_declaration = (RAW_SOURCES_DECLARATION
443      if have_raw_sources else RAW_SOURCES_COMPRESSION_DECLARATION)
444
445  metadata = {
446    "builtin_count": len(sources.modules),
447    "debugger_count": sum(sources.is_debugger_id),
448    "sources_declaration": SOURCES_DECLARATION % ToCArray(source_bytes),
449    "sources_data": ToCArray(source_bytes) if not omit else "",
450    "raw_sources_declaration": raw_sources_declaration,
451    "raw_total_length": sum(map(len, sources.modules)),
452    "total_length": total_length,
453    "get_index_cases": "".join(get_index_cases),
454    "get_raw_script_source_cases": "".join(get_raw_script_source_cases),
455    "get_script_name_cases": "".join(get_script_name_cases),
456    "type": native_type,
457  }
458  return metadata
459
460
461def CompressMaybe(sources, compression_type):
462  """Take the prepared sources and generate a sequence of bytes.
463
464  Args:
465    sources: A Sources instance with the prepared sourced.
466    compression_type: string, describing the desired compression.
467
468  Returns:
469    A sequence of bytes.
470  """
471  sources_bytes = "".join(sources.modules)
472  if compression_type == "off":
473    return sources_bytes
474  elif compression_type == "bz2":
475    return bz2.compress(sources_bytes)
476  else:
477    raise Error("Unknown compression type %s." % compression_type)
478
479
480def JS2C(source, target, native_type, compression_type, raw_file, omit):
481  sources = PrepareSources(source)
482  sources_bytes = CompressMaybe(sources, compression_type)
483  metadata = BuildMetadata(sources, sources_bytes, native_type, omit)
484
485  # Optionally emit raw file.
486  if raw_file:
487    output = open(raw_file, "w")
488    output.write(sources_bytes)
489    output.close()
490
491  # Emit resulting source file.
492  output = open(target, "w")
493  output.write(HEADER_TEMPLATE % metadata)
494  output.close()
495
496
497def main():
498  parser = optparse.OptionParser()
499  parser.add_option("--raw", action="store",
500                      help="file to write the processed sources array to.")
501  parser.add_option("--omit", dest="omit", action="store_true",
502                    help="Omit the raw sources from the generated code.")
503  parser.set_usage("""js2c out.cc type compression sources.js ...
504      out.cc: C code to be generated.
505      type: type parameter for NativesCollection template.
506      compression: type of compression used. [off|bz2]
507      sources.js: JS internal sources or macros.py.""")
508  (options, args) = parser.parse_args()
509
510  JS2C(args[3:], args[0], args[1], args[2], options.raw, options.omit)
511
512
513if __name__ == "__main__":
514  main()
515