circuitscript 0.1.29 → 0.1.32

package/dist/esm/visitor.js

@@ -3,7 +3,7 @@ import { NumberOperator, numeric, NumericValue, ParamDefinition } from './object
 import { PinDefinition, PinId, PinIdType } from './objects/PinDefinition.js';
 import { PinTypes } from './objects/PinTypes.js';
 import { AnyReference, DeclaredReference, TypeProps, UndeclaredReference } from './objects/types.js';
-import { BlockTypes, ComponentTypes, Delimiter1, FrameType, GlobalDocumentName, ModuleContainsKeyword, NoNetText, ParamKeys, ReferenceTypes, SymbolPinSide, ValidPinSides, WireAutoDirection } from './globals.js';
+import { BlockTypes, ComponentTypes, Delimiter1, FrameType, GlobalDocumentName, ModuleContainsKeyword, NoNetText, ParamKeys, RefdesFileSuffix, ReferenceTypes, SymbolPinSide, ValidPinSides, WireAutoDirection } from './globals.js';
 import { unwrapValue } from "./utils.js";
 import { PlaceHolderCommands, SymbolDrawingCommands } from './draw_symbols.js';
 import { BaseVisitor } from './BaseVisitor.js';
@@ -13,6 +13,16 @@ import { FrameParamKeys } from './objects/Frame.js';
 import { ComponentAnnotater } from './ComponentAnnotater.js';
 import { applyPartConditions, extractPartConditions, flattenConditionNodes } from './ComponentMatchConditions.js';
 export class ParserVisitor extends BaseVisitor {
+    constructor(silent = false, onErrorHandler = null, environment) {
+        super(silent, onErrorHandler, environment);
+        if (environment) {
+            this.log('-- Environment --');
+            this.log('Module directory: ' + environment.getModuleDirectory());
+            this.log('Default libs path: ' + environment.getDefaultLibsPath());
+            this.log('Current file: ' + environment.getCurrentFile());
+            this.log('-----------------');
+        }
+    }
     componentCreationIndex = 0;
     creationCtx = new Map();
     visitKeyword_assignment_expr = (ctx) => {
@@ -162,11 +172,117 @@ export class ParserVisitor extends BaseVisitor {
         if (ctxNotPathBlock) {
             this.visit(ctxNotPathBlock);
         }
+        if (ctx.start && ctx.stop) {
+            const startToken = ctx.start;
+            const stopToken = ctx.stop;
+            const annotationKey = this.getRefdesFileAnnotation(this.getCurrentFile(), startToken.line, startToken.column, stopToken.line, stopToken.column);
+            if (this.refdesFileAnnotations.has(annotationKey)) {
+                let refdesValue = this.refdesFileAnnotations.get(annotationKey);
+                refdesValue = refdesValue.split(',')[0];
+                this.setCurrentComponentRefdes(refdesValue, true);
+            }
+        }
     };
     visitCreate_component_expr = (ctx) => {
         const scope = this.getScope();
+        scope.setOnPropertyHandler(this.createComponentPropertyValidator());
+        scope.enterContext(ctx);
+        ctx.property_expr().forEach(item => {
+            this.visitResult(item);
+        });
+        scope.exitContext();
+        scope.popOnPropertyHandler();
+        const properties = this.getPropertyExprList(ctx.property_expr());
+        let instanceName = this.getExecutor().getUniqueInstanceName();
+        const propParams = properties.get('params');
+        const params = this.parseCreateComponentParams(propParams);
+        if (params.length > 0) {
+            const firstParam = params[0];
+            const paramValue = firstParam.paramValue;
+            let appendValue = paramValue.toString();
+            if (paramValue instanceof NumericValue) {
+                appendValue = paramValue.value;
+            }
+            instanceName += `${Delimiter1}${appendValue}`;
+        }
+        const typeProp = properties.get('type') ?? null;
+        const copy = properties.get('copy') ?? false;
+        const unitDefinitions = this.extractComponentUnitProperties(properties, typeProp);
+        const props = {
+            type: typeProp,
+            copy,
+            units: unitDefinitions
+        };
+        try {
+            const createdComponent = this.getExecutor().createComponent(instanceName, [], params, props);
+            this.setResult(ctx, createdComponent);
+            createdComponent._creationIndex = this.componentCreationIndex++;
+        }
+        catch (error) {
+            this.throwWithContext(ctx, error.message);
+        }
+    };
+    extractComponentUnitDefinition(properties, typeProp = null, lastNumericPinId = 0) {
+        const width = properties.get('width') ?? null;
+        const height = properties.get('height') ?? null;
+        const angle = properties.get(ParamKeys.angle) ?? null;
+        const followWireOrientation = properties.get('followWireOrientation') ?? true;
+        const arrange = properties.get('arrange') ?? null;
+        const display = properties.get('display') ?? null;
+        const suffix = properties.get('suffix') ?? null;
+        let pins = [];
+        if (display !== null && arrange === null && typeProp !== TypeProps.Graphic) {
+            const drawCommands = display.getCommands();
+            drawCommands.forEach(command => {
+                const [commandValue,] = command;
+                if (commandValue === PlaceHolderCommands.vpin
+                    || commandValue === PlaceHolderCommands.hpin
+                    || commandValue === PlaceHolderCommands.pin) {
+                    const id = PinId.from(command[1][0]);
+                    const pinType = id.getType();
+                    const pinName = id.toString();
+                    pins.push(new PinDefinition(id, pinType, pinName, PinTypes.Any));
+                }
+            });
+        }
+        else {
+            pins = this.extractPinDefintion(properties.get('pins'), lastNumericPinId);
+        }
+        return {
+            width,
+            height,
+            angle,
+            followWireOrientation,
+            display, arrange,
+            pins,
+            suffix
+        };
+    }
+    extractComponentUnitProperties(properties, typeProp) {
+        let lastNumericPinId = 0;
+        const unitsProperties = [];
+        for (const [key, value] of properties) {
+            if (key.split(':')[0] === 'unit') {
+                const unitDef = this.extractComponentUnitDefinition(value, typeProp, lastNumericPinId);
+                unitDef.pins.forEach(pin => {
+                    if (pin.id.isNumeric()) {
+                        lastNumericPinId = Math.max(lastNumericPinId, pin.id.getValue());
+                    }
+                });
+                unitsProperties.push([key, unitDef]);
+            }
+        }
+        if (unitsProperties.length === 0) {
+            unitsProperties.push(['unit',
+                this.extractComponentUnitDefinition(properties, typeProp)]);
+        }
+        return unitsProperties;
+    }
+    createComponentPropertyValidator() {
         const definedPinIds = [];
         const arrangedPinIds = [];
+        let didDefineArrangeProp = false;
+        let didDefineDisplayProp = false;
         const checkPinExistsAndNotDuplicated = (pinId, ctx) => {
             if (definedPinIds.indexOf(pinId) === -1) {
                 this.warnings.push({
@@ -181,9 +297,7 @@ export class ParserVisitor extends BaseVisitor {
             }
             arrangedPinIds.push(pinId);
         };
-        let didDefineArrangeProp = false;
-        let didDefineDisplayProp = false;
-        scope.setOnPropertyHandler((path, value, ctx) => {
+        return (path, value, ctx) => {
             if (path.length === 1) {
                 const [, keyName] = path[0];
                 switch (keyName) {
@@ -292,76 +406,8 @@ export class ParserVisitor extends BaseVisitor {
                     }
                 }
             }
-        });
-        scope.enterContext(ctx);
-        ctx.property_expr().forEach(item => {
-            this.visitResult(item);
-        });
-        scope.exitContext();
-        scope.popOnPropertyHandler();
-        const properties = this.getPropertyExprList(ctx.property_expr());
-        let instanceName = this.getExecutor().getUniqueInstanceName();
-        const propParams = properties.get('params');
-        const params = this.parseCreateComponentParams(propParams);
-        if (params.length > 0) {
-            const firstParam = params[0];
-            const paramValue = firstParam.paramValue;
-            let appendValue = paramValue.toString();
-            if (paramValue instanceof NumericValue) {
-                appendValue = paramValue.value;
-            }
-            instanceName += `${Delimiter1}${appendValue}`;
-        }
-        const arrangeProp = properties.has('arrange') ?
-            properties.get('arrange') : null;
-        const displayProp = properties.has('display') ?
-            properties.get('display') : null;
-        const typeProp = 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 height = properties.has('height') ?
-            properties.get('height') : null;
-        const angle = properties.has(ParamKeys.angle) ?
-            properties.get(ParamKeys.angle) : null;
-        const followWireOrientation = properties.has('followWireOrientation') ?
-            properties.get('followWireOrientation') : true;
-        let pins = [];
-        if (displayProp !== null && arrangeProp === null
-            && typeProp !== TypeProps.Graphic) {
-            const drawCommands = displayProp.getCommands();
-            drawCommands.forEach(command => {
-                const [commandValue,] = command;
-                if (commandValue === PlaceHolderCommands.vpin
-                    || commandValue === PlaceHolderCommands.hpin
-                    || commandValue === PlaceHolderCommands.pin) {
-                    const id = PinId.from(command[1][0]);
-                    const pinType = id.getType();
-                    const pinName = id.toString();
-                    pins.push(new PinDefinition(id, pinType, pinName, PinTypes.Any));
-                }
-            });
-        }
-        else {
-            pins = this.parseCreateComponentPins(properties.get('pins'));
-        }
-        const props = {
-            arrange: arrangeProp,
-            display: displayProp,
-            type: typeProp, width, height, copy,
-            angle, followWireOrientation
         };
-        try {
-            const createdComponent = this.getExecutor().createComponent(instanceName, pins, params, props);
-            this.setResult(ctx, createdComponent);
-            createdComponent._creationIndex = this.componentCreationIndex++;
-        }
-        catch (error) {
-            this.throwWithContext(ctx, error.message);
-        }
-    };
+    }
     visitCreate_graphic_expr = (ctx) => {
         const ctxId = ctx.ID();
         const paramIds = [];
@@ -496,19 +542,18 @@ export class ParserVisitor extends BaseVisitor {
             return new PinDefinition(index + 1, PinIdType.Int, portName, PinTypes.Any);
         });
         const arrange = this.getArrangePropFromModulePorts(modulePorts, nameToPinId);
-        const width = properties.has('width') ?
-            properties.get('width') : null;
-        const height = properties.has('height') ?
-            properties.get('height') : null;
+        const unitProperties = this.extractComponentUnitProperties(properties, TypeProps.Module);
+        const firstUnitDef = unitProperties[0][1];
+        firstUnitDef.pins = tmpPorts;
+        firstUnitDef.arrange = arrange;
         const blankParams = [];
         const props = {
-            arrange, width, height,
             copy: false,
-            followWireOrientation: true,
+            units: unitProperties,
         };
         const moduleInstanceName = this.getExecutor().getUniqueInstanceName();
         const moduleComponent = this.getExecutor().createComponent(moduleInstanceName, tmpPorts, blankParams, props, true);
-        moduleComponent.typeProp = ComponentTypes.module;
+        moduleComponent.typeProp = TypeProps.Module;
         const ctxPropertyBlock = ctx.property_block_expr();
         if (ctxPropertyBlock) {
             const [firstBlock] = ctxPropertyBlock;
@@ -531,6 +576,10 @@ export class ParserVisitor extends BaseVisitor {
     visitProperty_expr = (ctx) => {
         const ctxKey = ctx.property_key_expr();
         const ctxValue = ctx.property_value_expr();
+        const extraValue = ctx._extra;
+        if (extraValue) {
+            console.log('extra', extraValue.text);
+        }
         const scope = this.getScope();
         this.getScope().enterContext(ctxKey);
         this.getScope().enterContext(ctxValue);
@@ -625,6 +674,7 @@ export class ParserVisitor extends BaseVisitor {
             dataResult = this.getExecutor().copyComponent(dataResult);
         }
         if (dataResult && dataResult instanceof ClassComponent) {
+            const defaultUnit = dataResult.getUnit();
             const modifiers = ctx.component_modifier_expr();
             modifiers.forEach(modifier => {
                 const modifierText = modifier.ID(0).getText();
@@ -641,23 +691,23 @@ export class ParserVisitor extends BaseVisitor {
                 if (modifierText === ParamKeys.flip) {
                     const flipValue = result;
                     if (flipValue.indexOf('x') !== -1) {
-                        dataResult.setParam(ParamKeys.flipX, 1);
+                        defaultUnit.setParam(ParamKeys.flipX, numeric(1));
                         shouldIgnoreWireOrientation = true;
                     }
                     if (flipValue.indexOf('y') !== -1) {
-                        dataResult.setParam(ParamKeys.flipY, 1);
+                        defaultUnit.setParam(ParamKeys.flipY, numeric(1));
                         shouldIgnoreWireOrientation = true;
                     }
                 }
                 else if (modifierText === ParamKeys.angle) {
-                    dataResult.setParam(ParamKeys.angle, result);
+                    defaultUnit.setParam(ParamKeys.angle, result);
                     shouldIgnoreWireOrientation = true;
                 }
                 else if (modifierText === 'anchor') {
                     dataResult.setParam('anchor', result);
                 }
                 if (shouldIgnoreWireOrientation) {
-                    dataResult.useWireOrientationAngle = false;
+                    defaultUnit.useWireOrientationAngle = false;
                 }
             });
         }
@@ -685,10 +735,8 @@ export class ParserVisitor extends BaseVisitor {
             + component.instanceName
             + Delimiter1 + component.moduleCounter;
         const tmpNamespace = this.getNetNamespace(netNamespace, "+/" + component.instanceName + Delimiter1 + component.moduleCounter);
-        const newExecutor = this.enterNewChildContext(executionStack, executor, executionContextName, { netNamespace: tmpNamespace }, [], []);
+        this.enterNewChildContext(executionStack, executor, executionContextName, { netNamespace: tmpNamespace }, [], []);
         component.moduleCounter += 1;
-        newExecutor.resolveNet = this.createNetResolver(executionStack);
-        newExecutor.resolveComponentPinNet = this.createComponentPinNetResolver(executionStack);
         this.visit(component.moduleContainsExpressions);
         const executionContext = executionStack.pop();
         component.moduleExecutionContext = executionContext;
@@ -886,7 +934,7 @@ export class ParserVisitor extends BaseVisitor {
     visitFunction_def_expr = (ctx) => {
         const functionName = ctx.ID().getText();
         const uniqueFunctionID = '__._' + ctx.start.line + '_'
-            + ctx.start.column + '_' + functionName + '_' + ctx.getText();
+            + ctx.start.column + '_' + functionName + '_' + this.environment.hashStringSHA256(ctx.getText());
         let funcDefinedParameters = [];
         const ctxFunctionArgsExpr = ctx.function_args_expr();
         if (ctxFunctionArgsExpr) {
@@ -898,54 +946,17 @@ export class ParserVisitor extends BaseVisitor {
         const resolveComponentPinNet = this.createComponentPinNetResolver(this.executionStack);
         const __runFunc = (passedInParameters, options) => {
             const executor = this.getExecutor();
-            const parentBreakContext = executor.getParentBreakContext();
-            executor.addBreakContext(ctx);
-            let useIndex = -1;
-            if (parentBreakContext === null) {
-                useIndex = options.functionCallIndex;
-            }
-            else {
-                const parentEntry = executor.indexedStack.get(parentBreakContext);
-                const { funcCallIndex } = parentEntry;
-                if (!funcCallIndex.has(ctx)) {
-                    funcCallIndex.set(ctx, 0);
-                    useIndex = 0;
-                }
-                else {
-                    useIndex = funcCallIndex.get(ctx) + 1;
-                    funcCallIndex.set(ctx, useIndex);
-                }
-            }
-            executor.setBreakContextIndex(useIndex);
             const functionCounterIndex = functionCounter['counter'];
-            const executionContextName = `${functionName}-${functionCounterIndex}`;
-            const newExecutor = this.enterNewChildContext(executionStack, this.getExecutor(), executionContextName, options, funcDefinedParameters, passedInParameters);
             functionCounter['counter'] += 1;
+            const executionContextName = `${functionName}-${functionCounterIndex}`;
+            const newExecutor = this.handleEnterContext(executor, executionStack, executionContextName, ctx, options, funcDefinedParameters, passedInParameters);
             newExecutor.resolveNet = resolveNet;
             newExecutor.resolveComponentPinNet = resolveComponentPinNet;
             const returnValue = this.runExpressions(newExecutor, ctx.function_expr());
-            const lastExecution = executionStack.pop();
-            const nextLastExecution = executionStack[executionStack.length - 1];
-            const mergedComponents = nextLastExecution.mergeScope(lastExecution.scope, executionContextName);
-            const scope = this.getScope();
-            const indexedStack = [];
-            if (scope.breakStack.length > 0) {
-                const executor = this.getExecutor();
-                scope.breakStack.forEach(stackCtx => {
-                    const entry = executor.indexedStack.get(stackCtx);
-                    const { index } = entry;
-                    indexedStack.push([stackCtx, index]);
-                });
-                mergedComponents.forEach(component => {
-                    component.ctxReferences.forEach(ref => {
-                        ref.indexedStack = [...indexedStack, ...ref.indexedStack];
-                    });
-                });
-            }
-            executor.popBreakContext();
+            const lastExecution = this.handlePopContext(executor, executionStack, executionContextName);
             return [lastExecution, returnValue];
         };
-        this.getExecutor().createFunction(functionName, __runFunc, ctx, uniqueFunctionID);
+        this.getExecutor().createFunction(this.getExecutor().namespace, functionName, __runFunc, ctx, uniqueFunctionID);
     };
     visitPin_select_expr2 = (ctx) => {
         const ctxStringValue = ctx.STRING_VALUE();
@@ -1235,17 +1246,21 @@ export class ParserVisitor extends BaseVisitor {
         }
         executor.popBreakContext();
     };
-    visitAnnotation_comment_expr = (ctx) => {
-        const refdesID = ctx.ID().getText();
+    setCurrentComponentRefdes(refdesValue, forceSave = false) {
         const currentComponent = this.getScope().currentComponent;
         if (currentComponent !== null) {
-            if (refdesID.indexOf('_') === -1) {
-                currentComponent.setParam('refdes', refdesID);
+            if (refdesValue.indexOf('_') === -1) {
+                currentComponent.setParam('refdes', refdesValue);
             }
             else {
-                currentComponent.placeHolderRefDes = refdesID;
+                currentComponent.placeHolderRefDes = refdesValue;
             }
+            currentComponent.forceSaveRefdesAnnotation = forceSave;
         }
+    }
+    visitAnnotation_comment_expr = (ctx) => {
+        const refdesID = ctx.ID().getText();
+        this.setCurrentComponentRefdes(refdesID);
     };
     visitPart_set_expr = (ctx) => {
         const paramKeys = ctx.data_expr().map(ctx => {
@@ -1360,6 +1375,28 @@ export class ParserVisitor extends BaseVisitor {
             children,
         });
     };
+    async checkModuleHasRefdesFile(filePath) {
+        const dir = this.environment.dirname(filePath);
+        const ext = this.environment.extname(filePath);
+        const basename = this.environment.basename(filePath, ext);
+        const annotatedFilePath = this.environment.join(dir, `${basename}${RefdesFileSuffix}`);
+        const exists = await this.environment.exists(annotatedFilePath);
+        if (exists) {
+            this.log(`Import has refdes file: ${annotatedFilePath}`);
+            const fileData = await this.environment.readFile(annotatedFilePath);
+            const jsonData = JSON.parse(fileData);
+            const baseFilePath = this.environment.getAbsolutePath(this.filePathStack[0]);
+            const basePathDirectory = this.environment.dirname(baseFilePath);
+            const { file, items } = jsonData;
+            for (const item of items) {
+                const parts = item.split(':');
+                const refdes = parts[4];
+                const useFilePath = this.environment.join(basePathDirectory, file);
+                const key = this.getRefdesFileAnnotation(useFilePath, Number(parts[0]), Number(parts[1]), Number(parts[2]), Number(parts[3]));
+                this.refdesFileAnnotations.set(key, refdes);
+            }
+        }
+    }
     resolveDataExpr(data_expr) {
         const value = this.visitResult(data_expr);
         if (value instanceof UndeclaredReference) {
@@ -1386,13 +1423,13 @@ export class ParserVisitor extends BaseVisitor {
         PinTypes.Output,
         PinTypes.Power,
     ];
-    parseCreateComponentPins(pinData) {
+    extractPinDefintion(pinData, lastNumericPinId = 0) {
         const pins = [];
         if (pinData instanceof NumericValue) {
             const tmpMap = new Map();
             const lastPin = pinData.toNumber();
             for (let i = 0; i < lastPin; i++) {
-                const pinId = i + 1;
+                const pinId = lastNumericPinId + i + 1;
                 tmpMap.set(pinId, numeric(pinId));
             }
             pinData = tmpMap;
@@ -1565,6 +1602,7 @@ export class ParserVisitor extends BaseVisitor {
                     const refdes = instance.getParam('refdes');
                     if (refdes) {
                         instance.assignedRefDes = refdes;
+                        this.setComponentUnitRefdesSuffix(instance);
                         annotater.trackRefDes(refdes);
                         this.log(refdes, '-', instance.instanceName);
                         continue;
@@ -1578,6 +1616,7 @@ export class ParserVisitor extends BaseVisitor {
             if (newRefDes !== null) {
                 instance.assignedRefDes = newRefDes;
                 this.log(newRefDes, '-', instance.instanceName);
+                this.setComponentUnitRefdesSuffix(instance);
             }
             else {
                 this.log('Failed to annotate:', instance.instanceName);
@@ -1588,6 +1627,24 @@ export class ParserVisitor extends BaseVisitor {
         this.renameNetsWithRefdes();
         this.log('===== rename nets done =====');
     }
+    setComponentUnitRefdesSuffix(instance) {
+        if (instance.assignedRefDes) {
+            const { units } = instance;
+            if (units.length > 1) {
+                units.forEach((unit, index) => {
+                    let useRefdes = String.fromCharCode("A".charCodeAt(0) + index);
+                    if (unit.suffix !== null) {
+                        useRefdes = unit.suffix;
+                    }
+                    unit.refdesSuffix = useRefdes;
+                });
+            }
+            else {
+                const [firstUnit] = units;
+                firstUnit.refdesSuffix = '';
+            }
+        }
+    }
     renameNetsWithRefdes() {
         const nets = this.getScope().getNets();
         const seenNets = [];
@@ -1646,10 +1703,17 @@ export class ParserVisitor extends BaseVisitor {
     }
     getPropertyExprList(items) {
         const properties = new Map();
+        const keyCounter = new Map();
         items.forEach((item) => {
             const result = this.visitResult(item);
             for (const [key, value] of result) {
-                properties.set(key, value);
+                let useKey = key;
+                const counterValue = keyCounter.get(key) ?? 0;
+                keyCounter.set(key, counterValue + 1);
+                if (counterValue > 0) {
+                    useKey = key + ':' + counterValue;
+                }
+                properties.set(useKey, value);
             }
         });
         return properties;

package/dist/types/BaseVisitor.d.ts

@@ -1,24 +1,25 @@
-import { Array_exprContext, ArrayExprContext, ArrayIndexExprContext, Assignment_exprContext, Atom_exprContext, ExpressionContext, Flow_expressionsContext, Function_args_exprContext, Function_call_exprContext, Function_exprContext, Function_return_exprContext, FunctionCallExprContext, Import_exprContext, Operator_assignment_exprContext, ParametersContext, RoundedBracketsExprContext, ScriptContext, Trailer_expr2Context, Value_exprContext, ValueAtomExprContext } from "./antlr/CircuitScriptParser.js";
+import { Array_exprContext, ArrayExprContext, ArrayIndexExprContext, Assignment_exprContext, Atom_exprContext, ExpressionContext, Flow_expressionsContext, Function_args_exprContext, Function_call_exprContext, Function_exprContext, Function_return_exprContext, FunctionCallExprContext, Import_all_simpleContext, Import_exprContext, Import_simpleContext, Import_specificContext, Operator_assignment_exprContext, ParametersContext, RoundedBracketsExprContext, ScriptContext, Trailer_expr2Context, Value_exprContext, ValueAtomExprContext } from "./antlr/CircuitScriptParser.js";
 import { CircuitScriptVisitor } from "./antlr/CircuitScriptVisitor.js";
 import { ExecutionContext } from "./execute.js";
 import { Logger } from "./logger.js";
 import { ClassComponent } from "./objects/ClassComponent.js";
 import { Net } from "./objects/Net.js";
-import { CallableParameter, CFunctionOptions, ComplexType, Direction, FunctionDefinedParameter, AnyReference } from "./objects/types.js";
-import { ParserRuleContext } from 'antlr4ng';
+import { CallableParameter, ComplexType, Direction, FunctionDefinedParameter, AnyReference, ImportedModule, NewContextOptions, ImportFunctionHandling as ImportFunctionHandling } from "./objects/types.js";
+import { CommonTokenStream, ParserRuleContext } from 'antlr4ng';
 import { ExecutionWarning } from "./utils.js";
 import { BaseError } from './utils.js';
 import { ExecutionScope } from './objects/ExecutionScope.js';
 import { NodeScriptEnvironment } from "./environment.js";
 import { PinId } from './objects/PinDefinition.js';
 export declare class BaseVisitor extends CircuitScriptVisitor<ComplexType | AnyReference | any> {
-    indentLevel: number;
     startingContext: ExecutionContext;
     executionStack: ExecutionContext[];
+    filePathStack: string[];
     silent: boolean;
     logger: Logger;
     printStream: string[];
     printToConsole: boolean;
+    allowParseImports: boolean;
     acceptedDirections: Direction[];
     protected resultData: Map<ParserRuleContext, any>;
     protected componentCtxLinks: Map<ParserRuleContext, ClassComponent>;
@@ -27,10 +28,8 @@ export declare class BaseVisitor extends CircuitScriptVisitor<ComplexType | AnyR
     environment: NodeScriptEnvironment;
     protected importedFiles: ImportFile[];
     protected warnings: ExecutionWarning[];
-    onImportFile: (visitor: BaseVisitor, filePath: string, fileData: string, onErrorHandler: OnErrorHandler) => Promise<{
-        hasError: boolean;
-        hasParseError: boolean;
-    }>;
+    onImportFile: (visitor: BaseVisitor, filePath: string, fileData: string, onErrorHandler: OnErrorHandler) => Promise<ImportFileResult>;
+    refdesFileAnnotations: Map<string, string>;
     constructor(silent: boolean | undefined, onErrorHandler: OnErrorHandler | null | undefined, environment: NodeScriptEnvironment);
     getExecutor(): ExecutionContext;
     getScope(): ExecutionScope;
@@ -45,6 +44,10 @@ export declare class BaseVisitor extends CircuitScriptVisitor<ComplexType | AnyR
     log2(message: string): void;
     visitAsync(ctx: ParserRuleContext): Promise<void>;
     visitScript: (ctx: ScriptContext) => Promise<void>;
+    private importCommon;
+    visitImport_simple: (ctx: Import_simpleContext) => Promise<void>;
+    visitImport_all_simple: (ctx: Import_all_simpleContext) => Promise<void>;
+    visitImport_specific: (ctx: Import_specificContext) => Promise<void>;
     visitAssignment_expr: (ctx: Assignment_exprContext) => void;
     visitOperator_assignment_expr: (ctx: Operator_assignment_exprContext) => void;
     private getReference;
@@ -53,6 +56,8 @@ export declare class BaseVisitor extends CircuitScriptVisitor<ComplexType | AnyR
     visitFunctionCallExpr: (ctx: FunctionCallExprContext) => void;
     visitFunction_call_expr: (ctx: Function_call_exprContext) => void;
     private handleFunctionCall;
+    protected handleEnterContext(executor: ExecutionContext, executionStack: ExecutionContext[], contextName: string, ctx: ParserRuleContext, options: NewContextOptions, funcDefinedParameters: FunctionDefinedParameter[], passedInParameters: CallableParameter[], isBreakContext?: boolean): ExecutionContext;
+    protected handlePopContext(executor: ExecutionContext, executionStack: ExecutionContext[], namespaceExtension: string, isBreakContext?: boolean): ExecutionContext;
     visitValue_expr: (ctx: Value_exprContext) => void;
     visitValueAtomExpr: (ctx: ValueAtomExprContext) => void;
     visitFunction_args_expr: (ctx: Function_args_exprContext) => void;
@@ -68,20 +73,25 @@ export declare class BaseVisitor extends CircuitScriptVisitor<ComplexType | AnyR
     protected linkComponentToCtx(ctx: ParserRuleContext, instance: ClassComponent, creationFlag?: boolean): void;
     getComponentCtxLinks(): Map<ParserRuleContext, ClassComponent>;
     visitResult(ctx: ParserRuleContext): any;
-    protected handleImportFile(name: string, throwErrors?: boolean, ctx?: ParserRuleContext | null): Promise<ImportFile>;
+    protected handleImportFile(name: string, importHandling: ImportFunctionHandling, throwErrors?: boolean, ctx?: ParserRuleContext | null, specificImports?: string[]): Promise<ImportFile>;
+    checkModuleHasRefdesFile(filePath: string): Promise<void>;
+    getRefdesFileAnnotation(filePath: string, startLine: number, startColumn: number, stopLine: number, stopColumn: number): string;
     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 getInstanceParam<T>(object: ClassComponent, trailers: string[]): T;
-    protected enterNewChildContext(executionStack: ExecutionContext[], parentContext: ExecutionContext, executionContextName: string, options: CFunctionOptions, funcDefinedParameters: FunctionDefinedParameter[], passedInParameters: CallableParameter[]): ExecutionContext;
+    protected enterNewChildContext(executionStack: ExecutionContext[], parentContext: ExecutionContext, executionContextName: string, options: NewContextOptions, funcDefinedParameters: FunctionDefinedParameter[], passedInParameters: CallableParameter[]): ExecutionContext;
     protected prepareStringValue(value: string): string;
     protected throwWithContext(context: ParserRuleContext, messageOrError: string | BaseError): void;
     protected validateType(value: any, context: ParserRuleContext, validateFunction: (value: any) => boolean, expectedType: string): boolean;
     protected validateString(value: any, context: ParserRuleContext): void;
     protected validateBoolean(value: any, context: ParserRuleContext): void;
     protected validateNumeric(value: any, context: ParserRuleContext): void;
+    enterFile(filePath: string): void;
+    exitFile(): void;
+    getCurrentFile(): string;
 }
 export type OnErrorHandler = (message: string, context: ParserRuleContext, e?: any) => void;
 type ImportFile = {
@@ -89,5 +99,12 @@ type ImportFile = {
     hasError: boolean;
     hasParseError: boolean;
     pathExists: boolean;
+    importedModule: ImportedModule;
+};
+export type ImportFileResult = {
+    hasError: boolean;
+    hasParseError: boolean;
+    tree: ScriptContext;
+    tokens: CommonTokenStream;
 };
 export {};

package/dist/types/RefdesAnnotationVisitor.d.ts

@@ -27,9 +27,11 @@ export declare class RefdesAnnotationVisitor extends BaseVisitor {
     private generateRefdesAnnotationComment;
     private addRefdesAnnotationComment;
     getOutput(): string;
+    getOutputForExternalRefdesFile(): string[];
     private generateModifiedText;
     private buildContextTokenRanges;
     private findContextForToken;
     private markTokensAsProcessed;
     private log;
+    private generateReplacementText;
 }