Skip to content

Commit 601158c

Browse files
kainino0xkainino0x
committed
Allow overriding namespace of enum values
This is to allow defining compatibility mode extensions in the standard header.
1 parent a44ea5b commit 601158c

4 files changed

Lines changed: 80 additions & 58 deletions

File tree

‎gen/cheader.tmpl‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -198,15 +198,15 @@ struct {{CType .Base ""}}CallbackInfo;
198198
{{- range $entryIndex, $_ := .Entries}}
199199
{{- if .}}
200200
{{- MCommentEnumValue .Doc 0 $enum $entryIndex }}
201-
_wgpu_EXTEND_ENUM({{CType $enum.Base ""}}, {{CEnumName $enum.Base .Base}}, {{EnumValue32 $enum $entryIndex | printf "0x%.8X"}});
201+
_wgpu_EXTEND_ENUM({{CType $enum.Base ""}}, {{CEnumValueName $enum.Base .Base}}, {{EnumValue32 $enum $entryIndex | printf "0x%.8X"}});
202202
{{- end}}
203203
{{- end}}
204204
{{- else}}
205205
typedef enum {{CType .Base ""}} {
206206
{{- range $entryIndex, $_ := .Entries}}
207207
{{- if .}}
208208
{{- MCommentEnumValue .Doc 4 $enum $entryIndex }}
209-
{{CEnumName $enum.Base .Base}} = {{EnumValue32 $enum $entryIndex | printf "0x%.8X"}},
209+
{{CEnumValueName $enum.Base .Base}} = {{EnumValue32 $enum $entryIndex | printf "0x%.8X"}},
210210
{{- end}}
211211
{{- end}}
212212
{{CType $enum.Base ""}}_Force32 = 0x7FFFFFFF
@@ -230,7 +230,7 @@ typedef WGPUFlags {{CType .Base ""}};
230230
{{- end}}
231231
{{- range $entryIndex, $_ := .Entries}}
232232
{{- MCommentBitflagValue .Doc 0 $bitflag $entryIndex }}
233-
static const {{CType $bitflag.Base ""}} {{CEnumName $bitflag.Base .Base}} = {{BitflagValue $bitflag $entryIndex}};
233+
static const {{CType $bitflag.Base ""}} {{CEnumValueName $bitflag.Base .Base}} = {{BitflagValue $bitflag $entryIndex}};
234234
{{- end}}
235235
{{- end}}
236236

‎gen/gen.go‎

Lines changed: 75 additions & 53 deletions
Original file line numberDiff line numberDiff line change
@@ -194,7 +194,7 @@ func (g *Generator) Gen(dst io.Writer) error {
194194
"CamelCase": CamelCase,
195195
"ConstantCaseName": g.ConstantCaseName,
196196
"PascalCaseName": g.PascalCaseName,
197-
"CEnumName": g.CEnumName,
197+
"CEnumValueName": g.CEnumValueName,
198198
"CMethodName": g.CMethodName,
199199
"CType": g.CType,
200200
"CValue": g.CValue,
@@ -243,86 +243,104 @@ func (g *Generator) FindBaseType(typ string) Base {
243243
case "constant":
244244
idx := slices.IndexFunc(g.Constants, func(c Constant) bool { return c.Name == name })
245245
if idx == -1 {
246-
return Base{Name: name, Namespace: g.PrefixForNamespace("")}
246+
return Base{Name: name, Namespace: "webgpu"}
247247
}
248248
return g.Constants[idx].Base
249249
case "typedef":
250250
idx := slices.IndexFunc(g.Typedefs, func(t Typedef) bool { return t.Name == name })
251251
if idx == -1 {
252-
return Base{Name: name, Namespace: g.PrefixForNamespace("")}
252+
return Base{Name: name, Namespace: "webgpu"}
253253
}
254254
return g.Typedefs[idx].Base
255255
case "enum":
256256
idx := slices.IndexFunc(g.Enums, func(e Enum) bool { return e.Name == name })
257257
if idx == -1 {
258-
return Base{Name: name, Namespace: g.PrefixForNamespace("")}
258+
return Base{Name: name, Namespace: "webgpu"}
259259
}
260260
return g.Enums[idx].Base
261261
case "bitflag":
262262
idx := slices.IndexFunc(g.Bitflags, func(b Bitflag) bool { return b.Name == name })
263263
if idx == -1 {
264-
return Base{Name: name, Namespace: g.PrefixForNamespace("")}
264+
return Base{Name: name, Namespace: "webgpu"}
265265
}
266266
return g.Bitflags[idx].Base
267267
case "struct":
268268
idx := slices.IndexFunc(g.Structs, func(s Struct) bool { return s.Name == name })
269269
if idx == -1 {
270-
return Base{Name: name, Namespace: g.PrefixForNamespace("")}
270+
return Base{Name: name, Namespace: "webgpu"}
271271
}
272272
return g.Structs[idx].Base
273273
case "callback":
274274
idx := slices.IndexFunc(g.Callbacks, func(c Callback) bool { return c.Name == name })
275275
if idx == -1 {
276-
return Base{Name: name, Namespace: g.PrefixForNamespace("")}
276+
return Base{Name: name, Namespace: "webgpu"}
277277
}
278278
return g.Callbacks[idx].Base
279279
case "object":
280280
idx := slices.IndexFunc(g.Objects, func(o Object) bool { return o.Name == name })
281281
if idx == -1 {
282-
return Base{Name: name, Namespace: g.PrefixForNamespace("")}
282+
return Base{Name: name, Namespace: "webgpu"}
283283
}
284284
return g.Objects[idx].Base
285285
default:
286286
panic("Unable to find unknown category type: " + category + " for identifier: " + typ)
287287
}
288288
}
289289

290-
func (g *Generator) ConstantCaseName(b Base) string {
291-
if b.Extended {
292-
return ConstantCase(b.Name)
293-
}
294-
295-
prefix := g.PrefixForNamespace(b.Namespace)
296-
switch prefix {
297-
case "":
298-
return ConstantCase(b.Name)
299-
default:
300-
return ConstantCase(prefix + "_" + b.Name)
290+
func (g *Generator) ResolveNamespaceForTopLevel(b Base) string {
291+
if b.Namespace != "" {
292+
return b.Namespace
293+
} else if b.Extended {
294+
return ""
295+
} else {
296+
return g.ExtPrefix
301297
}
302298
}
303299

304-
func (g *Generator) PascalCaseName(b Base) string {
305-
if b.Extended {
306-
return PascalCase(b.Name)
300+
func (g *Generator) ResolveNamespaceForSecondLevel(typ Base, entry Base) string {
301+
if entry.Namespace != "" {
302+
return entry.Namespace
303+
} else if typ.Namespace != "" {
304+
return typ.Namespace
305+
} else {
306+
return g.ExtPrefix
307307
}
308+
}
308309

309-
prefix := g.PrefixForNamespace(b.Namespace)
310+
func (g *Generator) CanonicalCaseName(prefix string, b Base) string {
310311
switch prefix {
311312
case "":
312-
return PascalCase(b.Name)
313+
return b.Name
313314
default:
314-
return PascalCase(prefix + "_" + b.Name)
315+
return prefix + "_" + b.Name
315316
}
316317
}
317318

318-
func (g *Generator) CEnumName(typ Base, entry Base) string {
319-
if !typ.Extended {
320-
return g.CType(typ, "") + "_" + PascalCase(entry.Name)
319+
func (g *Generator) ConstantCaseName(b Base) string {
320+
prefix := g.PrefixForNamespace(g.ResolveNamespaceForTopLevel(b))
321+
return ConstantCase(g.CanonicalCaseName(prefix, b))
322+
}
323+
324+
func (g *Generator) PascalCaseName(b Base) string {
325+
prefix := g.PrefixForNamespace(g.ResolveNamespaceForTopLevel(b))
326+
return PascalCase(g.CanonicalCaseName(prefix, b))
327+
}
328+
329+
func (g *Generator) PrefixForNamespaceAtSecondLevel(typ Base, entry Base) string {
330+
outerNamespace := g.ResolveNamespaceForTopLevel(typ)
331+
innerNamespace := g.ResolveNamespaceForSecondLevel(typ, entry)
332+
if outerNamespace == innerNamespace {
333+
return ""
321334
} else {
322-
return g.CType(typ, "") + "_" + g.PascalCaseName(entry)
335+
return g.PrefixForNamespace(innerNamespace)
323336
}
324337
}
325338

339+
func (g *Generator) CEnumValueName(typ Base, entry Base) string {
340+
entryPrefix := g.PrefixForNamespaceAtSecondLevel(typ, entry)
341+
return g.CType(typ, "") + "_" + PascalCase(g.CanonicalCaseName(entryPrefix, entry))
342+
}
343+
326344
func (g *Generator) CMethodName(o Object, m Function) string {
327345
if !o.Extended {
328346
return g.PascalCaseName(o.Base) + PascalCase(m.Name)
@@ -488,34 +506,38 @@ func (g *Generator) CallbackArgs(f Callback) string {
488506
return sb.String()
489507
}
490508

491-
func (g *Generator) EnumValue16(e Enum, entryIndex int) (uint16, error) {
509+
func (g *Generator) EnumValue32(e Enum, entryIndex int) (uint32, error) {
492510
entry := e.Entries[entryIndex]
493-
if entry.Value == "" {
494-
return uint16(entryIndex), nil
495-
} else {
496-
var num string
497-
var base int
498-
if strings.HasPrefix(entry.Value, "0x") {
499-
base = 16
500-
num = strings.TrimPrefix(entry.Value, "0x")
501-
} else {
502-
base = 10
503-
num = entry.Value
511+
512+
var enum_prefix uint16
513+
if entry.Namespace != "" {
514+
if g.EnumPrefix != 0 {
515+
return 0, fmt.Errorf("EnumValue32: entry %s with overridden namespace %s can only be used in core webgpu.h (with global enum_prefix 0)", entry.Name, entry.Namespace)
504516
}
505-
value, err := strconv.ParseUint(num, base, 16)
506-
if err != nil {
507-
return 0, err
517+
if entry.Value == nil {
518+
return 0, fmt.Errorf("EnumValue32: entry %s with overridden namespace %s must have an explicit value", entry.Name, entry.Namespace)
508519
}
509-
return uint16(value), nil
520+
switch entry.Namespace {
521+
case "compatibility_mode":
522+
enum_prefix = 0x2000
523+
default:
524+
return 0, fmt.Errorf("EnumValue32: unknown namespace %s", entry.Namespace)
525+
}
526+
} else {
527+
enum_prefix = g.EnumPrefix
510528
}
511-
}
512529

513-
func (g *Generator) EnumValue32(e Enum, entryIndex int) (uint32, error) {
514-
value16, err := g.EnumValue16(e, entryIndex)
515-
if err != nil {
516-
return 0, err
530+
var value16 uint16
531+
if entry.Value == nil {
532+
value16 = uint16(entryIndex)
533+
if int(value16) != entryIndex {
534+
return 0, fmt.Errorf("EnumValue32: entry %s default value (entry index %d) is too large", entry.Name, entryIndex)
535+
}
536+
} else {
537+
value16 = *entry.Value
517538
}
518-
return uint32(g.EnumPrefix)<<16 | uint32(value16), nil
539+
540+
return uint32(enum_prefix)<<16 | uint32(value16), nil
519541
}
520542

521543
func bitflagEntryValue(entry BitflagEntry, entryIndex int) (uint64, error) {
@@ -589,10 +611,10 @@ func (g *Generator) BitflagValue(b Bitflag, entryIndex int, isDocString bool) (s
589611

590612
func (g *Generator) PrefixForNamespace(namespace string) string {
591613
switch namespace {
592-
case "":
593-
return g.ExtPrefix
594614
case "webgpu":
595615
return ""
616+
case "compatibility_mode":
617+
return ""
596618
default:
597619
return namespace
598620
}

‎gen/yml.go‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -46,7 +46,7 @@ type Enum struct {
4646
}
4747
type EnumEntry struct {
4848
Base `yaml:",inline"`
49-
Value string `yaml:"value"`
49+
Value *uint16 `yaml:"value"`
5050
}
5151

5252
type Bitflag struct {

‎schema.json‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -263,7 +263,7 @@
263263
"description": "The name/namespace of the specification"
264264
},
265265
"enum_prefix": {
266-
"type": "number",
266+
"type": "integer",
267267
"minimum": 0,
268268
"maximum": 32767,
269269
"description": "The dedicated enum prefix for the implementation specific header to avoid collisions"

0 commit comments

Comments
 (0)