@gtkx/codegen 1.0.0-rc.4 → 1.1.0

package/src/khronos/model.ts

@@ -1,3 +1,4 @@
+import { sortStrings } from "@gtkx/utils";
 import { collectText, nodeAttr, nodeChildren, nodeTag, type OrderedNode, parseRegistryFile } from "./parse.js";
 
 type GlParam = {
@@ -6,12 +7,25 @@ type GlParam = {
     group?: string;
     len?: string;
     objectClass?: string;
+    kinds: string[];
+};
+
+type GlGlx = {
+    type: string;
+    opcode: string;
+    comment?: string;
 };
 
 type GlCommand = {
     name: string;
     returnCType: string;
     returnGroup?: string;
+    returnObjectClass?: string;
+    returnKinds: string[];
+    comment?: string;
+    aliasTarget?: string;
+    vecEquiv?: string;
+    glx?: GlGlx;
     params: GlParam[];
 };
 
@@ -19,10 +33,27 @@ type GlEnum = {
     name: string;
     value: string;
     groups: string[];
+    comment?: string;
+    alias?: string;
+    api?: string;
+    valueType?: string;
+    vendor?: string;
+    blockComment?: string;
+    isBitmask: boolean;
+};
+
+type GlEnumBlock = {
+    group?: string;
+    vendor?: string;
+    comment?: string;
+    isBitmask: boolean;
 };
 
 type GlInterfaceBlock = {
+    kind: "require" | "remove";
+    api?: string;
     profile?: string;
+    comment?: string;
     commands: string[];
     enums: string[];
 };
@@ -31,21 +62,63 @@ type GlFeature = {
     api: string;
     name: string;
     number: number;
-    requires: GlInterfaceBlock[];
-    removes: GlInterfaceBlock[];
+    blocks: GlInterfaceBlock[];
+};
+
+type GlExtension = {
+    name: string;
+    supported: string[];
+    comment?: string;
+    blocks: GlInterfaceBlock[];
+};
+
+type GlType = {
+    name: string;
+    declaration: string;
+    requires?: string;
+    comment?: string;
 };
 
 type GlRegistry = {
+    comment?: string;
+    types: Map<string, GlType>;
+    kinds: Map<string, string>;
     commands: Map<string, GlCommand>;
     enums: GlEnum[];
     features: GlFeature[];
+    extensions: GlExtension[];
+    aliasTargets: Map<string, string[]>;
+    bitmaskGroups: Set<string>;
 };
 
+type CommandExtras = {
+    params: GlParam[];
+    aliasTarget: string | undefined;
+    vecEquiv: string | undefined;
+    glx: GlGlx | undefined;
+};
+
+type SectionHandler = (section: OrderedNode, registry: GlRegistry) => void;
+
 const NAME_TAG = "name";
 const SKIP_IN_C_TYPE: Set<string> = new Set([NAME_TAG, "comment"]);
+const EMPTY_SKIP: Set<string> = new Set();
+
+const definedEntry = <K extends string, V>(key: K, value: V | undefined): Partial<Record<K, V>> =>
+    value === undefined ? {} : ({ [key]: value } as Partial<Record<K, V>>);
 
 const normalizeWhitespace = (text: string): string => text.replaceAll(/\s+/g, " ").trim();
 
+const normalizeBlockText = (text: string): string =>
+    text
+        .split("\n")
+        .map((line) => line.trim())
+        .join("\n")
+        .trim();
+
+const splitAttr = (value: string | undefined, separator: string): string[] =>
+    value === undefined ? [] : value.split(separator).map((part) => part.trim());
+
 const childNamed = (node: OrderedNode, tag: string): OrderedNode | undefined => {
     for (const child of nodeChildren(node)) {
         if (nodeTag(child) === tag) {
@@ -63,25 +136,51 @@ const elementName = (node: OrderedNode): string => {
         return "";
     }
 
-    return normalizeWhitespace(collectText(nameChild, new Set()));
+    return normalizeWhitespace(collectText(nameChild, EMPTY_SKIP));
 };
 
-const parseParam = (node: OrderedNode): GlParam => {
-    const param: GlParam = {
-        name: elementName(node),
-        cType: normalizeWhitespace(collectText(node, SKIP_IN_C_TYPE)),
-    };
+const parseParam = (node: OrderedNode): GlParam => ({
+    name: elementName(node),
+    cType: normalizeWhitespace(collectText(node, SKIP_IN_C_TYPE)),
+    kinds: splitAttr(nodeAttr(node, "kind"), ","),
+    ...definedEntry("group", nodeAttr(node, "group")),
+    ...definedEntry("len", nodeAttr(node, "len")),
+    ...definedEntry("objectClass", nodeAttr(node, "class")),
+});
 
-    const group = nodeAttr(node, "group");
-    const len = nodeAttr(node, "len");
-    const objectClass = nodeAttr(node, "class");
+const parseGlx = (node: OrderedNode): GlGlx | undefined => {
+    const type = nodeAttr(node, "type");
+    const opcode = nodeAttr(node, "opcode");
 
-    return {
-        ...param,
-        ...((group !== undefined) && { group }),
-        ...((len !== undefined) && { len }),
-        ...((objectClass !== undefined) && { objectClass }),
-    };
+    if (type === undefined || opcode === undefined || nodeAttr(node, NAME_TAG) !== undefined) {
+        return undefined;
+    }
+
+    return { type, opcode, ...definedEntry("comment", nodeAttr(node, "comment")) };
+};
+
+const collectCommandChild = (child: OrderedNode, into: CommandExtras): void => {
+    switch (nodeTag(child)) {
+        case "param": {
+            into.params.push(parseParam(child));
+            break;
+        }
+        case "alias": {
+            into.aliasTarget = nodeAttr(child, NAME_TAG);
+            break;
+        }
+        case "vecequiv": {
+            into.vecEquiv = nodeAttr(child, NAME_TAG);
+            break;
+        }
+        case "glx": {
+            into.glx ??= parseGlx(child);
+            break;
+        }
+        default: {
+            break;
+        }
+    }
 };
 
 const parseCommand = (node: OrderedNode): GlCommand | undefined => {
@@ -91,57 +190,73 @@ const parseCommand = (node: OrderedNode): GlCommand | undefined => {
         return undefined;
     }
 
-    const params: GlParam[] = [];
+    const extras: CommandExtras = { params: [], aliasTarget: undefined, vecEquiv: undefined, glx: undefined };
 
     for (const child of nodeChildren(node)) {
-        if (nodeTag(child) === "param") {
-            params.push(parseParam(child));
-        }
+        collectCommandChild(child, extras);
     }
 
-    const returnGroup = nodeAttr(proto, "group");
-
     return {
         name: elementName(proto),
         returnCType: normalizeWhitespace(collectText(proto, SKIP_IN_C_TYPE)),
-        ...((returnGroup !== undefined) && { returnGroup }),
-        params,
+        returnKinds: splitAttr(nodeAttr(proto, "kind"), ","),
+        ...definedEntry("returnGroup", nodeAttr(proto, "group")),
+        ...definedEntry("returnObjectClass", nodeAttr(proto, "class")),
+        ...definedEntry("comment", nodeAttr(node, "comment")),
+        ...definedEntry("aliasTarget", extras.aliasTarget),
+        ...definedEntry("vecEquiv", extras.vecEquiv),
+        ...definedEntry("glx", extras.glx),
+        params: extras.params,
     };
 };
 
-const parseEnum = (child: OrderedNode): GlEnum | undefined => {
-    if (nodeTag(child) !== "enum") {
-        return undefined;
-    }
-
-    const name = nodeAttr(child, "name");
+const parseEnum = (child: OrderedNode, block: GlEnumBlock): GlEnum | undefined => {
+    const name = nodeAttr(child, NAME_TAG);
     const value = nodeAttr(child, "value");
 
-    if (name === undefined || value === undefined) {
+    if (name === undefined || value === undefined || nodeTag(child) !== "enum") {
         return undefined;
     }
 
-    const group = nodeAttr(child, "group");
-
     return {
         name,
         value,
-        groups: group === undefined ? [] : group.split(",").map((part) => part.trim()),
+        groups: splitAttr(nodeAttr(child, "group") ?? block.group, ","),
+        isBitmask: block.isBitmask,
+        ...definedEntry("comment", nodeAttr(child, "comment")),
+        ...definedEntry("alias", nodeAttr(child, "alias")),
+        ...definedEntry("api", nodeAttr(child, "api")),
+        ...definedEntry("valueType", nodeAttr(child, "type")),
+        ...definedEntry("vendor", block.vendor),
+        ...definedEntry("blockComment", block.comment),
     };
 };
 
-const parseEnums = (node: OrderedNode, into: GlEnum[]): void => {
+const enumBlockFor = (node: OrderedNode): GlEnumBlock => ({
+    isBitmask: nodeAttr(node, "type") === "bitmask",
+    ...definedEntry("group", nodeAttr(node, "group")),
+    ...definedEntry("vendor", nodeAttr(node, "vendor")),
+    ...definedEntry("comment", nodeAttr(node, "comment")),
+});
+
+const parseEnums = (node: OrderedNode, registry: GlRegistry): void => {
+    const block = enumBlockFor(node);
+
+    if (block.isBitmask && block.group !== undefined) {
+        registry.bitmaskGroups.add(block.group);
+    }
+
     for (const child of nodeChildren(node)) {
-        const parsed = parseEnum(child);
+        const parsed = parseEnum(child, block);
 
         if (parsed !== undefined) {
-            into.push(parsed);
+            registry.enums.push(parsed);
         }
     }
 };
 
 const collectInterfaceMember = (child: OrderedNode, commands: string[], enums: string[]): void => {
-    const name = nodeAttr(child, "name");
+    const name = nodeAttr(child, NAME_TAG);
 
     if (name === undefined) {
         return;
@@ -156,7 +271,7 @@ const collectInterfaceMember = (child: OrderedNode, commands: string[], enums: s
     }
 };
 
-const parseInterfaceBlock = (node: OrderedNode): GlInterfaceBlock => {
+const parseInterfaceBlock = (node: OrderedNode, kind: GlInterfaceBlock["kind"]): GlInterfaceBlock => {
     const commands: string[] = [];
     const enums: string[] = [];
 
@@ -164,42 +279,80 @@ const parseInterfaceBlock = (node: OrderedNode): GlInterfaceBlock => {
         collectInterfaceMember(child, commands, enums);
     }
 
-    const profile = nodeAttr(node, "profile");
-
     return {
-        ...((profile !== undefined) && { profile }),
+        kind,
+        ...definedEntry("api", nodeAttr(node, "api")),
+        ...definedEntry("profile", nodeAttr(node, "profile")),
+        ...definedEntry("comment", nodeAttr(node, "comment")),
         commands,
         enums,
     };
 };
 
-const collectFeatureBlock = (child: OrderedNode, requires: GlInterfaceBlock[], removes: GlInterfaceBlock[]): void => {
-    const tag = nodeTag(child);
+const collectInterfaceBlocks = (node: OrderedNode): GlInterfaceBlock[] => {
+    const blocks: GlInterfaceBlock[] = [];
 
-    if (tag === "require") {
-        requires.push(parseInterfaceBlock(child));
-    } else if (tag === "remove") {
-        removes.push(parseInterfaceBlock(child));
+    for (const child of nodeChildren(node)) {
+        const tag = nodeTag(child);
+
+        if (tag === "require" || tag === "remove") {
+            blocks.push(parseInterfaceBlock(child, tag));
+        }
     }
+
+    return blocks;
 };
 
 const parseFeature = (node: OrderedNode): GlFeature | undefined => {
     const api = nodeAttr(node, "api");
-    const name = nodeAttr(node, "name");
+    const name = nodeAttr(node, NAME_TAG);
     const number = nodeAttr(node, "number");
 
     if (api === undefined || name === undefined || number === undefined) {
         return undefined;
     }
 
-    const requires: GlInterfaceBlock[] = [];
-    const removes: GlInterfaceBlock[] = [];
+    return { api, name, number: Number(number), blocks: collectInterfaceBlocks(node) };
+};
 
-    for (const child of nodeChildren(node)) {
-        collectFeatureBlock(child, requires, removes);
+const parseExtension = (node: OrderedNode): GlExtension | undefined => {
+    const name = nodeAttr(node, NAME_TAG);
+
+    if (name === undefined || nodeTag(node) !== "extension") {
+        return undefined;
+    }
+
+    return {
+        name,
+        supported: splitAttr(nodeAttr(node, "supported"), "|"),
+        ...definedEntry("comment", nodeAttr(node, "comment")),
+        blocks: collectInterfaceBlocks(node),
+    };
+};
+
+const typeName = (node: OrderedNode): string => {
+    const fromChild = elementName(node);
+
+    if (fromChild.length > 0) {
+        return fromChild;
     }
 
-    return { api, name, number: Number(number), requires, removes };
+    return nodeAttr(node, NAME_TAG) ?? "";
+};
+
+const parseType = (node: OrderedNode): GlType | undefined => {
+    const name = typeName(node);
+
+    if (name.length === 0 || nodeTag(node) !== "type") {
+        return undefined;
+    }
+
+    return {
+        name,
+        declaration: normalizeWhitespace(collectText(node, EMPTY_SKIP)),
+        ...definedEntry("requires", nodeAttr(node, "requires")),
+        ...definedEntry("comment", nodeAttr(node, "comment")),
+    };
 };
 
 const addCommand = (child: OrderedNode, into: Map<string, GlCommand>): void => {
@@ -214,31 +367,48 @@ const addCommand = (child: OrderedNode, into: Map<string, GlCommand>): void => {
     }
 };
 
-const parseCommandsSection = (section: OrderedNode, into: Map<string, GlCommand>): void => {
+const parseCommandsSection = (section: OrderedNode, registry: GlRegistry): void => {
     for (const child of nodeChildren(section)) {
-        addCommand(child, into);
+        addCommand(child, registry.commands);
     }
 };
 
-const parseSection = (section: OrderedNode, registry: GlRegistry): void => {
-    const tag = nodeTag(section);
-
-    if (tag === "commands") {
-        parseCommandsSection(section, registry.commands);
+const parseTypesSection = (section: OrderedNode, registry: GlRegistry): void => {
+    for (const child of nodeChildren(section)) {
+        const parsed = parseType(child);
 
-        return;
+        if (parsed !== undefined) {
+            registry.types.set(parsed.name, parsed);
+        }
     }
+};
 
-    if (tag === "enums") {
-        parseEnums(section, registry.enums);
+const addKind = (child: OrderedNode, into: Map<string, string>): void => {
+    const name = nodeAttr(child, NAME_TAG);
+    const desc = nodeAttr(child, "desc");
 
-        return;
+    if (name !== undefined && desc !== undefined && nodeTag(child) === "kind") {
+        into.set(name, desc);
     }
+};
 
-    if (tag !== "feature") {
-        return;
+const parseKindsSection = (section: OrderedNode, registry: GlRegistry): void => {
+    for (const child of nodeChildren(section)) {
+        addKind(child, registry.kinds);
     }
+};
 
+const parseExtensionsSection = (section: OrderedNode, registry: GlRegistry): void => {
+    for (const child of nodeChildren(section)) {
+        const parsed = parseExtension(child);
+
+        if (parsed !== undefined) {
+            registry.extensions.push(parsed);
+        }
+    }
+};
+
+const parseFeatureSection = (section: OrderedNode, registry: GlRegistry): void => {
     const feature = parseFeature(section);
 
     if (feature !== undefined) {
@@ -246,22 +416,97 @@ const parseSection = (section: OrderedNode, registry: GlRegistry): void => {
     }
 };
 
+const parseCommentSection = (section: OrderedNode, registry: GlRegistry): void => {
+    registry.comment = normalizeBlockText(collectText(section, EMPTY_SKIP));
+};
+
+const sectionHandlerFor = (tag: string): SectionHandler | undefined => {
+    switch (tag) {
+        case "comment": {
+            return parseCommentSection;
+        }
+        case "commands": {
+            return parseCommandsSection;
+        }
+        case "enums": {
+            return parseEnums;
+        }
+        case "extensions": {
+            return parseExtensionsSection;
+        }
+        case "feature": {
+            return parseFeatureSection;
+        }
+        case "kinds": {
+            return parseKindsSection;
+        }
+        case "types": {
+            return parseTypesSection;
+        }
+        default: {
+            return undefined;
+        }
+    }
+};
+
+const parseSection = (section: OrderedNode, registry: GlRegistry): void => {
+    sectionHandlerFor(nodeTag(section))?.(section, registry);
+};
+
+const sortAliasNames = (pending: Map<string, string[]>): Map<string, string[]> => {
+    const sorted: Map<string, string[]> = new Map();
+
+    for (const target of sortStrings(pending.keys())) {
+        sorted.set(target, sortStrings(pending.get(target) ?? []));
+    }
+
+    return sorted;
+};
+
+const buildAliasTargets = (commands: Map<string, GlCommand>): Map<string, string[]> => {
+    const pending: Map<string, string[]> = new Map();
+
+    for (const command of commands.values()) {
+        const target = command.aliasTarget;
+
+        if (target !== undefined) {
+            pending.set(target, [...(pending.get(target) ?? []), command.name]);
+        }
+    }
+
+    return sortAliasNames(pending);
+};
+
 const loadGlRegistry = (path: string): GlRegistry => {
-    const registry: GlRegistry = { commands: new Map<string, GlCommand>(), enums: [], features: [] };
+    const registry: GlRegistry = {
+        types: new Map<string, GlType>(),
+        kinds: new Map<string, string>(),
+        commands: new Map<string, GlCommand>(),
+        enums: [],
+        features: [],
+        extensions: [],
+        aliasTargets: new Map<string, string[]>(),
+        bitmaskGroups: new Set<string>(),
+    };
 
     for (const section of parseRegistryFile(path)) {
         parseSection(section, registry);
     }
 
+    registry.aliasTargets = buildAliasTargets(registry.commands);
+
     return registry;
 };
 
 export {
     loadGlRegistry,
     type GlParam,
+    type GlGlx,
     type GlCommand,
     type GlEnum,
     type GlInterfaceBlock,
     type GlFeature,
+    type GlExtension,
+    type GlType,
     type GlRegistry,
 };