├── AST ├── ast.l ├── ast.sh ├── ast.y └── input.c ├── CD-Mini-Project-Report.pdf ├── Code Opt ├── codeopt.py └── inp.txt ├── ICG with Quadruples ├── icg_quad.l ├── icg_quad.y ├── input.c └── run_quad.sh ├── README.md ├── Symbol_Table ├── input.c ├── symTbl.l ├── symTbl.sh └── symTbl.y └── phase2 ├── phase2.l ├── phase2.sh ├── phase2.y └── phase2_input.c /AST/ast.l: -------------------------------------------------------------------------------- 1 | %{ 2 | #include 3 | #include 4 | #include "y.tab.h" 5 | %} 6 | 7 | alpha [A-Za-z_] 8 | digit [0-9] 9 | 10 | %% 11 | [ \t\n] ; 12 | ":" {return T_colon;} 13 | "?" {return T_ques;} 14 | "while" {return WHILE;} 15 | "for" {return FOR;} 16 | "if" {return IF;} 17 | "else" {return ELSE;} 18 | "cout" {return COUT;} 19 | "endl" {return ENDL;} 20 | "break" {return BREAK;} 21 | "continue" {return CONTINUE;} 22 | "int" {return INT;} 23 | "float" {return FLOAT;} 24 | "char" {return CHAR;} 25 | "void" {return VOID;} 26 | "#include" {return INCLUDE;} 27 | "main()" {return MAINTOK;} 28 | {digit}+ {yylval = (int)yytext; return NUM;} 29 | {digit}+.{digit}+ {return FLOAT;} 30 | {alpha}({alpha}|{digit})* {yylval = yytext;return ID;} 31 | {alpha}({alpha}|{digit})*"\.h"? {return H;} 32 | \".*\" {return STRING;} 33 | "<" {return T_lt;} 34 | ">" {return T_gt;} 35 | "=" {return T_eq;} 36 | "<=" {return T_lteq;} 37 | ">=" {return T_gteq;} 38 | "==" {return T_eqeq;} 39 | "!=" {return T_neq;} 40 | "+" {return T_pl;} 41 | "-" {return T_min;} 42 | "*" {return T_mul;} 43 | "/" {return T_div;} 44 | "++" {return T_incr;} 45 | "--" {return T_decr;} 46 | "!" {return T_neq;} 47 | "||" {return T_or;} 48 | "&&" {return T_and;} 49 | 50 | 51 | . return yytext[0]; 52 | 53 | %% 54 | int yywrap (void) 55 | {return 1;} 56 | -------------------------------------------------------------------------------- /AST/ast.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | lex ast.l 4 | yacc -d ast.y 5 | gcc lex.yy.c y.tab.c -ll -ly -w 6 | ./a.out < input.c 7 | 8 | -------------------------------------------------------------------------------- /AST/ast.y: -------------------------------------------------------------------------------- 1 | %{ 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | void yyerror(char *); 8 | typedef struct Abstract_syntax_tree 9 | { 10 | char *name; 11 | struct Abstract_syntax_tree *left; 12 | struct Abstract_syntax_tree *right; 13 | }node; 14 | 15 | extern FILE *yyin; 16 | node* buildTree(char *,node *,node *); 17 | void printTree(node *); 18 | #define COUNT 10 19 | #define YYSTYPE char* 20 | int count = 0; 21 | %} 22 | 23 | %start S 24 | %token ID NUM T_lt T_gt T_lteq T_gteq T_neq T_eqeq T_and T_or T_incr T_decr T_not T_eq WHILE INT CHAR FLOAT VOID H MAINTOK INCLUDE BREAK CONTINUE IF ELSE COUT STRING FOR ENDL T_ques T_colon 25 | 26 | %token T_pl T_min T_mul T_div 27 | %left T_lt T_gt 28 | %left T_pl T_min 29 | %left T_mul T_div 30 | 31 | %% 32 | S 33 | : START {printf("Input accepted.\n");} 34 | ; 35 | 36 | START 37 | : INCLUDE T_lt H T_gt MAIN 38 | | INCLUDE "\"" H "\"" MAIN 39 | ; 40 | 41 | MAIN 42 | : VOID MAINTOK BODY 43 | | INT MAINTOK BODY 44 | ; 45 | 46 | BODY 47 | : '{' C '}' 48 | ; 49 | 50 | C 51 | : C statement ';' {printTree($2);printf("\n");printf("----------------------------------------------------------------\n");} 52 | | C LOOPS {printTree($2);printf("\n");printf("----------------------------------------------------------------\n");} 53 | | statement ';' {printTree($1);printf("\n");printf("----------------------------------------------------------------\n");} 54 | | LOOPS {printTree($1);printf("\n");printf("----------------------------------------------------------------\n");} 55 | ; 56 | 57 | LOOPS 58 | : WHILE '(' COND ')' LOOPBODY {$$=buildTree("WHILE",$3,$5);} 59 | | FOR '(' ASSIGN_EXPR ';' COND ';' statement ')' LOOPBODY 60 | | IF '(' COND ')' LOOPBODY ELSE LOOPBODY 61 | | IF '(' COND ')' LOOPBODY {$$=buildTree("IF",$3,$5);} 62 | 63 | ; 64 | 65 | 66 | LOOPBODY 67 | : '{' LOOPC '}' {$$=$2;} 68 | | ';' 69 | | statement ';' 70 | ; 71 | 72 | LOOPC 73 | : LOOPC statement ';' {$$=buildTree("SEQ",$1,$2);} 74 | | LOOPC LOOPS {$$=buildTree("SEQ",$1,$2);} 75 | | statement ';' {$$=$1;} 76 | | LOOPS {$$=$1;} 77 | ; 78 | 79 | statement 80 | : ASSIGN_EXPR {$$ = $1;} 81 | | EXP {$$=$1;} 82 | | TERNARY_EXPR {$$=$1;} 83 | | PRINT 84 | ; 85 | 86 | COND 87 | : LIT RELOP LIT {$$=buildTree($2,$1,$3);} 88 | | LIT {$$=$1;} 89 | | LIT RELOP LIT bin_boolop LIT RELOP LIT 90 | | un_boolop '(' LIT RELOP LIT ')' 91 | | un_boolop LIT RELOP LIT 92 | | LIT bin_boolop LIT 93 | | un_boolop '(' LIT ')' 94 | | un_boolop LIT 95 | ; 96 | 97 | ASSIGN_EXPR 98 | : LIT T_eq EXP {$$=buildTree("=",$1,$3);} 99 | | TYPE LIT T_eq EXP {$$=buildTree("=",$2,$4);} 100 | ; 101 | 102 | EXP 103 | : ADDSUB {$$=$1;} 104 | | EXP T_lt ADDSUB {$$=buildTree("<",$1,$3);} 105 | | EXP T_gt ADDSUB {$$=buildTree(">",$1,$3);} 106 | ; 107 | 108 | ADDSUB 109 | : TERM {$$=$1;} 110 | | EXP T_pl TERM {$$=buildTree("+",$1,$3);} 111 | | EXP T_min TERM {$$=buildTree("-",$1,$3);} 112 | ; 113 | 114 | TERM 115 | : FACTOR {$$=$1;} 116 | | TERM T_mul FACTOR {$$=buildTree("*",$1,$3);} 117 | | TERM T_div FACTOR {$$=buildTree("/",$1,$3);} 118 | ; 119 | 120 | FACTOR 121 | : LIT {$$=$1;} 122 | | '(' EXP ')' {$$ = $2;} 123 | ; 124 | 125 | TERNARY_EXPR 126 | : '(' COND ')' T_ques ternary_statement {$$=buildTree("?",$2,$5);} 127 | ; 128 | 129 | ternary_statement 130 | : statement T_colon statement {$$ = buildTree(":",$1,$3);} 131 | ; 132 | 133 | PRINT 134 | : COUT T_lt T_lt STRING 135 | | COUT T_lt T_lt STRING T_lt T_lt ENDL 136 | ; 137 | LIT 138 | : ID {$$ = buildTree((char *)yylval,0,0);} 139 | | NUM {$$ = buildTree((char *)yylval,0,0);} 140 | ; 141 | TYPE 142 | : INT 143 | | CHAR 144 | | FLOAT 145 | ; 146 | RELOP 147 | : T_lt { $$ = "<";} 148 | | T_gt { $$ = ">";} 149 | | T_lteq { $$ = "<=";} 150 | | T_gteq { $$ = ">=";} 151 | | T_neq { $$ = "!=";} 152 | | T_eqeq { $$ = "==";} 153 | ; 154 | bin_boolop 155 | : T_and 156 | | T_or 157 | ; 158 | 159 | un_arop 160 | : T_incr 161 | | T_decr 162 | ; 163 | 164 | un_boolop 165 | : T_not 166 | ; 167 | 168 | 169 | %% 170 | int main(int argc,char *argv[]) 171 | { 172 | yyin = fopen("phase2_input.c","r"); 173 | /* 174 | node *root,*temp; 175 | root = (node*)malloc(sizeof(node)); 176 | temp = (node*)malloc(sizeof(node)); 177 | */ 178 | if(!yyparse()) //yyparse-> 0 if success 179 | { 180 | printf("Parsing Complete\n"); 181 | } 182 | else 183 | { 184 | printf("Parsing failed\n"); 185 | } 186 | fclose(yyin); 187 | return 0; 188 | } 189 | 190 | 191 | node* buildTree(char *op,node *left,node *right) 192 | { 193 | node *new = (node*)malloc(sizeof(node)); 194 | char *newstr = (char *)malloc(strlen(op)+1); 195 | strcpy(newstr,op); 196 | new->left=left; 197 | new->right=right; 198 | new->name=newstr; 199 | return (new); 200 | } 201 | 202 | void printTree(node *tree) 203 | { 204 | if(tree->left || tree->right) 205 | printf("("); 206 | printf(" %s ",tree->name); 207 | if(tree->left) 208 | printTree(tree->left); 209 | if(tree->right) 210 | printTree(tree->right); 211 | if(tree->left || tree->right) 212 | printf(")"); 213 | 214 | } 215 | /* 216 | void printTree(node *tree,int space) 217 | { 218 | if(tree == NULL) 219 | return; 220 | 221 | space += COUNT; 222 | 223 | printTree(tree->right, space); 224 | 225 | printf("\n"); 226 | 227 | for(int i = COUNT ;i < space; i++) 228 | printf(" "); 229 | printf("%s\n",tree->name); 230 | 231 | printTree(tree->left, space); 232 | }*/ 233 | -------------------------------------------------------------------------------- /AST/input.c: -------------------------------------------------------------------------------- 1 | #include 2 | void main() 3 | { 4 | int a = 4 * 5 / 2; 5 | int b = a * 7; 6 | 7 | while( a>b ){ 8 | a = a+1; 9 | } 10 | 11 | int x = 20*a; 12 | 13 | if( b <= x ){ 14 | a = 10; 15 | } 16 | c = 10; 17 | a = 100; 18 | int i = 1; 19 | if( a > 0) 20 | { 21 | i = 2; 22 | } 23 | 24 | int y = a+b; 25 | 26 | (x < b) ? x = 10 : x=11; 27 | 28 | } 29 | 30 | -------------------------------------------------------------------------------- /CD-Mini-Project-Report.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SandyaSivakumar/Mini-Compiler/7350e81b7a7e1bb39f09a166579bc1665978ddb6/CD-Mini-Project-Report.pdf -------------------------------------------------------------------------------- /Code Opt/codeopt.py: -------------------------------------------------------------------------------- 1 | f = open("inp.txt","r") 2 | fout = open("out.txt","w") 3 | 4 | list_of_lines = f.readlines() 5 | dictValues = dict() 6 | constantFoldedList = [] 7 | print("Quadruple form after Constant Folding") 8 | print("-------------------------------------") 9 | for i in list_of_lines: 10 | i = i.strip("\n") 11 | op,arg1,arg2,res = i.split() 12 | if(op in ["+","-","*","/"]): 13 | if(arg1.isdigit() and arg2.isdigit()): 14 | result = eval(arg1+op+arg2) 15 | dictValues[res] = result 16 | print("=",result,"NULL",res) 17 | constantFoldedList.append(["=",result,"NULL",res]) 18 | elif(arg1.isdigit()): 19 | if(arg2 in dictValues): 20 | result = eval(arg1+op+dictValues[arg2]) 21 | dictValues[res] = result 22 | print("=",result,"NULL",res) 23 | constantFoldedList.append(["=",result,"NULL",res]) 24 | else: 25 | print(op,arg1,arg2,res) 26 | constantFoldedList.append([op,arg1,arg2,res]) 27 | elif(arg2.isdigit()): 28 | if(arg1 in dictValues): 29 | result = eval(dictValues[arg1]+op+arg2) 30 | dictValues[res] = result 31 | print("=",result,"NULL",res) 32 | constantFoldedList.append(["=",result,"NULL",res]) 33 | else: 34 | print(op,arg1,arg2,res) 35 | constantFoldedList.append([op,arg1,arg2,res]) 36 | else: 37 | flag1=0 38 | flag2=0 39 | arg1Res = arg1 40 | if(arg1 in dictValues): 41 | arg1Res = str(dictValues[arg1]) 42 | flag1 = 1 43 | arg2Res = arg2 44 | if(arg2 in dictValues): 45 | arg2Res = str(dictValues[arg2]) 46 | flag2 = 1 47 | if(flag1==1 and flag2==1): 48 | result = eval(arg1Res+op+arg2Res) 49 | dictValues[res] = result 50 | print("=",result,"NULL",res) 51 | constantFoldedList.append(["=",result,"NULL",res]) 52 | else: 53 | print(op,arg1Res,arg2Res,res) 54 | constantFoldedList.append([op,arg1Res,arg2Res,res]) 55 | 56 | elif(op=="="): 57 | if(arg1.isdigit()): 58 | dictValues[res]=arg1 59 | print("=",arg1,"NULL",res) 60 | constantFoldedList.append(["=",arg1,"NULL",res]) 61 | else: 62 | if(arg1 in dictValues): 63 | print("=",dictValues[arg1],"NULL",res) 64 | constantFoldedList.append(["=",dictValues[arg1],"NULL",res]) 65 | else: 66 | print("=",arg1,"NULL",res) 67 | constantFoldedList.append(["=",arg1,"NULL",res]) 68 | 69 | else: 70 | print(op,arg1,arg2,res) 71 | constantFoldedList.append([op,arg1,arg2,res]) 72 | 73 | print("\n") 74 | print("Constant folded expression - ") 75 | print("--------------------") 76 | for i in constantFoldedList: 77 | if(i[0]=="="): 78 | print(i[3],i[0],i[1]) 79 | elif(i[0] in ["+","-","*","/","==","<=","<",">",">="]): 80 | print(i[3],"=",i[1],i[0],i[2]) 81 | elif(i[0] in ["if","goto","label","not"]): 82 | if(i[0]=="if"): 83 | print(i[0],i[1],"goto",i[3]) 84 | if(i[0]=="goto"): 85 | print(i[0],i[3]) 86 | if(i[0]=="label"): 87 | print(i[3],":") 88 | if(i[0]=="not"): 89 | print(i[3],"=",i[0],i[1]) 90 | 91 | print("\n") 92 | print("After dead code elimination - ") 93 | print("------------------------------") 94 | for i in constantFoldedList: 95 | if(i[0]=="="): 96 | pass 97 | elif(i[0] in ["+","-","*","/","==","<=","<",">",">="]): 98 | print(i[3],"=",i[1],i[0],i[2]) 99 | elif(i[0] in ["if","goto","label","not"]): 100 | if(i[0]=="if"): 101 | print(i[0],i[1],"goto",i[3]) 102 | if(i[0]=="goto"): 103 | print(i[0],i[3]) 104 | if(i[0]=="label"): 105 | print(i[3],":") 106 | if(i[0]=="not"): 107 | print(i[3],"=",i[0],i[1]) 108 | 109 | 110 | 111 | -------------------------------------------------------------------------------- /Code Opt/inp.txt: -------------------------------------------------------------------------------- 1 | = 3 NULL a 2 | + a 5 b 3 | + a b c 4 | * c e d 5 | = 8 NULL a 6 | * a 2 f 7 | if x NULL L0 8 | + a e a 9 | -------------------------------------------------------------------------------- /ICG with Quadruples/icg_quad.l: -------------------------------------------------------------------------------- 1 | %{ 2 | #include 3 | #include 4 | int line = 0; 5 | #define YYSTYPE char * 6 | %} 7 | 8 | alpha [A-Za-z_] 9 | digit [0-9] 10 | %option yylineno 11 | %% 12 | [ \t\n] {yylval = strdup(yytext);} 13 | ":" {yylval = strdup(yytext);return T_colon;} 14 | "?" {yylval = strdup(yytext);return T_ques;} 15 | "while" {yylval = strdup(yytext);return WHILE;} 16 | "for" {yylval = strdup(yytext);return FOR;} 17 | "if" {yylval = strdup(yytext);return IF;} 18 | "else" {yylval = strdup(yytext);return ELSE;} 19 | "cout" {yylval = strdup(yytext);return COUT;} 20 | "endl" {yylval = strdup(yytext);return ENDL;} 21 | "break" {yylval = strdup(yytext);return BREAK;} 22 | "continue" {yylval = strdup(yytext);return CONTINUE;} 23 | "int" {yylval = strdup(yytext);return INT;} 24 | "float" {yylval = strdup(yytext);return FLOAT;} 25 | "char" {yylval = strdup(yytext);return CHAR;} 26 | "void" {yylval = strdup(yytext);return VOID;} 27 | "#include" {yylval = strdup(yytext);return INCLUDE;} 28 | "main()" {yylval = strdup(yytext);return MAINTOK;} 29 | {digit}+ {yylval = strdup(yytext);return NUM;} 30 | {digit}+.{digit}+ {yylval = strdup(yytext);return FLOAT;} 31 | {alpha}({alpha}|{digit})* {yylval = strdup(yytext);return ID;} 32 | {alpha}({alpha}|{digit})*"\.h"? {yylval = strdup(yytext);return H;} 33 | \".*\" {yylval = strdup(yytext);return STRING;} 34 | "<" {yylval = strdup(yytext);return T_lt;} 35 | ">" {yylval = strdup(yytext);return T_gt;} 36 | "=" {yylval = strdup(yytext);return T_eq;} 37 | "<=" {yylval = strdup(yytext);return T_lteq;} 38 | ">=" {yylval = strdup(yytext);return T_gteq;} 39 | "==" {yylval = strdup(yytext);return T_eqeq;} 40 | "!=" {yylval = strdup(yytext);return T_neq;} 41 | "+" {yylval = strdup(yytext);return T_pl;} 42 | "-" {yylval = strdup(yytext);return T_min;} 43 | "*" {yylval = strdup(yytext);return T_mul;} 44 | "/" {yylval = strdup(yytext);return T_div;} 45 | "++" {yylval = strdup(yytext);return T_incr;} 46 | "--" {yylval = strdup(yytext);return T_decr;} 47 | "!" {yylval = strdup(yytext);return T_neq;} 48 | "||" {yylval = strdup(yytext);return T_or;} 49 | "&&" {yylval = strdup(yytext);return T_and;} 50 | 51 | . return yytext[0]; 52 | 53 | %% 54 | -------------------------------------------------------------------------------- /ICG with Quadruples/icg_quad.y: -------------------------------------------------------------------------------- 1 | %{ 2 | #include 3 | #include 4 | #include 5 | #include 6 | int top=-1; 7 | void yyerror(char *); 8 | extern FILE *yyin; 9 | #define YYSTYPE char* 10 | typedef struct quadruples 11 | { 12 | char *op; 13 | char *arg1; 14 | char *arg2; 15 | char *res; 16 | }quad; 17 | int quadlen = 0; 18 | quad q[100]; 19 | %} 20 | 21 | %start S 22 | %token ID NUM T_lt T_gt T_lteq T_gteq T_neq T_noteq T_eqeq T_and T_or T_incr T_decr T_not T_eq WHILE INT CHAR FLOAT VOID H MAINTOK INCLUDE BREAK CONTINUE IF ELSE COUT STRING FOR ENDL T_ques T_colon 23 | 24 | %token T_pl T_min T_mul T_div 25 | %left T_lt T_gt 26 | %left T_pl T_min 27 | %left T_mul T_div 28 | 29 | %% 30 | S 31 | : START {printf("Input accepted.\n");} 32 | ; 33 | 34 | START 35 | : INCLUDE T_lt H T_gt MAIN 36 | | INCLUDE "\"" H "\"" MAIN 37 | ; 38 | 39 | MAIN 40 | : VOID MAINTOK BODY 41 | | INT MAINTOK BODY 42 | ; 43 | 44 | BODY 45 | : '{' C '}' 46 | ; 47 | 48 | C 49 | : C statement ';' 50 | | C LOOPS 51 | | statement ';' 52 | | LOOPS 53 | ; 54 | 55 | LOOPS 56 | : WHILE {while1();} '(' COND ')'{while2();} LOOPBODY{while3();} 57 | | FOR '(' ASSIGN_EXPR{for1();} ';' COND{for2();} ';' statement{for3();} ')' LOOPBODY{for4();} 58 | | IF '(' COND ')' {ifelse1();} LOOPBODY{ifelse2();} ELSE LOOPBODY{ifelse3();} 59 | | IF '(' COND ')' {if1();} LOOPBODY{if3();}; 60 | 61 | TERNARY_EXPR 62 | : '(' TERNARY_COND ')' {ternary1();} T_ques statement{ternary2();} T_colon statement{ternary3();} 63 | ; 64 | 65 | LOOPBODY 66 | : '{' LOOPC '}' 67 | | ';' 68 | | statement ';' 69 | ; 70 | 71 | LOOPC 72 | : LOOPC statement ';' 73 | | LOOPC LOOPS 74 | | statement ';' 75 | | LOOPS 76 | ; 77 | 78 | statement 79 | : ASSIGN_EXPR 80 | | EXP 81 | | TERNARY_EXPR 82 | | PRINT 83 | ; 84 | 85 | TERNARY_COND : T_B {codegen_assigna();} 86 | | T_B T_and{codegen_assigna();} TERNARY_COND 87 | | T_B {codegen_assigna();}T_or TERNARY_COND 88 | | T_not T_B{codegen_assigna();} 89 | ; 90 | 91 | T_B : T_V T_eq{push();}T_eq{push();} LIT 92 | | T_V T_gt{push();}T_F 93 | | T_V T_lt{push();}T_F 94 | | T_V T_not{push();} T_eq{push();} LIT 95 | |'(' T_B ')' 96 | | T_V {pushab();} 97 | ; 98 | 99 | T_F :T_eq{push();}LIT 100 | |LIT{pusha();} 101 | ; 102 | 103 | COND : B {codegen_assigna();} 104 | | B T_and{codegen_assigna();} COND 105 | | B {codegen_assigna();}T_or COND 106 | | T_not B{codegen_assigna();} 107 | ; 108 | 109 | B : V T_eq{push();}T_eq{push();} LIT 110 | | V T_gt{push();}F 111 | | V T_lt{push();}F 112 | | V T_not{push();} T_eq{push();} LIT 113 | |'(' B ')' 114 | | V {pushab();} 115 | ; 116 | 117 | F :T_eq{push();}LIT 118 | |LIT{pusha();} 119 | ; 120 | 121 | V : ID{push();} 122 | 123 | T_V : ID{pushx();} 124 | 125 | ASSIGN_EXPR 126 | : LIT {push();} T_eq {push();} EXP {codegen_assign();} 127 | | TYPE LIT {push();} T_eq {push();} EXP {codegen_assign();} 128 | ; 129 | 130 | EXP 131 | : ADDSUB 132 | | EXP T_lt {push();} ADDSUB {codegen();} 133 | | EXP T_gt {push();} ADDSUB {codegen();} 134 | ; 135 | 136 | ADDSUB 137 | : TERM 138 | | EXP T_pl {push();} TERM {codegen();} 139 | | EXP T_min {push();} TERM {codegen();} 140 | ; 141 | 142 | TERM 143 | : FACTOR 144 | | TERM T_mul {push();} FACTOR {codegen();} 145 | | TERM T_div {push();} FACTOR {codegen();} 146 | ; 147 | 148 | FACTOR 149 | : LIT 150 | | '(' EXP ')' 151 | ; 152 | 153 | PRINT 154 | : COUT T_lt T_lt STRING 155 | | COUT T_lt T_lt STRING T_lt T_lt ENDL 156 | ; 157 | LIT 158 | : ID {push();} 159 | | NUM {push();} 160 | ; 161 | TYPE 162 | : INT 163 | | CHAR 164 | | FLOAT 165 | ; 166 | RELOP 167 | : T_lt 168 | | T_gt 169 | | T_lteq 170 | | T_gteq 171 | | T_neq 172 | | T_eqeq 173 | ; 174 | bin_boolop 175 | : T_and 176 | | T_or 177 | ; 178 | 179 | un_arop 180 | : T_incr 181 | | T_decr 182 | ; 183 | 184 | un_boolop 185 | : T_not 186 | ; 187 | 188 | 189 | %% 190 | 191 | #include "lex.yy.c" 192 | #include 193 | char st[100][100]; 194 | 195 | char i_[2]="0"; 196 | int temp_i=0; 197 | char tmp_i[3]; 198 | char temp[2]="t"; 199 | int label[20]; 200 | int lnum=0; 201 | int ltop=0; 202 | int abcd=0; 203 | int l_while=0; 204 | int l_for=0; 205 | int flag_set = 1; 206 | 207 | int main(int argc,char *argv[]) 208 | { 209 | 210 | yyin = fopen("input.c","r"); 211 | if(!yyparse()) //yyparse-> 0 if success 212 | { 213 | printf("Parsing Complete\n"); 214 | printf("---------------------Quadruples-------------------------\n\n"); 215 | printf("Operator \t Arg1 \t\t Arg2 \t\t Result \n"); 216 | int i; 217 | for(i=0;i 2 | void main() 3 | { 4 | int b = a*b; 5 | while( a > b ){ 6 | a = a+1; 7 | } 8 | if( b < = c ){ 9 | a = 10; 10 | } 11 | else{ 12 | a = 20; 13 | } 14 | a = 100; 15 | for(i=0;i<10;i = i+1){ 16 | a = a+1; 17 | } 18 | (x < b) ? x = 10 : x=11; 19 | 20 | } 21 | -------------------------------------------------------------------------------- /ICG with Quadruples/run_quad.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | lex icg_quad.l 4 | yacc icg_quad.y 5 | gcc y.tab.c -ll -ly -w 6 | ./a.out 7 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Mini-Compiler 2 | C++ Mini Compiler using tools Lex and Yacc 3 | #### Constructs implemented: 4 | 1. If-else 5 | 2. Ternary 6 | 3. While-loop 7 | 4. For-loop 8 | -------------------------------------------------------------------------------- /Symbol_Table/input.c: -------------------------------------------------------------------------------- 1 | #include 2 | void main() 3 | { 4 | int a = 4 * 5 / 2; 5 | int b = a * 7; 6 | 7 | int c = a / b + 8 / 4; 8 | int d = a + b * c; 9 | b = 100 * 100 - d + c; 10 | 11 | } 12 | 13 | -------------------------------------------------------------------------------- /Symbol_Table/symTbl.l: -------------------------------------------------------------------------------- 1 | %{ 2 | #include 3 | #include 4 | #include "y.tab.h" 5 | int line = 0; 6 | #define YYSTYPE char * 7 | #define YY_USER_ACTION yylloc.first_line = yylloc.last_line = yylineno; 8 | %} 9 | 10 | alpha [A-Za-z_] 11 | digit [0-9] 12 | %option yylineno 13 | %% 14 | [ \t\n] {yylval = strdup(yytext);} 15 | ":" {yylval = strdup(yytext);return T_colon;} 16 | "?" {yylval = strdup(yytext);return T_ques;} 17 | "while" {yylval = strdup(yytext);return WHILE;} 18 | "for" {yylval = strdup(yytext);return FOR;} 19 | "if" {yylval = strdup(yytext);return IF;} 20 | "else" {yylval = strdup(yytext);return ELSE;} 21 | "cout" {yylval = strdup(yytext);return COUT;} 22 | "endl" {yylval = strdup(yytext);return ENDL;} 23 | "break" {yylval = strdup(yytext);return BREAK;} 24 | "continue" {yylval = strdup(yytext);return CONTINUE;} 25 | "int" {yylval = strdup(yytext);return INT;} 26 | "float" {yylval = strdup(yytext);return FLOAT;} 27 | "char" {yylval = strdup(yytext);return CHAR;} 28 | "void" {yylval = strdup(yytext);return VOID;} 29 | "#include" {yylval = strdup(yytext);return INCLUDE;} 30 | "main()" {yylval = strdup(yytext);return MAINTOK;} 31 | {digit}+ {yylval = strdup(yytext);return NUM;} 32 | {digit}+.{digit}+ {yylval = strdup(yytext);return FLOAT;} 33 | {alpha}({alpha}|{digit})* {yylval = strdup(yytext);return ID;} 34 | {alpha}({alpha}|{digit})*"\.h"? {yylval = strdup(yytext);return H;} 35 | \".*\" {yylval = strdup(yytext);return STRING;} 36 | "<" {yylval = strdup(yytext);return T_lt;} 37 | ">" {yylval = strdup(yytext);return T_gt;} 38 | "=" {yylval = strdup(yytext);return T_eq;} 39 | "<=" {yylval = strdup(yytext);return T_lteq;} 40 | ">=" {yylval = strdup(yytext);return T_gteq;} 41 | "==" {yylval = strdup(yytext);return T_eqeq;} 42 | "!=" {yylval = strdup(yytext);return T_neq;} 43 | "+" {yylval = strdup(yytext);return T_pl;} 44 | "-" {yylval = strdup(yytext);return T_min;} 45 | "*" {yylval = strdup(yytext);return T_mul;} 46 | "/" {yylval = strdup(yytext);return T_div;} 47 | "++" {yylval = strdup(yytext);return T_incr;} 48 | "--" {yylval = strdup(yytext);return T_decr;} 49 | "!" {yylval = strdup(yytext);return T_neq;} 50 | "||" {yylval = strdup(yytext);return T_or;} 51 | "&&" {yylval = strdup(yytext);return T_and;} 52 | 53 | 54 | . return yytext[0]; 55 | 56 | %% 57 | -------------------------------------------------------------------------------- /Symbol_Table/symTbl.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | lex symTbl.l 4 | yacc -d symTbl.y 5 | gcc lex.yy.c y.tab.c -ll -ly -w 6 | ./a.out < input.c 7 | -------------------------------------------------------------------------------- /Symbol_Table/symTbl.y: -------------------------------------------------------------------------------- 1 | %{ 2 | #include 3 | #include 4 | #include 5 | #define YYSTYPE char * 6 | int yylex(); 7 | void yyerror(char *); 8 | void lookup(char *,int,char,char*,char* ); 9 | //void insert(char *,int,char,char*,char* ); 10 | void update(char *,int,char *); 11 | void search_id(char *,int ); 12 | extern FILE *yyin; 13 | extern int yylineno; 14 | extern char *yytext; 15 | typedef struct symbol_table 16 | { 17 | int line; 18 | char name[31]; 19 | char type; 20 | char *value; 21 | char *datatype; 22 | }ST; 23 | int struct_index = 0; 24 | ST st[10000]; 25 | char x[10]; 26 | %} 27 | %start S 28 | %token ID NUM T_lt T_gt T_lteq T_gteq T_neq T_eqeq T_and T_or T_incr T_decr T_not T_eq WHILE INT CHAR FLOAT VOID H MAINTOK INCLUDE BREAK CONTINUE IF ELSE COUT STRING FOR ENDL T_ques T_colon 29 | 30 | %token T_pl T_min T_mul T_div 31 | %left T_lt T_gt 32 | %left T_pl T_min 33 | %left T_mul T_div 34 | 35 | %% 36 | S 37 | : START {printf("\n\n\nINPUT ACCEPTED.\n");} 38 | ; 39 | 40 | START 41 | : INCLUDE T_lt H T_gt MAIN {lookup($1,@1.last_line,'K',NULL,NULL);} 42 | | INCLUDE "\"" H "\"" MAIN {lookup($1,@1.last_line,'K',NULL,NULL);} 43 | ; 44 | 45 | MAIN 46 | : VOID MAINTOK BODY {lookup($1,@1.last_line,'K',NULL,NULL);lookup($2,@1.last_line,'K',NULL,NULL);} 47 | | INT MAINTOK BODY {lookup($1,@1.last_line,'K',NULL,NULL);lookup($2,@1.last_line,'K',NULL,NULL);} 48 | ; 49 | 50 | BODY 51 | : '{' C '}' 52 | ; 53 | 54 | C 55 | : C statement ';' 56 | | C LOOPS 57 | | statement ';' 58 | | LOOPS 59 | ; 60 | 61 | LOOPS 62 | : WHILE '(' COND ')' LOOPBODY {lookup($1,@1.last_line,'K',NULL,NULL);} 63 | | FOR '(' ASSIGN_EXPR ';' COND ';' statement ')' LOOPBODY {lookup($1,@1.last_line,'K',NULL,NULL);} 64 | | IF '(' COND ')' LOOPBODY {lookup($1,@1.last_line,'K',NULL,NULL);} 65 | | IF '(' COND ')' LOOPBODY ELSE LOOPBODY {lookup($1,@1.last_line,'K',NULL,NULL);lookup($6,@1.last_line,'K',NULL,NULL);} 66 | ; 67 | 68 | 69 | LOOPBODY 70 | : '{' LOOPC '}' 71 | | ';' 72 | | statement ';' 73 | ; 74 | 75 | LOOPC 76 | : LOOPC statement ';' 77 | | LOOPC LOOPS 78 | | statement ';' 79 | | LOOPS 80 | ; 81 | 82 | statement 83 | : ASSIGN_EXPR 84 | | EXP 85 | | TERNARY_EXPR 86 | | PRINT 87 | ; 88 | 89 | COND 90 | : LIT RELOP LIT 91 | | LIT 92 | | LIT RELOP LIT bin_boolop LIT RELOP LIT 93 | | un_boolop '(' LIT RELOP LIT ')' 94 | | un_boolop LIT RELOP LIT 95 | | LIT bin_boolop LIT 96 | | un_boolop '(' LIT ')' 97 | | un_boolop LIT 98 | ; 99 | 100 | ASSIGN_EXPR 101 | : ID T_eq EXP {search_id($1,@1.last_line);lookup($2,@2.last_line,'O',NULL,NULL);update($1,@1.last_line,$3);} 102 | | TYPE ID T_eq EXP {lookup($2,@1.last_line,'I',NULL,$1);lookup($3,@3.last_line,'O',NULL,NULL);update($2,@1.last_line,$4);} 103 | ; 104 | 105 | EXP 106 | : ADDSUB 107 | | EXP T_lt ADDSUB {lookup($2,@1.last_line,'O',NULL,NULL);sprintf($$,"%d",atoi($1)atoi($3));} //printf("%s\n",$$);} 109 | ; 110 | 111 | ADDSUB 112 | : TERM 113 | | EXP T_pl TERM {lookup($2,@1.last_line,'O',NULL,NULL);sprintf($$,"%d",atoi($1)+atoi($3));} //printf("%s\n",$$);} 114 | | EXP T_min TERM {lookup($2,@1.last_line,'O',NULL,NULL);sprintf($$,"%d",atoi($1)-atoi($3));} //printf("%s\n",$$);} 115 | ; 116 | 117 | TERM 118 | : FACTOR 119 | | TERM T_mul FACTOR {lookup($2,@1.last_line,'O',NULL,NULL);sprintf($$,"%d",atoi($1)*atoi($3));} //printf("%s\n",$$);} 120 | | TERM T_div FACTOR {lookup($2,@1.last_line,'O',NULL,NULL);sprintf($$,"%d",atoi($1)/atoi($3));} //printf("%s\n",$$);} 121 | ; 122 | 123 | FACTOR 124 | : LIT 125 | | '(' EXP ')' 126 | ; 127 | 128 | TERNARY_EXPR 129 | : '(' COND ')' T_ques ternary_statement {lookup($4,@4.last_line,'O',NULL,NULL);} 130 | ; 131 | 132 | ternary_statement 133 | : statement T_colon statement {lookup($2,@2.last_line,'O',NULL,NULL);} 134 | ; 135 | 136 | PRINT 137 | : COUT T_lt T_lt STRING {lookup($1,@1.last_line,'K',NULL,NULL);lookup($4,@1.last_line,'C',NULL,NULL);} 138 | | COUT T_lt T_lt STRING T_lt T_lt ENDL {lookup($1,@1.last_line,'K',NULL,NULL);lookup($4,@1.last_line,'C',NULL,NULL);lookup($7,@1.last_line,'K',NULL,NULL);} 139 | ; 140 | LIT 141 | : ID {search_id($1,@1.last_line);sprintf($$,"%d",atoi(get_val($1)));} 142 | | NUM {lookup($1,@1.last_line,'C',NULL,NULL);} 143 | ; 144 | TYPE 145 | : INT {lookup($1,@1.last_line,'K',NULL,NULL);} 146 | | CHAR {lookup($1,@1.last_line,'K',NULL,NULL);} 147 | | FLOAT {lookup($1,@1.last_line,'K',NULL,NULL);} 148 | ; 149 | RELOP 150 | : T_lt {lookup($1,@1.last_line,'O',NULL,NULL);} 151 | | T_gt {lookup($1,@1.last_line,'O',NULL,NULL);} 152 | | T_lteq {lookup($1,@1.last_line,'O',NULL,NULL);} 153 | | T_gteq {lookup($1,@1.last_line,'O',NULL,NULL);} 154 | | T_neq {lookup($1,@1.last_line,'O',NULL,NULL);} 155 | | T_eqeq {lookup($1,@1.last_line,'O',NULL,NULL);} 156 | ; 157 | 158 | bin_boolop 159 | : T_and {lookup($1,@1.last_line,'O',NULL,NULL);} 160 | | T_or {lookup($1,@1.last_line,'O',NULL,NULL);} 161 | ; 162 | 163 | un_arop 164 | : T_incr {lookup($1,@1.last_line,'O',NULL,NULL);} 165 | | T_decr {lookup($1,@1.last_line,'O',NULL,NULL);} 166 | ; 167 | 168 | un_boolop 169 | : T_not {lookup($1,@1.last_line,'O',NULL,NULL);} 170 | ; 171 | 172 | 173 | %% 174 | 175 | int main(int argc,char *argv[]) 176 | { 177 | yyin = fopen("phase2_input.c","r"); 178 | if(!yyparse()) //yyparse-> 0 if success 179 | { 180 | printf("Parsing Complete\n"); 181 | printf("Number of entries in the symbol table = %d\n\n",struct_index); 182 | printf("-----------------------------------Symbol Table-----------------------------------\n\n"); 183 | printf("S.No\t Token \t Line Number \t Category \t DataType \t Value \n"); 184 | for(int i = 0;i < struct_index;i++) 185 | { 186 | char *ty; 187 | 188 | if(st[i].type=='K') 189 | ty="keyword"; 190 | else if(st[i].type=='I') 191 | { 192 | ty="identifier"; 193 | printf("%-4d\t %-7s\t %-10d \t %-9s\t %-7s\t %-5s\n",i+1,st[i].name,st[i].line,ty,st[i].datatype,st[i].value); 194 | } 195 | else if(st[i].type=='C') 196 | ty="constant"; 197 | else 198 | ty="operator"; 199 | if(st[i].type!='I') 200 | printf("%-4d\t %-7s\t %-10d\t %-9s\t NULL\t\t %-5s\n",i+1,st[i].name,st[i].line,ty,st[i].value); 201 | } 202 | } 203 | else 204 | { 205 | printf("Parsing failed\n"); 206 | } 207 | fclose(yyin); 208 | return 0; 209 | } 210 | 211 | 212 | void yyerror(char *s) 213 | { 214 | printf("Error :%s at %d \n",yytext,yylineno); 215 | } 216 | void lookup(char *token,int line,char type,char *value,char *datatype) 217 | { 218 | //printf("Token %s line number %d\n",token,line); 219 | int flag = 0; 220 | for(int i = 0;i < struct_index;i++) 221 | { 222 | if(!strcmp(st[i].name,token)) 223 | { 224 | flag = 1; 225 | if(st[i].line != line) 226 | { 227 | st[i].line = line; 228 | } 229 | } 230 | } 231 | 232 | //Insert 233 | if(flag == 0) 234 | { 235 | strcpy(st[struct_index].name,token); 236 | st[struct_index].type=type; 237 | if(value==NULL) 238 | st[struct_index].value=NULL; 239 | else 240 | strcpy(st[struct_index].value,value); 241 | 242 | if(datatype==NULL) 243 | st[struct_index].datatype=NULL; 244 | else 245 | st[struct_index].datatype=datatype; 246 | 247 | st[struct_index].line = line; 248 | struct_index++; 249 | } 250 | } 251 | /* 252 | void insert(char *token,int line,char type, char* value, char *datatype) 253 | { 254 | printf("start"); 255 | strcpy(st[struct_index].name,token); 256 | st[struct_index].type=type; 257 | strcpy(st[struct_index].value,value); 258 | strcpy(st[struct_index].datatype,datatype); 259 | st[struct_index].line = line; 260 | struct_index++; 261 | printf("end"); 262 | } 263 | */ 264 | void search_id(char *token,int lineno) 265 | { 266 | int flag = 0; 267 | for(int i = 0;i < struct_index;i++) 268 | { 269 | if(!strcmp(st[i].name,token)) 270 | { 271 | flag = 1; 272 | return; 273 | } 274 | } 275 | if(flag == 0) 276 | { 277 | printf("Error at line %d : %s is not defined\n",lineno,token); 278 | exit(0); 279 | } 280 | } 281 | 282 | void update(char *token,int lineno,char *value) 283 | { 284 | int flag = 0; 285 | 286 | for(int i = 0;i < struct_index;i++) 287 | { 288 | if(!strcmp(st[i].name,token)) 289 | { 290 | flag = 1; 291 | st[i].value = (char*)malloc(sizeof(char)*strlen(value)); 292 | //sprintf(st[i].value,"%s",value); 293 | strcpy(st[i].value,value); 294 | st[i].line = lineno; 295 | return; 296 | } 297 | } 298 | if(flag == 0) 299 | { 300 | printf("Error at line %d : %s is not defined\n",lineno,token); 301 | exit(0); 302 | } 303 | } 304 | 305 | int get_val(char *token) 306 | { 307 | int flag = 0; 308 | for(int i = 0;i < struct_index;i++) 309 | { 310 | if(!strcmp(st[i].name,token)) 311 | { 312 | flag = 1; 313 | return st[i].value; 314 | } 315 | } 316 | if(flag == 0) 317 | { 318 | printf("Error at line : %s is not defined\n",token); 319 | exit(0); 320 | } 321 | } 322 | -------------------------------------------------------------------------------- /phase2/phase2.l: -------------------------------------------------------------------------------- 1 | alpha [A-Za-z_] 2 | digit [0-9] 3 | %% 4 | [ \t\n] 5 | "while" return WHILE; 6 | "for" return FOR; 7 | "if" return IF; 8 | "else" return ELSE; 9 | "cout" return COUT; 10 | "endl" return ENDL; 11 | "break" return BREAK; 12 | "continue" return CONTINUE; 13 | "int" return INT; 14 | "float" return FLOAT; 15 | "char" return CHAR; 16 | "void" return VOID; 17 | "#include" return INCLUDE; 18 | "main()" return MAINTOK; 19 | {digit}+ return NUM; 20 | {alpha}({alpha}|{digit})* return ID; 21 | {alpha}({alpha}|{digit})*"\.h"? return H; 22 | \".*\" return STRING; 23 | "<" return T_lt; 24 | ">" return T_gt; 25 | "=" return T_eq; 26 | "<=" return T_lteq; 27 | ">=" return T_gteq; 28 | "==" return T_eqeq; 29 | "!=" return T_neq; 30 | "+" return T_pl; 31 | "-" return T_min; 32 | "*" return T_mul; 33 | "/" return T_div; 34 | "++" return T_incr; 35 | "--" return T_decr; 36 | "!" return T_neq; 37 | "||" return T_or; 38 | "&&" return T_and; 39 | 40 | . return yytext[0]; 41 | %% 42 | -------------------------------------------------------------------------------- /phase2/phase2.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | lex phase2.l 4 | yacc phase2.y 5 | gcc y.tab.c -ll -ly -w 6 | ./a.out < phase2_input.c 7 | -------------------------------------------------------------------------------- /phase2/phase2.y: -------------------------------------------------------------------------------- 1 | %{ 2 | #include 3 | #include 4 | 5 | %} 6 | %token ID NUM T_lt T_gt T_lteq T_gteq T_neq T_eqeq T_pl T_min T_mul T_div T_and T_or T_incr T_decr T_not T_eq WHILE INT CHAR FLOAT VOID H MAINTOK INCLUDE BREAK CONTINUE IF ELSE COUT STRING FOR ENDL 7 | 8 | %% 9 | S 10 | : START {printf("Input accepted.\n");exit(0);} 11 | ; 12 | 13 | START 14 | : INCLUDE T_lt H T_gt MAIN 15 | | INCLUDE "\"" H "\"" MAIN 16 | ; 17 | 18 | MAIN 19 | : VOID MAINTOK BODY 20 | | INT MAINTOK BODY 21 | ; 22 | 23 | BODY 24 | : '{' C '}' 25 | ; 26 | 27 | C 28 | : C statement ';' 29 | | C LOOPS 30 | | statement ';' 31 | | LOOPS 32 | ; 33 | 34 | LOOPS 35 | : WHILE '(' COND ')' LOOPBODY 36 | | FOR '(' ASSIGN_EXPR ';' COND ';' statement ')' LOOPBODY 37 | | IF '(' COND ')' LOOPBODY 38 | | IF '(' COND ')' LOOPBODY ELSE LOOPBODY 39 | ; 40 | 41 | LOOPBODY 42 | : '{' C '}' 43 | | ';' 44 | | statement ';' 45 | ; 46 | 47 | statement 48 | : ASSIGN_EXPR 49 | | ARITH_EXPR 50 | | TERNARY_EXPR 51 | | PRINT 52 | ; 53 | 54 | COND 55 | : LIT RELOP LIT 56 | | LIT 57 | | LIT RELOP LIT bin_boolop LIT RELOP LIT 58 | | un_boolop '(' LIT RELOP LIT ')' 59 | | un_boolop LIT RELOP LIT 60 | | LIT bin_boolop LIT 61 | | un_boolop '(' LIT ')' 62 | | un_boolop LIT 63 | ; 64 | 65 | ASSIGN_EXPR 66 | : ID T_eq ARITH_EXPR 67 | | TYPE ID T_eq ARITH_EXPR 68 | ; 69 | 70 | ARITH_EXPR 71 | : LIT 72 | | LIT bin_arop ARITH_EXPR 73 | | LIT bin_boolop ARITH_EXPR 74 | | LIT un_arop 75 | | un_arop ARITH_EXPR 76 | | un_boolop ARITH_EXPR 77 | ; 78 | 79 | TERNARY_EXPR 80 | : '(' COND ')' '?' statement ':' statement 81 | ; 82 | 83 | PRINT 84 | : COUT T_lt T_lt STRING 85 | | COUT T_lt T_lt STRING T_lt T_lt ENDL 86 | ; 87 | LIT 88 | : ID 89 | | NUM 90 | ; 91 | TYPE 92 | : INT 93 | | CHAR 94 | | FLOAT 95 | ; 96 | RELOP 97 | : T_lt 98 | | T_gt 99 | | T_lteq 100 | | T_gteq 101 | | T_neq 102 | | T_eqeq 103 | ; 104 | 105 | bin_arop 106 | : T_pl 107 | | T_min 108 | | T_mul 109 | | T_div 110 | ; 111 | 112 | bin_boolop 113 | : T_and 114 | | T_or 115 | ; 116 | 117 | un_arop 118 | : T_incr 119 | | T_decr 120 | ; 121 | 122 | un_boolop 123 | : T_not 124 | ; 125 | 126 | 127 | %% 128 | 129 | #include "lex.yy.c" 130 | 131 | int yyerror(){ 132 | printf("ERROR\n"); 133 | } 134 | 135 | int main(int argc, char* args[]) 136 | { 137 | yyin=fopen(args[1],"r"); 138 | //yyout=fopen("output.c","w"); 139 | yyparse(); 140 | return 0; 141 | } 142 | -------------------------------------------------------------------------------- /phase2/phase2_input.c: -------------------------------------------------------------------------------- 1 | #include 2 | void main() 3 | { 4 | int s=1+2+3+4; 5 | while(x>10){ 6 | while(x>10){ 7 | x = 0; 8 | cout<<"ejnfoejnfo"<0){ 10 | y=1; 11 | } 12 | else{ 13 | y=2; 14 | } 15 | } 16 | for(i=0;i0){ 22 | y=1; 23 | if(x>0){ 24 | y=1; 25 | } 26 | else{ 27 | y=2; 28 | } 29 | } 30 | else{ 31 | y=2; 32 | if(x>0){ 33 | y=1; 34 | } 35 | else{ 36 | y=2+3; 37 | } 38 | } 39 | if(x>0){ 40 | y=1; 41 | } 42 | cout<<"ejnfoejnfo" ; 43 | for(i=0;i= 2) ? y=0 : y=1; 47 | } 48 | --------------------------------------------------------------------------------