@gtkx/codegen 1.0.0-rc.1 → 1.0.0-rc.2

package/src/khronos/plan.ts

@@ -1,14 +1,66 @@
-import { tScalar } from "../analysis/descriptor.js";
 import type { GlCommand, GlParam } from "./model.js";
+import { tScalar } from "../analysis/descriptor.js";
 
-export type GlScalar = {
+type GlScalar = {
     descriptor: string;
     tsAlias: string;
     viewType?: string;
     groupBearing?: boolean;
 };
 
-export const GL_SCALARS: Map<string, GlScalar> = new Map([
+type ParsedCType = {
+    base: string;
+    pointers: number;
+    constData: boolean;
+};
+
+type ParamPlan =
+    | { kind: "scalar"; scalar: GlScalar } |
+    { kind: "boolean" } |
+    { kind: "sync" } |
+    { kind: "string-in" } |
+    { kind: "string-array-in" } |
+    { kind: "array-in"; scalar: GlScalar } |
+    { kind: "ref-out"; scalar: GlScalar } |
+    { kind: "ref-array-out"; scalar: GlScalar; lenParamName: string } |
+    { kind: "ref-fixed-out"; scalar: GlScalar; length: number } |
+    { kind: "string-out"; lenParamName: string } |
+    { kind: "buffer" } |
+    { kind: "byte-offset" } |
+    { kind: "byte-offset-array" };
+
+type ReturnPlan =
+    | { kind: "void" } |
+    { kind: "scalar"; scalar: GlScalar } |
+    { kind: "boolean" } |
+    { kind: "string" } |
+    { kind: "sync" } |
+    { kind: "opaque-pointer" };
+
+type GlExclusionReason =
+    | "callback-parameter" |
+    "compsize-output" |
+    "computed-output-length" |
+    "unsupported-shape" |
+    "override-owned";
+
+type GlPlanPolicy = {
+    byteOffsetParams: Set<string>;
+    singleValuedQueries: Set<string>;
+};
+
+type CommandPlan =
+    | {
+        ok: true;
+        command: GlCommand;
+        params: ParamPlan[];
+        returnPlan: ReturnPlan;
+    } |
+    { ok: false; command: GlCommand; reason: GlExclusionReason };
+
+type ParamOutcome = { plan: ParamPlan } | { reason: GlExclusionReason };
+
+const GL_SCALARS: Map<string, GlScalar> = new Map([
     ["GLenum", { descriptor: tScalar("uint32"), tsAlias: "GLenum", viewType: "Uint32Array", groupBearing: true }],
     [
         "GLbitfield",
@@ -34,97 +86,92 @@ const GL_CHAR = "GLchar";
 const GL_SYNC = "GLsync";
 const CALLBACK_BASES: Set<string> = new Set(["GLDEBUGPROC", "GLDEBUGPROCARB", "GLDEBUGPROCKHR", "GLVULKANPROCNV"]);
 
-export type ParsedCType = {
-    base: string;
-    pointers: number;
-    constData: boolean;
-};
-
-export const parseCType = (cType: string): ParsedCType => {
+const parseCType = (cType: string): ParsedCType => {
     const pointers = (cType.match(/\*/g) ?? []).length;
-    const constData = /(^|\s)const(\s|\*)/.test(` ${cType} `) && pointers > 0;
+    const isConstData = /(^|\s)const(\s|\*)/.test(` ${cType} `) && pointers > 0;
+
     const base = cType
         .replaceAll("*", " ")
         .split(/\s+/)
         .filter((token) => token.length > 0 && token !== "const" && token !== "struct")
         .join(" ");
-    return { base, pointers, constData };
-};
-
-export type ParamPlan =
-    | { kind: "scalar"; scalar: GlScalar }
-    | { kind: "boolean" }
-    | { kind: "sync" }
-    | { kind: "string-in" }
-    | { kind: "string-array-in" }
-    | { kind: "array-in"; scalar: GlScalar }
-    | { kind: "ref-out"; scalar: GlScalar }
-    | { kind: "ref-array-out"; scalar: GlScalar; lenParamName: string }
-    | { kind: "ref-fixed-out"; scalar: GlScalar; length: number }
-    | { kind: "string-out"; lenParamName: string }
-    | { kind: "buffer" }
-    | { kind: "byte-offset" }
-    | { kind: "byte-offset-array" };
-
-export type ReturnPlan =
-    | { kind: "void" }
-    | { kind: "scalar"; scalar: GlScalar }
-    | { kind: "boolean" }
-    | { kind: "string" }
-    | { kind: "sync" }
-    | { kind: "opaque-pointer" };
-
-export type GlExclusionReason =
-    | "callback-parameter"
-    | "compsize-output"
-    | "computed-output-length"
-    | "unsupported-shape"
-    | "override-owned";
-
-export type GlPlanPolicy = {
-    byteOffsetParams: Set<string>;
-    singleValuedQueries: Set<string>;
-};
 
-export type CommandPlan =
-    | {
-          ok: true;
-          command: GlCommand;
-          params: ParamPlan[];
-          returnPlan: ReturnPlan;
-      }
-    | { ok: false; command: GlCommand; reason: GlExclusionReason };
+    return { base, pointers, constData: isConstData };
+};
 
 const isCompsize = (len: string): boolean => len.includes("COMPSIZE(");
 
-type ParamOutcome = { plan: ParamPlan } | { reason: GlExclusionReason };
+const planCompsizeOut = (command: GlCommand, scalar: GlScalar, policy: GlPlanPolicy): ParamOutcome => {
+    if (policy.singleValuedQueries.has(command.name)) {
+        return { plan: { kind: "ref-out", scalar } };
+    }
+
+    return { reason: "compsize-output" };
+};
 
 const planPointerOut = (command: GlCommand, param: GlParam, scalar: GlScalar, policy: GlPlanPolicy): ParamOutcome => {
     const len = param.len;
-    if (len === undefined || len === "1") return { plan: { kind: "ref-out", scalar } };
+
+    if (len === undefined || len === "1") {
+        return { plan: { kind: "ref-out", scalar } };
+    }
+
     if (isCompsize(len)) {
-        if (policy.singleValuedQueries.has(command.name)) return { plan: { kind: "ref-out", scalar } };
-        return { reason: "compsize-output" };
+        return planCompsizeOut(command, scalar, policy);
+    }
+
+    if (/^\d+$/.test(len)) {
+        return { plan: { kind: "ref-fixed-out", scalar, length: Number(len) } };
     }
-    if (/^\d+$/.test(len)) return { plan: { kind: "ref-fixed-out", scalar, length: Number.parseInt(len, 10) } };
+
     if (command.params.some((other) => other.name === len)) {
         return { plan: { kind: "ref-array-out", scalar, lenParamName: len } };
     }
+
     return { reason: "computed-output-length" };
 };
 
 const planByteOffsetParam = (parsed: ParsedCType): ParamOutcome => {
-    if (parsed.pointers === 1) return { plan: { kind: "byte-offset" } };
-    if (parsed.pointers === 2) return { plan: { kind: "byte-offset-array" } };
+    if (parsed.pointers === 1) {
+        return { plan: { kind: "byte-offset" } };
+    }
+
+    if (parsed.pointers === 2) {
+        return { plan: { kind: "byte-offset-array" } };
+    }
+
     return { reason: "unsupported-shape" };
 };
 
+const charStringOutLen = (command: GlCommand, param: GlParam, parsed: ParsedCType): string | undefined => {
+    if (parsed.pointers !== 1) {
+        return undefined;
+    }
+
+    const len = param.len;
+
+    if (len === undefined) {
+        return undefined;
+    }
+
+    return command.params.some((other) => other.name === len) ? len : undefined;
+};
+
 const planCharParam = (command: GlCommand, param: GlParam, parsed: ParsedCType): ParamOutcome => {
-    if (parsed.pointers === 1 && parsed.constData) return { plan: { kind: "string-in" } };
-    if (parsed.pointers === 2 && parsed.constData) return { plan: { kind: "string-array-in" } };
-    if (parsed.pointers === 1 && param.len !== undefined && command.params.some((other) => other.name === param.len)) {
-        return { plan: { kind: "string-out", lenParamName: param.len } };
+    if (parsed.pointers === 1 && parsed.constData) {
+        return { plan: { kind: "string-in" } };
+    }
+
+    if (parsed.pointers === 2 && parsed.constData) {
+        return { plan: { kind: "string-array-in" } };
     }
+
+    const lenParamName = charStringOutLen(command, param, parsed);
+
+    if (lenParamName !== undefined) {
+        return { plan: { kind: "string-out", lenParamName } };
+    }
+
     return { reason: "unsupported-shape" };
 };
 
@@ -135,57 +182,159 @@ const planScalarParam = (
     policy: GlPlanPolicy,
 ): ParamOutcome => {
     const scalar = GL_SCALARS.get(parsed.base);
+
     if (scalar === undefined) {
         throw new Error(`Unmapped C base type "${parsed.base}" on ${command.name}(${param.name}: ${param.cType})`);
     }
-    if (parsed.pointers === 0) return { plan: { kind: "scalar", scalar } };
-    if (parsed.pointers === 1 && parsed.constData) return { plan: { kind: "array-in", scalar } };
-    if (parsed.pointers === 1) return planPointerOut(command, param, scalar, policy);
+
+    if (parsed.pointers === 0) {
+        return { plan: { kind: "scalar", scalar } };
+    }
+
+    if (parsed.pointers === 1 && parsed.constData) {
+        return { plan: { kind: "array-in", scalar } };
+    }
+
+    if (parsed.pointers === 1) {
+        return planPointerOut(command, param, scalar, policy);
+    }
+
+    return { reason: "unsupported-shape" };
+};
+
+const planVoidParam = (parsed: ParsedCType): ParamOutcome => {
+    if (parsed.pointers === 1) {
+        return { plan: { kind: "buffer" } };
+    }
+
+    return { reason: "unsupported-shape" };
+};
+
+const planBooleanParam = (parsed: ParsedCType): ParamOutcome => {
+    if (parsed.pointers === 0) {
+        return { plan: { kind: "boolean" } };
+    }
+
     return { reason: "unsupported-shape" };
 };
 
+const planCharOrBoolean = (command: GlCommand, param: GlParam, parsed: ParsedCType): ParamOutcome | undefined => {
+    if (parsed.base === GL_CHAR || parsed.base === "GLcharARB") {
+        return planCharParam(command, param, parsed);
+    }
+
+    if (parsed.base === GL_BOOLEAN) {
+        return planBooleanParam(parsed);
+    }
+
+    return undefined;
+};
+
+const planByBase = (command: GlCommand, param: GlParam, parsed: ParsedCType, policy: GlPlanPolicy): ParamOutcome => {
+    const { base, pointers } = parsed;
+
+    if (base === GL_SYNC && pointers === 0) {
+        return { plan: { kind: "sync" } };
+    }
+
+    if (base === "void") {
+        return planVoidParam(parsed);
+    }
+
+    return planCharOrBoolean(command, param, parsed) ?? planScalarParam(command, param, parsed, policy);
+};
+
 const planParam = (command: GlCommand, param: GlParam, policy: GlPlanPolicy): ParamOutcome => {
     const parsed = parseCType(param.cType);
-    const { base, pointers } = parsed;
+    const { base } = parsed;
+
     if (CALLBACK_BASES.has(base) || base.startsWith("_cl_")) {
         return { reason: "callback-parameter" };
     }
+
     if (policy.byteOffsetParams.has(`${command.name}:${param.name}`)) {
         return planByteOffsetParam(parsed);
     }
-    if (base === GL_SYNC && pointers === 0) return { plan: { kind: "sync" } };
+
+    return planByBase(command, param, parsed, policy);
+};
+
+const planScalarReturn = (base: string): ReturnPlan | undefined => {
     if (base === "void") {
-        if (pointers === 1) return { plan: { kind: "buffer" } };
-        return { reason: "unsupported-shape" };
+        return { kind: "void" };
     }
-    if (base === GL_CHAR || base === "GLcharARB") return planCharParam(command, param, parsed);
+
+    if (base === GL_SYNC) {
+        return { kind: "sync" };
+    }
+
     if (base === GL_BOOLEAN) {
-        if (pointers === 0) return { plan: { kind: "boolean" } };
-        return { reason: "unsupported-shape" };
+        return { kind: "boolean" };
+    }
+
+    const scalar = GL_SCALARS.get(base);
+
+    if (scalar !== undefined) {
+        return { kind: "scalar", scalar };
     }
-    return planScalarParam(command, param, parsed, policy);
+
+    return undefined;
+};
+
+const planPointerReturn = (base: string): ReturnPlan | undefined => {
+    if (base === "void") {
+        return { kind: "opaque-pointer" };
+    }
+
+    if (base === "GLubyte" || base === GL_CHAR) {
+        return { kind: "string" };
+    }
+
+    return undefined;
 };
 
 const planReturn = (command: GlCommand): ReturnPlan => {
     const { base, pointers } = parseCType(command.returnCType);
-    if (base === "void" && pointers === 0) return { kind: "void" };
-    if (base === "void" && pointers === 1) return { kind: "opaque-pointer" };
-    if (base === GL_SYNC && pointers === 0) return { kind: "sync" };
-    if (base === GL_BOOLEAN && pointers === 0) return { kind: "boolean" };
-    if ((base === "GLubyte" || base === GL_CHAR) && pointers === 1) return { kind: "string" };
-    const scalar = GL_SCALARS.get(base);
-    if (scalar !== undefined && pointers === 0) return { kind: "scalar", scalar };
+    let plan: ReturnPlan | undefined;
+
+    if (pointers === 0) {
+        plan = planScalarReturn(base);
+    } else if (pointers === 1) {
+        plan = planPointerReturn(base);
+    }
+
+    if (plan !== undefined) {
+        return plan;
+    }
+
     throw new Error(`Unmapped return type "${command.returnCType}" on ${command.name}`);
 };
 
-export const planCommand = (command: GlCommand, policy: GlPlanPolicy): CommandPlan => {
+const planCommand = (command: GlCommand, policy: GlPlanPolicy): CommandPlan => {
     const params: ParamPlan[] = [];
+
     for (const param of command.params) {
         const outcome = planParam(command, param, policy);
+
         if ("reason" in outcome) {
             return { ok: false, command, reason: outcome.reason };
         }
+
         params.push(outcome.plan);
     }
+
     return { ok: true, command, params, returnPlan: planReturn(command) };
 };
+
+export {
+    GL_SCALARS,
+    parseCType,
+    planCommand,
+    type GlScalar,
+    type ParsedCType,
+    type ParamPlan,
+    type ReturnPlan,
+    type GlExclusionReason,
+    type GlPlanPolicy,
+    type CommandPlan,
+};