cpp_bundle_generator.py revision 5f1c94371a64b3196d4be9466099bb892df9b88e
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. 4 5import code 6import cpp_util 7from model import Platforms 8from schema_util import CapitalizeFirstLetter 9from schema_util import JsFunctionNameToClassName 10 11import json 12import os 13import re 14 15 16def _RemoveDescriptions(node): 17 """Returns a copy of |schema| with "description" fields removed. 18 """ 19 if isinstance(node, dict): 20 result = {} 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): 25 continue 26 result[key] = _RemoveDescriptions(value) 27 return result 28 if isinstance(node, list): 29 return [_RemoveDescriptions(v) for v in node] 30 return node 31 32 33class CppBundleGenerator(object): 34 """This class contains methods to generate code based on multiple schemas. 35 """ 36 37 def __init__(self, 38 root, 39 model, 40 api_defs, 41 cpp_type_generator, 42 cpp_namespace_pattern, 43 source_file_dir, 44 impl_dir): 45 self._root = root 46 self._model = model 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 51 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] 56 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) 61 62 def _GenerateHeader(self, file_base, body_code): 63 """Generates a code.Code object for a header file 64 65 Parameters: 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""" 68 c = code.Code() 69 c.Append(cpp_util.CHROMIUM_LICENSE) 70 c.Append() 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)) 74 c.Append() 75 c.Append('#ifndef %s' % ifndef_name) 76 c.Append('#define %s' % ifndef_name) 77 c.Append() 78 c.Concat(body_code) 79 c.Append() 80 c.Append('#endif // %s' % ifndef_name) 81 c.Append() 82 return c 83 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. 87 """ 88 if model_object.platforms is None: 89 return None 90 ifdefs = [] 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)') 100 else: 101 raise ValueError("Unsupported platform ifdef: %s" % platform.name) 102 return ' || '.join(ifdefs) 103 104 def _GenerateRegisterFunctions(self, namespace_name, function): 105 c = code.Code() 106 function_ifdefs = self._GetPlatformIfdefs(function) 107 if function_ifdefs is not None: 108 c.Append("#if %s" % function_ifdefs, indent_level=0) 109 110 function_name = JsFunctionNameToClassName(namespace_name, function.name) 111 c.Append("registry->RegisterFunction<%sFunction>();" % ( 112 function_name)) 113 114 if function_ifdefs is not None: 115 c.Append("#endif // %s" % function_ifdefs, indent_level=0) 116 return c 117 118 def _GenerateFunctionRegistryRegisterAll(self): 119 c = code.Code() 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) 127 128 namespace_name = CapitalizeFirstLetter(namespace.name.replace( 129 "experimental.", "")) 130 for function in namespace.functions.values(): 131 if function.nocompile: 132 continue 133 c.Concat(self._GenerateRegisterFunctions(namespace.name, function)) 134 135 for type_ in namespace.types.values(): 136 for function in type_.functions.values(): 137 if function.nocompile: 138 continue 139 namespace_types_name = JsFunctionNameToClassName( 140 namespace.name, type_.name) 141 c.Concat(self._GenerateRegisterFunctions(namespace_types_name, 142 function)) 143 144 if namespace_ifdefs is not None: 145 c.Append("#endif // %s" % namespace_ifdefs, indent_level=0) 146 c.Eblock("}") 147 return c 148 149 150class _APIHGenerator(object): 151 """Generates the header for API registration / declaration""" 152 def __init__(self, cpp_bundle): 153 self._bundle = cpp_bundle 154 155 def Generate(self, _): # namespace not relevant, this is a bundle 156 c = code.Code() 157 158 c.Append('#include <string>') 159 c.Append() 160 c.Append('#include "base/basictypes.h"') 161 c.Append() 162 c.Append("class ExtensionFunctionRegistry;") 163 c.Append() 164 c.Concat(cpp_util.OpenNamespace(self._bundle._cpp_namespace)) 165 c.Append() 166 c.Append('class GeneratedFunctionRegistry {') 167 c.Sblock(' public:') 168 c.Append('static void RegisterAll(' 169 'ExtensionFunctionRegistry* registry);') 170 c.Eblock('};') 171 c.Append() 172 c.Concat(cpp_util.CloseNamespace(self._bundle._cpp_namespace)) 173 return self._bundle._GenerateHeader('generated_api', c) 174 175 176class _APICCGenerator(object): 177 """Generates a code.Code object for the generated API .cc file""" 178 179 def __init__(self, cpp_bundle): 180 self._bundle = cpp_bundle 181 182 def Generate(self, _): # namespace not relevant, this is a bundle 183 c = code.Code() 184 c.Append(cpp_util.CHROMIUM_LICENSE) 185 c.Append() 186 c.Append('#include "%s"' % (os.path.join(self._bundle._source_file_dir, 187 'generated_api.h'))) 188 c.Append() 189 for namespace in self._bundle._model.namespaces.values(): 190 namespace_name = namespace.unix_name.replace("experimental_", "") 191 implementation_header = namespace.compiler_options.get( 192 "implemented_in", 193 "%s/%s/%s_api.h" % (self._bundle._impl_dir, 194 namespace_name, 195 namespace_name)) 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)) 203 continue 204 ifdefs = self._bundle._GetPlatformIfdefs(namespace) 205 if ifdefs is not None: 206 c.Append("#if %s" % ifdefs, indent_level=0) 207 208 c.Append('#include "%s"' % implementation_header) 209 210 if ifdefs is not None: 211 c.Append("#endif // %s" % ifdefs, indent_level=0) 212 c.Append() 213 c.Append('#include ' 214 '"extensions/browser/extension_function_registry.h"') 215 c.Append() 216 c.Concat(cpp_util.OpenNamespace(self._bundle._cpp_namespace)) 217 c.Append() 218 c.Concat(self._bundle._GenerateFunctionRegistryRegisterAll()) 219 c.Append() 220 c.Concat(cpp_util.CloseNamespace(self._bundle._cpp_namespace)) 221 c.Append() 222 return c 223 224 225class _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 229 230 def Generate(self, _): # namespace not relevant, this is a bundle 231 c = code.Code() 232 c.Append('#include <map>') 233 c.Append('#include <string>') 234 c.Append() 235 c.Append('#include "base/strings/string_piece.h"') 236 c.Append() 237 c.Concat(cpp_util.OpenNamespace(self._bundle._cpp_namespace)) 238 c.Append() 239 c.Append('class GeneratedSchemas {') 240 c.Sblock(' public:') 241 c.Append('// Determines if schema named |name| is generated.') 242 c.Append('static bool IsGenerated(std::string name);') 243 c.Append() 244 c.Append('// Gets the API schema named |name|.') 245 c.Append('static base::StringPiece Get(const std::string& name);') 246 c.Eblock('};') 247 c.Append() 248 c.Concat(cpp_util.CloseNamespace(self._bundle._cpp_namespace)) 249 return self._bundle._GenerateHeader('generated_schemas', c) 250 251 252def _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('.', '_')) 258 259 260class _SchemasCCGenerator(object): 261 """Generates a code.Code object for the generated schemas .cc file""" 262 263 def __init__(self, cpp_bundle): 264 self._bundle = cpp_bundle 265 266 def Generate(self, _): # namespace not relevant, this is a bundle 267 c = code.Code() 268 c.Append(cpp_util.CHROMIUM_LICENSE) 269 c.Append() 270 c.Append('#include "%s"' % (os.path.join(self._bundle._source_file_dir, 271 'generated_schemas.h'))) 272 c.Append() 273 c.Append('#include "base/lazy_instance.h"') 274 c.Append() 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. 285 max_length = 8192 286 segments = [json_content[i:i + max_length].replace('\\', '\\\\') 287 .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))) 291 c.Append('}') 292 c.Concat(cpp_util.OpenNamespace(self._bundle._cpp_namespace)) 293 c.Append() 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))) 300 c.Eblock('}') 301 c.Append() 302 c.Append('std::map<std::string, const char*> schemas;') 303 c.Eblock('};') 304 c.Append() 305 c.Append('base::LazyInstance<Static> g_lazy_instance;') 306 c.Append() 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] : "";') 312 c.Eblock('}') 313 c.Append() 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;') 317 c.Eblock('}') 318 c.Append() 319 c.Concat(cpp_util.CloseNamespace(self._bundle._cpp_namespace)) 320 c.Append() 321 return c 322