circuitscript 0.5.1 → 0.5.3

package/dist/cjs/builtinMethods.js

@@ -9,6 +9,8 @@ const NumericValue_js_1 = require("./objects/NumericValue.js");
 const types_js_1 = require("./objects/types.js");
 const utils_js_1 = require("./utils.js");
 const globals_js_1 = require("./globals.js");
+const ClassComponent_js_1 = require("./objects/ClassComponent.js");
+const Net_js_1 = require("./objects/Net.js");
 const builtInMethods = [
     ['enumerate', enumerate],
     ['toMils', toMils],
@@ -159,6 +161,12 @@ function toString(obj) {
     else if (obj instanceof types_js_1.ImportedLibrary) {
         return `[library: ${obj.libraryName}]`;
     }
+    else if (obj instanceof ClassComponent_js_1.ClassComponent) {
+        return `[component: ${obj.instanceName}]`;
+    }
+    else if (obj instanceof Net_js_1.Net) {
+        return `[net: ${obj.toString()}]`;
+    }
     else {
         if (obj === undefined) {
             return 'undefined';

package/dist/cjs/execute.js

@@ -160,6 +160,7 @@ class ExecutionContext {
             const defaultPin = new PinDefinition_js_1.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) => {
@@ -729,31 +730,16 @@ class ExecutionContext {
         let rootValue;
         let useValue = item;
         if (trailers.length > 0) {
-            rootValue = useValue;
-            const trailersPath = trailers.join(".");
-            switch (type) {
-                case globals_js_1.ReferenceTypes.variable:
-                    useValue = rootValue;
-                    trailers.forEach(trailerPath => {
-                        useValue = useValue[trailerPath];
-                    });
-                    break;
-                case globals_js_1.ReferenceTypes.instance: {
-                    const tmpComponent = rootValue;
-                    if (tmpComponent.typeProp === globals_js_1.ComponentTypes.net) {
-                        const usedNet = this.scope.getNet(tmpComponent, new PinDefinition_js_1.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_js_1.ClassComponent) {
+                    useValue = useValue.parameters.get(trailers[i]);
                 }
-                case globals_js_1.ReferenceTypes.library: {
+                else if (useValue instanceof Net_js_1.Net) {
+                    useValue = useValue.params.get(trailers[i]);
+                }
+                else if (useValue instanceof types_js_1.ImportedLibrary) {
                     const funcName = trailers[0];
                     const library = rootValue;
                     const functionPath = `${library.libraryNamespace}${funcName}`;
@@ -768,7 +754,9 @@ class ExecutionContext {
                             value: foundFunc,
                         });
                     }
-                    break;
+                }
+                else {
+                    useValue = useValue[trailers[i]];
                 }
             }
         }
@@ -1016,52 +1004,6 @@ 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 = [
-                    globals_js_1.ParamKeys.angle,
-                    globals_js_1.ParamKeys.flip,
-                    globals_js_1.ParamKeys.flipX,
-                    globals_js_1.ParamKeys.flipY,
-                ];
-                if (unitModifiers.indexOf(paramName) !== -1) {
-                    if (paramName === globals_js_1.ParamKeys.flipX || paramName == globals_js_1.ParamKeys.flipY) {
-                        if (typeof value === "boolean") {
-                            value = value ? (0, NumericValue_js_2.numeric)(1) : (0, NumericValue_js_2.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/cjs/objects/Frame.js

@@ -25,6 +25,8 @@ 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/cjs/pipeline.js

@@ -161,8 +161,9 @@ async function renderScriptCustom(scriptData, outputPath, options, parseHandlers
     if (errors.length === 0 && throwError === undefined) {
         const { frameComponent } = visitor.applySheetFrameComponent();
         const { sequence, nets } = visitor.getGraph();
+        const documentVariable = visitor.getScope()
+            .variables.get(globals_js_1.GlobalDocumentName);
         if (enableBom && bomOutputPath) {
-            const documentVariable = visitor.getScope().variables.get('document');
             const bomConfig = documentVariable.bom;
             const bomData = (0, BomGeneration_js_1.generateBom)(bomConfig, visitor.getScope().getInstances());
             const bomCsvOutput = (0, BomGeneration_js_1.generateBomCSV)(bomData);
@@ -220,7 +221,7 @@ async function renderScriptCustom(scriptData, outputPath, options, parseHandlers
             const renderLogger = new logger_js_1.Logger();
             let svgCanvas;
             try {
-                svgCanvas = (0, render_js_1.renderSheetsToSVG)(sheetFrames, renderLogger);
+                svgCanvas = (0, render_js_1.renderSheetsToSVG)(sheetFrames, renderLogger, documentVariable);
             }
             catch (err) {
                 throw new utils_js_1.RenderError(`Error during SVG generation: ${err}`, 'svg_generation');

package/dist/cjs/render/render.js

@@ -25,7 +25,7 @@ function createSvgCanvas() {
     (0, sizing_js_1.applyFontsToSVG)(canvas);
     return canvas;
 }
-function renderSheetsToSVG(sheetFrames, logger) {
+function renderSheetsToSVG(sheetFrames, logger, documentVariable) {
     const canvas = createSvgCanvas();
     sheetFrames.forEach((sheet, index) => {
         const sheetGroup = canvas.group();
@@ -82,7 +82,13 @@ 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[Frame_js_1.FrameParamKeys.GridStyle],
+            color: documentVariable[Frame_js_1.FrameParamKeys.GridColor],
+        };
+        generateSVGChild(sheetElements, components, wires, junctions, mergedWires, allFrames, textObjects, gridProperties, logger);
         sheetElements.translate(xOffset, yOffset);
         sheetGroup.translate(0, sheetYOffset.toNumber());
     });
@@ -129,14 +135,15 @@ function generatePdfOutput(doc, canvas, sheetSize, sheetSizeDefined, zoomScale =
     });
 }
 exports.generatePdfOutput = generatePdfOutput;
-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 = (0, layout_js_1.getBounds)(components, wires, junctions, frameObjects);
+        gridProperties.gridBounds = (0, layout_js_1.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();
@@ -294,7 +301,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 = globals_js_1.defaultGridSizeUnits;
     const { xmin, ymin, xmax, ymax } = canvasSize;
     const extraValue = extendGrid ? 1 : 0;
@@ -312,6 +320,7 @@ function drawGrid(group, canvasSize, extendGrid, logger) {
     globals_js_1.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 = (0, helpers_js_1.milsToMM)(3);
     const startY = gridStartY.sub(smallOffset.half());
@@ -329,7 +338,7 @@ function drawGrid(group, canvasSize, extendGrid, logger) {
     })
         .stroke({
         width: strokeSize.toNumber(),
-        color: '#000'
+        color: useGridColor
     });
 }
 function drawSheetFrameBorder(frameGroup, frame) {

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

@@ -125,6 +125,8 @@ class SemanticTokensVisitor extends BaseVisitor_js_1.BaseVisitor {
                 });
             }
         };
+        this.visitTrailer = (ctx) => {
+        };
         this.lexer = lexer;
         this.script = script;
     }

package/dist/cjs/validate/SymbolValidatorVisitor.js

@@ -106,6 +106,8 @@ class SymbolValidatorVisitor extends BaseVisitor_js_1.BaseVisitor {
                 this.addSymbolVariable(ctxID.getSymbol(), ctxID.getText(), null);
             }
         };
+        this.visitTrailer = (ctx) => {
+        };
     }
     addSymbolVariable(token, name, value, executor = null) {
         const useExecutor = executor === null ? this.getExecutor() : executor;

package/dist/cjs/visitor.js

@@ -809,8 +809,19 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
         };
         this.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 types_js_1.AnyReference({
+                found: true,
+                value: useObject,
+                type: globals_js_1.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);
         };
         this.visitExpressions_block = (ctx) => {
             this.runExpressions(this.getExecutor(), ctx.expression());

package/dist/esm/BaseVisitor.js

@@ -4,20 +4,21 @@ import { CircuitScriptParserVisitor } from "./antlr/CircuitScriptParserVisitor.j
 import { ExecutionContext } from "./execute.js";
 import { Logger } from "./logger.js";
 import { ClassComponent } from "./objects/ClassComponent.js";
-import { NumberOperator, NumericValue, resolveToNumericValue } from "./objects/NumericValue.js";
+import { Net } from "./objects/Net.js";
+import { NumberOperator, numeric, NumericValue, resolveToNumericValue } from "./objects/NumericValue.js";
 import { PercentageValue } from "./objects/PercentageValue.js";
 import { Direction, AnyReference, UndeclaredReference, ImportedLibrary, ImportFunctionHandling as ImportFunctionHandling } from "./objects/types.js";
-import { BaseNamespace, ComponentTypes, DoubleDelimiter1, GlobalDocumentName, PinTypesList, ReferenceTypes, TrailerArrayIndex } from './globals.js';
+import { BaseNamespace, DoubleDelimiter1, GlobalDocumentName, ParamKeys, PinTypesList, ReferenceTypes, TrailerArrayIndex } from './globals.js';
 import { isReference, unwrapValue as unwrapValue } from "./utils.js";
 import { linkBuiltInMethods } from './builtinMethods.js';
 import { RuntimeExecutionError, throwWithContext } from './utils.js';
 import { SequenceAction } from './objects/ExecutionScope.js';
-import { PinId } from './objects/PinDefinition.js';
 import { computeContentHash } from './cache/hash.js';
 import { readCache, writeCache } from './cache/storage.js';
 import { serializeLibraryScope } from './cache/serializer.js';
 import { deserializeLibraryScope } from './cache/deserializer.js';
 import { resolveAllImportFilepaths } from './importResolver.js';
+import { Frame } from './objects/Frame.js';
 export class BaseVisitor extends CircuitScriptParserVisitor {
     startingContext;
     executionStack;
@@ -215,13 +216,24 @@ export class BaseVisitor extends CircuitScriptParserVisitor {
             currentReference = executor.resolveVariable(this.executionStack, atomId);
             this.log('reference:', currentReference.name, 'found:', currentReference.found);
         }
-        if (currentReference !== undefined && currentReference.found) {
+        currentReference = this.resolveTrailersForReference(currentReference, passedNetNamespace, ctx);
+        let resultValue = currentReference;
+        if (!keepReference) {
+            if (currentReference.type !== ReferenceTypes.pinType) {
+                resultValue = unwrapValue(resultValue);
+            }
+        }
+        this.setResult(ctx, resultValue);
+        this.log2('atom resolved: ' + ctx.getText() + ' -> ' + currentReference);
+    };
+    resolveTrailersForReference(reference, passedNetNamespace, ctx) {
+        if (reference !== undefined && reference.found) {
             ctx.trailer().forEach(ctxTrailer => {
                 this.setResult(ctxTrailer, {
-                    reference: currentReference,
+                    reference: reference,
                     netNamespace: passedNetNamespace
                 });
-                currentReference = this.visitResult(ctxTrailer);
+                reference = this.visitResult(ctxTrailer);
             });
         }
         else {
@@ -229,15 +241,8 @@ export class BaseVisitor extends CircuitScriptParserVisitor {
                 this.throwWithContext(ctx, `Function not found: ${ctx.getText()}`);
             }
         }
-        let resultValue = currentReference;
-        if (!keepReference) {
-            if (currentReference.type !== ReferenceTypes.pinType) {
-                resultValue = unwrapValue(resultValue);
-            }
-        }
-        this.setResult(ctx, resultValue);
-        this.log2('atom resolved: ' + ctx.getText() + ' -> ' + currentReference);
-    };
+        return reference;
+    }
     visitTrailer = (ctx) => {
         const { reference, netNamespace } = this.getResult(ctx);
         const ctxLParam = ctx.LParen();
@@ -276,68 +281,18 @@ export class BaseVisitor extends CircuitScriptParserVisitor {
         this.setResult(ctx, nextReference);
     };
     visitAssignment_expr = (ctx) => {
+        const lhsCtx = ctx.callable_expr();
+        this.setResult(lhsCtx, { keepReference: true });
+        const leftSideReference = this.visitResult(lhsCtx);
         if (ctx.Assign()) {
-            const lhsCtx = ctx.callable_expr();
-            this.setResult(lhsCtx, { keepReference: true });
-            const leftSideReference = this.visitResult(lhsCtx);
             const rhsCtx = ctx.data_expr();
             const rhsCtxResult = this.visitResult(rhsCtx);
+            const sequenceParts = [];
             if (isReference(rhsCtxResult) && !rhsCtxResult.found) {
                 this.throwWithContext(rhsCtx, rhsCtx.getText() + ' is not defined');
             }
             const rhsValue = unwrapValue(rhsCtxResult);
-            const { trailers = [] } = leftSideReference;
-            const sequenceParts = [];
-            if (trailers.length === 0) {
-                this.getScope().setVariable(leftSideReference.name, rhsValue);
-                let itemType = '';
-                if (rhsValue instanceof ClassComponent) {
-                    itemType = ReferenceTypes.instance;
-                    this.log2(`assigned '${leftSideReference.name}' to ClassComponent`);
-                }
-                else {
-                    itemType = ReferenceTypes.variable;
-                    this.getScope().setVariable(leftSideReference.name, rhsValue);
-                    this.log2(`assigned variable ${leftSideReference.name} to ${rhsValue}`);
-                }
-                sequenceParts.push(...[itemType, leftSideReference.name, rhsValue]);
-            }
-            else {
-                if (leftSideReference.rootValue instanceof ClassComponent) {
-                    this.setInstanceParam(leftSideReference.rootValue, trailers, rhsValue);
-                    this.log2(`assigned component param ${leftSideReference.rootValue} trailers: ${trailers} value: ${rhsValue}`);
-                    sequenceParts.push(...['instance', [leftSideReference.rootValue, trailers], rhsValue]);
-                    if (leftSideReference.rootValue.typeProp === ComponentTypes.net) {
-                        const net = this.getScope().getNet(leftSideReference.rootValue, new PinId(1));
-                        if (net) {
-                            const trailerValue = trailers.join(".");
-                            net.params.set(trailerValue, rhsValue);
-                        }
-                    }
-                }
-                else if (leftSideReference.rootValue instanceof Object) {
-                    if (Array.isArray(trailers[0]) && trailers[0][0] === TrailerArrayIndex) {
-                        if (Array.isArray(leftSideReference.rootValue)) {
-                            const arrayIndexValue = trailers[0][1];
-                            leftSideReference.rootValue[arrayIndexValue] = rhsValue;
-                            this.log2(`assigned array index ${leftSideReference.rootValue} index: ${arrayIndexValue} value: ${rhsValue}`);
-                        }
-                        else {
-                            this.throwWithContext(lhsCtx, "Invalid array");
-                        }
-                    }
-                    else {
-                        let expandedValue = leftSideReference.rootValue;
-                        trailers.slice(0, -1).forEach(trailer => {
-                            expandedValue = expandedValue[trailer];
-                        });
-                        const lastTrailer = trailers.slice(-1)[0];
-                        expandedValue[lastTrailer] = rhsValue;
-                        this.log2(`assigned object ${leftSideReference.rootValue} trailers: ${trailers} value: ${rhsValue}`);
-                    }
-                    sequenceParts.push(...['variable', [leftSideReference.rootValue, trailers], rhsValue]);
-                }
-            }
+            this.assignValueToReference(sequenceParts, leftSideReference, lhsCtx, rhsValue);
             if (sequenceParts.length > 0) {
                 this.getScope().sequence.push([
                     SequenceAction.Assign, ...sequenceParts
@@ -346,24 +301,21 @@ export class BaseVisitor extends CircuitScriptParserVisitor {
             this.setResult(ctx, rhsValue);
         }
         else {
-            const ctxCallable = ctx.callable_expr();
-            this.setResult(ctxCallable, { keepReference: true });
-            const reference = this.visitResult(ctx.callable_expr());
             const value = this.visitResult(ctx.data_expr());
-            if (!reference.found) {
-                this.throwWithContext(ctx, 'Undefined reference: ' + reference.name);
+            if (!leftSideReference.found) {
+                this.throwWithContext(ctx, 'Undefined reference: ' + leftSideReference.name);
             }
-            const trailers = reference.trailers ?? [];
+            const trailers = leftSideReference.trailers ?? [];
             let currentValue = null;
             if (trailers.length === 0) {
-                currentValue = this.getExecutor().scope.variables.get(reference.name);
+                currentValue = this.getExecutor().scope.variables.get(leftSideReference.name);
             }
             else {
-                if (reference.value instanceof ClassComponent) {
-                    currentValue = this.getInstanceParam(reference.value, trailers);
+                if (leftSideReference.value instanceof ClassComponent) {
+                    currentValue = this.getInstanceParam(leftSideReference.value, trailers);
                 }
-                else if (reference.value instanceof Object) {
-                    currentValue = reference.value[trailers.join('.')];
+                else if (leftSideReference.value instanceof Object) {
+                    currentValue = leftSideReference.value[trailers.join('.')];
                 }
             }
             if (currentValue === null) {
@@ -389,20 +341,59 @@ export class BaseVisitor extends CircuitScriptParserVisitor {
             else {
                 this.throwWithContext(ctx, 'Operator assignment failed: could not perform operator');
             }
-            if (trailers.length === 0) {
-                this.getExecutor().scope.setVariable(reference.name, newValue);
+            this.assignValueToReference([], leftSideReference, lhsCtx, newValue);
+            this.setResult(ctx, newValue);
+        }
+    };
+    assignValueToReference(sequenceParts, leftSideReference, lhsCtx, rhsValue) {
+        const { trailers = [] } = leftSideReference;
+        if (trailers.length === 0) {
+            this.getScope().setVariable(leftSideReference.name, rhsValue);
+            let itemType = '';
+            if (rhsValue instanceof ClassComponent) {
+                itemType = ReferenceTypes.instance;
+                this.log2(`assigned '${leftSideReference.name}' to ClassComponent`);
             }
             else {
-                if (reference.value instanceof ClassComponent) {
-                    this.setInstanceParam(reference.value, trailers, newValue);
+                itemType = ReferenceTypes.variable;
+                this.getScope().setVariable(leftSideReference.name, rhsValue);
+                this.log2(`assigned variable ${leftSideReference.name} to ${rhsValue}`);
+            }
+            sequenceParts.push(...[itemType, leftSideReference.name, rhsValue]);
+        }
+        else {
+            if (leftSideReference.rootValue instanceof ClassComponent) {
+                this.setInstanceParam(leftSideReference.rootValue, trailers, rhsValue);
+                this.log2(`assigned component param ${leftSideReference.rootValue} trailers: ${trailers} value: ${rhsValue}`);
+                sequenceParts.push(...['instance', [leftSideReference.rootValue, trailers], rhsValue]);
+            }
+            else if (leftSideReference.rootValue instanceof Frame) {
+                leftSideReference.rootValue.parameters.set(trailers[0], rhsValue);
+            }
+            else if (leftSideReference.rootValue instanceof Object) {
+                if (Array.isArray(trailers[0]) && trailers[0][0] === TrailerArrayIndex) {
+                    if (Array.isArray(leftSideReference.rootValue)) {
+                        const arrayIndexValue = trailers[0][1];
+                        leftSideReference.rootValue[arrayIndexValue] = rhsValue;
+                        this.log2(`assigned array index ${leftSideReference.rootValue} index: ${arrayIndexValue} value: ${rhsValue}`);
+                    }
+                    else {
+                        this.throwWithContext(lhsCtx, "Invalid array");
+                    }
                 }
-                else if (reference.value instanceof Object) {
-                    reference.value[trailers.join('.')] = newValue;
+                else {
+                    let expandedValue = leftSideReference.rootValue;
+                    trailers.slice(0, -1).forEach(trailer => {
+                        expandedValue = expandedValue[trailer];
+                    });
+                    const lastTrailer = trailers.slice(-1)[0];
+                    expandedValue[lastTrailer] = rhsValue;
+                    this.log2(`assigned object ${leftSideReference.rootValue} trailers: ${trailers} value: ${rhsValue}`);
                 }
+                sequenceParts.push(...['variable', [leftSideReference.rootValue, trailers], rhsValue]);
             }
-            this.setResult(ctx, newValue);
         }
-    };
+    }
     getReference(ctx) {
         const atomStr = ctx.getText();
         if (atomStr.indexOf('(') !== -1 || atomStr.indexOf(')') !== -1) {
@@ -417,65 +408,6 @@ export class BaseVisitor extends CircuitScriptParserVisitor {
         }
         return reference;
     }
-    visitTrailer_expr2 = (ctx) => {
-        const reference = this.getResult(ctx);
-        const ctxID = ctx.ID();
-        const ctxDataExpr = ctx.data_expr();
-        const useValue = reference.value;
-        let nextReference;
-        if (ctxID) {
-            reference.trailers.push(ctxID.getText());
-            const useRootValue = reference.rootValue ?? reference.value;
-            const useTrailerIndex = reference.trailerIndex ?? 0;
-            nextReference = this.getExecutor().resolveTrailers(reference.type, useRootValue, reference.trailers);
-            nextReference.name =
-                [reference.name,
-                    ...reference.trailers.slice(useTrailerIndex)].join('.');
-        }
-        else if (ctxDataExpr) {
-            const arrayIndex = this.visitResult(ctxDataExpr);
-            if (arrayIndex instanceof NumericValue) {
-                const arrayIndexValue = arrayIndex.toNumber();
-                const foundValue = useValue[arrayIndexValue];
-                const refType = foundValue instanceof ClassComponent
-                    ? ReferenceTypes.instance : ReferenceTypes.variable;
-                nextReference = new AnyReference({
-                    found: true,
-                    type: refType,
-                    value: foundValue,
-                    trailers: [[TrailerArrayIndex, arrayIndexValue]],
-                    rootValue: useValue
-                });
-            }
-        }
-        this.setResult(ctx, nextReference);
-    };
-    visitAtom_expr = (ctx) => {
-        const executor = this.getExecutor();
-        const firstId = ctx.ID(0);
-        const atomId = firstId.getText();
-        let currentReference;
-        if (PinTypesList.indexOf(atomId) !== -1) {
-            currentReference = new AnyReference({
-                found: true,
-                value: atomId,
-                type: ReferenceTypes.pinType,
-            });
-        }
-        else {
-            this.log('resolve variable ctx: ' + ctx.getText(), 'atomId', atomId);
-            currentReference = executor.resolveVariable(this.executionStack, atomId);
-            this.log('reference:', currentReference.name, 'found:', currentReference.found);
-        }
-        if (currentReference !== undefined && currentReference.found) {
-            ctx.trailer_expr2().forEach(ctxTrailer => {
-                this.setResult(ctxTrailer, currentReference);
-                currentReference = this.visitResult(ctxTrailer);
-            });
-        }
-        this.setResult(ctx, currentReference);
-        this.log2('atom resolved: ' + ctx.getText() + ' -> ' + currentReference);
-    };
     handleFunctionCall(currentReference, passedNetNamespace, ctx) {
         const executor = this.getExecutor();
         let parameters = [];
@@ -1049,9 +981,40 @@ export class BaseVisitor extends CircuitScriptParserVisitor {
         return result;
     }
     setInstanceParam(object, trailers, value) {
-        const paramName = trailers[0];
-        object.setParam(paramName, value);
-        this.log2(`set instance ${object.instanceName} param ${paramName} to ${value}`);
+        if (trailers.length === 1) {
+            const paramName = trailers[0];
+            if (paramName === ParamKeys.flipX || paramName == ParamKeys.flipY) {
+                if (typeof value === "boolean") {
+                    value = value ? numeric(1) : numeric(0);
+                }
+            }
+            object.setParam(paramName, value);
+            const unitModifiers = [
+                ParamKeys.angle,
+                ParamKeys.flip,
+                ParamKeys.flipX,
+                ParamKeys.flipY,
+            ];
+            if (unitModifiers.indexOf(paramName) !== -1) {
+                object.getUnit().setParam(paramName, value);
+            }
+            this.log2(`set instance ${object.instanceName} param ${paramName} to ${value}`);
+        }
+        else {
+            let reference = null;
+            for (let i = 0; i < trailers.length; i++) {
+                const trailer = trailers[i];
+                if (i === 0) {
+                    reference = object.getParam(trailer);
+                }
+                else {
+                    if (reference instanceof Net) {
+                        const remainingTrailers = trailers.slice(i);
+                        reference.params.set(remainingTrailers.join("."), value);
+                    }
+                }
+            }
+        }
     }
     getInstanceParam(object, trailers) {
         const paramName = trailers[0];