148 lines
5.9 KiB
Cheetah
148 lines
5.9 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.
|
|
This file provides common template definitions and is included by WebGPU.h.tmpl
|
|
and WebGPU.cpp.tmpl.
|
|
|
|
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
|
|
--------------------------------------------------------------------------------
|
|
*/ -}}
|
|
|
|
|
|
{{- /*
|
|
--------------------------------------------------------------------------------
|
|
-- Type generates the C++ type for the given ast.Type
|
|
--------------------------------------------------------------------------------
|
|
*/ -}}
|
|
{{- define "Type" -}}
|
|
{{- if IsUndefinedType $}}void
|
|
{{- else if IsTypeName $}}
|
|
{{- if eq $.Name "boolean" }}bool
|
|
{{- else if eq $.Name "short" }}int16_t
|
|
{{- else if eq $.Name "unsigned short" }}uint16_t
|
|
{{- else if eq $.Name "long" }}int32_t
|
|
{{- else if eq $.Name "unsigned long" }}uint32_t
|
|
{{- else if eq $.Name "long long" }}int64_t
|
|
{{- else if eq $.Name "unsigned long long" }}uint64_t
|
|
{{- else if eq $.Name "object" }}Object
|
|
{{- else if eq $.Name "DOMString" }}std::string
|
|
{{- else if eq $.Name "USVString" }}std::string
|
|
{{- else if eq $.Name "ArrayBuffer" }}ArrayBuffer
|
|
{{- else if IsInterface (Lookup $.Name) }}Interface<{{$.Name}}>
|
|
{{- else }}{{$.Name}}
|
|
{{- end }}
|
|
{{- else if IsParametrizedType $}}{{$.Name}}<{{template "TypeList" $.Elems}}>
|
|
{{- else if IsNullableType $}}std::optional<{{template "Type" $.Type}}>
|
|
{{- else if IsUnionType $}}std::variant<{{template "VariantTypeList" $.Types}}>
|
|
{{- else if IsSequenceType $}}std::vector<{{template "Type" $.Elem}}>
|
|
{{- else if IsRecordType $}}std::unordered_map<{{template "Type" $.Key}}, {{template "Type" $.Elem}}>
|
|
{{- else }} /* Unhandled Type {{printf "%T" $}} */
|
|
{{- end -}}
|
|
{{- end }}
|
|
|
|
|
|
{{- /*
|
|
--------------------------------------------------------------------------------
|
|
-- AttributeType generates the C++ type for the given ast.Member
|
|
--------------------------------------------------------------------------------
|
|
*/ -}}
|
|
{{- define "AttributeType" -}}
|
|
{{- if $.Required }}{{template "AttributeClampHelper" $}}
|
|
{{- else if $.Init }}{{template "AttributeClampHelper" $}}
|
|
{{- else }}std::optional<{{template "AttributeClampHelper" $}}>
|
|
{{- end}}
|
|
{{- end }}
|
|
|
|
|
|
{{- /*
|
|
A helper for AttributeType that wraps integer types if necessary for WebIDL attributes.
|
|
Note that [Clamp] and [EnforceRange] are supposed to be an annotation on the type and not
|
|
the attribute, but webidlparser doesn't parse this correctly.
|
|
*/ -}}
|
|
{{- define "AttributeClampHelper" -}}
|
|
{{- if HasAnnotation $ "Clamp" }}
|
|
ClampedInteger<{{template "Type" $.Type}}>
|
|
{{- else if HasAnnotation $ "EnforceRange" }}
|
|
EnforceRangeInteger<{{template "Type" $.Type}}>
|
|
{{- else}}
|
|
{{template "Type" $.Type}}
|
|
{{- end }}
|
|
{{- end }}
|
|
|
|
|
|
{{- /*
|
|
--------------------------------------------------------------------------------
|
|
-- Literal generates a C++ literal value using the following arguments:
|
|
-- Value - the ast.Literal
|
|
-- Type - the ast.Type of the literal
|
|
--------------------------------------------------------------------------------
|
|
*/ -}}
|
|
{{- define "Literal" -}}
|
|
{{- if IsDefaultDictionaryLiteral $.Value}}{{template "Type" $.Type}}{}
|
|
{{- else if IsTypeName $.Type }}
|
|
{{- $ty := Lookup $.Type.Name}}
|
|
{{- if IsTypedef $ty }}{{Eval "Literal" "Value" $.Value "Type" $ty.Type}}
|
|
{{- else if IsEnum $ty }}{{$.Type.Name}}::{{EnumEntryName $.Value.Value}}
|
|
{{- else if IsBasicLiteral $.Value }}{{$.Value.Value}}
|
|
{{- else }}/* Unhandled Type {{printf "ty: %T $.Type.Name: %T $.Value: %T" $ty $.Type.Name $.Value}} */
|
|
{{- end }}
|
|
{{- else if IsSequenceType $.Type }}{{template "Type" $.Type}}{} {{- /* TODO: Assumes the initialiser is empty */}}
|
|
{{- else if IsBasicLiteral $.Value }}{{$.Value.Value}}
|
|
{{- else }} /* Unhandled Type {{printf "%T %T" $.Type $.Value}} */
|
|
{{- end}}
|
|
{{- end }}
|
|
|
|
|
|
{{- /*
|
|
--------------------------------------------------------------------------------
|
|
-- TypeList generates a C++ comma separated list of types from the given
|
|
-- []ast.Type
|
|
--------------------------------------------------------------------------------
|
|
*/ -}}
|
|
{{- define "TypeList" -}}
|
|
{{- range $i, $ty := $}}
|
|
{{- if $i }}, {{end}}
|
|
{{- template "Type" $ty}}
|
|
{{- end}}
|
|
{{- end }}
|
|
|
|
|
|
{{- /*
|
|
--------------------------------------------------------------------------------
|
|
-- VariantTypeList generates a C++ comma separated list of types from the given
|
|
-- []ast.Type, skipping any 'undefined' types
|
|
--------------------------------------------------------------------------------
|
|
*/ -}}
|
|
{{- define "VariantTypeList" -}}
|
|
{{- range $i, $ty := $}}
|
|
{{- if $i }}, {{end}}
|
|
{{- if IsUndefinedType $ty -}}
|
|
UndefinedType
|
|
{{- else}}
|
|
{{- template "Type" $ty}}
|
|
{{- end}}
|
|
{{- end}}
|
|
{{- end }}
|
|
|