circuitscript 0.1.5 → 0.1.8

package/dist/esm/SymbolValidatorVisitor.mjs

@@ -1,222 +0,0 @@
-import { BaseVisitor } from "./BaseVisitor.mjs";
-import { ParseSymbolType } from "./objects/types.mjs";
-export class SymbolValidatorVisitor extends BaseVisitor {
-    symbolTable = new SymbolTable();
-    addSymbolVariable(name, value, executor = null) {
-        const useExecutor = executor === null ? this.getExecutor() : executor;
-        this.symbolTable.addVariable(useExecutor, name, value);
-        this.log2('add symbol variable: ' + name);
-    }
-    addSymbolFunction(functionName, funcDefinedParameters) {
-        if (!this.symbolTable.exists(this.getExecutor(), functionName)) {
-            this.symbolTable.addFunction(this.getExecutor(), functionName, funcDefinedParameters);
-            this.log2('add symbol function: ' + functionName);
-        }
-    }
-    handleAtomSymbol(atom) {
-        const atomId = atom.getText();
-        const executor = this.getExecutor();
-        let tmpSymbol;
-        if (this.symbolTable.exists(executor, atomId)) {
-            tmpSymbol = this.symbolTable.get(executor, atomId);
-        }
-        else {
-            const foundContext = this.symbolTable.searchParentContext(executor, atomId);
-            if (foundContext === null) {
-                tmpSymbol = this.symbolTable.addUndefined(executor, atomId, atom);
-                this.log2('symbol not found: ' + atomId);
-            }
-            else {
-                tmpSymbol = this.symbolTable.get(foundContext, atomId);
-            }
-        }
-        return tmpSymbol;
-    }
-    setSymbols(symbolTable) {
-        this.symbolTable = symbolTable;
-    }
-    visitImport_expr = (ctx) => {
-        const ID = ctx.ID().toString();
-        const { pathExists } = this.handleImportFile(ID, false, ctx);
-        if (!pathExists) {
-            this.symbolTable.addUndefined(this.getExecutor(), ID, ctx.ID());
-        }
-    };
-    visitAssignment_expr = (ctx) => {
-        const atomStr = ctx.atom_expr().getText();
-        const ctxDataExpr = ctx.data_expr();
-        this.visit(ctxDataExpr);
-        const value = this.getResult(ctxDataExpr);
-        this.addSymbolVariable(atomStr, value);
-        return null;
-    };
-    visitAtom_expr = (ctx) => {
-        const tmpSymbol = this.handleAtomSymbol(ctx.ID(0));
-        this.setResult(ctx, tmpSymbol);
-    };
-    visitFunction_call_expr = (ctx) => {
-        this.handleAtomSymbol(ctx.ID());
-        if (ctx.trailer_expr().length > 0) {
-            ctx.trailer_expr().forEach(item => {
-                if (item.OPEN_PAREN() && item.CLOSE_PAREN()) {
-                    const params = item.parameters();
-                    if (params) {
-                        this.visit(params);
-                    }
-                }
-            });
-        }
-    };
-    visitValueAtomExpr = (ctx) => {
-        let value = null;
-        const ctxValueExpr = ctx.value_expr();
-        const cxtAtomExpr = ctx.atom_expr();
-        if (ctxValueExpr) {
-            this.visit(ctxValueExpr);
-            value = this.getResult(ctxValueExpr);
-        }
-        else if (cxtAtomExpr) {
-            this.visit(cxtAtomExpr);
-            value = this.getResult(cxtAtomExpr);
-        }
-        this.setResult(ctx, value);
-    };
-    visitUnaryOperatorExpr = (ctx) => {
-        this.visit(ctx.data_expr());
-    };
-    visitMultiplyExpr = (ctx) => {
-        this.visit(ctx.data_expr(0));
-        this.visit(ctx.data_expr(1));
-    };
-    visitAdditionExpr = (ctx) => {
-        this.visit(ctx.data_expr(0));
-        this.visit(ctx.data_expr(1));
-    };
-    visitBinaryOperatorExpr = (ctx) => {
-        this.visit(ctx.data_expr(0));
-        this.visit(ctx.data_expr(1));
-    };
-    visitDataExpr = (ctx) => {
-        return;
-    };
-    visitFunction_def_expr = (ctx) => {
-        const functionName = ctx.ID().getText();
-        let funcDefinedParameters = [];
-        const ctxFunctionArgsExpr = ctx.function_args_expr();
-        if (ctxFunctionArgsExpr) {
-            this.visit(ctxFunctionArgsExpr);
-            funcDefinedParameters = this.getResult(ctxFunctionArgsExpr);
-        }
-        this.addSymbolFunction(functionName, funcDefinedParameters);
-        const executionContextName = functionName + '_validate';
-        const passedInParamsNull = funcDefinedParameters.map((param, index) => {
-            return ['position', index, null];
-        });
-        const newExecutor = this.enterNewChildContext(this.executionStack, this.getExecutor(), executionContextName, { netNamespace: "" }, funcDefinedParameters, passedInParamsNull);
-        funcDefinedParameters.forEach(param => {
-            this.addSymbolVariable(param[0], null, newExecutor);
-        });
-        this.runExpressions(newExecutor, ctx.function_expr());
-        this.executionStack.pop();
-    };
-    getSymbols() {
-        return this.symbolTable;
-    }
-    dumpSymbols() {
-        this.symbolTable.dumpSymbols();
-    }
-}
-export class SymbolValidatorResolveVisitor extends SymbolValidatorVisitor {
-    addSymbolVariable(name, value) {
-    }
-    addSymbolFunction(functionName, funcDefinedParameters) {
-        if (this.symbolTable.exists(this.getExecutor(), functionName)) {
-            this.symbolTable.addFunction(this.getExecutor(), functionName, funcDefinedParameters);
-        }
-    }
-}
-export class SymbolTable {
-    symbols = new Map();
-    executonContextsNamespaces = [];
-    getSymbols() {
-        return this.symbols;
-    }
-    addFunction(executionContext, id, funcDefinedParameters) {
-        return this.add(executionContext, id, ParseSymbolType.Function, {
-            funcDefinedParameters
-        });
-    }
-    addVariable(executionContext, id, variableValue) {
-        return this.add(executionContext, id, ParseSymbolType.Variable, {
-            variableValue
-        });
-    }
-    addUndefined(executionContext, id, node) {
-        return this.add(executionContext, id, ParseSymbolType.Undefined, {
-            node
-        });
-    }
-    add(executionContext, id, type, extra) {
-        if (this.executonContextsNamespaces.indexOf(executionContext.namespace) === -1) {
-            this.executonContextsNamespaces.push(executionContext.namespace);
-        }
-        const item = {
-            id,
-            type,
-            context: executionContext,
-            extra
-        };
-        this.symbols.set(this.idName(executionContext, id), item);
-        return item;
-    }
-    idName(executionContext, id) {
-        return executionContext.namespace + id;
-    }
-    dumpSymbols() {
-        for (const [key, value] of this.symbols) {
-            console.log(value.type.padEnd(10, " "), key);
-        }
-    }
-    exists(executionContext, id) {
-        const name = this.idName(executionContext, id);
-        return this.symbols.has(name);
-    }
-    existsAny(executionContext, id) {
-        if (this.exists(executionContext, id)) {
-            return true;
-        }
-        else {
-            return this.searchParentContext(executionContext, id) !== null;
-        }
-    }
-    get(executionContext, id) {
-        const name = this.idName(executionContext, id);
-        return this.symbols.get(name);
-    }
-    getParentContexts(executionContext, contextsNamespace) {
-        if (executionContext.parentContext !== null) {
-            contextsNamespace.push(executionContext.parentContext.namespace);
-            this.getParentContexts(executionContext.parentContext, contextsNamespace);
-        }
-        return contextsNamespace;
-    }
-    searchParentContext(executionContext, id) {
-        const contextNames = this.getParentContexts(executionContext, []);
-        for (const [key,] of this.symbols) {
-            if (key.endsWith(`.${id}`)) {
-                const { context } = this.symbols.get(key);
-                if (contextNames.indexOf(context.namespace) !== -1) {
-                    return context;
-                }
-            }
-        }
-        return null;
-    }
-    clearUndefined() {
-        for (const [key, value] of this.symbols) {
-            if (value.type === ParseSymbolType.Undefined) {
-                this.symbols.delete(key);
-            }
-        }
-    }
-}

package/dist/esm/helpers.mjs

@@ -1,364 +0,0 @@
-import { readFileSync, writeFileSync, createWriteStream, existsSync, mkdirSync } from "fs";
-import path from "path";
-import PDFDocument from "pdfkit";
-import { generateKiCADNetList, printTree } from "./export.mjs";
-import { LayoutEngine } from "./layout.mjs";
-import { parseFileWithVisitor } from "./parser.mjs";
-import { generatePdfOutput, generateSvgOutput, renderSheetsToSVG } from "./render.mjs";
-import { generateDebugSequenceAction, resolveToNumericValue, sequenceActionString, SimpleStopwatch } from "./utils.mjs";
-import { ParserVisitor, VisitorExecutionException } from "./visitor.mjs";
-import { createContext } from "this-file";
-import { SymbolValidatorResolveVisitor, SymbolValidatorVisitor } from "./SymbolValidatorVisitor.mjs";
-import { BaseErrorListener, CharStream, CommonTokenStream, DefaultErrorStrategy } from "antlr4ng";
-import { MainLexer } from "./lexer.mjs";
-import { CircuitScriptParser } from "./antlr/CircuitScriptParser.mjs";
-import { prepareTokens, SemanticTokensVisitor } from "./SemanticTokenVisitor.mjs";
-import { defaultPageMarginMM, defaultZoomScale, LengthUnit, MilsToMM, PxToMM } from "./globals.mjs";
-import { FrameParamKeys } from "./objects/Frame.mjs";
-import Big from "big.js";
-import { Logger } from "./logger.mjs";
-export var JSModuleType;
-(function (JSModuleType) {
-    JSModuleType["CommonJs"] = "cjs";
-    JSModuleType["ESM"] = "mjs";
-})(JSModuleType || (JSModuleType = {}));
-export function prepareFile(textData) {
-    const chars = CharStream.fromString(textData);
-    const lexer = new MainLexer(chars);
-    const lexerTimer = new SimpleStopwatch();
-    const tokens = new CommonTokenStream(lexer);
-    tokens.fill();
-    const lexerTimeTaken = lexerTimer.lap();
-    const parser = new CircuitScriptParser(tokens);
-    return {
-        parser,
-        lexer,
-        lexerTimeTaken,
-        tokens
-    };
-}
-export function getScriptText(filePath) {
-    try {
-        return readFileSync(filePath, { encoding: 'utf-8' });
-    }
-    catch (err) {
-        return null;
-    }
-}
-export function getSemanticTokens(scriptData, options) {
-    const { parser, lexer, tokens } = prepareFile(scriptData);
-    const tree = parser.script();
-    const { currentDirectory = null, defaultLibsPath, } = options;
-    const visitor = new SemanticTokensVisitor(true, null, currentDirectory, defaultLibsPath, lexer, scriptData);
-    parser.removeErrorListeners();
-    visitor.onImportFile = (visitor, textData) => {
-        let hasError = false;
-        let hasParseError = false;
-        if (textData !== null) {
-            const { parser } = prepareFile(textData);
-            const tree = parser.script();
-            try {
-                visitor.visit(tree);
-            }
-            catch (err) {
-                console.log('Error while parsing: ', err);
-                hasParseError = true;
-                hasError = true;
-            }
-        }
-        else {
-            console.log('File does not exist');
-            hasError = true;
-        }
-        return {
-            hasError, hasParseError
-        };
-    };
-    visitor.visit(tree);
-    const semanticTokens = visitor.getTokens();
-    const parsedTokens = prepareTokens(tokens.getTokens(), lexer, scriptData);
-    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 {
-        visitor,
-        parsedTokens: finalParsedTokens
-    };
-}
-class TokenErrorListener extends BaseErrorListener {
-    syntaxError(recognizer, offendingSymbol, line, column, msg, e) {
-        console.log(msg);
-    }
-}
-export class ParseErrorStrategy extends DefaultErrorStrategy {
-    reportUnwantedToken(recognizer) {
-        if (this.inErrorRecoveryMode(recognizer)) {
-            return;
-        }
-        this.beginErrorCondition(recognizer);
-        const t = recognizer.getCurrentToken();
-        const tokenName = this.getTokenErrorDisplay(t);
-        const msg = "extraneous input " + tokenName;
-        recognizer.notifyErrorListeners(msg, t, null);
-        this.endErrorCondition(recognizer);
-    }
-}
-export function validateScript(scriptData, options) {
-    const { parser } = prepareFile(scriptData);
-    parser.removeErrorListeners();
-    parser.errorHandler = new ParseErrorStrategy();
-    parser.addErrorListener(new TokenErrorListener());
-    const tree = parser.script();
-    const { currentDirectory = null, defaultLibsPath, } = options;
-    const visitor = new SymbolValidatorVisitor(true, null, currentDirectory, defaultLibsPath);
-    visitor.onImportFile = (visitor, textData) => {
-        let hasError = false;
-        let hasParseError = false;
-        if (textData !== null) {
-            const { parser } = prepareFile(textData);
-            const tree = parser.script();
-            try {
-                visitor.visit(tree);
-            }
-            catch (err) {
-                console.log('got an error while parsing tree: ', err);
-                hasParseError = true;
-                hasError = true;
-            }
-        }
-        else {
-            console.log('file does not exist!');
-            hasError = true;
-        }
-        return {
-            hasError, hasParseError
-        };
-    };
-    visitor.visit(tree);
-    const symbolTable = visitor.getSymbols();
-    symbolTable.clearUndefined();
-    const visitorResolver = new SymbolValidatorResolveVisitor(true, null, currentDirectory, defaultLibsPath);
-    visitorResolver.setSymbols(visitor.getSymbols());
-    visitorResolver.onImportFile = visitor.onImportFile;
-    visitorResolver.visit(tree);
-    return visitorResolver;
-}
-export function renderScript(scriptData, outputPath, options) {
-    const { currentDirectory = null, defaultLibsPath, dumpNets = false, dumpData = false, showStats = false } = options;
-    const onErrorHandler = (line, column, message, error) => {
-        if (error instanceof VisitorExecutionException) {
-            console.log('Error', line, column, message, error.errorMessage);
-        }
-    };
-    const visitor = new ParserVisitor(true, onErrorHandler, currentDirectory, defaultLibsPath);
-    visitor.onImportFile = (visitor, fileData) => {
-        const { hasError, hasParseError } = parseFileWithVisitor(visitor, fileData);
-        return { hasError, hasParseError };
-    };
-    visitor.log('reading file');
-    visitor.log('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);
-    if (dumpNets) {
-        const nets = visitor.dumpNets();
-        nets.forEach(item => console.log(item.join(" | ")));
-    }
-    const dumpDirectory = currentDirectory + '/dump/';
-    if (dumpData) {
-        if (!existsSync(dumpDirectory)) {
-            mkdirSync(dumpDirectory);
-        }
-    }
-    dumpData && writeFileSync(dumpDirectory + 'tree.lisp', tree.toStringTree(null, parser));
-    dumpData && writeFileSync(dumpDirectory + 'raw-parser.txt', visitor.logger.dump());
-    if (hasError || hasParseError) {
-        console.log('Error while parsing');
-        return null;
-    }
-    const { frameComponent } = visitor.applySheetFrameComponent();
-    try {
-        visitor.annotateComponents();
-    }
-    catch (err) {
-        console.log('Error during annotation: ', err);
-    }
-    const { sequence, nets } = visitor.getGraph();
-    const tmpSequence = generateDebugSequenceAction(sequence).map(item => sequenceActionString(item));
-    dumpData && writeFileSync(dumpDirectory + 'raw-sequence.txt', tmpSequence.join('\n'));
-    let svgOutput = "";
-    try {
-        let fileExtension = null;
-        let outputDefaultZoom = defaultZoomScale;
-        if (outputPath) {
-            fileExtension = path.extname(outputPath).substring(1);
-            if (fileExtension === "pdf") {
-                outputDefaultZoom = 1;
-            }
-        }
-        if (fileExtension === 'net') {
-            const { tree: kicadNetList, missingFootprints } = generateKiCADNetList(visitor.getNetList());
-            missingFootprints.forEach(entry => {
-                console.log(`${entry.refdes} (${entry.instanceName}) does not have footprint`);
-            });
-            writeFileSync(outputPath, printTree(kicadNetList));
-            console.log('Generated file', outputPath);
-            return null;
-        }
-        const layoutEngine = new LayoutEngine();
-        const layoutTimer = new SimpleStopwatch();
-        const sheetFrames = layoutEngine.runLayout(sequence, nets);
-        layoutEngine.printWarnings();
-        showStats && console.log('Layout took:', layoutTimer.lap());
-        dumpData && writeFileSync(dumpDirectory + 'raw-layout.txt', layoutEngine.logger.dump());
-        const generateSvgTimer = new SimpleStopwatch();
-        const renderLogger = new Logger();
-        const svgCanvas = renderSheetsToSVG(sheetFrames, renderLogger);
-        showStats && console.log('Render took:', generateSvgTimer.lap());
-        dumpData && writeFileSync(dumpDirectory + 'raw-render.txt', renderLogger.dump());
-        svgOutput = generateSvgOutput(svgCanvas, outputDefaultZoom);
-        if (outputPath) {
-            if (fileExtension === 'svg') {
-                writeFileSync(outputPath, svgOutput);
-            }
-            else if (fileExtension === 'pdf') {
-                let sheetSize = "A4";
-                let sheetSizeDefined = false;
-                if (frameComponent) {
-                    sheetSize = frameComponent.getParam(FrameParamKeys.PaperSize);
-                    sheetSizeDefined = true;
-                }
-                const doc = new PDFDocument({
-                    layout: 'landscape',
-                    size: sheetSize
-                });
-                const outputStream = createWriteStream(outputPath);
-                generatePdfOutput(doc, svgCanvas, sheetSize, sheetSizeDefined, outputDefaultZoom);
-                doc.pipe(outputStream);
-                doc.end();
-            }
-            else {
-                throw "Invalid output format";
-            }
-            console.log('Generated file', outputPath);
-        }
-    }
-    catch (err) {
-        console.log('Error during render: ', err);
-    }
-    return svgOutput;
-}
-export function detectJSModuleType() {
-    if (typeof __filename === 'undefined' &&
-        typeof __dirname === 'undefined') {
-        return JSModuleType.ESM;
-    }
-    else {
-        return JSModuleType.CommonJs;
-    }
-}
-const context = createContext();
-export function getCurrentPath() {
-    const filename = context.filename;
-    return { filePath: filename };
-}
-function getToolsPath() {
-    const { filePath } = getCurrentPath();
-    return path.normalize(path.dirname(filePath) + '/../../');
-}
-export function getFontsPath() {
-    const toolsPath = getToolsPath();
-    return path.normalize(toolsPath + "fonts");
-}
-export function getDefaultLibsPath() {
-    const toolsPath = getToolsPath();
-    return path.normalize(toolsPath + "libs");
-}
-export function getPackageVersion() {
-    const packageJson = JSON.parse(readFileSync(getToolsPath() + 'package.json').toString());
-    const { version } = packageJson;
-    return version;
-}
-export class UnitDimension {
-    type;
-    value;
-    constructor(value, type = LengthUnit.mils) {
-        this.value = value;
-        this.type = type;
-    }
-    getMM() {
-        switch (this.type) {
-            case LengthUnit.mm:
-                return this.value;
-            case LengthUnit.mils:
-                return this.value * MilsToMM;
-            case LengthUnit.px:
-                return this.value * PxToMM;
-        }
-    }
-    static mm(value) {
-        return new UnitDimension(value, LengthUnit.mm);
-    }
-    static mils(value) {
-        return new UnitDimension(value, LengthUnit.mils);
-    }
-    static px(value) {
-        return new UnitDimension(value, LengthUnit.px);
-    }
-}
-export function milsToMM(value) {
-    if (typeof value === 'number') {
-        value = resolveToNumericValue(new Big(value));
-    }
-    return resolveToNumericValue(value.toBigNumber().mul(new Big(MilsToMM)).round(6));
-}
-export function pxToMM(value) {
-    return value * PxToMM;
-}
-const PaperSizes = {
-    'A0': [1189, 841],
-    'A1': [841, 594],
-    'A2': [594, 420],
-    'A3': [420, 297],
-    'A4': [297, 210],
-    'A5': [210, 148],
-    'A6': [148, 105],
-};
-export const PaperGridReferences = {
-    'A0': [16, 24],
-    'A1': [12, 16],
-    'A2': [8, 12],
-    'A3': [6, 8],
-    'A4': [4, 6],
-};
-export function isSupportedPaperSize(type) {
-    if (PaperSizes[type]) {
-        return true;
-    }
-    return false;
-}
-export function getPaperSize(type, margin = defaultPageMarginMM) {
-    if (PaperSizes[type]) {
-        const [width, height] = PaperSizes[type];
-        const useWidth = width - margin * 2;
-        const useHeight = height - margin * 2;
-        return {
-            width: Math.floor(useWidth * (1 / MilsToMM)),
-            height: Math.floor(useHeight * (1 / MilsToMM)),
-            widthMM: useWidth,
-            heightMM: useHeight,
-            originalWidthMM: width,
-            originalHeightMM: height,
-        };
-    }
-    else {
-        return getPaperSize('A4');
-    }
-}

package/dist/esm/index.mjs

@@ -1,15 +0,0 @@
-export * from './draw_symbols.mjs';
-export * from './execute.mjs';
-export * from './export.mjs';
-export * from './geometry.mjs';
-export * from './globals.mjs';
-export * from './helpers.mjs';
-export * from './layout.mjs';
-export * from './lexer.mjs';
-export * from './logger.mjs';
-export * from './parser.mjs';
-export * from './render.mjs';
-export * from './utils.mjs';
-export * from './visitor.mjs';
-export * from './sizing.mjs';
-export * from './objects/types.mjs';

package/dist/esm/parser.mjs

@@ -1,64 +0,0 @@
-import { CircuitScriptParser } from './antlr/CircuitScriptParser.mjs';
-import { MainLexer } from './lexer.mjs';
-import { SimpleStopwatch } from './utils.mjs';
-import { CharStream, CommonTokenStream, DefaultErrorStrategy } from 'antlr4ng';
-export function parseFileWithVisitor(visitor, data) {
-    const chars = CharStream.fromString(data);
-    const lexer = new MainLexer(chars);
-    const lexerTimer = new SimpleStopwatch();
-    const tokens = new CommonTokenStream(lexer);
-    tokens.fill();
-    const lexerTimeTaken = lexerTimer.lap();
-    const parserTimer = new SimpleStopwatch();
-    const parser = new CircuitScriptParser(tokens);
-    const tree = parser.script();
-    let hasError = false;
-    try {
-        visitor.visit(tree);
-    }
-    catch (err) {
-        console.log(err);
-        hasError = true;
-    }
-    const parserTimeTaken = parserTimer.lap();
-    return {
-        tree, parser,
-        hasParseError: false,
-        hasError,
-        parserTimeTaken,
-        lexerTimeTaken,
-    };
-}
-export class TempErrorStrategy extends DefaultErrorStrategy {
-    recover(recognizer, e) {
-        throw new Error('Method not implemented.');
-    }
-    reportError(recognizer, e) {
-        throw new Error('Method not implemented.');
-    }
-}
-export class CircuitscriptParserErrorListener {
-    syntaxErrorCounter = 0;
-    onErrorHandler = null;
-    constructor(onErrorHandler = null) {
-        this.onErrorHandler = onErrorHandler;
-    }
-    syntaxError(recognizer, offendingSymbol, line, charPositionInLine, msg, e) {
-        if (this.onErrorHandler) {
-            this.onErrorHandler(line, charPositionInLine, msg, e);
-        }
-        else {
-            console.log("Syntax error at line", line, ':', charPositionInLine, ' - ', msg);
-        }
-        this.syntaxErrorCounter++;
-    }
-    reportAmbiguity(recognizer, dfa, startIndex, stopIndex, exact, ambigAlts, configs) {
-    }
-    reportAttemptingFullContext(recognizer, dfa, startIndex, stopIndex, conflictingAlts, configs) {
-    }
-    reportContextSensitivity(recognizer, dfa, startIndex, stopIndex, prediction, configs) {
-    }
-    hasSyntaxErrors() {
-        return (this.syntaxErrorCounter > 0);
-    }
-}