inter 2pass

 import java.util.*;


public class Ass4{


    static class Symbol {

        String symbol;

        int address;


        Symbol(String symbol, int address) {

            this.symbol = symbol;

            this.address = address;

        }

    }


    static class Literal {

        String literal;

        int address;


        Literal(String literal) {

            this.literal = literal;

            this.address = -1;

        }

    }


    static List<Symbol> symbolTable = new ArrayList<>();

    static List<Literal> literalTable = new ArrayList<>();

    static List<Integer> poolTable = new ArrayList<>();

    static List<String> intermediateCode = new ArrayList<>();


    static int locationCounter = 0;


    // Mnemonic Opcode Table (Mnemonic, Class, Opcode, Length)

    static Map<String, String[]> mot = new HashMap<>();

    static {

        mot.put("STOP", new String[]{"IS", "00", "1"});

        mot.put("ADD", new String[]{"IS", "01", "1"});

        mot.put("SUB", new String[]{"IS", "02", "1"});

        mot.put("MULTI", new String[]{"IS", "03", "1"});

        mot.put("MOVER", new String[]{"IS", "04", "1"});

        mot.put("MOVEM", new String[]{"IS", "05", "1"});

        mot.put("COMP", new String[]{"IS", "06", "1"});

        mot.put("BC", new String[]{"IS", "07", "1"});

        mot.put("DIV", new String[]{"IS", "08", "1"});

        mot.put("READ", new String[]{"IS", "09", "1"});

        mot.put("PRINT", new String[]{"IS", "10", "1"});


        mot.put("START", new String[]{"AD", "01", "-"});

        mot.put("END", new String[]{"AD", "02", "-"});

        mot.put("ORIGIN", new String[]{"AD", "03", "-"});

        mot.put("EQU", new String[]{"AD", "04", "-"});

        mot.put("LTORG", new String[]{"AD", "05", "-"});


        mot.put("DS", new String[]{"DL", "01", "1"});

        mot.put("DC", new String[]{"DL", "02", "1"});

    }


    static Map<String, Integer> registerCode = new HashMap<>();

    static {

        registerCode.put("AREG", 1);

        registerCode.put("BREG", 2);

        registerCode.put("CREG", 3);

    }


    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);

        System.out.println("Enter Assembly Code line by line (type 'END' to stop):");

        List<String> sourceCode = new ArrayList<>();


        while (true) {

            String line = sc.nextLine().trim();

            sourceCode.add(line);

            if (line.startsWith("END")) break;

        }


        passOne(sourceCode);

        passTwo();

        printTablesAndIC();

    }


    static void passOne(List<String> source) {

        locationCounter = 0;

        poolTable.add(0);  // Initial pool table entry

        int lastPoolIndex = 0;


        for (String line : source) {

            if (line.isEmpty()) continue;

            String[] tokens = line.trim().split("\\s+");

            if (tokens.length == 0) continue;


            String label = "";

            int i = 0;

            StringBuilder icLine = new StringBuilder();


            // Handle Label

            if (!mot.containsKey(tokens[0])) {

                label = tokens[0];

                addSymbol(label, locationCounter);

                icLine.append("(S, ").append(getSymbolIndex(label)).append(") ");

                i++;

            }


            if (i >= tokens.length) continue;


            String opcode = tokens[i];

            String[] motEntry = mot.getOrDefault(opcode, new String[]{"??", "??", "-"});

            icLine.append("(").append(motEntry[0]).append(" ").append(motEntry[1]).append(") ");


            switch (opcode) {

                case "START":

                    if (i + 1 < tokens.length) {

                        locationCounter = Integer.parseInt(tokens[++i]);

                        icLine.append("(C, ").append(locationCounter).append(")");

                    }

                    break;


                case "DS":

                case "DC":

                    if (i + 1 < tokens.length) {

                        icLine.append("(C, ").append(tokens[++i]).append(")");

                    }

                    break;


                case "READ":

                case "PRINT":

                    if (i + 1 < tokens.length) {

                        icLine.append(getOperand(tokens[++i]));

                    }

                    break;


                case "MOVER":

                case "MOVEM":

                case "COMP":

                case "ADD":

                case "SUB":

                case "DIV":

                case "MULTI":

                    if (i + 2 < tokens.length) {

                        String reg1 = tokens[++i].replace(",", "");

                        int regCode1 = registerCode.getOrDefault(reg1, 0);

                        icLine.append("(RG, ").append(String.format("%02d", regCode1)).append("), ");


                        String operand2 = tokens[++i];

                        if (registerCode.containsKey(operand2)) {

                            int regCode2 = registerCode.get(operand2);

                            icLine.append("(RG, ").append(String.format("%02d", regCode2)).append(")");

                        } else {

                            icLine.append(getOperand(operand2));

                        }

                    }

                    break;



                case "BC":

                    if (i + 2 < tokens.length) {

                        icLine.append("(CC, ").append(tokens[++i].replace(",", "")).append("), ");

                        icLine.append(getOperand(tokens[++i]));

                    }

                    break;


                case "LTORG":

                    // Only add a new pool entry if there are new literals

                    if (literalTable.size() > lastPoolIndex) {

                        for (int k = lastPoolIndex; k < literalTable.size(); k++) {

                            literalTable.get(k).address = locationCounter++;

                        }

                        poolTable.add(literalTable.size());

                        lastPoolIndex = literalTable.size();

                    }

                    break;


                case "END":

                    // Assign addresses to any remaining literals

                    for (int k = lastPoolIndex; k < literalTable.size(); k++) {

                        literalTable.get(k).address = locationCounter++;

                    }

                    break;


                default:

                    break;

            }


            intermediateCode.add(icLine.toString().trim());

            if (!opcode.equals("START") && !opcode.equals("END") && !opcode.equals("LTORG")) {

                locationCounter++;

            }

        }

    }


    static String getOperand(String operand) {

        if (operand.startsWith("=")) {

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

                if (literalTable.get(i).literal.equals(operand)) {

                    return "(L, " + i + ")";

                }

            }

            literalTable.add(new Literal(operand));

            return "(L, " + (literalTable.size() - 1) + ")";

        } else {

            int index = findOrAddSymbol(operand);

            return "(S, " + index + ")";

        }

    }


    static int findOrAddSymbol(String sym) {

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

            if (symbolTable.get(i).symbol.equals(sym)) return i;

        }

        symbolTable.add(new Symbol(sym, -1));

        return symbolTable.size() - 1;

    }


    static void addSymbol(String sym, int address) {

        for (Symbol s : symbolTable) {

            if (s.symbol.equals(sym)) {

                s.address = address;

                return;

            }

        }

        symbolTable.add(new Symbol(sym, address));

    }


    static int getSymbolIndex(String sym) {

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

            if (symbolTable.get(i).symbol.equals(sym)) return i;

        }

        return -1;

    }


    static void passTwo() {

        int addr = locationCounter;

        for (Symbol s : symbolTable) {

            if (s.address == -1) s.address = addr++;

        }

    }


    static void printTablesAndIC() {

        System.out.println("\n== Intermediate Code ==");

        for (String line : intermediateCode) System.out.println(line);


        System.out.println("\n== Symbol Table ==");

        System.out.println("Index\tSymbol\tAddress");

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

            Symbol s = symbolTable.get(i);

            System.out.println(i + "\t" + s.symbol + "\t" + s.address);

        }


        System.out.println("\n== Literal Table ==");

        System.out.println("Index\tLiteral\tAddress");

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

            Literal l = literalTable.get(i);

            System.out.println(i + "\t" + l.literal + "\t" + l.address);

        }


        System.out.println("\n== Pool Table ==");

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

            System.out.println("#" + (i + 1) + " starts at literal index: " + poolTable.get(i));

        }

    }

}

Comments

Post a Comment

Popular posts from this blog

literal

 import java.util.*; class Literal {     String value;     int address;     public Literal(String value) {         this.value = value;         this.address = -1; // not assigned yet     } } public class Ass2{     // Check if a literal already exists in the list     public static boolean literalExists(List<Literal> list, String value) {         for (Literal l : list) {             if (l.value.equals(value)) return true;         }         return false;     }     public static void main(String[] args) {         Scanner scanner = new Scanner(System.in);         List<String> code = new ArrayList<>();         List<Literal> literalTable = new ArrayList<>();         List<L...
Read more

yacc evaluate

  YACC evaluate a given variable First, make sure you have Flex, bison installed: For installing on Ubuntu- sudo apt-get install flex bison How to Compile and Run: Clean and rebuild: Plain Text Copy yacc -d parser.y lex lexer.l gcc lex.yy.c y.tab.c -o var_validator -ll ./var_validator ​ Assembly Copy - - - Save as lexer.l - - - % { #include "y.tab.h" % } % % [ a - zA - Z ] { yylval = yytext [ 0 ] ; return LETTER; } [ 0 - 9 ] { yylval = yytext [ 0 ] ; return DIGIT; } "_" { yylval = '_' ; return UNDERSCORE; } [ \t ] ; /* Ignore whitespace */ \n { return '\n' ; } . { return yytext [ 0 ] ; } % % int yywrap() { return 1 ; } ​ Assembly Copy - - - Save as parser.y - - - % { #include < stdio.h > int yylex() ; void yyerror(char * ) ; char var_name [ 100 ] ; int pos = 0 ; % } % token LETTER DIGIT UNDERSCORE % % input: / * empty * / | input line ; ...
Read more

built in functions

  YACC built-in functions First, make sure you have Flex installed: For installing on Ubuntu- sudo apt-get install flex bison How to Compile and Run: Clean and rebuild: Plain Text Copy yacc -d parser.y lex lexer.l gcc lex.yy.c y.tab.c -o function_evaluator -lm ./function_evaluator ​ Assembly Copy - - - Save as lexer.l - - - % { #include "y.tab.h" #include < math.h > #include < string.h > #include < stdlib.h > % } % % "sqrt" { return SQRT ; } "strlen" { return STRLEN ; } "print" { return PRINT ; } [ a - zA - Z ] { yylval.var = yytext [ 0 ] ; return VARIABLE; } [ 0 - 9 ] + { yylval.dval = atof(yytext) ; return NUMBER; } \" [ ^\" ] * \" { yylval.str = strdup(yytext) ; return STRING; } [ \t ] ; /* ignore whitespace */ \n { return '\n' ; } = { return '=' ; } . { return yytext [ 0 ] ; } % % int yywrap() { return 1 ...
Read more