Changeset 103763 in webkit


Ignore:
Timestamp:
Dec 28, 2011 5:29:33 AM (12 years ago)
Author:
yurys@chromium.org
Message:

Web Inspector: CodeGeneratorInspector.py: generate enum types.
https://bugs.webkit.org/show_bug.cgi?id=74954

Patch by Peter Rybin <peter.rybin@gmail.com> on 2011-12-28
Reviewed by Yury Semikhatsky.

Internal map of string contants is created. C enums are created for
each JSON enum.

  • inspector/CodeGeneratorInspector.py:

(EnumConstants.add_constant):
(EnumConstants):
(EnumConstants.get_enum_constant_code):
(TypeBindings.create_type_declaration_.EnumBinding.get_code_generator.CodeGenerator.generate_type_builder):
(TypeBindings.create_type_declaration_.EnumBinding.get_in_c_type_text):
(TypeBindings.create_type_declaration_.EnumBinding.get_setter_value_expression_pattern):
(TypeBindings.create_type_declaration_.PlainString.reduce_to_raw_type):
(TypeBindings.create_type_declaration_.PlainString.get_setter_value_expression_pattern):
(get_in_c_type_text):
(get_setter_value_expression_pattern):
(PlainObjectBinding.get_in_c_type_text):
(PlainObjectBinding.get_setter_value_expression_pattern):
(RawTypesBinding.get_in_c_type_text):
(RawTypesBinding.get_setter_value_expression_pattern):
(get_annotated_type_text):
(MethodGenerateModes.get_modes):
(MethodGenerateModes.StrictParameterMode.get_c_param_type_text):
(MethodGenerateModes.StrictParameterMode):
(MethodGenerateModes.StrictParameterMode.get_setter_value_expression):
(MethodGenerateModes.RawParameterMode.get_c_param_type_text):
(MethodGenerateModes.RawParameterMode):
(MethodGenerateModes.RawParameterMode.get_setter_value_expression):
(MethodGenerateModes.CombinedMode.get_c_param_type_text):
(MethodGenerateModes):
(MethodGenerateModes.CombinedMode):
(MethodGenerateModes.CombinedMode.get_setter_value_expression):

Location:
trunk/Source/WebCore
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/Source/WebCore/ChangeLog

    r103762 r103763  
     12011-12-28  Peter Rybin  <peter.rybin@gmail.com>
     2
     3        Web Inspector: CodeGeneratorInspector.py: generate enum types.
     4        https://bugs.webkit.org/show_bug.cgi?id=74954
     5
     6        Reviewed by Yury Semikhatsky.
     7
     8        Internal map of string contants is created. C enums are created for
     9        each JSON enum.
     10
     11        * inspector/CodeGeneratorInspector.py:
     12        (EnumConstants.add_constant):
     13        (EnumConstants):
     14        (EnumConstants.get_enum_constant_code):
     15        (TypeBindings.create_type_declaration_.EnumBinding.get_code_generator.CodeGenerator.generate_type_builder):
     16        (TypeBindings.create_type_declaration_.EnumBinding.get_in_c_type_text):
     17        (TypeBindings.create_type_declaration_.EnumBinding.get_setter_value_expression_pattern):
     18        (TypeBindings.create_type_declaration_.PlainString.reduce_to_raw_type):
     19        (TypeBindings.create_type_declaration_.PlainString.get_setter_value_expression_pattern):
     20        (get_in_c_type_text):
     21        (get_setter_value_expression_pattern):
     22        (PlainObjectBinding.get_in_c_type_text):
     23        (PlainObjectBinding.get_setter_value_expression_pattern):
     24        (RawTypesBinding.get_in_c_type_text):
     25        (RawTypesBinding.get_setter_value_expression_pattern):
     26        (get_annotated_type_text):
     27        (MethodGenerateModes.get_modes):
     28        (MethodGenerateModes.StrictParameterMode.get_c_param_type_text):
     29        (MethodGenerateModes.StrictParameterMode):
     30        (MethodGenerateModes.StrictParameterMode.get_setter_value_expression):
     31        (MethodGenerateModes.RawParameterMode.get_c_param_type_text):
     32        (MethodGenerateModes.RawParameterMode):
     33        (MethodGenerateModes.RawParameterMode.get_setter_value_expression):
     34        (MethodGenerateModes.CombinedMode.get_c_param_type_text):
     35        (MethodGenerateModes):
     36        (MethodGenerateModes.CombinedMode):
     37        (MethodGenerateModes.CombinedMode.get_setter_value_expression):
     38
    1392011-12-28  Hans Wennborg  <hans@chromium.org>
    240
  • trunk/Source/WebCore/inspector/CodeGeneratorInspector.py

    r103503 r103763  
    5252TYPE_NAME_FIX_MAP = {
    5353    "RGBA": "Rgba",  # RGBA is reported to be conflicting with a define name in Windows CE.
     54    "": "Empty",
    5455}
    5556
     
    520521
    521522
     523class EnumConstants:
     524    map_ = {}
     525    constants_ = []
     526
     527    @classmethod
     528    def add_constant(cls, value):
     529        if value in cls.map_:
     530            return cls.map_[value]
     531        else:
     532            pos = len(cls.map_)
     533            cls.map_[value] = pos
     534            cls.constants_.append(value)
     535            return pos
     536
     537    @classmethod
     538    def get_enum_constant_code(cls):
     539        output = []
     540        for item in cls.constants_:
     541            output.append("    \"" + item + "\"")
     542        return join(output, ",\n") + "\n"
     543
     544
    522545class TypeBindings:
    523546    @staticmethod
     
    527550        class Helper:
    528551            is_ad_hoc = False
     552            full_name_prefix = "TypeBuilder::" + context_domain_name + "::"
    529553
    530554            @staticmethod
     
    547571        class Helper:
    548572            is_ad_hoc = True
     573            full_name_prefix = ""
    549574
    550575            @staticmethod
     
    572597                            @staticmethod
    573598                            def generate_type_builder(writer, forward_listener):
    574                                 if comment_out:
    575                                     writer = writer.get_indented("// ")
    576599                                enum = json_typable["enum"]
    577600                                helper.write_doc(writer)
    578601                                enum_name = fixed_type_name.class_name
    579602                                fixed_type_name.output_comment(writer)
    580                                 writer.newline("namespace ")
     603                                writer.newline("struct ")
    581604                                writer.append(enum_name)
    582605                                writer.append(" {\n")
     606                                writer.newline("    enum Enum {\n")
    583607                                for enum_item in enum:
     608                                    enum_pos = EnumConstants.add_constant(enum_item)
     609
    584610                                    item_c_name = enum_item.replace('-', '_')
    585                                     writer.newline("const char* const ")
    586                                     writer.append(Capitalizer.upper_camel_case_to_lower(item_c_name))
    587                                     writer.append(" = \"")
    588                                     writer.append(enum_item)
    589                                     writer.append("\";\n")
    590                                 writer.newline("} // namespace ")
     611                                    item_c_name = Capitalizer.lower_camel_case_to_upper(item_c_name)
     612                                    if item_c_name in TYPE_NAME_FIX_MAP:
     613                                        item_c_name = TYPE_NAME_FIX_MAP[item_c_name]
     614                                    writer.newline("        ")
     615                                    writer.append(item_c_name)
     616                                    writer.append(" = ")
     617                                    writer.append("%s" % enum_pos)
     618                                    writer.append(",\n")
     619                                writer.newline("    };\n")
     620                                writer.newline("}; // struct ")
    591621                                writer.append(enum_name)
    592622                                writer.append("\n\n")
     
    600630                    @classmethod
    601631                    def get_in_c_type_text(cls, optional):
    602                         return cls.reduce_to_raw_type().get_c_param_type(ParamType.EVENT, optional).get_text()
     632                        return helper.full_name_prefix + fixed_type_name.class_name + "::Enum"
     633
     634                    @staticmethod
     635                    def get_setter_value_expression_pattern():
     636                        return "getEnumConstantValue(%s)"
    603637
    604638                    @staticmethod
     
    633667                    def reduce_to_raw_type():
    634668                        return RawTypes.String
     669
     670                    @staticmethod
     671                    def get_setter_value_expression_pattern():
     672                        return None
    635673
    636674                    @classmethod
     
    716754                                    param_type_binding = resolve_param_type(prop, context_domain_name, ad_hoc_type_context)
    717755                                    param_raw_type = param_type_binding.reduce_to_raw_type()
    718                                     annotated_type = get_annotated_type_text(param_raw_type.get_c_param_type(ParamType.TYPE_BUILDER_OUTPUT, False).get_text(),
    719                                         param_type_binding.get_in_c_type_text(False))
    720                                     writer.newline_multiline("""
     756                                    for param_type_opt in MethodGenerateModes.get_modes(param_type_binding):
     757                                        writer.newline_multiline("""
    721758        Builder<STATE | %s>& set%s(%s value)
    722759        {
    723760            COMPILE_ASSERT(!(STATE & %s), property_%s_already_set);
    724             m_result->set%s("%s", value);
     761            m_result->set%s("%s", %s);
    725762            return castState<%s>();
    726763        }
    727764"""
    728                                     % (state_enum_items[pos],
    729                                        Capitalizer.lower_camel_case_to_upper(prop_name),
    730                                        annotated_type,
    731                                        state_enum_items[pos], prop_name,
    732                                        param_raw_type.get_setter_name(), prop_name, state_enum_items[pos]))
     765                                        % (state_enum_items[pos],
     766                                           Capitalizer.lower_camel_case_to_upper(prop_name),
     767                                           param_type_opt.get_c_param_type_text(param_type_binding),
     768                                           state_enum_items[pos], prop_name,
     769                                           param_raw_type.get_setter_name(), prop_name,
     770                                           param_type_opt.get_setter_value_expression(param_type_binding, "value"),
     771                                           state_enum_items[pos]))
     772
     773                                        code_generator = param_type_binding.get_code_generator()
     774                                        if code_generator:
     775                                            code_generator.register_use(forward_listener)
    733776
    734777                                    pos += 1
    735 
    736                                     code_generator = param_type_binding.get_code_generator()
    737                                     if code_generator:
    738                                         code_generator.register_use(forward_listener)
    739778
    740779                                writer.newline_multiline("""
     
    774813                                    param_type_binding = resolve_param_type(prop, context_domain_name, ad_hoc_type_context)
    775814                                    setter_name = "set%s" % Capitalizer.lower_camel_case_to_upper(prop_name)
    776                                     writer.append_multiline("\n    void %s" % setter_name)
    777                                     annotated_type = get_annotated_type_text(param_type_binding.reduce_to_raw_type().get_c_param_type(ParamType.TYPE_BUILDER_OUTPUT, False).get_text(),
    778                                         param_type_binding.get_in_c_type_text(False))
    779                                     writer.append("(%s value)\n" % annotated_type)
    780                                     writer.newline("    {\n")
    781                                     writer.newline("        this->set%s(\"%s\", value);\n" % (param_type_binding.reduce_to_raw_type().get_setter_name(), prop["name"]))
    782                                     writer.newline("    }\n")
     815
     816                                    for param_type_opt in MethodGenerateModes.get_modes(param_type_binding):
     817                                        writer.append_multiline("\n    void %s" % setter_name)
     818                                        writer.append("(%s value)\n" % param_type_opt.get_c_param_type_text(param_type_binding))
     819                                        writer.newline("    {\n")
     820                                        writer.newline("        this->set%s(\"%s\", %s);\n"
     821                                            % (param_type_binding.reduce_to_raw_type().get_setter_name(), prop["name"],
     822                                               param_type_opt.get_setter_value_expression(param_type_binding, "value")))
     823                                        writer.newline("    }\n")
    783824
    784825                                    code_generator = param_type_binding.get_code_generator()
     
    826867                    @classmethod
    827868                    def get_in_c_type_text(cls, optional):
    828                         return "PassRefPtr<TypeBuilder::" + context_domain_name + "::" + fixed_type_name.class_name + ">"
     869                        return "PassRefPtr<" + helper.full_name_prefix + fixed_type_name.class_name + ">"
     870
     871                    @staticmethod
     872                    def get_setter_value_expression_pattern():
     873                        return None
    829874
    830875                    @staticmethod
     
    843888                    def get_in_c_type_text(cls, optional):
    844889                        return cls.reduce_to_raw_type().get_c_param_type(ParamType.EVENT, optional).get_text()
     890
     891                    @staticmethod
     892                    def get_setter_value_expression_pattern():
     893                        return None
    845894
    846895                    @staticmethod
     
    894943            def get_in_c_type_text(cls, optional):
    895944                return cls.reduce_to_raw_type().get_c_param_type(ParamType.EVENT, optional).get_text()
     945
     946            @staticmethod
     947            def get_setter_value_expression_pattern():
     948                return None
    896949
    897950            @staticmethod
     
    11001153namespace TypeBuilder {
    11011154${forwards}
     1155
     1156const String& getEnumConstantValue(int code);
     1157
    11021158${typeBuilders}
    11031159} // namespace TypeBuilder
     
    15421598$methods
    15431599
     1600namespace TypeBuilder {
     1601
     1602const String enum_constant_values[] = {
     1603$enumConstantValues};
     1604
     1605const String& getEnumConstantValue(int code) {
     1606    return enum_constant_values[0];
     1607}
     1608
     1609} // namespace TypeBuilder
     1610
    15441611} // namespace WebCore
    15451612
     
    15681635    else:
    15691636        return raw_type
     1637
     1638
     1639# Chooses method generate modes for a particular type. A particular setter
     1640# can be generated as one method with a simple parameter type,
     1641# as one method with a raw type name and commented annotation about expected
     1642# specialized type name or as overloaded method when raw and specialized
     1643# parameter types require different behavior.
     1644class MethodGenerateModes:
     1645    @classmethod
     1646    def get_modes(cls, type_binding):
     1647        if type_binding.get_setter_value_expression_pattern():
     1648            # In raw and strict modes method code is actually different.
     1649            return [cls.StrictParameterMode, cls.RawParameterMode]
     1650        else:
     1651            # In raw and strict modes method code is the same.
     1652            # Only put strict parameter type in comments.
     1653            return [cls.CombinedMode]
     1654
     1655    class StrictParameterMode:
     1656        @staticmethod
     1657        def get_c_param_type_text(type_binding):
     1658            return type_binding.get_in_c_type_text(False)
     1659
     1660        @staticmethod
     1661        def get_setter_value_expression(param_type_binding, value_ref):
     1662            pattern = param_type_binding.get_setter_value_expression_pattern()
     1663            if pattern:
     1664                return pattern % value_ref
     1665            else:
     1666                return value_ref
     1667
     1668    class RawParameterMode:
     1669        @staticmethod
     1670        def get_c_param_type_text(type_binding):
     1671            return type_binding.reduce_to_raw_type().get_c_param_type(ParamType.TYPE_BUILDER_OUTPUT, False).get_text()
     1672
     1673        @staticmethod
     1674        def get_setter_value_expression(param_type_binding, value_ref):
     1675            return value_ref
     1676
     1677    class CombinedMode:
     1678        @staticmethod
     1679        def get_c_param_type_text(type_binding):
     1680            return get_annotated_type_text(type_binding.reduce_to_raw_type().get_c_param_type(ParamType.TYPE_BUILDER_OUTPUT, False).get_text(),
     1681                type_binding.get_in_c_type_text(False))
     1682
     1683        @staticmethod
     1684        def get_setter_value_expression(param_type_binding, value_ref):
     1685            pattern = param_type_binding.get_setter_value_expression_pattern()
     1686            if pattern:
     1687                return pattern % value_ref
     1688            else:
     1689                return value_ref
    15701690
    15711691class Generator:
     
    16911811        ad_hoc_type_output = []
    16921812        frontend_method_declaration_lines.append(ad_hoc_type_output)
    1693         ad_hoc_type_writer = Writer(ad_hoc_type_output, "    ")
     1813        ad_hoc_type_writer = Writer(ad_hoc_type_output, "        ")
    16941814        if "parameters" in json_event:
    16951815            method_line_list.append("    RefPtr<InspectorObject> paramsObject = InspectorObject::create();\n")
     
    19532073frontend_cpp_file.write(Templates.frontend_cpp.substitute(None,
    19542074    constructorInit=join(Generator.frontend_constructor_init_list, ""),
    1955     methods=join(Generator.frontend_method_list, "\n")))
     2075    methods=join(Generator.frontend_method_list, "\n"),
     2076    enumConstantValues=EnumConstants.get_enum_constant_code()))
    19562077
    19572078backend_cpp_file.write(Templates.backend_cpp.substitute(None,
Note: See TracChangeset for help on using the changeset viewer.