circuitscript 0.1.29 → 0.1.32

package/dist/esm/objects/types.js

@@ -2,11 +2,15 @@ import { ReferenceTypes } from '../globals.js';
 import { RuntimeExecutionError } from '../utils.js';
 export class CFunctionEntry {
     name;
+    namespace;
+    originalNamespace;
     execute;
     uniqueId;
     source;
-    constructor(name, execute, source, uniqueId) {
+    constructor(namespace, name, execute, source, uniqueId) {
         this.name = name;
+        this.namespace = namespace;
+        this.originalNamespace = namespace;
         this.execute = execute;
         this.uniqueId = uniqueId;
         this.source = source;
@@ -124,3 +128,31 @@ export var NetTypes;
     NetTypes["Any"] = "any";
     NetTypes["Source"] = "source";
 })(NetTypes || (NetTypes = {}));
+export class ImportedModule {
+    moduleName;
+    context;
+    importHandlingFlag;
+    specifiedImports;
+    moduleNamespace;
+    moduleFilePath;
+    enableRefdesAnnotation = false;
+    enableRefdesAnnotationFile = false;
+    tree;
+    tokens;
+    constructor(moduleName, moduleNamespace, moduleFilePath, tree, tokens, context, flag, specifiedImports) {
+        this.moduleName = moduleName;
+        this.moduleNamespace = moduleNamespace;
+        this.moduleFilePath = moduleFilePath;
+        this.tree = tree;
+        this.tokens = tokens;
+        this.context = context;
+        this.importHandlingFlag = flag;
+        this.specifiedImports = specifiedImports;
+    }
+}
+export var ImportFunctionHandling;
+(function (ImportFunctionHandling) {
+    ImportFunctionHandling["AllWithNamespace"] = "all-with-namespace";
+    ImportFunctionHandling["AllMergeIntoNamespace"] = "all-merge-into-namespace";
+    ImportFunctionHandling["SpecificMergeIntoNamespace"] = "specific-merge-into-namespace";
+})(ImportFunctionHandling || (ImportFunctionHandling = {}));

package/dist/esm/parser.js

@@ -19,6 +19,8 @@ export async function parseFileWithVisitor(visitor, data) {
     parser.addErrorListener(parserErrorListener);
     const tree = parser.script();
     let throwError;
+    let hasError = false;
+    let hasParseError = false;
     try {
         await visitor.visitAsync(tree);
     }
@@ -31,13 +33,15 @@ export async function parseFileWithVisitor(visitor, data) {
                 throwError = error;
             }
         }
+        hasError = true;
+        hasParseError = true;
     }
     const parserTimeTaken = parserTimer.lap();
     return {
         tree, parser,
         tokens,
-        hasParseError: false,
-        hasError: false,
+        hasParseError,
+        hasError,
         parserTimeTaken,
         lexerTimeTaken,
         throwError

package/dist/esm/regenerate-tests.js

@@ -1,7 +1,7 @@
 import fs from 'fs';
 import { renderScript } from './helpers.js';
 import { NodeScriptEnvironment } from "./environment.js";
-const mainDir = './__tests__/renderData/';
+const mainDir = './__tests__/testData/renderData/';
 const env = new NodeScriptEnvironment();
 NodeScriptEnvironment.setInstance(env);
 async function regenerateTests(extra = "") {
@@ -9,7 +9,7 @@ async function regenerateTests(extra = "") {
     const cstFiles = [];
     const files = fs.readdirSync(mainDir);
     files.forEach(file => {
-        if (file.endsWith('.cst')) {
+        if (file.endsWith('.cst') && file.startsWith('script')) {
             cstFiles.push(file);
         }
     });
@@ -19,7 +19,7 @@ async function regenerateTests(extra = "") {
         const scriptData = fs.readFileSync(inputPath, { encoding: 'utf-8' });
         const outputPath = mainDir + 'svgs/' + file + extra + '.svg';
         env.setModuleDirectory(mainDir);
-        env.setDefaultLibsPath(mainDir + '../../libs/');
+        env.setDefaultLibsPath(mainDir + '../../../libs/');
         await renderScript(scriptData, outputPath, {
             dumpNets: false,
             dumpData: false,

package/dist/esm/render.js

@@ -36,10 +36,11 @@ export function renderSheetsToSVG(sheetFrames, logger) {
             const frameComponent = sheet.frame.frame.parameters
                 .get(FrameParamKeys.SheetType);
             if (frameComponent) {
-                if (frameComponent.displayProp === null) {
+                const frameComponentUnit = frameComponent.getUnit();
+                if (frameComponentUnit.displayProp === null) {
                     throw 'Invalid graphic object for sheet frame';
                 }
-                const frameRects = ExtractDrawingRects(frameComponent.displayProp) ?? [];
+                const frameRects = ExtractDrawingRects(frameComponentUnit.displayProp) ?? [];
                 let originalWidthMM = numeric(0);
                 let originalHeightMM = numeric(0);
                 let widthMM = numeric(0);
@@ -325,7 +326,8 @@ function drawSheetFrameBorder(frameGroup, frame) {
     const frameParams = frame.frame.parameters;
     if (frameParams.has(FrameParamKeys.SheetType)) {
         const frameComponent = frameParams.get(FrameParamKeys.SheetType);
-        const { displayProp = null } = frameComponent ?? {};
+        const frameComponentUnit = frameComponent.getUnit();
+        const { displayProp = null } = frameComponentUnit ?? {};
         if (displayProp) {
             const sheetFrameGroup = frameGroup.group();
             const symbol = new SymbolPlaceholder(displayProp);

package/dist/esm/rules-check/no-connect-on-connected-pin.js

@@ -8,25 +8,26 @@ export function RuleCheck_NoConnectOnConnectedPin(graph, nets) {
     const makeComponentPinHash = (instanceName, pin) => {
         return instanceName + '-' + pin.getHashValue();
     };
-    nets.forEach(item => {
-        const [component, pin, net] = item;
+    for (const [component, pin, net] of nets) {
         if (!netComponentPins.has(net)) {
             netComponentPins.set(net, []);
         }
         const items = netComponentPins.get(net);
+        const unit = component.getUnitForPin(pin);
         items.push([
-            component.instanceName,
+            unit.instanceName,
             pin
         ]);
         netComponentPins.set(net, items);
-        pinMapping.set(makeComponentPinHash(component.instanceName, pin), net);
-    });
-    allNodes.forEach(node => {
+        pinMapping.set(makeComponentPinHash(unit.instanceName, pin), net);
+    }
+    ;
+    for (const node of allNodes) {
         const nodeInfo = graph.node(node);
         if (nodeInfo[0] === RenderItemType.Component) {
             const { component } = nodeInfo[1];
             if (component.hasParam('no_connect')) {
-                const instanceName = component.instanceName;
+                const instanceName = component.getUnit().instanceName;
                 const edges = graph.nodeEdges(node);
                 const otherNodes = [];
                 edges.forEach(edge => {
@@ -72,6 +73,6 @@ export function RuleCheck_NoConnectOnConnectedPin(graph, nets) {
                 });
             }
         }
-    });
+    }
     return items;
 }

package/dist/esm/rules-check/rules.js

@@ -22,7 +22,7 @@ export function EvaluateERCRules(visitor, graph, nets) {
                         reportItems.push({
                             type,
                             start: token,
-                            message: `Unconnected pin ${item.pin} for component`
+                            message: `Unconnected pin: ${instance.assignedRefDes} pin ${item.pin}`
                         });
                     }
                 }
@@ -44,12 +44,17 @@ export function EvaluateERCRules(visitor, graph, nets) {
             case ERC_Rules.NoConnectOnConnectedPin:
                 {
                     const instance = item.instance;
+                    const { instance: targetComponent, pin: targetPin } = item.target;
+                    let extra = '';
+                    if (targetComponent && targetComponent.assignedRefDes) {
+                        extra = `: ${targetComponent.assignedRefDes} pin ${targetPin}`;
+                    }
                     const token = getComponentFirstCtxToken(instance);
                     if (token) {
                         reportItems.push({
                             type,
                             start: token,
-                            message: `No connect on connected pin`
+                            message: `No connect on connected pin${extra}`
                         });
                     }
                 }

package/dist/esm/rules-check/unconnected-pins.js

@@ -3,13 +3,15 @@ import { ERC_Rules } from "./rules.js";
 export function RuleCheck_UnconnectedPinsWires(graph) {
     const items = [];
     const allNodes = graph.nodes();
-    allNodes.forEach(node => {
+    for (const node of allNodes) {
         const nodeInfo = graph.node(node);
         if (nodeInfo[0] === RenderItemType.Component) {
-            const { component } = nodeInfo[1];
+            const renderComponent = nodeInfo[1];
+            const { component, unitId } = renderComponent;
             const edges = graph.nodeEdges(node);
-            const instanceName = component.instanceName;
-            const connectedPins = [];
+            const componentUnit = component.getUnit(unitId);
+            const instanceName = componentUnit.instanceName;
+            const connectedUnitPins = [];
             edges.forEach(edge => {
                 const edgeInfo = graph.edge(edge.v, edge.w);
                 let pin;
@@ -19,12 +21,12 @@ export function RuleCheck_UnconnectedPinsWires(graph) {
                 else if (edge.w === instanceName) {
                     pin = edgeInfo[3];
                 }
-                connectedPins.push(pin.getHashValue());
+                connectedUnitPins.push(pin.getHashValue());
             });
-            const pinIds = Array.from(component.pins.keys());
+            const pinIds = Array.from(componentUnit.pins.keys());
             pinIds.forEach(pinId => {
                 const hashValue = pinId.getHashValue();
-                if (connectedPins.indexOf(hashValue) === -1) {
+                if (connectedUnitPins.indexOf(hashValue) === -1) {
                     items.push({
                         type: ERC_Rules.UnconnectedPin,
                         instance: component,
@@ -43,6 +45,6 @@ export function RuleCheck_UnconnectedPinsWires(graph) {
                 });
             }
         }
-    });
+    }
     return items;
 }

package/dist/esm/utils.js

@@ -58,7 +58,8 @@ export function getBoundsSize(bounds) {
     };
 }
 export function getPortType(component) {
-    const drawingCommands = component.displayProp;
+    const targetUnit = component.getUnit();
+    const drawingCommands = targetUnit.displayProp;
     let foundPinType = null;
     const commands = drawingCommands.getCommands();
     commands.some(item => {

package/dist/esm/validate/SymbolTable.js

@@ -88,3 +88,8 @@ export class SymbolTable {
         }
     }
 }
+export function cloneSymbol(symbol) {
+    return {
+        ...symbol
+    };
+}

package/dist/esm/validate/SymbolValidatorVisitor.js

@@ -1,20 +1,12 @@
+import { Import_specificContext } from "../antlr/CircuitScriptParser.js";
 import { buildInMethodNamesList } from "../builtinMethods.js";
-import { ParseSymbolType } from "../objects/types.js";
+import { ImportFunctionHandling, ParseSymbolType } from "../objects/types.js";
+import { cloneSymbol } from "./SymbolTable.js";
 import { SymbolTable } from "./SymbolTable.js";
 import { BaseVisitor } from "../BaseVisitor.js";
-import { SymbolValidatorContext } from "../globals.js";
+import { BaseNamespace, SymbolValidatorContext } from "../globals.js";
 export class SymbolValidatorVisitor extends BaseVisitor {
     symbolTable = new SymbolTable();
-    filePathStack = [];
-    enterFile(filePath) {
-        this.filePathStack.push(filePath);
-    }
-    exitFile() {
-        this.filePathStack.pop();
-    }
-    getCurrentFile() {
-        return this.filePathStack[this.filePathStack.length - 1];
-    }
     addSymbolVariable(token, name, value, executor = null) {
         const useExecutor = executor === null ? this.getExecutor() : executor;
         this.symbolTable.addVariable(token, this.getCurrentFile(), useExecutor, name, value);
@@ -62,13 +54,58 @@ export class SymbolValidatorVisitor extends BaseVisitor {
     setSymbols(symbolTable) {
         this.symbolTable = symbolTable;
     }
-    visitImport_expr = (ctx) => {
-        const ID = ctx.ID().toString();
-        const { pathExists } = this.handleImportFile(ID, false, ctx);
+    async importCommon(ctx, handling) {
+        const specifiedImports = [];
+        if (ctx instanceof Import_specificContext) {
+            const tmpImports = ctx._funcNames.map(item => {
+                return item.text;
+            });
+            specifiedImports.push(...tmpImports);
+        }
+        const id = ctx._moduleName.text;
+        const { pathExists, importedModule } = await this.handleImportFile(id, handling, true, ctx, specifiedImports);
         if (!pathExists) {
-            this.symbolTable.addUndefined(this.getCurrentFile(), this.getExecutor(), ID, ctx.ID().getSymbol());
+            this.symbolTable.addUndefined(this.getCurrentFile(), this.getExecutor(), id, ctx._moduleName);
         }
+        else {
+            this.applyModuleImports(importedModule);
+        }
+    }
+    visitImport_simple = async (ctx) => {
+        await this.importCommon(ctx, ImportFunctionHandling.AllWithNamespace);
+    };
+    visitImport_all_simple = async (ctx) => {
+        await this.importCommon(ctx, ImportFunctionHandling.AllMergeIntoNamespace);
     };
+    visitImport_specific = async (ctx) => {
+        await this.importCommon(ctx, ImportFunctionHandling.SpecificMergeIntoNamespace);
+    };
+    applyModuleImports(module) {
+        const { importHandlingFlag: importHandling, specifiedImports } = module;
+        const addedSymbols = [];
+        const executor = this.getExecutor();
+        const symbolTable = this.symbolTable.getSymbols();
+        symbolTable.forEach((value, key) => {
+            if (value.type === ParseSymbolType.Function) {
+                const definedSymbol = value;
+                if (definedSymbol.fileName === module.moduleFilePath) {
+                    const addSymbolToNamespace = importHandling === ImportFunctionHandling.AllMergeIntoNamespace
+                        || (importHandling === ImportFunctionHandling.SpecificMergeIntoNamespace
+                            && specifiedImports.indexOf(definedSymbol.id) !== -1);
+                    if (addSymbolToNamespace) {
+                        const funcPath = `${BaseNamespace}${definedSymbol.id}`;
+                        const tmpSymbol = cloneSymbol(value);
+                        tmpSymbol.context = executor;
+                        addedSymbols.push([funcPath, tmpSymbol]);
+                    }
+                }
+            }
+        });
+        addedSymbols.forEach(item => {
+            const [key, value] = item;
+            symbolTable.set(key, value);
+        });
+    }
     visitAssignment_expr = (ctx) => {
         const ctxDataExpr = ctx.data_expr();
         this.visit(ctxDataExpr);