comments

Author: AndrewRayCode

src/preprocessor/preprocessor.ts

@@ -139,6 +139,8 @@ export type NodeEvaluators = Partial<
   }
 >;
 
+// Use the same parser, but starting from the expression entry point, to parse
+// expression strings on the fly after macro expansion
 const expressionParser = (src: string): PreprocessorAstNode =>
   formatError(parser)(src, {
     grammarSource: 'expression',
@@ -488,23 +490,30 @@ export type PreprocessorOptions = {
   startRule?: 'constant_expression' | 'program';
 };
 
-// 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.
+// Expressions are stored as strings in the AST, since their contents may be
+// affected by macro expansion. This function performs macro expansion, then
+// parses and evaluates the expanded string. It uses the same grammar, but
+// starting from the "constant expression" rule to parse, aka the rule for the
+// expression of an if / elif
 const evaluateExpressionString = (expr: string, macros: Macros): any => {
   // 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
+
+  // In the input
+  //     #define A
+  //     #if !defined(A)
+  // If we expand macros then evaluate the expression it will break. The spec
+  // says that identifiers inside defined() are not eligible for expansion. So
+  // hacky way to evaluate them first before macro expansion and parsing
+  const defined = stripped
     .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'
     );
-  // 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
+
+  const expanded = expandMacros(defined, macros);
   return evaluteExpression(expressionParser(expanded.trim()), macros);
 };