circuitscript 0.1.7 → 0.1.9

package/dist/esm/layout.js

@@ -1,8 +1,8 @@
-import pkg from '@dagrejs/graphlib';
-const { Graph, alg } = pkg;
+import graphlib, { Graph } from '@dagrejs/graphlib';
+const { alg } = graphlib;
 import { SymbolCustom, SymbolDrawing, SymbolCustomModule, SymbolPlaceholder, SymbolText, PlaceHolderCommands } from "./draw_symbols.js";
 import { FrameAction, SequenceAction } from "./objects/ExecutionScope.js";
-import { ComponentTypes, defaultFrameTitleTextSize, defaultGridSizeUnits, FrameType, ParamKeys, SymbolPinSide, WireAutoDirection } from './globals.js';
+import { ComponentTypes, defaultFrameTitleTextSize, defaultGridSizeUnits, FrameType, ParamKeys, WireAutoDirection } from './globals.js';
 import { Geometry, HorizontalAlign, VerticalAlign } from './geometry.js';
 import { Logger } from './logger.js';
 import { FixedFrameIds, Frame, FrameParamKeys, FramePlotDirection } from './objects/Frame.js';
@@ -30,7 +30,7 @@ export class LayoutEngine {
         return "[" + value + "]" + padding;
     }
     runLayout(sequence, nets) {
-        const logNodesAndEdges = false;
+        const logNodesAndEdges = true;
         this.print('===== creating graph and populating with nodes =====');
         const { graph, containerFrames } = this.generateLayoutGraph(sequence, nets);
         this.print('===== done populating graph =====');
@@ -47,7 +47,7 @@ export class LayoutEngine {
             this.print('===== graph nodes =====');
             const nodes = graph.nodes();
             nodes.forEach(node => {
-                this.print(node, graph.node(node));
+                this.print(`name:${node}, value:${graph.node(node)}`);
             });
             this.print('===== end nodes =====');
             this.print('');
@@ -606,7 +606,7 @@ export class LayoutEngine {
         let previousNode = null;
         let previousPin = null;
         const graph = new Graph({
-            directed: false,
+            directed: true,
             compound: true,
         });
         this.print('sequence length:', sequence.length);
@@ -624,7 +624,7 @@ export class LayoutEngine {
                     const tmpInstanceName = component.instanceName;
                     if (!graph.hasNode(tmpInstanceName)) {
                         this.print('create instance', tmpInstanceName);
-                        const { displayProp = null, widthProp = null, heightProp = null } = component;
+                        const { displayProp = null } = component;
                         let tmpSymbol;
                         if (displayProp instanceof SymbolDrawing) {
                             tmpSymbol = new SymbolPlaceholder(displayProp);
@@ -640,26 +640,6 @@ export class LayoutEngine {
                             }
                         }
                         applyComponentParamsToSymbol(component, tmpSymbol);
-                        if (component.parameters.has(ParamKeys.angle)) {
-                            const value = component.parameters.get(ParamKeys.angle).toNumber();
-                            tmpSymbol.angle = value;
-                        }
-                        if (component.parameters.has(ParamKeys.flipX)) {
-                            tmpSymbol.flipX =
-                                component.parameters.get(ParamKeys.flipX);
-                        }
-                        if (component.parameters.has(ParamKeys.flipY)) {
-                            tmpSymbol.flipY =
-                                component.parameters.get(ParamKeys.flipY);
-                        }
-                        if (tmpSymbol instanceof SymbolCustom) {
-                            if (widthProp) {
-                                tmpSymbol.bodyWidth = milsToMM(widthProp);
-                            }
-                            if (heightProp) {
-                                tmpSymbol.bodyHeight = milsToMM(heightProp);
-                            }
-                        }
                         tmpSymbol.refreshDrawing();
                         const { width: useWidth, height: useHeight } = tmpSymbol.size();
                         tmpComponent = new RenderComponent(component, useWidth, useHeight);
@@ -765,7 +745,11 @@ export class LayoutEngine {
         };
     }
     setGraphEdge(graph, node1, node2, edgeValue) {
+        if (!graph.isDirected && graph.hasEdge(node1, node2)) {
+            this.print(`Warning: edge already exists ${node1} ${node2}`);
+        }
         graph.setEdge(node1, node2, edgeValue);
+        this.print(`created edge: node1:${node1} node2:${node2} edgeValue:${edgeValue}`);
     }
     sizeSubGraphs(graph) {
         const subGraphs = alg.components(graph);
@@ -822,7 +806,6 @@ export class LayoutEngine {
         this.placeSubgraphV2(graph, firstNodeId, subgraphEdges);
     }
     placeSubgraphV2(graph, firstNodeId, subgraphEdges) {
-        let firstNodePlaced = false;
         const originNodes = [];
         const originNodeGroups = new Map();
         function findOriginNode(node) {
@@ -848,14 +831,6 @@ export class LayoutEngine {
             const [nodeId1, pin1, nodeId2, pin2] = graph.edge(edge);
             const [, node1] = graph.node(nodeId1);
             const [, node2] = graph.node(nodeId2);
-            if (nodeId1 === firstNodeId && !firstNodePlaced) {
-                this.print('first node placed at origin');
-                this.placeNodeAtPosition(numeric(0), numeric(0), node1, pin1);
-                firstNodePlaced = true;
-                node1.isFloating = false;
-                originNodes.push(node1);
-                originNodeGroups.set(node1.toString(), [node1]);
-            }
             this.print('edge:', '[', node1, pin1, node1.isFloating, ']', '[', node2, pin2, node2.isFloating, ']');
             if (!node1.isFloating && node2.isFloating) {
                 fixedNode = node1;
@@ -933,6 +908,7 @@ export class LayoutEngine {
                     this.print(`set wire auto end at: ${untilX} ${untilY}`);
                 }
             });
+            this.print('----');
         });
     }
     mergeOriginNodes(node1, pin1, node2, pin2, originNode1, originNode2, originNodes, originNodeGroups) {
@@ -1082,61 +1058,69 @@ function generateLayoutPinDefinition(component) {
     const pins = component.pins;
     const symbolPinDefinitions = [];
     const existingPinIds = Array.from(pins.keys());
-    if (component.arrangeProps === null) {
-        for (let i = 0; i < existingPinIds.length; i++) {
-            const pinPosition = Math.floor(i / 2);
-            const pin = pins.get(existingPinIds[i]);
-            symbolPinDefinitions.push({
-                side: (i % 2 === 0) ? SymbolPinSide.Left : SymbolPinSide.Right,
-                pinId: existingPinIds[i],
-                text: pin.name,
-                position: pinPosition,
-                pinType: pin.pinType,
-            });
+    const arrangeProps = component.arrangeProps ?? [];
+    const addedPins = [];
+    for (const [key, items] of arrangeProps) {
+        let useItems;
+        if (!Array.isArray(items)) {
+            useItems = [items];
         }
-    }
-    else {
-        const addedPins = [];
-        for (const [key, items] of component.arrangeProps) {
-            let useItems;
-            if (!Array.isArray(items)) {
-                useItems = [items];
-            }
-            else {
-                useItems = [...items];
-            }
-            useItems.forEach(pinId => {
-                if (pinId instanceof NumericValue) {
-                    const pinIdValue = pinId.toNumber();
-                    if (existingPinIds.indexOf(pinIdValue) !== -1) {
-                        const pin = pins.get(pinIdValue);
-                        symbolPinDefinitions.push({
-                            side: key,
-                            pinId: pinIdValue,
-                            text: pin.name,
-                            position: pin.position,
-                            pinType: pin.pinType,
-                        });
-                        addedPins.push(pinIdValue);
-                    }
-                }
-            });
+        else {
+            useItems = [...items];
         }
-        const unplacedPins = existingPinIds.filter(pinId => {
-            return addedPins.indexOf(pinId) === -1;
+        useItems.forEach(pinId => {
+            if (pinId instanceof NumericValue) {
+                const pinIdValue = pinId.toNumber();
+                if (existingPinIds.indexOf(pinIdValue) !== -1) {
+                    const pin = pins.get(pinIdValue);
+                    symbolPinDefinitions.push({
+                        side: key,
+                        pinId: pinIdValue,
+                        text: pin.name,
+                        position: pin.position,
+                        pinType: pin.pinType,
+                    });
+                    addedPins.push(pinIdValue);
+                }
+            }
         });
-        if (unplacedPins.length > 0) {
-            throw "'arrange' property is defined, but not all pins are specified: " + unplacedPins.join(",");
-        }
+    }
+    const unplacedPins = existingPinIds.filter(pinId => {
+        return addedPins.indexOf(pinId) === -1;
+    });
+    if (unplacedPins.length > 0) {
+        component._unplacedPins = unplacedPins;
+        console.warn("Warning: There are unplaced pins: " + unplacedPins);
     }
     return symbolPinDefinitions;
 }
 export function applyComponentParamsToSymbol(component, symbol) {
+    const { widthProp = null, heightProp = null } = component;
     const newMap = new Map(component.parameters);
     if (!newMap.has('refdes')) {
         newMap.set('refdes', component.assignedRefDes ?? "?");
     }
     symbol.drawing.variables = newMap;
+    if (component.parameters.has(ParamKeys.angle)) {
+        const value = component.parameters.get(ParamKeys.angle).toNumber();
+        symbol.angle = value;
+    }
+    if (component.parameters.has(ParamKeys.flipX)) {
+        symbol.flipX =
+            component.parameters.get(ParamKeys.flipX);
+    }
+    if (component.parameters.has(ParamKeys.flipY)) {
+        symbol.flipY =
+            component.parameters.get(ParamKeys.flipY);
+    }
+    if (symbol instanceof SymbolCustom) {
+        if (widthProp) {
+            symbol.bodyWidth = milsToMM(widthProp);
+        }
+        if (heightProp) {
+            symbol.bodyHeight = milsToMM(heightProp);
+        }
+    }
 }
 function calculateSymbolAngle(symbol, pin, direction) {
     let directionVector = 0;
@@ -1464,7 +1448,9 @@ export function CalculatePinPositions(component) {
     tmpSymbol.refreshDrawing();
     const pins = component.pins;
     pins.forEach((value, key) => {
-        pinPositionMapping.set(key, tmpSymbol.pinPosition(key));
+        if (component._unplacedPins.indexOf(key) === -1) {
+            pinPositionMapping.set(key, tmpSymbol.pinPosition(key));
+        }
     });
     return pinPositionMapping;
 }

package/dist/esm/objects/ClassComponent.js

@@ -15,6 +15,7 @@ export class ClassComponent {
     _copyID = null;
     _copyFrom = null;
     _pointLinkComponent;
+    _unplacedPins = [];
     arrangeProps = null;
     displayProp = null;
     widthProp = null;

package/dist/esm/objects/ExecutionScope.js

@@ -131,12 +131,13 @@ export class ExecutionScope {
     exitContext() {
         return this.contextStack.pop();
     }
-    findPropertyKeyTree() {
+    findPropertyKeyTree(visitor) {
         const keyNames = [];
         for (let i = this.contextStack.length - 1; i >= 0; i--) {
             const ctx = this.contextStack[i];
             if (ctx instanceof Property_key_exprContext) {
-                keyNames.push([ctx, ctx.getText()]);
+                const result = visitor.visitResult(ctx);
+                keyNames.push([ctx, result]);
             }
             else if (typeof ctx === 'number') {
                 keyNames.push(['index', ctx]);
@@ -150,9 +151,9 @@ export class ExecutionScope {
     popOnPropertyHandler() {
         return this.onPropertyHandler.pop();
     }
-    triggerPropertyHandler(value, valueCtx) {
+    triggerPropertyHandler(visitor, value, valueCtx) {
         const lastHandler = this.onPropertyHandler[this.onPropertyHandler.length - 1];
-        const propertyTree = this.findPropertyKeyTree();
+        const propertyTree = this.findPropertyKeyTree(visitor);
         lastHandler && lastHandler(propertyTree, value, valueCtx);
     }
 }

package/dist/esm/regenerate-tests.js

@@ -5,7 +5,7 @@ const mainDir = './__tests__/renderData/';
 const env = new NodeScriptEnvironment();
 NodeScriptEnvironment.setInstance(env);
 async function regenerateTests(extra = "") {
-    env.prepareSVGEnvironment();
+    await env.prepareSVGEnvironment();
     const cstFiles = [];
     const files = fs.readdirSync(mainDir);
     files.forEach(file => {
@@ -13,19 +13,20 @@ async function regenerateTests(extra = "") {
             cstFiles.push(file);
         }
     });
-    cstFiles.forEach(file => {
+    for (let i = 0; i < cstFiles.length; i++) {
+        const file = cstFiles[i];
         const inputPath = mainDir + file;
         const scriptData = fs.readFileSync(inputPath, { encoding: 'utf-8' });
         const outputPath = mainDir + 'svgs/' + file + extra + '.svg';
         env.setModuleDirectory(mainDir);
-        renderScript(scriptData, outputPath, {
+        env.setDefaultLibsPath(mainDir + '../../libs/');
+        await renderScript(scriptData, outputPath, {
             dumpNets: false,
             dumpData: false,
             showStats: false,
             environment: env,
         });
-        console.log('generated ', outputPath);
-    });
+    }
     return cstFiles;
 }
 (async () => {

package/dist/esm/utils.js

@@ -1,4 +1,5 @@
 import { Big } from 'big.js';
+import { ParserRuleContext } from "antlr4ng";
 import { ClassComponent } from "./objects/ClassComponent.js";
 import { NumericValue } from "./objects/ParamDefinition.js";
 import { SequenceAction } from './objects/ExecutionScope.js';
@@ -243,30 +244,52 @@ export class BaseError extends Error {
     startToken;
     endToken;
     filePath;
-    constructor(message, startToken, endToken, filePath) {
+    constructor(message, startTokenOrCtx, endToken, filePath) {
         super(message);
         this.message = message;
-        this.startToken = startToken;
-        this.endToken = endToken;
+        if (startTokenOrCtx instanceof ParserRuleContext) {
+            this.startToken = startTokenOrCtx.start;
+            this.endToken = startTokenOrCtx.stop;
+        }
+        else {
+            this.startToken = startTokenOrCtx;
+            this.endToken = endToken;
+        }
         this.filePath = filePath;
     }
     toString() {
         const parts = [this.name];
-        if (this.startToken) {
-            const { line, column } = this.startToken;
-            if (this.endToken && (this.endToken.line !== this.startToken.line || this.endToken.column !== this.startToken.column)) {
-                const endLine = this.endToken.line;
-                const endColumn = this.endToken.column + (this.endToken.stop - this.endToken.start);
-                parts.push(` at ${line}:${column}-${endLine}:${endColumn}`);
-            }
-            else {
-                parts.push(` at ${line}:${column}`);
-            }
+        const linePosition = getLinePositionAsString({
+            start: this.startToken,
+            stop: this.endToken
+        });
+        if (linePosition !== null) {
+            parts.push(linePosition);
         }
         parts.push(`: ${this.message}`);
         return parts.join('');
     }
 }
+export function getLinePositionAsString(ctx) {
+    if (ctx === null || ctx === undefined) {
+        return null;
+    }
+    const startToken = ctx.start;
+    const endToken = ctx.stop;
+    let result = null;
+    if (startToken) {
+        const { line, column } = startToken;
+        if (endToken && (endToken.line !== startToken.line || endToken.column !== startToken.column)) {
+            const endLine = endToken.line;
+            const endColumn = endToken.column + (endToken.stop - endToken.start);
+            result = ` at ${line}:${column}-${endLine}:${endColumn}`;
+        }
+        else {
+            result = ` at ${line}:${column}`;
+        }
+    }
+    return result;
+}
 export class ParseSyntaxError extends BaseError {
     name = 'ParseSyntaxError';
 }
@@ -284,3 +307,21 @@ export class RenderError extends Error {
         this.stage = stage;
     }
 }
+export function printWarnings(warnings) {
+    const warningMessages = [];
+    warnings.forEach(item => {
+        const { message } = item;
+        const linePosition = getLinePositionAsString(item.ctx);
+        const parts = [message];
+        if (linePosition !== null) {
+            parts.push(linePosition);
+        }
+        const finalMessage = parts.join('');
+        if (warningMessages.indexOf(finalMessage) === -1) {
+            warningMessages.push(finalMessage);
+        }
+    });
+    warningMessages.forEach(message => {
+        console.log(`Warning: ${message}`);
+    });
+}

package/dist/esm/validate.js

@@ -67,6 +67,7 @@ export default async function validate() {
     };
     const visitor = await validateScript(inputFilePath, scriptData, scriptOptions);
     const symbols = visitor.getSymbols().getSymbols();
+    const undefinedSymbols = [];
     symbols.forEach((value, key) => {
         if (value.type !== ParseSymbolType.Undefined) {
             value = value;
@@ -76,11 +77,29 @@ export default async function validate() {
                 console.log("    " + instance.line + ":" + instance.column + " " + instance.start);
             });
         }
+        else {
+            undefinedSymbols.push(value);
+        }
     });
     const { parsedTokens } = await getSemanticTokens(scriptData, scriptOptions);
     parsedTokens.forEach(item => {
         const { line, column, tokenType, tokenModifiers, textValue } = item;
         console.log(`${line}:${column} - ${textValue} - ${tokenType} | ${tokenModifiers.join(',')}`);
     });
+    console.log('--- undefined ---');
+    undefinedSymbols.forEach(symbol => {
+        const { token } = symbol;
+        const info = {
+            start: {
+                line: (token?.line || 1),
+                character: token?.column || 0
+            },
+            end: {
+                line: (token?.line || 1),
+                character: (token?.column || 0) + ((token?.stop || 0) - (token?.start || 0) + 1)
+            }
+        };
+        console.log(token.text, info);
+    });
 }
 validate();

package/dist/esm/visitor.js

@@ -47,7 +47,7 @@ export class ParserVisitor extends BaseVisitor {
                 });
             }
             catch (err) {
-                throw new RuntimeExecutionError(err.message, ctx.start, ctx.stop);
+                throw new RuntimeExecutionError(err.message, ctx);
             }
         });
         return this.getExecutor().getCurrentPoint();
@@ -115,6 +115,24 @@ export class ParserVisitor extends BaseVisitor {
     };
     visitCreate_component_expr = (ctx) => {
         const scope = this.getScope();
+        const definedPinIds = [];
+        const arrangedPinIds = [];
+        const checkPinExistsAndNotDuplicated = (pinId, ctx) => {
+            if (definedPinIds.indexOf(pinId) === -1) {
+                this.warnings.push({
+                    message: `Invalid pin ${pinId}`, ctx
+                });
+            }
+            if (arrangedPinIds.indexOf(pinId) !== -1) {
+                this.warnings.push({
+                    message: `Pin ${pinId} specified more than once`,
+                    ctx,
+                });
+            }
+            arrangedPinIds.push(pinId);
+        };
+        let didDefineArrangeProp = false;
+        let didDefineDisplayProp = false;
         scope.setOnPropertyHandler((path, value, ctx) => {
             if (path.length === 1) {
                 const [, keyName] = path[0];
@@ -127,9 +145,25 @@ export class ParserVisitor extends BaseVisitor {
                     case 'height':
                         this.validateNumeric(value, ctx);
                         break;
+                    case 'display':
+                        if (didDefineArrangeProp) {
+                            throw new RuntimeExecutionError("arrange property has already been defined", ctx);
+                        }
+                        didDefineDisplayProp = true;
+                        break;
+                    case 'arrange':
+                        if (didDefineDisplayProp) {
+                            throw new RuntimeExecutionError("display property already defined", ctx);
+                        }
+                        didDefineArrangeProp = true;
+                        break;
                     case 'pins':
                         if (!(value instanceof Map)) {
                             this.validateNumeric(value, ctx);
+                            const numPins = value.toNumber();
+                            for (let i = 0; i < numPins; i++) {
+                                definedPinIds.push(i + 1);
+                            }
                         }
                         break;
                     case 'copy':
@@ -140,7 +174,7 @@ export class ParserVisitor extends BaseVisitor {
                             this.validateBoolean(value, ctx);
                         }
                         else {
-                            throw new RuntimeExecutionError("Invalid value for 'copy' property", ctx.start, ctx.end);
+                            throw new RuntimeExecutionError("Invalid value for 'copy' property", ctx);
                         }
                         break;
                 }
@@ -150,20 +184,26 @@ export class ParserVisitor extends BaseVisitor {
                 if (keyName === 'arrange') {
                     const [sideKeyCtx, sideKeyName] = path[1];
                     if (ValidPinSides.indexOf(sideKeyName) === -1) {
-                        throw new RuntimeExecutionError(`Invalid side ${sideKeyName} in arrange`, sideKeyCtx.start, sideKeyCtx.stop);
+                        throw new RuntimeExecutionError(`Invalid side ${sideKeyName} in arrange`, sideKeyCtx);
                     }
                     else {
-                        if (path.length > 2 && path[2][0] === 'index') {
+                        if (path.length === 2 && value instanceof NumericValue) {
+                            checkPinExistsAndNotDuplicated(value.toNumber(), ctx);
+                        }
+                        else if (path.length > 2 && path[2][0] === 'index') {
                             if (Array.isArray(value)) {
                                 const goodBlank = value.length === 1 &&
                                     value[0] instanceof NumericValue;
                                 if (!goodBlank) {
-                                    throw new RuntimeExecutionError(`Invalid blank specifier`, ctx.start, ctx.stop);
+                                    throw new RuntimeExecutionError(`Invalid blank specifier`, ctx);
                                 }
                             }
                             else {
                                 if (!(value instanceof NumericValue)) {
-                                    throw new RuntimeExecutionError(`Invalid numeric value for arrange.${sideKeyName}`, ctx.start, ctx.stop);
+                                    throw new RuntimeExecutionError(`Invalid numeric value for arrange.${sideKeyName}`, ctx);
+                                }
+                                else {
+                                    checkPinExistsAndNotDuplicated(value.toNumber(), ctx);
                                 }
                             }
                         }
@@ -184,10 +224,12 @@ export class ParserVisitor extends BaseVisitor {
                 }
                 else if (keyName === 'pins') {
                     if (path.length === 2) {
+                        const idName = path[1][1];
+                        definedPinIds.push(idName);
                         if (value.length === 2) {
                             const [pinType,] = value;
                             if (pinType instanceof UndeclaredReference) {
-                                throw new RuntimeExecutionError(`Invalid pin type: ${pinType.reference.name}`, ctx.start, ctx.end);
+                                throw new RuntimeExecutionError(`Invalid pin type: ${pinType.reference.name}`, ctx);
                             }
                         }
                     }
@@ -416,7 +458,7 @@ export class ParserVisitor extends BaseVisitor {
         this.getScope().enterContext(ctxValue);
         const keyName = this.visitResult(ctxKey);
         const value = this.visitResult(ctxValue);
-        scope.triggerPropertyHandler(value, ctxValue);
+        scope.triggerPropertyHandler(this, value, ctxValue);
         this.getScope().exitContext();
         this.getScope().exitContext();
         if (value instanceof UndeclaredReference && (value.reference.parentValue === undefined
@@ -437,7 +479,7 @@ export class ParserVisitor extends BaseVisitor {
             value = ctx.data_expr().map((item, index) => {
                 this.getScope().enterContext(index);
                 const result = this.visitResult(item);
-                this.getScope().triggerPropertyHandler(result, item);
+                this.getScope().triggerPropertyHandler(this, result, item);
                 this.getScope().exitContext();
                 return result;
             });
@@ -1063,45 +1105,46 @@ export class ParserVisitor extends BaseVisitor {
     parseCreateComponentPins(pinData) {
         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;
-                pins.push(new PinDefinition(pinId, PinIdType.Int, pinId.toString()));
+                tmpMap.set(pinId, numeric(pinId));
             }
-        }
-        else if (pinData instanceof Map) {
-            for (const [pinId, pinDef] of pinData) {
-                let pinIdType = PinIdType.Int;
-                let pinType = PinTypes.Any;
-                let pinName = null;
-                let altPinNames = [];
-                if (typeof pinId === 'string') {
-                    pinIdType = PinIdType.Str;
-                }
-                if (Array.isArray(pinDef)) {
-                    const firstValue = pinDef[0];
-                    if (firstValue.type
-                        && firstValue.type === ReferenceTypes.pinType
-                        && this.pinTypes.indexOf(firstValue.value) !== -1) {
-                        pinType = firstValue.value;
-                        pinName = pinDef[1];
-                        if (pinDef.length > 2) {
-                            altPinNames = pinDef.slice(2);
-                        }
-                    }
-                    else {
-                        pinName = pinDef[0];
-                        if (pinDef.length > 1) {
-                            altPinNames = pinDef.slice(1);
-                        }
+            pinData = tmpMap;
+        }
+        pinData = pinData ?? [];
+        for (const [pinId, pinDef] of pinData) {
+            let pinIdType = PinIdType.Int;
+            let pinType = PinTypes.Any;
+            let pinName = null;
+            let altPinNames = [];
+            if (typeof pinId === 'string') {
+                pinIdType = PinIdType.Str;
+            }
+            if (Array.isArray(pinDef)) {
+                const firstValue = pinDef[0];
+                if (firstValue.type
+                    && firstValue.type === ReferenceTypes.pinType
+                    && this.pinTypes.indexOf(firstValue.value) !== -1) {
+                    pinType = firstValue.value;
+                    pinName = pinDef[1];
+                    if (pinDef.length > 2) {
+                        altPinNames = pinDef.slice(2);
                     }
                 }
                 else {
-                    pinName = pinDef;
+                    pinName = pinDef[0];
+                    if (pinDef.length > 1) {
+                        altPinNames = pinDef.slice(1);
+                    }
                 }
-                this.log('pins', pinId, pinIdType, pinName, pinType, altPinNames);
-                pins.push(new PinDefinition(pinId, pinIdType, pinName, pinType, altPinNames));
             }
+            else {
+                pinName = pinDef;
+            }
+            this.log('pins', pinId, pinIdType, pinName, pinType, altPinNames);
+            pins.push(new PinDefinition(pinId, pinIdType, pinName, pinType, altPinNames));
         }
         return pins;
     }
@@ -1310,6 +1353,9 @@ export class ParserVisitor extends BaseVisitor {
         });
         return properties;
     }
+    getWarnings() {
+        return this.warnings;
+    }
 }
 const ComponentRefDesPrefixes = {
     res: 'R',