circuitscript 0.0.21 → 0.0.24

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/main.ts

@@ -1,105 +0,0 @@
-#! /usr/bin/env node
-
-import { program } from 'commander';
-import figlet from 'figlet';
-import path from 'path';
-import { fileURLToPath } from 'url';
-import { readFileSync, watch } from 'fs';
-
-import { prepareSizing } from './sizing.js';
-import { renderScript } from './helpers.js';
-
-export default async function main(): Promise<void> {
-    const toolSrcPath = fileURLToPath(import.meta.url);
-
-    const toolDirectory = path.dirname(toolSrcPath) + '/../../';
-    const fontsPath = toolDirectory + '/fonts';
-    const defaultLibsPath = toolDirectory + '/libs'; 
-    
-    const packageJson = JSON.parse(readFileSync(toolDirectory + 'package.json').toString());;
-    const {version} = packageJson;
-
-    program
-        .description('generate graphical output from circuitscript files')
-        .version(version)
-        .option('-i, --input text <input text>', 'Input text directly')
-        .option('-f, --input-file <path>', 'Input file')
-        .option('-o, --output <path>', 'Output path')
-        .option('-c, --current-directory <path>', 'Set current directory')
-        .option('-k, --kicad-netlist <filename>', 'Create KiCad netlist')
-        .option('-w, --watch', 'Watch for file changes')
-        .option('-n, --dump-nets', 'Dump out net information')
-        .option('-d, --dump-data', 'Dump data during parsing')
-        .option('-s, --stats', 'Show stats during generation')
-        ;
-
-    program.addHelpText('before', figlet.textSync('circuitscript', {
-        font: 'Small Slant'
-    }));
-
-    if (process.argv.length < 3){
-        program.help();
-    }
-    
-    program.parse();    
-
-    const options = program.opts();
-
-    const watchFileChanges = options.watch;
-    const outputPath = options.output ?? null;
-    const dumpNets = options.dumpNets;
-    const dumpData = options.dumpData;
-    const kicadNetlist = options.kicadNetlist;
-
-    let currentDirectory = options.currentDirectory ?? null;
-
-    if (watchFileChanges) {
-        console.log('watching for file changes...');
-    }
-
-    await prepareSizing(fontsPath);
-
-    let inputFilePath: string = null;
-
-    let scriptData: string;
-    if (options.input) {
-        scriptData = options.input;
-    } else {
-        inputFilePath = options.inputFile; // this should be provided
-        scriptData = readFileSync(inputFilePath, { encoding: 'utf-8' });
-
-        if (currentDirectory === null) {
-            currentDirectory = path.dirname(inputFilePath);
-        }
-    }    
-
-    const renderOptions = {
-        currentDirectory,
-        defaultLibsPath,
-        dumpNets, 
-        dumpData,
-        kicadNetlistPath: kicadNetlist,
-        showStats: options.stats,
-    }
-
-    const output = renderScript(scriptData, outputPath,
-        renderOptions);
-
-    if (outputPath === null && output){
-        console.log(output);
-    }
-
-    if (watchFileChanges) {
-        watch(inputFilePath, event => {
-            if (event === 'change') {
-                const scriptData = readFileSync(inputFilePath, 
-                    {encoding: 'utf-8'});
-
-                renderScript(scriptData, outputPath, renderOptions);
-                console.log('done');
-            }
-        });
-    }
-}
-
-main();

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;
-    }
-}