Sources/interp.cpp

   1 /*
   2  * miniREPL
   3  * https://github.com/vrmiguel/minirepl
   4  *
   5  * Copyright (c) 2020 Vinícius R. Miguel <vinicius.miguel at unifesp.br>
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a copy
   8  * of this software and associated documentation files (the "Software"), to deal
   9  * in the Software without restriction, including without limitation the rights
  10  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  11  * copies of the Software, and to permit persons to whom the Software is
  12  * furnished to do so, subject to the following conditions:
  13  *
  14  * The above copyright notice and this permission notice shall be included in all
  15  * copies or substantial portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  18  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  20  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  21  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  22  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  23  * SOFTWARE.
  24  */
  25
  26 #include "Headers/interp.h"
  27 #include "Headers/os.h"
  28 #include <algorithm>
  29 #include <cmath>
  30
  31 using std::stoi;
  32 using std::to_string;
  33
  34 inline bool isdigit(char c)
  35 {
  36     return (c > 47 && c < 58);
  37 }
  38
  39 inline bool ischar(char c)
  40 {
  41     return (c > 64 && c < 91) || (c > 96 && c < 123);
  42 }
  43
  44 Interpreter::Interpreter(string text)
  45 {
  46     this->text      = text;
  47     this->pos       = 0;
  48 }
  49
  50 void Interpreter::eval_bin_op(vector<Token> &tokens, int optype, int index)
  51 {
  52     try
  53     {
  54         if(tokens[index-1].var_type == INTEGER && tokens[index+1].var_type == INTEGER)
  55         {
  56             int left_oper  = stoi(tokens[index-1].var_value);
  57             int right_oper = stoi(tokens[index+1].var_value);
  58             if (optype == PLUS)
  59                 tokens[index-1].var_value = to_string(left_oper + right_oper);
  60             else if (optype == MINUS)
  61                 tokens[index-1].var_value = to_string(left_oper - right_oper);
  62             else if (optype == MULT)
  63                 tokens[index-1].var_value = to_string(left_oper * right_oper);
  64             else if (optype == DIV)
  65                 tokens[index-1].var_value = to_string(left_oper / right_oper);
  66             else if (optype == EXP)
  67                 tokens[index-1].var_value = to_string((int) pow(left_oper, right_oper));
  68             tokens.erase(tokens.begin() + index);
  69             tokens.erase(tokens.begin() + index);
  70         }
  71     } catch (const std::exception& e) {
  72         cerr << "Syntax error.\n" << e.what() << '\n';
  73         exit(2);
  74     }
  75 }
  76
  77 Token Interpreter::get_token()
  78 {
  79     if (pos > (text.size() -1))
  80     {
  81         return Token(EOL, "");
  82     }
  83
  84     char cur_char = text[pos];
  85
  86     if (cur_char == ' ')
  87     {
  88         pos++;
  89         return Token(SPACE, cur_char);
  90     }
  91
  92     if (cur_char == '=')
  93     {
  94         pos++;
  95         return Token(ATTRIB, cur_char);
  96     }
  97
  98     if (cur_char == '^')
  99     {
 100         pos++;
 101         return Token(EXP, cur_char);
 102     }
 103
 104 //    if (cur_char == '(')
 105 //    {
 106 //        pos++;
 107 //        return Token(OPENPAR, cur_char);
 108 //    }
 109
 110 //    if (cur_char == ')')
 111 //    {
 112 //        pos++;
 113 //        return Token(CLOSEPAR, cur_char);
 114 //    }
 115
 116     if (isdigit(cur_char))
 117     {
 118         string intval (1, cur_char);
 119         try
 120         {
 121             while(isdigit(text[pos+1]))
 122                 intval = intval + text[++pos];
 123             pos++;
 124             return Token(INTEGER, intval);
 125         }
 126         catch (const std::out_of_range& oor)
 127         {
 128             cout << "Exception " << oor.what() << " catched.";
 129             pos++;
 130             return Token(INTEGER, intval);
 131         }
 132     }
 133
 134     if (ischar(cur_char))
 135     {
 136         string varname (1, cur_char);
 137         try
 138         {
 139             while(ischar(text[pos+1]))
 140                 varname = varname + text[++pos];
 141             pos++;
 142             return Token(STRING, varname);
 143         }
 144         catch (const std::out_of_range& oor)
 145         {
 146             cout << "Exception " << oor.what() << " catched.";
 147             pos++;
 148             return Token(STRING, varname);
 149         }
 150     }
 151
 152     if (cur_char == '+')
 153     {
 154         pos++;
 155         return Token(PLUS, cur_char);
 156     }
 157
 158
 159     if (cur_char == '-')
 160     {
 161         pos++;
 162         return Token(MINUS, cur_char);
 163     }
 164
 165     if (cur_char == '*')
 166     {
 167         pos++;
 168         return Token(MULT, cur_char);
 169     }
 170
 171     if (cur_char == '/')
 172     {
 173         pos++;
 174         return Token(DIV, cur_char);
 175     }
 176
 177     cerr << cur_char << " is an invalid token.";
 178     return Token(EOL, "");
 179 }
 180
 181 void Interpreter::perform_mult_and_div(vector<Token>& tokens)
 182 {
 183     Token mul(MULT, '*'), div(DIV,  '/');   // TODO: pls optimize this
 184     while (contains(tokens, mul) || contains(tokens, div))
 185     {
 186         for(unsigned long int i = 0; i < (unsigned int) tokens.size(); i++)
 187         {
 188             if (tokens[i].var_type == MULT)
 189             {
 190                 eval_bin_op(tokens, MULT, i);
 191                 break;
 192             }
 193
 194             if (tokens[i].var_type == DIV)
 195             {
 196                 eval_bin_op(tokens, DIV, i);
 197                 break;
 198             }
 199         }
 200     }
 201 }
 202
 203 void Interpreter::perform_add_and_subtraction(vector<Token>& tokens)
 204 {
 205     while (tokens.size() > 2)
 206     {
 207         for(unsigned long int i = 0; i < (unsigned int) tokens.size(); i++)
 208         {
 209             if (tokens[i].var_type == PLUS)
 210             {
 211                 eval_bin_op(tokens, PLUS, i);
 212                 break;
 213             }
 214
 215             if (tokens[i].var_type == MINUS)
 216             {
 217                 eval_bin_op(tokens, MINUS, i);
 218                 break;
 219             }
 220         }
 221     }
 222 }
 223
 224 void Interpreter::perform_unary_minus(vector<Token> &tokens)
 225 {
 226     if(tokens[0].var_type == MINUS)
 227     {
 228         if(tokens[1].var_type != INTEGER)
 229         {
 230             cerr << "Syntax error.\n";
 231             exit(0);
 232         }
 233         if(stoi(tokens[1].var_value) > 0)
 234             tokens[1].var_value = "-" + tokens[1].var_value;
 235
 236         tokens.erase(tokens.begin());
 237     }
 238 }
 239
 240 void Interpreter::perform_exp(vector<Token> &tokens)
 241 {
 242     Token exp(EXP, '^');
 243     while (contains(tokens, exp))
 244     {
 245         for(unsigned long int i = 0; i < (unsigned int) tokens.size(); i++)
 246         {
 247             if (tokens[i].var_type == EXP)
 248             {
 249                 eval_bin_op(tokens, EXP, i);
 250                 break;
 251             }
 252         }
 253     }
 254 }
 255
 256 Token Interpreter::replace_variable(vector<Token>& tokens)
 257 {
 258     //Token var_symbol (STRING, var.var_name);
 259         for(unsigned long int i = 0; i < (unsigned int) tokens.size(); i++)
 260         {
 261             if (tokens[i].var_type == STRING)
 262             {
 263                 findres_t res = var_find(tokens[i].var_value); // Looks for a variable with the given string value
 264                 if (!res.was_found)  // Variable not found
 265                 {
 266                     cerr << "Variable " << tokens[i].var_value << " is not defined.";
 267                     return Token(EOL, "");
 268                 }
 269                 else{
 270                         // The variable was found
 271                     tokens[i].var_type  = INTEGER;
 272                     tokens[i].var_value = res.var;   // so we'll replace it on the expression.
 273                 }
 274             }
 275         }
 276     return Token(STRING, "success");
 277 }
 278
 279 Token Interpreter::expr()
 280 {
 281     vector<Token> created_tokens;
 282     string var_name;
 283
 284     for(;;)
 285     {
 286         Token tok = get_token();           // Iterates through Interpreter::text and saves all tokens (except whitespaces)
 287         if(is_verbose)
 288             cout << tok << ' ';
 289         if (tok.var_type != SPACE)
 290             created_tokens.push_back(tok);
 291         if(tok.var_type == EOL || tok.var_type == EOFile)
 292             break;
 293     }
 294
 295         // Verifies if a string was read
 296     if (created_tokens[0].var_type == STRING)
 297     {
 298             // Verifies if there was an attribution of value
 299         if (created_tokens[1].var_type != ATTRIB)
 300         {
 301             findres_t res = var_find(created_tokens[0].var_value);
 302             if (!res.was_found)
 303             {                                               // Variable not found
 304                 cerr << "Variable " << created_tokens[0].var_value << " is not defined.";
 305                 return Token(EOL, "");
 306             }
 307             if(created_tokens.size() == 2)              // User wants to print a variable ..
 308                 return Token(INTEGER, res.var);         // .. so let's return the value of that variable
 309         }
 310         else
 311         {
 312             // In this case, there was attribution. We'll calculate the value of the expression and then
 313             // attribute this value to the given variable later on.
 314         if (created_tokens.size() == 3)
 315         {
 316             cerr << "Variable without a value.";
 317             return Token(EOL, "");
 318         }
 319         var_name = created_tokens[0].var_value;
 320         created_tokens.erase(created_tokens.begin());
 321         created_tokens.erase(created_tokens.begin());
 322         }
 323     }
 324
 325         // Verifies if there are variables inside of the expression
 326         // If there are, it replaces the variables with their contents
 327         // If the expression uses undefined variables, a warning is sent ..
 328         // .. and an EOL token is returned.
 329     Token response = replace_variable(created_tokens);
 330     if (response.var_type == EOL)
 331         return response;    // Expression uses an undefined variable.
 332
 333     perform_unary_minus(created_tokens);
 334     perform_exp(created_tokens);
 335
 336         // Does multiplication and division operations, if they exist
 337     perform_mult_and_div(created_tokens);
 338
 339         // Does addition and subtraction operations, if they exist
 340     perform_add_and_subtraction(created_tokens);
 341
 342     if (!var_name.empty())
 343     {
 344         // var_name isn't empty, so we'll create a variable with that value
 345         findres_t res = var_find(var_name);
 346         if (!res.was_found)    // Variable didn't exist, so we'll create it.
 347         {
 348            var_list[var_name] = created_tokens[0].var_value;
 349         }
 350         else
 351         {               // Variable already exists, so we need to update its value.
 352             var_list[var_name] = created_tokens[0].var_value;
 353         }
 354     }
 355     return created_tokens[0];
 356 }