| # Copyright (c) 2012 The Chromium Authors. All rights reserved. |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| from code import Code |
| from model import PropertyType, Type |
| import cpp_util |
| import model |
| import schema_util |
| import sys |
| import util_cc_helper |
| |
| class CCGenerator(object): |
| def __init__(self, type_generator, cpp_namespace): |
| self._type_generator = type_generator |
| self._cpp_namespace = cpp_namespace |
| |
| def Generate(self, namespace): |
| return _Generator(namespace, |
| self._type_generator, |
| self._cpp_namespace).Generate() |
| |
| class _Generator(object): |
| """A .cc generator for a namespace. |
| """ |
| def __init__(self, namespace, cpp_type_generator, cpp_namespace): |
| self._namespace = namespace |
| self._type_helper = cpp_type_generator |
| self._cpp_namespace = cpp_namespace |
| self._target_namespace = ( |
| self._type_helper.GetCppNamespaceName(self._namespace)) |
| self._util_cc_helper = ( |
| util_cc_helper.UtilCCHelper(self._type_helper)) |
| self._generate_error_messages = namespace.compiler_options.get( |
| 'generate_error_messages', False) |
| |
| def Generate(self): |
| """Generates a Code object with the .cc for a single namespace. |
| """ |
| c = Code() |
| (c.Append(cpp_util.CHROMIUM_LICENSE) |
| .Append() |
| .Append(cpp_util.GENERATED_FILE_MESSAGE % self._namespace.source_file) |
| .Append() |
| .Append(self._util_cc_helper.GetIncludePath()) |
| .Append('#include "base/logging.h"') |
| .Append('#include "base/strings/string_number_conversions.h"') |
| .Append('#include "%s/%s.h"' % |
| (self._namespace.source_file_dir, self._namespace.unix_name)) |
| .Cblock(self._type_helper.GenerateIncludes(include_soft=True)) |
| .Append() |
| .Concat(cpp_util.OpenNamespace(self._cpp_namespace)) |
| .Cblock(self._type_helper.GetNamespaceStart()) |
| ) |
| if self._namespace.properties: |
| (c.Append('//') |
| .Append('// Properties') |
| .Append('//') |
| .Append() |
| ) |
| for property in self._namespace.properties.values(): |
| property_code = self._type_helper.GeneratePropertyValues( |
| property, |
| 'const %(type)s %(name)s = %(value)s;', |
| nodoc=True) |
| if property_code: |
| c.Cblock(property_code) |
| if self._namespace.types: |
| (c.Append('//') |
| .Append('// Types') |
| .Append('//') |
| .Append() |
| .Cblock(self._GenerateTypes(None, self._namespace.types.values())) |
| ) |
| if self._namespace.functions: |
| (c.Append('//') |
| .Append('// Functions') |
| .Append('//') |
| .Append() |
| ) |
| for function in self._namespace.functions.values(): |
| c.Cblock(self._GenerateFunction(function)) |
| if self._namespace.events: |
| (c.Append('//') |
| .Append('// Events') |
| .Append('//') |
| .Append() |
| ) |
| for event in self._namespace.events.values(): |
| c.Cblock(self._GenerateEvent(event)) |
| (c.Concat(self._type_helper.GetNamespaceEnd()) |
| .Cblock(cpp_util.CloseNamespace(self._cpp_namespace)) |
| ) |
| return c |
| |
| def _GenerateType(self, cpp_namespace, type_): |
| """Generates the function definitions for a type. |
| """ |
| classname = cpp_util.Classname(schema_util.StripNamespace(type_.name)) |
| c = Code() |
| |
| if type_.functions: |
| # Wrap functions within types in the type's namespace. |
| (c.Append('namespace %s {' % classname) |
| .Append()) |
| for function in type_.functions.values(): |
| c.Cblock(self._GenerateFunction(function)) |
| c.Append('} // namespace %s' % classname) |
| elif type_.property_type == PropertyType.ARRAY: |
| c.Cblock(self._GenerateType(cpp_namespace, type_.item_type)) |
| elif type_.property_type in (PropertyType.CHOICES, |
| PropertyType.OBJECT): |
| if cpp_namespace is None: |
| classname_in_namespace = classname |
| else: |
| classname_in_namespace = '%s::%s' % (cpp_namespace, classname) |
| |
| if type_.property_type == PropertyType.OBJECT: |
| c.Cblock(self._GeneratePropertyFunctions(classname_in_namespace, |
| type_.properties.values())) |
| else: |
| c.Cblock(self._GenerateTypes(classname_in_namespace, type_.choices)) |
| |
| (c.Append('%s::%s()' % (classname_in_namespace, classname)) |
| .Cblock(self._GenerateInitializersAndBody(type_)) |
| .Append('%s::~%s() {}' % (classname_in_namespace, classname)) |
| .Append() |
| ) |
| if type_.origin.from_json: |
| c.Cblock(self._GenerateTypePopulate(classname_in_namespace, type_)) |
| if cpp_namespace is None: # only generate for top-level types |
| c.Cblock(self._GenerateTypeFromValue(classname_in_namespace, type_)) |
| if type_.origin.from_client: |
| c.Cblock(self._GenerateTypeToValue(classname_in_namespace, type_)) |
| elif type_.property_type == PropertyType.ENUM: |
| (c.Cblock(self._GenerateEnumToString(cpp_namespace, type_)) |
| .Cblock(self._GenerateEnumFromString(cpp_namespace, type_)) |
| ) |
| |
| return c |
| |
| def _GenerateInitializersAndBody(self, type_): |
| items = [] |
| for prop in type_.properties.values(): |
| if prop.optional: |
| continue |
| |
| t = prop.type_ |
| if t.property_type == PropertyType.INTEGER: |
| items.append('%s(0)' % prop.unix_name) |
| elif t.property_type == PropertyType.DOUBLE: |
| items.append('%s(0.0)' % prop.unix_name) |
| elif t.property_type == PropertyType.BOOLEAN: |
| items.append('%s(false)' % prop.unix_name) |
| elif (t.property_type == PropertyType.ANY or |
| t.property_type == PropertyType.ARRAY or |
| t.property_type == PropertyType.BINARY or # mapped to std::string |
| t.property_type == PropertyType.CHOICES or |
| t.property_type == PropertyType.ENUM or |
| t.property_type == PropertyType.OBJECT or |
| t.property_type == PropertyType.FUNCTION or |
| t.property_type == PropertyType.REF or |
| t.property_type == PropertyType.STRING): |
| # TODO(miket): It would be nice to initialize CHOICES and ENUM, but we |
| # don't presently have the semantics to indicate which one of a set |
| # should be the default. |
| continue |
| else: |
| raise TypeError(t) |
| |
| if items: |
| s = ': %s' % (', '.join(items)) |
| else: |
| s = '' |
| s = s + ' {}' |
| return Code().Append(s) |
| |
| def _GenerateTypePopulate(self, cpp_namespace, type_): |
| """Generates the function for populating a type given a pointer to it. |
| |
| E.g for type "Foo", generates Foo::Populate() |
| """ |
| classname = cpp_util.Classname(schema_util.StripNamespace(type_.name)) |
| c = Code() |
| (c.Append('// static') |
| .Append('bool %(namespace)s::Populate(') |
| .Sblock(' %s) {' % self._GenerateParams( |
| ('const base::Value& value', '%(name)s* out')))) |
| |
| if type_.property_type == PropertyType.CHOICES: |
| for choice in type_.choices: |
| (c.Sblock('if (%s) {' % self._GenerateValueIsTypeExpression('value', |
| choice)) |
| .Concat(self._GeneratePopulateVariableFromValue( |
| choice, |
| '(&value)', |
| 'out->as_%s' % choice.unix_name, |
| 'false', |
| is_ptr=True)) |
| .Append('return true;') |
| .Eblock('}') |
| ) |
| (c.Concat(self._GenerateError( |
| '"expected %s, got " + %s' % |
| (" or ".join(choice.name for choice in type_.choices), |
| self._util_cc_helper.GetValueTypeString('value')))) |
| .Append('return false;')) |
| elif type_.property_type == PropertyType.OBJECT: |
| (c.Sblock('if (!value.IsType(base::Value::TYPE_DICTIONARY)) {') |
| .Concat(self._GenerateError( |
| '"expected dictionary, got " + ' + |
| self._util_cc_helper.GetValueTypeString('value'))) |
| .Append('return false;') |
| .Eblock('}')) |
| |
| if type_.properties or type_.additional_properties is not None: |
| c.Append('const base::DictionaryValue* dict = ' |
| 'static_cast<const base::DictionaryValue*>(&value);') |
| for prop in type_.properties.values(): |
| c.Concat(self._InitializePropertyToDefault(prop, 'out')) |
| for prop in type_.properties.values(): |
| c.Concat(self._GenerateTypePopulateProperty(prop, 'dict', 'out')) |
| if type_.additional_properties is not None: |
| if type_.additional_properties.property_type == PropertyType.ANY: |
| c.Append('out->additional_properties.MergeDictionary(dict);') |
| else: |
| cpp_type = self._type_helper.GetCppType(type_.additional_properties, |
| is_in_container=True) |
| (c.Append('for (base::DictionaryValue::Iterator it(*dict);') |
| .Sblock(' !it.IsAtEnd(); it.Advance()) {') |
| .Append('%s tmp;' % cpp_type) |
| .Concat(self._GeneratePopulateVariableFromValue( |
| type_.additional_properties, |
| '(&it.value())', |
| 'tmp', |
| 'false')) |
| .Append('out->additional_properties[it.key()] = tmp;') |
| .Eblock('}') |
| ) |
| c.Append('return true;') |
| (c.Eblock('}') |
| .Substitute({'namespace': cpp_namespace, 'name': classname})) |
| return c |
| |
| def _GenerateValueIsTypeExpression(self, var, type_): |
| real_type = self._type_helper.FollowRef(type_) |
| if real_type.property_type is PropertyType.CHOICES: |
| return '(%s)' % ' || '.join(self._GenerateValueIsTypeExpression(var, |
| choice) |
| for choice in real_type.choices) |
| return '%s.IsType(%s)' % (var, cpp_util.GetValueType(real_type)) |
| |
| def _GenerateTypePopulateProperty(self, prop, src, dst): |
| """Generate the code to populate a single property in a type. |
| |
| src: base::DictionaryValue* |
| dst: Type* |
| """ |
| c = Code() |
| value_var = prop.unix_name + '_value' |
| c.Append('const base::Value* %(value_var)s = NULL;') |
| if prop.optional: |
| (c.Sblock( |
| 'if (%(src)s->GetWithoutPathExpansion("%(key)s", &%(value_var)s)) {') |
| .Concat(self._GeneratePopulatePropertyFromValue( |
| prop, value_var, dst, 'false'))) |
| underlying_type = self._type_helper.FollowRef(prop.type_) |
| if underlying_type.property_type == PropertyType.ENUM: |
| (c.Append('} else {') |
| .Append('%%(dst)s->%%(name)s = %s;' % |
| self._type_helper.GetEnumNoneValue(prop.type_))) |
| c.Eblock('}') |
| else: |
| (c.Sblock( |
| 'if (!%(src)s->GetWithoutPathExpansion("%(key)s", &%(value_var)s)) {') |
| .Concat(self._GenerateError('"\'%%(key)s\' is required"')) |
| .Append('return false;') |
| .Eblock('}') |
| .Concat(self._GeneratePopulatePropertyFromValue( |
| prop, value_var, dst, 'false')) |
| ) |
| c.Append() |
| c.Substitute({ |
| 'value_var': value_var, |
| 'key': prop.name, |
| 'src': src, |
| 'dst': dst, |
| 'name': prop.unix_name |
| }) |
| return c |
| |
| def _GenerateTypeFromValue(self, cpp_namespace, type_): |
| classname = cpp_util.Classname(schema_util.StripNamespace(type_.name)) |
| c = Code() |
| (c.Append('// static') |
| .Append('scoped_ptr<%s> %s::FromValue(%s) {' % (classname, |
| cpp_namespace, self._GenerateParams(('const base::Value& value',)))) |
| .Append(' scoped_ptr<%s> out(new %s());' % (classname, classname)) |
| .Append(' if (!Populate(%s))' % self._GenerateArgs( |
| ('value', 'out.get()'))) |
| .Append(' return scoped_ptr<%s>();' % classname) |
| .Append(' return out.Pass();') |
| .Append('}') |
| ) |
| return c |
| |
| def _GenerateTypeToValue(self, cpp_namespace, type_): |
| """Generates a function that serializes the type into a base::Value. |
| E.g. for type "Foo" generates Foo::ToValue() |
| """ |
| if type_.property_type == PropertyType.OBJECT: |
| return self._GenerateObjectTypeToValue(cpp_namespace, type_) |
| elif type_.property_type == PropertyType.CHOICES: |
| return self._GenerateChoiceTypeToValue(cpp_namespace, type_) |
| else: |
| raise ValueError("Unsupported property type %s" % type_.type_) |
| |
| def _GenerateObjectTypeToValue(self, cpp_namespace, type_): |
| """Generates a function that serializes an object-representing type |
| into a base::DictionaryValue. |
| """ |
| c = Code() |
| (c.Sblock('scoped_ptr<base::DictionaryValue> %s::ToValue() const {' % |
| cpp_namespace) |
| .Append('scoped_ptr<base::DictionaryValue> value(' |
| 'new base::DictionaryValue());') |
| .Append() |
| ) |
| |
| for prop in type_.properties.values(): |
| if prop.optional: |
| # Optional enum values are generated with a NONE enum value. |
| underlying_type = self._type_helper.FollowRef(prop.type_) |
| if underlying_type.property_type == PropertyType.ENUM: |
| c.Sblock('if (%s != %s) {' % |
| (prop.unix_name, |
| self._type_helper.GetEnumNoneValue(prop.type_))) |
| else: |
| c.Sblock('if (%s.get()) {' % prop.unix_name) |
| |
| # ANY is a base::Value which is abstract and cannot be a direct member, so |
| # it will always be a pointer. |
| is_ptr = prop.optional or prop.type_.property_type == PropertyType.ANY |
| c.Append('value->SetWithoutPathExpansion("%s", %s);' % ( |
| prop.name, |
| self._CreateValueFromType(prop.type_, |
| 'this->%s' % prop.unix_name, |
| is_ptr=is_ptr))) |
| |
| if prop.optional: |
| c.Eblock('}'); |
| |
| if type_.additional_properties is not None: |
| if type_.additional_properties.property_type == PropertyType.ANY: |
| c.Append('value->MergeDictionary(&additional_properties);') |
| else: |
| # Non-copyable types will be wrapped in a linked_ptr for inclusion in |
| # maps, so we need to unwrap them. |
| needs_unwrap = ( |
| not self._type_helper.IsCopyable(type_.additional_properties)) |
| cpp_type = self._type_helper.GetCppType(type_.additional_properties, |
| is_in_container=True) |
| (c.Sblock('for (std::map<std::string, %s>::const_iterator it =' % |
| cpp_util.PadForGenerics(cpp_type)) |
| .Append(' additional_properties.begin();') |
| .Append(' it != additional_properties.end(); ++it) {') |
| .Append('value->SetWithoutPathExpansion(it->first, %s);' % |
| self._CreateValueFromType( |
| type_.additional_properties, |
| '%sit->second' % ('*' if needs_unwrap else ''))) |
| .Eblock('}') |
| ) |
| |
| return (c.Append() |
| .Append('return value.Pass();') |
| .Eblock('}')) |
| |
| def _GenerateChoiceTypeToValue(self, cpp_namespace, type_): |
| """Generates a function that serializes a choice-representing type |
| into a base::Value. |
| """ |
| c = Code() |
| c.Sblock('scoped_ptr<base::Value> %s::ToValue() const {' % cpp_namespace) |
| c.Append('scoped_ptr<base::Value> result;'); |
| for choice in type_.choices: |
| choice_var = 'as_%s' % choice.unix_name |
| (c.Sblock('if (%s) {' % choice_var) |
| .Append('DCHECK(!result) << "Cannot set multiple choices for %s";' % |
| type_.unix_name) |
| .Append('result.reset(%s);' % |
| self._CreateValueFromType(choice, '*%s' % choice_var)) |
| .Eblock('}') |
| ) |
| (c.Append('DCHECK(result) << "Must set at least one choice for %s";' % |
| type_.unix_name) |
| .Append('return result.Pass();') |
| .Eblock('}') |
| ) |
| return c |
| |
| def _GenerateFunction(self, function): |
| """Generates the definitions for function structs. |
| """ |
| c = Code() |
| |
| # TODO(kalman): use function.unix_name not Classname. |
| function_namespace = cpp_util.Classname(function.name) |
| """Windows has a #define for SendMessage, so to avoid any issues, we need |
| to not use the name. |
| """ |
| if function_namespace == 'SendMessage': |
| function_namespace = 'PassMessage' |
| (c.Append('namespace %s {' % function_namespace) |
| .Append() |
| ) |
| |
| # Params::Populate function |
| if function.params: |
| c.Concat(self._GeneratePropertyFunctions('Params', function.params)) |
| (c.Append('Params::Params() {}') |
| .Append('Params::~Params() {}') |
| .Append() |
| .Cblock(self._GenerateFunctionParamsCreate(function)) |
| ) |
| |
| # Results::Create function |
| if function.callback: |
| c.Concat(self._GenerateCreateCallbackArguments('Results', |
| function.callback)) |
| |
| c.Append('} // namespace %s' % function_namespace) |
| return c |
| |
| def _GenerateEvent(self, event): |
| # TODO(kalman): use event.unix_name not Classname. |
| c = Code() |
| event_namespace = cpp_util.Classname(event.name) |
| (c.Append('namespace %s {' % event_namespace) |
| .Append() |
| .Cblock(self._GenerateEventNameConstant(None, event)) |
| .Cblock(self._GenerateCreateCallbackArguments(None, event)) |
| .Append('} // namespace %s' % event_namespace) |
| ) |
| return c |
| |
| def _CreateValueFromType(self, type_, var, is_ptr=False): |
| """Creates a base::Value given a type. Generated code passes ownership |
| to caller. |
| |
| var: variable or variable* |
| |
| E.g for std::string, generate base::Value::CreateStringValue(var) |
| """ |
| underlying_type = self._type_helper.FollowRef(type_) |
| if (underlying_type.property_type == PropertyType.CHOICES or |
| underlying_type.property_type == PropertyType.OBJECT): |
| if is_ptr: |
| return '(%s)->ToValue().release()' % var |
| else: |
| return '(%s).ToValue().release()' % var |
| elif (underlying_type.property_type == PropertyType.ANY or |
| underlying_type.property_type == PropertyType.FUNCTION): |
| if is_ptr: |
| vardot = '(%s)->' % var |
| else: |
| vardot = '(%s).' % var |
| return '%sDeepCopy()' % vardot |
| elif underlying_type.property_type == PropertyType.ENUM: |
| return 'base::Value::CreateStringValue(ToString(%s))' % var |
| elif underlying_type.property_type == PropertyType.BINARY: |
| if is_ptr: |
| vardot = var + '->' |
| else: |
| vardot = var + '.' |
| return ('base::BinaryValue::CreateWithCopiedBuffer(%sdata(), %ssize())' % |
| (vardot, vardot)) |
| elif underlying_type.property_type == PropertyType.ARRAY: |
| return '%s.release()' % self._util_cc_helper.CreateValueFromArray( |
| underlying_type, |
| var, |
| is_ptr) |
| elif underlying_type.property_type.is_fundamental: |
| if is_ptr: |
| var = '*%s' % var |
| if underlying_type.property_type == PropertyType.STRING: |
| return 'new base::StringValue(%s)' % var |
| else: |
| return 'new base::FundamentalValue(%s)' % var |
| else: |
| raise NotImplementedError('Conversion of %s to base::Value not ' |
| 'implemented' % repr(type_.type_)) |
| |
| def _GenerateParamsCheck(self, function, var): |
| """Generates a check for the correct number of arguments when creating |
| Params. |
| """ |
| c = Code() |
| num_required = 0 |
| for param in function.params: |
| if not param.optional: |
| num_required += 1 |
| if num_required == len(function.params): |
| c.Sblock('if (%(var)s.GetSize() != %(total)d) {') |
| elif not num_required: |
| c.Sblock('if (%(var)s.GetSize() > %(total)d) {') |
| else: |
| c.Sblock('if (%(var)s.GetSize() < %(required)d' |
| ' || %(var)s.GetSize() > %(total)d) {') |
| (c.Concat(self._GenerateError( |
| '"expected %%(total)d arguments, got " ' |
| '+ base::IntToString(%%(var)s.GetSize())')) |
| .Append('return scoped_ptr<Params>();') |
| .Eblock('}') |
| .Substitute({ |
| 'var': var, |
| 'required': num_required, |
| 'total': len(function.params), |
| })) |
| return c |
| |
| def _GenerateFunctionParamsCreate(self, function): |
| """Generate function to create an instance of Params. The generated |
| function takes a base::ListValue of arguments. |
| |
| E.g for function "Bar", generate Bar::Params::Create() |
| """ |
| c = Code() |
| (c.Append('// static') |
| .Sblock('scoped_ptr<Params> Params::Create(%s) {' % self._GenerateParams( |
| ['const base::ListValue& args'])) |
| .Concat(self._GenerateParamsCheck(function, 'args')) |
| .Append('scoped_ptr<Params> params(new Params());')) |
| |
| for param in function.params: |
| c.Concat(self._InitializePropertyToDefault(param, 'params')) |
| |
| for i, param in enumerate(function.params): |
| # Any failure will cause this function to return. If any argument is |
| # incorrect or missing, those following it are not processed. Note that |
| # for optional arguments, we allow missing arguments and proceed because |
| # there may be other arguments following it. |
| failure_value = 'scoped_ptr<Params>()' |
| c.Append() |
| value_var = param.unix_name + '_value' |
| (c.Append('const base::Value* %(value_var)s = NULL;') |
| .Append('if (args.Get(%(i)s, &%(value_var)s) &&') |
| .Sblock(' !%(value_var)s->IsType(base::Value::TYPE_NULL)) {') |
| .Concat(self._GeneratePopulatePropertyFromValue( |
| param, value_var, 'params', failure_value)) |
| .Eblock('}') |
| ) |
| if not param.optional: |
| (c.Sblock('else {') |
| .Concat(self._GenerateError('"\'%%(key)s\' is required"')) |
| .Append('return %s;' % failure_value) |
| .Eblock('}')) |
| c.Substitute({'value_var': value_var, 'i': i, 'key': param.name}) |
| (c.Append() |
| .Append('return params.Pass();') |
| .Eblock('}') |
| .Append() |
| ) |
| |
| return c |
| |
| def _GeneratePopulatePropertyFromValue(self, |
| prop, |
| src_var, |
| dst_class_var, |
| failure_value): |
| """Generates code to populate property |prop| of |dst_class_var| (a |
| pointer) from a Value*. See |_GeneratePopulateVariableFromValue| for |
| semantics. |
| """ |
| return self._GeneratePopulateVariableFromValue(prop.type_, |
| src_var, |
| '%s->%s' % (dst_class_var, |
| prop.unix_name), |
| failure_value, |
| is_ptr=prop.optional) |
| |
| def _GeneratePopulateVariableFromValue(self, |
| type_, |
| src_var, |
| dst_var, |
| failure_value, |
| is_ptr=False): |
| """Generates code to populate a variable |dst_var| of type |type_| from a |
| Value* at |src_var|. The Value* is assumed to be non-NULL. In the generated |
| code, if |dst_var| fails to be populated then Populate will return |
| |failure_value|. |
| """ |
| c = Code() |
| c.Sblock('{') |
| |
| underlying_type = self._type_helper.FollowRef(type_) |
| |
| if underlying_type.property_type.is_fundamental: |
| if is_ptr: |
| (c.Append('%(cpp_type)s temp;') |
| .Sblock('if (!%s) {' % cpp_util.GetAsFundamentalValue( |
| self._type_helper.FollowRef(type_), src_var, '&temp')) |
| .Concat(self._GenerateError( |
| '"\'%%(key)s\': expected ' + '%s, got " + %s' % ( |
| type_.name, |
| self._util_cc_helper.GetValueTypeString( |
| '%%(src_var)s', True)))) |
| .Append('return %(failure_value)s;') |
| .Eblock('}') |
| .Append('%(dst_var)s.reset(new %(cpp_type)s(temp));') |
| ) |
| else: |
| (c.Sblock('if (!%s) {' % cpp_util.GetAsFundamentalValue( |
| self._type_helper.FollowRef(type_), |
| src_var, |
| '&%s' % dst_var)) |
| .Concat(self._GenerateError( |
| '"\'%%(key)s\': expected ' + '%s, got " + %s' % ( |
| type_.name, |
| self._util_cc_helper.GetValueTypeString( |
| '%%(src_var)s', True)))) |
| .Append('return %(failure_value)s;') |
| .Eblock('}') |
| ) |
| elif underlying_type.property_type == PropertyType.OBJECT: |
| if is_ptr: |
| (c.Append('const base::DictionaryValue* dictionary = NULL;') |
| .Sblock('if (!%(src_var)s->GetAsDictionary(&dictionary)) {') |
| .Concat(self._GenerateError( |
| '"\'%%(key)s\': expected dictionary, got " + ' + |
| self._util_cc_helper.GetValueTypeString('%%(src_var)s', True))) |
| .Append('return %(failure_value)s;') |
| .Eblock('}') |
| .Append('scoped_ptr<%(cpp_type)s> temp(new %(cpp_type)s());') |
| .Append('if (!%%(cpp_type)s::Populate(%s)) {' % self._GenerateArgs( |
| ('*dictionary', 'temp.get()'))) |
| .Append(' return %(failure_value)s;') |
| .Append('}') |
| .Append('%(dst_var)s = temp.Pass();') |
| ) |
| else: |
| (c.Append('const base::DictionaryValue* dictionary = NULL;') |
| .Sblock('if (!%(src_var)s->GetAsDictionary(&dictionary)) {') |
| .Concat(self._GenerateError( |
| '"\'%%(key)s\': expected dictionary, got " + ' + |
| self._util_cc_helper.GetValueTypeString('%%(src_var)s', True))) |
| .Append('return %(failure_value)s;') |
| .Eblock('}') |
| .Append('if (!%%(cpp_type)s::Populate(%s)) {' % self._GenerateArgs( |
| ('*dictionary', '&%(dst_var)s'))) |
| .Append(' return %(failure_value)s;') |
| .Append('}') |
| ) |
| elif underlying_type.property_type == PropertyType.FUNCTION: |
| if is_ptr: |
| c.Append('%(dst_var)s.reset(new base::DictionaryValue());') |
| elif underlying_type.property_type == PropertyType.ANY: |
| c.Append('%(dst_var)s.reset(%(src_var)s->DeepCopy());') |
| elif underlying_type.property_type == PropertyType.ARRAY: |
| # util_cc_helper deals with optional and required arrays |
| (c.Append('const base::ListValue* list = NULL;') |
| .Sblock('if (!%(src_var)s->GetAsList(&list)) {') |
| .Concat(self._GenerateError( |
| '"\'%%(key)s\': expected list, got " + ' + |
| self._util_cc_helper.GetValueTypeString('%%(src_var)s', True))) |
| .Append('return %(failure_value)s;') |
| .Eblock('}')) |
| item_type = self._type_helper.FollowRef(underlying_type.item_type) |
| if item_type.property_type == PropertyType.ENUM: |
| c.Concat(self._GenerateListValueToEnumArrayConversion( |
| item_type, |
| 'list', |
| dst_var, |
| failure_value, |
| is_ptr=is_ptr)) |
| else: |
| (c.Sblock('if (!%s) {' % self._util_cc_helper.PopulateArrayFromList( |
| underlying_type, |
| 'list', |
| dst_var, |
| is_ptr)) |
| .Concat(self._GenerateError( |
| '"unable to populate array \'%%(parent_key)s\'"')) |
| .Append('return %(failure_value)s;') |
| .Eblock('}') |
| ) |
| elif underlying_type.property_type == PropertyType.CHOICES: |
| if is_ptr: |
| (c.Append('scoped_ptr<%(cpp_type)s> temp(new %(cpp_type)s());') |
| .Append('if (!%%(cpp_type)s::Populate(%s))' % self._GenerateArgs( |
| ('*%(src_var)s', 'temp.get()'))) |
| .Append(' return %(failure_value)s;') |
| .Append('%(dst_var)s = temp.Pass();') |
| ) |
| else: |
| (c.Append('if (!%%(cpp_type)s::Populate(%s))' % self._GenerateArgs( |
| ('*%(src_var)s', '&%(dst_var)s'))) |
| .Append(' return %(failure_value)s;')) |
| elif underlying_type.property_type == PropertyType.ENUM: |
| c.Concat(self._GenerateStringToEnumConversion(type_, |
| src_var, |
| dst_var, |
| failure_value)) |
| elif underlying_type.property_type == PropertyType.BINARY: |
| (c.Sblock('if (!%(src_var)s->IsType(base::Value::TYPE_BINARY)) {') |
| .Concat(self._GenerateError( |
| '"\'%%(key)s\': expected binary, got " + ' + |
| self._util_cc_helper.GetValueTypeString('%%(src_var)s', True))) |
| .Append('return %(failure_value)s;') |
| .Eblock('}') |
| .Append('const base::BinaryValue* binary_value =') |
| .Append(' static_cast<const base::BinaryValue*>(%(src_var)s);') |
| ) |
| if is_ptr: |
| (c.Append('%(dst_var)s.reset(') |
| .Append(' new std::string(binary_value->GetBuffer(),') |
| .Append(' binary_value->GetSize()));') |
| ) |
| else: |
| (c.Append('%(dst_var)s.assign(binary_value->GetBuffer(),') |
| .Append(' binary_value->GetSize());') |
| ) |
| else: |
| raise NotImplementedError(type_) |
| return c.Eblock('}').Substitute({ |
| 'cpp_type': self._type_helper.GetCppType(type_), |
| 'src_var': src_var, |
| 'dst_var': dst_var, |
| 'failure_value': failure_value, |
| 'key': type_.name, |
| 'parent_key': type_.parent.name |
| }) |
| |
| def _GenerateListValueToEnumArrayConversion(self, |
| item_type, |
| src_var, |
| dst_var, |
| failure_value, |
| is_ptr=False): |
| """Returns Code that converts a ListValue of string constants from |
| |src_var| into an array of enums of |type_| in |dst_var|. On failure, |
| returns |failure_value|. |
| """ |
| c = Code() |
| accessor = '.' |
| if is_ptr: |
| accessor = '->' |
| cpp_type = self._type_helper.GetCppType(item_type, is_in_container=True) |
| c.Append('%s.reset(new std::vector<%s>);' % |
| (dst_var, cpp_util.PadForGenerics(cpp_type))) |
| (c.Sblock('for (base::ListValue::const_iterator it = %s->begin(); ' |
| 'it != %s->end(); ++it) {' % (src_var, src_var)) |
| .Append('%s tmp;' % self._type_helper.GetCppType(item_type)) |
| .Concat(self._GenerateStringToEnumConversion(item_type, |
| '(*it)', |
| 'tmp', |
| failure_value)) |
| .Append('%s%spush_back(tmp);' % (dst_var, accessor)) |
| .Eblock('}') |
| ) |
| return c |
| |
| def _GenerateStringToEnumConversion(self, |
| type_, |
| src_var, |
| dst_var, |
| failure_value): |
| """Returns Code that converts a string type in |src_var| to an enum with |
| type |type_| in |dst_var|. In the generated code, if |src_var| is not |
| a valid enum name then the function will return |failure_value|. |
| """ |
| c = Code() |
| enum_as_string = '%s_as_string' % type_.unix_name |
| (c.Append('std::string %s;' % enum_as_string) |
| .Sblock('if (!%s->GetAsString(&%s)) {' % (src_var, enum_as_string)) |
| .Concat(self._GenerateError( |
| '"\'%%(key)s\': expected string, got " + ' + |
| self._util_cc_helper.GetValueTypeString('%%(src_var)s', True))) |
| .Append('return %s;' % failure_value) |
| .Eblock('}') |
| .Append('%s = Parse%s(%s);' % (dst_var, |
| self._type_helper.GetCppType(type_), |
| enum_as_string)) |
| .Sblock('if (%s == %s) {' % (dst_var, |
| self._type_helper.GetEnumNoneValue(type_))) |
| .Concat(self._GenerateError( |
| '\"\'%%(key)s\': expected \\"' + |
| '\\" or \\"'.join(self._type_helper.FollowRef(type_).enum_values) + |
| '\\", got \\"" + %s + "\\""' % enum_as_string)) |
| .Append('return %s;' % failure_value) |
| .Eblock('}') |
| .Substitute({'src_var': src_var, 'key': type_.name}) |
| ) |
| return c |
| |
| def _GeneratePropertyFunctions(self, namespace, params): |
| """Generates the member functions for a list of parameters. |
| """ |
| return self._GenerateTypes(namespace, (param.type_ for param in params)) |
| |
| def _GenerateTypes(self, namespace, types): |
| """Generates the member functions for a list of types. |
| """ |
| c = Code() |
| for type_ in types: |
| c.Cblock(self._GenerateType(namespace, type_)) |
| return c |
| |
| def _GenerateEnumToString(self, cpp_namespace, type_): |
| """Generates ToString() which gets the string representation of an enum. |
| """ |
| c = Code() |
| classname = cpp_util.Classname(schema_util.StripNamespace(type_.name)) |
| |
| if cpp_namespace is not None: |
| c.Append('// static') |
| maybe_namespace = '' if cpp_namespace is None else '%s::' % cpp_namespace |
| |
| c.Sblock('std::string %sToString(%s enum_param) {' % |
| (maybe_namespace, classname)) |
| c.Sblock('switch (enum_param) {') |
| for enum_value in self._type_helper.FollowRef(type_).enum_values: |
| (c.Append('case %s: ' % self._type_helper.GetEnumValue(type_, enum_value)) |
| .Append(' return "%s";' % enum_value)) |
| (c.Append('case %s:' % self._type_helper.GetEnumNoneValue(type_)) |
| .Append(' return "";') |
| .Eblock('}') |
| .Append('NOTREACHED();') |
| .Append('return "";') |
| .Eblock('}') |
| ) |
| return c |
| |
| def _GenerateEnumFromString(self, cpp_namespace, type_): |
| """Generates FromClassNameString() which gets an enum from its string |
| representation. |
| """ |
| c = Code() |
| classname = cpp_util.Classname(schema_util.StripNamespace(type_.name)) |
| |
| if cpp_namespace is not None: |
| c.Append('// static') |
| maybe_namespace = '' if cpp_namespace is None else '%s::' % cpp_namespace |
| |
| c.Sblock('%s%s %sParse%s(const std::string& enum_string) {' % |
| (maybe_namespace, classname, maybe_namespace, classname)) |
| for i, enum_value in enumerate( |
| self._type_helper.FollowRef(type_).enum_values): |
| # This is broken up into all ifs with no else ifs because we get |
| # "fatal error C1061: compiler limit : blocks nested too deeply" |
| # on Windows. |
| (c.Append('if (enum_string == "%s")' % enum_value) |
| .Append(' return %s;' % |
| self._type_helper.GetEnumValue(type_, enum_value))) |
| (c.Append('return %s;' % self._type_helper.GetEnumNoneValue(type_)) |
| .Eblock('}') |
| ) |
| return c |
| |
| def _GenerateCreateCallbackArguments(self, function_scope, callback): |
| """Generate all functions to create Value parameters for a callback. |
| |
| E.g for function "Bar", generate Bar::Results::Create |
| E.g for event "Baz", generate Baz::Create |
| |
| function_scope: the function scope path, e.g. Foo::Bar for the function |
| Foo::Bar::Baz(). May be None if there is no function scope. |
| callback: the Function object we are creating callback arguments for. |
| """ |
| c = Code() |
| params = callback.params |
| c.Concat(self._GeneratePropertyFunctions(function_scope, params)) |
| |
| (c.Sblock('scoped_ptr<base::ListValue> %(function_scope)s' |
| 'Create(%(declaration_list)s) {') |
| .Append('scoped_ptr<base::ListValue> create_results(' |
| 'new base::ListValue());') |
| ) |
| declaration_list = [] |
| for param in params: |
| declaration_list.append(cpp_util.GetParameterDeclaration( |
| param, self._type_helper.GetCppType(param.type_))) |
| c.Append('create_results->Append(%s);' % |
| self._CreateValueFromType(param.type_, param.unix_name)) |
| c.Append('return create_results.Pass();') |
| c.Eblock('}') |
| c.Substitute({ |
| 'function_scope': ('%s::' % function_scope) if function_scope else '', |
| 'declaration_list': ', '.join(declaration_list), |
| 'param_names': ', '.join(param.unix_name for param in params) |
| }) |
| return c |
| |
| def _GenerateEventNameConstant(self, function_scope, event): |
| """Generates a constant string array for the event name. |
| """ |
| c = Code() |
| c.Append('const char kEventName[] = "%s.%s";' % ( |
| self._namespace.name, event.name)) |
| return c |
| |
| def _InitializePropertyToDefault(self, prop, dst): |
| """Initialize a model.Property to its default value inside an object. |
| |
| E.g for optional enum "state", generate dst->state = STATE_NONE; |
| |
| dst: Type* |
| """ |
| c = Code() |
| underlying_type = self._type_helper.FollowRef(prop.type_) |
| if (underlying_type.property_type == PropertyType.ENUM and |
| prop.optional): |
| c.Append('%s->%s = %s;' % ( |
| dst, |
| prop.unix_name, |
| self._type_helper.GetEnumNoneValue(prop.type_))) |
| return c |
| |
| def _GenerateError(self, body): |
| """Generates an error message pertaining to population failure. |
| |
| E.g 'expected bool, got int' |
| """ |
| c = Code() |
| if not self._generate_error_messages: |
| return c |
| (c.Append('if (error)') |
| .Append(' *error = ' + body + ';')) |
| return c |
| |
| def _GenerateParams(self, params): |
| """Builds the parameter list for a function, given an array of parameters. |
| """ |
| if self._generate_error_messages: |
| params = list(params) + ['std::string* error'] |
| return ', '.join(str(p) for p in params) |
| |
| def _GenerateArgs(self, args): |
| """Builds the argument list for a function, given an array of arguments. |
| """ |
| if self._generate_error_messages: |
| args = list(args) + ['error'] |
| return ', '.join(str(a) for a in args) |