circuitscript 0.5.1 → 0.5.3

package/dist/esm/builtinMethods.js

@@ -3,6 +3,8 @@ import { NumericValue, numeric, resolveToNumericValue } from "./objects/NumericV
 import { CFunctionEntry, ImportedLibrary } from "./objects/types.js";
 import { unwrapValue, RuntimeExecutionError } from "./utils.js";
 import { BaseNamespace } from "./globals.js";
+import { ClassComponent } from "./objects/ClassComponent.js";
+import { Net } from "./objects/Net.js";
 const builtInMethods = [
     ['enumerate', enumerate],
     ['toMils', toMils],
@@ -152,6 +154,12 @@ function toString(obj) {
     else if (obj instanceof ImportedLibrary) {
         return `[library: ${obj.libraryName}]`;
     }
+    else if (obj instanceof ClassComponent) {
+        return `[component: ${obj.instanceName}]`;
+    }
+    else if (obj instanceof Net) {
+        return `[net: ${obj.toString()}]`;
+    }
     else {
         if (obj === undefined) {
             return 'undefined';

package/dist/esm/execute.js

@@ -6,7 +6,7 @@ import { Net } from './objects/Net.js';
 import { NumericValue } from './objects/NumericValue.js';
 import { numeric } from "./objects/NumericValue.js";
 import { PinId, PortSide } from './objects/PinDefinition.js';
-import { AnyReference, CFunctionEntry, DeclaredReference, Direction, ImportFunctionHandling, NetTypes } from './objects/types.js';
+import { AnyReference, CFunctionEntry, DeclaredReference, Direction, ImportFunctionHandling, ImportedLibrary, NetTypes } from './objects/types.js';
 import { Wire } from './objects/Wire.js';
 import { Frame } from './objects/Frame.js';
 import { CalculatePinPositions } from './render/layout.js';
@@ -165,6 +165,7 @@ export class ExecutionContext {
             const defaultPin = new PinId(1);
             this.scope.setNet(component, defaultPin, tmpNet);
             this.log('set net', netName, 'component', component, defaultPin);
+            component.setParam('net', tmpNet);
         }
         this.scope.instances.set(instanceName, component);
         const pinsOutput = pins.map((pin) => {
@@ -734,31 +735,16 @@ export class ExecutionContext {
         let rootValue;
         let useValue = item;
         if (trailers.length > 0) {
-            rootValue = useValue;
-            const trailersPath = trailers.join(".");
-            switch (type) {
-                case ReferenceTypes.variable:
-                    useValue = rootValue;
-                    trailers.forEach(trailerPath => {
-                        useValue = useValue[trailerPath];
-                    });
-                    break;
-                case ReferenceTypes.instance: {
-                    const tmpComponent = rootValue;
-                    if (tmpComponent.typeProp === ComponentTypes.net) {
-                        const usedNet = this.scope.getNet(tmpComponent, new PinId(1));
-                        if (usedNet) {
-                            const trailerValue = trailers.join(".");
-                            useValue = usedNet.params.get(trailerValue) ?? null;
-                        }
-                    }
-                    else {
-                        useValue = rootValue
-                            .parameters.get(trailersPath);
-                    }
-                    break;
+            rootValue = item;
+            useValue = item;
+            for (let i = 0; i < trailers.length; i++) {
+                if (useValue instanceof ClassComponent) {
+                    useValue = useValue.parameters.get(trailers[i]);
                 }
-                case ReferenceTypes.library: {
+                else if (useValue instanceof Net) {
+                    useValue = useValue.params.get(trailers[i]);
+                }
+                else if (useValue instanceof ImportedLibrary) {
                     const funcName = trailers[0];
                     const library = rootValue;
                     const functionPath = `${library.libraryNamespace}${funcName}`;
@@ -773,7 +759,9 @@ export class ExecutionContext {
                             value: foundFunc,
                         });
                     }
-                    break;
+                }
+                else {
+                    useValue = useValue[trailers[i]];
                 }
             }
         }
@@ -1021,52 +1009,6 @@ export class ExecutionContext {
             return commands;
         });
     }
-    setProperty(nameWithProp, value) {
-        this.log('set property', nameWithProp, 'value', value);
-        let idName;
-        let paramName;
-        let useActive = false;
-        if (nameWithProp.startsWith('..')) {
-            useActive = true;
-            paramName = nameWithProp.substring(2);
-        }
-        else {
-            const parts = nameWithProp.split(".");
-            idName = parts[0];
-            paramName = parts[1];
-        }
-        if (useActive && this.scope.currentFrameId !== -1) {
-            this.scope.frames[this.scope.currentFrameId - 1]
-                .parameters.set(paramName, value);
-        }
-        else {
-            idName = this.scope.currentComponent.instanceName;
-            if (this.scope.instances.has(idName)) {
-                const component = this.scope.instances.get(idName);
-                component.setParam(paramName, value);
-                const unitModifiers = [
-                    ParamKeys.angle,
-                    ParamKeys.flip,
-                    ParamKeys.flipX,
-                    ParamKeys.flipY,
-                ];
-                if (unitModifiers.indexOf(paramName) !== -1) {
-                    if (paramName === ParamKeys.flipX || paramName == ParamKeys.flipY) {
-                        if (typeof value === "boolean") {
-                            value = value ? numeric(1) : numeric(0);
-                        }
-                    }
-                    component.getUnit().setParam(paramName, value);
-                }
-            }
-            else if (this.scope.variables.has(idName)) {
-                throw "Not implemented yet!";
-            }
-            else {
-                throw "Unknown identifier: " + idName;
-            }
-        }
-    }
     applyComponentAngleFromWire(component, pin, opposite = false) {
         const targetUnit = component.getUnitForPin(pin);
         if (this.componentAngleFollowsWire

package/dist/esm/objects/Frame.js

@@ -23,6 +23,8 @@ export var FrameParamKeys;
     FrameParamKeys["Height"] = "height";
     FrameParamKeys["PaperSize"] = "paper_size";
     FrameParamKeys["SheetType"] = "sheet_type";
+    FrameParamKeys["GridStyle"] = "grid_style";
+    FrameParamKeys["GridColor"] = "grid_color";
     FrameParamKeys["TitleAlign"] = "title_align";
     FrameParamKeys["HorizontalAlign"] = "align";
     FrameParamKeys["VerticalAlign"] = "valign";

package/dist/esm/pipeline.js

@@ -3,7 +3,7 @@ import PDFDocument from "pdfkit";
 import { RecognitionException } from "antlr4ng";
 import { DefaultPostAnnotationCallback } from "./annotate/DefaultPostAnnotationCallback.js";
 import { generateBom, generateBomCSV, saveBomOutputCsv } from "./BomGeneration.js";
-import { defaultZoomScale } from "./globals.js";
+import { defaultZoomScale, GlobalDocumentName } from "./globals.js";
 import { NetGraph } from "./render/graph.js";
 import { LayoutEngine } from "./render/layout.js";
 import { Logger } from "./logger.js";
@@ -154,8 +154,9 @@ export async function renderScriptCustom(scriptData, outputPath, options, parseH
     if (errors.length === 0 && throwError === undefined) {
         const { frameComponent } = visitor.applySheetFrameComponent();
         const { sequence, nets } = visitor.getGraph();
+        const documentVariable = visitor.getScope()
+            .variables.get(GlobalDocumentName);
         if (enableBom && bomOutputPath) {
-            const documentVariable = visitor.getScope().variables.get('document');
             const bomConfig = documentVariable.bom;
             const bomData = generateBom(bomConfig, visitor.getScope().getInstances());
             const bomCsvOutput = generateBomCSV(bomData);
@@ -213,7 +214,7 @@ export async function renderScriptCustom(scriptData, outputPath, options, parseH
             const renderLogger = new Logger();
             let svgCanvas;
             try {
-                svgCanvas = renderSheetsToSVG(sheetFrames, renderLogger);
+                svgCanvas = renderSheetsToSVG(sheetFrames, renderLogger, documentVariable);
             }
             catch (err) {
                 throw new RenderError(`Error during SVG generation: ${err}`, 'svg_generation');

package/dist/esm/render/render.js

@@ -19,7 +19,7 @@ function createSvgCanvas() {
     applyFontsToSVG(canvas);
     return canvas;
 }
-export function renderSheetsToSVG(sheetFrames, logger) {
+export function renderSheetsToSVG(sheetFrames, logger, documentVariable) {
     const canvas = createSvgCanvas();
     sheetFrames.forEach((sheet, index) => {
         const sheetGroup = canvas.group();
@@ -76,7 +76,13 @@ export function renderSheetsToSVG(sheetFrames, logger) {
         logger.add('sheet contents offset: ' + xOffset + ' ' + yOffset);
         logger.add('generating svg children in sheet');
         const sheetElements = sheetGroup.group().addClass('sheet-elements');
-        generateSVGChild(sheetElements, components, wires, junctions, mergedWires, allFrames, textObjects, gridBounds, extendGrid, logger);
+        const gridProperties = {
+            gridBounds,
+            extendGrid,
+            style: documentVariable[FrameParamKeys.GridStyle],
+            color: documentVariable[FrameParamKeys.GridColor],
+        };
+        generateSVGChild(sheetElements, components, wires, junctions, mergedWires, allFrames, textObjects, gridProperties, logger);
         sheetElements.translate(xOffset, yOffset);
         sheetGroup.translate(0, sheetYOffset.toNumber());
     });
@@ -120,14 +126,15 @@ export function generatePdfOutput(doc, canvas, sheetSize, sheetSizeDefined, zoom
         }
     });
 }
-function generateSVGChild(canvas, components, wires, junctions, mergedWires, frameObjects, textObjects, gridBounds, extendGrid, logger) {
+function generateSVGChild(canvas, components, wires, junctions, mergedWires, frameObjects, textObjects, gridProperties, logger) {
     const displayWireId = false;
-    if (gridBounds === null) {
+    if (gridProperties.gridBounds === null) {
         logger.add('get grid bounds');
-        gridBounds = getBounds(components, wires, junctions, frameObjects);
+        gridProperties.gridBounds = getBounds(components, wires, junctions, frameObjects);
     }
+    const { gridBounds } = gridProperties;
     logger.add('grid bounds', gridBounds.xmin, gridBounds.ymin, gridBounds.xmax, gridBounds.ymax);
-    drawGrid(canvas.group().translate(0, 0), gridBounds, extendGrid, logger);
+    drawGrid(canvas.group().translate(0, 0), gridProperties, logger);
     components.forEach(item => {
         const { x, y, width, height } = item;
         const symbolGroup = canvas.group();
@@ -285,7 +292,8 @@ function generateSVGChild(canvas, components, wires, junctions, mergedWires, fra
         .translate(-originSize / 2, -originSize / 2)
         .stroke('none').fill('red');
 }
-function drawGrid(group, canvasSize, extendGrid, logger) {
+function drawGrid(group, gridProperties, logger) {
+    const { gridBounds: canvasSize, extendGrid, style: gridStyle = "dots", color: gridColor = "#000" } = gridProperties;
     const gridSize = defaultGridSizeUnits;
     const { xmin, ymin, xmax, ymax } = canvasSize;
     const extraValue = extendGrid ? 1 : 0;
@@ -303,6 +311,7 @@ function drawGrid(group, canvasSize, extendGrid, logger) {
     RenderFlags.ShowGridOrigin && group.circle(originSize)
         .translate(-originSize / 2, -originSize / 2)
         .stroke('none').fill('blue');
+    const useGridColor = gridStyle !== "none" ? gridColor : "rgba(0,0,0,0)";
     const lines = [];
     const smallOffset = milsToMM(3);
     const startY = gridStartY.sub(smallOffset.half());
@@ -320,7 +329,7 @@ function drawGrid(group, canvasSize, extendGrid, logger) {
     })
         .stroke({
         width: strokeSize.toNumber(),
-        color: '#000'
+        color: useGridColor
     });
 }
 function drawSheetFrameBorder(frameGroup, frame) {

package/dist/esm/semantic-tokens/SemanticTokenVisitor.js

@@ -127,6 +127,8 @@ export class SemanticTokensVisitor extends BaseVisitor {
             });
         }
     };
+    visitTrailer = (ctx) => {
+    };
     addSemanticToken(node, modifiers, tokenType = null) {
         const parsedToken = this.parseToken(node, modifiers, tokenType);
         this.semanticTokens.set(`${parsedToken.line}_${parsedToken.column}_${parsedToken.length}`, parsedToken);

package/dist/esm/validate/SymbolValidatorVisitor.js

@@ -191,6 +191,8 @@ export class SymbolValidatorVisitor extends BaseVisitor {
             this.addSymbolVariable(ctxID.getSymbol(), ctxID.getText(), null);
         }
     };
+    visitTrailer = (ctx) => {
+    };
     getSymbols() {
         return this.symbolTable;
     }

package/dist/esm/visitor.js

@@ -4,7 +4,7 @@ import { ParamDefinition } from "./objects/ParamDefinition.js";
 import { numeric } from "./objects/NumericValue.js";
 import { PinDefinition, PinId, PinIdType } from './objects/PinDefinition.js';
 import { PinTypes } from './objects/PinTypes.js';
-import { DeclaredReference, UndeclaredReference } from './objects/types.js';
+import { AnyReference, DeclaredReference, UndeclaredReference } from './objects/types.js';
 import { ComponentTypes, Delimiter1, FrameType, GlobalDocumentName, ModuleContainsKeyword, NoNetText, ParamKeys, RefdesFileSuffix, ReferenceTypes, SymbolPinSide, ValidPinSides, WireAutoDirection } from './globals.js';
 import { BlockTypes } from "./objects/BlockTypes.js";
 import { unwrapValue } from "./utils.js";
@@ -1048,8 +1048,19 @@ export class ParserVisitor extends BaseVisitor {
     };
     visitDouble_dot_property_set_expr = (ctx) => {
         const result = this.visitResult(ctx.data_expr());
-        const propertyName = ctx.ID().getText();
-        this.getExecutor().setProperty('..' + propertyName, result);
+        const scope = this.getScope();
+        const useObject = scope.currentFrameId !== -1 ?
+            scope.frames[scope.currentFrameId - 1] : scope.currentComponent;
+        const lastReference = new AnyReference({
+            found: true,
+            value: useObject,
+            type: ReferenceTypes.instance,
+            trailerIndex: 0,
+        });
+        const firstId = ctx.ID().getText();
+        const referenceWithFirstID = this.getExecutor().resolveTrailers(null, lastReference.value, [firstId]);
+        const useReference = this.resolveTrailersForReference(referenceWithFirstID, null, ctx);
+        this.assignValueToReference([], useReference, ctx, result);
     };
     visitExpressions_block = (ctx) => {
         this.runExpressions(this.getExecutor(), ctx.expression());

package/dist/types/BaseVisitor.d.ts

@@ -1,4 +1,4 @@
-import { ArrayExprContext, Assignment_exprContext, Callable_exprContext, CallableExprContext, ExpressionContext, Flow_expressionsContext, Function_args_exprContext, Function_exprContext, Function_return_exprContext, Import_exprContext, Import_simpleContext, Import_specific_or_allContext, Keyword_assignment_exprContext, ParametersContext, RoundedBracketsExprContext, ScriptContext, TrailerContext, Value_exprContext, ValueExprContext } from "./antlr/CircuitScriptParser.js";
+import { ArrayExprContext, Assignment_exprContext, Callable_exprContext, CallableExprContext, Double_dot_property_set_exprContext, ExpressionContext, Flow_expressionsContext, Function_args_exprContext, Function_exprContext, Function_return_exprContext, Import_exprContext, Import_simpleContext, Import_specific_or_allContext, Keyword_assignment_exprContext, ParametersContext, RoundedBracketsExprContext, ScriptContext, TrailerContext, Value_exprContext, ValueExprContext } from "./antlr/CircuitScriptParser.js";
 import { CircuitScriptParserVisitor } from "./antlr/CircuitScriptParserVisitor.js";
 import { ExecutionContext } from "./execute.js";
 import { Logger } from "./logger.js";
@@ -52,11 +52,11 @@ export declare class BaseVisitor extends CircuitScriptParserVisitor<ComplexType
     visitImport_specific_or_all: (ctx: Import_specific_or_allContext) => void;
     visitCallableExpr: (ctx: CallableExprContext) => void;
     visitCallable_expr: (ctx: Callable_exprContext) => void;
+    protected resolveTrailersForReference(reference: AnyReference, passedNetNamespace: string | null, ctx: Callable_exprContext | Double_dot_property_set_exprContext): AnyReference;
     visitTrailer: (ctx: TrailerContext) => void;
     visitAssignment_expr: (ctx: Assignment_exprContext) => void;
+    protected assignValueToReference(sequenceParts: (string | any)[], leftSideReference: AnyReference, lhsCtx: ParserRuleContext, rhsValue: any): void;
     private getReference;
-    visitTrailer_expr2: (ctx: Trailer_expr2Context) => void;
-    visitAtom_expr: (ctx: Atom_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;

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

@@ -407,6 +407,8 @@ export declare class Double_dot_property_set_exprContext extends antlr.ParserRul
     ID(): antlr.TerminalNode;
     Assign(): antlr.TerminalNode;
     data_expr(): Data_exprContext;
+    trailer(): TrailerContext[];
+    trailer(i: number): TrailerContext | null;
     get ruleIndex(): number;
     accept<Result>(visitor: CircuitScriptParserVisitor<Result>): Result | null;
 }

package/dist/types/execute.d.ts

@@ -95,7 +95,6 @@ export declare class ExecutionContext {
     addWire(segments: [string, (number | UnitDimension)?][]): Wire;
     addPoint(pointId: string, userDefined?: boolean): ComponentPin;
     private getPointSymbol;
-    setProperty(nameWithProp: string, value: any): void;
     applyComponentAngleFromWire(component: ClassComponent, pin: number, opposite?: boolean): void;
     enterFrame(frameType: FrameType): number;
     exitFrame(frameId: number): void;

package/dist/types/objects/ClassComponent.d.ts

@@ -61,7 +61,7 @@ export declare class ClassComponent {
     hasPin(pinId: PinId): boolean;
     getPin(pinId: PinId): PinId;
     getNextPinAfter(pinIndex: PinId): PinId;
-    setParam(key: string, value: number | string | NumericValue): void;
+    setParam(key: string, value: number | string | NumericValue | Net): void;
     hasParam(key: string): boolean;
     private refreshParamCache;
     private refreshPinsCache;

package/dist/types/objects/Frame.d.ts

@@ -18,6 +18,8 @@ export declare enum FrameParamKeys {
     Height = "height",
     PaperSize = "paper_size",
     SheetType = "sheet_type",
+    GridStyle = "grid_style",
+    GridColor = "grid_color",
     TitleAlign = "title_align",
     HorizontalAlign = "align",
     VerticalAlign = "valign",

package/dist/types/objects/types.d.ts

@@ -10,6 +10,8 @@ import { ScriptContext } from 'src/antlr/CircuitScriptParser.js';
 import { SymbolDrawingCommands } from 'src/render/draw_symbols.js';
 import { RefdesModification } from 'src/annotate/utils.js';
 import { SerializedExpression } from 'src/cache/types.js';
+import { BomConfig } from 'src/BomGeneration.js';
+import { FrameParamKeys } from './Frame.js';
 export type CFunction = (args: CallableParameter[], options?: CFunctionOptions) => CFunctionResult;
 export declare class CFunctionEntry {
     name: string;
@@ -155,3 +157,6 @@ export type ComponentUnitDefinition = {
     arrange: any | null;
     suffix: string | null;
 };
+export type DocumentVariable = {
+    bom: BomConfig;
+} & Partial<Record<FrameParamKeys, ValueType | ClassComponent>>;

package/dist/types/render/render.d.ts

@@ -2,6 +2,7 @@
 import { Svg } from '@svgdotjs/svg.js';
 import { SheetFrame } from "./layout.js";
 import { Logger } from '../logger.js';
-export declare function renderSheetsToSVG(sheetFrames: SheetFrame[], logger: Logger): Svg;
+import { DocumentVariable } from 'src/objects/types.js';
+export declare function renderSheetsToSVG(sheetFrames: SheetFrame[], logger: Logger, documentVariable: DocumentVariable): Svg;
 export declare function generateSvgOutput(canvas: Svg, zoomScale?: number): string;
 export declare function generatePdfOutput(doc: PDFKit.PDFDocument, canvas: Svg, sheetSize: string, sheetSizeDefined: boolean, zoomScale?: number): void;

package/dist/types/semantic-tokens/SemanticTokenVisitor.d.ts

@@ -1,6 +1,6 @@
 import { TerminalNode, Token } from "antlr4ng";
 import { CircuitScriptLexer } from "../antlr/CircuitScriptLexer.js";
-import { Function_def_exprContext, Create_component_exprContext, Create_graphic_exprContext, Callable_exprContext, Property_key_exprContext, Assignment_exprContext, Function_args_exprContext, GraphicCommandExprContext, For_exprContext, Annotation_comment_exprContext, ScriptContext, CreateExprContext, Import_simpleContext, Import_specific_or_allContext } from "../antlr/CircuitScriptParser.js";
+import { Function_def_exprContext, Create_component_exprContext, Create_graphic_exprContext, Callable_exprContext, Property_key_exprContext, Assignment_exprContext, Function_args_exprContext, GraphicCommandExprContext, For_exprContext, Annotation_comment_exprContext, ScriptContext, CreateExprContext, Import_simpleContext, Import_specific_or_allContext, TrailerContext } from "../antlr/CircuitScriptParser.js";
 import { BaseVisitor, OnErrorHandler } from "../BaseVisitor.js";
 import { NodeScriptEnvironment } from "../environment/environment.js";
 export declare class SemanticTokensVisitor extends BaseVisitor {
@@ -23,6 +23,7 @@ export declare class SemanticTokensVisitor extends BaseVisitor {
     visitImport_specific_or_all: (ctx: Import_specific_or_allContext) => void;
     visitFor_expr: (ctx: For_exprContext) => void;
     visitAnnotation_comment_expr: (ctx: Annotation_comment_exprContext) => void;
+    visitTrailer: (ctx: TrailerContext) => void;
     addSemanticToken(node: TerminalNode, modifiers: string[], tokenType?: string | null): void;
     parseToken(node: TerminalNode, modifiers: string[], tokenType?: string | null): IParsedToken;
     dumpTokens(): void;

package/dist/types/validate/SymbolValidatorVisitor.d.ts

@@ -1,5 +1,5 @@
 import { TerminalNode, Token } from "antlr4ng";
-import { Assignment_exprContext, CallableExprContext, UnaryOperatorExprContext, MultiplyExprContext, AdditionExprContext, BinaryOperatorExprContext, Function_def_exprContext, For_exprContext, Import_simpleContext, Import_specific_or_allContext, Create_graphic_exprContext } from "../antlr/CircuitScriptParser.js";
+import { Assignment_exprContext, CallableExprContext, UnaryOperatorExprContext, MultiplyExprContext, AdditionExprContext, BinaryOperatorExprContext, Function_def_exprContext, For_exprContext, Import_simpleContext, Import_specific_or_allContext, Create_graphic_exprContext, TrailerContext } from "../antlr/CircuitScriptParser.js";
 import { ExecutionContext } from "../execute.js";
 import { ComplexType, FunctionDefinedParameter } from "../objects/types.js";
 import { SymbolTableItem } from "./SymbolTable.js";
@@ -28,6 +28,7 @@ export declare class SymbolValidatorVisitor extends BaseVisitor {
     visitFunction_def_expr: (ctx: Function_def_exprContext) => void;
     visitFor_expr: (ctx: For_exprContext) => void;
     visitCreate_graphic_expr: (ctx: Create_graphic_exprContext) => void;
+    visitTrailer: (ctx: TrailerContext) => void;
     getSymbols(): SymbolTable;
     dumpSymbols(): void;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "circuitscript",
-    "version": "0.5.1",
+    "version": "0.5.3",
     "description": "Interpreter for the circuitscript language",
     "homepage": "https://circuitscript.net",
     "engines": {