Peg Grammar AST Parser Computer Language Interpreter, C++ (gcc)

Language: Layout:

//g++  7.4.0

/*TEST GRAMMAR AST PARSER FOR THE NEW GHC (GRASSHOPPER) COMPUTER LANGUAGE
  by: Robin Deatherage
  Written in C++
*/
#include <iostream>
#include <string.h>

#ifndef VMAX
#define VMAX 195
#endif

struct Var {
    int vtp;
    char vnm[VMAX];
    char val[VMAX];
};

void fetchval(struct Var p, char target[], int ndx) {
    
};

using namespace std; //----will remove after testing

enum gsdtypes {INT = 1, CHAR, DOUBLE, STRING, FLOAT, BOOL, LONG, UNSIGNED};
enum gskeywords {PRINT = 1, FOR, WHILE, IF, ELSE};// MORE TO ADD AS WE MOVE ON
// state machine PEG Grammer Parser
// vtype---intger=1, char=2, double=3, string=4, float=5, bool=6
//ABSTRACT SYNTAX TREE'S REQUIRE STATE MACHINE COUNTS AND SWITCHES FOR NODE TRAVERSING
int vstate=0;// DETERMINES VARIABLE STATE 1=ON 0=OFF
int vcnt=0;  // DETERMINES VARIABLE COUNT, INDEXES THE VARIABLE STORING LINKED LIST ARRAY STACK
int vtype=0; // DETERMINES VARIABLE DATA TYPE
int ststate=0;// DETERMINES STRING STATE  1=ON 0=OFF
int scnt=0;   // DETERMINES STRING WORD COUNT UNTIL WE REACH THE END OF STRING

int main()
{
    struct Var v[20]; // SET FOR TESTING AT 20, IN PRODUCTION THIS WILL BE AT 4096 MALLOC PLUS
    //CHAR STR IS OUR TEST PEG GRAMMAR FOR THE AST PARSER BELOW, ITS ENTRY WILL BE READ FROM (ARGV CHAR ARGC)
    char str[] = "INT x EQUAL 100 SCOLN NWLN INT y EQUAL 10 SCOLN NWLN INT\
    x EQUAL x PLUS y SCOLN NWLN PRINT x SCOLN NWLN FLOAT f1 EQUAL 4.579 SCOLN NWLN\
    CHAR stx EQUAL DBL I Am A String! DBL SCOLN NWLN DEF myfunction LPAREN RPAREN LCURL PRINT LPAREN \"I am a function.\"RPAREN RCURL SCOLN NWLN\
    CHAR xm EQUAL DBL  A short sentense for you. DBL SCOLN NWLN INT z EQUAL myfunction LPAREN RPAREN SCOLN NWLN"; 
    
    const char s[2] = " ";
    char *tok;
    char *tok2;
    char st[50];
    tok = strtok(str, s); //LOAD FIRST TOKEN FOR THE LOOP
    
    while( tok != NULL ) {        //BEGIN STATE MACHINE NODE TRAVERSALS
        if(!strcmp(tok, "INT")) {
            printf("--integer\n");
            v[vcnt].vtp = INT;
            vstate = 1; //THE LOOK-AHEAD THAT SIGNALS INTEGER IN THE TRAVERSAL ON THE NEXT ITERATION BELOW
            
            tok = strtok(0, s);//SUSPECDTED VARIABLE OR FUNCTION NAME
            strcpy(v[vcnt].vnm, tok);// STORE THE VARIABLE
            vcnt++;// INCREMENT THE COUNTER after initial var NM NAME is stored count
            
            tok = strtok(0, s);//SUSPECTED = EQUAL KEY OR FUNCTION NAME
            if(!strcmp(tok, "EQUAL")) {
                cout << "XX--EQUAL KEY--" << tok << endl;
            
                tok = strtok(0, s);//SUSPECTED VALUE IF IS DIGIT ELSE LEFT HAND VARIABLE OR NUMBER
                if(isdigit(tok[0])) {
                    cout << "X---XXXX-NUMBER---" << tok[0] << endl;
                    tok2 = strtok(0, s); //USING TOK2 ONLY AS A LOOK-AHEAD

if((!strcmp(tok2, "SCOLN"))) {//CONFIRM IT DOES END WITHOUT A RIGHT HAND OPERATOR (,),+,-,/,* ETC.
                        cout << "TOK2 HAS NO SCOLN(SEMICOLON)" << endl; // ITS A DATA VALUE WE STORE IT
                        strcpy(v[vcnt-1].val, tok); // STORE IT AS ASSIGNED DATA VAR VAL VALUE, ***REQUIRES SUBTRACTING 1 FROM VCNT
                        vstate = 0; //RESET VSTATE=0
                    }
                //HERE STORE TOKEN NUMBER AS LEFT-HAND LH INTO STRUCT EXPRESSION
                } else
                if(isalpha(tok[0])) { // WE HAVE A INTEGER ASSIGNED VARIABLE, CLASS OR FUNCTION CALLER 
                    cout << "IS ALPHA" << endl; //
                    // ADD DATA TO STRUCT EXPRESSION STORAGE FOR CALCULATING MATH
                    //NOT IMPLIMENTED YET----------------------XXX 
                    tok = strtok(0, s); // LOOK-AHEAD TO CHECK FOR "(" LPAREN --FOR CLASS OR FUNCTION CALLER
                    if((!strcmp(tok, "LPAREN"))) { //TO DETERMINE A FUNCTION OR CLASS CALLER
                        cout << "--do integer return function " << tok << endl;
                       
                    } //END IF LPAREN
                } //END ISALPHA
            } //END IF EQUAL
                //if(isalpha(tok[0])) {
                //tok = strtok(0, s);//SUSPECTED END-LINE, OPERAND OR FUNCTION LEFT CURLY BRACE
                //cout << "X---" << tok << endl;
                //tok = strtok(0, s);//SUSPECTED RIGHT-HAND VARIABLE OR NUMBER
                //cout << "X---" << tok << endl;} 
            
        } else 
        if(!strcmp(tok, "CHAR")) {
            printf("--char\n");
            v[vcnt].vtp = CHAR;
            tok = strtok(0, s);//SUSPECDTED VARIABLE NAME
            strcpy(v[vcnt].vnm, tok);// STORE THE VARIABLE NAME
            vcnt++;// INCREMENT THE COUNTER after initial var NM NAME is stored count
            tok = strtok(0, s); // SHOULD BE AN EQUAL HERE
            cout << "CHAR------EQUAL KEY--" << tok << endl;
            tok = strtok(0, s); // SHOULD BE A FIRST DBL DOUBLE QUOTE HERE
            //tok = strtok(0, s); //GET FIRST DBL DOUBLEQUOTE
            ststate = 2; // SET STATE FOR CHAR BUFFER CONCATENATIONS BEGINNING ON NEXT ITERATION
            /*tok2 = strtok(0, s); //USING TOK2 ONLY AS A LOOK-AHEAD
                    if((!strcmp(tok2, "SCOLN"))) {//CONFIRM IT DOES END WITHOUT A RIGHT HAND OPERATOR (,),+,-,/,* ETC.
                        cout << "TOK2 CHAR HAS NO SCOLN(SEMICOLON)" << endl; // ITS A DATA VALUE WE STORE IT
                        //vcnt++; // Begin the char count here to fetch all the strings between parentheses
                        strcpy (st, tok);
                        strcat (st,"strings ");
                    }*/
                        
        } else  
        if(!strcmp(tok, "DOUBLE")) {
            printf("--double\n");
            //vcnt++; //NOT STORED YET
            vstate = 3;
            
        } else 
        if(!strcmp(tok, "STRING")) {
            printf("--string\n");
            //vcnt++; //NOT STORED YET
            vstate = 4;
            
        } else  
        if(!strcmp(tok, "FLOAT")) {
            printf("--float\n");
            //vcnt++; //NOT STORED YET
            vstate = 5;
            
        } else   
        if(!strcmp(tok, "BOOL")) {
            printf("--found a bool\n");
            //vcnt++; //NOT STORED YET
            vstate = 6;
            
        } else  
        if(!strcmp(tok, "PRINT")) {
            printf("--do print\n");
            
        } else 
        if(!strcmp(tok, "DEF")) {
            printf("--DO DEF DEFINE FUNCTION\n");
            //vcnt++;
            vstate = 2;
            
        //} else   
        //if(!strcmp(tok, "NWLN")) {
        //    printf("-- found a newline\n");
            
        } else   
        if(!strcmp(tok, "EQUAL")) {
            printf("--operator =\n"); 
            
        } else   
        if(!strcmp(tok, "PLUS")) {
            printf("--found operator +\n");
            
        } else   
        if(!strcmp(tok, "MINUS")) {
            printf("--found operator -\n"); 
            
        } else  
        if(!strcmp(tok, "DIV")) {
            printf("--found divide operator /\n"); 
            
        } else  
        if(!strcmp(tok, "MULT")) {
            printf("--found multiply operator *\n");
            
        } else 
        if(vstate == 1) {
            printf("---fetching an integer %s \n", tok); //HERE WE CAN FETCH VARIABLES FOR STRUCTS
            vstate = 0;
            
        } else
        if(ststate == 2) {
            //printf("---fetching a char %s \n", tok);
            //tok = strtok(0, s); //GEt first word char group from char string
            if(!strcmp(tok, "DBL")) { //IF SECOND DBL CHAR STRING ENDS HERE....
                ststate = 0; //ENDS THE CHAR STRING FETCHING ROUTINE
                strcpy(v[vcnt-1].val, st); // store the full sentense or char string
                cout << vcnt-1 <<endl;
                strcpy(st, ""); //reset st buffer
            } else {
            cout << "CHAR'S FOUND AFTER FIRST DBL---"<< tok << endl;
            strcat (st, tok); // ADD CHAR STRING GROUP TO BUFFER.....
            //if()
            strcat (st, " "); // APPEND SPACES ALSO
            }
            
        } else 
        if(vstate == 3) {
            printf("---fetching a double %s \n", tok);
            vstate = 0;
        }
        
    tok = strtok(NULL, s); //flush it
    } //END WHILE
    // TEST OF STRUCT VARIABLE DATA STORES
    cout << "INT= " << v[0].vtp <<"--";
    cout << "VAR NAME= " << v[0].vnm <<"--";
    cout << "VAR VALUE of x= " <<v[0].val <<"\n";
    cout << "VAR VALUE of y= " <<v[1].val <<"\n"; // v[2] the float not implimented yet
    cout << "VAR VALUE of x + y= " << atoi(v[0].val) + atoi(v[1].val) <<"\n"; // TEST MATH X + Y
    cout << "VAR VALUE of stx= " << "\"" << v[3].val << "\"" << "\n";
    cout << "VAR VALUE of xm= " << "\"" << v[4].val << "\"" <<"\n";
    cout << st << endl; // TEST CHAR STRING BUFFER FETCHER
    
} //END MAIN

Show compiler warnings [ + ] Compiler args [ + ] Show input
Compilation time: 0.42 sec, absolute running time: 0.16 sec, cpu time: 0.01 sec, memory peak: 5 Mb, absolute service time: 0,68 sec