circuitscript 0.1.29 → 0.1.32

package/dist/cjs/objects/types.js

@@ -1,11 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.NetTypes = exports.TypeProps = exports.Direction = exports.ParseSymbolType = exports.DeclaredReference = exports.UndeclaredReference = exports.AnyReference = exports.CFunctionEntry = void 0;
+exports.ImportFunctionHandling = exports.ImportedModule = exports.NetTypes = exports.TypeProps = exports.Direction = exports.ParseSymbolType = exports.DeclaredReference = exports.UndeclaredReference = exports.AnyReference = exports.CFunctionEntry = void 0;
 const globals_js_1 = require("../globals.js");
 const utils_js_1 = require("../utils.js");
 class CFunctionEntry {
-    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;
@@ -125,3 +127,24 @@ var NetTypes;
     NetTypes["Any"] = "any";
     NetTypes["Source"] = "source";
 })(NetTypes || (exports.NetTypes = NetTypes = {}));
+class ImportedModule {
+    constructor(moduleName, moduleNamespace, moduleFilePath, tree, tokens, context, flag, specifiedImports) {
+        this.enableRefdesAnnotation = false;
+        this.enableRefdesAnnotationFile = false;
+        this.moduleName = moduleName;
+        this.moduleNamespace = moduleNamespace;
+        this.moduleFilePath = moduleFilePath;
+        this.tree = tree;
+        this.tokens = tokens;
+        this.context = context;
+        this.importHandlingFlag = flag;
+        this.specifiedImports = specifiedImports;
+    }
+}
+exports.ImportedModule = ImportedModule;
+var ImportFunctionHandling;
+(function (ImportFunctionHandling) {
+    ImportFunctionHandling["AllWithNamespace"] = "all-with-namespace";
+    ImportFunctionHandling["AllMergeIntoNamespace"] = "all-merge-into-namespace";
+    ImportFunctionHandling["SpecificMergeIntoNamespace"] = "specific-merge-into-namespace";
+})(ImportFunctionHandling || (exports.ImportFunctionHandling = ImportFunctionHandling = {}));

package/dist/cjs/parser.js

@@ -22,6 +22,8 @@ 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);
     }
@@ -34,13 +36,15 @@ 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/cjs/regenerate-tests.js

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const fs_1 = __importDefault(require("fs"));
 const helpers_js_1 = require("./helpers.js");
 const environment_js_1 = require("./environment.js");
-const mainDir = './__tests__/renderData/';
+const mainDir = './__tests__/testData/renderData/';
 const env = new environment_js_1.NodeScriptEnvironment();
 environment_js_1.NodeScriptEnvironment.setInstance(env);
 async function regenerateTests(extra = "") {
@@ -14,7 +14,7 @@ async function regenerateTests(extra = "") {
     const cstFiles = [];
     const files = fs_1.default.readdirSync(mainDir);
     files.forEach(file => {
-        if (file.endsWith('.cst')) {
+        if (file.endsWith('.cst') && file.startsWith('script')) {
             cstFiles.push(file);
         }
     });
@@ -24,7 +24,7 @@ async function regenerateTests(extra = "") {
         const scriptData = fs_1.default.readFileSync(inputPath, { encoding: 'utf-8' });
         const outputPath = mainDir + 'svgs/' + file + extra + '.svg';
         env.setModuleDirectory(mainDir);
-        env.setDefaultLibsPath(mainDir + '../../libs/');
+        env.setDefaultLibsPath(mainDir + '../../../libs/');
         await (0, helpers_js_1.renderScript)(scriptData, outputPath, {
             dumpNets: false,
             dumpData: false,

package/dist/cjs/render.js

@@ -42,10 +42,11 @@ function renderSheetsToSVG(sheetFrames, logger) {
             const frameComponent = sheet.frame.frame.parameters
                 .get(Frame_js_1.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 = (0, layout_js_1.ExtractDrawingRects)(frameComponent.displayProp) ?? [];
+                const frameRects = (0, layout_js_1.ExtractDrawingRects)(frameComponentUnit.displayProp) ?? [];
                 let originalWidthMM = (0, ParamDefinition_js_1.numeric)(0);
                 let originalHeightMM = (0, ParamDefinition_js_1.numeric)(0);
                 let widthMM = (0, ParamDefinition_js_1.numeric)(0);
@@ -334,7 +335,8 @@ function drawSheetFrameBorder(frameGroup, frame) {
     const frameParams = frame.frame.parameters;
     if (frameParams.has(Frame_js_1.FrameParamKeys.SheetType)) {
         const frameComponent = frameParams.get(Frame_js_1.FrameParamKeys.SheetType);
-        const { displayProp = null } = frameComponent ?? {};
+        const frameComponentUnit = frameComponent.getUnit();
+        const { displayProp = null } = frameComponentUnit ?? {};
         if (displayProp) {
             const sheetFrameGroup = frameGroup.group();
             const symbol = new draw_symbols_js_1.SymbolPlaceholder(displayProp);

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

@@ -11,25 +11,26 @@ 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] === graph_js_1.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 => {
@@ -75,7 +76,7 @@ function RuleCheck_NoConnectOnConnectedPin(graph, nets) {
                 });
             }
         }
-    });
+    }
     return items;
 }
 exports.RuleCheck_NoConnectOnConnectedPin = RuleCheck_NoConnectOnConnectedPin;

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

@@ -25,7 +25,7 @@ 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}`
                         });
                     }
                 }
@@ -47,12 +47,17 @@ 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/cjs/rules-check/unconnected-pins.js

@@ -6,13 +6,15 @@ const rules_js_1 = require("./rules.js");
 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] === graph_js_1.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;
@@ -22,12 +24,12 @@ 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: rules_js_1.ERC_Rules.UnconnectedPin,
                         instance: component,
@@ -46,7 +48,7 @@ function RuleCheck_UnconnectedPinsWires(graph) {
                 });
             }
         }
-    });
+    }
     return items;
 }
 exports.RuleCheck_UnconnectedPinsWires = RuleCheck_UnconnectedPinsWires;

package/dist/cjs/utils.js

@@ -66,7 +66,8 @@ function getBoundsSize(bounds) {
 }
 exports.getBoundsSize = getBoundsSize;
 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/cjs/validate/SymbolTable.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SymbolTable = void 0;
+exports.cloneSymbol = exports.SymbolTable = void 0;
 const types_js_1 = require("../objects/types.js");
 class SymbolTable {
     constructor() {
@@ -94,3 +94,9 @@ class SymbolTable {
     }
 }
 exports.SymbolTable = SymbolTable;
+function cloneSymbol(symbol) {
+    return {
+        ...symbol
+    };
+}
+exports.cloneSymbol = cloneSymbol;

package/dist/cjs/validate/SymbolValidatorVisitor.js

@@ -1,22 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SymbolValidatorVisitor = void 0;
+const CircuitScriptParser_js_1 = require("../antlr/CircuitScriptParser.js");
 const builtinMethods_js_1 = require("../builtinMethods.js");
 const types_js_1 = require("../objects/types.js");
 const SymbolTable_js_1 = require("./SymbolTable.js");
+const SymbolTable_js_2 = require("./SymbolTable.js");
 const BaseVisitor_js_1 = require("../BaseVisitor.js");
 const globals_js_1 = require("../globals.js");
 class SymbolValidatorVisitor extends BaseVisitor_js_1.BaseVisitor {
     constructor() {
         super(...arguments);
-        this.symbolTable = new SymbolTable_js_1.SymbolTable();
-        this.filePathStack = [];
-        this.visitImport_expr = (ctx) => {
-            const ID = ctx.ID().toString();
-            const { pathExists } = this.handleImportFile(ID, false, ctx);
-            if (!pathExists) {
-                this.symbolTable.addUndefined(this.getCurrentFile(), this.getExecutor(), ID, ctx.ID().getSymbol());
-            }
+        this.symbolTable = new SymbolTable_js_2.SymbolTable();
+        this.visitImport_simple = async (ctx) => {
+            await this.importCommon(ctx, types_js_1.ImportFunctionHandling.AllWithNamespace);
+        };
+        this.visitImport_all_simple = async (ctx) => {
+            await this.importCommon(ctx, types_js_1.ImportFunctionHandling.AllMergeIntoNamespace);
+        };
+        this.visitImport_specific = async (ctx) => {
+            await this.importCommon(ctx, types_js_1.ImportFunctionHandling.SpecificMergeIntoNamespace);
         };
         this.visitAssignment_expr = (ctx) => {
             const ctxDataExpr = ctx.data_expr();
@@ -109,15 +112,6 @@ class SymbolValidatorVisitor extends BaseVisitor_js_1.BaseVisitor {
             });
         };
     }
-    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);
@@ -165,6 +159,49 @@ class SymbolValidatorVisitor extends BaseVisitor_js_1.BaseVisitor {
     setSymbols(symbolTable) {
         this.symbolTable = symbolTable;
     }
+    async importCommon(ctx, handling) {
+        const specifiedImports = [];
+        if (ctx instanceof CircuitScriptParser_js_1.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._moduleName);
+        }
+        else {
+            this.applyModuleImports(importedModule);
+        }
+    }
+    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 === types_js_1.ParseSymbolType.Function) {
+                const definedSymbol = value;
+                if (definedSymbol.fileName === module.moduleFilePath) {
+                    const addSymbolToNamespace = importHandling === types_js_1.ImportFunctionHandling.AllMergeIntoNamespace
+                        || (importHandling === types_js_1.ImportFunctionHandling.SpecificMergeIntoNamespace
+                            && specifiedImports.indexOf(definedSymbol.id) !== -1);
+                    if (addSymbolToNamespace) {
+                        const funcPath = `${globals_js_1.BaseNamespace}${definedSymbol.id}`;
+                        const tmpSymbol = (0, SymbolTable_js_1.cloneSymbol)(value);
+                        tmpSymbol.context = executor;
+                        addedSymbols.push([funcPath, tmpSymbol]);
+                    }
+                }
+            }
+        });
+        addedSymbols.forEach(item => {
+            const [key, value] = item;
+            symbolTable.set(key, value);
+        });
+    }
     getSymbols() {
         return this.symbolTable;
     }