interpreter/syntax2.y at master · SelfMade-Programming-Language/interpreter · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
%{
  #include <stdio.h>
  #include <string.h>

  #include "HeaderFiles/langFunctions.h"
  #include "HeaderFiles/validators.h"

  extern char Data_Type[50];

  extern void yyerror();
  extern int yylex();
  extern char* yytext;
  extern int yylineno;

  void storeDataType(char*);
  int isDuplicate(char*, char*);
  void storeIdentifier(char*,char*);
  void DuplicateIdentifierError(char*);
  char* retrieveDataType();
  void clearBuffers();
  int isValidAssignment(char*);
  void AssignmentError(char*);
  char* extractIdentifier(char[]);

  //For Array Identifiers
  int noOfArrayIdentifiers=0;
  char extractedIdentifier[50][50];

%}


%define parse.lac full
%define parse.error verbose


%union {
  int intVal;
  char* dataType;
  char* strVal;
  float floatVal;
  char charVal;
}


%token  COMMA   SINGLE_QUOTES   SEMI_COLON   EQUALS
%token  BRACKET_OPEN  BRACKET_CLOSE   CURLY_BRACE_OPEN  CURLY_BRACE_CLOSE BIG_BRACKET_OPEN  BIG_BRACKET_CLOSE

%token <charVal>  CHARACTER_VALUE
%token <intVal>   INTEGER_VALUE
%token <floatVal> FLOAT_VALUE
%token <strVal> STRING_VALUE


%token <intVal> INT
%token <floatVal> FLOAT
%token <strVal> STRING
%token <dataType> DATA_TYPE
%token <strVal> IDENTIFIER   ARRAY_IDENTIFIER
%token <strVal> STRUCT

%type <strVal> DECLARATION
%type <strVal> EXPRESSION
%type <strVal> FUNCTION_DECLARATION


%%

DECLARATION : EXPRESSION  SEMI_COLON                              { clearBuffers(); }
      |   FUNCTION_DECLARATION SEMI_COLON
      | STRUCT  IDENTIFIER  STRUCTURE_DEFINITION  SEMI_COLON
      | STRUCT  IDENTIFIER  STRUCTURE_DEFINITION  IDENTIFIER_LIST   SEMI_COLON
      | DECLARATION EXPRESSION  SEMI_COLON                        { clearBuffers(); }
      | DECLARATION FUNCTION_DECLARATION SEMI_COLON
      | DECLARATION   STRUCT  IDENTIFIER  STRUCTURE_DEFINITION  SEMI_COLON
      | DECLARATION   STRUCT  IDENTIFIER  STRUCTURE_DEFINITION  IDENTIFIER_LIST   SEMI_COLON

      | error '>'                     {/* ' > ' stops execution all together */}
      ;

EXPRESSION  : DATA_TYPE IDENTIFIER              {
                                  if(!isDuplicate($2,retrieveDataType())){
                                    storeIdentifier($2,retrieveDataType());
                                    storeDataType($1);
                                  }else{
                                    DuplicateIdentifierError($2);
                                  }
                                }


      | EXPRESSION  EQUALS  NUMBER            {;}

      | EXPRESSION  COMMA IDENTIFIER          {
                                  if(!isDuplicate($3,retrieveDataType())){
                                    storeIdentifier($3,retrieveDataType());
                                  }else{
                                    DuplicateIdentifierError($3);
                                  }
                                }


      | DATA_TYPE   ARRAY_IDENTIFIER            {

                                  strcpy(extractedIdentifier[noOfArrayIdentifiers],extractIdentifier($2));
                                  if(!isDuplicate(extractedIdentifier[noOfArrayIdentifiers],retrieveDataType())){
                                    storeIdentifier(extractedIdentifier[noOfArrayIdentifiers],retrieveDataType());
                                    storeDataType($1);
                                  }else{
                                    DuplicateIdentifierError(extractedIdentifier[noOfArrayIdentifiers]);
                                  }
                                  noOfArrayIdentifiers++;
                                }

      | EXPRESSION  EQUALS  CURLY_BRACE_OPEN  PARAMETER_LIST  CURLY_BRACE_CLOSE

      | EXPRESSION COMMA ARRAY_IDENTIFIER             {
                                    strcpy(extractedIdentifier[noOfArrayIdentifiers],extractIdentifier($3));
                                    if(!isDuplicate(extractedIdentifier[noOfArrayIdentifiers],retrieveDataType())){
                                      storeIdentifier(extractedIdentifier[noOfArrayIdentifiers],retrieveDataType());
                                    }else{
                                      DuplicateIdentifierError(extractedIdentifier[noOfArrayIdentifiers]);
                                    }
                                    noOfArrayIdentifiers++;
                                  }


      | error '>'                   {/* no need to call yyerror cuz of line 1570 of y.tab.c*/}
      ;


NUMBER    : INTEGER_VALUE                 {if(!isValidAssignment("int")){ AssignmentError(itoa($1));}}
      | FLOAT_VALUE                   {if(!isValidAssignment("float")){ AssignmentError(ftoa($1));}}
      | CHARACTER_VALUE                 {if(!isValidAssignment("char")){ AssignmentError(ctoa($1));}   }
      | STRING_VALUE                  {if(!isValidAssignment("char*")){ AssignmentError($1);} }
      ;


PARAMETER_LIST  : NUMBER
        | PARAMETER_LIST  COMMA   NUMBER
          |   NUMBER EQUALS NUMBER                        { yyerror("Two or more equal signs are not allowed in C");}
          |   error '>'
        ;


STRUCTURE_DEFINITION  : CURLY_BRACE_OPEN  DECLARATION   CURLY_BRACE_CLOSE
            ;

FUNCTION_DECLARATION : DATA_TYPE IDENTIFIER BRACKET_OPEN DATA_TYPE_LIST BRACKET_CLOSE {

                                          if(!isDuplicate($2,retrieveDataType())){
                                            storeIdentifier($2,retrieveDataType());
                                            storeDataType($1);
                                          }else{
                                            DuplicateIdentifierError($2);
                                          }

                                        }
          ;

IDENTIFIER_LIST     : IDENTIFIER
            | IDENTIFIER_LIST   COMMA   IDENTIFIER
            ;

DATA_TYPE_LIST      : DATA_TYPE
            | DATA_TYPE_LIST  COMMA DATA_TYPE
            ;

%%


int main(){

  yyparse();
  printf("No Errors!!\n");
  return 0;
}