cleanup in progress

alaindef · alaindef · commit f13cd5dd8d38 · 2024-03-09T20:15:49.000+01:00
diff --git a/defs.h b/defs.h
@@ -8,18 +8,17 @@ using namespace std;
 //    we will assign a type to each allowed character  .
 //    e.g. character 'h' (ascii 104)  is a LETT, character '0' (ascii 48 )is a DIGIT. character (40) is PAR_L (left parenthesis)
 //    the following are the possible character types:
-enum KarType
+enum TokenType
     {ETX,   LF, TAB,    BLANK,  HASHT,  PAR_L,  PAR_R,  DOT,   TIMES,  DIV, PLUS,   MINUS,  LT, EQ, GT, QUEST,  COLON,  LETT,   DIGIT,  CR, OTHER,  EXCLA,  TEST};
 
+typedef vector<TokenType> TokenTypeList;
+
 //PASS 2 will scan the output of PASS1 and generate a list of tokens
 // precedence is according to   https://en.cppreference.com/w/cpp/language/operator_precedence#cite_note-2
 //                          or  https://en.wikipedia.org/wiki/Order_of_operations
-//enum TokenType
-//    {COMMENT, VARI, LIT, NUM, CHS, TimesDiv, PlusMin, COMPARE, ELV_Q, ELV_C, BEXPS, BEXPE, EOT, NONE};
-typedef KarType TokenType;
 
 // prettyPrint of TokenType:
-string ppTokenType[32] =     {"ETX",   "LF", "TAB",    "BLANK",  "HASHT",  "PAR_L",  "PAR_R",  "DOT",   "TIMES",  "DIV", "PLUS",   "MINUS",  "LT", "EQ", "GT", "QUEST",  "COLON",  "LETT",   "DIGIT",  "CR", "OTHER",  "EXCLA",  "TEST"};
+string ppTokenType[32] ={"ETX", "LF", "TAB", "BLANK", "HASHT", "PAR_L", "PAR_R", "DOT", "TIMES", "DIV", "PLUS", "MINUS", "LT", "EQ", "GT", "QUEST", "COLON", "LETT", "DIGIT", "CR", "OTHER", "EXCLA",  "TEST"};
 
 uint cursor = 0;
 typedef struct {
@@ -30,8 +29,10 @@ typedef struct {
     int precedence;
     uint cursor;
 } Token;
+typedef vector<Token> TokenList;
+
+TokenType kartyp[256];    // type of each character
 
-KarType kartyp[256];    // type of each character
 string KarPP[256];      // string representation of each character
 
 void initDinges(){
@@ -63,12 +64,10 @@ void initDinges(){
 }
 
 //      finally our main data structures:
-//  1. the input expression as a text string:
-string textIn= "";
 //  2. the output of PASS1 as a vector of symbols. it is also the input for PASS2.
 //      symbols of type Token, the element "content" can be TODO
-vector<Token> symList;
+TokenList symList;
 //  3. the output of PASS2 as a vector of tokens
-vector<Token> symListOut;
+TokenList symListOut;
 
 #endif // DEFS_H
diff --git a/interpreter.h b/interpreter.h
@@ -1,11 +1,12 @@
 #ifndef INTERPRETER_H
 #define INTERPRETER_H
 
-float calc(vector<Token>& s){
-    float v1;
+float calc(TokenList& s){
+  float v1;
     float v2;
     float v3;
-    Token last = s.back(); s.pop_back();
+    Token last = s.back();
+    s.pop_back();
     if (last.type == DIGIT) return stof(last.content);                                  // todo also LIT VARI?
     switch (last.arity){
         case 1: v1 =calc(s); return -v1;
@@ -19,8 +20,9 @@ float calc(vector<Token>& s){
 }
 
 
- void calcandprint(vector<Token> s) {
-    cout << "RESULT ==> " << float(calc(s)) << endl;
+ void calcandprint(TokenList s) {
+        cout << "\nEVALUATION RESULT ==> " << float(calc(s)) << endl <<
+        "_______________________________________________________________________________" << endl;
 }
 
 #endif // INTERPRETER_H
diff --git a/main.cpp b/main.cpp
@@ -10,22 +10,11 @@
 #include <unistd.h>
 #include <algorithm>        // count function
 
-
 #include <defs.h>          // global definitions
 #include <utils.h>         // utilities
 
 using namespace std;
 
-bool elaps = true;
-clock_t pTime, cTime = clock();
-void reportElapsedTime(string msg){
-    if (elaps){
-        cTime = clock();
-        std::cout << "time passed: " << (cTime - pTime)/1000000.0 << " in " << msg << endl;
-        pTime = cTime;
-    }
-}
-
 #include <pass1.h>
 #include <pass2.h>
 #include <interpreter.h>
@@ -36,60 +25,52 @@ int main(int argc, char *argv[])
     initDinges();
     initOperators();
 
-    //tests
-    cout << "testing ... \n" << int(c) << endl;
-//    cout << "invoke: " << op2[1](2,3) << endl;
-
-// test cases: uncomment 1 of them to try
-
-//    textIn = "1<-2!";
-//    textIn = "(2+3)*(1<(-2)) + (6/2)!";
-//    textIn = "(2+3)*(1<-2) + (6/2)!";          //CALC CRASH
-//    textIn = "1+-2!";
-//    textIn = "6*2*4/5!";
-//    textIn = "(6)!";
-//        textIn = "(6)";
-//    textIn = "5*(-1 + (6-2)*2)!";
-    textIn = "2*3+5<1?777:((1<2 + (6/2))+17/4)";
-//    textIn = "2*-5+17*2-(45<2)!";
-//    textIn = "0?2:3!";
-//    textIn = "-1+(5<4 ?4*5:(17-5)*3)!";
-
-
-    cout << "textIn is: " << textIn << endl;
-    cout << "\nPASS 1 gives the tokenized input :\n"; parse1();
+    string text = "";
+
+    vector<string> inputs = {"","type it yourself",
+        "1<-2",
+        "1 -2",
+        "(2+3)*(1<(-2)) + (6/2)",
+        "(2+3)*(1<-2) + (6/2)",
+        "1+-2",
+        "6*2*4/5",
+        "(6)",
+        "(6)",
+        "5*(-1 + (6-2)*2)",
+        "2*3+5<1?777:((1<2 + (6/2))+17/4)",
+        "2*-5+17*2-(45<2)",
+        "0?2:3",
+        "-1+(5<4 ?4*5:(17-5)*3)"};
+
+    uint choice = 0;
+    string ch = "";
+
+    while (true) {
+    cout << "\nchoose:         -- choose 0 to exit\n"
+            "\n1. enter expression";
+    for (uint i = 2; i<inputs.size(); i++) cout << "\n" << i << ". " << inputs[i] ;
+    cout << "\n\nchoice ==> ";
+//    cin  >> choice;  //because cin stops at spaces, we use getline now. do not mix cin and getline!
+    getline(cin, ch); choice = stoi(ch);
+    if (choice > inputs.size()) {cout << "wrong choice   " << choice << endl; continue;}
+    if (choice == 0) return 0;
+    if (choice == 1) getline(cin, text);
+//    if (choice == 1) cin >> text;
+    else text = inputs[choice];
+
+    cin.clear();
+    cin.ignore();
+    cout << "\ntext in: " << text << endl;
+    cout << "\nPASS 1 gives the tokenized input :\n"; parse1(text);
     printPass(symList, 5);
     cout << "\n\nPASS 2 gives the RPN form of the expression"; parse2();
     printPass(symListOut, 5);
-
     calcandprint(symListOut);
-
-    cout << "\n\nthe end"<< endl;
+    };
 
     return 0;
 
     //end TEST
 
-    // the following is not used yet
-    int choice = 0;
-    cout << "choose:\n1. create the 4 world part files\n2. create srtmfiles\n3. create both\n4. reduce files to Res400\n5. create both and reduce files to Res400\n";
-    while ((choice==0) | (choice>3)) {
-        cin  >> choice;
-        switch (choice) {
-        case 1:
-            break;
-        case 2:
-            break;
-        case 3:
-            break;
-        default:
-            cout << "wrong choice " << choice << endl;
-            break;
-        };
-        cin.clear();
-        cin.ignore();
-    };
-    cout << "optionChosen final = " << choice << endl;
-
     return 0;
 }
diff --git a/pass1.h b/pass1.h
@@ -6,13 +6,13 @@
 bool isFirstSymbol=true;
 char c;
 
-Token makeSymbol(vector<TokenType> expected){
+Token makeSymbol(string textIn, TokenTypeList expected){
     string s = "";
     if (cursor >= textIn.length()) return Token{ETX,"",-1,-1,-1};
     c = textIn[cursor];
     if (isaC(c, {BLANK, TAB})) {
         cursor++;
-        return makeSymbol({});                                                          //makesymbol advances the cursor
+        return makeSymbol(textIn, {});                                                          //makesymbol advances the cursor
         }
 
     symIn.type = kartyp[int(c)];
@@ -21,7 +21,7 @@ Token makeSymbol(vector<TokenType> expected){
     symIn.arity   = -1;
     symIn.precedence = -1;
     symIn.cursor  = cursor;                                                             // not used for now
-    KarType karTypeIn = kartyp[int(c)];
+    TokenType karTypeIn = kartyp[int(c)];
     switch (karTypeIn) {
         case LETT: case DIGIT: case DOT:                                                //c is a KAR, so we're building a string
             s = "";
@@ -75,13 +75,15 @@ Token makeSymbol(vector<TokenType> expected){
     isFirstSymbol = false;
     cursor++;
     if (expected.empty()) return symIn;            //default, we do not complain
-    if (count(expected.begin(), expected.end(), symIn.type) > 0) return symIn;         //check on expected char is ok, no complaints
+    if (count(expected.begin(), expected.end(), symIn.type) > 0) return symIn;        //check on expected char is ok, no complaints
     errorsPresent = true;
-//        throw IllegalArgumentException(
-//            "SEPARATOR in line at cursor " +
+    string errors = "SEPARATOR in line at cursor " + to_string(cursor) ;
+        throw invalid_argument(errors
+//            "SEPARATOR in line at cursor " &
 //            "$cursor < ${textIn.substring(0, cursor)} > \n" +
 //            "     char=$c, symbol=${symIn.content}   ==> < ${expected.contentToString()} >\n"
-//            );
+// adf cpp problem
+            );
     return symIn;
 }
 
@@ -91,12 +93,12 @@ void clear1() {
     symList.clear();
 }
 
-vector<Token> parse1(){
+TokenList parse1(string textIn){
     clear1();
     cursor = 0;
     errorsPresent = false;
         do {
-        symIn = makeSymbol({});
+        symIn = makeSymbol(textIn, {});
         symList.push_back(symIn);
         } while (symIn.type != ETX);
     return symList;
diff --git a/pass2.h b/pass2.h
@@ -8,16 +8,18 @@ void push(Token sym) {
     textOut += sym.content;
 }
 
-Token nextSymbol(string from, vector<TokenType> expected){
-//  param from: the cpp function from where nextsymbol is called. used for error reporting
-    if (symList.empty()) throw invalid_argument("from" + from + ": symbols missing!");
+Token nextSymbol(string from, TokenTypeList expected){
+    //  param from: the cpp function from where nextsymbol is called. used for error reporting
+    // expected: the list of possible TokenTypes. it is filled in by the calling function
+    string ppexpectedList = "";
+    for (TokenType t: expected) ppexpectedList += " " + ppTokenType[t];
+    if (symList.empty()) throw invalid_argument("from " + from + ": symbols missing!");
     Token next = symList.back(); symList.pop_back();
     if (expected.empty()) return next;
     if (count(expected.begin(), expected.end(), next.type) > 0) return next;
-    errorsPresent = true;
     throw invalid_argument(
         "from " + from + " at cursor=" + to_string(next.cursor) + " symbol=" + next.content + ", " + ppTokenType[next.type] +
-        "} NOT IN " + "expected" + "}"                                                      // "expected" should be the list of expected types
+        " is not one of {" + ppexpectedList + "}"                                                      // "expected" should be the list of expected types
         );
     return next;
 }
@@ -113,22 +115,19 @@ void expr13(){
 void clear2() {
     symListOut.clear();
     cursor = 0;
-    errorsPresent = false;
     textOut = "";
 }
 
-vector<Token> parse2(){
+TokenList parse2(){
     reverse(symList.begin(), symList.end());
     clear2();
     cursor = 0;
-    errorsPresent = false;
     try {
         symIn = nextSymbol("parse", {});
         expr();
     } catch (const exception& e) {
         cout << "\n\n!!! PARSE ERROR:" << e.what() << endl<< endl;;
     };
-    if (!errorsPresent) cout << endl;
     return symListOut;
 };
 
diff --git a/utils.h b/utils.h
@@ -8,12 +8,12 @@
 Token symIn = {OTHER, "", -1, -1, 0, 0};             // used in both pass1 and pass2
 bool errorsPresent = false;
 
-bool isa(Token token, vector<TokenType> allowedTypes){
+bool isa(Token token, TokenTypeList allowedTypes){
     //    check if the symbol sym is one of the symbols in the list op
     return(count(allowedTypes.begin(), allowedTypes.end(), token.type) > 0);
 }
 
-bool isaC(char Kar, vector<KarType> allowedTypes){
+bool isaC(char Kar, TokenTypeList allowedTypes){
     //    int found = find(allowedTypes.begin(), allowedTypes.end(), int(Kar));
     int cnt = count(allowedTypes.begin(), allowedTypes.end(), kartyp[int(Kar)]);
     return(cnt > 0);
@@ -47,7 +47,7 @@ void initOperators(){
 }
 
 // some printing stuff
-void printPass(vector<Token> symList, int tab){
+void printPass(TokenList symList, int tab){
     cout << "type  : ";
     for (Token element : symList)
         cout << setw(tab) << ppTokenType[element.type] << " ";
