1 # Copyright (c) 2012 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.
7 from model import Platforms
8 from schema_util import CapitalizeFirstLetter
9 from schema_util import JsFunctionNameToClassName
16 def _RemoveDescriptions(node):
17 """Returns a copy of |schema| with "description" fields removed.
19 if isinstance(node, dict):
21 for key, value in node.items():
22 # Some schemas actually have properties called "description", so only
23 # remove descriptions that have string values.
24 if key == 'description' and isinstance(value, basestring):
26 result[key] = _RemoveDescriptions(value)
28 if isinstance(node, list):
29 return [_RemoveDescriptions(v) for v in node]
33 class CppBundleGenerator(object):
34 """This class contains methods to generate code based on multiple schemas.
42 cpp_namespace_pattern,
47 self._api_defs = api_defs
48 self._cpp_type_generator = cpp_type_generator
49 self._source_file_dir = source_file_dir
50 self._impl_dir = impl_dir
52 # Hack: assume that the C++ namespace for the bundle is the namespace of the
53 # files without the last component of the namespace. A cleaner way to do
54 # this would be to make it a separate variable in the gyp file.
55 self._cpp_namespace = cpp_namespace_pattern.rsplit('::', 1)[0]
57 self.api_cc_generator = _APICCGenerator(self)
58 self.api_h_generator = _APIHGenerator(self)
59 self.schemas_cc_generator = _SchemasCCGenerator(self)
60 self.schemas_h_generator = _SchemasHGenerator(self)
62 def _GenerateHeader(self, file_base, body_code):
63 """Generates a code.Code object for a header file
66 - |file_base| - the base of the filename, e.g. 'foo' (for 'foo.h')
67 - |body_code| - the code to put in between the multiple inclusion guards"""
69 c.Append(cpp_util.CHROMIUM_LICENSE)
71 c.Append(cpp_util.GENERATED_BUNDLE_FILE_MESSAGE % self._source_file_dir)
72 ifndef_name = cpp_util.GenerateIfndefName(
73 '%s/%s.h' % (self._source_file_dir, file_base))
75 c.Append('#ifndef %s' % ifndef_name)
76 c.Append('#define %s' % ifndef_name)
80 c.Append('#endif // %s' % ifndef_name)
84 def _GetPlatformIfdefs(self, model_object):
85 """Generates the "defined" conditional for an #if check if |model_object|
86 has platform restrictions. Returns None if there are no restrictions.
88 if model_object.platforms is None:
91 for platform in model_object.platforms:
92 if platform == Platforms.CHROMEOS:
93 ifdefs.append('defined(OS_CHROMEOS)')
94 elif platform == Platforms.LINUX:
95 ifdefs.append('defined(OS_LINUX)')
96 elif platform == Platforms.MAC:
97 ifdefs.append('defined(OS_MACOSX)')
98 elif platform == Platforms.WIN:
99 ifdefs.append('defined(OS_WIN)')
101 raise ValueError("Unsupported platform ifdef: %s" % platform.name)
102 return ' || '.join(ifdefs)
104 def _GenerateRegisterFunctions(self, namespace_name, function):
106 function_ifdefs = self._GetPlatformIfdefs(function)
107 if function_ifdefs is not None:
108 c.Append("#if %s" % function_ifdefs, indent_level=0)
110 function_name = JsFunctionNameToClassName(namespace_name, function.name)
111 c.Append("registry->RegisterFunction<%sFunction>();" % (
114 if function_ifdefs is not None:
115 c.Append("#endif // %s" % function_ifdefs, indent_level=0)
118 def _GenerateFunctionRegistryRegisterAll(self):
120 c.Append('// static')
121 c.Sblock('void GeneratedFunctionRegistry::RegisterAll('
122 'ExtensionFunctionRegistry* registry) {')
123 for namespace in self._model.namespaces.values():
124 namespace_ifdefs = self._GetPlatformIfdefs(namespace)
125 if namespace_ifdefs is not None:
126 c.Append("#if %s" % namespace_ifdefs, indent_level=0)
128 namespace_name = CapitalizeFirstLetter(namespace.name.replace(
129 "experimental.", ""))
130 for function in namespace.functions.values():
131 if function.nocompile:
133 c.Concat(self._GenerateRegisterFunctions(namespace.name, function))
135 for type_ in namespace.types.values():
136 for function in type_.functions.values():
137 if function.nocompile:
139 namespace_types_name = JsFunctionNameToClassName(
140 namespace.name, type_.name)
141 c.Concat(self._GenerateRegisterFunctions(namespace_types_name,
144 if namespace_ifdefs is not None:
145 c.Append("#endif // %s" % namespace_ifdefs, indent_level=0)
150 class _APIHGenerator(object):
151 """Generates the header for API registration / declaration"""
152 def __init__(self, cpp_bundle):
153 self._bundle = cpp_bundle
155 def Generate(self, _): # namespace not relevant, this is a bundle
158 c.Append('#include <string>')
160 c.Append('#include "base/basictypes.h"')
162 c.Append("class ExtensionFunctionRegistry;")
164 c.Concat(cpp_util.OpenNamespace(self._bundle._cpp_namespace))
166 c.Append('class GeneratedFunctionRegistry {')
168 c.Append('static void RegisterAll('
169 'ExtensionFunctionRegistry* registry);')
172 c.Concat(cpp_util.CloseNamespace(self._bundle._cpp_namespace))
173 return self._bundle._GenerateHeader('generated_api', c)
176 class _APICCGenerator(object):
177 """Generates a code.Code object for the generated API .cc file"""
179 def __init__(self, cpp_bundle):
180 self._bundle = cpp_bundle
182 def Generate(self, _): # namespace not relevant, this is a bundle
184 c.Append(cpp_util.CHROMIUM_LICENSE)
186 c.Append('#include "%s"' % (os.path.join(self._bundle._source_file_dir,
189 for namespace in self._bundle._model.namespaces.values():
190 namespace_name = namespace.unix_name.replace("experimental_", "")
191 implementation_header = namespace.compiler_options.get(
193 "%s/%s/%s_api.h" % (self._bundle._impl_dir,
196 if not os.path.exists(
197 os.path.join(self._bundle._root,
198 os.path.normpath(implementation_header))):
199 if "implemented_in" in namespace.compiler_options:
200 raise ValueError('Header file for namespace "%s" specified in '
201 'compiler_options not found: %s' %
202 (namespace.unix_name, implementation_header))
204 ifdefs = self._bundle._GetPlatformIfdefs(namespace)
205 if ifdefs is not None:
206 c.Append("#if %s" % ifdefs, indent_level=0)
208 c.Append('#include "%s"' % implementation_header)
210 if ifdefs is not None:
211 c.Append("#endif // %s" % ifdefs, indent_level=0)
214 '"extensions/browser/extension_function_registry.h"')
216 c.Concat(cpp_util.OpenNamespace(self._bundle._cpp_namespace))
218 c.Concat(self._bundle._GenerateFunctionRegistryRegisterAll())
220 c.Concat(cpp_util.CloseNamespace(self._bundle._cpp_namespace))
225 class _SchemasHGenerator(object):
226 """Generates a code.Code object for the generated schemas .h file"""
227 def __init__(self, cpp_bundle):
228 self._bundle = cpp_bundle
230 def Generate(self, _): # namespace not relevant, this is a bundle
232 c.Append('#include <map>')
233 c.Append('#include <string>')
235 c.Append('#include "base/strings/string_piece.h"')
237 c.Concat(cpp_util.OpenNamespace(self._bundle._cpp_namespace))
239 c.Append('class GeneratedSchemas {')
241 c.Append('// Determines if schema named |name| is generated.')
242 c.Append('static bool IsGenerated(std::string name);')
244 c.Append('// Gets the API schema named |name|.')
245 c.Append('static base::StringPiece Get(const std::string& name);')
248 c.Concat(cpp_util.CloseNamespace(self._bundle._cpp_namespace))
249 return self._bundle._GenerateHeader('generated_schemas', c)
252 def _FormatNameAsConstant(name):
253 """Formats a name to be a C++ constant of the form kConstantName"""
254 name = '%s%s' % (name[0].upper(), name[1:])
255 return 'k%s' % re.sub('_[a-z]',
256 lambda m: m.group(0)[1].upper(),
257 name.replace('.', '_'))
260 class _SchemasCCGenerator(object):
261 """Generates a code.Code object for the generated schemas .cc file"""
263 def __init__(self, cpp_bundle):
264 self._bundle = cpp_bundle
266 def Generate(self, _): # namespace not relevant, this is a bundle
268 c.Append(cpp_util.CHROMIUM_LICENSE)
270 c.Append('#include "%s"' % (os.path.join(self._bundle._source_file_dir,
271 'generated_schemas.h')))
273 c.Append('#include "base/lazy_instance.h"')
275 c.Append('namespace {')
276 for api in self._bundle._api_defs:
277 namespace = self._bundle._model.namespaces[api.get('namespace')]
278 # JSON parsing code expects lists of schemas, so dump a singleton list.
279 json_content = json.dumps([_RemoveDescriptions(api)],
280 separators=(',', ':'))
281 # Escape all double-quotes and backslashes. For this to output a valid
282 # JSON C string, we need to escape \ and ". Note that some schemas are
283 # too large to compile on windows. Split the JSON up into several
284 # strings, since apparently that helps.
286 segments = [json_content[i:i + max_length].replace('\\', '\\\\')
288 for i in xrange(0, len(json_content), max_length)]
289 c.Append('const char %s[] = "%s";' %
290 (_FormatNameAsConstant(namespace.name), '" "'.join(segments)))
292 c.Concat(cpp_util.OpenNamespace(self._bundle._cpp_namespace))
294 c.Sblock('struct Static {')
295 c.Sblock('Static() {')
296 for api in self._bundle._api_defs:
297 namespace = self._bundle._model.namespaces[api.get('namespace')]
298 c.Append('schemas["%s"] = %s;' % (namespace.name,
299 _FormatNameAsConstant(namespace.name)))
302 c.Append('std::map<std::string, const char*> schemas;')
305 c.Append('base::LazyInstance<Static> g_lazy_instance;')
307 c.Append('// static')
308 c.Sblock('base::StringPiece GeneratedSchemas::Get('
309 'const std::string& name) {')
310 c.Append('return IsGenerated(name) ? '
311 'g_lazy_instance.Get().schemas[name] : "";')
314 c.Append('// static')
315 c.Sblock('bool GeneratedSchemas::IsGenerated(std::string name) {')
316 c.Append('return g_lazy_instance.Get().schemas.count(name) > 0;')
319 c.Concat(cpp_util.CloseNamespace(self._bundle._cpp_namespace))