1763 lines
50 KiB
TypeScript
1763 lines
50 KiB
TypeScript
// SPDX-License-Identifier: GPL-3.0-or-later
|
|
// Copyright (C) 2026 ZiroEDA and contributors.
|
|
// Portions derived from KiCad, copyright The KiCad Developers. See NOTICE.md.
|
|
/**
|
|
* `include/libeval_compiler/libeval_compiler.h` +
|
|
* `common/libeval_compiler/libeval_compiler.cpp` + `grammar.lemon`: the
|
|
* expression language of the custom DRC rules — tokenizer, parser, the
|
|
* TREE_NODE tree, code generation to UOPs, and the stack machine that runs
|
|
* them.
|
|
*
|
|
* The C++ parser is `grammar.c`, generated by lemon from grammar.lemon. What
|
|
* is here is that grammar as a precedence-climbing parser building the SAME
|
|
* TREE_NODE tree the lemon actions build (`newNode` per rule action, the
|
|
* same op codes, the same leaf layout), with the lemon precedence table
|
|
* followed exactly — including its oddities: `&&` binds LOOSER than `||`,
|
|
* comparisons and `.` are nonassoc (a second one in a row is a syntax
|
|
* error), `!` is right-associative at a level between comparisons and `+`.
|
|
*
|
|
* `srcPos` of a node is the compiler's source position when the node is
|
|
* made, which for a lemon reduction is the start of the lookahead token;
|
|
* this parser makes the node once it has seen the token after the
|
|
* construct, so the positions the error messages subtract from agree.
|
|
*/
|
|
import { DoubleValueFromString, type EdaUnits } from '../eda_units.js';
|
|
import { wildCompareString } from '../string_utils.js';
|
|
|
|
export const TR_OP_BINARY_MASK = 0x200;
|
|
export const TR_OP_UNARY_MASK = 0x100;
|
|
|
|
export const TR_OP_MUL = 0x201;
|
|
export const TR_OP_DIV = 0x202;
|
|
export const TR_OP_ADD = 0x203;
|
|
export const TR_OP_SUB = 0x204;
|
|
export const TR_OP_LESS = 0x205;
|
|
export const TR_OP_GREATER = 0x206;
|
|
export const TR_OP_LESS_EQUAL = 0x207;
|
|
export const TR_OP_GREATER_EQUAL = 0x208;
|
|
export const TR_OP_EQUAL = 0x209;
|
|
export const TR_OP_NOT_EQUAL = 0x20a;
|
|
export const TR_OP_BOOL_AND = 0x20b;
|
|
export const TR_OP_BOOL_OR = 0x20c;
|
|
export const TR_OP_BOOL_NOT = 0x100;
|
|
export const TR_OP_FUNC_CALL = 24;
|
|
export const TR_OP_METHOD_CALL = 25;
|
|
export const TR_UOP_PUSH_VAR = 1;
|
|
export const TR_UOP_PUSH_VALUE = 2;
|
|
|
|
export enum COMPILATION_STAGE {
|
|
CST_PARSE = 0,
|
|
CST_CODEGEN,
|
|
CST_RUNTIME,
|
|
}
|
|
|
|
export interface ERROR_STATUS {
|
|
pendingError: boolean;
|
|
stage: COMPILATION_STAGE;
|
|
message: string;
|
|
srcPos: number;
|
|
}
|
|
|
|
export enum VAR_TYPE_T {
|
|
VT_STRING = 1,
|
|
VT_NUMERIC,
|
|
VT_NUMERIC_DOUBLE,
|
|
VT_UNDEFINED,
|
|
VT_PARSE_ERROR,
|
|
VT_NULL,
|
|
}
|
|
|
|
export enum TOKEN_TYPE_T {
|
|
TR_UNDEFINED = 0,
|
|
TR_NUMBER = 1,
|
|
TR_IDENTIFIER = 2,
|
|
TR_ASSIGN = 3,
|
|
TR_STRUCT_REF = 4,
|
|
TR_STRING = 5,
|
|
TR_UNIT = 6,
|
|
TR_ARG_LIST = 7,
|
|
TR_NULL = 8,
|
|
}
|
|
|
|
/** The terminals of grammar.lemon (`grammar.h`). */
|
|
export enum G_TOKEN {
|
|
G_ENDS = 0,
|
|
G_IDENTIFIER,
|
|
G_ASSIGN,
|
|
G_SEMCOL,
|
|
G_COMMA,
|
|
G_BOOL_AND,
|
|
G_BOOL_OR,
|
|
G_BOOL_XOR,
|
|
G_LESS_THAN,
|
|
G_GREATER_THAN,
|
|
G_LESS_EQUAL_THAN,
|
|
G_GREATER_EQUAL_THAN,
|
|
G_EQUAL,
|
|
G_NOT_EQUAL,
|
|
G_BOOL_NOT,
|
|
G_PLUS,
|
|
G_MINUS,
|
|
G_DIVIDE,
|
|
G_MULT,
|
|
G_STRUCT_REF,
|
|
G_UNIT,
|
|
G_VALUE,
|
|
G_STRING,
|
|
G_PARENL,
|
|
G_PARENR,
|
|
}
|
|
|
|
export type FUNC_CALL_REF = ((aCtx: CONTEXT, aSelf: VAR_REF | null) => void) | null;
|
|
|
|
export interface T_TOKEN_VALUE {
|
|
str: string | null;
|
|
num: number;
|
|
idx: number;
|
|
}
|
|
|
|
// Lemon can't handle c'tors and d'tors, so we provide a poor-man's version.
|
|
export const defaultTokenValue: T_TOKEN_VALUE = { str: null, num: 0.0, idx: 0 };
|
|
|
|
export interface T_TOKEN {
|
|
token: number;
|
|
value: T_TOKEN_VALUE;
|
|
}
|
|
|
|
export class TREE_NODE {
|
|
value: T_TOKEN_VALUE = { str: null, num: 0, idx: 0 };
|
|
op = 0;
|
|
leaf: [TREE_NODE | null, TREE_NODE | null] = [null, null];
|
|
uop: UOP | null = null;
|
|
valid = false;
|
|
isTerminal = false;
|
|
isVisited = false;
|
|
srcPos = 0;
|
|
|
|
SetUop(aOp: number, aValue: number, aUnits: EdaUnits): void;
|
|
SetUop(aOp: number, aValue: string, aStringIsWildcard: boolean): void;
|
|
SetUop(aOp: number, aRef?: VAR_REF | null): void;
|
|
SetUop(aOp: number, aFunc: FUNC_CALL_REF, aRef?: VAR_REF | null): void;
|
|
SetUop(
|
|
aOp: number,
|
|
a?: number | string | VAR_REF | FUNC_CALL_REF | null,
|
|
b?: EdaUnits | boolean | VAR_REF | null,
|
|
): void {
|
|
this.uop = null;
|
|
|
|
if (typeof a === 'number') {
|
|
const val = new VALUE(a);
|
|
val.SetUnits(b as EdaUnits);
|
|
this.uop = new UOP(aOp, val);
|
|
} else if (typeof a === 'string') {
|
|
const val = new VALUE(a, b as boolean);
|
|
this.uop = new UOP(aOp, val);
|
|
} else if (typeof a === 'function') {
|
|
this.uop = UOP.MethodCall(aOp, a, (b as VAR_REF | null) ?? null);
|
|
} else {
|
|
this.uop = UOP.VarRef(aOp, (a as VAR_REF | null) ?? null);
|
|
}
|
|
}
|
|
}
|
|
|
|
export function newNode(
|
|
compiler: COMPILER,
|
|
op: number,
|
|
value: T_TOKEN_VALUE = defaultTokenValue,
|
|
): TREE_NODE {
|
|
const t2 = new TREE_NODE();
|
|
t2.valid = true;
|
|
t2.value.str = value.str !== null ? value.str : null;
|
|
t2.value.num = value.num;
|
|
t2.value.idx = value.idx;
|
|
t2.op = op;
|
|
t2.leaf[0] = null;
|
|
t2.leaf[1] = null;
|
|
t2.isTerminal = false;
|
|
t2.srcPos = compiler.GetSourcePos();
|
|
t2.uop = null;
|
|
|
|
compiler.GcItem(t2);
|
|
|
|
return t2;
|
|
}
|
|
|
|
function formatOpName(op: number): string {
|
|
const simpleOps: [number, string][] = [
|
|
[TR_OP_MUL, 'MUL'],
|
|
[TR_OP_DIV, 'DIV'],
|
|
[TR_OP_ADD, 'ADD'],
|
|
[TR_OP_SUB, 'SUB'],
|
|
[TR_OP_LESS, 'LESS'],
|
|
[TR_OP_GREATER, 'GREATER'],
|
|
[TR_OP_LESS_EQUAL, 'LESS_EQUAL'],
|
|
[TR_OP_GREATER_EQUAL, 'GREATER_EQUAL'],
|
|
[TR_OP_EQUAL, 'EQUAL'],
|
|
[TR_OP_NOT_EQUAL, 'NEQUAL'],
|
|
[TR_OP_BOOL_AND, 'AND'],
|
|
[TR_OP_BOOL_OR, 'OR'],
|
|
[TR_OP_BOOL_NOT, 'NOT'],
|
|
];
|
|
|
|
for (const [o, mnemonic] of simpleOps) {
|
|
if (o === op) return mnemonic;
|
|
}
|
|
|
|
return '???';
|
|
}
|
|
|
|
export class UNIT_RESOLVER {
|
|
GetSupportedUnits(): readonly string[] {
|
|
return UNIT_RESOLVER.nullUnits;
|
|
}
|
|
private static readonly nullUnits: readonly string[] = [];
|
|
|
|
GetSupportedUnitsTypes(): readonly EdaUnits[] {
|
|
return UNIT_RESOLVER.nullUnitTypes;
|
|
}
|
|
private static readonly nullUnitTypes: readonly EdaUnits[] = [];
|
|
|
|
GetSupportedUnitsMessage(): string {
|
|
return '';
|
|
}
|
|
|
|
Convert(_aString: string, _unitType: number): number {
|
|
return 0.0;
|
|
}
|
|
}
|
|
|
|
export class VALUE {
|
|
private m_type: VAR_TYPE_T;
|
|
private m_valueDbl: number; // mutable to support deferred evaluation
|
|
private m_valueStr: string; // mutable to support deferred evaluation
|
|
private m_stringIsWildcard: boolean;
|
|
private m_isDeferredDbl: boolean;
|
|
private m_lambdaDbl: (() => number) | null = null;
|
|
private m_isDeferredStr: boolean;
|
|
private m_lambdaStr: (() => string) | null = null;
|
|
private m_units: EdaUnits;
|
|
|
|
constructor();
|
|
constructor(aStr: string, aIsWildcard?: boolean);
|
|
constructor(aVal: number);
|
|
constructor(a?: string | number, aIsWildcard = false) {
|
|
if (typeof a === 'string') {
|
|
this.m_type = VAR_TYPE_T.VT_STRING;
|
|
this.m_valueDbl = 0;
|
|
this.m_valueStr = a;
|
|
this.m_stringIsWildcard = aIsWildcard;
|
|
} else if (typeof a === 'number') {
|
|
this.m_type = VAR_TYPE_T.VT_NUMERIC;
|
|
this.m_valueDbl = a;
|
|
this.m_valueStr = '';
|
|
this.m_stringIsWildcard = false;
|
|
} else {
|
|
this.m_type = VAR_TYPE_T.VT_UNDEFINED;
|
|
this.m_valueDbl = 0;
|
|
this.m_valueStr = '';
|
|
this.m_stringIsWildcard = false;
|
|
}
|
|
|
|
this.m_isDeferredDbl = false;
|
|
this.m_isDeferredStr = false;
|
|
this.m_units = 'unscaled';
|
|
}
|
|
|
|
static MakeNullValue(): VALUE {
|
|
const v = new VALUE();
|
|
v.m_type = VAR_TYPE_T.VT_NULL;
|
|
return v;
|
|
}
|
|
|
|
AsDouble(): number {
|
|
if (this.m_isDeferredDbl) {
|
|
this.m_valueDbl = this.m_lambdaDbl!();
|
|
this.m_isDeferredDbl = false;
|
|
}
|
|
|
|
return this.m_valueDbl;
|
|
}
|
|
|
|
AsString(): string {
|
|
if (this.m_isDeferredStr) {
|
|
this.m_valueStr = this.m_lambdaStr!();
|
|
this.m_isDeferredStr = false;
|
|
}
|
|
|
|
return this.m_valueStr;
|
|
}
|
|
|
|
EqualTo(aCtx: CONTEXT, b: VALUE): boolean {
|
|
if (this.m_type === VAR_TYPE_T.VT_UNDEFINED || b.m_type === VAR_TYPE_T.VT_UNDEFINED)
|
|
return false;
|
|
|
|
if (this.m_type === VAR_TYPE_T.VT_NULL && b.m_type === VAR_TYPE_T.VT_NULL) return true;
|
|
|
|
if (this.m_type === VAR_TYPE_T.VT_NUMERIC && b.m_type === VAR_TYPE_T.VT_NUMERIC) {
|
|
return this.AsDouble() === b.AsDouble();
|
|
} else if (this.m_type === VAR_TYPE_T.VT_STRING && b.m_type === VAR_TYPE_T.VT_STRING) {
|
|
if (b.m_stringIsWildcard) return wildCompareString(b.AsString(), this.AsString(), false);
|
|
else return this.AsString().toLowerCase() === b.AsString().toLowerCase();
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
// NB: this is not an inverse of EqualTo as they both return false for undefined values.
|
|
NotEqualTo(aCtx: CONTEXT, b: VALUE): boolean {
|
|
if (this.m_type === VAR_TYPE_T.VT_UNDEFINED || b.m_type === VAR_TYPE_T.VT_UNDEFINED)
|
|
return false;
|
|
|
|
return !this.EqualTo(aCtx, b);
|
|
}
|
|
|
|
GetType(): VAR_TYPE_T {
|
|
return this.m_type;
|
|
}
|
|
|
|
Set(aValue: number): void;
|
|
Set(aValue: string): void;
|
|
Set(val: VALUE): void;
|
|
Set(a: number | string | VALUE): void {
|
|
if (typeof a === 'number') {
|
|
this.m_type = VAR_TYPE_T.VT_NUMERIC;
|
|
this.m_valueDbl = a;
|
|
} else if (typeof a === 'string') {
|
|
this.m_type = VAR_TYPE_T.VT_STRING;
|
|
this.m_valueStr = a;
|
|
} else {
|
|
this.m_type = a.m_type;
|
|
this.m_valueDbl = a.m_valueDbl;
|
|
|
|
if (this.m_type === VAR_TYPE_T.VT_STRING) this.m_valueStr = a.m_valueStr;
|
|
}
|
|
}
|
|
|
|
/** `SetDeferredEval( std::function<double()> )` */
|
|
SetDeferredEvalDbl(aLambda: () => number): void {
|
|
this.m_type = VAR_TYPE_T.VT_NUMERIC;
|
|
this.m_lambdaDbl = aLambda;
|
|
this.m_isDeferredDbl = true;
|
|
}
|
|
|
|
/** `SetDeferredEval( std::function<wxString()> )` */
|
|
SetDeferredEvalStr(aLambda: () => string): void {
|
|
this.m_type = VAR_TYPE_T.VT_STRING;
|
|
this.m_lambdaStr = aLambda;
|
|
this.m_isDeferredStr = true;
|
|
}
|
|
|
|
SetUnits(aUnits: EdaUnits): void {
|
|
this.m_units = aUnits;
|
|
}
|
|
GetUnits(): EdaUnits {
|
|
return this.m_units;
|
|
}
|
|
|
|
StringIsWildcard(): boolean {
|
|
return this.m_stringIsWildcard;
|
|
}
|
|
}
|
|
|
|
export abstract class VAR_REF {
|
|
abstract GetType(): VAR_TYPE_T;
|
|
abstract GetValue(aCtx: CONTEXT): VALUE;
|
|
}
|
|
|
|
export class CONTEXT {
|
|
private m_ownedValues: VALUE[] = [];
|
|
private m_stack: (VALUE | null)[] = new Array(100).fill(null); // std::stack not performant enough
|
|
private m_stackPtr = 0;
|
|
private m_errorCallback: ((aMessage: string, aOffset: number) => void) | null = null;
|
|
|
|
AllocValue(): VALUE {
|
|
const v = new VALUE();
|
|
this.m_ownedValues.push(v);
|
|
return v;
|
|
}
|
|
|
|
StoreValue(aValue: VALUE): VALUE {
|
|
this.m_ownedValues.push(aValue);
|
|
return aValue;
|
|
}
|
|
|
|
Push(v: VALUE | null): void {
|
|
this.m_stack[this.m_stackPtr++] = v;
|
|
}
|
|
|
|
Pop(): VALUE | null {
|
|
if (this.m_stackPtr === 0) {
|
|
this.ReportError('Malformed expression');
|
|
return this.AllocValue();
|
|
}
|
|
|
|
return this.m_stack[--this.m_stackPtr]!;
|
|
}
|
|
|
|
SP(): number {
|
|
return this.m_stackPtr;
|
|
}
|
|
|
|
SetErrorCallback(aCallback: ((aMessage: string, aOffset: number) => void) | null): void {
|
|
this.m_errorCallback = aCallback;
|
|
}
|
|
|
|
HasErrorCallback(): boolean {
|
|
return this.m_errorCallback !== null;
|
|
}
|
|
|
|
ReportError(aErrorMsg: string): void {
|
|
if (this.m_errorCallback) this.m_errorCallback(aErrorMsg, -1);
|
|
}
|
|
}
|
|
|
|
export class UCODE {
|
|
protected m_ucode: UOP[] = [];
|
|
|
|
AddOp(uop: UOP): void {
|
|
this.m_ucode.push(uop);
|
|
}
|
|
|
|
Run(ctx: CONTEXT): VALUE {
|
|
try {
|
|
for (const op of this.m_ucode) op.Exec(ctx);
|
|
} catch {
|
|
// rules which fail outright should not be fired; return 0/false
|
|
return ctx.StoreValue(new VALUE(0));
|
|
}
|
|
|
|
if (ctx.SP() === 1) {
|
|
return ctx.Pop()!;
|
|
} else {
|
|
// If stack is corrupted after execution it suggests a problem with the compiler, not
|
|
// the rule....
|
|
// do not use "assert"; it crashes outright on OSX
|
|
console.assert(ctx.SP() === 1);
|
|
|
|
// non-well-formed rules should not be fired on a release build
|
|
return ctx.StoreValue(new VALUE(0));
|
|
}
|
|
}
|
|
|
|
Dump(): string {
|
|
let rv = '';
|
|
|
|
for (const op of this.m_ucode) {
|
|
rv += op.Format();
|
|
rv += '\n';
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
CreateVarRef(_aVar: string, _aField: string): VAR_REF | null {
|
|
return null;
|
|
}
|
|
|
|
CreateFuncCall(_aName: string): FUNC_CALL_REF {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
export class UOP {
|
|
private m_op: number;
|
|
private m_func: FUNC_CALL_REF = null;
|
|
private m_ref: VAR_REF | null = null;
|
|
private m_value: VALUE | null = null;
|
|
|
|
/** `UOP( int op, std::unique_ptr<VALUE> value )` */
|
|
constructor(op: number, value: VALUE | null) {
|
|
this.m_op = op;
|
|
this.m_value = value;
|
|
}
|
|
|
|
/** `UOP( int op, std::unique_ptr<VAR_REF> vref )` */
|
|
static VarRef(op: number, vref: VAR_REF | null): UOP {
|
|
const u = new UOP(op, null);
|
|
u.m_ref = vref;
|
|
return u;
|
|
}
|
|
|
|
/** `UOP( int op, FUNC_CALL_REF func, std::unique_ptr<VAR_REF> vref = nullptr )` */
|
|
static MethodCall(op: number, func: FUNC_CALL_REF, vref: VAR_REF | null = null): UOP {
|
|
const u = new UOP(op, null);
|
|
u.m_func = func;
|
|
u.m_ref = vref;
|
|
return u;
|
|
}
|
|
|
|
Exec(ctx: CONTEXT): void {
|
|
switch (this.m_op) {
|
|
case TR_UOP_PUSH_VAR: {
|
|
let value: VALUE | null = null;
|
|
|
|
if (this.m_ref) value = ctx.StoreValue(this.m_ref.GetValue(ctx));
|
|
else value = ctx.AllocValue();
|
|
|
|
ctx.Push(value);
|
|
break;
|
|
}
|
|
|
|
case TR_UOP_PUSH_VALUE:
|
|
ctx.Push(this.m_value);
|
|
return;
|
|
|
|
case TR_OP_METHOD_CALL:
|
|
if (this.m_func) this.m_func(ctx, this.m_ref);
|
|
|
|
return;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
const AS_DOUBLE = (arg: VALUE | null): number => (arg ? arg.AsDouble() : 0.0);
|
|
|
|
if (this.m_op & TR_OP_BINARY_MASK) {
|
|
const arg2 = ctx.Pop();
|
|
const arg1 = ctx.Pop();
|
|
let result: number;
|
|
|
|
if (ctx.HasErrorCallback()) {
|
|
if (
|
|
arg1 &&
|
|
arg1.GetType() === VAR_TYPE_T.VT_STRING &&
|
|
arg2 &&
|
|
arg2.GetType() === VAR_TYPE_T.VT_NUMERIC
|
|
) {
|
|
ctx.ReportError(
|
|
`Type mismatch between '${arg1.AsString()}' and ${formatLf(arg2.AsDouble())}`,
|
|
);
|
|
} else if (
|
|
arg1 &&
|
|
arg1.GetType() === VAR_TYPE_T.VT_NUMERIC &&
|
|
arg2 &&
|
|
arg2.GetType() === VAR_TYPE_T.VT_STRING
|
|
) {
|
|
ctx.ReportError(
|
|
`Type mismatch between ${formatLf(arg1.AsDouble())} and '${arg2.AsString()}'`,
|
|
);
|
|
}
|
|
}
|
|
|
|
// TODO: This doesn't fully calculate units correctly yet. We really need to work out the dimensional analysis
|
|
// TODO: (and do this independently of unit specifics - e.g. MM + INCH needs to return one of the dimension
|
|
// TODO: types, but our units framework doesn't currently allow this. Therefore, use some heuristics to
|
|
// TODO: determine the resulting operation unit type for now
|
|
const getOpResultUnits = (aVal1: VALUE | null, aVal2: VALUE | null): EdaUnits => {
|
|
if (!(aVal1 && aVal2)) return 'unscaled';
|
|
|
|
// This condition can occur in, e.g., a unary negation operation
|
|
if (aVal1.GetUnits() === 'unscaled' && aVal2.GetUnits() !== 'unscaled')
|
|
return aVal2.GetUnits();
|
|
|
|
if (aVal1.GetUnits() !== 'unscaled' && aVal2.GetUnits() === 'unscaled')
|
|
return aVal1.GetUnits();
|
|
|
|
return aVal2.GetUnits();
|
|
};
|
|
|
|
let resultUnits: EdaUnits = 'unscaled';
|
|
|
|
switch (this.m_op) {
|
|
case TR_OP_ADD:
|
|
result = AS_DOUBLE(arg1) + AS_DOUBLE(arg2);
|
|
resultUnits = getOpResultUnits(arg1, arg2);
|
|
break;
|
|
case TR_OP_SUB:
|
|
result = AS_DOUBLE(arg1) - AS_DOUBLE(arg2);
|
|
resultUnits = getOpResultUnits(arg1, arg2);
|
|
break;
|
|
case TR_OP_MUL:
|
|
result = AS_DOUBLE(arg1) * AS_DOUBLE(arg2);
|
|
resultUnits = getOpResultUnits(arg1, arg2);
|
|
break;
|
|
case TR_OP_DIV:
|
|
result = AS_DOUBLE(arg1) / AS_DOUBLE(arg2);
|
|
resultUnits = getOpResultUnits(arg1, arg2);
|
|
break;
|
|
case TR_OP_LESS_EQUAL:
|
|
result = AS_DOUBLE(arg1) <= AS_DOUBLE(arg2) ? 1 : 0;
|
|
break;
|
|
case TR_OP_GREATER_EQUAL:
|
|
result = AS_DOUBLE(arg1) >= AS_DOUBLE(arg2) ? 1 : 0;
|
|
break;
|
|
case TR_OP_LESS:
|
|
result = AS_DOUBLE(arg1) < AS_DOUBLE(arg2) ? 1 : 0;
|
|
break;
|
|
case TR_OP_GREATER:
|
|
result = AS_DOUBLE(arg1) > AS_DOUBLE(arg2) ? 1 : 0;
|
|
break;
|
|
case TR_OP_EQUAL:
|
|
if (!arg1 || !arg2) result = arg1 === arg2 ? 1 : 0;
|
|
else if (arg2.GetType() === VAR_TYPE_T.VT_UNDEFINED)
|
|
result = arg2.EqualTo(ctx, arg1) ? 1 : 0;
|
|
else result = arg1.EqualTo(ctx, arg2) ? 1 : 0;
|
|
break;
|
|
case TR_OP_NOT_EQUAL:
|
|
if (!arg1 || !arg2) result = arg1 !== arg2 ? 1 : 0;
|
|
else if (arg2.GetType() === VAR_TYPE_T.VT_UNDEFINED)
|
|
result = arg2.NotEqualTo(ctx, arg1) ? 1 : 0;
|
|
else result = arg1.NotEqualTo(ctx, arg2) ? 1 : 0;
|
|
break;
|
|
case TR_OP_BOOL_AND:
|
|
result = AS_DOUBLE(arg1) !== 0.0 && AS_DOUBLE(arg2) !== 0.0 ? 1 : 0;
|
|
break;
|
|
case TR_OP_BOOL_OR:
|
|
result = AS_DOUBLE(arg1) !== 0.0 || AS_DOUBLE(arg2) !== 0.0 ? 1 : 0;
|
|
break;
|
|
default:
|
|
result = 0.0;
|
|
break;
|
|
}
|
|
|
|
const rp = ctx.AllocValue();
|
|
rp.Set(result);
|
|
rp.SetUnits(resultUnits);
|
|
ctx.Push(rp);
|
|
return;
|
|
} else if (this.m_op & TR_OP_UNARY_MASK) {
|
|
const arg1 = ctx.Pop();
|
|
const ARG1VALUE = arg1 ? arg1.AsDouble() : 0.0;
|
|
let result: number;
|
|
const resultUnits: EdaUnits = arg1 ? arg1.GetUnits() : 'unscaled';
|
|
|
|
switch (this.m_op) {
|
|
case TR_OP_BOOL_NOT:
|
|
result = ARG1VALUE !== 0.0 ? 0 : 1;
|
|
break;
|
|
default:
|
|
result = ARG1VALUE !== 0.0 ? 1 : 0;
|
|
break;
|
|
}
|
|
|
|
const rp = ctx.AllocValue();
|
|
rp.Set(result);
|
|
rp.SetUnits(resultUnits);
|
|
ctx.Push(rp);
|
|
return;
|
|
}
|
|
}
|
|
|
|
Format(): string {
|
|
let str: string;
|
|
|
|
switch (this.m_op) {
|
|
case TR_UOP_PUSH_VAR:
|
|
str = 'PUSH VAR [ref]';
|
|
break;
|
|
|
|
case TR_UOP_PUSH_VALUE:
|
|
if (!this.m_value) str = 'PUSH nullptr';
|
|
else if (this.m_value.GetType() === VAR_TYPE_T.VT_NUMERIC)
|
|
str = `PUSH NUM [${this.m_value.AsDouble().toFixed(10)}]`;
|
|
else str = `PUSH STR [${this.m_value.AsString()}]`;
|
|
break;
|
|
|
|
case TR_OP_METHOD_CALL:
|
|
str = 'MCALL';
|
|
break;
|
|
|
|
case TR_OP_FUNC_CALL:
|
|
str = 'FCALL';
|
|
break;
|
|
|
|
default:
|
|
str = `${formatOpName(this.m_op)} ${this.m_op}`;
|
|
break;
|
|
}
|
|
|
|
return str;
|
|
}
|
|
}
|
|
|
|
/** printf's `%lf` */
|
|
function formatLf(v: number): string {
|
|
return v.toFixed(6);
|
|
}
|
|
|
|
export class TOKENIZER {
|
|
private m_str = '';
|
|
private m_pos = 0;
|
|
|
|
Restart(aStr: string): void {
|
|
this.m_str = aStr;
|
|
this.m_pos = 0;
|
|
}
|
|
|
|
Clear(): void {
|
|
this.m_str = '';
|
|
this.m_pos = 0;
|
|
}
|
|
|
|
GetChar(): number {
|
|
if (this.m_pos >= this.m_str.length) return 0;
|
|
|
|
return this.m_str.charCodeAt(this.m_pos);
|
|
}
|
|
|
|
Done(): boolean {
|
|
return this.m_pos >= this.m_str.length;
|
|
}
|
|
|
|
NextChar(aAdvance = 1): void {
|
|
this.m_pos += aAdvance;
|
|
}
|
|
|
|
GetPos(): number {
|
|
return this.m_pos;
|
|
}
|
|
|
|
GetString(): string {
|
|
let rv = '';
|
|
|
|
while (this.m_pos < this.m_str.length && this.m_str[this.m_pos] !== "'") {
|
|
if (
|
|
this.m_str[this.m_pos] === '\\' &&
|
|
this.m_pos + 1 < this.m_str.length &&
|
|
this.m_str[this.m_pos + 1] === "'"
|
|
)
|
|
this.m_pos++;
|
|
|
|
rv += this.m_str[this.m_pos++];
|
|
}
|
|
|
|
this.m_pos++;
|
|
|
|
return rv;
|
|
}
|
|
|
|
GetChars(cond: (c: number) => boolean): string {
|
|
let rv = '';
|
|
let p = this.m_pos;
|
|
|
|
while (p < this.m_str.length && cond(this.m_str.charCodeAt(p))) {
|
|
rv += this.m_str[p];
|
|
p++;
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
MatchAhead(match: string, stopCond: (c: number) => boolean): boolean {
|
|
const remaining = this.m_str.length - this.m_pos;
|
|
|
|
if (remaining < match.length) return false;
|
|
|
|
if (this.m_str.substr(this.m_pos, match.length) === match)
|
|
return (
|
|
remaining === match.length || stopCond(this.m_str.charCodeAt(this.m_pos + match.length))
|
|
);
|
|
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// <cctype> on a wxUniChar cast to int: ASCII classes only
|
|
const isdigit = (c: number): boolean => c >= 0x30 && c <= 0x39;
|
|
const isalpha = (c: number): boolean => (c >= 0x41 && c <= 0x5a) || (c >= 0x61 && c <= 0x7a);
|
|
const isalnum = (c: number): boolean => isdigit(c) || isalpha(c);
|
|
|
|
enum LEXER_STATE {
|
|
LS_DEFAULT = 0,
|
|
LS_STRING = 1,
|
|
}
|
|
|
|
/** A token with the source position the compiler held when it was read. */
|
|
interface LEXED {
|
|
tok: T_TOKEN;
|
|
pos: number;
|
|
}
|
|
|
|
/** `pEval->parseError( "Syntax error" )`, thrown out of the parser. */
|
|
class SYNTAX_ERROR extends Error {}
|
|
|
|
/**
|
|
* The grammar.lemon precedence table, lowest first. The lemon rule gets the
|
|
* precedence of its last terminal with one; a token not in the table has none.
|
|
*/
|
|
enum ASSOC {
|
|
LEFT,
|
|
RIGHT,
|
|
NONASSOC,
|
|
}
|
|
|
|
const PREC_COMMA = 1;
|
|
const PREC_BOOL_AND = 2;
|
|
const PREC_BOOL_OR = 3;
|
|
// const PREC_BOOL_XOR = 4; // no rule uses G_BOOL_XOR
|
|
const PREC_COMPARE = 5;
|
|
const PREC_BOOL_NOT = 6;
|
|
const PREC_ADDITIVE = 7;
|
|
const PREC_MULTIPLICATIVE = 8;
|
|
const PREC_STRUCT_REF = 9;
|
|
// const PREC_UNIT = 10; // `nt ::= G_VALUE G_UNIT` is handled at the primary
|
|
|
|
interface BINARY_OP {
|
|
prec: number;
|
|
assoc: ASSOC;
|
|
/** The TREE_NODE op the rule's action makes. */
|
|
op: number;
|
|
}
|
|
|
|
const BINARY_OPS: Partial<Record<G_TOKEN, BINARY_OP>> = {
|
|
[G_TOKEN.G_COMMA]: { prec: PREC_COMMA, assoc: ASSOC.LEFT, op: TOKEN_TYPE_T.TR_ARG_LIST },
|
|
[G_TOKEN.G_BOOL_AND]: { prec: PREC_BOOL_AND, assoc: ASSOC.LEFT, op: TR_OP_BOOL_AND },
|
|
[G_TOKEN.G_BOOL_OR]: { prec: PREC_BOOL_OR, assoc: ASSOC.LEFT, op: TR_OP_BOOL_OR },
|
|
[G_TOKEN.G_LESS_THAN]: { prec: PREC_COMPARE, assoc: ASSOC.NONASSOC, op: TR_OP_LESS },
|
|
[G_TOKEN.G_GREATER_THAN]: { prec: PREC_COMPARE, assoc: ASSOC.NONASSOC, op: TR_OP_GREATER },
|
|
[G_TOKEN.G_LESS_EQUAL_THAN]: { prec: PREC_COMPARE, assoc: ASSOC.NONASSOC, op: TR_OP_LESS_EQUAL },
|
|
[G_TOKEN.G_GREATER_EQUAL_THAN]: {
|
|
prec: PREC_COMPARE,
|
|
assoc: ASSOC.NONASSOC,
|
|
op: TR_OP_GREATER_EQUAL,
|
|
},
|
|
[G_TOKEN.G_EQUAL]: { prec: PREC_COMPARE, assoc: ASSOC.NONASSOC, op: TR_OP_EQUAL },
|
|
[G_TOKEN.G_NOT_EQUAL]: { prec: PREC_COMPARE, assoc: ASSOC.NONASSOC, op: TR_OP_NOT_EQUAL },
|
|
[G_TOKEN.G_PLUS]: { prec: PREC_ADDITIVE, assoc: ASSOC.LEFT, op: TR_OP_ADD },
|
|
[G_TOKEN.G_MINUS]: { prec: PREC_ADDITIVE, assoc: ASSOC.LEFT, op: TR_OP_SUB },
|
|
[G_TOKEN.G_MULT]: { prec: PREC_MULTIPLICATIVE, assoc: ASSOC.LEFT, op: TR_OP_MUL },
|
|
[G_TOKEN.G_DIVIDE]: { prec: PREC_MULTIPLICATIVE, assoc: ASSOC.LEFT, op: TR_OP_DIV },
|
|
[G_TOKEN.G_STRUCT_REF]: {
|
|
prec: PREC_STRUCT_REF,
|
|
assoc: ASSOC.NONASSOC,
|
|
op: TOKEN_TYPE_T.TR_STRUCT_REF,
|
|
},
|
|
};
|
|
|
|
export class COMPILER {
|
|
protected m_lexerState: LEXER_STATE = LEXER_STATE.LS_DEFAULT;
|
|
protected m_tokenizer = new TOKENIZER();
|
|
protected m_localeDecimalSeparator = '.';
|
|
protected m_unitResolver: UNIT_RESOLVER = new UNIT_RESOLVER();
|
|
protected m_sourcePos = 0;
|
|
protected m_parseFinished = false;
|
|
protected m_errorStatus: ERROR_STATUS = {
|
|
pendingError: false,
|
|
stage: COMPILATION_STAGE.CST_PARSE,
|
|
message: '',
|
|
srcPos: 0,
|
|
};
|
|
protected m_errorCallback: ((aMessage: string, aOffset: number) => void) | null = null;
|
|
protected m_tree: TREE_NODE | null = null;
|
|
protected m_gcItems: TREE_NODE[] = [];
|
|
|
|
/** The lemon parser's state: the tokens read so far and the one being looked at. */
|
|
private m_tokens: LEXED[] = [];
|
|
private m_tokenIndex = 0;
|
|
|
|
/*
|
|
* clear() should be invoked by the client if a new input string is to be processed. It
|
|
* will reset the parser. User defined variables are retained.
|
|
*/
|
|
Clear(): void {
|
|
this.m_tokenizer.Clear();
|
|
|
|
if (this.m_tree) {
|
|
this.freeTree(this.m_tree);
|
|
this.m_tree = null;
|
|
}
|
|
|
|
this.m_tree = null;
|
|
this.m_gcItems = [];
|
|
this.m_tokens = [];
|
|
this.m_tokenIndex = 0;
|
|
}
|
|
|
|
/* Used by the lemon parser */
|
|
parseError(s: string): void {
|
|
this.reportError(COMPILATION_STAGE.CST_PARSE, s);
|
|
}
|
|
|
|
parseOk(): void {
|
|
this.m_parseFinished = true;
|
|
}
|
|
|
|
GetSourcePos(): number {
|
|
return this.m_sourcePos;
|
|
}
|
|
|
|
setRoot(root: TREE_NODE): void {
|
|
this.m_tree = root;
|
|
}
|
|
|
|
freeTree(tree: TREE_NODE): void {
|
|
if (tree.leaf[0]) this.freeTree(tree.leaf[0]);
|
|
if (tree.leaf[1]) this.freeTree(tree.leaf[1]);
|
|
|
|
tree.uop = null;
|
|
}
|
|
|
|
Compile(aString: string, aCode: UCODE, aPreflightContext: CONTEXT): boolean {
|
|
// Feed parser token after token until end of input.
|
|
|
|
this.newString(aString);
|
|
|
|
if (this.m_tree) {
|
|
this.freeTree(this.m_tree);
|
|
this.m_tree = null;
|
|
}
|
|
|
|
this.m_tree = null;
|
|
this.m_parseFinished = false;
|
|
|
|
if (aString.length === 0) {
|
|
this.m_parseFinished = true;
|
|
return this.generateUCode(aCode, aPreflightContext);
|
|
}
|
|
|
|
// The lemon parser consumes the tokens as they are lexed and reports a
|
|
// syntax error at the token it cannot take; ours lexes on demand from the
|
|
// same stream and throws at that token. A lexer error stops it just as the
|
|
// C++'s pending-error check after each token does.
|
|
try {
|
|
this.parseInput();
|
|
} catch (e) {
|
|
if (!(e instanceof SYNTAX_ERROR)) throw e;
|
|
}
|
|
|
|
if (this.m_errorStatus.pendingError) return false;
|
|
|
|
return this.generateUCode(aCode, aPreflightContext);
|
|
}
|
|
|
|
SetErrorCallback(aCallback: ((aMessage: string, aOffset: number) => void) | null): void {
|
|
this.m_errorCallback = aCallback;
|
|
}
|
|
|
|
IsErrorPending(): boolean {
|
|
return this.m_errorStatus.pendingError;
|
|
}
|
|
|
|
GetError(): ERROR_STATUS {
|
|
return this.m_errorStatus;
|
|
}
|
|
|
|
GcItem(aItem: TREE_NODE): void {
|
|
this.m_gcItems.push(aItem);
|
|
}
|
|
|
|
protected reportError(stage: COMPILATION_STAGE, aErrorMsg: string, aPos = -1): void {
|
|
if (aPos === -1) aPos = this.m_sourcePos;
|
|
|
|
this.m_errorStatus.pendingError = true;
|
|
this.m_errorStatus.stage = stage;
|
|
this.m_errorStatus.message = aErrorMsg;
|
|
this.m_errorStatus.srcPos = aPos;
|
|
|
|
if (this.m_errorCallback) this.m_errorCallback(aErrorMsg, aPos);
|
|
}
|
|
|
|
/* Begin processing of a new input string */
|
|
protected newString(aString: string): void {
|
|
this.Clear();
|
|
|
|
this.m_lexerState = LEXER_STATE.LS_DEFAULT;
|
|
this.m_tokenizer.Restart(aString);
|
|
this.m_parseFinished = false;
|
|
}
|
|
|
|
/* Tokenizer: Next token/value taken from input string. */
|
|
protected getToken(): T_TOKEN {
|
|
const rv: T_TOKEN = { token: 0, value: { ...defaultTokenValue } };
|
|
let done = false;
|
|
|
|
do {
|
|
switch (this.m_lexerState) {
|
|
case LEXER_STATE.LS_DEFAULT:
|
|
done = this.lexDefault(rv);
|
|
break;
|
|
case LEXER_STATE.LS_STRING:
|
|
done = this.lexString(rv);
|
|
break;
|
|
}
|
|
} while (!done);
|
|
|
|
return rv;
|
|
}
|
|
|
|
protected lexString(aToken: T_TOKEN): boolean {
|
|
aToken.token = G_TOKEN.G_STRING;
|
|
aToken.value.str = this.m_tokenizer.GetString();
|
|
|
|
this.m_lexerState = LEXER_STATE.LS_DEFAULT;
|
|
return true;
|
|
}
|
|
|
|
protected resolveUnits(): number {
|
|
let unitId = 0;
|
|
|
|
for (const unitName of this.m_unitResolver.GetSupportedUnits()) {
|
|
if (this.m_tokenizer.MatchAhead(unitName, (c: number): boolean => !isalnum(c))) {
|
|
this.m_tokenizer.NextChar(unitName.length);
|
|
return unitId;
|
|
}
|
|
|
|
unitId++;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
protected lexDefault(aToken: T_TOKEN): boolean {
|
|
const retval: T_TOKEN = { token: G_TOKEN.G_ENDS, value: { str: null, num: 0.0, idx: -1 } };
|
|
let current = '';
|
|
let convertFrom: number;
|
|
|
|
if (this.m_tokenizer.Done()) {
|
|
aToken.token = retval.token;
|
|
aToken.value = retval.value;
|
|
return true;
|
|
}
|
|
|
|
const isDecimalSeparator = (ch: number): boolean =>
|
|
ch === this.m_localeDecimalSeparator.charCodeAt(0) || ch === 0x2e || ch === 0x2c;
|
|
|
|
// Lambda: get value as string, store into clToken.token and update current index.
|
|
const extractNumber = (): void => {
|
|
let haveSeparator = false;
|
|
let ch = this.m_tokenizer.GetChar();
|
|
|
|
do {
|
|
if (isDecimalSeparator(ch) && haveSeparator) break;
|
|
|
|
current += String.fromCharCode(ch);
|
|
|
|
if (isDecimalSeparator(ch)) haveSeparator = true;
|
|
|
|
this.m_tokenizer.NextChar();
|
|
ch = this.m_tokenizer.GetChar();
|
|
} while (isdigit(ch) || isDecimalSeparator(ch));
|
|
|
|
// Ensure that the systems decimal separator is used
|
|
let fixed = '';
|
|
|
|
for (let i = 0; i < current.length; i++) {
|
|
fixed += isDecimalSeparator(current.charCodeAt(i))
|
|
? this.m_localeDecimalSeparator
|
|
: current[i];
|
|
}
|
|
|
|
current = fixed;
|
|
};
|
|
|
|
let ch: number;
|
|
|
|
// Start processing of first/next token: Remove whitespace
|
|
for (;;) {
|
|
ch = this.m_tokenizer.GetChar();
|
|
|
|
if (ch === 0x20) this.m_tokenizer.NextChar();
|
|
else break;
|
|
}
|
|
|
|
if (ch === 0) {
|
|
/* End of input */
|
|
} else if (isdigit(ch)) {
|
|
// VALUE
|
|
extractNumber();
|
|
retval.token = G_TOKEN.G_VALUE;
|
|
retval.value.str = current;
|
|
} else if (
|
|
// biome-ignore lint/suspicious/noAssignInExpressions: the C++'s `( convertFrom = resolveUnits() ) >= 0`
|
|
(convertFrom = this.resolveUnits()) >= 0
|
|
) {
|
|
// UNIT
|
|
// Units are appended to a VALUE.
|
|
// Determine factor to default unit if unit for value is given.
|
|
// Example: Default is mm, unit is inch: factor is 25.4
|
|
// The factor is assigned to the terminal UNIT. The actual
|
|
// conversion is done within a parser action.
|
|
retval.token = G_TOKEN.G_UNIT;
|
|
retval.value.idx = convertFrom;
|
|
} else if (ch === 0x27) {
|
|
// string literal
|
|
this.m_lexerState = LEXER_STATE.LS_STRING;
|
|
this.m_tokenizer.NextChar();
|
|
return false;
|
|
} else if (isalpha(ch) || ch === 0x5f) {
|
|
current = this.m_tokenizer.GetChars((c: number): boolean => isalnum(c) || c === 0x5f);
|
|
retval.token = G_TOKEN.G_IDENTIFIER;
|
|
retval.value.str = current;
|
|
this.m_tokenizer.NextChar(current.length);
|
|
} else if (this.m_tokenizer.MatchAhead('==', (c: number): boolean => c !== 0x3d)) {
|
|
retval.token = G_TOKEN.G_EQUAL;
|
|
this.m_tokenizer.NextChar(2);
|
|
} else if (this.m_tokenizer.MatchAhead('!=', (c: number): boolean => c !== 0x3d)) {
|
|
retval.token = G_TOKEN.G_NOT_EQUAL;
|
|
this.m_tokenizer.NextChar(2);
|
|
} else if (this.m_tokenizer.MatchAhead('<=', (c: number): boolean => c !== 0x3d)) {
|
|
retval.token = G_TOKEN.G_LESS_EQUAL_THAN;
|
|
this.m_tokenizer.NextChar(2);
|
|
} else if (this.m_tokenizer.MatchAhead('>=', (c: number): boolean => c !== 0x3d)) {
|
|
retval.token = G_TOKEN.G_GREATER_EQUAL_THAN;
|
|
this.m_tokenizer.NextChar(2);
|
|
} else if (this.m_tokenizer.MatchAhead('&&', (c: number): boolean => c !== 0x26)) {
|
|
retval.token = G_TOKEN.G_BOOL_AND;
|
|
this.m_tokenizer.NextChar(2);
|
|
} else if (this.m_tokenizer.MatchAhead('||', (c: number): boolean => c !== 0x7c)) {
|
|
retval.token = G_TOKEN.G_BOOL_OR;
|
|
this.m_tokenizer.NextChar(2);
|
|
} else {
|
|
// Single char tokens
|
|
switch (String.fromCharCode(ch)) {
|
|
case '+':
|
|
retval.token = G_TOKEN.G_PLUS;
|
|
break;
|
|
case '!':
|
|
retval.token = G_TOKEN.G_BOOL_NOT;
|
|
break;
|
|
case '-':
|
|
retval.token = G_TOKEN.G_MINUS;
|
|
break;
|
|
case '*':
|
|
retval.token = G_TOKEN.G_MULT;
|
|
break;
|
|
case '/':
|
|
retval.token = G_TOKEN.G_DIVIDE;
|
|
break;
|
|
case '<':
|
|
retval.token = G_TOKEN.G_LESS_THAN;
|
|
break;
|
|
case '>':
|
|
retval.token = G_TOKEN.G_GREATER_THAN;
|
|
break;
|
|
case '(':
|
|
retval.token = G_TOKEN.G_PARENL;
|
|
break;
|
|
case ')':
|
|
retval.token = G_TOKEN.G_PARENR;
|
|
break;
|
|
case ';':
|
|
retval.token = G_TOKEN.G_SEMCOL;
|
|
break;
|
|
case '.':
|
|
retval.token = G_TOKEN.G_STRUCT_REF;
|
|
break;
|
|
case ',':
|
|
retval.token = G_TOKEN.G_COMMA;
|
|
break;
|
|
default:
|
|
if (this.m_tokenizer.MatchAhead('${', (c: number): boolean => c !== 0x7b))
|
|
this.reportError(
|
|
COMPILATION_STAGE.CST_PARSE,
|
|
'Unresolved text variable reference',
|
|
this.m_sourcePos + 2,
|
|
);
|
|
else
|
|
this.reportError(
|
|
COMPILATION_STAGE.CST_PARSE,
|
|
`Unrecognized character '${String.fromCharCode(ch)}'`,
|
|
);
|
|
|
|
break;
|
|
}
|
|
|
|
this.m_tokenizer.NextChar();
|
|
}
|
|
|
|
aToken.token = retval.token;
|
|
aToken.value = retval.value;
|
|
return true;
|
|
}
|
|
|
|
// ----- the parser: grammar.lemon --------------------------------------------
|
|
|
|
/** The lemon driver loop's read of the next token: `m_sourcePos = GetPos(); tok = getToken()`. */
|
|
private lexNext(): LEXED {
|
|
this.m_sourcePos = this.m_tokenizer.GetPos();
|
|
const tok = this.getToken();
|
|
const lexed = { tok, pos: this.m_sourcePos };
|
|
this.m_tokens.push(lexed);
|
|
|
|
if (this.m_errorStatus.pendingError) throw new SYNTAX_ERROR();
|
|
|
|
return lexed;
|
|
}
|
|
|
|
/** The lookahead token, lexing it if the parser has not looked yet. */
|
|
private peek(): LEXED {
|
|
while (this.m_tokenIndex >= this.m_tokens.length) this.lexNext();
|
|
|
|
const t = this.m_tokens[this.m_tokenIndex]!;
|
|
// the compiler's position is where the lookahead was read: a reduction
|
|
// makes its nodes there
|
|
this.m_sourcePos = t.pos;
|
|
return t;
|
|
}
|
|
|
|
private advance(): LEXED {
|
|
const t = this.peek();
|
|
this.m_tokenIndex++;
|
|
return t;
|
|
}
|
|
|
|
private syntaxError(at: LEXED): never {
|
|
this.m_sourcePos = at.pos;
|
|
this.parseError('Syntax error');
|
|
throw new SYNTAX_ERROR();
|
|
}
|
|
|
|
/**
|
|
* main ::= in. in ::= stmt | in stmt. stmt ::= G_ENDS | nt G_ENDS.
|
|
*
|
|
* G_ENDS is only ever the last token, so the input is one expression, or
|
|
* nothing, before it.
|
|
*/
|
|
private parseInput(): void {
|
|
const first = this.peek();
|
|
|
|
if (first.tok.token !== G_TOKEN.G_ENDS) {
|
|
const root = this.parseExpr(0);
|
|
const end = this.peek();
|
|
|
|
if (end.tok.token !== G_TOKEN.G_ENDS) this.syntaxError(end);
|
|
|
|
this.advance();
|
|
this.setRoot(root);
|
|
} else {
|
|
this.advance();
|
|
}
|
|
|
|
this.parseOk();
|
|
}
|
|
|
|
/** The `nt` rules with a binary operator, by precedence climbing. */
|
|
private parseExpr(aMinPrec: number): TREE_NODE {
|
|
let lhs = this.parsePrefix();
|
|
let lastNonassoc = -1;
|
|
|
|
for (;;) {
|
|
const look = this.peek();
|
|
const bin = BINARY_OPS[look.tok.token as G_TOKEN];
|
|
|
|
if (!bin || bin.prec < aMinPrec) return lhs;
|
|
|
|
// a nonassoc operator following one of the same precedence is a
|
|
// conflict lemon resolves as a syntax error
|
|
if (bin.assoc === ASSOC.NONASSOC && bin.prec === lastNonassoc) this.syntaxError(look);
|
|
|
|
this.advance();
|
|
|
|
const rhs = this.parseExpr(bin.assoc === ASSOC.RIGHT ? bin.prec : bin.prec + 1);
|
|
|
|
// the reduction: the node is made with the lookahead in hand
|
|
this.peek();
|
|
const node = newNode(this, bin.op);
|
|
node.leaf[0] = lhs;
|
|
node.leaf[1] = rhs;
|
|
lhs = node;
|
|
lastNonassoc = bin.assoc === ASSOC.NONASSOC ? bin.prec : -1;
|
|
}
|
|
}
|
|
|
|
/** The prefix and primary `nt` rules. */
|
|
private parsePrefix(): TREE_NODE {
|
|
const t = this.peek();
|
|
|
|
switch (t.tok.token) {
|
|
case G_TOKEN.G_BOOL_NOT: {
|
|
// nt ::= G_BOOL_NOT nt. (%right, above the comparisons)
|
|
this.advance();
|
|
const B = this.parseExpr(PREC_BOOL_NOT);
|
|
this.peek();
|
|
const A = newNode(this, TR_OP_BOOL_NOT);
|
|
A.leaf[0] = B;
|
|
return A;
|
|
}
|
|
|
|
case G_TOKEN.G_PLUS: {
|
|
// nt ::= G_PLUS nt. (the rule has G_PLUS's precedence, %left)
|
|
this.advance();
|
|
const B = this.parseExpr(PREC_ADDITIVE + 1);
|
|
this.peek();
|
|
const A = newNode(this, B.op, B.value);
|
|
A.leaf[0] = B.leaf[0];
|
|
A.leaf[1] = B.leaf[1];
|
|
return A;
|
|
}
|
|
|
|
case G_TOKEN.G_MINUS: {
|
|
// nt ::= G_MINUS nt.
|
|
this.advance();
|
|
const B = this.parseExpr(PREC_ADDITIVE + 1);
|
|
this.peek();
|
|
const A = newNode(this, TR_OP_SUB);
|
|
A.leaf[0] = newNode(this, TOKEN_TYPE_T.TR_NUMBER);
|
|
A.leaf[1] = B;
|
|
return A;
|
|
}
|
|
|
|
case G_TOKEN.G_PARENL: {
|
|
// nt ::= G_PARENL nt G_PARENR.
|
|
this.advance();
|
|
const B = this.parseExpr(0);
|
|
const close = this.peek();
|
|
|
|
if (close.tok.token !== G_TOKEN.G_PARENR) this.syntaxError(close);
|
|
|
|
this.advance();
|
|
this.peek();
|
|
const A = newNode(this, B.op, B.value);
|
|
A.leaf[0] = B.leaf[0];
|
|
A.leaf[1] = B.leaf[1];
|
|
return A;
|
|
}
|
|
|
|
case G_TOKEN.G_VALUE: {
|
|
// nt ::= G_VALUE. nt ::= G_VALUE G_UNIT.
|
|
const B = this.advance();
|
|
const next = this.peek();
|
|
|
|
if (next.tok.token === G_TOKEN.G_UNIT) {
|
|
const C = this.advance();
|
|
this.peek();
|
|
const A = newNode(this, TOKEN_TYPE_T.TR_NUMBER, B.tok.value);
|
|
A.leaf[0] = newNode(this, TOKEN_TYPE_T.TR_UNIT, C.tok.value);
|
|
return A;
|
|
}
|
|
|
|
return newNode(this, TOKEN_TYPE_T.TR_NUMBER, B.tok.value);
|
|
}
|
|
|
|
case G_TOKEN.G_STRING: {
|
|
// nt ::= G_STRING.
|
|
const B = this.advance();
|
|
this.peek();
|
|
return newNode(this, TOKEN_TYPE_T.TR_STRING, B.tok.value);
|
|
}
|
|
|
|
case G_TOKEN.G_IDENTIFIER: {
|
|
// nt ::= G_IDENTIFIER.
|
|
// nt ::= G_IDENTIFIER G_PARENL nt G_PARENR.
|
|
// nt ::= G_IDENTIFIER G_PARENL G_PARENR.
|
|
const F = this.advance();
|
|
const next = this.peek();
|
|
|
|
if (next.tok.token === G_TOKEN.G_PARENL) {
|
|
this.advance();
|
|
const inner = this.peek();
|
|
let B: TREE_NODE;
|
|
|
|
if (inner.tok.token === G_TOKEN.G_PARENR) {
|
|
this.advance();
|
|
this.peek();
|
|
B = newNode(this, TOKEN_TYPE_T.TR_NULL);
|
|
} else {
|
|
B = this.parseExpr(0);
|
|
const close = this.peek();
|
|
|
|
if (close.tok.token !== G_TOKEN.G_PARENR) this.syntaxError(close);
|
|
|
|
this.advance();
|
|
this.peek();
|
|
}
|
|
|
|
const A = newNode(this, TR_OP_FUNC_CALL);
|
|
A.leaf[0] = newNode(this, TOKEN_TYPE_T.TR_IDENTIFIER, F.tok.value);
|
|
A.leaf[1] = B;
|
|
return A;
|
|
}
|
|
|
|
return newNode(this, TOKEN_TYPE_T.TR_IDENTIFIER, F.tok.value);
|
|
}
|
|
|
|
default:
|
|
return this.syntaxError(t);
|
|
}
|
|
}
|
|
|
|
// ----- code generation ------------------------------------------------------
|
|
|
|
protected generateUCode(aCode: UCODE, aPreflightContext: CONTEXT): boolean {
|
|
const stack: TREE_NODE[] = [];
|
|
let msg: string;
|
|
let numericValueCount = 0;
|
|
let missingUnitsMsg = '';
|
|
let missingUnitsSrcPos = 0;
|
|
|
|
if (!this.m_tree) {
|
|
const val = new VALUE(1.0);
|
|
// Empty expression returns true
|
|
aCode.AddOp(new UOP(TR_UOP_PUSH_VALUE, val));
|
|
return true;
|
|
}
|
|
|
|
prepareTree(this.m_tree);
|
|
|
|
stack.push(this.m_tree);
|
|
|
|
while (stack.length > 0) {
|
|
const node = stack[stack.length - 1]!;
|
|
|
|
// process terminal nodes first
|
|
switch (node.op) {
|
|
case TR_OP_FUNC_CALL:
|
|
// Function call's uop was generated inside TR_STRUCT_REF
|
|
if (!node.uop) {
|
|
// This function call is bare so we don't know who to apply it to
|
|
// Set a safe default value to exit gracefully with an error
|
|
this.reportError(
|
|
COMPILATION_STAGE.CST_CODEGEN,
|
|
'Unknown parent of function parameters',
|
|
node.srcPos,
|
|
);
|
|
node.SetUop(TR_UOP_PUSH_VALUE, 0.0, 'unscaled');
|
|
}
|
|
|
|
node.isTerminal = true;
|
|
break;
|
|
|
|
case TOKEN_TYPE_T.TR_STRUCT_REF: {
|
|
// leaf[0]: object
|
|
// leaf[1]: field (TR_IDENTIFIER) or TR_OP_FUNC_CALL
|
|
|
|
if (node.leaf[0]!.op !== TOKEN_TYPE_T.TR_IDENTIFIER) {
|
|
let pos = node.leaf[0]!.srcPos;
|
|
|
|
if (node.leaf[0]!.value.str) pos -= formatNode(node.leaf[0]!).length;
|
|
|
|
this.reportError(COMPILATION_STAGE.CST_CODEGEN, 'Unknown parent of property', pos);
|
|
|
|
node.leaf[0]!.isVisited = true;
|
|
node.leaf[1]!.isVisited = true;
|
|
|
|
node.SetUop(TR_UOP_PUSH_VALUE, 0.0, 'unscaled');
|
|
node.isTerminal = true;
|
|
break;
|
|
}
|
|
|
|
switch (node.leaf[1]!.op) {
|
|
case TOKEN_TYPE_T.TR_IDENTIFIER: {
|
|
// leaf[0]: object
|
|
// leaf[1]: field
|
|
|
|
const itemName = formatNode(node.leaf[0]!);
|
|
const propName = formatNode(node.leaf[1]!);
|
|
const vref = aCode.CreateVarRef(itemName, propName);
|
|
|
|
if (!vref) {
|
|
msg = `Unrecognized item '${itemName}'`;
|
|
this.reportError(
|
|
COMPILATION_STAGE.CST_CODEGEN,
|
|
msg,
|
|
node.leaf[0]!.srcPos - itemName.length,
|
|
);
|
|
} else if (vref.GetType() === VAR_TYPE_T.VT_PARSE_ERROR) {
|
|
msg = `Unrecognized property '${propName}'`;
|
|
this.reportError(
|
|
COMPILATION_STAGE.CST_CODEGEN,
|
|
msg,
|
|
node.leaf[1]!.srcPos - propName.length,
|
|
);
|
|
}
|
|
|
|
node.leaf[0]!.isVisited = true;
|
|
node.leaf[1]!.isVisited = true;
|
|
|
|
node.SetUop(TR_UOP_PUSH_VAR, vref);
|
|
node.isTerminal = true;
|
|
break;
|
|
}
|
|
|
|
case TR_OP_FUNC_CALL: {
|
|
// leaf[0]: object
|
|
// leaf[1]: TR_OP_FUNC_CALL
|
|
// leaf[0]: function name
|
|
// leaf[1]: parameter
|
|
|
|
const itemName = formatNode(node.leaf[0]!);
|
|
const vref = aCode.CreateVarRef(itemName, '');
|
|
|
|
if (!vref) {
|
|
msg = `Unrecognized item '${itemName}'`;
|
|
this.reportError(
|
|
COMPILATION_STAGE.CST_CODEGEN,
|
|
msg,
|
|
node.leaf[0]!.srcPos - itemName.length,
|
|
);
|
|
}
|
|
|
|
const functionName = formatNode(node.leaf[1]!.leaf[0]!);
|
|
const func = aCode.CreateFuncCall(functionName);
|
|
const params = squashParamList(node.leaf[1]!.leaf[1]);
|
|
|
|
if (!func) {
|
|
msg = `Unrecognized function '${functionName}'`;
|
|
this.reportError(COMPILATION_STAGE.CST_CODEGEN, msg, node.leaf[0]!.srcPos + 1);
|
|
}
|
|
|
|
if (func) {
|
|
// Preflight the function call
|
|
for (const pnode of params) {
|
|
const param = aPreflightContext.AllocValue();
|
|
param.Set(formatNode(pnode));
|
|
aPreflightContext.Push(param);
|
|
}
|
|
|
|
aPreflightContext.SetErrorCallback((aMessage: string, _aOffset: number) => {
|
|
const loc = node.leaf[1]!.leaf[1]!.srcPos;
|
|
this.reportError(COMPILATION_STAGE.CST_CODEGEN, aMessage, loc - 1);
|
|
});
|
|
|
|
try {
|
|
func(aPreflightContext, vref);
|
|
aPreflightContext.Pop(); // return value
|
|
} catch {
|
|
// the C++ swallows whatever the preflight throws
|
|
}
|
|
}
|
|
|
|
node.leaf[0]!.isVisited = true;
|
|
node.leaf[1]!.isVisited = true;
|
|
node.leaf[1]!.leaf[0]!.isVisited = true;
|
|
node.leaf[1]!.leaf[1]!.isVisited = true;
|
|
|
|
// Our non-terminal-node stacking algorithm can't handle doubly-nested
|
|
// structures so we need to pop a level by replacing the TR_STRUCT_REF with
|
|
// a TR_OP_FUNC_CALL and its function parameter
|
|
stack.pop();
|
|
stack.push(node.leaf[1]!);
|
|
|
|
for (const pnode of params) stack.push(pnode);
|
|
|
|
node.leaf[1]!.SetUop(TR_OP_METHOD_CALL, func, vref);
|
|
node.isTerminal = false;
|
|
break;
|
|
}
|
|
|
|
default: {
|
|
// leaf[0]: object
|
|
// leaf[1]: malformed syntax
|
|
|
|
const itemName = formatNode(node.leaf[0]!);
|
|
const propName = formatNode(node.leaf[1]!);
|
|
const vref = aCode.CreateVarRef(itemName, propName);
|
|
|
|
if (!vref) {
|
|
msg = `Unrecognized item '${itemName}'`;
|
|
this.reportError(
|
|
COMPILATION_STAGE.CST_CODEGEN,
|
|
msg,
|
|
node.leaf[0]!.srcPos - itemName.length,
|
|
);
|
|
}
|
|
|
|
msg = `Unrecognized property '${propName}'`;
|
|
this.reportError(COMPILATION_STAGE.CST_CODEGEN, msg, node.leaf[0]!.srcPos + 1);
|
|
|
|
node.leaf[0]!.isVisited = true;
|
|
node.leaf[1]!.isVisited = true;
|
|
|
|
node.SetUop(TR_UOP_PUSH_VALUE, 0.0, 'unscaled');
|
|
node.isTerminal = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case TOKEN_TYPE_T.TR_NUMBER: {
|
|
const son = node.leaf[0];
|
|
let value: number;
|
|
let unitsType: EdaUnits = 'unscaled';
|
|
|
|
if (node.value.str === null) {
|
|
value = 0.0;
|
|
} else if (son && son.op === TOKEN_TYPE_T.TR_UNIT) {
|
|
if (this.m_unitResolver.GetSupportedUnits().length === 0) {
|
|
msg = `Unexpected units for '${formatNode(node)}'`;
|
|
this.reportError(COMPILATION_STAGE.CST_CODEGEN, msg, node.srcPos);
|
|
}
|
|
|
|
const units = son.value.idx;
|
|
unitsType = this.m_unitResolver.GetSupportedUnitsTypes()[units]!;
|
|
value = this.m_unitResolver.Convert(formatNode(node), units);
|
|
son.isVisited = true;
|
|
} else {
|
|
if (this.m_unitResolver.GetSupportedUnitsMessage().length > 0) {
|
|
missingUnitsMsg = `Missing units for '${formatNode(node)}'| (${this.m_unitResolver.GetSupportedUnitsMessage()})`;
|
|
missingUnitsSrcPos = node.srcPos;
|
|
}
|
|
|
|
value = DoubleValueFromString(formatNode(node));
|
|
}
|
|
|
|
node.SetUop(TR_UOP_PUSH_VALUE, value, unitsType);
|
|
node.isTerminal = true;
|
|
numericValueCount++;
|
|
break;
|
|
}
|
|
|
|
case TOKEN_TYPE_T.TR_STRING: {
|
|
const str = formatNode(node);
|
|
const isWildcard = str.includes('?') || str.includes('*');
|
|
node.SetUop(TR_UOP_PUSH_VALUE, str, isWildcard);
|
|
node.isTerminal = true;
|
|
break;
|
|
}
|
|
|
|
case TOKEN_TYPE_T.TR_IDENTIFIER: {
|
|
const vref = aCode.CreateVarRef(formatNode(node), '');
|
|
|
|
if (!vref) {
|
|
msg = `Unrecognized item '${formatNode(node)}'`;
|
|
this.reportError(
|
|
COMPILATION_STAGE.CST_CODEGEN,
|
|
msg,
|
|
node.srcPos - formatNode(node).length,
|
|
);
|
|
}
|
|
|
|
node.SetUop(TR_UOP_PUSH_VAR, vref);
|
|
node.isTerminal = true;
|
|
break;
|
|
}
|
|
|
|
default:
|
|
node.SetUop(node.op);
|
|
node.isTerminal =
|
|
(!node.leaf[0] || node.leaf[0].isVisited) && (!node.leaf[1] || node.leaf[1].isVisited);
|
|
break;
|
|
}
|
|
|
|
if (!node.isTerminal) {
|
|
if (node.leaf[0] && !node.leaf[0].isVisited) {
|
|
stack.push(node.leaf[0]);
|
|
node.leaf[0].isVisited = true;
|
|
} else if (node.leaf[1] && !node.leaf[1].isVisited) {
|
|
stack.push(node.leaf[1]);
|
|
node.leaf[1].isVisited = true;
|
|
}
|
|
|
|
continue;
|
|
}
|
|
|
|
node.isVisited = true;
|
|
|
|
if (node.uop) {
|
|
aCode.AddOp(node.uop);
|
|
node.uop = null;
|
|
}
|
|
|
|
stack.pop();
|
|
}
|
|
|
|
// Report the common error condition of a single numeric value with no units (which will result in
|
|
// nanometers, and rarely leads to anything useful).
|
|
// Reporting missing units with multiple numeric values is far more complicated as we have to
|
|
// separate comparison operators from multiplicative operators from additive operators. Consider:
|
|
// 2 * 1.5mm
|
|
// 2mm + 105um
|
|
// 2mm > 20um
|
|
// (2mm + 1.5mm) * 3
|
|
if (missingUnitsMsg.length > 0 && numericValueCount === 1)
|
|
this.reportError(COMPILATION_STAGE.CST_CODEGEN, missingUnitsMsg, missingUnitsSrcPos);
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
export function formatNode(node: TREE_NODE): string {
|
|
return node.value.str !== null ? node.value.str : '';
|
|
}
|
|
|
|
export function dumpNode(buf: { s: string }, tok: TREE_NODE | null, depth = 0): void {
|
|
if (!tok) return;
|
|
|
|
buf.s += `\n[node L0:${tok.leaf[0] ? 'x' : '-'} L1:${tok.leaf[1] ? 'x' : '-'}] `;
|
|
|
|
for (let i = 0; i < 2 * depth; i++) buf.s += ' ';
|
|
|
|
if (tok.op & TR_OP_BINARY_MASK) {
|
|
buf.s += formatOpName(tok.op);
|
|
dumpNode(buf, tok.leaf[0], depth + 1);
|
|
dumpNode(buf, tok.leaf[1], depth + 1);
|
|
}
|
|
|
|
switch (tok.op) {
|
|
case TOKEN_TYPE_T.TR_NUMBER:
|
|
buf.s += 'NUMERIC: ';
|
|
buf.s += formatNode(tok);
|
|
|
|
if (tok.leaf[0]) dumpNode(buf, tok.leaf[0], depth + 1);
|
|
|
|
break;
|
|
|
|
case TOKEN_TYPE_T.TR_ARG_LIST:
|
|
buf.s += 'ARG_LIST: ';
|
|
buf.s += formatNode(tok);
|
|
|
|
if (tok.leaf[0]) dumpNode(buf, tok.leaf[0], depth + 1);
|
|
if (tok.leaf[1]) dumpNode(buf, tok.leaf[1], depth + 1);
|
|
|
|
break;
|
|
|
|
case TOKEN_TYPE_T.TR_STRING:
|
|
buf.s += 'STRING: ';
|
|
buf.s += formatNode(tok);
|
|
break;
|
|
|
|
case TOKEN_TYPE_T.TR_IDENTIFIER:
|
|
buf.s += 'ID: ';
|
|
buf.s += formatNode(tok);
|
|
break;
|
|
|
|
case TOKEN_TYPE_T.TR_STRUCT_REF:
|
|
buf.s += 'SREF: ';
|
|
dumpNode(buf, tok.leaf[0], depth + 1);
|
|
dumpNode(buf, tok.leaf[1], depth + 1);
|
|
break;
|
|
|
|
case TR_OP_FUNC_CALL:
|
|
buf.s += "CALL '";
|
|
buf.s += formatNode(tok.leaf[0]!);
|
|
buf.s += "': ";
|
|
dumpNode(buf, tok.leaf[1], depth + 1);
|
|
break;
|
|
|
|
case TOKEN_TYPE_T.TR_UNIT:
|
|
buf.s += `UNIT: ${tok.value.idx} `;
|
|
break;
|
|
}
|
|
}
|
|
|
|
function prepareTree(node: TREE_NODE): void {
|
|
node.isVisited = false;
|
|
|
|
// fixme: for reasons I don't understand the lemon parser isn't initializing the
|
|
// leaf node pointers of function name nodes. -JY
|
|
if (node.op === TR_OP_FUNC_CALL && node.leaf[0]) {
|
|
node.leaf[0].leaf[0] = null;
|
|
node.leaf[0].leaf[1] = null;
|
|
}
|
|
|
|
if (node.leaf[0]) prepareTree(node.leaf[0]);
|
|
if (node.leaf[1]) prepareTree(node.leaf[1]);
|
|
}
|
|
|
|
function squashParamList(root: TREE_NODE | null): TREE_NODE[] {
|
|
const args: TREE_NODE[] = [];
|
|
|
|
if (!root) return args;
|
|
|
|
if (root.op !== TOKEN_TYPE_T.TR_ARG_LIST && root.op !== TOKEN_TYPE_T.TR_NULL) {
|
|
args.push(root);
|
|
} else {
|
|
let n: TREE_NODE | null = root;
|
|
|
|
do {
|
|
if (n.leaf[1]) args.push(n.leaf[1]);
|
|
|
|
n = n.leaf[0];
|
|
} while (n && n.op === TOKEN_TYPE_T.TR_ARG_LIST);
|
|
|
|
if (n) args.push(n);
|
|
}
|
|
|
|
args.reverse();
|
|
|
|
return args;
|
|
}
|