Merge branch 'refactorLDF' of igorfelix/ivprog into master

grammar/en/ivprog.g4

@@ -1,12 +1,5 @@
 lexer grammar ivprog;
 
-@lexer::members{
-  //Translate to fit your language
-  ivprog.MAIN_FUNCTION_NAME = "start";
-  ivprog.READ_FUNCTION_NAME = "read";
-  ivprog.WRITE_FUNCTION_NAME = "write";
-}
-
 // BEGIN i18n Lexical rules
 RK_PROGRAM
   : 'program'

grammar/en/langFunctions.js

@@ -0,0 +1,7 @@
+/* This is a dictionary of the language defined functions
+**/
+export default {
+  main_function: "start",
+  $read: "read",
+  $write: "write"
+}

grammar/es/ivprog.g4

@@ -1,12 +1,5 @@
 lexer grammar ivprog;
 
-@lexer::members{
-  //Translate to fit your language
-  ivprog.MAIN_FUNCTION_NAME = "inicio";
-  ivprog.READ_FUNCTION_NAME = "leia";
-  ivprog.WRITE_FUNCTION_NAME = "escreva";
-}
-
 // BEGIN i18n Lexical rules
 RK_PROGRAM
   : 'programa'

grammar/es/langFunctions.js

@@ -0,0 +1,7 @@
+/* This is a dictionary of the language defined functions
+**/
+export default {
+  main_function: "inicio",
+  $read: "leia",
+  $write: "escreva"
+}

grammar/index.js

@@ -1,7 +1,10 @@
 import * as PT from './pt/ivprog.g4';
+import PTFuncs from './pt/langFunctions';
 import * as EN from './en/ivprog.g4';
+import ENFuncs from './en/langFunctions';
 import * as ES from './es/ivprog.g4';
+import ESFuncs from './es/langFunctions';
 
-exports.pt = PT.ivprog;
-exports.en = EN.ivprog;
-exports.es = ES.ivprog;
+exports.pt = {lexer: PT.ivprog, langFuncs: PTFuncs};
+exports.en = {lexer: EN.ivprog, langFuncs: ENFuncs};
+exports.es = {lexer: ES.ivprog, langFuncs: ESFuncs};

grammar/pt/ivprog.g4

@@ -1,12 +1,5 @@
 lexer grammar ivprog;
 
-@lexer::members{
-  //Translate to fit your language
-  ivprog.MAIN_FUNCTION_NAME = "inicio";
-  ivprog.READ_FUNCTION_NAME = "leia";
-  ivprog.WRITE_FUNCTION_NAME = "escreva";
-}
-
 // BEGIN i18n Lexical rules
 RK_PROGRAM
   : 'programa'

grammar/pt/langFunctions.js

@@ -0,0 +1,7 @@
+/* This is a dictionary of the language defined functions
+**/
+export default {
+  main_function: "inicio",
+  $read: "leia",
+  $write: "escreva"
+}

js/ast/commands/sysCall.js

@@ -6,7 +6,7 @@
  */
 export class SysCall {
 
-  constructor (id) {
-    this.id = id;
+  constructor (langFunc) {
+    this.langFunc = langFunc;
   }
 }

js/ast/ivprogParser.js

@@ -1,10 +1,11 @@
 import { CommonTokenStream, InputStream } from 'antlr4/index';
 import * as Expressions from './expressions/';
 import * as Commands from './commands/';
-import { Types, toInt, toString } from './types';
+import { Types, toInt, toString, toBool } from './types';
 import { convertFromString } from './operators';
 import { SyntaxErrorFactory } from './error/syntaxErrorFactory';
-import { NAMES } from './../processor/definedFunctions';
+import { LanguageDefinedFunction } from './../processor/definedFunctions';
+import { LanguageService } from '../services/languageService';
 
 export class IVProgParser {
 
@@ -37,6 +38,7 @@ export class IVProgParser {
     this.functionTypes = this.variableTypes.concat(this.lexerClass.RK_VOID);
     this.parsingArrayDimension = 0;
     this.scope = [];
+    this.langFuncs = LanguageService.getCurrentLangFuncs();
   }
 
   parseTree () {
@@ -204,7 +206,6 @@ export class IVProgParser {
 
   parseGlobalVariables () {
     const decl = this.parseMaybeConst();
-    const eosToken = this.getToken();
     this.checkEOS();
     this.pos++;
     return decl;
@@ -333,7 +334,7 @@ export class IVProgParser {
   }
 
   getBoolLiteral (token) {
-    const val = token.type === this.lexerClass.RK_TRUE ? true : false;
+    const val = toBool(token.text);
     return new Expressions.BoolLiteral(val);
   }
 
@@ -402,7 +403,7 @@ export class IVProgParser {
     const func = new Commands.Function(functionID, returnType, formalParams, commandsBlock);
     if (functionID === null && !func.isMain) {
       // TODO: better error message
-      throw SyntaxErrorFactory.invalid_main_return(this.lexerClass.MAIN_FUNCTION_NAME,
+      throw SyntaxErrorFactory.invalid_main_return(LanguageDefinedFunction.getMainFunctionName(),
         this.lexer.literalNames[this.lexerClass.RK_VOID],
         token.line);
     }
@@ -449,7 +450,7 @@ export class IVProgParser {
     } 
     this.pos++;
     if (this.insideScope(IVProgParser.FUNCTION)) {
-      if (token.text === this.lexerClass.MAIN_FUNCTION_NAME){
+      if (token.text === LanguageDefinedFunction.getMainFunctionName()){
         return null;
       }
     }
@@ -468,7 +469,7 @@ export class IVProgParser {
       switch(token.type) {
         case this.lexerClass.RK_INTEGER:
           return Types.INTEGER;
-        case this.lexerClass.RK_LOGIC:
+        case this.lexerClass.RK_BOOLEAN:
           return Types.BOOLEAN;
         case this.lexerClass.RK_REAL:
           return Types.REAL;
@@ -926,12 +927,11 @@ export class IVProgParser {
   }
 
   getFunctionName (id) {
-    if (id === this.lexerClass.READ_FUNCTION_NAME) {
-      return NAMES.READ;
-    } else if (id === this.lexerClass.WRITE_FUNCTION_NAME) {
-      return NAMES.WRITE;
-    } else {
+    const name = LanguageDefinedFunction.getInternalName(id);
+    if (name === null) {
       return id;
+    } else {
+      return name;
     }
   }
 

js/ast/types.js

@@ -1,3 +1,5 @@
+import { LanguageService } from "../services/languageService";
+
 export const Types = Object.freeze({
   INTEGER: {value: "int", ord: 0},
   REAL: {value: "real", ord: 1},
@@ -33,5 +35,15 @@ export function toString (str) {
 }
 
 export function toBool (str) {
-  return true;
+  const val = "'" + str + "'";
+  const lexer = LanguageService.getCurrentLexer();
+  const instance = new lexer(null);
+  if (instance.literalNames[lexer.RK_TRUE] === val) {
+    return true;
+  } else if (instance.literalNames[lexer.RK_FALSE] === val) {
+    return false;
+  } else {
+    // TODO: better error message
+    throw new Error(str + "not a valid boolean");
+  }
 }

js/processor/definedFunctions.js

@@ -1,8 +1,15 @@
 import * as Commands from './../ast/commands';
-import {Types} from './../ast/types';
+import {Types, toInt, toString, toBool} from './../ast/types';
+import { LanguageService } from '../services/languageService';
+import { StoreObject } from './store/storeObject';
 
 function createOutputFun () {
-  const block = new Commands.CommandBlock([], [new Commands.SysCall('$write')]);
+  const writeFunction = function (store, _) {
+    const val = store.applyStore('p1');
+    this.output.sendOutput(''+val.value);
+    return Promise.resolve(store);
+  }
+  const block = new Commands.CommandBlock([], [new Commands.SysCall(writeFunction)]);
   const func = new Commands.Function('$write', Types.VOID,
     [new Commands.FormalParameter(Types.ALL, 'p1', 0, false)],
     block);
@@ -10,19 +17,52 @@ function createOutputFun () {
 }
 
 function createInputFun () {
-  const block = new Commands.CommandBlock([],  [new Commands.SysCall('$read')]);
+  const readFunction = function (store, _) {
+    const request = new Promise((resolve, _) => {
+      this.input.requestInput(resolve);
+    });
+    return request.then(text => {
+      const typeToConvert = store.applyStore('p1').type;
+      let stoObj = null;
+      if (typeToConvert === Types.INTEGER) {
+        const val = toInt(text);
+        stoObj = new StoreObject(Types.INTEGER, val);
+      } else if (typeToConvert === Types.REAL) {
+        stoObj = new StoreObject(Types.REAL, parseFloat(text));
+      } else if (typeToConvert === Types.BOOLEAN) {
+        stoObj = new StoreObject(Types.BOOLEAN, toBool(text));
+      } else if (typeToConvert === Types.STRING) {
+        stoObj = new StoreObject(Types.STRING, toString(text));
+      }
+      store.updateStore('p1', stoObj);
+      return Promise.resolve(store);
+    });
+  }
+  const block = new Commands.CommandBlock([],  [new Commands.SysCall(readFunction)]);
   const func = new Commands.Function('$read', Types.VOID,
     [new Commands.FormalParameter(Types.ALL, 'p1', 0, true)],
     block);
   return func;
 }
 
-export const LanguageDefinedFunction = Object.freeze({
-  $write: createOutputFun(),
-  $read: createInputFun()
-});
+function valueToKey (value, object) {
+  for (const key in object) {
+    if(object.hasOwnProperty(key)){
+      if (object[key] === value) {
+        return key;
+      }
+    }
+  }
+  return null;
+}
 
-export const NAMES = Object.freeze({
-  WRITE: '$write',
-  READ: '$read'
+const funcsObject = {
+  $read: createInputFun(),
+  $write: createOutputFun()
+}
+
+export const LanguageDefinedFunction = Object.freeze({
+  getMainFunctionName: () => LanguageService.getCurrentLangFuncs().main_function,
+  getInternalName: (localName) => valueToKey(localName, LanguageService.getCurrentLangFuncs()),
+  getFunction: (internalName) => funcsObject[internalName],
 });

js/processor/ivprogProcessor.js

@@ -6,7 +6,7 @@ import { Modes } from './modes';
 import { Context } from './context';
 import { Types, toInt } from './../ast/types';
 import { Operators } from './../ast/operators';
-import { NAMES, LanguageDefinedFunction } from './definedFunctions';
+import { LanguageDefinedFunction } from './definedFunctions';
 import { resultTypeAfterInfixOp, resultTypeAfterUnaryOp } from './compatibilityTable';
 import * as Commands from './../ast/commands/';
 import * as Expressions from './../ast/expressions/';
@@ -69,7 +69,7 @@ export class IVProgProcessor {
 
   findFunction (name) {
     if(name.match(/^\$.+$/)) {
-      const fun = LanguageDefinedFunction[name];
+      const fun = LanguageDefinedFunction.getFunction(name);
       if(!!!fun) {
         throw new Error("!!!Internal Error. Language defined function not implemented -> " + name + "!!!");
       }
@@ -232,39 +232,8 @@ export class IVProgProcessor {
   }
 
   executeSysCall (store, cmd) {
-    if (cmd.id === NAMES.WRITE) {
-      return this.runWriteFunction(store)
-    } else if (cmd.id === NAMES.READ) {
-      return this.runReadFunction(store);
-    }
-  }
-
-  runWriteFunction (store) {
-    const val = store.applyStore('p1');
-    this.output.sendOutput(''+val.value);
-    return Promise.resolve(store);
-  }
-
-  runReadFunction (store) {
-    const request = new Promise((resolve, _) => {
-      this.input.requestInput(resolve);
-    });
-    return request.then(text => {
-      const typeToConvert = store.applyStore('p1').type;
-      let stoObj = null;
-      if (typeToConvert === Types.INTEGER) {
-        const val = toInt(text);
-        stoObj = new StoreObject(Types.INTEGER, val);
-      } else if (typeToConvert === Types.REAL) {
-        stoObj = new StoreObject(Types.REAL, parseFloat(text));
-      } else if (typeToConvert === Types.BOOLEAN) {
-        stoObj = new StoreObject(Types.BOOLEAN, true);
-      } else if (typeToConvert === Types.STRING) {
-        stoObj = new StoreObject(Types.STRING, text);
-      }
-      store.updateStore('p1', stoObj);
-      return Promise.resolve(store);
-    });
+    const func = cmd.langFunc.bind(this);
+    return func(store, cmd);
   }
 
   executeFunctionCall (store, cmd) {

js/services/languageService.js

@@ -18,11 +18,20 @@ export const LanguageService  = Object.freeze({
   },
 
   getCurrentLexer: () => {
-    const lexer = Lexers[LanguageService.getLang()];
-    if(lexer === null || lexer === undefined) {
-      return Lexers[DEFAULT_LANG];
+    const langInfo = Lexers[LanguageService.getLang()];
+    if(langInfo === null || langInfo === undefined) {
+      return Lexers[DEFAULT_LANG].lexer;
     } else {
-      return lexer;
+      return langInfo.lexer;
+    }
+  },
+
+  getCurrentLangFuncs: () => {
+    const langInfo = Lexers[LanguageService.getLang()];
+    if(langInfo === null || langInfo === undefined) {
+      return Lexers[DEFAULT_LANG].langFuncs;
+    } else {
+      return langInfo.langFuncs;
     }
   }
 

tests/test40.spec.js

@@ -5,6 +5,10 @@ import { LanguageService } from '../js/services/languageService';
 
 describe('The LanguageService', function () {
 
+  beforeEach( () => {
+    localStorage.setItem('ivprog.lang', 'en');  
+  });
+
   const code = `program {
 
     function start() {

tests/test43.spec.js

@@ -8,8 +8,8 @@ describe('The sum of a real and a integer', function () {
   const code = `programa {
 
     funcao inicio() {
-      real a;
-      leia(a);
+      real a
+      leia(a)
       a = a + 0xff
     }
   }`;