| # Copyright 2019 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. |
| |
| import web_idl |
| |
| from . import name_style |
| from .blink_v8_bridge import blink_class_name |
| from .blink_v8_bridge import blink_type_info |
| from .blink_v8_bridge import make_blink_to_v8_value |
| from .blink_v8_bridge import make_default_value_expr |
| from .blink_v8_bridge import make_v8_to_blink_value |
| from .blink_v8_bridge import native_value_tag |
| from .code_node import Likeliness |
| from .code_node import ListNode |
| from .code_node import SequenceNode |
| from .code_node import SymbolNode |
| from .code_node import SymbolScopeNode |
| from .code_node import TextNode |
| from .code_node_cxx import CxxClassDefNode |
| from .code_node_cxx import CxxFuncDeclNode |
| from .code_node_cxx import CxxFuncDefNode |
| from .code_node_cxx import CxxIfElseNode |
| from .code_node_cxx import CxxLikelyIfNode |
| from .code_node_cxx import CxxNamespaceNode |
| from .codegen_accumulator import CodeGenAccumulator |
| from .codegen_context import CodeGenContext |
| from .codegen_expr import expr_from_exposure |
| from .codegen_format import format_template as _format |
| from .codegen_utils import collect_forward_decls_and_include_headers |
| from .codegen_utils import component_export |
| from .codegen_utils import component_export_header |
| from .codegen_utils import enclose_with_header_guard |
| from .codegen_utils import make_copyright_header |
| from .codegen_utils import make_forward_declarations |
| from .codegen_utils import make_header_include_directives |
| from .codegen_utils import write_code_node_to_file |
| from .mako_renderer import MakoRenderer |
| from .package_initializer import package_initializer |
| from .path_manager import PathManager |
| from .task_queue import TaskQueue |
| |
| |
| _DICT_MEMBER_PRESENCE_PREDICATES = { |
| "ScriptValue": "!{}.IsEmpty()", |
| "ScriptPromise": "!{}.IsEmpty()", |
| } |
| |
| |
| def _blink_member_name(member): |
| assert isinstance(member, web_idl.DictionaryMember) |
| |
| class BlinkMemberName(object): |
| def __init__(self, member): |
| blink_name = (member.code_generator_info.property_implemented_as |
| or member.identifier) |
| self.get_api = name_style.api_func(blink_name) |
| self.get_or_api = name_style.api_func(blink_name, "or") |
| self.set_api = name_style.api_func("set", blink_name) |
| self.has_api = name_style.api_func("has", blink_name) |
| # C++ data member that shows the presence of the IDL member. |
| self.presence_var = name_style.member_var("has", blink_name) |
| # C++ data member that holds the value of the IDL member. |
| self.value_var = name_style.member_var_f("member_{}", blink_name) |
| # Migration Adapters |
| self.get_non_null_api = name_style.api_func(blink_name, "non_null") |
| self.has_non_null_api = name_style.api_func( |
| "has", blink_name, "non_null") |
| |
| return BlinkMemberName(member) |
| |
| |
| def _is_member_always_present(member): |
| assert isinstance(member, web_idl.DictionaryMember) |
| return member.is_required or member.default_value is not None |
| |
| |
| def _does_use_presence_flag(member): |
| assert isinstance(member, web_idl.DictionaryMember) |
| return (not _is_member_always_present(member) and blink_type_info( |
| member.idl_type).member_t not in _DICT_MEMBER_PRESENCE_PREDICATES) |
| |
| |
| def _member_presence_expr(member): |
| assert isinstance(member, web_idl.DictionaryMember) |
| if _is_member_always_present(member): |
| return "true" |
| if _does_use_presence_flag(member): |
| return _blink_member_name(member).presence_var |
| blink_type = blink_type_info(member.idl_type).member_t |
| assert blink_type in _DICT_MEMBER_PRESENCE_PREDICATES |
| _1 = _blink_member_name(member).value_var |
| return _format(_DICT_MEMBER_PRESENCE_PREDICATES[blink_type], _1) |
| |
| |
| def bind_member_iteration_local_vars(code_node): |
| local_vars = [ |
| SymbolNode( |
| "current_context", "v8::Local<v8::Context> ${current_context} = " |
| "${isolate}->GetCurrentContext();"), |
| SymbolNode( |
| "v8_member_names", "const auto* ${v8_member_names} = " |
| "GetV8MemberNames(${isolate}).data();"), |
| SymbolNode( |
| "is_in_secure_context", "const bool ${is_in_secure_context} = " |
| "${execution_context}->IsSecureContext();"), |
| ] |
| |
| # Execution context |
| node = SymbolNode( |
| "execution_context", "ExecutionContext* ${execution_context} = " |
| "ToExecutionContext(${current_context});") |
| node.accumulate( |
| CodeGenAccumulator.require_include_headers([ |
| "third_party/blink/renderer/core/execution_context/execution_context.h" |
| ])) |
| local_vars.append(node) |
| |
| code_node.register_code_symbols(local_vars) |
| |
| |
| def _is_default_ctor_available(dictionary): |
| for member in dictionary.members: |
| if member.default_value is None: |
| continue |
| default_expr = make_default_value_expr(member.idl_type, |
| member.default_value) |
| if default_expr.initializer_deps: |
| return False |
| return True |
| |
| |
| def make_create_dict_funcs(cg_context): |
| assert isinstance(cg_context, CodeGenContext) |
| |
| dictionary = cg_context.dictionary |
| name = "Create" |
| return_type = "${class_name}*" |
| |
| decls = ListNode() |
| defs = ListNode() |
| |
| if _is_default_ctor_available(dictionary): |
| func_def = CxxFuncDefNode(name=name, |
| arg_decls=[], |
| return_type=return_type, |
| static=True) |
| decls.append(func_def) |
| func_def.set_base_template_vars(cg_context.template_bindings()) |
| func_def.body.append( |
| TextNode("return MakeGarbageCollected<${class_name}>();")) |
| |
| func_def = CxxFuncDefNode(name=name, |
| arg_decls=["v8::Isolate* isolate"], |
| return_type=return_type, |
| static=True) |
| decls.append(func_def) |
| func_def.set_base_template_vars(cg_context.template_bindings()) |
| func_def.body.append( |
| TextNode("return MakeGarbageCollected<${class_name}>(isolate);")) |
| |
| arg_decls = [ |
| "v8::Isolate* isolate", |
| "v8::Local<v8::Value> v8_value", |
| "ExceptionState& exception_state", |
| ] |
| func_decl = CxxFuncDeclNode(name=name, |
| arg_decls=arg_decls, |
| return_type=return_type, |
| static=True) |
| decls.append(func_decl) |
| func_def = CxxFuncDefNode(name=name, |
| class_name=cg_context.class_name, |
| arg_decls=arg_decls, |
| return_type=return_type) |
| defs.append(func_def) |
| func_def.set_base_template_vars(cg_context.template_bindings()) |
| |
| func_def.body.append( |
| TextNode("""\ |
| DCHECK(!v8_value.IsEmpty()); |
| |
| ${class_name}* dictionary = Create(isolate); |
| dictionary->FillMembers(isolate, v8_value, exception_state); |
| if (exception_state.HadException()) { |
| return nullptr; |
| } |
| return dictionary;""")) |
| |
| return decls, defs |
| |
| |
| def make_dict_constructors(cg_context): |
| decls = ListNode() |
| defs = ListNode() |
| |
| dictionary = cg_context.dictionary |
| class_name = blink_class_name(dictionary) |
| |
| member_initializer_list = [] |
| should_construct_in_source = False |
| for member in dictionary.own_members: |
| if member.default_value is None: |
| continue |
| # In order to avoid cyclic header inclusion of IDL dictionaries, do not |
| # put dictionary member's initialization in the class definition. |
| does_initialize_with_dict = member.default_value.idl_type.is_object |
| if does_initialize_with_dict: |
| should_construct_in_source = True |
| |
| default_expr = make_default_value_expr(member.idl_type, |
| member.default_value) |
| if (default_expr.initializer_deps == ["isolate"] |
| or does_initialize_with_dict): |
| _1 = _blink_member_name(member).value_var |
| _2 = default_expr.initializer_expr |
| member_initializer_list.append(_format("{_1}({_2})", _1=_1, _2=_2)) |
| |
| if _is_default_ctor_available(dictionary): |
| name = class_name |
| arg_decls = [] |
| return_type = "" |
| # In order to avoid cyclic header inclusion of IDL dictionaries, do not |
| # put dictionary member's initialization in the class definition. |
| if should_construct_in_source: |
| ctor_decl = CxxFuncDeclNode(name=name, |
| arg_decls=arg_decls, |
| return_type=return_type) |
| decls.append(ctor_decl) |
| ctor_def = CxxFuncDefNode( |
| name=name, |
| class_name=class_name, |
| arg_decls=arg_decls, |
| return_type=return_type, |
| member_initializer_list=member_initializer_list) |
| defs.append(ctor_def) |
| else: |
| ctor_decl = CxxFuncDeclNode(name=name, |
| arg_decls=arg_decls, |
| return_type=return_type, |
| default=True) |
| decls.append(ctor_decl) |
| |
| ctor_decl = CxxFuncDeclNode(name=class_name, |
| arg_decls=["v8::Isolate* isolate"], |
| return_type="", |
| explicit=True) |
| decls.append(ctor_decl) |
| ctor_decl.set_base_template_vars(cg_context.template_bindings()) |
| |
| member_initializer_list.insert(0, "BaseClass(${isolate})") |
| ctor_def = CxxFuncDefNode(name=class_name, |
| class_name=class_name, |
| arg_decls=["v8::Isolate* isolate"], |
| return_type="", |
| member_initializer_list=member_initializer_list) |
| defs.append(ctor_def) |
| ctor_def.set_base_template_vars(cg_context.template_bindings()) |
| ctor_def.add_template_var("isolate", "isolate") |
| |
| return decls, defs |
| |
| |
| def make_dict_member_get(cg_context): |
| assert isinstance(cg_context, CodeGenContext) |
| |
| member = cg_context.dict_member |
| blink_member_name = _blink_member_name(member) |
| name = blink_member_name.get_api |
| idl_type = member.idl_type.unwrap(typedef=True) |
| blink_type = blink_type_info(idl_type) |
| const_ref_t = blink_type.const_ref_t |
| ref_t = blink_type.ref_t |
| |
| # Since Blink conventionally prefers non-const references to const |
| # references for the certain types, makes const member's getters return a |
| # non-const reference. For example, "Node* foo() const;" is preferable to |
| # "const Node* foo() const;". |
| if (idl_type.unwrap().is_interface |
| or idl_type.unwrap().is_callback_interface |
| or idl_type.unwrap().is_callback_function |
| or idl_type.unwrap().is_buffer_source_type): |
| const_ref_t = ref_t |
| |
| decls = ListNode() |
| defs = ListNode() |
| |
| func_def = CxxFuncDefNode(name=name, |
| arg_decls=[], |
| return_type=const_ref_t, |
| const=True) |
| decls.append(func_def) |
| func_def.set_base_template_vars(cg_context.template_bindings()) |
| func_def.body.extend([ |
| TextNode(_format("DCHECK({}());", blink_member_name.has_api)), |
| TextNode(_format("return {};", blink_member_name.value_var)), |
| ]) |
| |
| if ref_t != const_ref_t: |
| func_def = CxxFuncDefNode(name=name, arg_decls=[], return_type=ref_t) |
| decls.append(func_def) |
| func_def.set_base_template_vars(cg_context.template_bindings()) |
| func_def.body.extend([ |
| TextNode(_format("DCHECK({}());", blink_member_name.has_api)), |
| TextNode(_format("return {};", blink_member_name.value_var)), |
| ]) |
| |
| if idl_type.is_numeric or idl_type.unwrap().is_string: |
| arg_type = blink_type.const_ref_t |
| return_type = blink_type.value_t |
| elif idl_type.unwrap().is_enumeration: |
| arg_type = ("base::nullopt_t" |
| if idl_type.is_nullable else blink_type.value_t) |
| return_type = blink_type.value_t |
| elif idl_type.unwrap().is_dictionary: |
| arg_type = "nullptr_t" |
| return_type = blink_type.const_ref_t |
| elif idl_type.unwrap().type_definition_object: |
| arg_type = "nullptr_t" |
| return_type = blink_type.ref_t |
| elif idl_type.is_nullable and (idl_type.unwrap().is_sequence |
| or idl_type.unwrap().is_frozen_array |
| or idl_type.unwrap().is_record): |
| arg_type = "base::nullopt_t" |
| return_type = blink_type.value_t |
| else: |
| arg_type = None |
| return_type = None |
| |
| if arg_type is not None or return_type is not None: |
| assert arg_type is not None and return_type is not None |
| |
| name = blink_member_name.get_or_api |
| arg_decls = [_format("{} fallback_value", arg_type)] |
| |
| def should_be_defined_in_source(member): |
| # sequence<Dictionary> and record<String, Dictionary> are |
| # implemented with HeapVector and Dictionary's definition is |
| # required while promise<Dictionary> doesn't require it. |
| def element_or_value_of(idl_type): |
| return (idl_type.unwrap().element_type |
| or idl_type.unwrap().value_type) |
| |
| idl_type = element_or_value_of(member.idl_type) |
| while idl_type and element_or_value_of(idl_type): |
| idl_type = element_or_value_of(idl_type) |
| return idl_type and idl_type.unwrap().is_dictionary |
| |
| # In order to avoid cyclic header inclusion of IDL dictionaries, |
| # whenever the function needs a dictionary's definition, do not put the |
| # function definition in the header file. |
| if should_be_defined_in_source(member): |
| func_decl = CxxFuncDeclNode(name=name, |
| arg_decls=arg_decls, |
| return_type=return_type, |
| const=True) |
| decls.append(func_decl) |
| func_def = CxxFuncDefNode(name=name, |
| class_name=cg_context.class_name, |
| arg_decls=arg_decls, |
| return_type=return_type, |
| const=True) |
| defs.append(func_def) |
| func_def.set_base_template_vars(cg_context.template_bindings()) |
| else: |
| func_def = CxxFuncDefNode(name=name, |
| arg_decls=arg_decls, |
| return_type=return_type, |
| const=True) |
| decls.append(func_def) |
| func_def.set_base_template_vars(cg_context.template_bindings()) |
| |
| body_node = TextNode( |
| _format("""\ |
| if ({has}()) {{ |
| return {get}(); |
| }} |
| return fallback_value;""", |
| has=blink_member_name.has_api, |
| get=blink_member_name.get_api)) |
| func_def.body.append(body_node) |
| |
| return decls, defs |
| |
| |
| def make_dict_member_has(cg_context): |
| assert isinstance(cg_context, CodeGenContext) |
| |
| member = cg_context.dict_member |
| |
| decls = ListNode() |
| defs = ListNode() |
| |
| func_def = CxxFuncDefNode( |
| name=_blink_member_name(member).has_api, |
| arg_decls=[], |
| return_type="bool", |
| const=True) |
| decls.append(func_def) |
| func_def.set_base_template_vars(cg_context.template_bindings()) |
| body = func_def.body |
| |
| _1 = _member_presence_expr(member) |
| body.append(TextNode(_format("return {_1};", _1=_1))) |
| |
| return decls, defs |
| |
| |
| def make_dict_member_set(cg_context): |
| assert isinstance(cg_context, CodeGenContext) |
| |
| T = TextNode |
| |
| member = cg_context.dict_member |
| blink_member_name = _blink_member_name(member) |
| real_type = member.idl_type.unwrap(typedef=True) |
| type_info = blink_type_info(real_type) |
| |
| decls = ListNode() |
| defs = ListNode() |
| |
| template_func_def = CxxFuncDefNode( |
| name=blink_member_name.set_api, |
| arg_decls=["T&& value"], |
| return_type="void", |
| template_params=["typename T"]) |
| decls.append(template_func_def) |
| |
| # This setter with the explicit type declaration makes it possible to set |
| # the dictionary member with uniform initialization (especially aggregate |
| # initialization), e.g. setIntVector({3, 1, 4, 1, 5}). |
| move_func_decl = CxxFuncDeclNode( |
| name=blink_member_name.set_api, |
| arg_decls=[_format("{}&&", type_info.member_t)], |
| return_type="void") |
| decls.append(move_func_decl) |
| |
| move_func_def = CxxFuncDefNode( |
| name=blink_member_name.set_api, |
| arg_decls=[_format("{}&& value", type_info.member_t)], |
| return_type="void", |
| class_name=cg_context.class_name) |
| defs.append(move_func_def) |
| |
| _1 = blink_member_name.value_var |
| template_func_def.body.append( |
| T(_format("{_1} = std::forward<T>(value);", _1=_1))) |
| move_func_def.body.append(T(_format("{_1} = value;", _1=_1))) |
| |
| if _does_use_presence_flag(member): |
| set_presense_expr = _format("{} = true;", |
| blink_member_name.presence_var) |
| template_func_def.body.append(T(set_presense_expr)) |
| move_func_def.body.append(T(set_presense_expr)) |
| |
| # Migration Adapter |
| if (real_type.is_nullable and |
| blink_type_info(real_type).typename.startswith("base::Optional")): |
| to_null_func_def = CxxFuncDefNode( |
| name=_format("{}ToNull", blink_member_name.set_api), |
| arg_decls=[], |
| return_type="void") |
| decls.append(to_null_func_def) |
| to_null_func_def.set_base_template_vars(cg_context.template_bindings()) |
| to_null_func_def.body.append( |
| T(_format("{}(base::nullopt);", blink_member_name.set_api))) |
| |
| return decls, defs |
| |
| |
| def make_dict_member_vars(cg_context): |
| assert isinstance(cg_context, CodeGenContext) |
| |
| member = cg_context.dict_member |
| |
| default_value_initializer = "" |
| if member.default_value: |
| default_expr = make_default_value_expr(member.idl_type, |
| member.default_value) |
| # In order to avoid cyclic header inclusion of IDL dictionaries, do not |
| # put dictionary member's initialization in the class definition. |
| if (default_expr.initializer_expr is not None |
| and not default_expr.initializer_deps |
| and not member.default_value.idl_type.is_object): |
| default_value_initializer = _format("{{{}}}", |
| default_expr.initializer_expr) |
| |
| _1 = blink_type_info(member.idl_type).member_t |
| _2 = _blink_member_name(member).value_var |
| _3 = default_value_initializer |
| value_var_def = TextNode(_format("{_1} {_2}{_3};", _1=_1, _2=_2, _3=_3)) |
| |
| if _does_use_presence_flag(member): |
| _1 = _blink_member_name(member).presence_var |
| presense_var_def = TextNode(_format("bool {_1} = false;", _1=_1)) |
| else: |
| presense_var_def = None |
| |
| return value_var_def, presense_var_def |
| |
| |
| def make_dict_member_migration_adapters(cg_context): |
| assert isinstance(cg_context, CodeGenContext) |
| |
| member = cg_context.dict_member |
| blink_member_name = _blink_member_name(member) |
| idl_type = member.idl_type |
| blink_type = blink_type_info(idl_type) |
| real_type = idl_type.unwrap(typedef=True) |
| |
| if (not real_type.is_nullable |
| or blink_type_info(real_type.inner_type).has_null_value): |
| return None, None |
| |
| decls = ListNode([TextNode("// Migration Adapters")]) |
| defs = ListNode() |
| |
| # Accessors for non-null values, if the usual getter returns |
| # base::Optional<T>. |
| blink_inner_type = blink_type_info(real_type.inner_type) |
| get_api = blink_member_name.get_api |
| has_api = blink_member_name.has_api |
| get_non_null_api = blink_member_name.get_non_null_api |
| has_non_null_api = blink_member_name.has_non_null_api |
| |
| func_def = CxxFuncDefNode(name=get_non_null_api, |
| arg_decls=[], |
| return_type=blink_inner_type.const_ref_t, |
| const=True) |
| decls.extend([ |
| TextNode( |
| _format( |
| """\ |
| // Returns the value if this member has a non-null value. Call |
| // |{}| in advance to check the condition.""", has_non_null_api)), |
| func_def, |
| ]) |
| func_def.set_base_template_vars(cg_context.template_bindings()) |
| func_def.body.extend([ |
| TextNode(_format("DCHECK({}());", has_non_null_api)), |
| TextNode(_format("return {}().value();", get_api)), |
| ]) |
| |
| if blink_inner_type.ref_t != blink_inner_type.const_ref_t: |
| func_def = CxxFuncDefNode(name=get_non_null_api, |
| arg_decls=[], |
| return_type=blink_inner_type.ref_t) |
| decls.append(func_def) |
| func_def.set_base_template_vars(cg_context.template_bindings()) |
| func_def.body.extend([ |
| TextNode(_format("DCHECK({}());", has_non_null_api)), |
| TextNode(_format("return {}().value();", get_api)), |
| ]) |
| |
| func_def = CxxFuncDefNode(name=has_non_null_api, |
| arg_decls=[], |
| return_type="bool", |
| const=True) |
| decls.extend([ |
| TextNode("""\ |
| // Returns true iff this member has a non-null value. Returns false if the |
| // value is missing or the null value."""), |
| func_def, |
| ]) |
| func_def.set_base_template_vars(cg_context.template_bindings()) |
| func_def.body.append( |
| TextNode(_format("return {}() && {}().has_value();", has_api, |
| get_api))) |
| |
| return decls, defs |
| |
| |
| def make_get_v8_dict_member_names_func(cg_context): |
| assert isinstance(cg_context, CodeGenContext) |
| |
| dictionary = cg_context.dictionary |
| name = "GetV8MemberNames" |
| arg_decls = ["v8::Isolate* isolate"] |
| return_type = "const base::span<const v8::Eternal<v8::Name>>" |
| |
| func_decl = CxxFuncDeclNode( |
| name=name, arg_decls=arg_decls, return_type=return_type, static=True) |
| func_def = CxxFuncDefNode( |
| name=name, |
| class_name=cg_context.class_name, |
| arg_decls=arg_decls, |
| return_type=return_type) |
| func_def.set_base_template_vars(cg_context.template_bindings()) |
| body = func_def.body |
| |
| if dictionary.own_members: |
| pattern = "static const char* const kKeyStrings[] = {{{_1}}};" |
| _1 = ", ".join( |
| _format("\"{}\"", member.identifier) |
| for member in dictionary.own_members) |
| body.extend([ |
| TextNode(_format(pattern, _1=_1)), |
| TextNode("return V8PerIsolateData::From(isolate)" |
| "->FindOrCreateEternalNameCache(kKeyStrings, " |
| "kKeyStrings);"), |
| ]) |
| else: |
| body.append(TextNode("return {};")) |
| |
| return func_decl, func_def |
| |
| |
| def make_fill_with_dict_members_func(cg_context): |
| assert isinstance(cg_context, CodeGenContext) |
| |
| dictionary = cg_context.dictionary |
| name = "FillWithMembers" |
| arg_decls = [ |
| "v8::Isolate* isolate", |
| "v8::Local<v8::Object> creation_context", |
| "v8::Local<v8::Object> v8_dictionary", |
| ] |
| return_type = "bool" |
| |
| func_decl = CxxFuncDeclNode( |
| name=name, |
| arg_decls=arg_decls, |
| return_type=return_type, |
| const=True, |
| override=True) |
| func_def = CxxFuncDefNode( |
| name=name, |
| class_name=cg_context.class_name, |
| arg_decls=arg_decls, |
| return_type=return_type, |
| const=True) |
| func_def.set_base_template_vars(cg_context.template_bindings()) |
| body = func_def.body |
| |
| if dictionary.inherited: |
| text = """\ |
| if (!BaseClass::FillWithMembers(isolate, creation_context, v8_dictionary)) { |
| return false; |
| }""" |
| body.append(TextNode(text)) |
| |
| body.append( |
| TextNode("return FillWithOwnMembers(" |
| "isolate, creation_context, v8_dictionary);")) |
| |
| return func_decl, func_def |
| |
| |
| def make_fill_with_own_dict_members_func(cg_context): |
| assert isinstance(cg_context, CodeGenContext) |
| |
| dictionary = cg_context.dictionary |
| own_members = dictionary.own_members |
| name = "FillWithOwnMembers" |
| arg_decls = [ |
| "v8::Isolate* isolate", |
| "v8::Local<v8::Object> creation_context", |
| "v8::Local<v8::Object> v8_dictionary", |
| ] |
| return_type = "bool" |
| |
| func_decl = CxxFuncDeclNode( |
| name=name, arg_decls=arg_decls, return_type=return_type, const=True) |
| func_def = CxxFuncDefNode( |
| name=name, |
| class_name=cg_context.class_name, |
| arg_decls=arg_decls, |
| return_type=return_type, |
| const=True) |
| func_def.set_base_template_vars(cg_context.template_bindings()) |
| body = func_def.body |
| body.add_template_var("isolate", "isolate") |
| body.add_template_var("creation_context", "creation_context") |
| body.add_template_var("v8_dictionary", "v8_dictionary") |
| bind_member_iteration_local_vars(body) |
| |
| for index, member in enumerate(own_members): |
| member_name = _blink_member_name(member) |
| v8_member_name = name_style.local_var_f("v8_member_{}", |
| member.identifier) |
| body.register_code_symbol( |
| make_blink_to_v8_value(v8_member_name, |
| "{}()".format(member_name.get_api), |
| member.idl_type, "${creation_context}")) |
| node = CxxLikelyIfNode( |
| cond="{}()".format(member_name.has_api), |
| body=TextNode( |
| _format( |
| "${v8_dictionary}->CreateDataProperty(" |
| "${current_context}, " |
| "${v8_member_names}[{index}].Get(${isolate}), " |
| "${{{v8_member_name}}}" |
| ").ToChecked();", |
| index=index, |
| v8_member_name=v8_member_name))) |
| conditional = expr_from_exposure(member.exposure) |
| if not conditional.is_always_true: |
| node = CxxLikelyIfNode(cond=conditional, body=node) |
| body.append(node) |
| |
| body.append(TextNode("return true;")) |
| |
| return func_decl, func_def |
| |
| |
| def make_fill_dict_members_func(cg_context): |
| assert isinstance(cg_context, CodeGenContext) |
| |
| T = TextNode |
| |
| dictionary = cg_context.dictionary |
| own_members = dictionary.own_members |
| required_own_members = list( |
| member for member in own_members if member.is_required) |
| name = "FillMembers" |
| arg_decls = [ |
| "v8::Isolate* isolate", |
| "v8::Local<v8::Value> v8_value", |
| "ExceptionState& exception_state", |
| ] |
| return_type = "void" |
| |
| func_decl = CxxFuncDeclNode( |
| name=name, arg_decls=arg_decls, return_type=return_type) |
| func_def = CxxFuncDefNode( |
| name=name, |
| class_name=cg_context.class_name, |
| arg_decls=arg_decls, |
| return_type=return_type) |
| func_def.set_base_template_vars(cg_context.template_bindings()) |
| |
| if required_own_members: |
| check_required_members_node = T("""\ |
| if (v8_value->IsNullOrUndefined()) { |
| exception_state.ThrowTypeError(ExceptionMessages::FailedToConstruct( |
| "${dictionary.identifier}", |
| "has required members, but null/undefined was passed.")); |
| return; |
| }""") |
| else: |
| check_required_members_node = T("""\ |
| if (v8_value->IsNullOrUndefined()) { |
| return; |
| }""") |
| |
| # [PermissiveDictionaryConversion] |
| if "PermissiveDictionaryConversion" in dictionary.extended_attributes: |
| permissive_conversion_node = T("""\ |
| if (!v8_value->IsObject()) { |
| // [PermissiveDictionaryConversion] |
| return; |
| }""") |
| else: |
| permissive_conversion_node = T("""\ |
| if (!v8_value->IsObject()) { |
| exception_state.ThrowTypeError( |
| ExceptionMessages::FailedToConstruct( |
| "${dictionary.identifier}", "The value is not of type Object")); |
| return; |
| }""") |
| |
| call_internal_func_node = T("""\ |
| FillMembersInternal(isolate, v8_value.As<v8::Object>(), exception_state);""") |
| |
| func_def.body.extend([ |
| check_required_members_node, |
| permissive_conversion_node, |
| call_internal_func_node, |
| ]) |
| |
| return func_decl, func_def |
| |
| |
| def make_fill_dict_members_internal_func(cg_context): |
| assert isinstance(cg_context, CodeGenContext) |
| |
| T = TextNode |
| |
| dictionary = cg_context.dictionary |
| own_members = dictionary.own_members |
| name = "FillMembersInternal" |
| arg_decls = [ |
| "v8::Isolate* isolate", |
| "v8::Local<v8::Object> v8_dictionary", |
| "ExceptionState& exception_state", |
| ] |
| return_type = "void" |
| func_decl = CxxFuncDeclNode( |
| name=name, arg_decls=arg_decls, return_type=return_type) |
| func_def = CxxFuncDefNode( |
| name=name, |
| class_name=cg_context.class_name, |
| arg_decls=arg_decls, |
| return_type=return_type) |
| func_def.set_base_template_vars(cg_context.template_bindings()) |
| body = func_def.body |
| body.add_template_var("isolate", "isolate") |
| body.add_template_var("exception_state", "exception_state") |
| bind_member_iteration_local_vars(body) |
| body.register_code_symbols([ |
| SymbolNode("try_block", "v8::TryCatch ${try_block}(${isolate});"), |
| SymbolNode("v8_value", "v8::Local<v8::Value> ${v8_value};"), |
| SymbolNode("unused_presence_var", "bool ${unused_presence_var};"), |
| ]) |
| |
| if dictionary.inherited: |
| text = """\ |
| BaseClass::FillMembersInternal(${isolate}, v8_dictionary, ${exception_state}); |
| if (${exception_state}.HadException()) { |
| return; |
| } |
| """ |
| body.append(T(text)) |
| |
| for key_index, member in enumerate(own_members): |
| body.append(make_fill_own_dict_member(key_index, member)) |
| |
| return func_decl, func_def |
| |
| |
| def make_fill_own_dict_member(key_index, member): |
| assert isinstance(key_index, int) |
| assert isinstance(member, web_idl.DictionaryMember) |
| |
| pattern = """\ |
| if (!bindings::ConvertDictionaryMember<{nvt_tag}, {is_required}>( |
| ${isolate}, |
| ${current_context}, |
| v8_dictionary, |
| ${v8_member_names}[{key_index}].Get(${isolate}), |
| "${{dictionary.identifier}}", |
| "{member_name}", |
| {value_var}, |
| {presence_var}, |
| ${try_block}, |
| ${exception_state})) {{ |
| return; |
| }}""" |
| if _does_use_presence_flag(member): |
| presence_var = _blink_member_name(member).presence_var |
| else: |
| presence_var = "${unused_presence_var}" |
| node = TextNode( |
| _format(pattern, |
| nvt_tag=native_value_tag(member.idl_type), |
| is_required="true" if member.is_required else "false", |
| key_index=key_index, |
| member_name=member.identifier, |
| value_var=_blink_member_name(member).value_var, |
| presence_var=presence_var)) |
| |
| conditional = expr_from_exposure(member.exposure) |
| if not conditional.is_always_true: |
| node = CxxLikelyIfNode(cond=conditional, body=node) |
| |
| return node |
| |
| |
| def make_dict_trace_func(cg_context): |
| assert isinstance(cg_context, CodeGenContext) |
| |
| T = TextNode |
| |
| dictionary = cg_context.dictionary |
| own_members = dictionary.own_members |
| name = "Trace" |
| arg_decls = ["Visitor* visitor"] |
| return_type = "void" |
| |
| func_decl = CxxFuncDeclNode(name=name, |
| arg_decls=arg_decls, |
| return_type=return_type, |
| const=True, |
| override=True) |
| func_def = CxxFuncDefNode(name=name, |
| class_name=cg_context.class_name, |
| arg_decls=arg_decls, |
| return_type=return_type, |
| const=True) |
| func_def.set_base_template_vars(cg_context.template_bindings()) |
| body = func_def.body |
| |
| def make_trace_member_node(member): |
| pattern = "TraceIfNeeded<{_1}>::Trace(visitor, {_2});" |
| _1 = blink_type_info(member.idl_type).member_t |
| _2 = _blink_member_name(member).value_var |
| return TextNode(_format(pattern, _1=_1, _2=_2)) |
| |
| body.extend(list(map(make_trace_member_node, own_members))) |
| body.append(TextNode("BaseClass::Trace(visitor);")) |
| |
| return func_decl, func_def |
| |
| |
| def generate_dictionary(dictionary_identifier): |
| assert isinstance(dictionary_identifier, web_idl.Identifier) |
| |
| web_idl_database = package_initializer().web_idl_database() |
| dictionary = web_idl_database.find(dictionary_identifier) |
| |
| path_manager = PathManager(dictionary) |
| assert path_manager.api_component == path_manager.impl_component, ( |
| "We don't support partial dictionaries across components yet.") |
| api_component = path_manager.api_component |
| for_testing = dictionary.code_generator_info.for_testing |
| |
| path_manager = PathManager(dictionary) |
| class_name = name_style.class_(blink_class_name(dictionary)) |
| if dictionary.inherited: |
| base_class_name = blink_class_name(dictionary.inherited) |
| else: |
| base_class_name = "bindings::DictionaryBase" |
| |
| cg_context = CodeGenContext( |
| dictionary=dictionary, |
| class_name=class_name, |
| base_class_name=base_class_name) |
| |
| # Filepaths |
| header_path = path_manager.api_path(ext="h") |
| source_path = path_manager.api_path(ext="cc") |
| |
| # Root nodes |
| header_node = ListNode(tail="\n") |
| header_node.set_accumulator(CodeGenAccumulator()) |
| header_node.set_renderer(MakoRenderer()) |
| source_node = ListNode(tail="\n") |
| source_node.set_accumulator(CodeGenAccumulator()) |
| source_node.set_renderer(MakoRenderer()) |
| |
| # Namespaces |
| header_blink_ns = CxxNamespaceNode(name_style.namespace("blink")) |
| source_blink_ns = CxxNamespaceNode(name_style.namespace("blink")) |
| |
| # Class definitions |
| class_def = CxxClassDefNode(cg_context.class_name, |
| base_class_names=[cg_context.base_class_name], |
| export=component_export( |
| api_component, for_testing)) |
| class_def.set_base_template_vars(cg_context.template_bindings()) |
| class_def.top_section.append( |
| TextNode("using BaseClass = ${base_class_name};")) |
| |
| # Create functions |
| create_decl, create_def = make_create_dict_funcs(cg_context) |
| |
| # Constructor and destructor |
| constructor_decls, constructor_defs = make_dict_constructors(cg_context) |
| destructor_decl = CxxFuncDeclNode( |
| name="~${class_name}", arg_decls=[], return_type="", default=True) |
| |
| # Fill with members (Blink -> V8 conversion) |
| (fill_with_members_decl, |
| fill_with_members_def) = make_fill_with_dict_members_func(cg_context) |
| (fill_with_own_members_decl, fill_with_own_members_def |
| ) = make_fill_with_own_dict_members_func(cg_context) |
| |
| # Fill members (V8 -> Blink conversion) |
| (fill_members_decl, |
| fill_members_def) = make_fill_dict_members_func(cg_context) |
| (fill_members_internal_decl, fill_members_internal_def |
| ) = make_fill_dict_members_internal_func(cg_context) |
| |
| # Misc. functions |
| (get_v8_member_names_decl, |
| get_v8_member_names_def) = make_get_v8_dict_member_names_func(cg_context) |
| trace_decl, trace_def = make_dict_trace_func(cg_context) |
| |
| member_accessor_decls = ListNode() |
| member_accessor_defs = ListNode() |
| member_value_var_defs = ListNode() |
| member_presense_var_defs = ListNode() |
| for member in cg_context.dictionary.own_members: |
| member_context = cg_context.make_copy(dict_member=member) |
| get_decls, get_defs = make_dict_member_get(member_context) |
| has_decls, has_defs = make_dict_member_has(member_context) |
| set_decls, set_defs = make_dict_member_set(member_context) |
| value_var_def, presense_var_def = make_dict_member_vars(member_context) |
| (migration_adapter_decls, migration_adapter_defs |
| ) = make_dict_member_migration_adapters(member_context) |
| member_accessor_decls.extend([ |
| TextNode(""), |
| get_decls, |
| has_decls, |
| set_decls, |
| migration_adapter_decls, |
| ]) |
| member_accessor_defs.extend([ |
| TextNode(""), |
| get_defs, |
| has_defs, |
| set_defs, |
| migration_adapter_defs, |
| ]) |
| member_value_var_defs.append(value_var_def) |
| member_presense_var_defs.append(presense_var_def) |
| |
| # Header part (copyright, include directives, and forward declarations) |
| header_node.extend([ |
| make_copyright_header(), |
| TextNode(""), |
| enclose_with_header_guard( |
| ListNode([ |
| make_header_include_directives(header_node.accumulator), |
| TextNode(""), |
| header_blink_ns, |
| ]), name_style.header_guard(header_path)), |
| ]) |
| header_blink_ns.body.extend([ |
| make_forward_declarations(header_node.accumulator), |
| TextNode(""), |
| ]) |
| source_node.extend([ |
| make_copyright_header(), |
| TextNode(""), |
| TextNode("#include \"{}\"".format(header_path)), |
| TextNode(""), |
| make_header_include_directives(source_node.accumulator), |
| TextNode(""), |
| source_blink_ns, |
| ]) |
| source_blink_ns.body.extend([ |
| make_forward_declarations(source_node.accumulator), |
| TextNode(""), |
| ]) |
| |
| # Assemble the parts. |
| header_node.accumulator.add_class_decls(["ExceptionState"]) |
| header_node.accumulator.add_include_headers([ |
| (PathManager(dictionary.inherited).api_path(ext="h") |
| if dictionary.inherited else |
| "third_party/blink/renderer/platform/bindings/dictionary_base.h"), |
| component_export_header(api_component, for_testing), |
| "v8/include/v8.h", |
| ]) |
| source_node.accumulator.add_include_headers([ |
| "third_party/blink/renderer/bindings/core/v8/generated_code_helper.h", |
| "third_party/blink/renderer/bindings/core/v8/native_value_traits_impl.h", |
| "third_party/blink/renderer/platform/bindings/exception_messages.h", |
| "third_party/blink/renderer/platform/bindings/exception_state.h", |
| "third_party/blink/renderer/platform/bindings/v8_per_isolate_data.h", |
| ]) |
| (header_forward_decls, header_include_headers, source_forward_decls, |
| source_include_headers) = collect_forward_decls_and_include_headers( |
| map(lambda member: member.idl_type, dictionary.own_members)) |
| header_node.accumulator.add_class_decls(header_forward_decls) |
| header_node.accumulator.add_include_headers(header_include_headers) |
| source_node.accumulator.add_class_decls(source_forward_decls) |
| source_node.accumulator.add_include_headers(source_include_headers) |
| |
| header_blink_ns.body.append(class_def) |
| class_def.public_section.extend([ |
| create_decl, |
| constructor_decls, |
| destructor_decl, |
| TextNode(""), |
| trace_decl, |
| TextNode(""), |
| member_accessor_decls, |
| ]) |
| class_def.protected_section.extend([ |
| fill_with_members_decl, |
| TextNode(""), |
| fill_members_internal_decl, |
| ]) |
| class_def.private_section.extend([ |
| get_v8_member_names_decl, |
| TextNode(""), |
| fill_with_own_members_decl, |
| TextNode(""), |
| fill_members_decl, |
| TextNode(""), |
| member_value_var_defs, |
| TextNode(""), |
| member_presense_var_defs, |
| ]) |
| source_blink_ns.body.extend([ |
| constructor_defs, |
| TextNode(""), |
| get_v8_member_names_def, |
| TextNode(""), |
| create_def, |
| TextNode(""), |
| fill_with_members_def, |
| TextNode(""), |
| fill_with_own_members_def, |
| TextNode(""), |
| fill_members_def, |
| TextNode(""), |
| fill_members_internal_def, |
| TextNode(""), |
| member_accessor_defs, |
| TextNode(""), |
| trace_def, |
| ]) |
| |
| # Write down to the files. |
| write_code_node_to_file(header_node, path_manager.gen_path_to(header_path)) |
| write_code_node_to_file(source_node, path_manager.gen_path_to(source_path)) |
| |
| |
| def generate_dictionaries(task_queue): |
| assert isinstance(task_queue, TaskQueue) |
| |
| web_idl_database = package_initializer().web_idl_database() |
| |
| for dictionary in web_idl_database.dictionaries: |
| task_queue.post_task(generate_dictionary, dictionary.identifier) |
