sky/engine/bindings-dart/dart/scripts/templates/methods_cpp.template - Issue 918273002: Remove bindings-dart

Unified Diff: sky/engine/bindings-dart/dart/scripts/templates/methods_cpp.template

Issue 918273002: Remove bindings-dart (Closed) Base URL: git@github.com:domokit/mojo.git@master

Patch Set: Created 5 years, 10 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

« no previous file with comments | « sky/engine/bindings-dart/dart/scripts/templates/interface_h.template ('k') | sky/engine/bindings-dart/dart/scripts/templates/templates.gypi » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Hide Comments ('s')

Index: sky/engine/bindings-dart/dart/scripts/templates/methods_cpp.template

diff --git a/sky/engine/bindings-dart/dart/scripts/templates/methods_cpp.template b/sky/engine/bindings-dart/dart/scripts/templates/methods_cpp.template

deleted file mode 100644

index 60847af25aa83100632af2c92e0fe6ea615a6952..0000000000000000000000000000000000000000

--- a/sky/engine/bindings-dart/dart/scripts/templates/methods_cpp.template

+++ /dev/null

@@ -1,498 +0,0 @@

-{##############################################################################}

-{# FIXME: We should return a rejected Promise if an error occurs in this

-function when ALL methods in this overload return Promise. In order to do so,

-we must ensure either ALL or NO methods in this overload return Promise #}

-{% macro overload_resolution_method(method) %}

-{% set overloads = method.overloads %}

-{% if method.is_static %}

- {% set offset = 0 %}

-{% else %}

- {% set offset = 1 %}

-{% endif %}

-static void {{static_method_name(overloads.name)}}Dispatcher(Dart_NativeArguments args)

- Dart_Handle exception = 0;

- const int argOffset = {{offset}};

- int argCount = Dart_GetNativeArgumentCount(args) - argOffset;

- {# First resolve by length #}

- {# 2. Initialize argcount to be min(maxarg, n). #}

- switch (std::min({{overloads.maxarg}}, argCount)) {

- {# 3. Remove from S all entries whose type list is not of length argcount. #}

- {% for length, tests_methods in overloads.length_tests_methods %}

- {# 10. If i = d, then: #}

- case {{length}}:

- {# Then resolve by testing argument #}

- {% for test, method in tests_methods %}

- {% filter runtime_enabled(not overloads.runtime_enabled_function_all and

- method.runtime_enabled_function) %}

- if ({{test}}) {

- {% if method.is_custom %}

- {{static_method_name(method.name)}}(args);

- {% else %}

- {{static_method_name(method.name, method.overload_index)}}(args);

- {% endif %}

- return;

- }

- {% endfilter %}

- {% endfor %}

- break;

- {% endfor %}

- default:

- {# Invalid arity, throw error #}

- {# Report full list of valid arities if gaps and above minimum #}

- {% if overloads.valid_arities %}

- if (argCount >= {{overloads.minarg}}) {

- const String message = "Wrong arity, expected one of {{overloads.valid_arities}}";

- exception = DartUtilities::coreArgumentErrorException(message);

- goto fail;

- }

- {% endif %}

- {# Otherwise just report "not enough arguments" #}

- {

- const String message = "Not enough arguments (at least {{overloads.minarg}} required)";

- exception = DartUtilities::coreArgumentErrorException(message);

- goto fail;

- }

- return;

- }

- {

- const String message = "No function was found that matched the signature provided.";

- exception = DartUtilities::coreArgumentErrorException(message);

- goto fail;

- }

- return;

-fail:

- Dart_ThrowException(exception);

- ASSERT_NOT_REACHED();

-{% endmacro %}

-{##############################################################################}

-{# arguments_count is normal method.number_of_arguments however for optional #}

-{# arguments then number_of_required_arguments is passed (sans optional). #}

-{# overload in the index if overloaded. #}

-{# interface is specified signals that it's a constructor being called the #}

-{# delegation to the create is emitted.

-{##############################################################################}

-{% macro generate_method(method, arguments_count) %}

-{% set overload_index = method.overload_index %}

-static void {{static_method_name(method.name, overload_index)}}(Dart_NativeArguments args)

-{% if not method.is_static %}

-{% if cpp_class == "EventTarget" %}

- {{cpp_class}}* receiver = DartDOMWrapper::receiverToEventTarget(args);

-{% else %}

- {{cpp_class}}* /* FIXME(vsm): Remove this. */ ALLOW_UNUSED receiver = DartDOMWrapper::receiver< {{cpp_class}} >(args);

-{% endif %}

-{% if method.is_custom_element_callbacks %}

- CustomElementCallbackDispatcher::CallbackDeliveryScope deliveryScope;

-{% endif %}

-{% if arguments_count > 0 or

- method.has_exception_state or

- method.is_call_with_script_state or

- method.is_call_with_execution_context or

- method.is_call_with_script_arguments %}

- Dart_Handle exception = 0;

-{% endif %}

- {

- {% if method.is_call_with_script_state %}

- ScriptState* state = DartUtilities::currentScriptState();

- if (!state) {

- exception = Dart_NewStringFromCString("Failed to retrieve a script state");

- goto fail;

- }

- {% endif %}

- {% if method.is_call_with_execution_context %}

- ExecutionContext* context = DartUtilities::scriptExecutionContext();

- if (!context) {

- exception = Dart_NewStringFromCString("Failed to retrieve a context");

- goto fail;

- }

- {% endif %}

- {% if method.is_call_with_script_arguments %}

- {# Last parameter is the customArgument #}

- Dart_Handle customArgument = Dart_GetNativeArgument(args, Dart_GetNativeArgumentCount(args) - 1);

- RefPtr<ScriptArguments> scriptArguments(DartUtilities::createScriptArguments(customArgument, exception));

- if (!scriptArguments)

- goto fail;

- {% endif %}

- {% if method.number_of_arguments != method.number_of_required_arguments %}

- int argCount /* FIXME(vsm): Remove this. */ ALLOW_UNUSED = Dart_GetNativeArgumentCount(args);

- {% endif %}

- {% if method.has_exception_state %}

- DartExceptionState es;

- {% endif %}

- {{generate_arguments(method) | indent(8)}}

- {{callback_return(method, method.dart_set_return_value, method.cpp_value)}}

- {% if method.has_exception_state %}

- if (es.hadException()) {

- exception = es.toDart(args, {{method.auto_scope}});

- goto fail;

- }

- {% endif %}

- return;

- }

-{% if arguments_count > 0 or method.has_exception_state or method.is_call_with_script_state or method.is_call_with_execution_context or method.is_call_with_script_arguments %}

-fail:

- Dart_ThrowException(exception);

- ASSERT_NOT_REACHED();

-{% endif %}

-{% endmacro %}

-{##############################################################################}

-{% macro callback_return(method, dart_set_return_value, cpp_value) %}

-{%- if method.union_arguments -%}

-{{callback_union_return(method) | indent(8)}}

-{%- elif method.idl_type == 'void' -%}

-{{cpp_value}};

-{%- elif method.is_constructor -%}

-{{dart_class}}::returnToDart(args, {{cpp_value}}, {{method.auto_scope}});

-{%- else -%}

-{{dart_set_return_value}};

-{%- endif -%}

-{% endmacro %}

-{##############################################################################}

-{% macro callback_union_return(method, argument_count) %}

- {% set type_index = 0 %}

- {% for union_argument in method.union_arguments %}

-{{method.cpp_type[type_index]}} {{union_argument}};

- {% set type_index = type_index + 1 %}

- {% endfor %}

-{{method.cpp_value}};

- {% set union_set_result_index = 0 %}

- {% for union_argument in method.union_arguments %}

-if ({{union_argument}}) {

- {{method.dart_set_return_value[union_set_result_index]}};

- return;

- {% set union_set_result_index = union_set_result_index + 1 %}

- {% endfor %}

-{% endmacro %}

-{##############################################################################}

-{% macro generate_argument(method, argument) %}

-{# If sequence result is passed as an argument not as function return value. #}

-{% if argument.is_optional and

- not argument.has_default and

- argument.idl_type != 'Dictionary' and

- not argument.is_callback_interface %}

-{# Optional arguments without a default value generate an early call with

- fewer arguments if they are omitted. #}

-if (UNLIKELY(argCount <= {{argument.arg_index}})) {

- {{callback_return(method, argument.dart_set_return_value, argument.cpp_value)}}

- if (exception)

- goto fail;

- return;

-{% endif %}

-{% if argument.is_callback_interface %}

-{# Callback functions must be functions:

- http://www.w3.org/TR/WebIDL/#es-callback-function #}

-{% if argument.is_optional %}

-{{argument.local_cpp_type}} {{argument.name}};

-if (argCount > {{argument.arg_index}}) {

- {{argument.name}} = Dart{{argument.idl_type}}::createWithNullCheck(args, {{argument.arg_index}}, exception);

-{% else %}{# argument.is_optional #}

-{{argument.local_cpp_type}} {{argument.name}} = Dart{{argument.idl_type}}::createWithNullCheck(args, {{argument.arg_index}}, exception);

-{% endif %}{# argument.is_optional #}

-{% else %}{# argument.is_callback_interface #}

-{% if argument.is_optional and argument.has_default -%}

-{{argument.local_cpp_type}} {{argument.name}} =

- (argCount <= {{argument.arg_index}}) ? ({{argument.default_value}}) : {{argument.dart_value_to_local_cpp_value}};

-{% elif argument.is_optional and argument.idl_type == 'Dictionary' %}

-{{argument.local_cpp_type}} {{argument.name}};

-if (UNLIKELY(argCount <= {{argument.arg_index}})) {

- {{argument.name}} = Dictionary();

-} else {

- {{argument.name}} = {{argument.dart_value_to_local_cpp_value}};

-{% elif argument.is_array_or_sequence_type %}

-{{argument.local_cpp_type}} {{argument.name}};

-{{argument.dart_value_to_local_cpp_value}};

-{% else %}

-{{argument.local_cpp_type}} {{argument.name}} = {{argument.dart_value_to_local_cpp_value}};

-{% endif %}

-{% endif %}{# argument.is_callback_interface #}

-if (exception)

- goto fail;

-{% endmacro %}

-{######################################}

-{% macro generate_arguments(method) %}

-{%- for argument in method.arguments -%}

-{{generate_argument(method, argument)}}

-{%- endfor -%}

-{% endmacro %}

-{##############################################################################}

-{% macro static_method_name(name, overload_index) %}

-{% set name = 'constructor' if not name else name -%}

-{% if overload_index -%}

-{{name}}Callback_{{overload_index}}

-{%- else -%}

-{{name}}Callback

-{%- endif %}

-{% endmacro -%}

-{##############################################################################}

-{% macro generate_resolver_body(dart_class, class_name, method) %}

-{% for native_entry_group in method.native_entries|groupby('resolver_string') %}

-{% set uses_script_args = method.is_call_with_script_arguments %}

-{% if method.overload_index %}

- {% set method_name = static_method_name(method.name) + "Dispatcher" %}

-{% else %}

- {% set method_name = static_method_name(method.name) %}

-{% endif %}

-{% set resolver_string = native_entry_group.grouper %}

-{% if method.is_custom %}

-// FIXME: we are missing changes from dart.idl so we don't always know how many

-// args custom methods will take so we ignore that check which could hurt perf

-// and security but lets us get everything running quicker.

-if (name == "{{resolver_string}}") {

- *autoSetupScope = {{method.auto_scope}};

- return {{dart_class}}Internal::{{method_name}};

-{% else %}

- {% set args_one_based = method.number_of_arguments %}

- {% set args_required_one_based = method.number_of_required_arguments %}

- {% if not method.is_static %}

- {% set args_one_based = args_one_based + 1 %}

- {% set args_required_one_based = args_required_one_based + 1 %}

- {% endif %}

- {% if uses_script_args %}

- {# FIXME(vsm): At least one script argument is expected. Generalize? #}

- {% set args_one_based = args_one_based + 1 %}

- {% set args_required_one_based = args_required_one_based + 1 %}

- {% endif %}

- {% if args_one_based == args_required_one_based %}

-if (argumentCount == {{args_one_based}} && name == "{{resolver_string}}") {

- *autoSetupScope = {{method.auto_scope}};

- return {{dart_class}}Internal::{{method_name}};

- {% else %}

-if (argumentCount >= {{args_required_one_based}} && argumentCount <= {{args_one_based}} && name == "{{resolver_string}}") {

- *autoSetupScope = {{method.auto_scope}};

- return {{dart_class}}Internal::{{method_name}};

- {% endif %}

-{% endif %}

-{% endfor %}

-{% endmacro %}

-{##############################################################################}

-{% macro generate_symbolizer_body(dart_class, class_name, method) %}

-{% for native_entry_group in method.native_entries|groupby('resolver_string') %}

-{% set uses_script_args = method.is_call_with_script_arguments %}

-{% if method.overload_index %}

- {% set method_name = static_method_name(method.name) + "Dispatcher" %}

-{% else %}

- {% set method_name = static_method_name(method.name) %}

-{% endif %}

-{% set resolver_string = native_entry_group.grouper %}

-if (nf == {{dart_class}}Internal::{{method_name}}) {

- return reinterpret_cast<const uint8_t*>("{{resolver_string}}");

-{% endfor %}

-{% endmacro %}

-{##############################################################################}

-{% macro generate_constructor(constructor, arguments_count, overload='') %}

-{% if overload == '' %}

- {% set overload_index = constructor.overload_index %}

-{% else %}

- {% set overload_index = overload %}

-{% endif %}

-static void {{static_method_name(constructor.name, overload_index)}}(Dart_NativeArguments args)

-{% if arguments_count > 0 or

- constructor.has_exception_state or

- is_constructor_call_with_execution_context or

- is_constructor_call_with_document or

- (constructor == named_constructor) %}

- Dart_Handle exception = 0;

-{% endif %}

- {

-{% if is_constructor_call_with_execution_context %}

- ExecutionContext* context = DartUtilities::scriptExecutionContext();

- if (!context) {

- exception = Dart_NewStringFromCString("Failed to retrieve a context");

- goto fail;

- }

-{% endif %}

-{% if is_constructor_call_with_document or (constructor == named_constructor) %}

- LocalDOMWindow* domWindow = DartUtilities::domWindowForCurrentIsolate();

- if (!domWindow) {

- exception = Dart_NewStringFromCString("Failed to fetch domWindow");

- goto fail;

- }

- Document& document = *domWindow->document();

-{% endif %}

- int argCount /* FIXME(vsm): Remove this. */ ALLOW_UNUSED = Dart_GetNativeArgumentCount(args);

-{% if constructor.has_exception_state %}

- DartExceptionState es;

-{% endif %}

- {{generate_arguments(constructor) | indent(8)}}

- {{callback_return(constructor, constructor.dart_set_return_value, constructor.cpp_value) | indent(8)}}

-{% if constructor.has_exception_state %}

- if (es.hadException()) {

- exception = es.toDart(args, {{constructor.auto_scope}});

- goto fail;

- }

-{% endif %}

- return;

- }

-{% if arguments_count > 0 or constructor.has_exception_state or is_constructor_call_with_execution_context or is_constructor_call_with_document or (constructor == named_constructor) %}

-fail:

- Dart_ThrowException(exception);

- ASSERT_NOT_REACHED();

-{% endif %}

-{% endmacro %}

-{##############################################################################}

-{% macro generate_event_constructor() %}

-template <typename T>

-static void convert(const String& idlType, Dart_Handle handle, bool nullable, T& value, Dart_Handle& exception)

- value = DartUtilities::TypeConvertor<T>()(handle, exception);

-template <typename T>

-static void convert(const String& idlType, Dart_Handle handle, bool nullable, RefPtr<T>& value, Dart_Handle& exception)

- if (Dart_IsNull(handle))

- value = nullptr;

- else

- exception = Dart_NewStringFromCString("Event initialization unimplemented for non-primitive types");

-template <typename T>

-static void convert(const String& idlType, Dart_Handle handle, bool nullable, Member<T>& value, Dart_Handle& exception)

- if (Dart_IsNull(handle))

- value = nullptr;

- else

- exception = Dart_NewStringFromCString("Event initialization unimplemented for non-primitive types");

-void initialize{{interface_name}}ForDart({{interface_name}}Init& eventInit, const String& type, const HashMap<String, Dart_Handle>& options, Dart_Handle& exception)

- {% if parent_interface %}

- Dart{{parent_interface}}Internal::initialize{{parent_interface}}ForDart(eventInit, type, options, exception);

- if (exception)

- return;

- {% endif %}

- {% for attribute in attributes

- if (attribute.is_initialized_by_event_constructor and

- not attribute.idl_type == 'any')%}

- {% set is_nullable = 'true' if attribute.is_nullable else 'false' %}

- if (options.contains("{{attribute.name}}")) {

- Dart_Handle option = options.get("{{attribute.name}}");

- convert("{{attribute.idl_type}}", option, {{is_nullable}}, eventInit.{{attribute.cpp_name}}, exception);

- if (exception)

- return;

- }

- {% endfor %}

-static void eventConstructorCallback(Dart_NativeArguments args)

- Dart_Handle exception = 0;

- {

- DartStringAdapter type = DartUtilities::dartToString(args, 0, exception);

- if (exception)

- goto fail;

- Dart_Handle handle = Dart_GetNativeArgument(args, 1);

- HashMap<String, Dart_Handle> options;

- DartUtilities::extractMapElements(handle, exception, options);

- if (exception)

- goto fail;

- {{interface_name}}Init eventInit;

- initialize{{interface_name}}ForDart(eventInit, type, options, exception);

- if (exception)

- goto fail;

- {% if is_constructor_raises_exception %}

- DartExceptionState es;

- RefPtrWillBeRawPtr<{{interface_name}}> event = {{interface_name}}::create(type, eventInit, es);

- if (es.hadException()) {

- exception = es.toDart(args);

- goto fail;

- }

- {% else %}

- RefPtrWillBeRawPtr<{{interface_name}}> event = {{interface_name}}::create(type, eventInit);

- {% endif %}

- {{dart_class}}::returnToDart(args, event.get());

- return;

- }

-fail:

- Dart_ThrowException(exception);

- ASSERT_NOT_REACHED();

-{% endmacro %}

-{##############################################################################}

-{% macro generate_resolver_constructor(dart_class, class_name, constructor) %}

-{% for native_entry in constructor.native_entries %}

-{% set resolver_string = native_entry.resolver_string %}

-{% if constructor.overload_index %}

- {% set constructor_name = static_method_name(constructor.name) + "Dispatcher" %}

-{% else %}

- {% set constructor_name = static_method_name(constructor.name) %}

-{% endif %}

-{% if has_custom_constructor %}

-if (name == "{{resolver_string}}") {

-{% elif constructor.number_of_arguments == constructor.number_of_required_arguments %}

-if (argumentCount == {{constructor.number_of_arguments}} && name == "{{resolver_string}}") {

-{% else %}

-if (argumentCount >= {{constructor.number_of_required_arguments}} && argumentCount <= {{constructor.number_of_arguments}} && name == "{{resolver_string}}") {

-{% endif %}

- *autoSetupScope = {{constructor.auto_scope}};

- return {{dart_class}}Internal::{{constructor_name}};

-{% endfor %}

-{% endmacro %}

-{##############################################################################}

-{% macro generate_resolver_event_constructor(dart_class, class_name) %}

-{% set resolver_string = interface_name + "_constructorCallback" %}

-if (argumentCount == 2 && name == "{{resolver_string}}") {

- *autoSetupScope = 1;

- return {{dart_class}}Internal::eventConstructorCallback;

-{% endmacro %}

-{##############################################################################}

-{% macro generate_symbolizer_constructor(dart_class, class_name, constructor) %}

-{% for native_entry in constructor.native_entries %}

-{% set resolver_string = native_entry.resolver_string %}

-if (nf == {{dart_class}}Internal::{{static_method_name(constructor.name, constructor.overload_index)}}) {

- return reinterpret_cast<const uint8_t*>("{{resolver_string}}");

-{% endfor %}

-{% endmacro %}