circuitscript 0.1.5 → 0.1.7

package/dist/types/helpers.d.ts

@@ -1,20 +1,22 @@
-import { SymbolValidatorVisitor } from "./SymbolValidatorVisitor.js";
+import { BaseError } from "./utils.js";
+import { SymbolValidatorVisitor } from "./validate/SymbolValidatorVisitor.js";
 import { CommonTokenStream, DefaultErrorStrategy, Parser } from "antlr4ng";
 import { CircuitScriptParser } from "./antlr/CircuitScriptParser.js";
 import { CircuitScriptLexer } from "./antlr/CircuitScriptLexer.js";
 import { IParsedToken, SemanticTokensVisitor } from "./SemanticTokenVisitor.js";
 import { LengthUnit } from "./globals.js";
+export type SVGWindow = any;
 import { NumericValue } from "./objects/ParamDefinition.js";
+import { NodeScriptEnvironment } from "./environment.js";
 export declare enum JSModuleType {
     CommonJs = "cjs",
     ESM = "mjs"
 }
 export type ScriptOptions = {
-    currentDirectory: string | null;
-    defaultLibsPath: string;
     dumpNets: boolean;
     dumpData: boolean;
     showStats: boolean;
+    environment: NodeScriptEnvironment;
 };
 export declare function prepareFile(textData: string): {
     parser: CircuitScriptParser;
@@ -22,23 +24,19 @@ export declare function prepareFile(textData: string): {
     lexerTimeTaken: number;
     tokens: CommonTokenStream;
 };
-export declare function getScriptText(filePath: string): string | null;
-export declare function getSemanticTokens(scriptData: string, options: ScriptOptions): {
+export declare function getSemanticTokens(scriptData: string, options: ScriptOptions): Promise<{
     visitor: SemanticTokensVisitor;
     parsedTokens: IParsedToken[];
-};
+}>;
 export declare class ParseErrorStrategy extends DefaultErrorStrategy {
     reportUnwantedToken(recognizer: Parser): void;
 }
-export declare function validateScript(scriptData: string, options: ScriptOptions): SymbolValidatorVisitor;
-export declare function renderScript(scriptData: string, outputPath: string, options: ScriptOptions): string | null;
+export declare function validateScript(filePath: string, scriptData: string, options: ScriptOptions): Promise<SymbolValidatorVisitor>;
+export declare function renderScript(scriptData: string, outputPath: string | null, options: ScriptOptions): Promise<{
+    svgOutput: string | null;
+    errors: BaseError[];
+}>;
 export declare function detectJSModuleType(): JSModuleType;
-export declare function getCurrentPath(): {
-    filePath: string;
-};
-export declare function getFontsPath(): string;
-export declare function getDefaultLibsPath(): string;
-export declare function getPackageVersion(): string;
 export declare class UnitDimension {
     type: LengthUnit;
     value: number;

package/dist/types/index.d.ts

@@ -13,3 +13,8 @@ export * from './utils.js';
 export * from './visitor.js';
 export * from './sizing.js';
 export * from './objects/types.js';
+export * from './builtinMethods.js';
+export * from './validate/SymbolTable.js';
+export * from './validate/SymbolValidatorResolveVisitor.js';
+export * from './validate/SymbolValidatorVisitor.js';
+export * from './environment.js';

package/dist/types/objects/ClassComponent.d.ts

@@ -17,6 +17,7 @@ export declare class ClassComponent {
     _cachedParams: string;
     _copyID?: number;
     _copyFrom?: ClassComponent;
+    _pointLinkComponent?: ClassComponent;
     arrangeProps: Map<string, NumericValue[]> | null;
     displayProp: SymbolDrawingCommands | null;
     widthProp: number | null;

package/dist/types/objects/ExecutionScope.d.ts

@@ -5,6 +5,8 @@ import { LayoutDirection } from '../globals.js';
 import { Wire, WireSegment } from './Wire.js';
 import { Frame } from './Frame.js';
 import { ParserRuleContext } from 'antlr4ng';
+type OnPropertyHandler = (path: PropertyTreeKey[], value: any, valueContext: ParserRuleContext) => void;
+export type PropertyTreeKey = [ctx: ParserRuleContext, value: any] | ['index', number];
 export declare class ExecutionScope {
     scopeId: number;
     private nets;
@@ -15,6 +17,8 @@ export declare class ExecutionScope {
         type: ParseSymbolType;
     }>;
     blockStack: Map<number, any>;
+    contextStack: ParserRuleContext[];
+    onPropertyHandler: OnPropertyHandler[];
     breakStack: ParserRuleContext[];
     wires: Wire[];
     frames: Frame[];
@@ -44,6 +48,12 @@ export declare class ExecutionScope {
     setActive(type: ActiveObject, item: any): void;
     clearActive(): void;
     setCurrent(component: ClassComponent | null, pin?: number | null): void;
+    enterContext(context: ParserRuleContext): void;
+    exitContext(): ParserRuleContext;
+    findPropertyKeyTree(): PropertyTreeKey[];
+    setOnPropertyHandler(handler: OnPropertyHandler): void;
+    popOnPropertyHandler(): OnPropertyHandler;
+    triggerPropertyHandler(value: any, valueCtx: ParserRuleContext): void;
 }
 export declare enum SequenceAction {
     To = "to",
@@ -71,3 +81,4 @@ export type SequenceActionAtTo = [
 export type SequenceActionWire = [SequenceAction.Wire, wireId: number, WireSegment[]];
 export type SequenceActionAssign = [SequenceAction.Assign, variable: string, ClassComponent];
 export type SequenceItem = SequenceActionAtTo | SequenceActionWire | [SequenceAction.WireJump, wireId: number, pinId: number] | [SequenceAction.Frame, Frame, "enter" | "exit"] | SequenceActionAssign;
+export {};

package/dist/types/objects/types.d.ts

@@ -1,3 +1,4 @@
+import { Token } from 'antlr4ng';
 import { ExecutionContext } from '../execute.js';
 import { ClassComponent } from './ClassComponent.js';
 import { Net } from './Net.js';
@@ -35,7 +36,11 @@ export type CallableParameter = [
     key: number,
     value: ValueType
 ];
-export type FunctionDefinedParameter = [name: string, defaultValue: ValueType] | [name: string];
+export type FunctionDefinedParameter = [
+    name: string,
+    token: Token,
+    defaultValue: ValueType
+] | [name: string, token: Token];
 export declare class UndeclaredReference {
     reference: ReferenceType;
     constructor(reference: ReferenceType);

package/dist/types/parser.d.ts

@@ -1,23 +1,19 @@
 import { CircuitScriptParser, ScriptContext } from './antlr/CircuitScriptParser.js';
-import { ANTLRErrorListener, ATNConfigSet, ATNSimulator, BitSet, DefaultErrorStrategy, DFA, Parser, RecognitionException, Recognizer, Token } from 'antlr4ng';
-import { BaseVisitor, OnErrorCallback } from './BaseVisitor.js';
-export declare function parseFileWithVisitor(visitor: BaseVisitor, data: string): {
+import { ANTLRErrorListener, ATNConfigSet, ATNSimulator, BitSet, DFA, Parser, RecognitionException, Recognizer, Token } from 'antlr4ng';
+import { BaseVisitor, OnErrorHandler } from './BaseVisitor.js';
+export declare function parseFileWithVisitor(visitor: BaseVisitor, data: string): Promise<{
     tree: ScriptContext;
     parser: CircuitScriptParser;
     hasError: boolean;
     hasParseError: boolean;
     parserTimeTaken: number;
     lexerTimeTaken: number;
-};
-export declare class TempErrorStrategy extends DefaultErrorStrategy {
-    recover(recognizer: Parser, e: RecognitionException): void;
-    reportError(recognizer: Parser, e: RecognitionException): void;
-}
+}>;
 export declare class CircuitscriptParserErrorListener implements ANTLRErrorListener {
     syntaxErrorCounter: number;
-    onErrorHandler: OnErrorCallback | null;
-    constructor(onErrorHandler?: OnErrorCallback | null);
-    syntaxError<S extends Token, T extends ATNSimulator>(recognizer: Recognizer<T>, offendingSymbol: S | null, line: number, charPositionInLine: number, msg: string, e: RecognitionException | null): void;
+    onErrorHandler: OnErrorHandler | null;
+    constructor(onErrorHandler?: OnErrorHandler | null);
+    syntaxError<S extends Token, T extends ATNSimulator>(recognizer: Recognizer<T>, offendingSymbol: S | null, line: number, column: number, msg: string, e: RecognitionException | null): void;
     reportAmbiguity(recognizer: Parser, dfa: DFA, startIndex: number, stopIndex: number, exact: boolean, ambigAlts: BitSet | undefined, configs: ATNConfigSet): void;
     reportAttemptingFullContext(recognizer: Parser, dfa: DFA, startIndex: number, stopIndex: number, conflictingAlts: BitSet | undefined, configs: ATNConfigSet): void;
     reportContextSensitivity(recognizer: Parser, dfa: DFA, startIndex: number, stopIndex: number, prediction: number, configs: ATNConfigSet): void;

package/dist/types/sizing.d.ts

@@ -1,8 +1,5 @@
 import { Box, SVGTypeMapping } from '@svgdotjs/svg.js';
 import { HorizontalAlign, VerticalAlign } from './geometry.js';
-import { SVGWindow } from 'svgdom';
-export declare function prepareSVGEnvironment(fontsPath: string | null): Promise<void>;
-export declare function getCreateSVGWindow(): () => SVGWindow;
 export declare function applyFontsToSVG(canvas: SVGTypeMapping): void;
 export declare function measureTextSize2(text: string, fontFamily: string, fontSize: number, fontWeight?: string, anchor?: HorizontalAlign, vanchor?: VerticalAlign): {
     width: number;

package/dist/types/utils.d.ts

@@ -1,9 +1,9 @@
 import { Big } from 'big.js';
-import { ParserRuleContext } from "antlr4ng";
-import { ClassComponent } from "./objects/ClassComponent";
-import { NumericValue } from "./objects/ParamDefinition";
-import { SequenceAction, SequenceItem } from './objects/ExecutionScope';
-import { BlockTypes } from './globals';
+import { ParserRuleContext, Token } from "antlr4ng";
+import { ClassComponent } from "./objects/ClassComponent.js";
+import { NumericValue } from "./objects/ParamDefinition.js";
+import { SequenceAction, SequenceItem } from './objects/ExecutionScope.js';
+import { BlockTypes } from './globals.js';
 export declare class SimpleStopwatch {
     startTime: Date;
     constructor();
@@ -31,7 +31,9 @@ export declare function getBoundsSize(bounds: BoundBox): {
 };
 export declare function getPortType(component: ClassComponent): string | null;
 export declare function roundValue(value: NumericValue): NumericValue;
-export declare function throwWithContext(context: ParserRuleContext, message: string): void;
+export declare function throwWithContext(context: ParserRuleContext, messageOrError: string | BaseError): void;
+export declare function throwWithToken(message: string, token: Token): void;
+export declare function throwWithTokenRange(message: string, startToken: Token, endToken?: Token): void;
 export declare function combineMaps(map1: Map<string, any>, map2: Map<string, any>): Map<string, any>;
 export declare function getNumberExponential(value: string): number;
 export declare function getNumberExponentialText(value: number): string;
@@ -41,3 +43,25 @@ export declare function areasOverlap(area1: BoundBox2, area2: BoundBox2): boolea
 export declare function sequenceActionString(sequenceAction: SequenceAction): string;
 export declare function generateDebugSequenceAction(sequence: SequenceItem[]): string[];
 export declare function getBlockTypeString(type: BlockTypes): string;
+export declare class BaseError extends Error {
+    name: string;
+    message: string;
+    startToken?: Token;
+    endToken?: Token;
+    filePath?: string;
+    constructor(message: string, startToken?: Token, endToken?: Token, filePath?: string);
+    toString(): string;
+}
+export declare class ParseSyntaxError extends BaseError {
+    name: string;
+}
+export declare class ParseError extends ParseSyntaxError {
+    name: string;
+}
+export declare class RuntimeExecutionError extends BaseError {
+    name: string;
+}
+export declare class RenderError extends Error {
+    stage?: string;
+    constructor(message: string, stage?: string);
+}

package/dist/types/validate/SymbolTable.d.ts

@@ -0,0 +1,40 @@
+import { TerminalNode, Token } from "antlr4ng";
+import { ExecutionContext } from "../execute.js";
+import { FunctionDefinedParameter, ParseSymbolType, ValueType } from "../objects/types.js";
+export declare class SymbolTable {
+    protected symbols: Map<string, SymbolTableItem>;
+    executonContextsNamespaces: string[];
+    getSymbols(): Map<string, SymbolTableItem>;
+    addFunction(token: Token | null, fileName: string, executionContext: ExecutionContext, id: string, funcDefinedParameters: FunctionDefinedParameter[]): SymbolTableItem;
+    addVariable(token: Token, fileName: string, executionContext: ExecutionContext, id: string, variableValue: SymbolTableItem | ValueType | null): SymbolTableItem;
+    addUndefined(filePath: string, executionContext: ExecutionContext, id: string, token: Token): SymbolTableItem;
+    add(fileName: string, executionContext: ExecutionContext, id: string, type: ParseSymbolType, extra: SymbolTableItemExtra, token: Token | null): SymbolTableItem;
+    protected idName(executionContext: ExecutionContext, id: string): string;
+    dumpSymbols(): void;
+    exists(executionContext: ExecutionContext, id: string): boolean;
+    existsAny(executionContext: ExecutionContext, id: string): boolean;
+    get(executionContext: ExecutionContext, id: string): SymbolTableItem;
+    getParentContexts(executionContext: ExecutionContext, contextsNamespace: string[]): string[];
+    searchParentContext(executionContext: ExecutionContext, id: string): ExecutionContext | null;
+    clearUndefined(): void;
+}
+export type SymbolTableItemDefined = {
+    id: string;
+    type: ParseSymbolType;
+    context: ExecutionContext;
+    fileName: string;
+    token: Token | null;
+    extra: SymbolTableItemExtra;
+    instances: Token[];
+};
+export type SymbolTableItemUndefined = {
+    type: ParseSymbolType.Undefined;
+    extra: SymbolTableItemExtra;
+    token: Token | null;
+};
+export type SymbolTableItem = SymbolTableItemDefined | SymbolTableItemUndefined;
+export type SymbolTableItemExtra = {
+    funcDefinedParameters?: FunctionDefinedParameter[];
+    variableValue?: SymbolTableItem | ValueType | null;
+    node?: TerminalNode;
+};

package/dist/types/validate/SymbolValidatorResolveVisitor.d.ts

@@ -0,0 +1,7 @@
+import { Token } from "antlr4ng";
+import { ComplexType, FunctionDefinedParameter } from "../objects/types.js";
+import { SymbolValidatorVisitor } from "./SymbolValidatorVisitor.js";
+export declare class SymbolValidatorResolveVisitor extends SymbolValidatorVisitor {
+    protected addSymbolVariable(token: Token, name: string, value: ComplexType): void;
+    protected addSymbolFunction(token: Token, functionName: string, funcDefinedParameters: FunctionDefinedParameter[]): void;
+}

package/dist/types/validate/SymbolValidatorVisitor.d.ts

@@ -0,0 +1,32 @@
+import { TerminalNode, Token } from "antlr4ng";
+import { Import_exprContext, Assignment_exprContext, Atom_exprContext, Function_call_exprContext, ValueAtomExprContext, UnaryOperatorExprContext, MultiplyExprContext, AdditionExprContext, BinaryOperatorExprContext, DataExprContext, Function_def_exprContext } from "src/antlr/CircuitScriptParser";
+import { ExecutionContext } from "../execute.js";
+import { ComplexType, FunctionDefinedParameter } from "../objects/types.js";
+import { SymbolTableItem } from "./SymbolTable.js";
+import { SymbolTable } from "./SymbolTable.js";
+import { BaseVisitor } from "../BaseVisitor.js";
+export declare class SymbolValidatorVisitor extends BaseVisitor {
+    symbolTable: SymbolTable;
+    filePathStack: string[];
+    enterFile(filePath: string): void;
+    exitFile(): void;
+    getCurrentFile(): string;
+    protected addSymbolVariable(token: Token, name: string, value: ComplexType, executor?: ExecutionContext | null): void;
+    protected addSymbolFunction(token: Token, functionName: string, funcDefinedParameters: FunctionDefinedParameter[]): void;
+    protected handleAtomSymbol(atom: TerminalNode): SymbolTableItem;
+    protected addSymbolInstance(symbol: SymbolTableItem, token: Token): void;
+    setSymbols(symbolTable: SymbolTable): void;
+    visitImport_expr: (ctx: Import_exprContext) => void;
+    visitAssignment_expr: (ctx: Assignment_exprContext) => ComplexType;
+    visitAtom_expr: (ctx: Atom_exprContext) => void;
+    visitFunction_call_expr: (ctx: Function_call_exprContext) => void;
+    visitValueAtomExpr: (ctx: ValueAtomExprContext) => void;
+    visitUnaryOperatorExpr: (ctx: UnaryOperatorExprContext) => void;
+    visitMultiplyExpr: (ctx: MultiplyExprContext) => void;
+    visitAdditionExpr: (ctx: AdditionExprContext) => void;
+    visitBinaryOperatorExpr: (ctx: BinaryOperatorExprContext) => void;
+    visitDataExpr: (ctx: DataExprContext) => void;
+    visitFunction_def_expr: (ctx: Function_def_exprContext) => void;
+    getSymbols(): SymbolTable;
+    dumpSymbols(): void;
+}

package/dist/types/validate.d.ts

@@ -1,2 +1,2 @@
 #! /usr/bin/env node
-export declare function validate(): Promise<void>;
+export default function validate(): Promise<void>;

package/package.json

@@ -1,13 +1,13 @@
 {
     "name": "circuitscript",
-    "version": "0.1.5",
+    "version": "0.1.7",
     "description": "Interpreter for the circuitscript language",
     "homepage": "https://circuitscript.net",
     "engines": {
         "node": ">=16.0"
     },
     "main": "./dist/cjs/index.js",
-    "module": "./dist/esm/index.mjs",
+    "module": "./dist/esm/index.js",
     "types": "./dist/types/index.d.ts",
     "bin": {
         "circuitscript": "./dist/cjs/main.js"
@@ -15,7 +15,7 @@
     "exports": {
         ".": {
             "require": "./dist/cjs/index.js",
-            "import": "./dist/esm/index.mjs"
+            "import": "./dist/esm/index.js"
         }
     },
     "files": [
@@ -49,30 +49,31 @@
     "scripts": {
         "start": "node build/src/main.js",
         "clean": "rimraf coverage build tmp dist",
-        "build": "npm run build:cjs || npm run build:esm",
+        "build": "npm run copy-assets ; npm run build:cjs ; npm run build:esm",
         "build:cjs": "tsc -p tsconfig.cjs.json",
         "build:release:cjs": "tsc -p tsconfig.release.cjs.json",
-        "build:esm": "tsc -p tsconfig.esm.json || npm run rename:esm",
-        "build:release:esm": "tsc -p tsconfig.release.esm.json || npm run rename:esm",
+        "build:esm": "tsc -p tsconfig.esm.json",
+        "build:release:esm": "tsc -p tsconfig.release.esm.json",
         "rename:esm": "npx ts2mjs ./dist/esm && rm -rf ./dist/esm/*.js && rm -rf ./dist/esm/**/*.js",
         "build:watch": "tsc -w -p tsconfig.esm.json",
         "build:watch:cjs": "tsc -w -p tsconfig.cjs.json",
-        "build:release": "npm run clean && npm run build:release:cjs || npm run build:release:esm",
+        "build:release": "npm run clean && npm run copy-assets && npm run build:release:cjs || npm run build:release:esm",
         "prebuild": "npm run lint || true",
         "lint": "eslint . --ext .ts --ext .mts",
-        "test": "jest",
-        "test-coverage": "jest --coverage",
+        "test": "node --experimental-vm-modules node_modules/.bin/jest",
+        "test-coverage": "node --experimental-vm-modules node_modules/.bin/jest --coverage",
         "prettier": "prettier --config .prettierrc --write .",
-        "test:watch": "jest --watch",
+        "test:watch": "node --experimental-vm-modules node_modules/.bin/jest --watch",
         "antlr": "antlr4 -Dlanguage=TypeScript ./src/antlr/CircuitScript.g4 -no-listener -visitor",
         "antlr4ng": "npx antlr4ng -Dlanguage=TypeScript -o src/antlr -visitor -no-listener -Xexact-output-dir src/antlr/CircuitScript.g4",
         "profile": "node --prof build/src/main.js examples/example_garden_pump.cst",
         "profile-flame": "node --prof-process --preprocess -j isolate*.log | flamebearer",
         "server": "node server.js",
-        "pack-local": "npm pack; rm circuitscript-install.tgz; mv `ls | grep circuitscript` circuitscript-install.tgz; cp circuitscript-install.tgz ../circuitscript-vscode/client; cp circuitscript-install.tgz ../circuitscript-vscode/server",
+        "pack-local": "npm run build; npm pack; rm circuitscript-install.tgz; mv `ls | grep circuitscript-` circuitscript-install.tgz; cp circuitscript-install.tgz ../circuitscript-vscode/client; cp circuitscript-install.tgz ../circuitscript-vscode/server && echo 'OK'",
         "changelog": "auto-changelog --handlebars-setup ../changelog/helper.js -p",
         "preversion": "npm run test",
-        "version": "npm run changelog && git add CHANGELOG.md"
+        "version": "npm run changelog && git add CHANGELOG.md",
+        "copy-assets": "mkdir -p dist/fonts && mkdir -p dist/libs && cp -r fonts dist/ && cp -r libs dist/"
     },
     "boilerplate_author": "Jakub Synowiec <jsynowiec@users.noreply.github.com>",
     "license": "MIT",
@@ -88,7 +89,7 @@
         "lodash": "^4.17.21",
         "pdfkit": "^0.15.1",
         "svg-to-pdfkit": "^0.1.8",
-        "svgdom": "0.1.14",
+        "svgdom": "^0.1.22",
         "this-file": "^2.0.3",
         "tslib": "~2.5",
         "ws": "^8.14.2"

package/dist/cjs/SymbolValidatorVisitor.js

@@ -1,233 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SymbolTable = exports.SymbolValidatorResolveVisitor = exports.SymbolValidatorVisitor = void 0;
-const BaseVisitor_js_1 = require("./BaseVisitor.js");
-const types_js_1 = require("./objects/types.js");
-class SymbolValidatorVisitor extends BaseVisitor_js_1.BaseVisitor {
-    constructor() {
-        super(...arguments);
-        this.symbolTable = new SymbolTable();
-        this.visitImport_expr = (ctx) => {
-            const ID = ctx.ID().toString();
-            const { pathExists } = this.handleImportFile(ID, false, ctx);
-            if (!pathExists) {
-                this.symbolTable.addUndefined(this.getExecutor(), ID, ctx.ID());
-            }
-        };
-        this.visitAssignment_expr = (ctx) => {
-            const atomStr = ctx.atom_expr().getText();
-            const ctxDataExpr = ctx.data_expr();
-            this.visit(ctxDataExpr);
-            const value = this.getResult(ctxDataExpr);
-            this.addSymbolVariable(atomStr, value);
-            return null;
-        };
-        this.visitAtom_expr = (ctx) => {
-            const tmpSymbol = this.handleAtomSymbol(ctx.ID(0));
-            this.setResult(ctx, tmpSymbol);
-        };
-        this.visitFunction_call_expr = (ctx) => {
-            this.handleAtomSymbol(ctx.ID());
-            if (ctx.trailer_expr().length > 0) {
-                ctx.trailer_expr().forEach(item => {
-                    if (item.OPEN_PAREN() && item.CLOSE_PAREN()) {
-                        const params = item.parameters();
-                        if (params) {
-                            this.visit(params);
-                        }
-                    }
-                });
-            }
-        };
-        this.visitValueAtomExpr = (ctx) => {
-            let value = null;
-            const ctxValueExpr = ctx.value_expr();
-            const cxtAtomExpr = ctx.atom_expr();
-            if (ctxValueExpr) {
-                this.visit(ctxValueExpr);
-                value = this.getResult(ctxValueExpr);
-            }
-            else if (cxtAtomExpr) {
-                this.visit(cxtAtomExpr);
-                value = this.getResult(cxtAtomExpr);
-            }
-            this.setResult(ctx, value);
-        };
-        this.visitUnaryOperatorExpr = (ctx) => {
-            this.visit(ctx.data_expr());
-        };
-        this.visitMultiplyExpr = (ctx) => {
-            this.visit(ctx.data_expr(0));
-            this.visit(ctx.data_expr(1));
-        };
-        this.visitAdditionExpr = (ctx) => {
-            this.visit(ctx.data_expr(0));
-            this.visit(ctx.data_expr(1));
-        };
-        this.visitBinaryOperatorExpr = (ctx) => {
-            this.visit(ctx.data_expr(0));
-            this.visit(ctx.data_expr(1));
-        };
-        this.visitDataExpr = (ctx) => {
-            return;
-        };
-        this.visitFunction_def_expr = (ctx) => {
-            const functionName = ctx.ID().getText();
-            let funcDefinedParameters = [];
-            const ctxFunctionArgsExpr = ctx.function_args_expr();
-            if (ctxFunctionArgsExpr) {
-                this.visit(ctxFunctionArgsExpr);
-                funcDefinedParameters = this.getResult(ctxFunctionArgsExpr);
-            }
-            this.addSymbolFunction(functionName, funcDefinedParameters);
-            const executionContextName = functionName + '_validate';
-            const passedInParamsNull = funcDefinedParameters.map((param, index) => {
-                return ['position', index, null];
-            });
-            const newExecutor = this.enterNewChildContext(this.executionStack, this.getExecutor(), executionContextName, { netNamespace: "" }, funcDefinedParameters, passedInParamsNull);
-            funcDefinedParameters.forEach(param => {
-                this.addSymbolVariable(param[0], null, newExecutor);
-            });
-            this.runExpressions(newExecutor, ctx.function_expr());
-            this.executionStack.pop();
-        };
-    }
-    addSymbolVariable(name, value, executor = null) {
-        const useExecutor = executor === null ? this.getExecutor() : executor;
-        this.symbolTable.addVariable(useExecutor, name, value);
-        this.log2('add symbol variable: ' + name);
-    }
-    addSymbolFunction(functionName, funcDefinedParameters) {
-        if (!this.symbolTable.exists(this.getExecutor(), functionName)) {
-            this.symbolTable.addFunction(this.getExecutor(), functionName, funcDefinedParameters);
-            this.log2('add symbol function: ' + functionName);
-        }
-    }
-    handleAtomSymbol(atom) {
-        const atomId = atom.getText();
-        const executor = this.getExecutor();
-        let tmpSymbol;
-        if (this.symbolTable.exists(executor, atomId)) {
-            tmpSymbol = this.symbolTable.get(executor, atomId);
-        }
-        else {
-            const foundContext = this.symbolTable.searchParentContext(executor, atomId);
-            if (foundContext === null) {
-                tmpSymbol = this.symbolTable.addUndefined(executor, atomId, atom);
-                this.log2('symbol not found: ' + atomId);
-            }
-            else {
-                tmpSymbol = this.symbolTable.get(foundContext, atomId);
-            }
-        }
-        return tmpSymbol;
-    }
-    setSymbols(symbolTable) {
-        this.symbolTable = symbolTable;
-    }
-    getSymbols() {
-        return this.symbolTable;
-    }
-    dumpSymbols() {
-        this.symbolTable.dumpSymbols();
-    }
-}
-exports.SymbolValidatorVisitor = SymbolValidatorVisitor;
-class SymbolValidatorResolveVisitor extends SymbolValidatorVisitor {
-    addSymbolVariable(name, value) {
-    }
-    addSymbolFunction(functionName, funcDefinedParameters) {
-        if (this.symbolTable.exists(this.getExecutor(), functionName)) {
-            this.symbolTable.addFunction(this.getExecutor(), functionName, funcDefinedParameters);
-        }
-    }
-}
-exports.SymbolValidatorResolveVisitor = SymbolValidatorResolveVisitor;
-class SymbolTable {
-    constructor() {
-        this.symbols = new Map();
-        this.executonContextsNamespaces = [];
-    }
-    getSymbols() {
-        return this.symbols;
-    }
-    addFunction(executionContext, id, funcDefinedParameters) {
-        return this.add(executionContext, id, types_js_1.ParseSymbolType.Function, {
-            funcDefinedParameters
-        });
-    }
-    addVariable(executionContext, id, variableValue) {
-        return this.add(executionContext, id, types_js_1.ParseSymbolType.Variable, {
-            variableValue
-        });
-    }
-    addUndefined(executionContext, id, node) {
-        return this.add(executionContext, id, types_js_1.ParseSymbolType.Undefined, {
-            node
-        });
-    }
-    add(executionContext, id, type, extra) {
-        if (this.executonContextsNamespaces.indexOf(executionContext.namespace) === -1) {
-            this.executonContextsNamespaces.push(executionContext.namespace);
-        }
-        const item = {
-            id,
-            type,
-            context: executionContext,
-            extra
-        };
-        this.symbols.set(this.idName(executionContext, id), item);
-        return item;
-    }
-    idName(executionContext, id) {
-        return executionContext.namespace + id;
-    }
-    dumpSymbols() {
-        for (const [key, value] of this.symbols) {
-            console.log(value.type.padEnd(10, " "), key);
-        }
-    }
-    exists(executionContext, id) {
-        const name = this.idName(executionContext, id);
-        return this.symbols.has(name);
-    }
-    existsAny(executionContext, id) {
-        if (this.exists(executionContext, id)) {
-            return true;
-        }
-        else {
-            return this.searchParentContext(executionContext, id) !== null;
-        }
-    }
-    get(executionContext, id) {
-        const name = this.idName(executionContext, id);
-        return this.symbols.get(name);
-    }
-    getParentContexts(executionContext, contextsNamespace) {
-        if (executionContext.parentContext !== null) {
-            contextsNamespace.push(executionContext.parentContext.namespace);
-            this.getParentContexts(executionContext.parentContext, contextsNamespace);
-        }
-        return contextsNamespace;
-    }
-    searchParentContext(executionContext, id) {
-        const contextNames = this.getParentContexts(executionContext, []);
-        for (const [key,] of this.symbols) {
-            if (key.endsWith(`.${id}`)) {
-                const { context } = this.symbols.get(key);
-                if (contextNames.indexOf(context.namespace) !== -1) {
-                    return context;
-                }
-            }
-        }
-        return null;
-    }
-    clearUndefined() {
-        for (const [key, value] of this.symbols) {
-            if (value.type === types_js_1.ParseSymbolType.Undefined) {
-                this.symbols.delete(key);
-            }
-        }
-    }
-}
-exports.SymbolTable = SymbolTable;