circuitscript 0.0.25 → 0.0.27

package/dist/esm/helpers.mjs

@@ -1,5 +1,5 @@
 import { readFileSync, writeFileSync } from "fs";
-import { generateKiCADNetList } from "./export.mjs";
+import { generateKiCADNetList, printTree } from "./export.mjs";
 import { LayoutEngine } from "./layout.mjs";
 import { SequenceAction } from "./objects/ExecutionScope.mjs";
 import { parseFileWithVisitor } from "./parser.mjs";
@@ -177,8 +177,11 @@ export function renderScript(scriptData, outputPath, options) {
         console.log('Error during annotation: ', err);
     }
     if (kicadNetlistPath) {
-        const kicadNetList = generateKiCADNetList(visitor.getNetList());
-        writeFileSync(kicadNetlistPath, kicadNetList);
+        const { tree: kicadNetList, missingFootprints } = generateKiCADNetList(visitor.getNetList());
+        missingFootprints.forEach(entry => {
+            console.log(`${entry.refdes} (${entry.instanceName}) does not have footprint`);
+        });
+        writeFileSync(kicadNetlistPath, printTree(kicadNetList));
         console.log('Generated KiCad netlist file');
     }
     const { sequence, nets } = visitor.getGraph();
@@ -212,6 +215,7 @@ export function renderScript(scriptData, outputPath, options) {
         showStats && console.log('Render took:', generateSvgTimer.lap());
         if (outputPath) {
             writeFileSync(outputPath, svgOutput);
+            console.log('Generated file', outputPath);
         }
     }
     catch (err) {

package/dist/esm/layout.mjs

@@ -7,6 +7,7 @@ import { Geometry } from './geometry.mjs';
 import { Logger } from './logger.mjs';
 import { Frame, FrameParamKeys, FramePlotDirection } from './objects/Frame.mjs';
 import { getBoundsSize, printBounds, resizeBounds, resizeToNearestGrid, toNearestGrid } from './utils.mjs';
+import { Direction } from './objects/types.mjs';
 export class LayoutEngine {
     logger;
     placeSubgraphVersion = 2;
@@ -935,16 +936,16 @@ function applyComponentParamsToSymbol(typeProp, component, symbol) {
 function calculateSymbolAngle(symbol, pin, direction) {
     let directionVector = 0;
     switch (direction) {
-        case 'right':
+        case Direction.Right:
             directionVector = 0;
             break;
-        case 'down':
+        case Direction.Down:
             directionVector = 90;
             break;
-        case 'left':
+        case Direction.Left:
             directionVector = 180;
             break;
-        case 'up':
+        case Direction.Up:
             directionVector = 270;
             break;
     }
@@ -1012,16 +1013,16 @@ export class RenderWire extends RenderObject {
         this.segments.forEach(segment => {
             const { direction, value } = segment;
             let didAddPoint = false;
-            if (direction === 'down') {
+            if (direction === Direction.Down) {
                 tmpY += value;
             }
-            else if (direction === 'up') {
+            else if (direction === Direction.Up) {
                 tmpY -= value;
             }
-            else if (direction === 'left') {
+            else if (direction === Direction.Left) {
                 tmpX -= value;
             }
-            else if (direction === 'right') {
+            else if (direction === Direction.Right) {
                 tmpX += value;
             }
             else if (direction === 'auto' || direction === "auto_") {
@@ -1090,16 +1091,16 @@ export class RenderWire extends RenderObject {
         let tmpY = this.y;
         excludeLastSegment.forEach(segment => {
             const { direction, value } = segment;
-            if (direction === 'down') {
+            if (direction === Direction.Down) {
                 tmpY += value;
             }
-            else if (direction === 'up') {
+            else if (direction === Direction.Up) {
                 tmpY -= value;
             }
-            else if (direction === 'left') {
+            else if (direction === Direction.Left) {
                 tmpX -= value;
             }
-            else if (direction === 'right') {
+            else if (direction === Direction.Right) {
                 tmpX += value;
             }
         });
@@ -1107,16 +1108,16 @@ export class RenderWire extends RenderObject {
         let valueXY = null;
         const lastSegment = this.segments[this.segments.length - 1];
         switch (lastSegment.direction) {
-            case 'left':
+            case Direction.Left:
                 useValue = tmpX - untilX;
                 break;
-            case 'right':
+            case Direction.Right:
                 useValue = untilX - tmpX;
                 break;
-            case 'up':
+            case Direction.Up:
                 useValue = untilY - tmpY;
                 break;
-            case 'down':
+            case Direction.Down:
                 useValue = tmpY - untilY;
                 break;
             case 'auto':
@@ -1224,6 +1225,24 @@ export class RenderJunction {
         this.y = y;
     }
 }
+export function CalculatePinPositions(component) {
+    const pinPositionMapping = new Map();
+    let tmpSymbol;
+    if (component.displayProp !== null
+        && component.displayProp instanceof SymbolDrawing) {
+        tmpSymbol = new SymbolPlaceholder(component.displayProp);
+    }
+    else {
+        const symbolPinDefinitions = generateLayoutPinDefinition(component);
+        tmpSymbol = new SymbolCustom(symbolPinDefinitions);
+    }
+    tmpSymbol.refreshDrawing();
+    const pins = component.pins;
+    pins.forEach((value, key) => {
+        pinPositionMapping.set(key, tmpSymbol.pinPosition(key));
+    });
+    return pinPositionMapping;
+}
 function isPointOverlap(x, y, other) {
     return (x >= other.x && y >= other.y && x <= (other.x + other.width) && y <= (other.y + other.height));
 }

package/dist/esm/main.mjs

@@ -12,9 +12,9 @@ export default async function main() {
     program
         .description('generate graphical output from circuitscript files')
         .version(version)
+        .argument('[input path]', 'Input path')
+        .argument('[output path]', 'Output path')
         .option('-i, --input text <input text>', 'Input text directly')
-        .option('-f, --input-file <path>', 'Input file')
-        .option('-o, --output <path>', 'Output path')
         .option('-c, --current-directory <path>', 'Set current directory')
         .option('-k, --kicad-netlist <filename>', 'Create KiCad netlist')
         .option('-w, --watch', 'Watch for file changes')
@@ -29,8 +29,8 @@ export default async function main() {
     }
     program.parse();
     const options = program.opts();
+    const args = program.args;
     const watchFileChanges = options.watch;
-    const outputPath = options.output ?? null;
     const dumpNets = options.dumpNets;
     const dumpData = options.dumpData;
     const kicadNetlist = options.kicadNetlist;
@@ -39,18 +39,26 @@ export default async function main() {
         console.log('watching for file changes...');
     }
     await prepareSVGEnvironment(fontsPath);
-    let inputFilePath = null;
-    let scriptData;
-    if (options.input) {
-        scriptData = options.input;
+    let inputFilePath = "";
+    if (args.length > 2) {
+        console.log("Error: Extra arguments passed");
+        return;
     }
-    else {
-        inputFilePath = options.inputFile;
+    let scriptData;
+    if (args.length > 0 && args[0]) {
+        inputFilePath = args[0];
         scriptData = readFileSync(inputFilePath, { encoding: 'utf-8' });
         if (currentDirectory === null) {
             currentDirectory = path.dirname(inputFilePath);
         }
     }
+    else if (options.input) {
+        scriptData = options.input;
+    }
+    else {
+        console.log("Error: No input provided");
+        return;
+    }
     const scriptOptions = {
         currentDirectory,
         defaultLibsPath,
@@ -59,6 +67,10 @@ export default async function main() {
         kicadNetlistPath: kicadNetlist,
         showStats: options.stats,
     };
+    let outputPath = null;
+    if (args.length > 0 && args[1]) {
+        outputPath = args[1];
+    }
     const output = renderScript(scriptData, outputPath, scriptOptions);
     if (outputPath === null && output) {
         console.log(output);

package/dist/esm/objects/ClassComponent.mjs

@@ -17,6 +17,11 @@ export class ClassComponent {
     displayProp = null;
     widthProp = null;
     typeProp = null;
+    copyProp = false;
+    angleProp = 0;
+    followWireOrientationProp = true;
+    wireOrientationAngle = 0;
+    useWireOrientationAngle = true;
     styles = {};
     assignedRefDes = null;
     constructor(instanceName, numPins, className) {
@@ -119,6 +124,9 @@ export class ClassComponent {
         component.arrangeProps = this.arrangeProps;
         component.widthProp = this.widthProp;
         component.typeProp = this.typeProp;
+        component.angleProp = this.angleProp;
+        component.followWireOrientationProp = this.followWireOrientationProp;
+        component.useWireOrientationAngle = this.useWireOrientationAngle;
         if (this.displayProp) {
             if (typeof this.displayProp === "string") {
                 component.displayProp = this.displayProp;

package/dist/esm/objects/types.mjs

@@ -10,3 +10,10 @@ export var ParseSymbolType;
     ParseSymbolType["Function"] = "function";
     ParseSymbolType["Undefined"] = "undefined";
 })(ParseSymbolType || (ParseSymbolType = {}));
+export var Direction;
+(function (Direction) {
+    Direction["Left"] = "left";
+    Direction["Right"] = "right";
+    Direction["Down"] = "down";
+    Direction["Up"] = "up";
+})(Direction || (Direction = {}));

package/dist/esm/render.mjs

@@ -1,7 +1,7 @@
 import { SVG, registerWindow } from '@svgdotjs/svg.js';
 import { RenderFrameType, getBounds } from "./layout.mjs";
 import { applyFontsToSVG, getCreateSVGWindow } from './sizing.mjs';
-import { ParamKeys, bodyColor, junctionColor, junctionSize, wireColor } from './globals.mjs';
+import { ComponentTypes, ParamKeys, bodyColor, junctionColor, junctionSize, wireColor } from './globals.mjs';
 import { NumericValue } from './objects/ParamDefinition.mjs';
 import { getBoundsSize } from './utils.mjs';
 export function generateSVG2(graph) {
@@ -36,7 +36,7 @@ function generateSVGChild(canvas, components, wires, junctions, mergedWires, fra
         const { symbol = null } = item;
         if (symbol !== null && symbol) {
             const extra = {};
-            if (item.component.parameters.has('__is_net')) {
+            if (item.component.typeProp === ComponentTypes.net) {
                 extra.net_name = item.component.parameters.get(ParamKeys.net_name);
             }
             else if (item.component.parameters.has('value')) {

package/dist/esm/visitor.mjs

@@ -1,11 +1,10 @@
-import { isNetOnlyComponent } from './execute.mjs';
 import { ClassComponent } from './objects/ClassComponent.mjs';
 import { NumericValue, ParamDefinition, } from './objects/ParamDefinition.mjs';
 import { PinDefinition, PinIdType } from './objects/PinDefinition.mjs';
 import { PinTypes } from './objects/PinTypes.mjs';
 import { UndeclaredReference } from './objects/types.mjs';
-import { BlockTypes, ComponentTypes, NoNetText } from './globals.mjs';
-import { SymbolDrawingCommands } from './draw_symbols.mjs';
+import { BlockTypes, ComponentTypes, NoNetText, ReferenceTypes } from './globals.mjs';
+import { PlaceHolderCommands, SymbolDrawingCommands } from './draw_symbols.mjs';
 import { BaseVisitor } from './BaseVisitor.mjs';
 export class ParserVisitor extends BaseVisitor {
     visitKeyword_assignment_expr = (ctx) => {
@@ -29,10 +28,9 @@ export class ParserVisitor extends BaseVisitor {
     };
     visitAdd_component_expr = (ctx) => {
         const ctxDataWithAssignmentExpr = ctx.data_expr_with_assignment();
-        this.setParam(ctxDataWithAssignmentExpr, { clone: false });
         this.visit(ctxDataWithAssignmentExpr);
         const [component, pinValue] = this.getResult(ctxDataWithAssignmentExpr);
-        return this.getExecutor().addComponentExisting(component, pinValue);
+        this.getExecutor().addComponentExisting(component, pinValue);
     };
     visitAt_component_expr = (ctx) => {
         if (ctx.Point()) {
@@ -135,18 +133,22 @@ export class ParserVisitor extends BaseVisitor {
             properties.get('display') : null;
         const type = properties.has('type') ?
             properties.get('type') : null;
+        const copy = properties.has('copy') ?
+            properties.get('copy') : false;
         const width = properties.has('width') ?
             properties.get('width') : null;
+        const angle = properties.has('angle') ?
+            properties.get('angle') : null;
+        const followWireOrientation = properties.has('followWireOrientation') ?
+            properties.get('followWireOrientation') : true;
         const props = {
-            arrange,
-            display,
-            type,
-            width,
+            arrange, display, type, width, copy,
+            angle, followWireOrientation
         };
         this.setResult(ctx, this.getExecutor().createComponent(instanceName, pins, params, props));
     };
     visitCreate_graphic_expr = (ctx) => {
-        const commands = ctx.sub_expr().reduce((accum, item) => {
+        const commands = ctx.graphic_expr().reduce((accum, item) => {
             this.visit(item);
             const [commandName, parameters] = this.getResult(item);
             const keywordParams = new Map();
@@ -166,7 +168,7 @@ export class ParserVisitor extends BaseVisitor {
         drawing.source = ctx.getText();
         this.setResult(ctx, drawing);
     };
-    visitSub_expr = (ctx) => {
+    visitGraphic_expr = (ctx) => {
         let commandName = null;
         const command = ctx._command;
         if (command) {
@@ -175,9 +177,20 @@ export class ParserVisitor extends BaseVisitor {
         else {
             throw "Invalid command!";
         }
-        const ctxParameters = ctx.parameters();
-        this.visit(ctxParameters);
-        const parameters = this.getResult(ctxParameters);
+        let parameters = [];
+        const ctxNestedProperties = ctx.nested_properties_inner();
+        if (ctxNestedProperties) {
+            this.visit(ctxNestedProperties);
+            const nestedKeyValues = this.getResult(ctxNestedProperties);
+            nestedKeyValues.forEach((value, key) => {
+                parameters.push(['keyword', key, value]);
+            });
+        }
+        else {
+            const ctxParameters = ctx.parameters();
+            this.visit(ctxParameters);
+            parameters = this.getResult(ctxParameters);
+        }
         this.setResult(ctx, [commandName, parameters]);
     };
     visitProperty_expr = (ctx) => {
@@ -206,7 +219,7 @@ export class ParserVisitor extends BaseVisitor {
         }
         this.setResult(ctx, value);
     };
-    visitNested_properties = (ctx) => {
+    visitNested_properties_inner = (ctx) => {
         const result = new Map();
         ctx.property_expr().forEach((item) => {
             this.visit(item);
@@ -217,6 +230,11 @@ export class ParserVisitor extends BaseVisitor {
         });
         this.setResult(ctx, result);
     };
+    visitNested_properties = (ctx) => {
+        const ctxNested = ctx.nested_properties_inner();
+        this.visit(ctxNested);
+        this.setResult(ctx, this.getResult(ctxNested));
+    };
     visitProperty_key_expr = (ctx) => {
         const ctxID = ctx.ID();
         const ctxIntegerValue = ctx.INTEGER_VALUE();
@@ -248,14 +266,9 @@ export class ParserVisitor extends BaseVisitor {
             this.visit(ctxAssignmentExpr);
             component = this.getResult(ctxAssignmentExpr);
         }
-        let allowClone = true;
-        if (this.hasParam(ctx)) {
-            const { clone } = this.getParam(ctx);
-            allowClone = clone;
-        }
-        if (allowClone && component instanceof ClassComponent
-            && isNetOnlyComponent(component)) {
-            component = this.getExecutor().cloneComponent(component);
+        if (component instanceof ClassComponent
+            && component.copyProp) {
+            component = this.getExecutor().copyComponent(component);
         }
         if (component && component instanceof ClassComponent) {
             const modifiers = ctx.component_modifier_expr();
@@ -271,18 +284,40 @@ export class ParserVisitor extends BaseVisitor {
                 else if (ctxID2) {
                     result = ctxID2.getText();
                 }
+                let shouldIgnoreWireOrientation = false;
                 if (modifierText === 'flip') {
                     const flipValue = result;
                     if (flipValue.indexOf('x') !== -1) {
                         component.setParam('flipX', 1);
+                        shouldIgnoreWireOrientation = true;
                     }
                     if (flipValue.indexOf('y') !== -1) {
                         component.setParam('flipY', 1);
+                        shouldIgnoreWireOrientation = true;
                     }
                 }
                 else if (modifierText === 'angle') {
                     const angleValue = Number(result);
                     component.setParam('angle', angleValue);
+                    shouldIgnoreWireOrientation = true;
+                }
+                else if (modifierText === 'anchor') {
+                    if (component.displayProp
+                        && component.displayProp instanceof SymbolDrawingCommands) {
+                        const commands = (component.displayProp)
+                            .getCommands();
+                        commands.forEach(command => {
+                            const positionParams = command[1];
+                            const keywordParams = command[2];
+                            if (command[0] === PlaceHolderCommands.label
+                                && positionParams[0] === 'value') {
+                                keywordParams.set('anchor', result);
+                            }
+                        });
+                    }
+                }
+                if (shouldIgnoreWireOrientation) {
+                    component.useWireOrientationAngle = false;
                 }
             });
         }
@@ -353,6 +388,41 @@ export class ParserVisitor extends BaseVisitor {
         else if (binaryOperatorType.NotEquals()) {
             result = value1 != value2;
         }
+        else if (binaryOperatorType.GreaterThan()) {
+            result = value1 > value2;
+        }
+        else if (binaryOperatorType.GreatOrEqualThan()) {
+            result = value1 >= value2;
+        }
+        else if (binaryOperatorType.LessThan()) {
+            result = value1 < value2;
+        }
+        else if (binaryOperatorType.LessOrEqualThan()) {
+            result = value1 <= value2;
+        }
+        this.setResult(ctx, result);
+    };
+    visitLogicalOperatorExpr = (ctx) => {
+        const ctx0 = ctx.data_expr(0);
+        const ctx1 = ctx.data_expr(1);
+        this.visit(ctx0);
+        const value1 = this.getResult(ctx0);
+        let value2 = false;
+        let skipNext = false;
+        if (ctx.LogicalOr() && value1) {
+            skipNext = true;
+        }
+        if (!skipNext) {
+            this.visit(ctx1);
+            value2 = this.getResult(ctx1);
+        }
+        let result = null;
+        if (ctx.LogicalAnd()) {
+            result = value1 && value2;
+        }
+        else if (ctx.LogicalOr()) {
+            result = value1 || value2;
+        }
         this.setResult(ctx, result);
     };
     visitMultiplyExpr = (ctx) => {
@@ -555,6 +625,42 @@ export class ParserVisitor extends BaseVisitor {
         }
         this.setResult(ctx, (hasPlus ? "+" : "") + netNamespace);
     };
+    visitIf_expr = (ctx) => {
+        const ctxDataExpr = ctx.data_expr();
+        this.visit(ctxDataExpr);
+        const result = this.getResult(ctxDataExpr);
+        if (result) {
+            this.runExpressions(this.getExecutor(), ctx.expression());
+        }
+        else {
+            const ctxInnerIfExprs = ctx.if_inner_expr();
+            let innerIfWasTrue = false;
+            for (let i = 0; i < ctxInnerIfExprs.length; i++) {
+                const tmpCtx = ctxInnerIfExprs[i];
+                this.visit(tmpCtx);
+                const innerResult = this.getResult(tmpCtx);
+                if (innerResult) {
+                    innerIfWasTrue = true;
+                    break;
+                }
+            }
+            if (!innerIfWasTrue) {
+                const elseCtx = ctx.else_expr();
+                if (elseCtx) {
+                    this.visit(elseCtx);
+                }
+            }
+        }
+    };
+    visitIf_inner_expr = (ctx) => {
+        const ctxDataExpr = ctx.data_expr();
+        this.visit(ctxDataExpr);
+        const result = this.getResult(ctxDataExpr);
+        if (result) {
+            this.runExpressions(this.getExecutor(), ctx.expression());
+        }
+        this.setResult(ctx, result);
+    };
     pinTypes = [
         PinTypes.Any,
         PinTypes.IO,
@@ -582,8 +688,10 @@ export class ParserVisitor extends BaseVisitor {
                 }
                 if (Array.isArray(pinDef)) {
                     const firstValue = pinDef[0];
-                    if (this.pinTypes.indexOf(firstValue) !== -1) {
-                        pinType = firstValue;
+                    if (firstValue.type
+                        && firstValue.type === ReferenceTypes.pinType
+                        && this.pinTypes.indexOf(firstValue.value) !== -1) {
+                        pinType = firstValue.value;
                         pinName = pinDef[1];
                         if (pinDef.length > 2) {
                             altPinNames = pinDef.slice(2);

package/dist/types/BaseVisitor.d.ts

@@ -4,7 +4,7 @@ import { ExecutionContext } from "./execute";
 import { Logger } from "./logger";
 import { ClassComponent } from "./objects/ClassComponent";
 import { Net } from "./objects/Net";
-import { CallableParameter, CFunctionOptions, ComplexType, FunctionDefinedParameter, ReferenceType } from "./objects/types";
+import { CallableParameter, CFunctionOptions, ComplexType, Direction, FunctionDefinedParameter, ReferenceType } from "./objects/types";
 import { ParserRuleContext } from 'antlr4ng';
 export declare class BaseVisitor extends CircuitScriptVisitor<ComplexType | ReferenceType | any> {
     indentLevel: number;
@@ -16,7 +16,7 @@ export declare class BaseVisitor extends CircuitScriptVisitor<ComplexType | Refe
     defaultLibsPath: string;
     printStream: string[];
     printToConsole: boolean;
-    acceptedDirections: string[];
+    acceptedDirections: Direction[];
     acceptedFlip: string[];
     protected resultData: Map<ParserRuleContext, any>;
     protected paramData: Map<ParserRuleContext, any>;
@@ -50,9 +50,6 @@ export declare class BaseVisitor extends CircuitScriptVisitor<ComplexType | Refe
     visitBreak_keyword: (ctx: Break_keywordContext) => void;
     protected setResult(ctx: ParserRuleContext, value: any): void;
     protected getResult(ctx: ParserRuleContext): any;
-    protected setParam(ctx: ParserRuleContext, value: any): void;
-    protected getParam(ctx: ParserRuleContext): any;
-    protected hasParam(ctx: ParserRuleContext): boolean;
     protected handleImportFile(name: string, throwErrors?: boolean): {
         hasError: boolean;
         hasParseError: boolean;

package/dist/types/SemanticTokenVisitor.d.ts

@@ -1,6 +1,6 @@
 import { TerminalNode, Token } from "antlr4ng";
 import { CircuitScriptLexer } from "./antlr/CircuitScriptLexer";
-import { Function_def_exprContext, Create_component_exprContext, Create_graphic_exprContext, Atom_exprContext, Property_key_exprContext, Sub_exprContext, ValueAtomExprContext, Assignment_exprContext, Import_exprContext, Function_args_exprContext, Function_call_exprContext } from "./antlr/CircuitScriptParser";
+import { Function_def_exprContext, Create_component_exprContext, Create_graphic_exprContext, Atom_exprContext, Property_key_exprContext, ValueAtomExprContext, Assignment_exprContext, Import_exprContext, Function_args_exprContext, Function_call_exprContext, Graphic_exprContext } from "./antlr/CircuitScriptParser";
 import { BaseVisitor, OnErrorCallback } from "./BaseVisitor";
 export declare class SemanticTokensVisitor extends BaseVisitor {
     parsedTokens: IParsedToken[];
@@ -14,7 +14,7 @@ export declare class SemanticTokensVisitor extends BaseVisitor {
     visitCreate_component_expr: (ctx: Create_component_exprContext) => void;
     visitCreate_graphic_expr: (ctx: Create_graphic_exprContext) => void;
     visitProperty_key_expr: (ctx: Property_key_exprContext) => void;
-    visitSub_expr: (ctx: Sub_exprContext) => void;
+    visitGraphic_expr: (ctx: Graphic_exprContext) => void;
     visitValueAtomExpr: (ctx: ValueAtomExprContext) => void;
     visitAssignment_expr: (ctx: Assignment_exprContext) => void;
     visitAtom_expr: (ctx: Atom_exprContext) => void;

package/dist/types/antlr/CircuitScriptLexer.d.ts

@@ -24,28 +24,35 @@ export declare class CircuitScriptLexer extends antlr.Lexer {
     static readonly Define = 22;
     static readonly Import = 23;
     static readonly If = 24;
-    static readonly Not = 25;
-    static readonly Frame = 26;
-    static readonly Equals = 27;
-    static readonly NotEquals = 28;
-    static readonly Addition = 29;
-    static readonly Minus = 30;
-    static readonly Divide = 31;
-    static readonly Multiply = 32;
-    static readonly OPEN_PAREN = 33;
-    static readonly CLOSE_PAREN = 34;
-    static readonly NOT_CONNECTED = 35;
-    static readonly BOOLEAN_VALUE = 36;
-    static readonly ID = 37;
-    static readonly INTEGER_VALUE = 38;
-    static readonly DECIMAL_VALUE = 39;
-    static readonly NUMERIC_VALUE = 40;
-    static readonly STRING_VALUE = 41;
-    static readonly PERCENTAGE_VALUE = 42;
-    static readonly ALPHA_NUMERIC = 43;
-    static readonly WS = 44;
-    static readonly NEWLINE = 45;
-    static readonly COMMENT = 46;
+    static readonly Else = 25;
+    static readonly Not = 26;
+    static readonly Frame = 27;
+    static readonly Equals = 28;
+    static readonly NotEquals = 29;
+    static readonly GreaterThan = 30;
+    static readonly GreatOrEqualThan = 31;
+    static readonly LessThan = 32;
+    static readonly LessOrEqualThan = 33;
+    static readonly LogicalAnd = 34;
+    static readonly LogicalOr = 35;
+    static readonly Addition = 36;
+    static readonly Minus = 37;
+    static readonly Divide = 38;
+    static readonly Multiply = 39;
+    static readonly OPEN_PAREN = 40;
+    static readonly CLOSE_PAREN = 41;
+    static readonly NOT_CONNECTED = 42;
+    static readonly BOOLEAN_VALUE = 43;
+    static readonly ID = 44;
+    static readonly INTEGER_VALUE = 45;
+    static readonly DECIMAL_VALUE = 46;
+    static readonly NUMERIC_VALUE = 47;
+    static readonly STRING_VALUE = 48;
+    static readonly PERCENTAGE_VALUE = 49;
+    static readonly ALPHA_NUMERIC = 50;
+    static readonly WS = 51;
+    static readonly NEWLINE = 52;
+    static readonly COMMENT = 53;
     static readonly channelNames: string[];
     static readonly literalNames: (string | null)[];
     static readonly symbolicNames: (string | null)[];