circuitscript 0.0.24 → 0.0.25

package/dist/types/BaseVisitor.d.ts

@@ -0,0 +1,69 @@
+import { Assignment_exprContext, Atom_exprContext, Blank_exprContext, Break_keywordContext, ExpressionContext, Function_args_exprContext, Function_call_exprContext, Function_exprContext, Function_return_exprContext, FunctionCallExprContext, Import_exprContext, ParametersContext, RoundedBracketsExprContext, ScriptContext, Value_exprContext, ValueAtomExprContext } from "./antlr/CircuitScriptParser";
+import { CircuitScriptVisitor } from "./antlr/CircuitScriptVisitor";
+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 { ParserRuleContext } from 'antlr4ng';
+export declare class BaseVisitor extends CircuitScriptVisitor<ComplexType | ReferenceType | any> {
+    indentLevel: number;
+    startingContext: ExecutionContext;
+    executionStack: ExecutionContext[];
+    silent: boolean;
+    logger: Logger;
+    currentDirectory: string;
+    defaultLibsPath: string;
+    printStream: string[];
+    printToConsole: boolean;
+    acceptedDirections: string[];
+    acceptedFlip: string[];
+    protected resultData: Map<ParserRuleContext, any>;
+    protected paramData: Map<ParserRuleContext, any>;
+    pinTypesList: string[];
+    onErrorCallbackHandler: OnErrorCallback | null;
+    onImportFile: (visitor: BaseVisitor, filePath: string) => {
+        hasError: boolean;
+        hasParseError: boolean;
+    };
+    constructor(silent: boolean | undefined, onErrorHandler: OnErrorCallback | null | undefined, currentDirectory: string | null, defaultLibsPath: string);
+    getExecutor(): ExecutionContext;
+    protected setupPrintFunction(context: ExecutionContext): void;
+    createNetResolver(executionStack: ExecutionContext[]): (netName: string, netNamespace: string) => {
+        found: boolean;
+        net?: Net;
+    };
+    log(...params: any[]): void;
+    log2(message: string): void;
+    visitScript: (ctx: ScriptContext) => void;
+    visitAssignment_expr: (ctx: Assignment_exprContext) => void;
+    visitAtom_expr: (ctx: Atom_exprContext) => void;
+    visitFunctionCallExpr: (ctx: FunctionCallExprContext) => void;
+    visitFunction_call_expr: (ctx: Function_call_exprContext) => void;
+    visitValue_expr: (ctx: Value_exprContext) => void;
+    visitBlank_expr: (ctx: Blank_exprContext) => void;
+    visitValueAtomExpr: (ctx: ValueAtomExprContext) => void;
+    visitFunction_args_expr: (ctx: Function_args_exprContext) => void;
+    visitParameters: (ctx: ParametersContext) => void;
+    visitImport_expr: (ctx: Import_exprContext) => void;
+    visitFunction_return_expr: (ctx: Function_return_exprContext) => void;
+    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;
+        pathExists: boolean;
+    };
+    visitRoundedBracketsExpr: (ctx: RoundedBracketsExprContext) => void;
+    protected setupDefinedParameters(funcDefinedParameters: FunctionDefinedParameter[], passedInParameters: CallableParameter[], executor: ExecutionContext): void;
+    protected runExpressions(executor: ExecutionContext, expressions: ExpressionContext[] | Function_exprContext[]): ComplexType;
+    protected getNetNamespace(executorNetNamespace: string, passedNetNamespace: string | null): string;
+    protected setInstanceParam(object: ClassComponent, trailers: string[], value: any): void;
+    protected enterNewChildContext(executionStack: ExecutionContext[], parentContext: ExecutionContext, executionContextName: string, options: CFunctionOptions, funcDefinedParameters: FunctionDefinedParameter[], passedInParameters: CallableParameter[]): ExecutionContext;
+    protected prepareStringValue(value: string): string;
+}
+export type OnErrorCallback = (line: number, column: number, message: string, e: any | undefined) => void;

package/dist/types/SemanticTokenVisitor.d.ts

@@ -0,0 +1,36 @@
+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 { BaseVisitor, OnErrorCallback } from "./BaseVisitor";
+export declare class SemanticTokensVisitor extends BaseVisitor {
+    parsedTokens: IParsedToken[];
+    lexer: CircuitScriptLexer;
+    script: string;
+    semanticTokens: Map<string, IParsedToken>;
+    constructor(silent: boolean | undefined, onErrorHandler: OnErrorCallback | null | undefined, currentDirectory: string | null, defaultsLibsPath: string, lexer: CircuitScriptLexer, script: string);
+    visitFunction_args_expr: (ctx: Function_args_exprContext) => void;
+    visitFunction_call_expr: (ctx: Function_call_exprContext) => void;
+    visitFunction_def_expr: (ctx: Function_def_exprContext) => void;
+    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;
+    visitValueAtomExpr: (ctx: ValueAtomExprContext) => void;
+    visitAssignment_expr: (ctx: Assignment_exprContext) => void;
+    visitAtom_expr: (ctx: Atom_exprContext) => void;
+    visitImport_expr: (ctx: Import_exprContext) => void;
+    addSemanticToken(node: TerminalNode, modifiers: string[], tokenType?: string | null): void;
+    parseToken(node: TerminalNode, modifiers: string[], tokenType?: string | null): IParsedToken;
+    dumpTokens(): void;
+    getTokens(): Map<string, IParsedToken>;
+}
+export interface IParsedToken {
+    line: number;
+    column: number;
+    length: number;
+    tokenType: string;
+    tokenModifiers: string[];
+    textValue: string;
+    path: string;
+}
+export declare function prepareTokens(tokens: Token[], lexer: CircuitScriptLexer, script: string): IParsedToken[];

package/dist/types/SymbolValidatorVisitor.d.ts

@@ -0,0 +1,61 @@
+import { TerminalNode } from "antlr4ng";
+import { AdditionExprContext, Assignment_exprContext, Atom_exprContext, BinaryOperatorExprContext, DataExprContext, Function_call_exprContext, Function_def_exprContext, Import_exprContext, MultiplyExprContext, UnaryOperatorExprContext, ValueAtomExprContext } from "./antlr/CircuitScriptParser.js";
+import { BaseVisitor } from "./BaseVisitor.js";
+import { ExecutionContext } from "./execute.js";
+import { ComplexType, FunctionDefinedParameter, ParseSymbolType, ValueType } from "./objects/types.js";
+export declare class SymbolValidatorVisitor extends BaseVisitor {
+    symbolTable: SymbolTable;
+    protected addSymbolVariable(name: string, value: ComplexType, executor?: ExecutionContext | null): void;
+    protected addSymbolFunction(functionName: string, funcDefinedParameters: FunctionDefinedParameter[]): void;
+    protected handleAtomSymbol(atom: TerminalNode): SymbolTableItem;
+    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;
+}
+export declare class SymbolValidatorResolveVisitor extends SymbolValidatorVisitor {
+    protected addSymbolVariable(name: string, value: ComplexType): void;
+    protected addSymbolFunction(functionName: string, funcDefinedParameters: FunctionDefinedParameter[]): void;
+}
+type SymbolTableItem = {
+    id: string;
+    type: ParseSymbolType;
+    context: ExecutionContext;
+    extra: SymbolTableItemExtra;
+} | {
+    type: ParseSymbolType.Undefined;
+    extra: SymbolTableItemExtra;
+};
+type SymbolTableItemExtra = {
+    funcDefinedParameters?: FunctionDefinedParameter[];
+    variableValue?: SymbolTableItem | ValueType | null;
+    node?: TerminalNode;
+};
+export declare class SymbolTable {
+    protected symbols: Map<string, SymbolTableItem>;
+    executonContextsNamespaces: string[];
+    getSymbols(): Map<string, SymbolTableItem>;
+    addFunction(executionContext: ExecutionContext, id: string, funcDefinedParameters: FunctionDefinedParameter[]): SymbolTableItem;
+    addVariable(executionContext: ExecutionContext, id: string, variableValue: SymbolTableItem | ValueType | null): SymbolTableItem;
+    addUndefined(executionContext: ExecutionContext, id: string, node: TerminalNode): SymbolTableItem;
+    protected add(executionContext: ExecutionContext, id: string, type: ParseSymbolType, extra: SymbolTableItemExtra): 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 {};

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

@@ -1,5 +1,5 @@
-import { ATN, CharStream, DFA, Lexer, RuleContext } from "antlr4";
-export default class CircuitScriptLexer extends Lexer {
+import * as antlr from "antlr4ng";
+export declare class CircuitScriptLexer extends antlr.Lexer {
     static readonly T__0 = 1;
     static readonly T__1 = 2;
     static readonly T__2 = 3;
@@ -46,13 +46,12 @@ export default class CircuitScriptLexer extends Lexer {
     static readonly WS = 44;
     static readonly NEWLINE = 45;
     static readonly COMMENT = 46;
-    static readonly EOF: number;
     static readonly channelNames: string[];
     static readonly literalNames: (string | null)[];
     static readonly symbolicNames: (string | null)[];
     static readonly modeNames: string[];
     static readonly ruleNames: string[];
-    constructor(input: CharStream);
+    constructor(input: antlr.CharStream);
     get grammarFileName(): string;
     get literalNames(): (string | null)[];
     get symbolicNames(): (string | null)[];
@@ -60,12 +59,14 @@ export default class CircuitScriptLexer extends Lexer {
     get serializedATN(): number[];
     get channelNames(): string[];
     get modeNames(): string[];
-    action(localctx: RuleContext, ruleIndex: number, actionIndex: number): void;
+    action(localContext: antlr.ParserRuleContext | null, ruleIndex: number, actionIndex: number): void;
     private OPEN_PAREN_action;
     private CLOSE_PAREN_action;
     private NEWLINE_action;
     static readonly _serializedATN: number[];
     private static __ATN;
-    static get _ATN(): ATN;
-    static DecisionsToDFA: DFA[];
+    static get _ATN(): antlr.ATN;
+    private static readonly vocabulary;
+    get vocabulary(): antlr.Vocabulary;
+    private static readonly decisionsToDFA;
 }