change compiler to use ranges

Author: efekos

src/compiler.ts

@@ -68,7 +68,7 @@ export class SyntaxScriptCompiler {
      * Compiles one .syx file from the path given.
      * @param {string} file Path to a file to compile.
      * @author efekos
-     * @version 1.0.2
+     * @version 1.0.3
      * @since 0.0.1-alpha
      */
     public compileSyx(file: string) {
@@ -106,7 +106,7 @@ export class SyntaxScriptCompiler {
                         const compileStmt = stmt as CompileStatement;
 
                         compileStmt.formats.forEach(frmt => {
-                            if (operatorStmtExport.outputGenerators[frmt] !== undefined) throw new CompilerError({ character: compileStmt.pos, line: compileStmt.line }, `Duplicate file format at compile statement \'${frmt}\'`);
+                            if (operatorStmtExport.outputGenerators[frmt] !== undefined) throw new CompilerError(compileStmt.range, `Duplicate file format at compile statement \'${frmt}\'`);
 
                             operatorStmtExport.outputGenerators[frmt] = (src) => {
                                 let out = '';
@@ -117,7 +117,7 @@ export class SyntaxScriptCompiler {
                                         const varExpr = e as VariableExpression;
                                         const v = src.match(new RegExp(regexes[varExpr.value].source, 'g'))[varExpr.index];
 
-                                        if (v === undefined) throw new CompilerError({ character: compileStmt.pos, line: compileStmt.line }, 'Unknown statement/expression.');
+                                        if (v === undefined) throw new CompilerError(compileStmt.range, 'Unknown statement/expression.');
                                         out += v;
                                     } else if (e.type === NodeType.WhitespaceIdentifier) out += ' ';
                                 });
@@ -131,11 +131,11 @@ export class SyntaxScriptCompiler {
                         const importStmt = stmt as ImportsStatement;
 
                         importStmt.formats.forEach(frmt => {
-                            if (operatorStmtExport.imports[frmt] !== undefined) throw new CompilerError({ character: importStmt.pos, line: importStmt.line }, `Duplicate file format at imports statement \'${frmt}\'`);
+                            if (operatorStmtExport.imports[frmt] !== undefined) throw new CompilerError(importStmt.range, `Duplicate file format at imports statement \'${frmt}\'`);
                             operatorStmtExport.imports[frmt] = importStmt.module;
                         });
 
-                    } else throw new CompilerError({line:stmt.line,character:stmt.pos}, `Unexpected \'${stmt.type}\' statement insdie operator statement.`);
+                    } else throw new CompilerError(stmt.range, `Unexpected \'${stmt.type}\' statement insdie operator statement.`);
                 });
 
                 out.push(operatorStmtExport);
@@ -147,15 +147,15 @@ export class SyntaxScriptCompiler {
 
                     if (statement.type === NodeType.Compile) {
                         const compileStatement = statement as CompileStatement;
-                        if (compileStatement.body[0].type !== NodeType.String) throw new CompilerError({ character: compileStatement.pos, line: compileStatement.line }, 'Expected a string after compile statement parens');
+                        if (compileStatement.body[0].type !== NodeType.String) throw new CompilerError(compileStatement.range, 'Expected a string after compile statement parens');
                         compileStatement.formats.forEach(each => {
-                            if (statementExport.formatNames[each] !== undefined) throw new CompilerError({ character: compileStatement.pos, line: compileStatement.line }, `Encountered multiple compile statements for target language '${each}'`);
+                            if (statementExport.formatNames[each] !== undefined) throw new CompilerError(compileStatement.range, `Encountered multiple compile statements for target language '${each}'`);
                             statementExport.formatNames[each] = compileStatement.body[0].value;
                         });
                     } else if (statement.type === NodeType.Imports) {
                         const importsStatement = statement as ImportsStatement;
                         importsStatement.formats.forEach(each => {
-                            if (statementExport.imports[each] !== undefined) throw new CompilerError({ character: importsStatement.pos, line: importsStatement.line }, `Encountered multiple import statements for target language '${each}'`);
+                            if (statementExport.imports[each] !== undefined) throw new CompilerError(importsStatement.range, `Encountered multiple import statements for target language '${each}'`);
                             statementExport.imports[each] = importsStatement.module;
                         });
                     }
@@ -168,7 +168,7 @@ export class SyntaxScriptCompiler {
                 const stmt = exported as KeywordStatement;
 
                 out.push({ type: ExportType.Keyword, word: stmt.word });
-            } else throw new CompilerError({ character: statement.pos, line: statement.line }, `Unexpected \'${statement.type}\' statement after export statement.`);
+            } else throw new CompilerError(statement.range, `Unexpected \'${statement.type}\' statement after export statement.`);
 
         });
 
@@ -197,7 +197,7 @@ export class SyntaxScriptCompiler {
      * @param {string} file Path to the .sys file to compile.
      * @author efekos
      * @since 0.0.1-alpha
-     * @version 1.0.1
+     * @version 1.0.2
      */
     public compileSys(file: string) {
         const ast = sysparser.parseTokens(tokenizeSys(readFileSync(file).toString()), this.watchMode);
@@ -209,10 +209,10 @@ export class SyntaxScriptCompiler {
                 const importStmt = stmt as ImportStatement;
 
                 const pathToImport = join(dirname(file), importStmt.path.endsWith('.syx') ? importStmt.path : importStmt.path + '.syx');
-                if (!existsSync(pathToImport)) throw new CompilerError({ character: importStmt.pos, line: importStmt.line }, `File \'${pathToImport}\' imported from \'${file}\' does not exist.`);
+                if (!existsSync(pathToImport)) throw new CompilerError(importStmt.range, `File \'${pathToImport}\' imported from \'${file}\' does not exist.`);
                 this.exportData[pathToImport].forEach(exported => {
                     if (exported.type === ExportType.Operator)
-                        if (imported.filter(r => r.type === ExportType.Operator).some(i => exported.regexMatcher === (i as Operator).regexMatcher)) throw new CompilerError({ character: importStmt.pos, line: importStmt.line }, `There are more than one operators with the same syntax imported to \'${file}\'.`);
+                        if (imported.filter(r => r.type === ExportType.Operator).some(i => exported.regexMatcher === (i as Operator).regexMatcher)) throw new CompilerError(importStmt.range, `There are more than one operators with the same syntax imported to \'${file}\'.`);
                     imported.push(exported);
                 });
             }
@@ -235,11 +235,11 @@ export class SyntaxScriptCompiler {
         imported.forEach(i => {
 
             if (i.type === ExportType.Operator) {
-                if (i.outputGenerators[this.mainFileFormat] === undefined) throw new CompilerError({ character: 1, line: 1 }, `Can't compile operator to target language (${this.mainFileFormat}).`);
+                if (i.outputGenerators[this.mainFileFormat] === undefined) throw new CompilerError({end:{character:0,line:0},start:{character:0,line:0}}, `Can't compile operator to target language (${this.mainFileFormat}).`);
                 fileContent = fileContent.replace(new RegExp(i.regexMatcher.source, 'g'), i.outputGenerators[this.mainFileFormat]);
                 if (i.imports[this.mainFileFormat] !== undefined && !imports.includes(i.imports[this.mainFileFormat])) imports.push(i.imports[this.mainFileFormat]);
             } else if (i.type === ExportType.Function) {
-                if (i.formatNames[this.mainFileFormat] === undefined) throw new CompilerError({ character: 1, line: 1 }, `Can't compile function to target language (${this.mainFileFormat}).`);
+                if (i.formatNames[this.mainFileFormat] === undefined) throw new CompilerError({end:{character:0,line:0},start:{character:0,line:0}}, `Can't compile function to target language (${this.mainFileFormat}).`);
                 fileContent = fileContent.replace(new RegExp(i.name + '\\(' + i.args.map(m => m.source).join(',') + '\\)', 'g'), (m) => m.replace(i.name, i.formatNames[this.mainFileFormat]));
             }