OLD | NEW |
| (Empty) |
1 # Copyright 2016 The Chromium Authors. All rights reserved. | |
2 # Use of this source code is governed by a BSD-style license that can be | |
3 # found in the LICENSE file. | |
4 | |
5 import os.path | |
6 import sys | |
7 import optparse | |
8 import collections | |
9 import functools | |
10 try: | |
11 import json | |
12 except ImportError: | |
13 import simplejson as json | |
14 | |
15 # Path handling for libraries and templates | |
16 # Paths have to be normalized because Jinja uses the exact template path to | |
17 # determine the hash used in the cache filename, and we need a pre-caching step | |
18 # to be concurrency-safe. Use absolute path because __file__ is absolute if | |
19 # module is imported, and relative if executed directly. | |
20 # If paths differ between pre-caching and individual file compilation, the cache | |
21 # is regenerated, which causes a race condition and breaks concurrent build, | |
22 # since some compile processes will try to read the partially written cache. | |
23 module_path, module_filename = os.path.split(os.path.realpath(__file__)) | |
24 | |
25 def read_config(): | |
26 # pylint: disable=W0703 | |
27 def json_to_object(data, output_base, config_base): | |
28 def json_object_hook(object_dict): | |
29 items = [(k, os.path.join(config_base, v) if k == "path" else v) for
(k, v) in object_dict.items()] | |
30 items = [(k, os.path.join(output_base, v) if k == "output" else v) f
or (k, v) in items] | |
31 keys, values = zip(*items) | |
32 return collections.namedtuple('X', keys)(*values) | |
33 return json.loads(data, object_hook=json_object_hook) | |
34 | |
35 def init_defaults(config_tuple, path, defaults): | |
36 keys = list(config_tuple._fields) # pylint: disable=E1101 | |
37 values = [getattr(config_tuple, k) for k in keys] | |
38 for i in xrange(len(keys)): | |
39 if hasattr(values[i], "_fields"): | |
40 values[i] = init_defaults(values[i], path + "." + keys[i], defau
lts) | |
41 for optional in defaults: | |
42 if optional.find(path + ".") != 0: | |
43 continue | |
44 optional_key = optional[len(path) + 1:] | |
45 if optional_key.find(".") == -1 and optional_key not in keys: | |
46 keys.append(optional_key) | |
47 values.append(defaults[optional]) | |
48 return collections.namedtuple('X', keys)(*values) | |
49 | |
50 try: | |
51 cmdline_parser = optparse.OptionParser() | |
52 cmdline_parser.add_option("--output_base") | |
53 cmdline_parser.add_option("--jinja_dir") | |
54 cmdline_parser.add_option("--config") | |
55 arg_options, _ = cmdline_parser.parse_args() | |
56 jinja_dir = arg_options.jinja_dir | |
57 if not jinja_dir: | |
58 raise Exception("jinja directory must be specified") | |
59 output_base = arg_options.output_base | |
60 if not output_base: | |
61 raise Exception("Base output directory must be specified") | |
62 config_file = arg_options.config | |
63 if not config_file: | |
64 raise Exception("Config file name must be specified") | |
65 config_base = os.path.dirname(config_file) | |
66 except Exception: | |
67 # Work with python 2 and 3 http://docs.python.org/py3k/howto/pyporting.h
tml | |
68 exc = sys.exc_info()[1] | |
69 sys.stderr.write("Failed to parse command-line arguments: %s\n\n" % exc) | |
70 exit(1) | |
71 | |
72 try: | |
73 config_json_file = open(config_file, "r") | |
74 config_json_string = config_json_file.read() | |
75 config_partial = json_to_object(config_json_string, output_base, config_
base) | |
76 config_json_file.close() | |
77 defaults = { | |
78 ".imported": False, | |
79 ".imported.export_macro": "", | |
80 ".imported.export_header": False, | |
81 ".imported.header": False, | |
82 ".imported.package": False, | |
83 ".protocol.export_macro": "", | |
84 ".protocol.export_header": False, | |
85 ".exported": False, | |
86 ".exported.export_macro": "", | |
87 ".exported.export_header": False, | |
88 ".lib": False, | |
89 ".lib.export_macro": "", | |
90 ".lib.export_header": False, | |
91 } | |
92 return (jinja_dir, config_file, init_defaults(config_partial, "", defaul
ts)) | |
93 except Exception: | |
94 # Work with python 2 and 3 http://docs.python.org/py3k/howto/pyporting.h
tml | |
95 exc = sys.exc_info()[1] | |
96 sys.stderr.write("Failed to parse config file: %s\n\n" % exc) | |
97 exit(1) | |
98 | |
99 | |
100 def to_title_case(name): | |
101 return name[:1].upper() + name[1:] | |
102 | |
103 | |
104 def dash_to_camelcase(word): | |
105 prefix = "" | |
106 if word[0] == "-": | |
107 prefix = "Negative" | |
108 word = word[1:] | |
109 return prefix + "".join(to_title_case(x) or "-" for x in word.split("-")) | |
110 | |
111 | |
112 def initialize_jinja_env(jinja_dir, cache_dir): | |
113 # pylint: disable=F0401 | |
114 sys.path.insert(1, os.path.abspath(jinja_dir)) | |
115 import jinja2 | |
116 | |
117 jinja_env = jinja2.Environment( | |
118 loader=jinja2.FileSystemLoader(module_path), | |
119 # Bytecode cache is not concurrency-safe unless pre-cached: | |
120 # if pre-cached this is read-only, but writing creates a race condition. | |
121 bytecode_cache=jinja2.FileSystemBytecodeCache(cache_dir), | |
122 keep_trailing_newline=True, # newline-terminate generated files | |
123 lstrip_blocks=True, # so can indent control flow tags | |
124 trim_blocks=True) | |
125 jinja_env.filters.update({"to_title_case": to_title_case, "dash_to_camelcase
": dash_to_camelcase}) | |
126 jinja_env.add_extension("jinja2.ext.loopcontrols") | |
127 return jinja_env | |
128 | |
129 | |
130 def patch_full_qualified_refs(protocol): | |
131 def patch_full_qualified_refs_in_domain(json, domain_name): | |
132 if isinstance(json, list): | |
133 for item in json: | |
134 patch_full_qualified_refs_in_domain(item, domain_name) | |
135 | |
136 if not isinstance(json, dict): | |
137 return | |
138 for key in json: | |
139 if key == "type" and json[key] == "string": | |
140 json[key] = domain_name + ".string" | |
141 if key != "$ref": | |
142 patch_full_qualified_refs_in_domain(json[key], domain_name) | |
143 continue | |
144 if json["$ref"].find(".") == -1: | |
145 json["$ref"] = domain_name + "." + json["$ref"] | |
146 return | |
147 | |
148 for domain in protocol.json_api["domains"]: | |
149 patch_full_qualified_refs_in_domain(domain, domain["domain"]) | |
150 | |
151 | |
152 def calculate_exports(protocol): | |
153 def calculate_exports_in_json(json_value): | |
154 has_exports = False | |
155 if isinstance(json_value, list): | |
156 for item in json_value: | |
157 has_exports = calculate_exports_in_json(item) or has_exports | |
158 if isinstance(json_value, dict): | |
159 has_exports = ("exported" in json_value and json_value["exported"])
or has_exports | |
160 for key in json_value: | |
161 has_exports = calculate_exports_in_json(json_value[key]) or has_
exports | |
162 return has_exports | |
163 | |
164 protocol.json_api["has_exports"] = False | |
165 for domain_json in protocol.json_api["domains"]: | |
166 domain_json["has_exports"] = calculate_exports_in_json(domain_json) | |
167 if domain_json["has_exports"] and domain_json["domain"] in protocol.gene
rate_domains: | |
168 protocol.json_api["has_exports"] = True | |
169 | |
170 | |
171 def create_imported_type_definition(domain_name, type, imported_namespace): | |
172 # pylint: disable=W0622 | |
173 return { | |
174 "return_type": "std::unique_ptr<%s::%s::API::%s>" % (imported_namespace,
domain_name, type["id"]), | |
175 "pass_type": "std::unique_ptr<%s::%s::API::%s>" % (imported_namespace, d
omain_name, type["id"]), | |
176 "to_raw_type": "%s.get()", | |
177 "to_pass_type": "std::move(%s)", | |
178 "to_rvalue": "std::move(%s)", | |
179 "type": "std::unique_ptr<%s::%s::API::%s>" % (imported_namespace, domain
_name, type["id"]), | |
180 "raw_type": "%s::%s::API::%s" % (imported_namespace, domain_name, type["
id"]), | |
181 "raw_pass_type": "%s::%s::API::%s*" % (imported_namespace, domain_name,
type["id"]), | |
182 "raw_return_type": "%s::%s::API::%s*" % (imported_namespace, domain_name
, type["id"]), | |
183 } | |
184 | |
185 | |
186 def create_user_type_definition(domain_name, type): | |
187 # pylint: disable=W0622 | |
188 return { | |
189 "return_type": "std::unique_ptr<protocol::%s::%s>" % (domain_name, type[
"id"]), | |
190 "pass_type": "std::unique_ptr<protocol::%s::%s>" % (domain_name, type["i
d"]), | |
191 "to_raw_type": "%s.get()", | |
192 "to_pass_type": "std::move(%s)", | |
193 "to_rvalue": "std::move(%s)", | |
194 "type": "std::unique_ptr<protocol::%s::%s>" % (domain_name, type["id"]), | |
195 "raw_type": "protocol::%s::%s" % (domain_name, type["id"]), | |
196 "raw_pass_type": "protocol::%s::%s*" % (domain_name, type["id"]), | |
197 "raw_return_type": "protocol::%s::%s*" % (domain_name, type["id"]), | |
198 } | |
199 | |
200 | |
201 def create_object_type_definition(): | |
202 # pylint: disable=W0622 | |
203 return { | |
204 "return_type": "std::unique_ptr<protocol::DictionaryValue>", | |
205 "pass_type": "std::unique_ptr<protocol::DictionaryValue>", | |
206 "to_raw_type": "%s.get()", | |
207 "to_pass_type": "std::move(%s)", | |
208 "to_rvalue": "std::move(%s)", | |
209 "type": "std::unique_ptr<protocol::DictionaryValue>", | |
210 "raw_type": "protocol::DictionaryValue", | |
211 "raw_pass_type": "protocol::DictionaryValue*", | |
212 "raw_return_type": "protocol::DictionaryValue*", | |
213 } | |
214 | |
215 | |
216 def create_any_type_definition(): | |
217 # pylint: disable=W0622 | |
218 return { | |
219 "return_type": "std::unique_ptr<protocol::Value>", | |
220 "pass_type": "std::unique_ptr<protocol::Value>", | |
221 "to_raw_type": "%s.get()", | |
222 "to_pass_type": "std::move(%s)", | |
223 "to_rvalue": "std::move(%s)", | |
224 "type": "std::unique_ptr<protocol::Value>", | |
225 "raw_type": "protocol::Value", | |
226 "raw_pass_type": "protocol::Value*", | |
227 "raw_return_type": "protocol::Value*", | |
228 } | |
229 | |
230 | |
231 def create_string_type_definition(): | |
232 # pylint: disable=W0622 | |
233 return { | |
234 "return_type": "String", | |
235 "pass_type": "const String&", | |
236 "to_pass_type": "%s", | |
237 "to_raw_type": "%s", | |
238 "to_rvalue": "%s", | |
239 "type": "String", | |
240 "raw_type": "String", | |
241 "raw_pass_type": "const String&", | |
242 "raw_return_type": "String", | |
243 } | |
244 | |
245 | |
246 def create_primitive_type_definition(type): | |
247 # pylint: disable=W0622 | |
248 typedefs = { | |
249 "number": "double", | |
250 "integer": "int", | |
251 "boolean": "bool" | |
252 } | |
253 defaults = { | |
254 "number": "0", | |
255 "integer": "0", | |
256 "boolean": "false" | |
257 } | |
258 jsontypes = { | |
259 "number": "TypeDouble", | |
260 "integer": "TypeInteger", | |
261 "boolean": "TypeBoolean", | |
262 } | |
263 return { | |
264 "return_type": typedefs[type], | |
265 "pass_type": typedefs[type], | |
266 "to_pass_type": "%s", | |
267 "to_raw_type": "%s", | |
268 "to_rvalue": "%s", | |
269 "type": typedefs[type], | |
270 "raw_type": typedefs[type], | |
271 "raw_pass_type": typedefs[type], | |
272 "raw_return_type": typedefs[type], | |
273 "default_value": defaults[type] | |
274 } | |
275 | |
276 | |
277 def wrap_array_definition(type): | |
278 # pylint: disable=W0622 | |
279 return { | |
280 "return_type": "std::unique_ptr<protocol::Array<%s>>" % type["raw_type"]
, | |
281 "pass_type": "std::unique_ptr<protocol::Array<%s>>" % type["raw_type"], | |
282 "to_raw_type": "%s.get()", | |
283 "to_pass_type": "std::move(%s)", | |
284 "to_rvalue": "std::move(%s)", | |
285 "type": "std::unique_ptr<protocol::Array<%s>>" % type["raw_type"], | |
286 "raw_type": "protocol::Array<%s>" % type["raw_type"], | |
287 "raw_pass_type": "protocol::Array<%s>*" % type["raw_type"], | |
288 "raw_return_type": "protocol::Array<%s>*" % type["raw_type"], | |
289 "create_type": "wrapUnique(new protocol::Array<%s>())" % type["raw_type"
], | |
290 "out_type": "protocol::Array<%s>&" % type["raw_type"], | |
291 } | |
292 | |
293 | |
294 def create_type_definitions(protocol, imported_namespace): | |
295 protocol.type_definitions = {} | |
296 protocol.type_definitions["number"] = create_primitive_type_definition("numb
er") | |
297 protocol.type_definitions["integer"] = create_primitive_type_definition("int
eger") | |
298 protocol.type_definitions["boolean"] = create_primitive_type_definition("boo
lean") | |
299 protocol.type_definitions["object"] = create_object_type_definition() | |
300 protocol.type_definitions["any"] = create_any_type_definition() | |
301 for domain in protocol.json_api["domains"]: | |
302 protocol.type_definitions[domain["domain"] + ".string"] = create_string_
type_definition() | |
303 if not ("types" in domain): | |
304 continue | |
305 for type in domain["types"]: | |
306 type_name = domain["domain"] + "." + type["id"] | |
307 if type["type"] == "object" and domain["domain"] in protocol.importe
d_domains: | |
308 protocol.type_definitions[type_name] = create_imported_type_defi
nition(domain["domain"], type, imported_namespace) | |
309 elif type["type"] == "object": | |
310 protocol.type_definitions[type_name] = create_user_type_definiti
on(domain["domain"], type) | |
311 elif type["type"] == "array": | |
312 items_type = type["items"]["type"] | |
313 protocol.type_definitions[type_name] = wrap_array_definition(pro
tocol.type_definitions[items_type]) | |
314 elif type["type"] == domain["domain"] + ".string": | |
315 protocol.type_definitions[type_name] = create_string_type_defini
tion() | |
316 else: | |
317 protocol.type_definitions[type_name] = create_primitive_type_def
inition(type["type"]) | |
318 | |
319 | |
320 def type_definition(protocol, name): | |
321 return protocol.type_definitions[name] | |
322 | |
323 | |
324 def resolve_type(protocol, prop): | |
325 if "$ref" in prop: | |
326 return protocol.type_definitions[prop["$ref"]] | |
327 if prop["type"] == "array": | |
328 return wrap_array_definition(resolve_type(protocol, prop["items"])) | |
329 return protocol.type_definitions[prop["type"]] | |
330 | |
331 | |
332 def join_arrays(dict, keys): | |
333 result = [] | |
334 for key in keys: | |
335 if key in dict: | |
336 result += dict[key] | |
337 return result | |
338 | |
339 | |
340 def has_disable(commands): | |
341 for command in commands: | |
342 if command["name"] == "disable": | |
343 return True | |
344 return False | |
345 | |
346 | |
347 def format_include(header): | |
348 return "\"" + header + "\"" if header[0] not in "<\"" else header | |
349 | |
350 | |
351 def read_protocol_file(file_name, json_api): | |
352 input_file = open(file_name, "r") | |
353 json_string = input_file.read() | |
354 input_file.close() | |
355 parsed_json = json.loads(json_string) | |
356 version = parsed_json["version"]["major"] + "." + parsed_json["version"]["mi
nor"] | |
357 domains = [] | |
358 for domain in parsed_json["domains"]: | |
359 domains.append(domain["domain"]) | |
360 domain["version"] = version | |
361 json_api["domains"] += parsed_json["domains"] | |
362 return domains | |
363 | |
364 | |
365 class Protocol(object): | |
366 def __init__(self): | |
367 self.json_api = {} | |
368 self.generate_domains = [] | |
369 self.imported_domains = [] | |
370 | |
371 | |
372 def main(): | |
373 jinja_dir, config_file, config = read_config() | |
374 | |
375 protocol = Protocol() | |
376 protocol.json_api = {"domains": []} | |
377 protocol.generate_domains = read_protocol_file(config.protocol.path, protoco
l.json_api) | |
378 protocol.imported_domains = read_protocol_file(config.imported.path, protoco
l.json_api) if config.imported else [] | |
379 patch_full_qualified_refs(protocol) | |
380 calculate_exports(protocol) | |
381 create_type_definitions(protocol, "::".join(config.imported.namespace) if co
nfig.imported else "") | |
382 | |
383 if not config.exported: | |
384 for domain_json in protocol.json_api["domains"]: | |
385 if domain_json["has_exports"] and domain_json["domain"] in protocol.
generate_domains: | |
386 sys.stderr.write("Domain %s is exported, but config is missing e
xport entry\n\n" % domain_json["domain"]) | |
387 exit(1) | |
388 | |
389 if not os.path.exists(config.protocol.output): | |
390 os.mkdir(config.protocol.output) | |
391 if protocol.json_api["has_exports"] and not os.path.exists(config.exported.o
utput): | |
392 os.mkdir(config.exported.output) | |
393 jinja_env = initialize_jinja_env(jinja_dir, config.protocol.output) | |
394 | |
395 inputs = [] | |
396 inputs.append(__file__) | |
397 inputs.append(config_file) | |
398 inputs.append(config.protocol.path) | |
399 if config.imported: | |
400 inputs.append(config.imported.path) | |
401 templates_dir = os.path.join(module_path, "templates") | |
402 inputs.append(os.path.join(templates_dir, "TypeBuilder_h.template")) | |
403 inputs.append(os.path.join(templates_dir, "TypeBuilder_cpp.template")) | |
404 inputs.append(os.path.join(templates_dir, "Exported_h.template")) | |
405 inputs.append(os.path.join(templates_dir, "Imported_h.template")) | |
406 | |
407 h_template = jinja_env.get_template("templates/TypeBuilder_h.template") | |
408 cpp_template = jinja_env.get_template("templates/TypeBuilder_cpp.template") | |
409 exported_template = jinja_env.get_template("templates/Exported_h.template") | |
410 imported_template = jinja_env.get_template("templates/Imported_h.template") | |
411 | |
412 outputs = dict() | |
413 | |
414 for domain in protocol.json_api["domains"]: | |
415 class_name = domain["domain"] | |
416 template_context = { | |
417 "config": config, | |
418 "domain": domain, | |
419 "join_arrays": join_arrays, | |
420 "resolve_type": functools.partial(resolve_type, protocol), | |
421 "type_definition": functools.partial(type_definition, protocol), | |
422 "has_disable": has_disable, | |
423 "format_include": format_include, | |
424 } | |
425 | |
426 if domain["domain"] in protocol.generate_domains: | |
427 outputs[os.path.join(config.protocol.output, class_name + ".h")] = h
_template.render(template_context) | |
428 outputs[os.path.join(config.protocol.output, class_name + ".cpp")] =
cpp_template.render(template_context) | |
429 if domain["has_exports"]: | |
430 outputs[os.path.join(config.exported.output, class_name + ".h")]
= exported_template.render(template_context) | |
431 if domain["domain"] in protocol.imported_domains and domain["has_exports
"]: | |
432 outputs[os.path.join(config.protocol.output, class_name + ".h")] = i
mported_template.render(template_context) | |
433 | |
434 if config.lib: | |
435 template_context = { | |
436 "config": config, | |
437 "format_include": format_include, | |
438 } | |
439 | |
440 lib_templates_dir = os.path.join(module_path, "lib") | |
441 # Note these should be sorted in the right order. | |
442 # TODO(dgozman): sort them programmatically based on commented includes. | |
443 lib_h_templates = [ | |
444 "Collections_h.template", | |
445 "ErrorSupport_h.template", | |
446 "Values_h.template", | |
447 "Object_h.template", | |
448 "ValueConversions_h.template", | |
449 "Maybe_h.template", | |
450 "Array_h.template", | |
451 "BackendCallback_h.template", | |
452 "DispatcherBase_h.template", | |
453 "Parser_h.template", | |
454 ] | |
455 | |
456 lib_cpp_templates = [ | |
457 "Protocol_cpp.template", | |
458 "ErrorSupport_cpp.template", | |
459 "Values_cpp.template", | |
460 "Object_cpp.template", | |
461 "DispatcherBase_cpp.template", | |
462 "Parser_cpp.template", | |
463 ] | |
464 | |
465 forward_h_templates = [ | |
466 "Forward_h.template", | |
467 "Allocator_h.template", | |
468 "FrontendChannel_h.template", | |
469 ] | |
470 | |
471 def generate_lib_file(file_name, template_files): | |
472 parts = [] | |
473 for template_file in template_files: | |
474 inputs.append(os.path.join(lib_templates_dir, template_file)) | |
475 template = jinja_env.get_template("lib/" + template_file) | |
476 parts.append(template.render(template_context)) | |
477 outputs[file_name] = "\n\n".join(parts) | |
478 | |
479 generate_lib_file(os.path.join(config.lib.output, "Forward.h"), forward_
h_templates) | |
480 generate_lib_file(os.path.join(config.lib.output, "Protocol.h"), lib_h_t
emplates) | |
481 generate_lib_file(os.path.join(config.lib.output, "Protocol.cpp"), lib_c
pp_templates) | |
482 | |
483 # Make gyp / make generatos happy, otherwise make rebuilds world. | |
484 inputs_ts = max(map(os.path.getmtime, inputs)) | |
485 up_to_date = True | |
486 for output_file in outputs.iterkeys(): | |
487 if not os.path.exists(output_file) or os.path.getmtime(output_file) < in
puts_ts: | |
488 up_to_date = False | |
489 break | |
490 if up_to_date: | |
491 sys.exit() | |
492 | |
493 for file_name, content in outputs.iteritems(): | |
494 out_file = open(file_name, "w") | |
495 out_file.write(content) | |
496 out_file.close() | |
497 | |
498 | |
499 main() | |
OLD | NEW |