Programme_js

//List of all tokens
var tokenList = [
    {
        name: "motsCle",
        hardRegex: /(var|variable|const|constante|fonction|function|procedure|debut|begin|ecrire|write|lire|read|afficher|print|si|if|alors|then|sinon|else|tantque|while|faire|do|repeter|pour|for|De|to|finsi|finPour|finTantque|endWhile|endDoWhile|endFor|entier|integer|reel|double|booleen|boolean|chaine|string|caractere|char|fin|end)$/g,
        softRegex: /(var|variable|const|constante|fonction|function|procedure|debut|begin|fin|end|ecrire|write|lire|read|afficher|print|si|if|alors|then|sinon|else|tantque|while|faire|do|repeter|pour|for|De|to|finsi|finPour|finTantque|endWhile|endDoWhile|endFor|entier|integer|reel|double|booleen|boolean|chaine|string|caractere|char)/g,
        print: "onlyWord"
    }
    ,
    {
        name: "ident",
        hardRegex: /[a-zA-Z_]+[a-zA-Z0-9]*$/g,
        softRegex: /[a-zA-Z_]+[a-zA-Z0-9]*/g,
        print: "wordAndToken"
    },
    {
        name: "affectation",
        hardRegex: /<--$/,
        softRegex: /<--/,
        print: "onlyToken"
    },
    {
        name: "aperateurLogique",
        hardRegex: /><=|\&$/,
        softRegex: /><=|\&/,
        print: "onlyToken"
    },
    {
        name: "numerique",
        hardRegex: /((-)?[0-9]*\.[0-9]+[0-9]*$)|(^(-)?[0-9]+[0-9]*$)/,
        softRegex: /((-)?[0-9]*\.[0-9]+[0-9]*)|(^(-)?[0-9]+[0-9]*)/,
        print: "wordAndToken"
    },
    /*{
        name: "operateur",
        hardRegex: "^\-\/\+\*\%$",
        softRegex: "^\-\/\+\*\%$",
        print: "onlyToken"
    },*/
    {
        name: "plus",
        hardRegex: /\+$/,
        softRegex: /^\+/,
        print: "onlyToken"
    },
    {
        name: "moins",
        hardRegex: /\-$/,
        softRegex: /\-/,
        print: "onlyToken"
    },
    {
        name: "division",
        hardRegex: /\/$/,
        softRegex: /\//,
        print: "onlyToken"
    },
    {
        name: "modulo",
        hardRegex: /\%$/,
        softRegex: /\%/,
        print: "onlyToken"
    },
    {
        name: "pointConcat",
        hardRegex: /\.$/,
        softRegex: /\./,
        print: "onlyToken"
    },
    {
        name: "separateur",
        hardRegex: /\[\]\s,;:\(\)\{\}$/g,
        softRegex: /\[\]\s,;:\(\)\{\}/g,
        print: "onlyToken"
    },
]

//Additional Regexs
var commentRegex = /\\\/*/;


// Useful Variables// variable utilisable
var lexical_analysis;
var partial_lexical_analysis;
var wordsToAnalyse = [] // mot a analyser

//Function to get next token //founction de recuperation du token suivant
function getNextToken(){
    if(wordsToAnalyse.length==0)
        lexicalAnalyzer(null, true)
    token = wordsToAnalyse.shift()
    findToken(token.[https://www.commentcamarche.net/word/ word], token.row)
    console.log(partial_lexical_analysis)
    $('#result').append(partial_lexical_analysis.replace(/&/g, '&')
                                        .replace(/>/g, '>')
                                        .replace(/</g, '<')
                                        .replace(/\n/g,'<br/>'))
}


//Function that splits the code by breaklines and spaces to obtain the WORD
function lexicalAnalyzer(input, only_load) {

    lexical_analysis = "";
    var code;
    if (!input)
        code = document.getElementsByClassName("ace_text-input").value;
    else
        code = input;
    var lines = code.split(/\n/);
    for(var i = 0; i < lines.length; i++){
        var line = lines[i].replace(commentRegex, '');
        var words = splitWithIndex(line)
        for(let word of words){
            if(word.name != ""){
                if(!only_load){ //Sometimes we only need to load all the words but no do the analysis
                    findToken(word, i+1);
                    if(!partial_lexical_analysis.match(tokenList)){
                        i = Number.MAX_SAFE_INTEGER //Force break of two loops
                        break;
                    }
                }
                wordsToAnalyse.push({word:word, row: i+1})
            }
        }
    }
    if(!only_load){
        //console.log(lexical_analysis)
        $('#editor').html(code.replace(/\n/g,'<br/>'))
        $('#result').html(lexical_analysis.replace(/&/g, '&')
                                        .replace(/>/g, '>')
                                        .replace(/</g, '<')
                                        .replace(/\n/g,'<br/>'))
        return lexical_analysis;
    }
}


//Function that finds the token that matches that WORD, but only when it is an absolute match
/* fonction de correspondance entre les mots recuperés et les unités lexicaux definies.
Elle prend en entrée le mot(suite de caracteres) en question et la ligne coorespondante 


*/ 
function findToken(word, row){
   var matched = false;   
   for(let token of tokenList){       
     if(word.name.match(token.hardRegex)){
            matched = true;
            print(token, word.name, word.column, row)
            break;    
     }   
   }    
 if(!matched){       
  deepFindToken(word.name, row, word.column)  
 }
}

//Function that finds the token that matches one word, but only when it is within another onefunction 
deepFindToken(word, row, column) {  
  var matched = false;    
  var min_index_token = Number.MAX_SAFE_INTEGER;   
  var token_to_match=[]    
  var matched_word = [];    
  for (let token of tokenList) {      
    if (word.match(token.softRegex)) {          
      matched = true;           
     // Get index of the matched regexep           
     matched_word = token.softRegex.exec(word)           
     if (matched_word.index < min_index_token) {  
              min_index_token = matched_word.index; 
               token_to_match = token;
     }  else if(matched_word.index == min_index_token){
           if(token_to_match.softRegex.exec(word)[0] != matched_word[0])  
                  token_to_match = token;          
            }     
    } 
   }   
 if (matched) {        
    var matched_regexp = token_to_match.softRegex.exec(word)[0];       
     print(token_to_match, matched_regexp, column, row)     
     if (!(word === matched_regexp) && (matched_regexp.length != 0)) {           
         var cropped_word = word.replace(matched_regexp, '');          
         column += matched_regexp.length
            deepFindToken(cropped_word.trim(), row, column);
      }   
 } else {       
 partial_lexical_analysis = ">>> erreur lexical a la ligne:" + row + " et position: " + column + "\n"       
 lexical_analysis += partial_lexical_analysis   
 }}
//Function that splits by spaces and saves the column of the wordfunction splitWithIndex(line){    
var splits = line.split(/\[\]\s,;:\(\)\{\}/g,).map(item => {        return item.trim()        });    

var words=[]    var index=0    for(let split of splits){        if(split!=' ')            words.push({ column: index+1, name: split})        index += split.length + 1    }    return words}
//Function that prints the token
// fonction qui renvoit les unités lexicales
function print(token, word, column, row){   
 //for(let i =0;i<=token.length;i++){       
 if (token.print == "onlyWord")        
partial_lexical_analysis = "<" + word + "," + row + "," + column + ">\n";       
 else if (token.print == "onlyToken")           
partial_lexical_analysis =  "<" + token.name + "," + row + "," + column + ">\n";          
  else if (token.print == "wordAndToken")                
 partial_lexical_analysis = "<" + token.name + "," + word + "," + row + "," + column + ">\n";      
  lexical_analysis += partial_lexical_analysis;    //}   }
function testInputs(){    const input1 =`  
 var nom , prenom : chaine;    var naissance , age : entier;    
var sexe : caractere;    var statut : chaine;    const limit = 21;    debut        ecrire("entrez votre nom");        lire(nom);        afficher("entrez votre prenom");        lire(prenom);        lire("entrez votre année de naissance" naissance);        lire("entrez votre sexe" sexe);        age <-- 2021-naissance;        si(age<= limit){            statut <-- mineur;                return statut;            }            sinon                 {statut <-- majeur;                return statut;            }        finsi        ecrire(nom." ".prenom." etes age de ".age." et donc ".statut);    fin`;    console.log(lexicalAnalyzer(input1));  }