circuitscript 0.0.24 → 0.0.25

package/dist/esm/helpers.mjs

@@ -1,23 +1,165 @@
-import { writeFileSync } from "fs";
+import { readFileSync, writeFileSync } from "fs";
 import { generateKiCADNetList } from "./export.mjs";
 import { LayoutEngine } from "./layout.mjs";
 import { SequenceAction } from "./objects/ExecutionScope.mjs";
 import { parseFileWithVisitor } from "./parser.mjs";
 import { generateSVG2 } from "./render.mjs";
 import { SimpleStopwatch } from "./utils.mjs";
-import { MainVisitor } from "./visitor.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 path from "path";
 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, 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 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);
@@ -91,3 +233,20 @@ 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;
+}

package/dist/esm/index.mjs

@@ -11,3 +11,5 @@ 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/layout.mjs

@@ -393,6 +393,14 @@ export class LayoutEngine {
                         didSetAngle = true;
                         tmpSymbol.angle = component.parameters.get('angle');
                     }
+                    if (component.parameters.has('flipX')) {
+                        tmpSymbol.flipX =
+                            component.parameters.get('flipX');
+                    }
+                    if (component.parameters.has('flipY')) {
+                        tmpSymbol.flipY =
+                            component.parameters.get('flipY');
+                    }
                     if (tmpSymbol instanceof SymbolCustom && widthProp) {
                         tmpSymbol.bodyWidth = widthProp;
                     }

package/dist/esm/lexer.mjs

@@ -1,6 +1,6 @@
-import { CommonToken } from "antlr4";
-import CircuitScriptParser from "./antlr/CircuitScriptParser.mjs";
-import CircuitScriptLexer from "./antlr/CircuitScriptLexer.mjs";
+import { CommonToken } from "antlr4ng";
+import { CircuitScriptParser } from "./antlr/CircuitScriptParser.mjs";
+import { CircuitScriptLexer } from "./antlr/CircuitScriptLexer.mjs";
 export class MainLexer extends CircuitScriptLexer {
     tokens;
     indents;
@@ -22,7 +22,7 @@ export class MainLexer extends CircuitScriptLexer {
         this.tokens.push(token);
     }
     nextToken() {
-        if (this._input.LA(1) === CircuitScriptParser.EOF && this.indents.length) {
+        if (this.inputStream.LA(1) === CircuitScriptParser.EOF && this.indents.length) {
             this.tokens = this.tokens.filter(function (val) {
                 return val.type !== CircuitScriptParser.EOF;
             });
@@ -40,20 +40,20 @@ export class MainLexer extends CircuitScriptLexer {
         return this.commonToken(CircuitScriptParser.DEDENT, "");
     }
     getCharIndex() {
-        return this._input.index;
+        return this.inputStream.index;
     }
     commonToken(type, text) {
         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;
+        const token = CommonToken.fromSource([this, this.inputStream], type, 0, start, stop);
+        let tokenTypeString = null;
         if (type === CircuitScriptParser.INDENT) {
             tokenTypeString = "indent";
         }
         else if (type === CircuitScriptParser.DEDENT) {
             tokenTypeString = "dedent";
         }
-        if (tokenTypeString) {
+        if (tokenTypeString !== null) {
             token.text = tokenTypeString;
         }
         return token;
@@ -82,8 +82,8 @@ export class MainLexer extends CircuitScriptLexer {
     onNewLine() {
         const newLine = this.text.replace(/[^\r\n]+/g, '');
         const spaces = this.text.replace(/[\r\n]+/g, '');
-        const next = this._input.LA(1);
-        const nextnext = this._input.LA(2);
+        const next = this.inputStream.LA(1);
+        const nextnext = this.inputStream.LA(2);
         if (this.opened > 0 || (nextnext != -1 &&
             (next === 13 || next === 10 || next === 35))) {
             this.skip();

package/dist/esm/main.mjs

@@ -4,16 +4,11 @@ import figlet from 'figlet';
 import path from 'path';
 import { readFileSync, watch } from 'fs';
 import { prepareSVGEnvironment } from './sizing.mjs';
-import { getCurrentPath, renderScript } from './helpers.mjs';
+import { getDefaultLibsPath, getFontsPath, getPackageVersion, renderScript } from './helpers.mjs';
 export default async function main() {
-    const { filePath } = getCurrentPath();
-    const toolSrcPath = filePath;
-    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;
+    const fontsPath = getFontsPath();
+    const defaultLibsPath = getDefaultLibsPath();
+    const version = getPackageVersion();
     program
         .description('generate graphical output from circuitscript files')
         .version(version)
@@ -56,7 +51,7 @@ export default async function main() {
             currentDirectory = path.dirname(inputFilePath);
         }
     }
-    const renderOptions = {
+    const scriptOptions = {
         currentDirectory,
         defaultLibsPath,
         dumpNets,
@@ -64,7 +59,7 @@ export default async function main() {
         kicadNetlistPath: kicadNetlist,
         showStats: options.stats,
     };
-    const output = renderScript(scriptData, outputPath, renderOptions);
+    const output = renderScript(scriptData, outputPath, scriptOptions);
     if (outputPath === null && output) {
         console.log(output);
     }
@@ -72,7 +67,7 @@ export default async function main() {
         watch(inputFilePath, event => {
             if (event === 'change') {
                 const scriptData = readFileSync(inputFilePath, { encoding: 'utf-8' });
-                renderScript(scriptData, outputPath, renderOptions);
+                renderScript(scriptData, outputPath, scriptOptions);
                 console.log('done');
             }
         });

package/dist/esm/objects/ClassComponent.mjs

@@ -129,6 +129,9 @@ export class ClassComponent {
             }
         }
         for (const [key, value] of this.parameters) {
+            if (key === 'flipX' || key === 'flipY' || key === 'angle') {
+                continue;
+            }
             component.parameters.set(key, value);
         }
         for (const [key, value] of this.pins) {

package/dist/esm/objects/ExecutionScope.mjs

@@ -4,6 +4,7 @@ export class ExecutionScope {
     instances = new Map();
     functions = new Map();
     variables = new Map();
+    symbols = new Map();
     blockStack = new Map();
     wires = [];
     frames = [];

package/dist/esm/objects/types.mjs

@@ -4,3 +4,9 @@ export class UndeclaredReference {
         this.reference = reference;
     }
 }
+export var ParseSymbolType;
+(function (ParseSymbolType) {
+    ParseSymbolType["Variable"] = "variable";
+    ParseSymbolType["Function"] = "function";
+    ParseSymbolType["Undefined"] = "undefined";
+})(ParseSymbolType || (ParseSymbolType = {}));

package/dist/esm/parser.mjs

@@ -1,9 +1,9 @@
-import { CharStream, CommonTokenStream, ErrorListener, ParseTreeVisitor } from 'antlr4';
-import CircuitScriptParser, { Atom_exprContext, Create_component_exprContext, Create_graphic_exprContext, Function_def_exprContext, Property_key_exprContext, Sub_exprContext } from './antlr/CircuitScriptParser.mjs';
+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 = new CharStream(data);
+    const chars = CharStream.fromString(data);
     const lexer = new MainLexer(chars);
     const lexerTimer = new SimpleStopwatch();
     const tokens = new CommonTokenStream(lexer);
@@ -11,259 +11,54 @@ export function parseFileWithVisitor(visitor, data) {
     const lexerTimeTaken = lexerTimer.lap();
     const parserTimer = new SimpleStopwatch();
     const parser = new CircuitScriptParser(tokens);
-    parser.removeErrorListeners();
-    const errorListener = new CircuitscriptParserErrorListener();
-    parser.addErrorListener(errorListener);
     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,
     };
 }
-export class SemanticTokensVisitor extends ParseTreeVisitor {
-    parsedTokens = [];
-    lexer;
-    script;
-    semanticTokens = new Map();
-    constructor(lexer, script) {
-        super();
-        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);
-            }
-        }
+export class TempErrorStrategy extends 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 Function_def_exprContext) {
-            this.addSemanticToken(this.parseToken(ctx.ID(), ['declaration'], 'function'));
-        }
-        else if (ctx instanceof Create_component_exprContext
-            || ctx instanceof Create_graphic_exprContext) {
-            this.addSemanticToken(this.parseToken(ctx.Create(), ['defaultLibrary'], 'function'));
-        }
-        else if (ctx instanceof 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 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 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);
+}
+export class CircuitscriptParserErrorListener {
+    syntaxErrorCounter = 0;
+    onErrorHandler = null;
+    constructor(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;
+            console.log("Syntax error at line", line, ':', charPositionInLine, ' - ', msg);
         }
-        return {
-            line: token.line,
-            column: token.column,
-            length: token.stop - token.start + 1,
-            tokenType: tokenType !== null ? tokenType : stringValue,
-            tokenModifiers: modifiers,
-            textValue: textPart,
-        };
-    }
-}
-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,
-                });
-            }
-        }
-    });
-    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);
-        }
-    });
-}
-export class CircuitscriptParserErrorListener extends ErrorListener {
-    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);
     }
 }