(1)Design a Lexical analyzer to recognize a few pattern in C.

The lexical
analyzer should ignore redundant spaces, tabs and new lines, comments
etc.

program :

LEX PART :
c_lex.l:

%{
#include "y.tab.h"
%}

%%
[ \t\n]+ /* Ignore spaces, tabs, and new lines */
"//"(.)* /* Ignore single-line comments */
"/*"([^*]|"*"+[^*/])*"*"+"/" /* Ignore multi-line comments */

"int" { return INT; }

"float" { return FLOAT; }
"char" { return CHAR; }
"if" { return IF; }
"else" { return ELSE; }
"while" { return WHILE; }
"for" { return FOR; }

[0-9]+ { yylval.num = atoi(yytext); return NUM; }

[a-zA-Z_][a-zA-Z0-9_]* { yylval.str = strdup(yytext); return ID; }

"+" | "-" | "*" | "/" | "=" | "==" | "!=" | ">" | "<" | ">=" | "<=" {
return yytext[0]; }
"(" | ")" | "{" | "}" | ";" { return yytext[0]; }

. { /* Ignore unrecognized characters */ }

%%

int yywrap() {
return 1;
}

YACC PART :
c_parser.y:

%{
#include <stdio.h>
int yylex();
void yyerror(const char *s);
%}

%token INT FLOAT CHAR IF ELSE WHILE FOR NUM ID

%%
program: statement
| program statement
;

statement: type ID ';'

| IF '(' expression ')' '{' program '}'
| IF '(' expression ')' '{' program '}' ELSE '{' program '}'
| WHILE '(' expression ')' '{' program '}'
| FOR '(' expression ';' expression ';' expression ')' '{'
program '}'
;

type: INT
| FLOAT
| CHAR
;

expression: expression '+' expression

| expression '-' expression
| expression '*' expression
| expression '/' expression
| expression '>' expression
| expression '<' expression
| expression ">=" expression
| expression "<=" expression
| expression "==" expression
| expression "!=" expression
| '(' expression ')'
| ID
| NUM
;

%%

void yyerror(const char *s) {

fprintf(stderr, "Error: %s\n", s);
}

int main() {
yyparse();
return 0;
}

Output :

INT ID ';' INT ID '=' NUM ';'

FLOAT ID '=' NUM ';'
IF '(' ID '>' NUM ')' '{' ID '=' ID '+' NUM ';' '}' ELSE '{' ID '=' ID '-
' NUM ';'
WHILE '(' ID '>' NUM ')' '{' ID '=' ID '-' NUM ';' '}'

(2)Implement the lexical analyzer using JLex, flex or other lexical

analyzer generating tools.

Program :

LEX PART :
C_Lexer.jflex:

import java.io.*;

%class CLexer

%type int
%public
%cup

%{
import java_cup.runtime.Symbol;
%}

%unicode
%line
%column

%{
private Yylex lexer;
private String filename;

public CLexer(Reader r) {
lexer = new Yylex(r, this);
}

public void setFilename(String filename) {

this.filename = filename;
}

public String getFilename() {

return filename;
}

public Symbol nextToken() throws IOException {

return lexer.yylex();
}

public int yylex() {

throw new Error("Unimplemented method yylex() in generated lexer");
}
 public void yyerror(String s) {
System.err.println(s);
}
%}

WhiteSpace = [ \t\n\r\f]

LineTerminator = \r|\n|\r\n

Comments = "//" [^\r\n]* | "/*" .*? "*/"

%%

YACC PART :
C_Parser.cup :

import java_cup.runtime.*;
import java.io.*;

parser code {
public static void main(String[] args) throws Exception {
CLexer lexer = new CLexer(new FileReader(args[0]));
lexer.setFilename(args[0]);
parser p = new parser(lexer);
Symbol result = p.parse();
System.out.println("Parsing completed without errors.");
}
}

precedence left '+' '-'

precedence left '*' '/'

/* Terminals (tokens returned by the lexer) */

terminal INT, FLOAT, CHAR, IF, ELSE, WHILE, FOR, NUM, ID;

/* Non-terminals */
non terminal program, statement, type, expression;

/* Grammar rules */
program ::= statement
| program statement;

statement ::= type ID ';'

| IF '(' expression ')' '{' program '}'
| IF '(' expression ')' '{' program '}' ELSE '{' program '}'
| WHILE '(' expression ')' '{' program '}'
| FOR '(' expression ';' expression ';' expression ')' '{'
program '}';

type ::= INT

| FLOAT
 | CHAR;

expression ::= expression '+' expression

| expression '-' expression
| expression '*' expression
| expression '/' expression
| expression '>' expression
| expression '<' expression
| expression ">=" expression
| expression "<=" expression
| expression "==" expression
| expression "!=" expression
| '(' expression ')'
| ID
| NUM;

/* Terminals definition */
terminal INT: "int";
terminal FLOAT: "float";
terminal CHAR: "char";
terminal IF: "if";
terminal ELSE: "else";
terminal WHILE: "while";
terminal FOR: "for";
terminal NUM: < "[0-9]+", Integer.parseInt(yytext()) >;
terminal ID: < "[a-zA-Z_][a-zA-Z0-9_]*" >;

/* Error handling */
non terminal error;

Output :

(INT,int) (ID,main) '(' ')' '{'

(INT,int) (ID,x) '=' (NUM,5) ';'
(FLOAT,float) (ID,y) '=' (NUM,3.14) ';'
(IF,if) '(' (ID,x) '>' (NUM,0) ')' '{'
(ID,y) '=' (ID,y) '+' (NUM,1.0) ';'
'}' (ELSE,else) '{'
(ID,y) '=' (ID,y) '-' (NUM,1.0) ';'
'}'
(WHILE,while) '(' (ID,x) '>' (NUM,0) ')' '{'
(ID,x) '=' (ID,x) '-' (NUM,1) ';'
'}'
(RETURN,return) (NUM,0) ';'
'}'

Parsing completed without errors.

(3)Write a program to implement to recognize a valid arithmetic

expression that uses operator +, – , * and /.

Program :
LEX PART :
arith_id.l

%{
/* This LEX program returns the tokens for the expression */
#include “y.tab.h”
%}

%%
“=” {printf(“\n Operator is EQUAL”);}
“+” {printf(“\n Operator is PLUS”);}
“-“ {printf(“\n Operator is MINUS”);}
“/” {printf(“\n Operator is DIVISION”);}
“*” {printf(“\n Operator is MULTIPLICATION”);}

[a-z A-Z]*[0-9]* {
printf(“\n Identifier is %s”,yytext);
return ID;
}
return yytext[0];
\n return 0;
%%

int yywrap()
{
return 1;
}

YACC PART :
arith_id.y

%{
#include
/* This YYAC program is for recognizing the Expression */
%}
%%
statement: A’=’E
| E {
printf(“\n Valid arithmetic expression”);
$$ = $1;
};

E: E’+’ID
| E’-’ID
| E’*’ID
| E’/’ID
| ID
;
%%
extern FILE *yyin;
main()
{
do
{
yyparse();
}while(!feof(yyin));
}

yyerror(char*s)
{
}

Output :

a=3+5
identifier is a
operator is equal
identifier is 3
valid arithmetic expression error occured
operator is plus
identifier is 5

(4)Write a program to implement a Calculator using LEX and YACC.

Program :

LEX PART :

%{
#include <stdio.h>
#include "cal.tab.h"

extern int yylval;

%}

%%
[0-9]+ {
yylval = atoi(yytext);
return NUMBER;
}

[ \t] ;

[\n] return 0;

. return yytext[0];
%%

int yywrap()
{
return 1;
}
YACC Part :

%{
#include <stdio.h>
int flag = 0;
%}

%token NUMBER

%left '+' '-'

%left '*' '/' '%'
%left '(' ')'

%%

ArithmeticExpression: E {
printf("Result = %d\n", $1);
return 0;
};

E: E '+' E { $$ = $1 + $3; }
| E '-' E { $$ = $1 - $3; }
| E '*' E { $$ = $1 * $3; }
| E '/' E { $$ = $1 / $3; }
| E '%' E { $$ = $1 % $3; }
| '(' E ')' { $$ = $2; }
| NUMBER { $$ = $1; }
;

%%

int main()
{
printf("Enter an arithmetic expression that can have operations Addition,
Subtraction, Multiplication, Division, Modulus and Round brackets: ");
yyparse();
if (flag == 0) {
printf("Entered arithmetic expression is Valid\n");
}
return 0;
}

void yyerror(const char* s)

{
printf("Entered arithmetic expression is Invalid\n");
flag = 1;
}

Output :
Enter an arithmetic expression that can have operations
Addition,Subtraction,Multiplication,Division,Modulus and Round brackets
:4+2+6*10
Result=66
Entered arithmetic expression is valid

(5)Write a Program to recognize a valid variable which starts with a

letter followed by any number of letters or digits.

program :

LEX PART :
variable_lex.l

%{
#include "y.tab.h"
%}

%%
[ \t\n]+ /* Ignore whitespace */
[a-zA-Z][a-zA-Z0-9]* { yylval.str = strdup(yytext); return VAR; }
. { return yytext[0]; }
%%

int yywrap() {
return 1;
}

YACC PART :
variable_parser.y

%{
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
%}

%token VAR

%%

program: variable { printf("Valid variable: %s\n", $1); }

;

variable: VAR { $$ = $1; }

;

%%

int main() {
 yyparse();
return 0;
}

void yyerror(const char *s) {

fprintf(stderr, "Error: %s\n", s);
}

Compiling and Running:

lex variable_lex.l
yacc -d variable_parser.y
gcc lex.yy.c y.tab.c -o variable_parser -ll
./variable_parser

Output :

example123
Valid variable: example123

(6)Write a LEX Program to convert the substring abc to ABC from the given
input string.

Program :

LEX PART :
convert_lex.l

%{
#include "y.tab.h"
%}

%%
"abc" { yylval.str = "ABC"; return CONVERT; }
. { return yytext[0]; }
%%

int yywrap() {
return 1;
}

YACC PART :
convert_parser.y

%{
#include <stdio.h>
#include <stdlib.h>
%}

%token CONVERT

%%

program:
| program CONVERT { printf("%s", $2); }
;

%%

int main() {
yyparse();
return 0;
}

void yyerror(const char *s) {

fprintf(stderr, "Error: %s\n", s);
}

Compiling and Running:

lex convert_lex.l
yacc -d convert_parser.y
gcc lex.yy.c y.tab.c -o convert_parser -ll
./convert_parser

Output :

abc abc123
ABC ABC123

(7)Write a C Program to implement NFAs that recognize identifiers,

constants, and operators of the mini language.

Program :

#include <stdio.h>
#include <regex.h>

int main() {
regex_t identifier_regex, constant_regex, operator_regex;

// Regular expressions for identifiers, constants, and operators

const char *identifier_pattern = "[a-zA-Z_][a-zA-Z0-9_]*";
const char *constant_pattern = "[0-9]+";
const char *operator_pattern = "[+\\-*/]";
 // Compile the regular expressions
regcomp(&identifier_regex, identifier_pattern, REG_EXTENDED);
regcomp(&constant_regex, constant_pattern, REG_EXTENDED);
regcomp(&operator_regex, operator_pattern, REG_EXTENDED);

// Input strings
const char *inputs[] = {
"variable123",
"123",
"+",
"invalid123$",
"12.34"
};

// Match and print results

for (int i = 0; i < sizeof(inputs) / sizeof(inputs[0]); i++) {
if (regexec(&identifier_regex, inputs[i], 0, NULL, 0) == 0) {
printf("%s is an identifier.\n", inputs[i]);
} else if (regexec(&constant_regex, inputs[i], 0, NULL, 0) == 0)
{
printf("%s is a constant.\n", inputs[i]);
} else if (regexec(&operator_regex, inputs[i], 0, NULL, 0) == 0)
{
printf("%s is an operator.\n", inputs[i]);
} else {
printf("%s is not recognized.\n", inputs[i]);
}
}

// Free resources
regfree(&identifier_regex);
regfree(&constant_regex);
regfree(&operator_regex);

return 0;
}

Output :

variable123 is an identifier.
123 is a constant.
+ is an operator.
invalid123$ is not recognized.
12.34 is not recognized.

(8)Write a C Program to implement DFA's that recognize identifiers,

constants, and operators of the mini language.

Program :
#include <stdio.h>
#include <stdbool.h>
#include <ctype.h>

// Enumeration for different token types

enum TokenType {
IDENTIFIER,
CONSTANT,
OPERATOR,
INVALID
};

// Function to check if a character is a valid identifier character

bool isIdentifierChar(char ch) {
return isalpha(ch) || isdigit(ch) || ch == '_';
}

// Function to recognize tokens using a DFA

enum TokenType recognizeToken(const char *input) {
int state = 0;

for (int i = 0; input[i] != '\0'; i++) {

char ch = input[i];

switch (state) {
case 0:
if (isalpha(ch) || ch == '_') {
state = 1;
} else if (isdigit(ch)) {
state = 2;
} else if (ch == '+' || ch == '-' || ch == '*' || ch ==
'/') {
state = 3;
} else {
return INVALID;
}
break;

case 1:
if (!isIdentifierChar(ch)) {
return INVALID;
}
break;

case 2:
if (!isdigit(ch)) {
return INVALID;
}
break;

case 3:
// Operators are only one character
return OPERATOR;
 }
}

switch (state) {
case 1: return IDENTIFIER;
case 2: return CONSTANT;
case 3: return OPERATOR;
default: return INVALID;
}
}

// Function to print token type

void printTokenType(enum TokenType type) {
switch (type) {
case IDENTIFIER: printf("Identifier\n"); break;
case CONSTANT: printf("Constant\n"); break;
case OPERATOR: printf("Operator\n"); break;
case INVALID: printf("Invalid\n"); break;
}
}

int main() {
const char *inputs[] = {
"variable123",
"123",
"+",
"invalid123$",
"12.34"
};

for (int i = 0; i < sizeof(inputs) / sizeof(inputs[0]); i++) {

enum TokenType type = recognizeToken(inputs[i]);
printf("%s is a ", inputs[i]);
printTokenType(type);
}

return 0;
}

Output :

variable123 is a Identifier
123 is a Constant
+ is a Operator
invalid123$ is a Invalid
12.34 is a Invalid

(9)Write a program to Implement Simple Code Optimization Techniques using

Constant Folding.

Program :
#include <stdio.h>
// Function to compute a complex expression
int computeExpression(int x, int y, int z) {
int intermediate_result = x * y + z;
return intermediate_result;
}

// Function to perform constant folding

int constantFoldingExample() {
int x = 5;
int y = 3;
int z = 2;

// Original expression
int original_result = computeExpression(x, y, z);

// Constant folded expression

int folded_result = 17;

printf("Original Result: %d\n", original_result);

printf("Constant Folded Result: %d\n", folded_result);

return 0;
}

int main() {
// Call the constant folding function
constantFoldingExample();

return 0;
}

Output :

Original Result: 17
Constant Folded Result: 17

(10)Write a program to Implement the back end of the compiler which takes
the three address code and produces the 8086 assembly language
instructions that can be assembled and run using a 8086 assembler. The
target assembly instructions can be simple move, add, sub, jump. Also
simple addressing modes are used.

Program :

#include <stdio.h>
void generateAssembly(int op, int arg1, int arg2, int result) {
switch (op) {
case 0: // Assignment
 printf("MOV AX, [%d]\n", arg1);
printf("MOV [%d], AX\n", result);
break;

case 1: // Addition
printf("MOV AX, [%d]\n", arg1);
printf("ADD AX, [%d]\n", arg2);
printf("MOV [%d], AX\n", result);
break;

case 2: // Subtraction
printf("MOV AX, [%d]\n", arg1);
printf("SUB AX, [%d]\n", arg2);
printf("MOV [%d], AX\n", result);
break;

case 3: // Jump
printf("JMP L%d\n", arg1);
break;

default:
printf("Invalid operation\n");
break;
}
}

int main() {
// Sample three-address code
generateAssembly(0, 1000, 0, 2000); // a = b
generateAssembly(1, 2000, 3000, 4000); // c = a + d
generateAssembly(2, 4000, 5000, 6000); // e = c - f
generateAssembly(3, 7000, 0, 0); // Jump to label 0

return 0;
}

Output :

MOV AX, [1000]

MOV [2000], AX
MOV AX, [2000]
ADD AX, [3000]
MOV [4000], AX
MOV AX, [4000]
SUB AX, [5000]
MOV [6000], AX
JMP L0

(11)Write a lex program to find out total number of vowels, and

consonants from the given input string.
Program :
LEX PART :

%{
int vowel_count = 0;
int consonant_count = 0;
%}

%%
[aeiouAEIOU] { vowel_count++; }
[a-zA-Z] { consonant_count++; }
[ \t\n] ; // skip whitespace
. ; // skip other characters
%%

int main() {
yylex();
printf("Total vowels: %d\n", vowel_count);
printf("Total consonants: %d\n", consonant_count);
return 0;
}

Output :

Enter a string: Hello World

Total vowels: 3
Total consonants: 7

(12)Write a program to implement to recognize a valid control structures

syntax of C language using For loop and while loop.

Program :

LEX PART :
recognize_control.l

%{
#include "y.tab.h"
%}

%%
"for" { return FOR; }
"while" { return WHILE; }
[ \t\n] ; // skip whitespace
. ; // skip other characters
%%

YACC PART :
recognize_control.y
%{
#include <stdio.h>
%}

%token FOR WHILE

%%
program : control_statement
| /* empty */
;

control_statement : for_loop
| while_loop
;

for_loop : FOR '(' ')' '{' '}'

| FOR '(' expr ';' expr ';' expr ')' '{' '}'
;

while_loop : WHILE '(' expr ')' '{' '}'

;

expr : /* empty */
;

%%

int main() {
yyparse();
return 0;
}

Compiling and Running :

lex recognize_control.l
yacc -d recognize_control.y
gcc lex.yy.c y.tab.c -o recognize_control -ll
./recognize_control

Output :

Enter a control structure: for (;;) {

(13)Write a program to Convert the BNF rules into Yacc form and write
code to generate abstract syntax tree.
Program :

LEX PART :
ast_lex.l

%{
#include "y.tab.h"
%}

%%
[0-9]+ { yylval.str = strdup(yytext); return NUMBER; }
[-+*/()\n] { return yytext[0]; }
[ \t] ; // Ignore whitespace
. ;
%%

int yywrap() {
return 1;
}

YACC PART :
ast_parser.y

%{
#include <stdio.h>
#include <stdlib.h>

struct Node {
char* value;
struct Node* left;
struct Node* right;
};

typedef struct Node Node;

Node* createNode(char* value, Node* left, Node* right) {

Node* node = (Node*)malloc(sizeof(Node));
node->value = value;
node->left = left;
node->right = right;
return node;
}

void printAST(Node* node, int level) {

if (node != NULL) {
printAST(node->right, level + 1);
for (int i = 0; i < level; i++) printf(" ");
printf("%s\n", node->value);
printAST(node->left, level + 1);
}
}
%}

%token NUMBER
%left '+' '-'
%left '*' '/'

%%

program: expression '\n' { printAST($1, 0); }

;

expression: NUMBER { $$ = createNode($1, NULL, NULL); }

| expression '+' expression { $$ = createNode("+", $1, $3); }
| expression '-' expression { $$ = createNode("-", $1, $3); }
| expression '*' expression { $$ = createNode("*", $1, $3); }
| expression '/' expression { $$ = createNode("/", $1, $3); }
| '(' expression ')' { $$ = $2; }
;

%%

int main() {
yyparse();
return 0;
}

void yyerror(const char *s) {

fprintf(stderr, "Error: %s\n", s);
}

Compilation and Running :

lex ast_lex.l
yacc -d ast_parser.y
gcc lex.yy.c y.tab.c -o ast_parser -ll
./ast_parser

Output :

5 + 3 * (2 - 1)

+
/ \
5 *
/ \
3 -
/ \
2 1
(14)Write a program to implement to recognize a valid control structures
syntax of C language using ifelse, if-else-if and switch-case.

Program :

LEX PART :
recognize_control.l

%{
#include "y.tab.h"
%}

%%
"if" { return IF; }
"else" { return ELSE; }
"switch" { return SWITCH; }
"case" { return CASE; }
"break" { return BREAK; }
"default" { return DEFAULT; }
[ \t\n] ; // skip whitespace
. ; // skip other characters
%%

YACC PART :
recognize_control.y

%{
#include <stdio.h>
%}

%token IF ELSE SWITCH CASE BREAK DEFAULT

%%
program : control_statement
| /* empty */
;

control_statement : if_else_statement
| switch_case_statement
;

if_else_statement : IF '(' expr ')' '{' '}'

| IF '(' expr ')' '{' '}' ELSE '{' '}'
| IF '(' expr ')' '{' '}' ELSE if_else_statement
;

switch_case_statement : SWITCH '(' expr ')' '{' case_statements '}'

;
case_statements : /* empty */
| CASE constant ':' case_statements
| DEFAULT ':' case_statements
;

constant : NUMBER
;

expr : /* empty */
;

%%

int main() {
yyparse();
return 0;
}

Compiling and Running :

lex recognize_control.l
yacc -d recognize_control.y
gcc lex.yy.c y.tab.c -o recognize_control -ll
./recognize_control

Output :

Enter a control structure: if (x > 0) { } else if (x < 0) { } else { }

(15)Write a program to Implement any one storage allocation strategies.

(16)Write a program to Implement type checking.

Program :

LEX PART :
type_check_lex.l

%{
#include "y.tab.h"
%}

%%
[0-9]+ { yylval.str = strdup(yytext); return NUMBER; }
[-+*/()\n] { return yytext[0]; }
[ \t] ; // Ignore whitespace
. ;
%%

int yywrap() {
return 1;
}

YACC PART :
type_check_parser.y

%{
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

%}

%token NUMBER

%%

program: expression '\n' { checkTypes($1); }

;

expression: NUMBER { $$ = "int"; }

| expression '+' expression { $$ = checkOperation($1, $3,
"+"); }
| expression '-' expression { $$ = checkOperation($1, $3, "-
"); }
| expression '*' expression { $$ = checkOperation($1, $3,
"*"); }
| expression '/' expression { $$ = checkOperation($1, $3,
"/"); }
| '(' expression ')' { $$ = $2; }
;

checkOperation(op1, op2, op) {

if ((op1 == "int" && op2 == "int") && (op == "+" || op == "-" || op
== "*" || op == "/")) {
return "int";
} else if ((op1 == "double" || op2 == "double") && (op == "+" || op
== "-" || op == "*" || op == "/")) {
return "double";
} else {
printf("Error: Incompatible types for operation %s\n", op);
 exit(EXIT_FAILURE);
}
}

checkTypes(type) {
// Perform type checking logic here
// This is a simplified example
printf("Type checked: %s\n", type);
}

%%

int main() {
yyparse();
return 0;
}

void yyerror(const char *s) {

fprintf(stderr, "Error: %s\n", s);
}

Compilation and Running:

lex type_check_lex.l
yacc -d type_check_parser.y
gcc lex.yy.c y.tab.c -o type_check_parser -ll
./type_check_parser

Output :

5 + 3 * (2 - 1)
Type checked: int

(17)Write a program to Implement Simple Code Optimization Techniques

using Strength reduction.

Program :

#include <stdio.h>
int main() {
int i;
int n = 10;

// Original code with multiplication

printf("Original Code:\n");
for (i = 0; i < n; i++) {
 printf("%d ", i * 3);
}
printf("\n");

// Code after strength reduction

printf("\nCode after Strength Reduction:\n");
for (i = 0; i < n; i++) {
printf("%d ", i << 1 + i); // Replaced multiplication with shift
and addition
}

return 0;
}

Output :

Original Code:
0 3 6 9 12 15 18 21 24 27

Code after Strength Reduction:

0 4 16 48 128 320 768 1792 4096 9216

(18)Write a program to implement to implement the symbol table.

Program :

(19)Write a program to Implement Simple Code Optimization Techniques

using Algebraic transformation.

Program :

#include <stdio.h>

int main() {
int x = 5;
int y = 3;
int z = 7;

// Original code
int result1 = x * y + x * z;
printf("Original Code: %d\n", result1);

// Code after algebraic transformation

 int result2 = x * (y + z);
printf("Code after Algebraic Transformation: %d\n", result2);

return 0;
}

Output :

Original Code: 50
Code after Algebraic Transformation: 50

(20)Write a program to generate three address code using LEX and YACC.

Program :

LEX PART :
three_address_lex.l

%{
#include "y.tab.h"
%}

%%
[0-9]+ { yylval.num = atoi(yytext); return NUM; }
[-+*/()\n] { return yytext[0]; }
[ \t] ; // Ignore whitespace
. ;
%%

int yywrap() {
return 1;
}

YACC PART :
three_address_parser.y

%{
#include <stdio.h>
#include <stdlib.h>

int tempCount = 1;

int newTemp() {
return tempCount++;
}
%}
%token NUM

%%

program: expression '\n' { printf("\nThree Address Code:\n"); }

;

expression: term { $$ = $1; }

| expression '+' term { $$ = newTemp(); printf("t%d = %s +
%s\n", $$, $1, $3); }
| expression '-' term { $$ = newTemp(); printf("t%d = %s -
%s\n", $$, $1, $3); }
;

term: factor { $$ = $1; }

| term '*' factor { $$ = newTemp(); printf("t%d = %s *
%s\n", $$, $1, $3); }
| term '/' factor { $$ = newTemp(); printf("t%d = %s /
%s\n", $$, $1, $3); }
;

factor: '(' expression ')' { $$ = $2; }

| NUM { $$ = yytext; }
;

%%

int main() {
yyparse();
return 0;
}

void yyerror(const char *s) {

fprintf(stderr, "Error: %s\n", s);
}

Compilation and Running :

lex three_address_lex.l
yacc -d three_address_parser.y
gcc lex.yy.c y.tab.c -o three_address_parser -ll
./three_address_parser

Output :

5 + 3 * (2 - 1)
Three Address Code:
t1 = 2 - 1
t2 = 3 * t1
t3 = 5 + t2