Compiler

package ImiPackage;

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStreamReader;

import java.util.ArrayList;

import java.util.logging.Level;

import java.util.logging.Logger;

// a=-(b+c)*m

// a=-(b*10)-(c/d)+g

// a=-88*cd/d

// a=a-(b+c)*(d+e)/f

// a=z+(c*(b+(c-l)))/f

// a=-b*(c+d)

/**

*

* @author OnlyImran

*/

public class ThreeAddressCode {

InputStreamReader ir = new InputStreamReader(System.in);

BufferedReader br = new BufferedReader(ir);

String splitted[];

String expr = "", bodmas = "()/*+-", left = "", right = "", temp = "", t = "T", operators = "", operands = "", op = "=/*+-";

int tempCount = 1, cntOpen = 0, cntClose = 0, cntOperator = 0;

ArrayList threeLeft = new ArrayList();

ArrayList threeRight = new ArrayList();

ArrayList openBrace = new ArrayList();

ArrayList closeBrace = new ArrayList();

ArrayList optimizedLeft = new ArrayList();

ArrayList optimizedRight = new ArrayList();

boolean matched = false, gotOperator = false, nestedBrace = false, innerMatched = false;

String s1 = "", s2 = "", s3 = "", subS1 = "", subS2 = "", subS3 = "", arg1 = "", arg2 = "", opr = "";

String[][] quadruple;

public ThreeAddressCode() {

System.out.println("Enter grammar in following format:\nExpr=Expr");

try {

while ((expr = br.readLine()) != null && expr.length() != 0) {

splitted = expr.split("=");

left = splitted[0];

right = splitted[1];

}

} catch (IOException ex) {

}

expr = left + " = " + right;

for (int i = 0; i < expr.length(); i++) {

for (int j = 0; j < op.length(); j++) {

if ((op.charAt(j) + "").equals(expr.charAt(i) + "")) {

operators = operators + " " + expr.charAt(i);

}

}

if (expr.charAt(i) > 95 && expr.charAt(i) < 122) {

operands = operands + " " + expr.charAt(i);

}

}

System.out.println("Operands are: " + operands);

System.out.println("Operators are: " + operators + "\n");

checkOperator();

if (cntOperator > 1) {

if ("-".equals(right.charAt(0) + "") && ("(".equals(right.charAt(1) + ""))) {

chekUnaryParanthesis();

}

if ("-".equals(right.charAt(0) + "")) { //// -b*c or -13*c

checkUnary();

}

for (int i = 0; i < right.length(); i++) {

if ("(".equals(right.charAt(i) + "")) {

openBrace.add(i);

}

if (")".equals(right.charAt(i) + "")) {

closeBrace.add(i);

}

}

// checking for nested braces

if (openBrace.size() >= 1) {

if (openBrace.size() == 1) { // Because if size is exactly 1 then else if will throw error--> openBrace.get(1);

removeBraces();

checkOperator();

} else if (openBrace.get(1) > closeBrace.get(0)) {

nestedBrace = false; // Not used anywhere, just for notification

removeBraces();

checkOperator();

} else {

nestedBrace = true; // Not used anywhere

removeNested();

checkOperator();

}

}


while (cntOperator != 1) {

//System.out.println("cnt Operator is: " + cntOperator);

cntOperator--;

for (int i = 0; i < bodmas.length(); i++) {

for (int j = 0; j < right.length(); j++) {

if ((bodmas.charAt(i) + "").equals(right.charAt(j) + "")) {

//System.out.println("matched i=" + j);

matched = true;

// checking for inner match = 0; k--) {

for (int l = 0; l < bodmas.length(); l++) {

if ((right.charAt(k) + "").equals(bodmas.charAt(l) + "")) {

//System.out.println("MATCHED INNER");

innerMatched = true;

subS1 = right.substring(k + 1, j); // 10

subS2 = right.charAt(j) + ""; // /

s1 = right.substring(0, k + 1); // b+a*

break;

} else if (k == 0) { // consider input: b*c+d

// System.out.println("Reached End start");

subS1 = right.substring(0, j); // b

subS2 = right.charAt(j) + ""; // *

s1 = ""; //

break;

}

}

if (innerMatched) {

innerMatched = false;

break;

}

}

// checking for inner match --> z=b+a*10/20*d+e

for (int k = j + 1; k < right.length(); k++) {




subS3 = right.substring(j + 1, k); // 20

s3 = right.substring(k, right.length()); // *d+e

} else if (k == right.length() - 1) { // assume as input: b+c*d

subS3 = right.substring(j + 1, right.length()); // d

s3 = "";

}

}

if (innerMatched) {


break;

}

}

s2 = subS1 + subS2 + subS3;

temp = t + tempCount;

threeLeft.add(temp);

threeRight.add(s2);

right = s1 + temp + s3;

// System.out.println("Right=" + right);

tempCount++;

break;

}

}

if (matched) {

matched = false;

break;

}

}

}

checkOperator();

}

} else {

System.out.println("Please enter proper input:");

}

System.out.println("Three Left" + threeLeft);

System.out.println("Three right" + threeRight);

// Printing final output

System.out.println("Printing three address code of:" + expr);

for (int i = 0; i < threeLeft.size(); i++) {

System.out.println(threeLeft.get(i) + " = " + threeRight.get(i));

}

}

private void chekUnaryParanthesis() {

// - ( b * 1 0 ) + d

// 0 1 2 3 4 5 6 7 8

cntOpen = right.indexOf("(");

cntClose = right.indexOf(")");

s1 = right.charAt(0) + ""; // -

s2 = right.substring(cntOpen + 1, cntClose); // b*c

s3 = right.substring(cntClose + 1, right.length()); // +d

temp = t + tempCount; // T1

threeLeft.add(temp); // T1

threeRight.add(s2); // b*10

right = s1 + temp + s3; // -T1+d


tempCount++;

}

void checkUnary() {

// - T 1 * d

// 0 1 2 3


for (int j = 0; j < bodmas.length(); j++) {

if (("" + right.charAt(i)).equals(bodmas.charAt(j) + "")) {

s1 = "";

s2 = right.substring(0, i); // -T1

s3 = right.substring(i, right.length()); // +d



threeRight.add(s2); // -T1

right = temp + s3; // T3+d


tempCount++;

checkOperator();

matched = true;

}

}

if (matched) {

matched = false;

break;

}

}

}

void checkOperator() {

cntOperator = 0;


for (int j = 0; j < bodmas.length(); j++) { // open ( and close ) braces are decreased to 0 coz of cntClose--


cntOperator++;

}

}

}

// System.out.println("Operator count=" + cntOperator);

if (cntOperator == 1 && "-".equals("" + right.charAt(0))) { // a=-b

System.out.println("Single input: ");

threeLeft.add("T1");

threeRight.add(right);

threeLeft.add(left);

threeRight.add("T1"); //threeRight.add(right);

} else if (cntOperator == 1) {



}

}

void removeNested() {

// a + ( c * ( b + c ) ) / f

// 0 1 2 3 4 5 6 7 8 9 10 11 12

for (int i = 0; i < openBrace.size(); i++) {

cntOpen = right.lastIndexOf("("); // 5

cntClose = right.indexOf(")");// 9

s1 = right.substring(0, cntOpen); // a+(c*

s2 = right.substring(cntOpen + 1, cntClose); // b+c

s3 = right.substring(cntClose + 1, right.length()); // )/f



threeRight.add(s2);



tempCount++;

}

}

void removeBraces() {

// a + ( b + c ) * ( d + e ) / f

// 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14

// System.out.println(openBrace.size());


cntOpen = right.indexOf("("); // 2

cntClose = right.indexOf(")"); // 6

s1 = right.substring(0, cntOpen); // a+


s3 = right.substring(cntClose + 1, right.length()); // *(d+e)/f



threeRight.add(s2);



tempCount++;

}

}

public static void main(String args[]) {

ThreeAddressCode q = new ThreeAddressCode();

}

}

package ImiPackage;





// a=-(b+c)*m

// a=-(b*10)-(c/d)+g

// a=-88*cd/d

// a=a-(b+c)*(d+e)/f

// a=z+(c*(b+(c-l)))/f

// a=-b*(c+d)

/**

*

* @author OnlyImran

*/

public class Quadruples {



String splitted[];











String[][] quadruple;

public Quadruples() {


try {



left = splitted[0];


}


}






}

}



}

}



checkOperator();




}


checkUnary();

}



openBrace.add(i);

}


closeBrace.add(i);

}

}




removeBraces();

checkOperator();



removeBraces();

checkOperator();

} else {


removeNested();

checkOperator();

}

}




cntOperator--;





matched = true;









break;



subS1 = right.substring(0, j);

subS2 = right.charAt(j) + "";

s1 = ""; //

break;

}

}

if (innerMatched) {


break;

}

}









subS3 = right.substring(j + 1, right.length()); // 20

s3 = "";

}

}

if (innerMatched) {


break;

}

}




threeRight.add(s2);



tempCount++;

break;

}

}

if (matched) {

matched = false;

break;

}

}

}

checkOperator();

}

} else {


}

// System.out.println("Three Left" + threeLeft);

// System.out.println("Three right" + threeRight);





optimizedLeft.add(threeLeft.get(i));

optimizedRight.add(threeRight.get(i));

}

quadruple = new String[optimizedRight.size() + 1][5];

// filling quadruples

for (int i = 0; i < optimizedRight.size() + 1; i++) {

for (int j = 0; j < 5; j++) {

quadruple[i][j] = "";

if (i != 0 && j == 0) {

quadruple[i][j] = "(" + (i - 1) + ")";

} else if (i == 0 && j == 1) {

quadruple[i][j] = "OP";

} else if (i == 0 && j == 2) {

quadruple[i][j] = "ARG-1";

} else if (i == 0 && j == 3) {

quadruple[i][j] = "ARG-2";

} else if (i == 0 && j == 4) {

quadruple[i][j] = "RESULT";

}

}

}


String arg = optimizedRight.get(i - 1);

if ((arg.charAt(0) + "").equals("-")) {

arg = arg.substring(1, arg.length()) + arg.charAt(0);

}

String result = optimizedLeft.get(i - 1);

int x;

for (x = 0; x < arg.length(); x++) {

for (int y = 0; y < bodmas.length(); y++) {

if ((arg.charAt(x) + "").equals(bodmas.charAt(y) + "")) {


break;

}

}

if (innerMatched) {


break;

}

}

op = arg.charAt(x) + "";// b*10

arg1 = arg.substring(0, x);

arg2 = arg.substring(x + 1, arg.length());

//System.out.println("ARG1=" + arg1 + " OP=" + op + " ARG2=" + arg2);

for (int j = 0; j < 5; j++) {

if ((arg.charAt(arg.length() - 1) + "").equals("-")) {

quadruple[i][1] = "UMINUS";

}

if (j == 1) {

quadruple[i][j] = op;

} else if (j == 2) {

quadruple[i][j] = arg1;

} else if (j == 3) {

quadruple[i][j] = arg2;

} else if (j == 4) {

quadruple[i][j] = result;

}

}

}

// Printing Quatruple


for (int j = 0; j < 5; j++) {

System.out.print(quadruple[i][j] + "\t");

}

System.out.println("");

}

}

private void chekUnaryParanthesis() {

// - ( b * 1 0 ) + d

// 0 1 2 3 4 5 6 7 8

cntOpen = right.indexOf("(");

cntClose = right.indexOf(")");

s1 = right.charAt(0) + ""; // -

s2 = right.substring(cntOpen + 1, cntClose); // b*c

s3 = right.substring(cntClose + 1, right.length()); // +d



threeRight.add(s2); // b*10

right = s1 + temp + s3; // -T1+d


tempCount++;

}

void checkUnary() {

// - T 1 * d

// 0 1 2 3


for (int j = 0; j < bodmas.length(); j++) {


s1 = "";

s2 = right.substring(0, i); // -T1

s3 = right.substring(i, right.length()); // +d



threeRight.add(s2); // -T1

right = temp + s3; // T3+d

//System.out.println("Right=" + right);

tempCount++;

checkOperator();

matched = true;

}

}

if (matched) {

matched = false;

break;

}

}

}

void checkOperator() {

cntOperator = 0;


for (int j = 0; j < bodmas.length(); j++) { // open ( and close ) braces are decreased to 0 coz of cntClose--


cntOperator++;

}

}

}

// System.out.println("Operator count=" + cntOperator);

if (cntOperator == 1 && "-".equals("" + right.charAt(0))) { // a=-b

System.out.println("Single input: ");

threeLeft.add("T1");



threeRight.add("T1"); //threeRight.add(right);

} else if (cntOperator == 1) {



}

}

void removeNested() {

// a + ( c * ( b + c ) ) / f

// 0 1 2 3 4 5 6 7 8 9 10 11 12


cntOpen = right.lastIndexOf("("); // 5

cntClose = right.indexOf(")");// 9

s1 = right.substring(0, cntOpen); // a+(c*


s3 = right.substring(cntClose + 1, right.length()); // )/f



threeRight.add(s2);



tempCount++;

}

}

void removeBraces() {

// a + ( b + c ) * ( d + e ) / f

// 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14

// System.out.println(openBrace.size());


cntOpen = right.indexOf("("); // 2

cntClose = right.indexOf(")"); // 6

s1 = right.substring(0, cntOpen); // a+


s3 = right.substring(cntClose + 1, right.length()); // *(d+e)/f



threeRight.add(s2);



tempCount++;

}

}

public static void main(String args[]) {

Quadruples q = new Quadruples();

}

}

package ImiPackage;





public class Triple {



String splitted[];











String[][] triple;

public Triple() {


try {



left = splitted[0];


}


}






}

}



}

}



checkOperator();




}


checkUnary();

}



openBrace.add(i);

}


closeBrace.add(i);

}

}



removeBraces();

checkOperator();



removeBraces();

checkOperator();

} else {


removeNested();

checkOperator();

}

}



cntOperator--;





matched = true;








break;




s1 = ""; //

break;

}

}

if (innerMatched) {


break;

}

}










s3 = "";

}

}

if (innerMatched) {


break;

}

}




threeRight.add(s2);



tempCount++;

break;

}

}

if (matched) {

matched = false;

break;

}

}

}

checkOperator();

}

} else {


}







}

triple = new String[optimizedRight.size() + 1][5];

// filling triples


for (int j = 0; j < 5; j++) {

triple[i][j] = "-";

if (i != 0 && j == 0) {

triple[i][j] = "(" + (i - 1) + ")";

} else if (i == 0 && j == 1) {

triple[i][j] = "OP";

} else if (i == 0 && j == 2) {

triple[i][j] = "ARG-1";

} else if (i == 0 && j == 3) {

triple[i][j] = "ARG-2";

} else if (i == 0 && j == 4) {

triple[i][j] = "RESULT";

}

}

}





}


int x;





break;

}

}

if (innerMatched) {


break;

}

}

op = arg.charAt(x) + "";




for (int j = 0; j < 5; j++) {


triple[i][1] = "UMINUS";

}

if (j == 1) {

triple[i][j] = op;

} else if (j == 2) {

triple[i][j] = arg1;

for(int k=1;k 1) {



}


checkUnary();

}



openBrace.add(i);

}


closeBrace.add(i);

}

}




removeBraces();

checkOperator();



removeBraces();

checkOperator();

} else {


removeNested();

checkOperator();

}

}




cntOperator--;





matched = true;









break;





s1 = ""; //

break;

}

}

if (innerMatched) {


break;

}

}










s3 = "";

}

}

if (innerMatched) {


break;

}

}




threeRight.add(s2);



tempCount++;

break;

}

}

if (matched) {

matched = false;

break;

}

}

}

checkOperator();

}

} else {


}







}

indirectTriple = new String[optimizedRight.size() + 1][5];

// filling indirectTriples


for (int j = 0; j < 5; j++) {

indirectTriple[i][j] = "-";

if (i != 0 && j == 0) {

indirectTriple[i][j] = "(" + (i +13) + ")";

} else if (i == 0 && j == 1) {

indirectTriple[i][j] = "OP";

} else if (i == 0 && j == 2) {

indirectTriple[i][j] = "ARG-1";

} else if (i == 0 && j == 3) {

indirectTriple[i][j] = "ARG-2";

} else if (i == 0 && j == 4) {

indirectTriple[i][j] = "RESULT";

}

}

}





}


int x;





break;

}

}

if (innerMatched) {


break;

}

}

op = arg.charAt(x) + "";




for (int j = 0; j < 5; j++) {


indirectTriple[i][1] = "UMINUS";

}

if (j == 1) {

indirectTriple[i][j] = op;

} else if (j == 2) {

indirectTriple[i][j] = arg1;

for(int k=1;k= 0; i--) {

postFix = postFix + stack.get(i);

//stack.clear();

System.out.println(postFix + "\t\t" + stack);

}

}

System.out.println("Post Fix is: " + postFix);

}

public static void main(String[] args) {

InfixToPostfix p = new InfixToPostfix();

}

}

package ImiPackage;







// abc-+de-fg-h+/*

// abc+*d/

/**

*

* @author Imran

*/

public class PostfixToInfix {



String infix = "",expr="",op="/*+-";

ArrayList stack = new ArrayList();

public PostfixToInfix() {

System.out.println("Enter grammar :");

try {

expr = br.readLine();


Logger.getLogger(ThreeAddressCode.class.getName()).log(Level.SEVERE, null, ex);

}

System.out.println("Expr " + expr);


String ch = expr.charAt(i) + "";

if ((expr.charAt(i) >= 97 && expr.charAt(i) 1){

secondLastElement = "("+secondLastElement+")";

}

if(getCharCount(lastElement)>1){

lastElement = "("+lastElement+")";

}

}

String newElement = secondLastElement+ch+lastElement;

stack.add(newElement);

System.out.println(stack);

}

}

System.out.println("Converted Infix is: "+stack.get(0));

}

private int getCharCount(String str){

int count=str.length();

return count;

}

public static void main(String args[]){

PostfixToInfix pti = new PostfixToInfix();

}

}

package ImiPackage;







// 13+5* ans=20

// 246+*5/ ans=4

/**

*

* @author Imran

*/

public class EvaluationOfPostfix {



String postFix = "",expr="";

ArrayList stack = new ArrayList();

public EvaluationOfPostfix() {

System.out.println("Enter grammar :");

try {

expr = br.readLine();


Logger.getLogger(ThreeAddressCode.class.getName()).log(Level.SEVERE, null, ex);

}

System.out.println("Expr " + expr);


String ch = expr.charAt(i) + "";

if ((expr.charAt(i) >= 97 && expr.charAt(i) = 48 && expr.charAt(i)

Compiler

Documents

Transcript of Compiler