mirror of
https://github.com/encounter/dawn-cmake.git
synced 2025-08-02 10:15:50 +00:00
8033af0947
These are implemented by wrapping the integer types in transparent ClampedInteger<> and EnforceRangeInteger<> structures. Some parts of the core needed to be updated after this, either to disambiguate conversions, or because of bugs (u32 vs u64). To make the CTS tests checking for this pass, the errors returned when conversion FromJS failed needed to be updated to TypeError and not just the generic Napi::Error. Bug: dawn:1123 Change-Id: Ife1d0baa7687e43d735a1814ec41883c49ae74a6 Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/85640 Reviewed-by: Ben Clayton <bclayton@google.com> Commit-Queue: Corentin Wallez <cwallez@chromium.org>
410 lines
13 KiB
Cheetah
410 lines
13 KiB
Cheetah
{{/*
|
|
Copyright 2021 The Dawn Authors
|
|
|
|
Licensed under the Apache License, Version 2.0 (the "License");
|
|
you may not use this file except in compliance with the License.
|
|
You may obtain a copy of the License at
|
|
|
|
http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
Unless required by applicable law or agreed to in writing, software
|
|
distributed under the License is distributed on an "AS IS" BASIS,
|
|
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
See the License for the specific language governing permissions and
|
|
limitations under the License.
|
|
*/}}
|
|
|
|
{{- /*
|
|
--------------------------------------------------------------------------------
|
|
Template file for use with src/dawn/node/tools/cmd/idlgen/main.go to generate
|
|
the WebGPU.cpp source file.
|
|
|
|
See:
|
|
* https://github.com/ben-clayton/webidlparser/blob/main/ast/ast.go for the AST
|
|
types used by this template
|
|
* src/dawn/node/tools/cmd/idlgen/main.go for additional structures and functions
|
|
used by this template
|
|
* https://golang.org/pkg/text/template/ for documentation on the template syntax
|
|
--------------------------------------------------------------------------------
|
|
*/ -}}
|
|
|
|
{{- Include "WebGPUCommon.tmpl" -}}
|
|
|
|
#include "src/dawn/node/interop/WebGPU.h"
|
|
|
|
#include <unordered_map>
|
|
|
|
#include "src/dawn/node/utils/Debug.h"
|
|
|
|
namespace wgpu {
|
|
namespace interop {
|
|
|
|
namespace {
|
|
|
|
{{template "Wrappers" $}}
|
|
|
|
} // namespace
|
|
|
|
{{ range $ := .Declarations}}
|
|
{{- if IsDictionary $}}{{template "Dictionary" $}}
|
|
{{- else if IsInterface $}}{{template "Interface" $}}
|
|
{{- else if IsEnum $}}{{template "Enum" $}}
|
|
{{- end}}
|
|
{{- end}}
|
|
|
|
|
|
void Initialize(Napi::Env env) {
|
|
auto* wrapper = Wrappers::Init(env);
|
|
auto global = env.Global();
|
|
{{- range $ := .Declarations}}
|
|
{{- if IsInterfaceOrNamespace $}}
|
|
{{- if not (HasAnnotation $ "LegacyNoInterfaceObject")}}
|
|
global.Set(Napi::String::New(env, "{{$.Name}}"), wrapper->{{$.Name}}_ctor.Value());
|
|
{{- end}}
|
|
{{- end}}
|
|
{{- end}}
|
|
}
|
|
|
|
} // namespace interop
|
|
} // namespace wgpu
|
|
|
|
|
|
{{- /*
|
|
--------------------------------------------------------------------------------
|
|
-- Wrappers emits the C++ 'Wrappers' class, which holds all the interface and
|
|
-- namespace interop wrapper classes.
|
|
--------------------------------------------------------------------------------
|
|
*/ -}}
|
|
{{- define "Wrappers"}}
|
|
// Wrappers holds all the Napi class constructors, and Napi::ObjectWrap type
|
|
// declarations, for each of the WebIDL interface and namespace types.
|
|
class Wrappers {
|
|
Wrappers(Napi::Env env) {
|
|
{{- range $ := .Declarations}}
|
|
{{- if IsInterfaceOrNamespace $}}
|
|
{{$.Name}}_ctor = Napi::Persistent(W{{$.Name}}::Class(env));
|
|
{{- end}}
|
|
{{- end}}
|
|
}
|
|
|
|
static Wrappers* instance;
|
|
|
|
public:
|
|
{{- range $ := .Declarations}}
|
|
{{- if IsInterfaceOrNamespace $}}{{template "Wrapper" $}}
|
|
{{- end}}
|
|
{{- end}}
|
|
|
|
// Allocates and constructs the Wrappers instance
|
|
static Wrappers* Init(Napi::Env env) {
|
|
instance = new Wrappers(env);
|
|
return instance;
|
|
}
|
|
|
|
// Destructs and frees the Wrappers instance
|
|
static void Term(Napi::Env env) {
|
|
delete instance;
|
|
instance = nullptr;
|
|
}
|
|
|
|
static Wrappers* For(Napi::Env env) {
|
|
// Currently Napi only actually supports a single Env, so there's no point
|
|
// maintaining a map of Env to Wrapper. Note: This might not always be true.
|
|
return instance;
|
|
}
|
|
|
|
{{ range $ := .Declarations}}
|
|
{{- if IsInterfaceOrNamespace $}}
|
|
Napi::FunctionReference {{$.Name}}_ctor;
|
|
{{- end}}
|
|
{{- end}}
|
|
};
|
|
|
|
Wrappers* Wrappers::instance = nullptr;
|
|
{{- end}}
|
|
|
|
|
|
{{- /*
|
|
--------------------------------------------------------------------------------
|
|
-- Wrapper emits the C++ wrapper class for the given ast.Interface or
|
|
-- ast.Namespace.
|
|
-- This wrapper class inherits from Napi::ObjectWrap, which binds the lifetime
|
|
-- of the JavaScript object to the lifetime of the wrapper class instance.
|
|
-- If the wrapper is for an interface, the wrapper object holds a unique_ptr to
|
|
-- the interface implementation, and delegates all exposed method calls on to
|
|
-- the implementation.
|
|
-- See: https://github.com/nodejs/node-addon-api/blob/main/doc/object_wrap.md
|
|
--------------------------------------------------------------------------------
|
|
*/ -}}
|
|
{{- define "Wrapper"}}
|
|
struct W{{$.Name}} : public Napi::ObjectWrap<W{{$.Name}}> {
|
|
{{- if IsInterface $}}
|
|
std::unique_ptr<{{$.Name}}> impl;
|
|
{{- end}}
|
|
static Napi::Function Class(Napi::Env env) {
|
|
return DefineClass(env, "{{$.Name}}", {
|
|
{{ if $s := SetlikeOf $}}
|
|
InstanceMethod("has", &W{{$.Name}}::has),
|
|
InstanceMethod("keys", &W{{$.Name}}::keys),
|
|
{{- end}}
|
|
{{- range $m := MethodsOf $}}
|
|
InstanceMethod("{{$m.Name}}", &W{{$.Name}}::{{$m.Name}}),
|
|
{{- end}}
|
|
{{- range $a := AttributesOf $}}
|
|
{{- if not (HasAnnotation $a "SameObject")}}
|
|
InstanceAccessor("{{$a.Name}}", &W{{$.Name}}::get{{Title $a.Name}},
|
|
{{- if $a.Readonly}} nullptr{{else}} &W{{$.Name}}::set{{Title $a.Name}}{{end -}}
|
|
),
|
|
{{- end}}
|
|
{{- end}}
|
|
{{- range $c := ConstantsOf $}}
|
|
StaticValue("{{$c.Name}}", ToJS(env, {{$.Name}}::{{$c.Name}}), napi_default_jsproperty),
|
|
{{- end}}
|
|
});
|
|
}
|
|
|
|
W{{$.Name}}(const Napi::CallbackInfo& info) : ObjectWrap(info) {}
|
|
|
|
{{ if $s := SetlikeOf $}}
|
|
Napi::Value has(const Napi::CallbackInfo& info) {
|
|
std::tuple<{{template "Type" $s.Elem}}> args;
|
|
auto res = FromJS(info, args);
|
|
if (res) {
|
|
return ToJS(info.Env(), impl->has(info.Env(), std::get<0>(args)));
|
|
}
|
|
Napi::TypeError::New(info.Env(), res.error).ThrowAsJavaScriptException();
|
|
return {};
|
|
}
|
|
Napi::Value keys(const Napi::CallbackInfo& info) {
|
|
return ToJS(info.Env(), impl->keys(info.Env()));
|
|
}
|
|
{{- end}}
|
|
{{- range $m := MethodsOf $}}
|
|
Napi::Value {{$m.Name}}(const Napi::CallbackInfo& info) {
|
|
std::string error;
|
|
{{- range $overload_idx, $o := $m.Overloads}}
|
|
{{- $overloaded := gt (len $m.Overloads) 1}}
|
|
{ {{if $overloaded}}// Overload {{$overload_idx}}{{end}}
|
|
std::tuple<
|
|
{{- range $i, $p := $o.Parameters}}
|
|
{{- if $i}}, {{end}}
|
|
{{- if $p.Init }}DefaultedParameter<{{template "Type" $p.Type}}>
|
|
{{- else if $p.Optional}}std::optional<{{template "Type" $p.Type}}>
|
|
{{- else }}{{template "Type" $p.Type}}
|
|
{{- end}}
|
|
{{- end}}> args;
|
|
|
|
{{- range $i, $p := $o.Parameters}}
|
|
{{- if $p.Init}}
|
|
std::get<{{$i}} /* {{$p.Name}} */>(args).default_value = {{Eval "Literal" "Value" $p.Init "Type" $p.Type}};
|
|
{{- end}}
|
|
{{- end}}
|
|
|
|
auto res = FromJS(info, args);
|
|
if (res) {
|
|
{{/* indent */}}INTEROP_LOG(
|
|
{{- range $i, $p := $o.Parameters}}
|
|
{{- if $i}}, ", {{$p.Name}}: "{{else}}"{{$p.Name}}: "{{end}}, std::get<{{$i}}>(args)
|
|
{{- end}});
|
|
{{/* indent */}}
|
|
{{- if not (IsUndefinedType $o.Type) }}auto result = {{end -}}
|
|
impl->{{$o.Name}}(info.Env(){{range $i, $_ := $o.Parameters}}, std::get<{{$i}}>(args){{end}});
|
|
{{/* indent */ -}}
|
|
{{- if IsUndefinedType $o.Type}}return info.Env().Undefined();
|
|
{{- else }}return ToJS(info.Env(), result);
|
|
{{- end }}
|
|
}
|
|
error = {{if $overloaded}}"\noverload {{$overload_idx}} failed to match:\n" + {{end}}res.error;
|
|
}
|
|
{{- end}}
|
|
Napi::TypeError::New(info.Env(), "no overload matched for {{$m.Name}}:\n" + error).ThrowAsJavaScriptException();
|
|
return {};
|
|
}
|
|
{{- end}}
|
|
|
|
{{- range $a := AttributesOf $}}
|
|
{{- if not (HasAnnotation $a "SameObject")}}
|
|
Napi::Value get{{Title $a.Name}}(const Napi::CallbackInfo& info) {
|
|
return ToJS(info.Env(), impl->get{{Title $a.Name}}(info.Env()));
|
|
}
|
|
{{- if not $a.Readonly}}
|
|
void set{{Title $a.Name}}(const Napi::CallbackInfo& info, const Napi::Value& value) {
|
|
{{template "Type" $a.Type}} v{};
|
|
auto res = FromJS(info.Env(), value, v);
|
|
if (res) {
|
|
impl->set{{Title $a.Name}}(info.Env(), std::move(v));
|
|
} else {
|
|
res = res.Append("invalid value to {{$a.Name}}");
|
|
Napi::TypeError::New(info.Env(), res.error).ThrowAsJavaScriptException();
|
|
}
|
|
}
|
|
{{- end}}
|
|
{{- end}}
|
|
{{- end}}
|
|
};
|
|
{{end}}
|
|
|
|
|
|
{{- /*
|
|
--------------------------------------------------------------------------------
|
|
-- Dictionary emits the C++ method implementations and associated functions of
|
|
-- the interop type that defines the given ast.Dictionary
|
|
--------------------------------------------------------------------------------
|
|
*/ -}}
|
|
{{- define "Dictionary"}}
|
|
Result Converter<{{$.Name}}>::FromJS(Napi::Env env, Napi::Value value, {{$.Name}}& out) {
|
|
auto object = value.ToObject();
|
|
Result res;
|
|
{{- template "DictionaryMembersFromJS" $}};
|
|
return Success;
|
|
}
|
|
|
|
Napi::Value Converter<{{$.Name}}>::ToJS(Napi::Env env, {{$.Name}} value) {
|
|
auto object = Napi::Object::New(env);
|
|
{{- template "DictionaryMembersToJS" $}}
|
|
return object;
|
|
}
|
|
|
|
std::ostream& operator<<(std::ostream& o, const {{$.Name}}& dict) {
|
|
o << "{{$.Name}} {";
|
|
{{- range $i, $m := $.Members}}
|
|
o << {{if $i}}", "{{else}}" "{{end}} << "{{$m.Name}}: ";
|
|
utils::Write(o, dict.{{$m.Name}});
|
|
{{- end }}
|
|
o << "}" << std::endl;
|
|
return o;
|
|
}
|
|
{{ end}}
|
|
|
|
|
|
{{- /*
|
|
--------------------------------------------------------------------------------
|
|
-- DictionaryMembersFromJS emits the C++ logic to convert each of the
|
|
-- dictionary ast.Member fields from JavaScript to C++. Each call to ToJS() is
|
|
-- emitted as a separate statement, and requires a 'Result res' local to be
|
|
-- declared
|
|
--------------------------------------------------------------------------------
|
|
*/ -}}
|
|
{{- define "DictionaryMembersFromJS"}}
|
|
{{- if $.Inherits}}{{template "DictionaryMembersFromJS" (Lookup $.Inherits)}}{{end}}
|
|
{{- range $i, $m := $.Members}}
|
|
{{/* indent */}}
|
|
{{- if $m.Init }}res = interop::FromJSOptional(env, object.Get("{{$m.Name}}"), out.{{$m.Name}});
|
|
{{- else }}res = interop::FromJS(env, object.Get("{{$m.Name}}"), out.{{$m.Name}});
|
|
{{- end }}
|
|
if (!res) {
|
|
return res.Append("while converting member '{{$m.Name}}'");
|
|
}
|
|
{{- end}}
|
|
{{- end}}
|
|
|
|
|
|
{{- /*
|
|
--------------------------------------------------------------------------------
|
|
-- DictionaryMembersToJS emits the C++ logic to convert each of the
|
|
-- dictionary ast.Member fields to JavaScript from C++. Each call to ToJS() is
|
|
-- emitted as a separate statement
|
|
--------------------------------------------------------------------------------
|
|
*/ -}}
|
|
{{- define "DictionaryMembersToJS"}}
|
|
{{- if $.Inherits}}{{template "DictionaryMembersToJS" (Lookup $.Inherits)}}{{end}}
|
|
{{- range $m := $.Members}}
|
|
object.Set(Napi::String::New(env, "{{$m.Name}}"), interop::ToJS(env, value.{{$m.Name}}));
|
|
{{- end}}
|
|
{{- end}}
|
|
|
|
|
|
{{- /*
|
|
--------------------------------------------------------------------------------
|
|
-- Interface emits the C++ method implementations that define the given
|
|
-- ast.Interface.
|
|
-- Note: Most of the actual binding logic lives in the interface wrapper class.
|
|
--------------------------------------------------------------------------------
|
|
*/ -}}
|
|
{{- define "Interface"}}
|
|
{{$.Name}}::{{$.Name}}() = default;
|
|
|
|
{{$.Name}}* {{$.Name}}::Unwrap(Napi::Object object) {
|
|
auto* wrappers = Wrappers::For(object.Env());
|
|
if (!object.InstanceOf(wrappers->{{$.Name}}_ctor.Value())) {
|
|
return nullptr;
|
|
}
|
|
return Wrappers::W{{$.Name}}::Unwrap(object)->impl.get();
|
|
}
|
|
|
|
Interface<{{$.Name}}> {{$.Name}}::Bind(Napi::Env env, std::unique_ptr<{{$.Name}}>&& impl) {
|
|
auto* wrappers = Wrappers::For(env);
|
|
auto object = wrappers->{{$.Name}}_ctor.New({});
|
|
auto* wrapper = Wrappers::W{{$.Name}}::Unwrap(object);
|
|
wrapper->impl = std::move(impl);
|
|
|
|
{{- /*Add the [SameObject] members as read-only property on the JS object.*/ -}}
|
|
{{- range $a := AttributesOf $}}
|
|
{{- if HasAnnotation $a "SameObject"}}
|
|
object.DefineProperty(Napi::PropertyDescriptor::Value(
|
|
"{{$a.Name}}", ToJS(env, wrapper->impl->get{{Title $a.Name}}(env))
|
|
));
|
|
{{- end}}
|
|
{{- end}}
|
|
|
|
return Interface<{{$.Name}}>(object);
|
|
}
|
|
|
|
{{$.Name}}::~{{$.Name}}() = default;
|
|
{{ end}}
|
|
|
|
|
|
{{- /*
|
|
--------------------------------------------------------------------------------
|
|
-- Enum emits the C++ associated functions of the interop type that defines the
|
|
-- given ast.Enum
|
|
--------------------------------------------------------------------------------
|
|
*/ -}}
|
|
{{- define "Enum"}}
|
|
bool Converter<{{$.Name}}>::FromString(std::string str, {{$.Name}}& out) {
|
|
{{- range $e := $.Values}}
|
|
if (str == {{$e.Value}}) {
|
|
out = {{$.Name}}::{{EnumEntryName $e.Value}};
|
|
return true;
|
|
}
|
|
{{- end}}
|
|
return false;
|
|
}
|
|
|
|
const char* Converter<{{$.Name}}>::ToString({{$.Name}} value) {
|
|
switch (value) {
|
|
{{- range $e := $.Values}}
|
|
case {{$.Name}}::{{EnumEntryName $e.Value}}:
|
|
return {{$e.Value}};
|
|
{{- end}}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
Result Converter<{{$.Name}}>::FromJS(Napi::Env env, Napi::Value value, {{$.Name}}& out) {
|
|
std::string str = value.ToString();
|
|
if (FromString(str, out)) {
|
|
return Success;
|
|
}
|
|
return Error(str + " is not a valid enum value of {{$.Name}}");
|
|
}
|
|
|
|
Napi::Value Converter<{{$.Name}}>::ToJS(Napi::Env env, {{$.Name}} value) {
|
|
switch (value) {
|
|
{{- range $e := $.Values}}
|
|
case {{$.Name}}::{{EnumEntryName $e.Value}}:
|
|
return Napi::String::New(env, {{$e.Value}});
|
|
{{- end}}
|
|
}
|
|
return env.Undefined();
|
|
}
|
|
|
|
std::ostream& operator<<(std::ostream& o, {{$.Name}} value) {
|
|
if (auto* s = Converter<{{$.Name}}>::ToString(value)) {
|
|
return o << s;
|
|
}
|
|
return o << "undefined<{{$.Name}}>";
|
|
}
|
|
|
|
{{end}}
|