circuitscript 0.0.22 → 0.0.25

package/src/helpers.ts

@@ -1,114 +0,0 @@
-import { writeFileSync } from "fs";
-import { generateKiCADNetList } from "./export.js";
-import { LayoutEngine } from "./layout.js";
-import { SequenceAction } from "./objects/ExecutionScope.js";
-import { parseFileWithVisitor } from "./parser.js";
-import { generateSVG2 } from "./render.js";
-import { SimpleStopwatch } from "./utils.js";
-import { MainVisitor } from "./visitor.js";
-
-export function renderScript(scriptData: string, outputPath: string, options): string {
-
-    const {
-        currentDirectory = null, 
-        defaultLibsPath,
-        dumpNets = false,
-        dumpData = false,
-        kicadNetlistPath = null,
-        showStats = false} = options;
-
-    const visitor = new MainVisitor(true);
-
-    visitor.onImportFile = visitor.createImportFileHandler(currentDirectory, defaultLibsPath);
-
-    visitor.print('reading file');
-    visitor.print('done reading file');
-
-    const { tree, parser,
-        hasParseError, hasError, 
-        parserTimeTaken, 
-        lexerTimeTaken } = parseFileWithVisitor(visitor, scriptData);
-
-    showStats && console.log('Lexing took:', lexerTimeTaken);
-    showStats && console.log('Parsing took:', parserTimeTaken);
-    dumpNets && console.log(visitor.dumpNets());
-
-    dumpData && writeFileSync('dump/tree.lisp', tree.toStringTree(null, parser));
-    dumpData && writeFileSync('dump/raw-parser.txt', visitor.logger.dump());
-    
-    if (hasError || hasParseError) {
-        console.log('Error while parsing');
-        return null;
-    }
-
-    try {
-        visitor.annotateComponents();
-    } catch (err) {
-        console.log('Error during annotation: ', err);
-    }
-
-    if (kicadNetlistPath) {
-        const kicadNetList = generateKiCADNetList(visitor.getNetList());
-        writeFileSync(kicadNetlistPath, kicadNetList);
-        console.log('Generated KiCad netlist file');
-    }
-    
-
-    // await writeFile('dump/raw-netlist.json', JSON.stringify(visitor.dump2(), null, 2));
-
-    const { sequence, nets } = visitor.getGraph();
-
-    // const tmpInstances = visitor.getExecutor().scope.instances;
-    // for (const [instanceName, instance] of tmpInstances){
-    //     console.log(instanceName);
-    //     console.log(instance.pinNets);
-    // }
-
-
-    const tmpSequence = sequence.map(item => {
-        const tmp = [...item];
-
-        const action = tmp[0];
-
-        if (action === SequenceAction.Wire) {
-            tmp[2] = tmp[2].map(item2 => {
-                return [item2.direction, item2.value].join(",");
-            }).join(" ");
-        } else if (action === SequenceAction.Frame) {
-            tmp[1] = item[1].frameId;
-            
-        } else if (action !== SequenceAction.WireJump) {
-            tmp[1] = item[1].instanceName;
-        }
-
-        return tmp.join(" | ");
-    });
-
-    dumpData && writeFileSync('dump/raw-sequence.txt', tmpSequence.join('\n'));
-    let svgOutput: string = null;
-
-    try {
-        const layoutEngine = new LayoutEngine();
-        const layoutTimer = new SimpleStopwatch();
-
-        const graph = layoutEngine.runLayout(sequence, nets);
-
-        layoutEngine.printWarnings();
-
-        showStats && console.log('Layout took:', layoutTimer.lap());
-
-        dumpData && writeFileSync('dump/raw-layout.txt', layoutEngine.logger.dump());
-
-        const generateSvgTimer = new SimpleStopwatch();
-        svgOutput = generateSVG2(graph);
-        showStats && console.log('Render took:', generateSvgTimer.lap());
-
-        if (outputPath) {
-            writeFileSync(outputPath, svgOutput);
-        }
-    } catch (err) {
-        console.log('Error during render: ', err);
-    }
-
-    return svgOutput;
-}

package/src/lexer.ts

@@ -1,151 +0,0 @@
-/**
- * Adapted from: 
- *  https://github.com/antlr/grammars-v4/blob/master/python/python3/TypeScript/Python3LexerBase.ts
- */
-
-import { CommonToken, CharStream, Token } from "antlr4";
-import CircuitScriptParser from "./antlr/CircuitScriptParser.js";
-import CircuitScriptLexer from "./antlr/CircuitScriptLexer.js";
-
-export class MainLexer extends CircuitScriptLexer {
-
-    // A queue where extra tokens are pushed on (see the NEWLINE lexer rule).
-    tokens: any[];
-
-    // The stack that keeps track of the indentation level.
-    indents: any[];
-
-    // The amount of opened braces, brackets and parenthesis.
-    opened: number;
-
-    constructor(input: CharStream) {
-        super(input);
-        this.tokens = [];
-        this.indents = [];
-        this.opened = 0;
-    }
-
-    reset(): void {
-        this.tokens = [];
-        this.indents = [];
-        this.opened = 0;
-
-        super.reset();
-    }
-
-    emitToken(token: Token): void {
-        super.emitToken(token);
-        this.tokens.push(token);
-    }
-
-    nextToken(): Token {
-        // Check if the end-of-file is ahead and there are still some DEDENTS expected.
-        if (this._input.LA(1) === CircuitScriptParser.EOF && this.indents.length) {
-            // Remove any trailing EOF tokens from our buffer.
-            this.tokens = this.tokens.filter(function (val) {
-                return val.type !== CircuitScriptParser.EOF;
-            });
-            // First emit an extra line break that serves as the end of the statement.
-            this.emitToken(this.commonToken(CircuitScriptParser.NEWLINE, "\n"));
-            // Now emit as much DEDENT tokens as needed.
-            while (this.indents.length) {
-                this.emitToken(this.createDedent());
-                this.indents.pop();
-            }
-            // Put the EOF back on the token stream.
-            this.emitToken(this.commonToken(CircuitScriptParser.EOF, "<EOF>"));
-        }
-        const next = super.nextToken();
-        return this.tokens.length ? this.tokens.shift() : next;
-    }
-
-    createDedent(): Token {
-        return this.commonToken(CircuitScriptParser.DEDENT, "");
-    }
-
-    getCharIndex(): number {
-        return this._input.index;
-    }
-
-    commonToken(type: number, text: string): Token {
-        const stop = this.getCharIndex() - 1;
-        const start = text.length ? stop - text.length + 1 : stop;
-        const token = new CommonToken([this, this._input], type, 0, start, stop);
-
-        let tokenTypeString: string;
-        if (type === CircuitScriptParser.INDENT) {
-            tokenTypeString = "indent";
-        } else if (type === CircuitScriptParser.DEDENT) {
-            tokenTypeString = "dedent";
-        }
-
-        if (tokenTypeString) {
-            token.text = tokenTypeString;
-        }
-
-        return token;
-    }
-
-    getIndentationCount(whitespace: string): number {
-        let count = 0;
-        for (let i = 0; i < whitespace.length; i++) {
-            if (whitespace[i] === '\t') {
-                count += 8 - count % 8;
-            } else {
-                count++;
-            }
-        }
-        return count;
-    }
-
-    atStartOfInput(): boolean {
-        return this.getCharIndex() === 0;
-    }
-
-    openBrace(): void {
-        this.opened++;
-    }
-
-    closeBrace(): void {
-        this.opened--;
-    }
-
-    onNewLine(): void {
-        const newLine = this.text.replace(/[^\r\n]+/g, '');
-        const spaces = this.text.replace(/[\r\n]+/g, '');
-
-        // Strip newlines inside open clauses except if we are near EOF. We keep NEWLINEs near EOF to
-        // satisfy the final newline needed by the single_put rule used by the REPL.
-        const next = this._input.LA(1);
-        const nextnext = this._input.LA(2);
-
-        if (this.opened > 0 || (nextnext != -1 /* EOF */ &&
-            (next === 13 /* '\r' */ || next === 10 /* '\n' */ || next === 35 /* '#' */))) {
-
-            // If we're inside a list or on a blank line, ignore all indents,
-            // dedents and line breaks.
-            this.skip();
-
-        } else {
-            this.emitToken(this.commonToken(CircuitScriptParser.NEWLINE, newLine));
-
-            const indent = this.getIndentationCount(spaces);
-            const previous = this.indents.length ? this.indents[this.indents.length - 1] : 0;
-
-            if (indent === previous) {
-                // skip indents of the same size as the present indent-size
-                this.skip();
-            } else if (indent > previous) {
-                this.indents.push(indent);
-                this.emitToken(this.commonToken(CircuitScriptParser.INDENT, spaces));
-            } else {
-                // Possibly emit more than 1 DEDENT token.
-                while (this.indents.length && this.indents[this.indents.length - 1] > indent) {
-                    this.emitToken(this.createDedent());
-                    this.indents.pop();
-                }
-            }
-        }
-    }
-}
-

package/src/logger.ts

@@ -1,17 +0,0 @@
-export class Logger {
-
-    logs: string[] = [];
-
-    constructor() {
-        this.add((new Date()).toISOString());
-        this.add('starting logger...');
-    }
-
-    add(message: string): void {
-        this.logs.push((new Date()).toISOString()+" | " + message);
-    }
-
-    dump(): string {
-        return this.logs.join('\n');
-    }
-}

package/src/objects/ClassComponent.ts

@@ -1,223 +0,0 @@
-import { SymbolDrawingCommands } from '../draw_symbols.js';
-import { Net } from './Net.js';
-import { PinDefinition, PinIdType } from './PinDefinition.js';
-import { PinTypes } from './PinTypes.js';
-import { WireSegment } from './Wire.js';
-
-export class ClassComponent {
-
-    // A component has an instance_name to identify it
-    // num_pins: The maximum number of pins that are avaible from this component
-    // Note: the pin number starts from 1
-
-    instanceName: string;
-    numPins: number;
-
-    parameters: Map<string, number | string> = new Map();
-
-    // Maps pin indexes to the pin definition
-    pins: Map<number, PinDefinition> = new Map();
-
-    // Maps pin indexes to the nets.
-    pinNets: Map<number, Net> = new Map();
-
-    pinWires: Map<number, WireSegment[]> = new Map();
-
-    // The cached values are used for easier comparison/equality check.
-    _cachedPins: string;
-    _cachedParams: string;
-
-    className: string;
-
-    // For nets, labels and gnds, this can be used to identify different
-    // copies of the same symbol on the schematic
-    _copyID?: number = null;
-    _copyFrom?: ClassComponent = null;
-
-    // This determines how pins are arrange on the component/symbol.
-    arrangeProps: Map<string, number[]> | null = null;
-
-    // Used to identify what graphic to draw for this symbol
-    displayProp: string | SymbolDrawingCommands | null = null;
-
-    widthProp: number | null = null;
-
-    typeProp: string | null = null;
-
-    styles: { [key: string]: number | string } = {};
-
-    assignedRefDes: string | null = null;
-
-    constructor(instanceName: string, numPins: number, className: string) {
-        this.instanceName = instanceName;
-        this.numPins = numPins;
-        this.className = className;
-    }
-
-    setupPins(): void {
-        // Let pin index start from 1.
-        for (let i = 1; i < this.numPins + 1; i++) {
-            const pinIndex = i;
-            this.pins.set(
-                pinIndex,
-                new PinDefinition(
-                    pinIndex,
-                    PinIdType.Int,
-                    pinIndex.toString(),
-                    PinTypes.Any,
-                ),
-            );
-        }
-
-        this.refreshPinsCache();
-    }
-
-    getDefaultPin(): number {
-        // Return id of the default pin
-        return 1;
-    }
-
-    hasPin(pinId: number | string): boolean {
-        if (typeof pinId === 'number') {
-            return this.pins.has(pinId);
-        } else {
-            // assume is string
-            for (const [, pinDef] of this.pins) {
-                if (
-                    pinDef.name === pinId ||
-                    pinDef.altNames.indexOf(pinId) !== -1
-                ) {
-                    return true;
-                }
-            }
-        }
-
-        return false;
-    }
-
-    getPin(pinId: number | string): number {
-        // Given a pinId, which is either a number of string,
-        // this returns the pin index in the component.
-        // If the pinId does not match, then a -1 is returned.
-
-        if (typeof pinId === 'number') {
-            return pinId;
-        } else {
-            // assume is string
-            for (const [pin, pinDef] of this.pins) {
-                if (
-                    pinDef.name === pinId ||
-                    pinDef.altNames.indexOf(pinId) !== -1
-                ) {
-                    return pin;
-                }
-            }
-
-            return -1;
-        }
-    }
-
-    getNextPinAfter(pinIndex: number): number {
-        if (pinIndex + 1 <= this.numPins) {
-            return pinIndex + 1;
-        } else {
-            // No more next pin, so just wrap around.
-            // Might not be the right behaviour...
-            return 1;
-        }
-    }
-
-    setParam(key: string, value: number | string): void {
-        this.parameters.set(key, value);
-        this.refreshParamCache();
-    }
-
-    private refreshParamCache(): void {
-        this._cachedParams = 
-            JSON.stringify(Object.fromEntries(this.parameters));
-    }
-
-    private refreshPinsCache(): void {
-        this._cachedPins = JSON.stringify(Object.fromEntries(this.pins));
-    }
-
-    refreshCache(): void {
-        this.refreshParamCache();
-        this.refreshPinsCache();
-    }
-
-    getParam(key: string): number | string {
-        if (this.parameters.has(key)) {
-            return this.parameters.get(key);
-        } else {
-            throw 'Invalid parameter key';
-        }
-    }
-
-    toString(): string {
-        return this.instanceName;
-    }
-
-    static simple(
-        instanceName: string,
-        numPins: number,
-        className: string,
-    ): ClassComponent {
-        const component = new ClassComponent(instanceName, numPins, className);
-        component.setupPins();
-        return component;
-    }
-
-    isEqual(other: ClassComponent): boolean {
-        // Use manual comparison as this is faster than lodash.
-        // Make sure that all important props are added.
-        return this.instanceName === other.instanceName 
-            && this.numPins === other.numPins
-            && this.className === other.className
-            && this._copyID === other._copyID
-            && this.arrangeProps === other.arrangeProps
-            && this.displayProp === other.displayProp 
-            && this.widthProp === other.widthProp
-            && this.typeProp === other.typeProp
-            && this._cachedPins === other._cachedPins
-            && this._cachedParams === other._cachedParams;
-    }
-
-    clone(): ClassComponent {
-        // returns new copy
-        const component = new ClassComponent(
-            this.instanceName, this.numPins, this.className);
-
-        component._copyID = this._copyID;
-        component.arrangeProps = this.arrangeProps;
-        component.widthProp = this.widthProp;
-        component.typeProp = this.typeProp;
-
-
-        if (this.displayProp) {
-            if (typeof this.displayProp === "string") {
-                component.displayProp = this.displayProp;
-            } else if (this.displayProp instanceof SymbolDrawingCommands) {
-                // Do a proper clone, otherwise, cloned objects will share the 
-                // same drawing object.
-                component.displayProp =
-                    (this.displayProp as SymbolDrawingCommands).clone();
-            }
-        }
-
-        for (const [key, value] of this.parameters) {
-            component.parameters.set(key, value);
-        }
-
-        for (const [key, value] of this.pins) {
-            component.pins.set(key, value);
-        }
-
-        for (const key in this.styles) {
-            component.styles[key] = this.styles[key];
-        }
-
-        component.refreshCache();
-        return component;
-    }
-}

package/src/objects/ExecutionScope.ts

@@ -1,201 +0,0 @@
-import { ClassComponent } from './ClassComponent.js';
-import { Net } from './Net.js';
-import { CFunction, ComponentPinNet, ComponentPinNetPair, ValueType } from './types.js';
-import { LayoutDirection } from '../globals.js';
-import { Wire, WireSegment } from './Wire.js';
-import { Frame } from './Frame.js';
-
-export class ExecutionScope {
-    scopeId: number;
-    private nets: ComponentPinNetPair[] = [];
-
-    instances: Map<string, ClassComponent> = new Map();
-
-    functions: Map<string, CFunction> = new Map();
-
-    variables: Map<string, ValueType | ClassComponent> = new Map();
-
-    blockStack: Map<number, any> = new Map();
-
-    wires: Wire[] = [];
-    frames: Frame[] = [];
-
-    indentLevel = 0;
-    netCounter = 1;
-    unnamedCounter = 1;
-
-    currentComponent: ClassComponent | null = null;
-    currentPin: number | null = null;
-
-    currentWireId = -1;
-    currentFrameId = -1;
-
-    netGnd: Net | null = null;
-
-    // This is the main gnd net of the circuit scope
-    componentGnd: ClassComponent | null = null;
-
-    // This is the first component in the circuit scope
-    componentRoot: ClassComponent | null = null;
-    
-    // Tracks the counter for copies of each component instance
-    // Copies are the same component electrically, but different symbols.
-    copyIDs: Map<string, number> = new Map();
-
-    // Determines how components are added/joined on the graph graphically.
-    // This is very important in "building" up the graph
-    // according to the user's order.
-    sequence: any[] = [];
-    
-    constructor(scopeId: number) {
-        this.scopeId = scopeId;
-    }
-
-    static scopeId = 0;
-
-    static create(): ExecutionScope {
-        const scope = new ExecutionScope(ExecutionScope.scopeId);
-        ExecutionScope.scopeId += 1;
-        return scope;
-    }
-
-    private findNet(component: ClassComponent, pin: number): ComponentPinNetPair {
-        return this.nets.find(([tmpComponent, tmpPin]) => {
-            // Use manual equality, much faster than using lodash
-            return tmpComponent.isEqual(component) && tmpPin === pin;
-        });
-    }
-
-    getNetWithName(name: string): Net {
-        const found = this.nets.find(([,, net]) => {
-            return net.name === name;
-        });
-        
-        return found ? found[2]: null;
-    }
-
-    hasNet(component: ClassComponent, pin: number): boolean {
-        return this.findNet(component, pin) !== undefined;
-    }
-
-    getNet(component: ClassComponent, pin: number): Net {
-        const result = this.findNet(component, pin);
-        if (result) {
-            return result[2]; // net
-        }
-
-        return null;
-    }
-
-    setNet(component: ClassComponent, pin: number, net: Net): void {
-        const pair = this.findNet(component, pin);
-        const result = this.nets.indexOf(pair);
-
-        if (result === -1) {
-            this.nets.push([component, pin, net]);
-        } else {
-            this.nets[result][2] = net;
-        }
-
-        component.pinNets.set(pin, net);
-    }
-
-    removeNet(component: ClassComponent, pin: number): void {
-        const pair = this.findNet(component, pin);
-        const result = this.nets.indexOf(pair);
-
-        if (result !== -1) {
-            this.nets.splice(result, 1);
-        }
-
-        component.pinNets.delete(pin);
-    }
-
-    getNets(): ComponentPinNetPair[] {
-        return this.nets;
-    }
-
-    dumpNets(): ComponentPinNet[] {
-        const sortedNet = [...this.nets].sort((a, b) => {
-            const netA = a[2];
-            const netB = b[2];
-
-            const netAId = netA.namespace + netA.name;
-            const netBId = netB.namespace + b[2].name;
-
-            if (netAId > netBId) {
-                return 1;
-            } else if (netAId < netBId) {
-                return -1;
-            } else {
-                return 0;
-            }
-        });
-
-        return sortedNet.map(([component, pin, net]) => {
-            return [net.namespace + net.name, component.instanceName, pin];
-        });
-    }
-
-    printNets(): void {
-        this.dumpNets().forEach(item => {
-            const [netName, instanceName, pin] = item;
-            console.log(netName.padEnd(10), '=>', instanceName, pin);
-        });
-    }
-    
-    setActive(type: ActiveObject, item: any): void {
-        // Reset the state and ensure that only one of the 
-        // active object is selected.
-
-        this.clearActive();
-
-        if (type === ActiveObject.Wire) {
-            this.currentWireId = item;
-        } else if (type === ActiveObject.Frame) {
-            this.currentFrameId = item;
-        }
-    }
-
-    clearActive(): void {
-        // Clears any current selected wire or frame
-        this.currentWireId = -1;
-        this.currentFrameId = -1;
-    }
-}
-
-export enum SequenceAction {
-    // Link current insertion point to component pin
-    To = 'to',
-
-    // Move insertion point at component pin
-    At = 'at',
-
-    // Link current insertion point with wire of given segments
-    Wire = 'wire',
-
-    // Jump to wire with target ID. Pin 0 of wire is the start of the 
-    // wire, pin 1 is the other end of the wire.
-    WireJump = 'wire-jump',
-
-    // Creates a new frame group
-    Frame = 'frame',
-}
-
-export enum FrameAction {
-    Enter = 'enter',
-    Exit = 'exit',
-}
-
-export enum ActiveObject {
-    Frame = 'frame',
-    Wire = 'wire',
-}
-
-
-export type SequenceItem =
-    [SequenceAction.To | SequenceAction.At, ClassComponent, number, LayoutDirection?, string?]
-    | [SequenceAction.Wire, wireId: number, WireSegment[]]
-    | [SequenceAction.WireJump, wireId: number, pinId: number]
-    | [SequenceAction.Frame, Frame, "enter" | "exit"]
-    ;