circuitscript 0.0.24 → 0.0.25

package/dist/cjs/parser.js

@@ -1,298 +1,69 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CircuitscriptParserErrorListener = exports.SemanticTokensVisitor = exports.parseFileWithVisitor = void 0;
-const antlr4_1 = require("antlr4");
-const CircuitScriptParser_js_1 = __importStar(require("./antlr/CircuitScriptParser.js"));
+exports.CircuitscriptParserErrorListener = exports.TempErrorStrategy = exports.parseFileWithVisitor = void 0;
+const CircuitScriptParser_js_1 = require("./antlr/CircuitScriptParser.js");
 const lexer_js_1 = require("./lexer.js");
 const utils_js_1 = require("./utils.js");
+const antlr4ng_1 = require("antlr4ng");
 function parseFileWithVisitor(visitor, data) {
-    const chars = new antlr4_1.CharStream(data);
+    const chars = antlr4ng_1.CharStream.fromString(data);
     const lexer = new lexer_js_1.MainLexer(chars);
     const lexerTimer = new utils_js_1.SimpleStopwatch();
-    const tokens = new antlr4_1.CommonTokenStream(lexer);
+    const tokens = new antlr4ng_1.CommonTokenStream(lexer);
     tokens.fill();
     const lexerTimeTaken = lexerTimer.lap();
     const parserTimer = new utils_js_1.SimpleStopwatch();
-    const parser = new CircuitScriptParser_js_1.default(tokens);
-    parser.removeErrorListeners();
-    const errorListener = new CircuitscriptParserErrorListener();
-    parser.addErrorListener(errorListener);
+    const parser = new CircuitScriptParser_js_1.CircuitScriptParser(tokens);
     const tree = parser.script();
     let hasError = false;
     try {
         visitor.visit(tree);
     }
     catch (err) {
-        err.print(data);
+        console.log(err);
         hasError = true;
     }
     const parserTimeTaken = parserTimer.lap();
-    const semanticTokenVisitor = new SemanticTokensVisitor(lexer, data);
-    semanticTokenVisitor.visit(tree);
-    const semanticTokens = semanticTokenVisitor.semanticTokens;
-    const parsedTokens = prepareTokens(tokens.tokens, lexer, data);
-    const finalParsedTokens = [];
-    parsedTokens.forEach(token => {
-        const location = `${token.line}_${token.column}`;
-        if (semanticTokens.has(location)) {
-            finalParsedTokens.push(semanticTokens.get(location));
-        }
-        else {
-            finalParsedTokens.push(token);
-        }
-    });
     return {
         tree, parser,
-        hasParseError: errorListener.hasParseErrors(),
+        hasParseError: false,
         hasError,
         parserTimeTaken,
         lexerTimeTaken,
-        tokens: finalParsedTokens,
     };
 }
 exports.parseFileWithVisitor = parseFileWithVisitor;
-class SemanticTokensVisitor extends antlr4_1.ParseTreeVisitor {
-    constructor(lexer, script) {
-        super();
-        this.parsedTokens = [];
-        this.semanticTokens = new Map();
-        this.lexer = lexer;
-        this.script = script;
-    }
-    visit(ctx) {
-        const here = this;
-        if (Array.isArray(ctx)) {
-            return ctx.map(function (child) {
-                try {
-                    here.checkContext(child);
-                    return child.accept(this);
-                }
-                catch (err) {
-                    this.handleError(child, err);
-                }
-            }, this);
-        }
-        else {
-            try {
-                this.checkContext(ctx);
-                return ctx.accept(this);
-            }
-            catch (err) {
-                this.handleError(ctx, err);
-            }
-        }
+class TempErrorStrategy extends antlr4ng_1.DefaultErrorStrategy {
+    recover(recognizer, e) {
+        throw new Error('Method not implemented.');
     }
-    handleError(ctx, err) {
-        console.log('error!', err);
+    reportError(recognizer, e) {
+        throw new Error('Method not implemented.');
     }
-    checkContext(ctx) {
-        if (ctx instanceof CircuitScriptParser_js_1.Function_def_exprContext) {
-            this.addSemanticToken(this.parseToken(ctx.ID(), ['declaration'], 'function'));
-        }
-        else if (ctx instanceof CircuitScriptParser_js_1.Create_component_exprContext
-            || ctx instanceof CircuitScriptParser_js_1.Create_graphic_exprContext) {
-            this.addSemanticToken(this.parseToken(ctx.Create(), ['defaultLibrary'], 'function'));
-        }
-        else if (ctx instanceof CircuitScriptParser_js_1.Atom_exprContext) {
-            if (ctx.ID()) {
-                if (ctx.trailer_expr_list().length > 0) {
-                    this.addSemanticToken(this.parseToken(ctx.ID(), ['declaration'], 'function'));
-                }
-                else {
-                    this.addSemanticToken(this.parseToken(ctx.ID(), ['declaration'], 'variable'));
-                }
-            }
-        }
-        else if (ctx instanceof CircuitScriptParser_js_1.Property_key_exprContext) {
-            let useToken = null;
-            if (ctx.ID()) {
-                useToken = ctx.ID();
-            }
-            else if (ctx.INTEGER_VALUE()) {
-                useToken = ctx.INTEGER_VALUE();
-            }
-            else if (ctx.STRING_VALUE()) {
-                useToken = ctx.STRING_VALUE();
-            }
-            useToken && this.addSemanticToken(this.parseToken(useToken, ['declaration'], 'property'));
-        }
-        else if (ctx instanceof CircuitScriptParser_js_1.Sub_exprContext) {
-            let useToken = null;
-            if (ctx.ID()) {
-                useToken = ctx.ID();
-            }
-            else if (ctx.Pin()) {
-                useToken = ctx.Pin();
-            }
-            useToken && this.addSemanticToken(this.parseToken(useToken, ['defaultLibrary'], 'function'));
-        }
-    }
-    addSemanticToken(parsedToken) {
-        this.semanticTokens.set(parsedToken.line + "_" + parsedToken.column, parsedToken);
+}
+exports.TempErrorStrategy = TempErrorStrategy;
+class CircuitscriptParserErrorListener {
+    constructor(onErrorHandler = null) {
+        this.syntaxErrorCounter = 0;
+        this.onErrorHandler = null;
+        this.onErrorHandler = onErrorHandler;
     }
-    parseToken(node, modifiers, tokenType = null) {
-        const token = node.symbol;
-        let stringValue = "";
-        let textPart = "";
-        if (this.lexer.symbolicNames[token.type] !== null && this.lexer.symbolicNames[token.type] !== undefined) {
-            stringValue = this.lexer.symbolicNames[token.type];
-            if (stringValue !== "NEWLINE") {
-                textPart = this.script.substring(token.start, token.stop + 1);
-            }
-            else {
-                textPart = token.text.length - 1;
-            }
-        }
-        else if (this.lexer.literalNames[token.type] !== null && this.lexer.literalNames[token.type] !== undefined) {
-            stringValue = this.lexer.literalNames[token.type];
-            textPart = this.script.substring(token.start, token.stop + 1);
+    syntaxError(recognizer, offendingSymbol, line, charPositionInLine, msg, e) {
+        if (this.onErrorHandler) {
+            this.onErrorHandler(line, charPositionInLine, msg, e);
         }
         else {
-            stringValue = token._text;
-        }
-        return {
-            line: token.line,
-            column: token.column,
-            length: token.stop - token.start + 1,
-            tokenType: tokenType !== null ? tokenType : stringValue,
-            tokenModifiers: modifiers,
-            textValue: textPart,
-        };
-    }
-}
-exports.SemanticTokensVisitor = SemanticTokensVisitor;
-function prepareTokens(tokens, lexer, script) {
-    const parsedTokens = [];
-    tokens.forEach(item => {
-        if (item.type !== -1) {
-            let stringValue = "";
-            let textPart = "";
-            if (lexer.symbolicNames[item.type] !== null && lexer.symbolicNames[item.type] !== undefined) {
-                stringValue = lexer.symbolicNames[item.type];
-                if (stringValue !== "NEWLINE") {
-                    textPart = script.substring(item.start, item.stop + 1);
-                }
-                else {
-                    textPart = item.text.length - 1;
-                }
-            }
-            else if (lexer.literalNames[item.type] !== null && lexer.literalNames[item.type] !== undefined) {
-                stringValue = lexer.literalNames[item.type];
-                textPart = script.substring(item.start, item.stop + 1);
-            }
-            else {
-                stringValue = item._text;
-            }
-            if (textPart !== 0 && textPart !== '') {
-                parsedTokens.push({
-                    line: item.line,
-                    column: item.column,
-                    length: item.stop - item.start + 1,
-                    tokenType: resolveTokenType(stringValue),
-                    tokenModifiers: resolveTokenModifiers(stringValue),
-                    textValue: textPart,
-                });
-            }
+            console.log("Syntax error at line", line, ':', charPositionInLine, ' - ', msg);
         }
-    });
-    return parsedTokens;
-}
-const languageKeywords = [
-    'break', 'branch', 'create', 'component',
-    'graphic', 'wire', 'pin', 'add', 'at', 'to',
-    'point', 'join', 'parallel', 'return', 'def', 'import',
-    'true', 'false', 'nc', 'frame',
-];
-const operatorKeywords = [
-    'at', 'to', 'wire', 'add', 'frame', 'join', 'parallel', 'point'
-];
-function resolveTokenType(tokenType) {
-    if (operatorKeywords.indexOf(tokenType.toLowerCase()) !== -1) {
-        return 'graphKeyword';
+        this.syntaxErrorCounter++;
     }
-    else if (languageKeywords.indexOf(tokenType.toLowerCase()) !== -1) {
-        return 'keyword';
+    reportAmbiguity(recognizer, dfa, startIndex, stopIndex, exact, ambigAlts, configs) {
     }
-    else {
-        switch (tokenType) {
-            case 'INTEGER_VALUE':
-            case 'NUMERIC_VALUE':
-            case 'DECIMAL_VALUE':
-            case 'PERCENTAGE_VALUE':
-                return 'number';
-            case 'STRING_VALUE':
-                return 'string';
-            case 'ID':
-                return 'variable';
-            case 'Define':
-                return 'keyword';
-            case 'COMMENT':
-                return 'comment';
-        }
-        return null;
+    reportAttemptingFullContext(recognizer, dfa, startIndex, stopIndex, conflictingAlts, configs) {
     }
-}
-function resolveTokenModifiers(tokenType) {
-    return [];
-}
-function dumpTokens(tokens, lexer, scriptData) {
-    tokens.forEach(item => {
-        if (item.type !== -1) {
-            let stringValue = "";
-            let textPart = "";
-            if (lexer.symbolicNames[item.type] !== null && lexer.symbolicNames[item.type] !== undefined) {
-                stringValue = lexer.symbolicNames[item.type];
-                if (stringValue !== "NEWLINE") {
-                    textPart = scriptData.substring(item.start, item.stop + 1);
-                }
-                else {
-                    textPart = item.text.length - 1;
-                }
-            }
-            else if (lexer.literalNames[item.type] !== null && lexer.literalNames[item.type] !== undefined) {
-                stringValue = lexer.literalNames[item.type];
-                textPart = scriptData.substring(item.start, item.stop + 1);
-            }
-            else {
-                stringValue = item._text;
-            }
-            console.log('line', item.line + ':' + item.column, `\t${stringValue} (${item.type})`.padEnd(30), textPart);
-        }
-    });
-}
-class CircuitscriptParserErrorListener extends antlr4_1.ErrorListener {
-    constructor() {
-        super(...arguments);
-        this.syntaxErrorCounter = 0;
-    }
-    syntaxError(recognizer, offendingSymbol, line, column, msg, e) {
-        console.log("Syntax error at line", line, ':', column, ' - ', msg);
-        this.syntaxErrorCounter++;
+    reportContextSensitivity(recognizer, dfa, startIndex, stopIndex, prediction, configs) {
     }
-    hasParseErrors() {
+    hasSyntaxErrors() {
         return (this.syntaxErrorCounter > 0);
     }
 }

package/dist/cjs/validate.js

@@ -0,0 +1,81 @@
+#! /usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validate = void 0;
+const commander_1 = require("commander");
+const figlet_1 = __importDefault(require("figlet"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = require("fs");
+const sizing_js_1 = require("./sizing.js");
+const helpers_js_1 = require("./helpers.js");
+async function validate() {
+    const { filePath } = (0, helpers_js_1.getCurrentPath)();
+    const toolSrcPath = filePath;
+    const toolDirectory = path_1.default.dirname(toolSrcPath) + '/../../';
+    const fontsPath = toolDirectory + '/fonts';
+    const defaultLibsPath = toolDirectory + '/libs';
+    const packageJson = JSON.parse((0, fs_1.readFileSync)(toolDirectory + 'package.json').toString());
+    ;
+    const { version } = packageJson;
+    commander_1.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');
+    commander_1.program.addHelpText('before', figlet_1.default.textSync('circuitscript', {
+        font: 'Small Slant'
+    }));
+    if (process.argv.length < 3) {
+        commander_1.program.help();
+    }
+    commander_1.program.parse();
+    const options = commander_1.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 (0, sizing_js_1.prepareSVGEnvironment)(fontsPath);
+    let inputFilePath = null;
+    let scriptData;
+    if (options.input) {
+        scriptData = options.input;
+    }
+    else {
+        inputFilePath = options.inputFile;
+        const tmpScriptData = (0, helpers_js_1.getScriptText)(inputFilePath);
+        if (tmpScriptData === null) {
+            throw "File does not exists";
+        }
+        scriptData = tmpScriptData;
+        if (currentDirectory === null) {
+            currentDirectory = path_1.default.dirname(inputFilePath);
+        }
+    }
+    const scriptOptions = {
+        currentDirectory,
+        defaultLibsPath,
+        dumpNets,
+        dumpData,
+        kicadNetlistPath: kicadNetlist,
+        showStats: options.stats,
+    };
+    const visitor = (0, helpers_js_1.validateScript)(scriptData, scriptOptions);
+    const semanticTokensVisitor = (0, helpers_js_1.getSemanticTokens)(scriptData, scriptOptions);
+}
+exports.validate = validate;
+validate();