cleanup

Author: AndrewRayCode

src/preprocessor/index.ts

@@ -4,31 +4,13 @@ import {
   preprocessComments,
   PreprocessorOptions,
   visitPreprocessedAst,
-  initExpressionParser,
 } from './preprocessor.js';
-import { formatError, GlslSyntaxError } from '../error.js';
-import type { SyntaxError } from '../error.js';
+import { formatError } from '../error.js';
 
 // This index file is currently only for package publishing, where the whole
 // library exists in the dist/ folder, so the below import is relative to dist/
 import * as parser from './preprocessor-parser.js';
 
-// Register the constant_expression parser so preprocessor.ts can parse #if
-// expression strings after macro expansion.
-initExpressionParser((src) => {
-  try {
-    return (parser.parse as any)(src, {
-      grammarSource: 'expression',
-      startRule: 'constant_expression',
-    });
-  } catch (e) {
-    if (e instanceof parser.SyntaxError) {
-      throw new GlslSyntaxError(src, 'expression', e as SyntaxError);
-    }
-    throw e;
-  }
-});
-
 /**
  * This is the main entry point for the preprocessor. It parses the source
  * code and returns an AST. It protects the user from the horrific peggy

src/preprocessor/preprocessor.ts

@@ -3,12 +3,22 @@ import {
   PreprocessorAstNode,
   PreprocessorElseIfNode,
   PreprocessorIdentifierNode,
-  PreprocessorIfNode,
   PreprocessorLiteralNode,
   PreprocessorSegmentNode,
 } from './preprocessor-node.js';
 import generate from './generator.js';
 
+import * as parser from './preprocessor-parser.js';
+import { formatError } from '../error.js';
+
+// Register the constant_expression parser so preprocessor.ts can parse #if
+// expression strings after macro expansion.
+const expressionParser = (src: string): PreprocessorAstNode =>
+  formatError(parser)(src, {
+    grammarSource: 'expression',
+    startRule: 'constant_expression',
+  });
+
 export type PreprocessorProgram = {
   type: string;
   program: PreprocessorSegmentNode[];
@@ -479,40 +489,24 @@ export type PreprocessorOptions = {
   grammarSource?: string;
 };
 
-// Parser for constant_expression strings, registered by index.ts at startup.
-// Must be set before preprocessAst() is called on any program that uses #if.
-let _exprParser: ((src: string) => PreprocessorAstNode) | undefined;
-export const initExpressionParser = (
-  fn: (src: string) => PreprocessorAstNode
-) => {
-  _exprParser = fn;
-};
-
 // Evaluate a raw #if / #elif expression string against the current macros.
 // Handles defined() before macro expansion (spec-correct order), then
 // parses the result as a constant_expression AST and evaluates it.
 const evaluateExpressionString = (expr: string, macros: Macros): any => {
-  if (!_exprParser) {
-    throw new Error(
-      'No expression parser registered. Import from preprocessor/index.js, or call initExpressionParser() first.'
-    );
-  }
   // Strip inline comments so "defined/**/A" is treated as "defined A"
   const stripped = preprocessComments(expr);
   // Step 1: evaluate defined(X) / defined X before any macro expansion
   const withDefined = stripped
-    .replace(
-      /defined\s*\(\s*([A-Za-z_][A-Za-z_0-9]*)\s*\)/g,
-      (_, id) => (id in macros ? '1' : '0')
+    .replace(/defined\s*\(\s*([A-Za-z_][A-Za-z_0-9]*)\s*\)/g, (_, id) =>
+      id in macros ? '1' : '0'
     )
-    .replace(
-      /defined\s+([A-Za-z_][A-Za-z_0-9]*)/g,
-      (_, id) => (id in macros ? '1' : '0')
+    .replace(/defined\s+([A-Za-z_][A-Za-z_0-9]*)/g, (_, id) =>
+      id in macros ? '1' : '0'
     );
   // Step 2: expand all macros in the resulting string
   const expanded = expandMacros(withDefined, macros);
   // Step 3: parse the expanded string as a constant_expression and evaluate
-  return evaluteExpression(_exprParser(expanded.trim()), macros);
+  return evaluteExpression(expressionParser(expanded.trim()), macros);
 };
 
 // Remove escaped newlines, rather than try to handle them in the grammar