287 lines
9.2 KiB
Cheetah
287 lines
9.2 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 tools/src/cmd/idlgen/main.go to generate the
|
|
WebGPU.h header file.
|
|
|
|
See:
|
|
* https://github.com/ben-clayton/webidlparser/blob/main/ast/ast.go for the AST
|
|
types used by this template
|
|
* tools/src/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" -}}
|
|
|
|
#ifndef DAWN_NODE_GEN_INTEROP_WEBGPU_H_
|
|
#define DAWN_NODE_GEN_INTEROP_WEBGPU_H_
|
|
|
|
#include "src/dawn/node/interop/Core.h"
|
|
|
|
namespace wgpu {
|
|
namespace interop {
|
|
|
|
// Initialize() registers the WebGPU types with the Napi environment.
|
|
void Initialize(Napi::Env env);
|
|
|
|
{{ range $ := .Declarations}}
|
|
{{- if IsDictionary $}}{{template "Dictionary" $}}
|
|
{{- else if IsNamespace $}}{{template "Namespace" $}}
|
|
{{- else if IsInterface $}}{{template "Interface" $}}
|
|
{{- else if IsEnum $}}{{template "Enum" $}}
|
|
{{- else if IsTypedef $}}{{template "Typedef" $}}
|
|
{{- end}}
|
|
{{- end}}
|
|
|
|
} // namespace interop
|
|
} // namespace wgpu
|
|
|
|
#endif // DAWN_NODE_GEN_INTEROP_WEBGPU_H_
|
|
|
|
|
|
{{- /*
|
|
--------------------------------------------------------------------------------
|
|
-- Dictionary emits the C++ header declaration that defines the interop type for
|
|
-- the given ast.Dictionary
|
|
--------------------------------------------------------------------------------
|
|
*/ -}}
|
|
{{- define "Dictionary"}}
|
|
// dictionary {{$.Name}}
|
|
class {{$.Name}} {{- if $.Inherits }} : public {{$.Inherits}}{{end}} {
|
|
public:
|
|
{{ range $m := $.Members}}
|
|
{{- if IsInitializer $m}} {{$.Name}}();
|
|
{{ else if IsMember $m}} {{template "DictionaryMember" $m}}
|
|
{{ end}}
|
|
{{- end -}}
|
|
};
|
|
|
|
template<>
|
|
class Converter<{{$.Name}}> {
|
|
public:
|
|
static Result FromJS(Napi::Env, Napi::Value, {{$.Name}}&);
|
|
static Napi::Value ToJS(Napi::Env, {{$.Name}});
|
|
};
|
|
|
|
std::ostream& operator<<(std::ostream& o, const {{$.Name}}& desc);
|
|
{{end}}
|
|
|
|
|
|
{{- /*
|
|
--------------------------------------------------------------------------------
|
|
-- Namespace emits the C++ header declaration that defines the interop type for
|
|
-- the given ast.Namespace
|
|
--------------------------------------------------------------------------------
|
|
*/ -}}
|
|
{{- define "Namespace"}}
|
|
// namespace {{$.Name}}
|
|
class {{$.Name}} {
|
|
public:
|
|
virtual ~{{$.Name}}();
|
|
{{$.Name}}();
|
|
{{- range $c := ConstantsOf $}}
|
|
{{- template "Constant" $c}}
|
|
{{- end}}
|
|
};
|
|
{{end}}
|
|
|
|
|
|
{{- /*
|
|
--------------------------------------------------------------------------------
|
|
-- Interface emits the C++ header declaration that defines the interop type for
|
|
-- the given ast.Interface
|
|
--------------------------------------------------------------------------------
|
|
*/ -}}
|
|
{{- define "Interface"}}
|
|
// interface {{$.Name}}
|
|
class {{$.Name}} {{- if $.Inherits }} : public {{$.Inherits}}{{end}} {
|
|
public:
|
|
static Interface<{{$.Name}}> Bind(Napi::Env, std::unique_ptr<{{$.Name}}>&&);
|
|
static {{$.Name}}* Unwrap(Napi::Object);
|
|
|
|
template<typename T, typename ... ARGS>
|
|
static inline Interface<{{$.Name}}> Create(Napi::Env env, ARGS&& ... args) {
|
|
return Bind(env, std::make_unique<T>(std::forward<ARGS>(args)...));
|
|
}
|
|
|
|
virtual ~{{$.Name}}();
|
|
{{$.Name}}();
|
|
{{- if $s := SetlikeOf $}}
|
|
{{- template "InterfaceSetlike" $s}}
|
|
{{- end}}
|
|
{{- range $m := MethodsOf $}}
|
|
{{- template "InterfaceMethod" $m}}
|
|
{{- end}}
|
|
{{- range $a := AttributesOf $}}
|
|
{{- template "InterfaceAttribute" $a}}
|
|
{{- end}}
|
|
{{- range $c := ConstantsOf $}}
|
|
{{- template "Constant" $c}}
|
|
{{- end}}
|
|
};
|
|
{{end}}
|
|
|
|
|
|
{{- /*
|
|
--------------------------------------------------------------------------------
|
|
-- Typedef emits the C++ header declaration that defines the interop type for
|
|
-- the given ast.Interface
|
|
--------------------------------------------------------------------------------
|
|
*/ -}}
|
|
{{- define "Typedef"}}
|
|
{{- if HasAnnotation $ "EnforceRange"}}
|
|
using {{$.Name}} = EnforceRangeInteger<{{template "Type" $.Type}}>;
|
|
{{- else}}
|
|
using {{$.Name}} = {{template "Type" $.Type}};
|
|
{{- end}}
|
|
{{end}}
|
|
|
|
|
|
{{- /*
|
|
--------------------------------------------------------------------------------
|
|
-- Enum emits the C++ header declaration that defines the interop type for
|
|
-- the given ast.Enum
|
|
--------------------------------------------------------------------------------
|
|
*/ -}}
|
|
{{- define "Enum"}}
|
|
enum class {{$.Name}} {
|
|
{{- range $ := $.Values}}
|
|
{{EnumEntryName $.Value}},
|
|
{{- end}}
|
|
};
|
|
|
|
template<>
|
|
class Converter<{{$.Name}}> {
|
|
public:
|
|
static Result FromJS(Napi::Env, Napi::Value, {{$.Name}}&);
|
|
static Napi::Value ToJS(Napi::Env, {{$.Name}});
|
|
static bool FromString(std::string, {{$.Name}}&);
|
|
static const char* ToString({{$.Name}});
|
|
};
|
|
|
|
std::ostream& operator<<(std::ostream& o, {{$.Name}});
|
|
{{end}}
|
|
|
|
|
|
{{- /*
|
|
--------------------------------------------------------------------------------
|
|
-- DictionaryMember emits the C++ declaration for a single dictionary ast.Member
|
|
--------------------------------------------------------------------------------
|
|
*/ -}}
|
|
{{- define "DictionaryMember"}}
|
|
{{- if $.Attribute}}{{template "AttributeType" $}} {{$.Name}}
|
|
{{- if $.Init}} = {{Eval "Literal" "Value" $.Init "Type" $.Type}}{{end}};
|
|
{{- else }}{{template "Type" $.Type}} {{$.Name}}({{template "Parameters" $.Parameters}});
|
|
{{- end }}
|
|
{{- end }}
|
|
|
|
|
|
{{- /*
|
|
--------------------------------------------------------------------------------
|
|
-- InterfaceSetlike emits the C++ methods for a setlike interface
|
|
--------------------------------------------------------------------------------
|
|
*/ -}}
|
|
{{- define "InterfaceSetlike"}}
|
|
virtual bool has(Napi::Env, {{template "Type" $.Elem}}) = 0;
|
|
virtual std::vector<{{template "Type" $.Elem}}> keys(Napi::Env) = 0;
|
|
{{- /* TODO(crbug.com/dawn/1143):
|
|
entries, forEach, size, values
|
|
read-write: add, clear, or delete
|
|
*/}}
|
|
{{- end }}
|
|
|
|
|
|
{{- /*
|
|
--------------------------------------------------------------------------------
|
|
-- InterfaceMethod emits the C++ declaration for a single interface ast.Member
|
|
-- method
|
|
--------------------------------------------------------------------------------
|
|
*/ -}}
|
|
{{- define "InterfaceMethod"}}
|
|
{{- range $o := $.Overloads}}
|
|
virtual {{template "Type" $o.Type}} {{$.Name}}(Napi::Env{{template "ParametersWithLeadingComma" $o.Parameters}}) = 0;
|
|
{{- end }}
|
|
{{- end }}
|
|
|
|
|
|
{{- /*
|
|
--------------------------------------------------------------------------------
|
|
-- InterfaceAttribute emits the C++ declaration for a single interface
|
|
-- ast.Member attribute
|
|
--------------------------------------------------------------------------------
|
|
*/ -}}
|
|
{{- define "InterfaceAttribute"}}
|
|
virtual {{template "Type" $.Type}} get{{Title $.Name}}(Napi::Env) = 0;
|
|
{{- if not $.Readonly}}
|
|
virtual void set{{Title $.Name}}(Napi::Env, {{template "Type" $.Type}} value) = 0;
|
|
{{- end }}
|
|
{{- end }}
|
|
|
|
|
|
{{- /*
|
|
--------------------------------------------------------------------------------
|
|
-- Constant emits the C++ declaration for a single ast.Member constant
|
|
--------------------------------------------------------------------------------
|
|
*/ -}}
|
|
{{- define "Constant"}}
|
|
static constexpr {{template "Type" $.Type}} {{$.Name}} = {{Eval "Literal" "Value" $.Init "Type" $.Type}};
|
|
{{- end }}
|
|
|
|
|
|
{{- /*
|
|
--------------------------------------------------------------------------------
|
|
-- Parameters emits the C++ comma separated list of parameter declarations for
|
|
-- the given []ast.Parameter
|
|
--------------------------------------------------------------------------------
|
|
*/ -}}
|
|
{{- define "Parameters"}}
|
|
{{- range $i, $param := $ }}
|
|
{{- if $i }}, {{end}}
|
|
{{- template "Parameter" $param}}
|
|
{{- end }}
|
|
{{- end }}
|
|
|
|
|
|
{{- /*
|
|
--------------------------------------------------------------------------------
|
|
-- ParametersWithLeadingComma emits the C++ comma separated list of parameter
|
|
-- declarations for the given []ast.Parameter, starting with a leading comma
|
|
-- for the first parameter
|
|
--------------------------------------------------------------------------------
|
|
*/ -}}
|
|
{{- define "ParametersWithLeadingComma"}}
|
|
{{- range $i, $param := $ }}, {{/* */}}
|
|
{{- template "Parameter" $param}}
|
|
{{- end }}
|
|
{{- end }}
|
|
|
|
|
|
{{- /*
|
|
--------------------------------------------------------------------------------
|
|
-- Parameter emits the C++ parameter type and name for the given ast.Parameter
|
|
--------------------------------------------------------------------------------
|
|
*/ -}}
|
|
{{- define "Parameter" -}}
|
|
{{- if $.Init }}{{template "Type" $.Type}} {{$.Name}}
|
|
{{- else if $.Optional}}std::optional<{{template "Type" $.Type}}> {{$.Name}}
|
|
{{- else }}{{template "Type" $.Type}} {{$.Name}}
|
|
{{- end }}
|
|
{{- end}}
|