A Lex program to generate tokens of a subset of input Java program

Inputs

javatoken.txt

import java.sql.*;
class Hello{
public static void main(String args[]){
    System.out.println("HI");
    //printing
}
}

javatoken.l

 %{
    #include<stdio.h>
%}

DATATYPE int|char|bool|float|double|String
SC [;]
DOTOP [.]
OPERATOR "+"|"-"|"/"|"*"|"="
UNARY "++"|"--"
IDENTIFIER [a-zA-Z]+[a-zA-Z0-9]*
COMMENT "//"[a-zA-Z0-9]*
PREPROCESSOR "import"[a-zA-Z0-9 "." "*"]*
KEYWORD public|static|void|main|abstract|class
BLOCK_S "{"
BLOCK_E "}"
BRACKET ")"|"("
STRING "\""[a-zA-Z0-9]*"\""

%%
{DOTOP} {printf("");}
{BRACKET} {printf("\n %s: bracket",yytext);}
{DATATYPE} {printf("\n %s: datatype",yytext);}
{SC} {printf("\n %s: semi colon \n",yytext);}
{OPERATOR} {printf("\n %s: operator \n",yytext);}
{UNARY} {printf("\n %s: unary \n",yytext);}
{BLOCK_S} {printf("\n %s: block start",yytext);}
{BLOCK_E} {printf("\n %s: block end",yytext);}
{COMMENT} {printf("\n %s: comment",yytext);}
{PREPROCESSOR} {printf("\n %s: preprocessor",yytext);}
{KEYWORD} {printf("\n %s: keyword",yytext);}
{STRING} {printf("\n %s: string",yytext);}
{IDENTIFIER} {printf("\n %s: identifier",yytext);}
%%
int yywrap(){
    return (1);
}
main(){
    yyin=fopen("javatoken.txt","r");
    yylex();
    return 0;
}

Commands to run a file with '.l' extension

1) lex filename.l

2) gcc lex.yy.c

3) ./a.out

Output 

A Lex program to count number of words, lines and characters of given input file.

Input: file.txt

hi
HELLO
how are you

wordcount.l

%{
    #include<stdio.h>
    int cletter=0,sletter=0,lines=0,spaces=0,num=0,chara=0,words=0;
%}

%%
[\t ' ']+ {words++; spaces++; chara=chara+yyleng;}
\n  {lines++; words++;}
[A-Z] cletter++;
[a-z] sletter++;
[0-9] num++;
%%

main(){
    yyin=fopen("file.txt","r");
    yylex();
    printf("FILE HAS \n");
    printf("%d spaces",spaces);
    printf("\n");
    printf("%d words",words);
    printf("\n");
    printf("%d characters",chara);
    printf("\n");
    printf("%d  numbers",num);
    printf("\n");
    printf("%d  upper case letters",cletter);
    printf("\n");
    printf("%d  lower case letters",sletter);
    printf("\n");
    printf("%d  lines",lines);
    return 0;
}

int yywrap(){
    return (1);
}

Output

 

A Java program for pass-II of a two-pass macro-processor. The output of Macro pass one preprocessor (MNT, MDT) is input for this program.

A Java Program for Macro Pass Two Preprocessing

//===============================================
// Name        : PassTwo.java
// Author      : Rucha Tambe
// Version     :
// Copyright   : Your copyright notice
// Description : Pass Two Preprocessor in Java
//================================================

 PassTwo.java

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;


public class PassTwo {

    ArrayList<mntf> mnt = new ArrayList<>();
    ArrayList<String>mdt = new ArrayList<>();
    HashMap<String, ArrayList<String>> pntab = new HashMap<>();
    ArrayList<String>kptab = new ArrayList<>();
    PassOne p;
    public PassTwo() throws Exception {
        p = new PassOne();
        p.PassOne();
        mnt = p.mnt;
        mdt = p.mdt;
        pntab = p.pntab;
        kptab = p.kptab;
       
    }
   
    void passtwo() throws IOException{
        BufferedReader br = new BufferedReader(new FileReader("input1.asm"));
        String line = "";
       
        int flag=0;
        while((line=br.readLine())!=null){
            String[] split = line.split("\\s+");
            if(split[1].equals("START")){
                flag=1;
            }
            if(flag==1){
                if(pntab.containsKey(split[1])){
                    ArrayList<String> apt = new ArrayList<>();
                   
                    int index = getIndexMnt(split[1]);
                    int kpdtp = mnt.get(index).getKpdtp();
                    //fill default values
                   
                    int pp = mnt.get(index).getPp();
                    int kp = mnt.get(index).getKp();
                    int i=0;
                    for(i=0;i<pp;i++){
                        apt.add("0");
                    }
                    int j=0;
                    for(i=pp;i<pp+kp;i++){
                        String kpara = kptab.get(kpdtp+j);
kpara=kpara.substring(kpara.indexOf("=")+1,kpara.length()).replace(",","");
                       
                        if(kpara.length()>1){
                            apt.add(kpara);
                        }else{
                            apt.add("0");
                        }
                        j++;
                    }
                   
                    int k=2,l=0;
                    while(k<split.length){
                        if(l<pp){
                            apt.remove(l);
                            apt.add(l,split[k].replace(",", ""));
                        }else{
                          String para =  split[k].substring(split[k].indexOf("&")+1,split[k].indexOf("="));
                            String value = split[k].substring(split[k].indexOf("=")+1,split[k].length()).replace(",", "");
                           
                  int in = pntab.get(split[1]).indexOf(para);
                            apt.remove(in);
                            apt.add(in,value);
                        }
                        l++;
                        k++;
                    }
                   
                    int mdtp = mnt.get(index).getMdtp();
                   
                    while(true){
                        String inst = mdt.get(mdtp);
                        if(inst.contains("MEND")){
                            break;
                        }
                       
                        String[] sp = inst.split("\\s+");
                       
                        k=1;
                        while(k<sp.length && sp[k].contains("P")){
                             String val =  apt.get(Integer.parseInt(sp[k].substring(sp[k].indexOf(",")+1,sp[k].indexOf(")"))));
                             sp[k] = val;
                             k++;
                        }
                        System.out.println(sp[0]+" "+sp[1]+" "+sp[2]);
                        mdtp++;
                    }
                    System.out.println("APTAB:");
                    for(i=0;i<apt.size();i++){
                        System.out.println(apt.get(i));
                    }
                }
            }
        }
    }
   
    public int getIndexMnt(String mn){
        int temp=0;
        while(!mnt.get(temp).getName().equals(mn)){
            temp++;
        }
        return temp;
    }
    public static void main(String[] args) throws Exception {
        PassTwo p = new PassTwo();
        p.passtwo();
    }

} 

Output 

MOVER AREG 10
ADD AREG ='1'
MOVER CREG 20
ADD CREG ='5'
APTAB:
10
20
AREG
CREG
MOVER BREG 100
MOVER AREG 200
ADD BREG ='15'
ADD AREG ='10'
APTAB:
100
200
BREG
AREG

Design suitable data structures and implement pass-I of a two-pass macro-processor in Java

A Java Program for Macro Pass One Preprocessor

//===============================================
// Name        : PassOne.java
// Author      : Rucha Tambe
// Version     :
// Copyright   : Your copyright notice
// Description : Macro Pass One Assembler in Java
//================================================

Inputs

input1.asm

    MACRO
    M1    &X, &Y, &A=AREG, &B=
    MOVER    &A, &X
    ADD    &A, ='1'
    MOVER    &B, &Y
    ADD    &B, ='5'
    MEND
    MACRO
    M2    &P, &Q, &U=CREG, &V=DREG
    MOVER    &U, &P
    MOVER    &V, &Q
    ADD    &U, ='15'
    ADD    &V, ='10'
    MEND
    START    100
    M1    10, 20, &B=CREG   
    M2    100, 200, &V=AREG, &U=BREG
    END 

PassOne.java 

import java.io.*;
import java.util.*;


public class PassOne {

    static ArrayList<mntf> mnt = new ArrayList<>();
    static ArrayList<String>mdt = new ArrayList<>();
    static HashMap<String, ArrayList<String>> pntab = new HashMap<>();
    static ArrayList<String>kptab = new ArrayList<>();
   
    static void PassOne() throws Exception{
       
        BufferedReader br = new BufferedReader(new FileReader("input1.asm"));
        String line = "";
        while((line = br.readLine()) != null)
        {
            String split[] = line.split("\\s+");
            if(split[1].equals("MACRO")){
               
                ArrayList<String> pnt = new ArrayList<>();
                line = br.readLine();
                int k = 2,pp=0,kp=0;
               
                String sp[] = line.split("\\s+");
                mntf mn = new mntf();
                mn.name = sp[1];
                mn.kpdtp = kptab.size();
                mn.mdtp = mdt.size();
                //System.out.println();
                while(k < sp.length){
                    String s = "";
                    if(sp[k].contains("=")){
                        //Keyword parameter present
      s = sp[k].substring(sp[k].indexOf("&")+1,sp[k].indexOf("="));
                        kptab.add(sp[k]);
                        kp++;
                       
                    }else{
                        //Positional Parameter present
         s = sp[k].substring(sp[k].indexOf("&")+1,sp[k].indexOf(","));
                   
                        pp++;
                    }
                    pnt.add(s);
                    //System.out.println(s);
                    k++;
                }
                //Setting the macro and putting it in pntab
               
                mn.setKp(kp);
                mn.setPp(pp);
                mnt.add(mn);
                pntab.put(mn.name,pnt);
                //Reading macro and putting the definition in mdt
                while((line = br.readLine())!=null){
                    String s = "";
                    String def[] = line.split("\\s+");
                    if(def[1].equals("MEND")){
                         mdt.add("MEND");
                         break;
                    }
                   
                    s = def[1]+" ";
                    k=2;
                    while(k < def.length){
                        if(def[k].contains("&")){
           s += "(P,"+ pnt.indexOf(def[k].replace("&", "").replace(",",""))+")    ";
                           
                        }else{
                             s += def[k];
                           
                        }
                        k++;
                    }
                    mdt.add(s);
                }
            }
           
        }
        print();
    }
    public static void print() {
        for(int i=0;i<mnt.size();i++) {
            mntf m = mnt.get(i);
            //System.out.println(m.getName()+" "+m.getKp()+" "+m.getPp()+" "+m.getKpdtp()+" "+m.getMdtp());
            ArrayList<String> p = pntab.get(m.getName());
            System.out.println("Pntab for "+m.getName());
            for(int k=0;k<p.size();k++) {
                System.out.println(p.get(k));
            }
        }
        for(int i=0;i<mdt.size();i++) {
            System.out.println(mdt.get(i));
        }
    }
   
    public static void main(String[] args) {
       
        try {
            PassOne();
           
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }

}

Output 

 

Implement Pass Two of two pass assembler for pseudo-machine in Java using object oriented features. The output of pass one assembler (intermediate file and symbol table) should be input for pass two assembler.

A Java Program for Pass Two Assembler

 
//===============================================
// Name        : PassTwo.java
// Author      : Rucha Tambe
// Version     :
// Copyright   : Your copyright notice
// Description : Pass Two Assembler in Java
//================================================

Inputs:

sym.txt

A  100
L1  103
B  109
C  100
D  101
L2  107 

lit.txt

12  106
5  110 

pool.txt

0
1

PassTwo.java

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.util.ArrayList;

public class PassTwo {
    ArrayList<Integer> symaddr=new ArrayList<>();
    ArrayList<String> littab=new ArrayList<>();
    ArrayList<Integer> litaddr=new ArrayList<>();
    ArrayList<Integer> pooltab=new ArrayList<>();

    public void readFile() throws Exception {
        BufferedReader br=new BufferedReader(new FileReader("sym.txt"));
        String line=" ";
        while((line=br.readLine())!=null) {
            String split[]=line.split("\\s+");
            symaddr.add(Integer.parseInt(split[1]));
        }
        BufferedReader br2=new BufferedReader(new FileReader("lit.txt"));
        while((line=br2.readLine())!=null) {
            String split[]=line.split("\\s+");
            littab.add(split[0]);
            litaddr.add(Integer.parseInt(split[1]));
        }

        BufferedReader br3=new BufferedReader(new FileReader("pool.txt"));
        while((line=br3.readLine())!=null) {
            pooltab.add(Integer.parseInt(line));
        }
    }

    public void generateMachineCode() throws Exception {
        String line=" ";
        BufferedReader br=new BufferedReader(new FileReader("ic.txt"));
        int p=0;
        while((line=br.readLine())!=null) {
            String split[]=line.split("\\s+");

            String sp[]=split[0].replace("(","").replace(")", "").split("\\,");

            if(sp[0].equals("DL")) {
                String arr[]=split[1].replace("(", "").replace(")", "").split("\\,");
                System.out.println("+00 0 "+String.format("%03d", Integer.parseInt(arr[1])));
            }

            else if(sp[0].equals("IS")) {
                System.out.print(sp[1]+" ");

                int i=1;
                while(i<split.length) {
                    String arr[]=split[i].replace("(", "").replace(")","").split("\\,");
                    if(arr[0].equals("S")) {
                     
                        System.out.println(symaddr.get(Integer.parseInt(arr[1])));
                    }
                    else if(arr[0].equals("L")) {
                       
                        System.out.println(litaddr.get(Integer.parseInt(arr[1])));
                    }
                    else if(arr[0].equals("C")) {
                       
                        System.out.println((Integer.parseInt(arr[1])));
                    }
                    else {
                        System.out.print(arr[0]+"  ");
                    }
                    i++;
                }
            }
            else if(sp[0].equals("AD") && (sp[1].equals("04") || sp[1].equals("05"))){
                if(sp[1].equals("05")) {
                    for(int i=pooltab.get(p);i<pooltab.get(p+1);i++) {
                        System.out.println("+00 0 "+Integer.parseInt(littab.get(i)));
                    }
                  
                }
                else {
                    for(int i=pooltab.get(p);i<littab.size();i++) {
                        System.out.println("+00 0"+Integer.parseInt(littab.get(i)));
                    }
                }
                p++;
            }
        }

    }


    public static void main(String[] args) throws Exception {
        PassTwo p=new PassTwo();
        p.readFile();
        p.generateMachineCode();
    }
} 

Output

 

Design suitable data structures and implement pass-I of a two-pass assembler for pseudo-machine in Java using object oriented feature. Implementation should consist of a few instructions from each category and few assembler directives.

A Java program for a Pass One Assembler

//===============================================
// Name        : PassOne.java
// Author      : Rucha Tambe
// Version     :
// Copyright   : Your copyright notice
// Description : Pass One Assembler in Java
//================================================

Input to Assembler: input.asm 

    START    100
A    DS    3
L1    MOVEM    AREG,    B
    ADD    AREG,    C
    MOVER    AREG,    ='12'
D    EQU    A+1
    LTORG
L2    PRINT    D
    ORIGIN     A-1
    MOVER    AREG,    ='5'
C     DC     '5'
    ORIGIN    L2+1
    STOP

B    DC    '19'

    END        

PassOne.java

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.util.ArrayList;
import java.util.Hashtable;

public class PassOne {

    Hashtable<String,MnemonicTable> is=new Hashtable<>();
    ArrayList<String>symtab=new ArrayList<>();
    ArrayList<Integer> symaddr=new ArrayList<>();
    ArrayList<String>littab=new ArrayList<>();
    ArrayList<Integer> litaddr=new ArrayList<>();
    ArrayList<Integer>pooltab=new ArrayList<>();
    int LC=0;
    public void createIS() {
        MnemonicTable m=new MnemonicTable("STOP","00", 0);
        is.put("STOP",m);
        m=new MnemonicTable("ADD","01", 0);
        is.put("ADD",m);
        m=new MnemonicTable("SUB","02", 0);
        is.put("SUB",m);
        m=new MnemonicTable("MULT","03", 0);
        is.put("MULT",m);
        m=new MnemonicTable("MOVER","04", 0);
        is.put("MOVER",m);
        m=new MnemonicTable("MOVEM","05", 0);
        is.put("MOVEM",m);
        m=new MnemonicTable("COMP","06", 0);
        is.put("COMP",m);
        m=new MnemonicTable("BC","07", 0);
        is.put("BC",m);
        m=new MnemonicTable("DIV","08", 0);
        is.put("DIV",m);
        m=new MnemonicTable("READ","09", 0);
        is.put("READ",m);
        m=new MnemonicTable("PRINT","10", 0);
        is.put("PRINT",m);
    }
    public void generateIC() throws Exception {
        BufferedWriter wr=new BufferedWriter(new FileWriter("ic.txt"));
        BufferedReader br=new BufferedReader(new FileReader("input.asm"));
        String line=" ";
        pooltab.add(0, 0);
        while((line=br.readLine())!=null) {
           
            String[] split=line.split("\\s+");
            if(split[0].length()>0) {
                //it is a label
                if(!symtab.contains(split[0])) {      
                    symtab.add(split[0]);
                    symaddr.add(LC);     
                }
                else {
                    int index=symtab.indexOf(split[0]);
                    symaddr.remove(index);
                    symaddr.add(index,LC);
                }
            }

            if(split[1].equals("START")) {
                LC=Integer.parseInt(split[2]);
                wr.write("(AD,01)(C,"+split[2]+") \n");
            }
            else if(split[1].equals("ORIGIN")) {
                if(split[2].contains("+") || split[2].contains("-")) {
                    LC=getAddress(split[2]);
                }
                else {
                    LC=symaddr.get(symtab.indexOf(split[2]));
                } 
            }
            else if(split[1].equals("EQU")) {
                int addr=0;
                if(split[2].contains("+") || split[2].contains("-")) {
                    addr=getAddress(split[2]);
                }
                else {
                    addr=symaddr.get(symtab.indexOf(split[2]));
                }
                if(!symtab.contains(split[0])) {
                    symtab.add(split[0]);
                    symaddr.add(addr);
                }
                else {
                    int index=symtab.indexOf(split[0]);
                    symaddr.remove(index);
                    symaddr.add(index,addr);
                }
            }
            else if(split[1].equals("LTORG") || split[1].equals("END")) {
                if(litaddr.contains(0)) {
                    for(int i=pooltab.get(pooltab.size()-1);i<littab.size();i++) {
                        if(litaddr.get(i)==0) {                           
                            litaddr.remove(i);
                            litaddr.add(i, LC);
                            LC++;
                        }                       
                    }
                    if(!split[1].equals("END")) {
                        pooltab.add(littab.size());
                        wr.write("(AD,05) \n");
                    }
                    else
                        wr.write("(AD,04) \n");
                }              
            }
            else if(split[1].contains("DS")) {
                LC+=Integer.parseInt(split[2]);
                wr.write("(DL,01) (C,"+split[2]+") \n");
            }
            else if(split[1].equals("DC")) {
                LC++;
                wr.write("(DL,02) (C,"+split[2].replace("'", "").replace("'", "")+") \n");
            }
            else if(is.containsKey(split[1])) {
                wr.write("(IS,"+is.get(split[1]).opcode+") ");
                if(split.length>2 && split[2]!=null) {
                    String reg=split[2].replace(",","");
                    if(reg.equals("AREG")) {
                        wr.write("(1) ");
                    }
                    else if(reg.equals("BREG")) {
                        wr.write("(2) ");
                    }
                    else if(reg.equals("CREG")) {
                        wr.write("(3) ");
                    }
                    else if(reg.equals("DREG")) {
                        wr.write("(4) ");
                    }
                    else {
                        if(symtab.contains(reg)) {
                            wr.write("(S,"+symtab.indexOf(reg)+") ");
                        }
                        else {
                            symtab.add(reg);
                            symaddr.add(0);
                            wr.write("(S,"+symtab.indexOf(reg)+") ");

                        }
                    }
                }

                if(split.length>3 && split[3]!=null) {
                    if(split[3].contains("=")) {
                        String norm=split[3].replace("=","").replace("'", "").replace("'", "");
                        if(!littab.contains(norm)) {
                            littab.add(norm);
                            litaddr.add(0);
                            wr.write("(L,"+littab.indexOf(norm)+") \n");
                        }
                        else {
                            wr.write("L,"+littab.indexOf(norm)+") \n");
                        }
                       
                    }
                    else if(symtab.contains(split[3])) {
                        wr.write("(S,"+symtab.indexOf(split[3])+")");

                    }
                    else {
                        symtab.add(split[3]);
                        symaddr.add(0);
                        wr.write("(S,"+symtab.indexOf(split[3])+")");

                    }
                }
                LC++;
            }
        }
        wr.flush();
        wr.close();
        BufferedWriter br1=new BufferedWriter(new FileWriter("sym.txt"));
        BufferedWriter br2=new BufferedWriter(new FileWriter("lit.txt"));
        BufferedWriter br3=new BufferedWriter(new FileWriter("pool.txt"));
        //System.out.println("symtab");
        for(int i=0;i<symtab.size();i++)
            br1.write(symtab.get(i)+"  "+symaddr.get(i)+"\n");
       
        //System.out.println("littab");
        for(int i=0;i<littab.size();i++)
            br2.write(littab.get(i)+"  "+litaddr.get(i)+"\n");
       
        for(int i=0;i<pooltab.size();i++)
            br3.write(pooltab.get(i)+"\n");
        br1.flush();
        br2.flush();
        br3.flush();
       
        br1.close();
        br2.close();
        br3.close();
    }

    private int getAddress(String string) {
        int temp=0;
        if(string.contains("+")) {
            String sp[]=string.split("\\+");
            int ad=symaddr.get(symtab.indexOf(sp[0]));
            temp=ad+Integer.parseInt(sp[1]);
        }
        else if(string.contains("-")) {
            String sp[]=string.split("\\-");
            int ad=symaddr.get(symtab.indexOf(sp[0]));
            temp=ad-Integer.parseInt(sp[1]);
        }
        return temp;
    }
    public static void main(String[] args) throws Exception {
        PassOne p=new PassOne();
        p.createIS();
        p.generateIC();
    }
}

Output

ic.txt

(AD,01) (C,100)
(DL,01) (C,3)
(IS,05) (1) (S,2)
(IS,01) (1) (S,3)
(IS,04) (1) (L,0)
(AD,05)
(IS,10) (S,4)
(IS,04) (1) (L,1)
(DL,02) (C,5)
(IS,00)
(DL,02) (C,19)
(AD,04) 

 lit.txt

12  106
5  110 

pool.txt

0
1 

sym.txt

A  100
L1  103
B  109
C  100
D  101
L2  107