OLD | NEW |
| (Empty) |
1 # Copyright (C) 2013 Google Inc. All rights reserved. | |
2 # | |
3 # Redistribution and use in source and binary forms, with or without | |
4 # modification, are permitted provided that the following conditions are | |
5 # met: | |
6 # | |
7 # * Redistributions of source code must retain the above copyright | |
8 # notice, this list of conditions and the following disclaimer. | |
9 # * Redistributions in binary form must reproduce the above | |
10 # copyright notice, this list of conditions and the following disclaimer | |
11 # in the documentation and/or other materials provided with the | |
12 # distribution. | |
13 # * Neither the name of Google Inc. nor the names of its | |
14 # contributors may be used to endorse or promote products derived from | |
15 # this software without specific prior written permission. | |
16 # | |
17 # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | |
18 # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | |
19 # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | |
20 # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT | |
21 # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | |
22 # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT | |
23 # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, | |
24 # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY | |
25 # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | |
26 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | |
27 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
28 | |
29 """Generate Blink C++ bindings (.h and .cpp files) for use by Dart:HTML. | |
30 | |
31 If run itself, caches Jinja templates (and creates dummy file for build, | |
32 since cache filenames are unpredictable and opaque). | |
33 | |
34 This module is *not* concurrency-safe without care: bytecode caching creates | |
35 a race condition on cache *write* (crashes if one process tries to read a | |
36 partially-written cache). However, if you pre-cache the templates (by running | |
37 the module itself), then you can parallelize compiling individual files, since | |
38 cache *reading* is safe. | |
39 | |
40 Input: An object of class IdlDefinitions, containing an IDL interface X | |
41 Output: DartX.h and DartX.cpp | |
42 | |
43 Design doc: http://www.chromium.org/developers/design-documents/idl-compiler | |
44 """ | |
45 | |
46 import os | |
47 import cPickle as pickle | |
48 import re | |
49 import sys | |
50 | |
51 | |
52 # Path handling for libraries and templates | |
53 # Paths have to be normalized because Jinja uses the exact template path to | |
54 # determine the hash used in the cache filename, and we need a pre-caching step | |
55 # to be concurrency-safe. Use absolute path because __file__ is absolute if | |
56 # module is imported, and relative if executed directly. | |
57 # If paths differ between pre-caching and individual file compilation, the cache | |
58 # is regenerated, which causes a race condition and breaks concurrent build, | |
59 # since some compile processes will try to read the partially written cache. | |
60 module_path, module_filename = os.path.split(os.path.realpath(__file__)) | |
61 third_party_dir = os.path.normpath(os.path.join( | |
62 module_path, os.pardir, os.pardir, os.pardir, os.pardir, os.pardir)) | |
63 templates_dir = os.path.normpath(os.path.join(module_path, 'templates')) | |
64 | |
65 # Make sure extension is .py, not .pyc or .pyo, so doesn't depend on caching | |
66 module_pyname = os.path.splitext(module_filename)[0] + '.py' | |
67 | |
68 # jinja2 is in chromium's third_party directory. | |
69 # Insert at 1 so at front to override system libraries, and | |
70 # after path[0] == invoking script dir | |
71 sys.path.insert(1, third_party_dir) | |
72 | |
73 # Add the base compiler scripts to the path here as in compiler.py | |
74 dart_script_path = os.path.dirname(os.path.abspath(__file__)) | |
75 script_path = os.path.join(os.path.dirname(os.path.dirname(dart_script_path)), | |
76 'scripts') | |
77 sys.path.extend([script_path]) | |
78 | |
79 import jinja2 | |
80 | |
81 import idl_types | |
82 from idl_types import IdlType | |
83 from utilities import write_pickle_file | |
84 from v8_globals import includes, interfaces | |
85 from dart_utilities import DartUtilities | |
86 | |
87 | |
88 # TODO(jacobr): remove this hacked together list. | |
89 INTERFACES_WITHOUT_RESOLVERS = frozenset([ | |
90 'TypeConversions', | |
91 'GCObservation', | |
92 'InternalProfilers', | |
93 'InternalRuntimeFlags', | |
94 'InternalSettings', | |
95 'InternalSettingsGenerated', | |
96 'Internals', | |
97 'LayerRect', | |
98 'LayerRectList', | |
99 'MallocStatistics', | |
100 'TypeConversions']) | |
101 | |
102 class CodeGeneratorDart(object): | |
103 def __init__(self, interfaces_info, cache_dir): | |
104 interfaces_info = interfaces_info or {} | |
105 self.interfaces_info = interfaces_info | |
106 self.jinja_env = initialize_jinja_env(cache_dir) | |
107 | |
108 # Set global type info | |
109 idl_types.set_ancestors(dict( | |
110 (interface_name, interface_info['ancestors']) | |
111 for interface_name, interface_info in interfaces_info.iteritems() | |
112 if interface_info['ancestors'])) | |
113 IdlType.set_callback_interfaces(set( | |
114 interface_name | |
115 for interface_name, interface_info in interfaces_info.iteritems() | |
116 if interface_info['is_callback_interface'])) | |
117 IdlType.set_implemented_as_interfaces(dict( | |
118 (interface_name, interface_info['implemented_as']) | |
119 for interface_name, interface_info in interfaces_info.iteritems() | |
120 if interface_info['implemented_as'])) | |
121 IdlType.set_garbage_collected_types(set( | |
122 interface_name | |
123 for interface_name, interface_info in interfaces_info.iteritems() | |
124 if 'GarbageCollected' in interface_info['inherited_extended_attribut
es'])) | |
125 IdlType.set_will_be_garbage_collected_types(set( | |
126 interface_name | |
127 for interface_name, interface_info in interfaces_info.iteritems() | |
128 if 'WillBeGarbageCollected' in interface_info['inherited_extended_at
tributes'])) | |
129 | |
130 def generate_code(self, definitions, interface_name, idl_pickle_filename, | |
131 only_if_changed): | |
132 """Returns .h/.cpp code as (header_text, cpp_text).""" | |
133 try: | |
134 interface = definitions.interfaces[interface_name] | |
135 except KeyError: | |
136 raise Exception('%s not in IDL definitions' % interface_name) | |
137 | |
138 # Store other interfaces for introspection | |
139 interfaces.update(definitions.interfaces) | |
140 | |
141 # Set local type info | |
142 IdlType.set_callback_functions(definitions.callback_functions.keys()) | |
143 IdlType.set_enums((enum.name, enum.values) | |
144 for enum in definitions.enumerations.values()) | |
145 | |
146 # Select appropriate Jinja template and contents function | |
147 if interface.is_callback: | |
148 header_template_filename = 'callback_interface_h.template' | |
149 cpp_template_filename = 'callback_interface_cpp.template' | |
150 generate_contents = dart_callback_interface.generate_callback_interf
ace | |
151 else: | |
152 header_template_filename = 'interface_h.template' | |
153 cpp_template_filename = 'interface_cpp.template' | |
154 generate_contents = dart_interface.generate_interface | |
155 header_template = self.jinja_env.get_template(header_template_filename) | |
156 cpp_template = self.jinja_env.get_template(cpp_template_filename) | |
157 | |
158 # Generate contents (input parameters for Jinja) | |
159 template_contents = generate_contents(interface) | |
160 template_contents['code_generator'] = module_pyname | |
161 | |
162 # Add includes for interface itself and any dependencies | |
163 interface_info = self.interfaces_info[interface_name] | |
164 template_contents['header_includes'].add(interface_info['include_path']) | |
165 template_contents['header_includes'] = sorted(template_contents['header_
includes']) | |
166 includes.update(interface_info.get('dependencies_include_paths', [])) | |
167 | |
168 # Remove includes that are not needed for Dart and trigger fatal | |
169 # compile warnings if included. These IDL files need to be | |
170 # imported by Dart to generate the list of events but the | |
171 # associated header files do not contain any code used by Dart. | |
172 includes.discard('core/dom/GlobalEventHandlers.h') | |
173 includes.discard('core/frame/DOMWindowEventHandlers.h') | |
174 | |
175 template_contents['cpp_includes'] = sorted(includes) | |
176 | |
177 idl_world = {'interface': None, 'callback': None} | |
178 | |
179 # Load the pickle file for this IDL. | |
180 if os.path.isfile(idl_pickle_filename): | |
181 with open(idl_pickle_filename) as idl_pickle_file: | |
182 idl_global_data = pickle.load(idl_pickle_file) | |
183 idl_pickle_file.close() | |
184 idl_world['interface'] = idl_global_data['interface'] | |
185 idl_world['callback'] = idl_global_data['callback'] | |
186 | |
187 if 'interface_name' in template_contents: | |
188 interface_global = {'name': template_contents['interface_name'], | |
189 'parent_interface': template_contents['parent_in
terface'], | |
190 'is_active_dom_object': template_contents['is_ac
tive_dom_object'], | |
191 'is_event_target': template_contents['is_event_t
arget'], | |
192 'has_resolver': template_contents['interface_nam
e'] not in INTERFACES_WITHOUT_RESOLVERS, | |
193 'is_node': template_contents['is_node'], | |
194 'conditional_string': template_contents['conditi
onal_string'], | |
195 } | |
196 idl_world['interface'] = interface_global | |
197 else: | |
198 callback_global = {'name': template_contents['cpp_class']} | |
199 idl_world['callback'] = callback_global | |
200 | |
201 write_pickle_file(idl_pickle_filename, idl_world, only_if_changed) | |
202 | |
203 # Render Jinja templates | |
204 header_text = header_template.render(template_contents) | |
205 cpp_text = cpp_template.render(template_contents) | |
206 return header_text, cpp_text | |
207 | |
208 # Generates global file for all interfaces. | |
209 def generate_globals(self, output_directory): | |
210 header_template_filename = 'global_h.template' | |
211 cpp_template_filename = 'global_cpp.template' | |
212 | |
213 # Delete the global pickle file we'll rebuild from each pickle generated | |
214 # for each IDL file '(%s_globals.pickle) % interface_name'. | |
215 global_pickle_filename = os.path.join(output_directory, 'global.pickle') | |
216 if os.path.isfile(global_pickle_filename): | |
217 os.remove(global_pickle_filename) | |
218 | |
219 # List of all interfaces and callbacks for global code generation. | |
220 world = {'interfaces': [], 'callbacks': []} | |
221 | |
222 # Load all pickled data for each interface. | |
223 listing = os.listdir(output_directory) | |
224 for filename in listing: | |
225 if filename.endswith('_globals.pickle'): | |
226 idl_filename = os.path.join(output_directory, filename) | |
227 with open(idl_filename) as idl_pickle_file: | |
228 idl_world = pickle.load(idl_pickle_file) | |
229 if 'interface' in idl_world: | |
230 # FIXME: Why are some of these None? | |
231 if idl_world['interface']: | |
232 world['interfaces'].append(idl_world['interface']) | |
233 if 'callbacks' in idl_world: | |
234 # FIXME: Why are some of these None? | |
235 if idl_world['callbacks']: | |
236 world['callbacks'].append(idl_world['callback']) | |
237 idl_pickle_file.close() | |
238 | |
239 world['interfaces'] = sorted(world['interfaces'], key=lambda (x): x['nam
e']) | |
240 world['callbacks'] = sorted(world['callbacks'], key=lambda (x): x['name'
]) | |
241 | |
242 template_contents = world | |
243 template_contents['code_generator'] = module_pyname | |
244 | |
245 header_template = self.jinja_env.get_template(header_template_filename) | |
246 header_text = header_template.render(template_contents) | |
247 | |
248 cpp_template = self.jinja_env.get_template(cpp_template_filename) | |
249 cpp_text = cpp_template.render(template_contents) | |
250 return header_text, cpp_text | |
251 | |
252 | |
253 def initialize_jinja_env(cache_dir): | |
254 jinja_env = jinja2.Environment( | |
255 loader=jinja2.FileSystemLoader(templates_dir), | |
256 # Bytecode cache is not concurrency-safe unless pre-cached: | |
257 # if pre-cached this is read-only, but writing creates a race condition. | |
258 bytecode_cache=jinja2.FileSystemBytecodeCache(cache_dir), | |
259 keep_trailing_newline=True, # newline-terminate generated files | |
260 lstrip_blocks=True, # so can indent control flow tags | |
261 trim_blocks=True) | |
262 jinja_env.filters.update({ | |
263 'blink_capitalize': DartUtilities.capitalize, | |
264 'conditional': conditional_if_endif, | |
265 'runtime_enabled': runtime_enabled_if, | |
266 }) | |
267 return jinja_env | |
268 | |
269 | |
270 # [Conditional] | |
271 def conditional_if_endif(code, conditional_string): | |
272 # Jinja2 filter to generate if/endif directive blocks | |
273 if not conditional_string: | |
274 return code | |
275 return ('#if %s\n' % conditional_string + | |
276 code + | |
277 '#endif // %s\n' % conditional_string) | |
278 | |
279 | |
280 # [RuntimeEnabled] | |
281 def runtime_enabled_if(code, runtime_enabled_function_name): | |
282 if not runtime_enabled_function_name: | |
283 return code | |
284 # Indent if statement to level of original code | |
285 indent = re.match(' *', code).group(0) | |
286 return ('%sif (%s())\n' % (indent, runtime_enabled_function_name) + | |
287 ' %s' % code) | |
288 | |
289 | |
290 ################################################################################ | |
291 | |
292 def main(argv): | |
293 # If file itself executed, cache templates | |
294 try: | |
295 cache_dir = argv[1] | |
296 dummy_filename = argv[2] | |
297 except IndexError as err: | |
298 print 'Usage: %s OUTPUT_DIR DUMMY_FILENAME' % argv[0] | |
299 return 1 | |
300 | |
301 # Cache templates | |
302 jinja_env = initialize_jinja_env(cache_dir) | |
303 template_filenames = [filename for filename in os.listdir(templates_dir) | |
304 # Skip .svn, directories, etc. | |
305 if filename.endswith(('.cpp', '.h', '.template'))] | |
306 for template_filename in template_filenames: | |
307 jinja_env.get_template(template_filename) | |
308 | |
309 # Create a dummy file as output for the build system, | |
310 # since filenames of individual cache files are unpredictable and opaque | |
311 # (they are hashes of the template path, which varies based on environment) | |
312 with open(dummy_filename, 'w') as dummy_file: | |
313 pass # |open| creates or touches the file | |
314 | |
315 | |
316 if __name__ == '__main__': | |
317 sys.exit(main(sys.argv)) | |
OLD | NEW |