NAME: KARTHIKEY.B
REG NO: 21BCE3316
NAME: KARTHIKEY.B
REG NO: 21BCE3316
CODE:
#include <stdio.h>
int main() {
int a, b, c, d, e;
// Read input from file or user
// Assuming input.txt contains the given sample input
FILE *inputFile = fopen("input.txt", "r");
fscanf(inputFile, "a=%d\n", &a);
fscanf(inputFile, "b=%d\n", &b);
fclose(inputFile);
// Perform constant propagation
c = a + 10;
d = 20 - b;
e = c * d;
// Print results
printf("After constant propagation\n");
printf("c=%d+10\n", a);
printf("Result: %d\n", c);
printf("d=20-%d\n", b);
printf("Result: %d\n", d);
printf("e=%d*%d\n", c, d);
printf("Result: %d\n", e);
return 0;
}
NAME: KARTHIKEY.B
REG NO: 21BCE3316
NAME: KARTHIKEY.B
REG NO: 21BCE3316
CODE:
#include <stdio.h>
int main() {
int a, b, c, d, e, f, r;
// Read input from file or user
// Assuming input.txt contains the given sample input
FILE *inputFile = fopen("input.txt", "r");
fscanf(inputFile, "a=%d\n", &a);
fscanf(inputFile, "b=%d\n", &b);
fclose(inputFile);
// Perform dead code elimination
b = c + d;
e = c + d;
f = b + e;
r = f;
NAME: KARTHIKEY.B
REG NO: 21BCE3316
// Print results after dead code elimination
printf("After dead code elimination\n");
printf("b=c+d\n");
printf("e=c+d\n");
printf("f=b+e\n");
printf("r=f\n");
// Perform common subexpression elimination
b = c + d;
f = b + d;
r = f;
// Print results after common subexpression elimination
printf("Eliminate Common Expression\n");
printf("b=c+d\n");
printf("b=c+d\n");
printf("f=b+b\n");
printf("r=f\n");
// Print optimized code
printf("Optimized code\n");
printf("b=c+d\n");
printf("f=b+d\n");
printf("r=f\n");
return 0;
}
NAME: KARTHIKEY.B
REG NO: 21BCE3316
NAME: KARTHIKEY.B
REG NO: 21BCE3316
NAME: KARTHIKEY.B
REG NO: 21BCE3316
CODE:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX_SIZE 100
typedef struct {
char data[MAX_SIZE];
int top;
} Stack;
void initialize(Stack* stack) {
stack->top = -1;
}
int isEmpty(Stack* stack) {
return stack->top == -1;
}
int isFull(Stack* stack) {
return stack->top == MAX_SIZE - 1;
}
void push(Stack* stack, char value) {
if (isFull(stack)) {
printf("Stack overflow!\n");
exit(1);
}
stack->data[++stack->top] = value;
}
char pop(Stack* stack) {
if (isEmpty(stack)) {
printf("Stack underflow!\n");
exit(1);
}
return stack->data[stack->top--];
}
char peek(Stack* stack) {
if (isEmpty(stack)) {
printf("Stack is empty!\n");
exit(1);
}
return stack->data[stack->top];
}
NAME: KARTHIKEY.B
REG NO: 21BCE3316
int isOperator(char c) {
return c == '+' || c == '-' || c == '*' || c == '/';
}
int getPrecedence(char operator) {
switch (operator) {
case '+':
case '-':
return 1;
case '*':
case '/':
return 2;
default:
return 0;
}
}
void infixToPostfix(char* infix, char* postfix) {
Stack stack;
initialize(&stack);
int j = 0;
for (int i = 0; infix[i] != '\0'; i++) {
char current = infix[i];
if (isOperator(current)) {
while (!isEmpty(&stack) && getPrecedence(peek(&stack)) >= getPrecedence(current)) {
postfix[j++] = pop(&stack);
}
push(&stack, current);
} else if (current == '(') {
push(&stack, current);
} else if (current == ')') {
while (!isEmpty(&stack) && peek(&stack) != '(') {
postfix[j++] = pop(&stack);
}
if (!isEmpty(&stack) && peek(&stack) == '(') {
pop(&stack); // Discard '('
}
} else {
postfix[j++] = current;
}
}
while (!isEmpty(&stack)) {
postfix[j++] = pop(&stack);
}
postfix[j] = '\0';
}
NAME: KARTHIKEY.B
REG NO: 21BCE3316
typedef struct {
char op;
char arg1;
char arg2;
char result;
} Quadruple;
void generateQuadruples(char* postfix, Quadruple* quadruples, int* numQuadruples) {
Stack stack;
initialize(&stack);
int tempCount = 1;
int j = 0;
for (int i = 0; postfix[i] != '\0'; i++) {
char current = postfix[i];
if (!isOperator(current)) {
push(&stack, current);
} else {
char arg2 = pop(&stack);
char arg1 = pop(&stack);
char result = 'T' + tempCount++;
quadruples[j].op = current;
quadruples[j].arg1 = arg1;
quadruples[j].arg2 = arg2;
quadruples[j].result = result;
j++;
push(&stack, result);
}
}
*numQuadruples = j;
}
void printQuadruples(Quadruple* quadruples, int numQuadruples) {
printf("Quadruple Table:\n");
printf("-----------------\n");
printf("| Op | Arg1 | Arg2 | Result |\n");
printf("-----------------\n");
for (int i = 0; i < numQuadruples; i++) {
printf("| %c | %c | %c | %c |\n", quadruples[i].op, quadruples[i].arg1, quadruples[i].arg2,
quadruples[i].result);
}
printf("-----------------\n");
}
void generateMachineInstructions(Quadruple* quadruples, int numQuadruples) {
printf("Machine Instructions:\n");
NAME: KARTHIKEY.B
REG NO: 21BCE3316
for (int i = 0; i < numQuadruples; i++) {
Quadruple q = quadruples[i];
switch (q.op) {
case '+':
printf("ADD %c, %c, %c\n", q.arg1, q.arg2, q.result);
break;
case '-':
printf("SUB %c, %c, %c\n", q.arg1, q.arg2, q.result);
break;
case '*':
printf("MUL %c, %c, %c\n", q.arg1, q.arg2, q.result);
break;
case '/':
printf("DIV %c, %c, %c\n", q.arg1, q.arg2, q.result);
break;
}
}
}
int main() {
char infix[MAX_SIZE];
char postfix[MAX_SIZE];
Quadruple quadruples[MAX_SIZE];
int numQuadruples = 0;
printf("Enter the infix expression: ");
scanf("%s", infix);
infixToPostfix(infix, postfix);
printf("Postfix Expression: %s\n", postfix);
generateQuadruples(postfix, quadruples, &numQuadruples);
printQuadruples(quadruples, numQuadruples);
generateMachineInstructions(quadruples, numQuadruples);
return 0;
}
NAME: KARTHIKEY.B
REG NO: 21BCE3316
THE END