System Programming and Operating Systems Lab

ASSIGNMENT A2

1 Aim:
Implement Pass-2 of two pass assembler for pseudo-machine in Java using object oriented features.

2 Objectives:
To implement Pass-2 of two pass assembler for pseudo-machine in Java.

3 Theory:
Assembly Language is a low-level programming language which is used for a computer or other
programmable devices. There is a very strong correspondence between the assembly language and
the architectures machine code instructions.

Every assembly language is system specific i.e, it is unique for every individual system that it
operates on which is exactly opposite to the high-level languages where the language is portable
from device to device. but require interpreting or compiling.

An assembler is a translator, that translates an assembler program into a conventional ma-

chine language program. Basically, the assembler goes through the program one line at a time
and generates machine code for that instruction. Let us see two pass assemblers

It requires all data symbols to be defined prior to being used. A two-pass assembler solves this
dilemma by devoting one pass to exclusively resolve all (data/label) forward references and then
generate object code with no hassles in the next pass. If a data symbol depends on another and
this another depends on yet another, the assembler resolved this recursively. If I try explaining
even that in this post, the post will become too big.

Data structure required in pass 2 assembler

Intermediate file
Output file
MNT

1
MDT
MNT Pointer
MDT Pointer
Line Pointer
Actual v/s positional parameter list array
4 Algorithm:
1. Assumptions
a]Macro call within macro definition
b]Early expansion method
c]Any depth of nesting is permitted
d]Static allocation is used

2. Step1:
a]Set MNT pointer and MDT pointer to start of respective tables
b]Open source file in read mode and target file in write mode
c]Set macro definition flag (d) = 0 and macro expansion flag (e) = 0
d]Initialize formal v/s positional parameter list actual v/s positional parameter list
e]Set error-flag OFF

3. Step 2:
a]Read a line of text from the source file till EOF() or visit a keyword END.
b]If EOF() or a keyword END has occurred then GOTO step 4, else GOTO step 3

4. Step 3:
a]Case d = 0, e = 0
b]Case d = 1, e = 0
c]Case d = 0, e = 1
d]Case d = 1, e = 1

A]
a]Read a line
b]If line contains MACRO DEFINITION then d=1 and goto case d=1, e=0
c]If line contains MACRO CALL then e=1 and goto case d=0, e=1
d]If line contains neither MACRO DEFINITION nor MACRO CALL then write into target
file
e]Goto step 2

B]
a]Validate macro signature in MNT
b]If duplicate macro,
-display err-massage
-set error-flag = ON
c]Goto step 2
d]Otherwise
-make entries in MNT
-create formal v/s positional parameter list
-make entries in MDT
e]If MACRO CALL,
-set e = 1
 f]goto Case d = 1, e =1
g]If MEND, set d = 0
h]Goto step 2

C]
a]If normal MACRO CALL, search in MNT
b]If NOT FOUND
-disp-error Call to macro without definition
-set error-flag = ON
c]Else
-Prepare actual v/s positional parameter list
-Read lines from MDT till MEND
-Replace positional parameter with actual
-Write the line into the target file
d]When MEND occures
-Set e = 0
-Goto step 2

D]
a]Macro call inside a macro definition
b]Validate macro signature in MNT
c]If macro name not found,
-Display err-massage call to a macro which is not defined
-Set error-flag = ON
-Set d = 1 and e = 0
-Goto step 2
d]Else
e]Save current position of source file
f]Expand macro call with the help of MDT
g]Prepare formal v/s positional parameter list
h]Prepare actual v/s positional parameter list
i]If MEND
-Set e = 0
j]Goto case d = 1, e =0

5. Step 4:
If ( d = 0 AND e = 0) AND error-flag = OFF
display Successful macro processing
Else
Display-error Unsuccessful macro processing

6. End
5 Flowchart:

5
6 Code:

packag e macropass2n ;

i mpo rt j a v a . i o . ∗ ;
i mpo rt j a v a . l a n g . S t r i n g ;
i mpo rt j a v a . u t i l . S c anne r ;

p u b l i c c l a s s MacroPass2N {
p u b l i c s t a t i c v o i d main ( S t r i n g [ ] a r g s ) thro w s E x c e p ti o n
{
F i l e f=new F i l e ( ” program . t x t ” ) ;
S c anne r s=new S c anne r ( f ) ;

S t r i n g [ ] to k e n s , m a c r o a r g s ; // Array f o r s t o r i n g t o k e n s g e n
b o o l e a n i s m a c r o=f a l s e ;
w h i l e ( s . has N e x tL i ne ( ) )
{
t o k e n s=s . n e x t L i n e ( ) . s p l i t ( ” ” ) ; // s p l i t th e l i n e on s p a c e

f o r ( i n t i =0; i <t o k e n s . l e n g t h ; i ++)

{
i s m a c r o=c h e c k i f m a c r o ( t o k e n s [ i ] ) ;
i f ( i s m a c r o==t r u e )
{
m a c r o a r g s=t o k e n s [ i + 1 ] . s p l i t ( ” , ” ) ;
expand ( t o k e n s [ i ] , m a c r o a r g s ) ;
// System . out . p r i n t l n ( t o k e n s [ i ]+” ”+m a c r o a r g s [ 0 ] + ” ”+m

}
else
{
if(!tokens[i].contains(”,”))
System . out . p r i n t l n ( t o k e n s [ i ] ) ;
}
}

System . out . p r i n t l n ( ) ;

s.close();

6
s t a t i c v o i d expand ( S t r i n g macro name , S t r i n g [ ] m a c r o a r g s ) thro w s Fi l e N o
{
F i l e f 1=new F i l e ( ” c o n t e n t s . t x t ” ) ;
S c anne r s 1=new S c anne r ( f 1 ) ;

String [ ] t oke ns a rr ;
w h i l e ( ! s 1 . n e x t L i n e ( ) . c o n t a i n s ( ”MDT: ” ) )
s1 . nextLine ( ) ;
w h i l e ( ! s 1 . n e x t L i n e ( ) . c o n t a i n s ( macro name ) )
continue ;

S t r i n g d e f =””;
w h i l e ( ! d e f . c o n t a i n s ( ”MEND” ) )
{
d e f=s 1 . n e x t L i n e ( ) ;

d e f= d e f . r e p l a c e (”#0” , m a c r o a r g s [ 0 ] ) ;
d e f=d e f . r e p l a c e (”#1” , m a c r o a r g s [ 1 ] ) ;
i f ( ! d e f . c o n t a i n s ( ”MEND” ) )
System . out . p r i n t l n ( d e f ) ;
}

s t a t i c b o o l e a n c h e c k i f m a c r o ( S t r i n g to k e n ) thro w s Fi l e N o tFo und Ex c e pti o

{

F i l e f 1=new F i l e ( ” c o n t e n t s . t x t ” ) ;
S c anne r s 1=new S c anne r ( f 1 ) ;

String [ ] t oke ns a rr ;

w h i l e ( ! s 1 . n e x t L i n e ( ) . c o n t a i n s ( ”MNT: ” ) )
s1 . nextLine ( ) ;
w h i l e ( s 1 . has N e x tL i ne ( ) )
{
t o k e n s a r r=s 1 . n e x t L i n e ( ) . s p l i t ( ” ” ) ;
f o r ( i n t i =0; i <t o k e n s a r r . l e n g t h ; i ++)
{
i f ( t o k e n s a r r [ i ] . e q u a l s ( to k e n ) )
{
s1.close();

return true;
}
 }

s1.close();
return f a l s e ;

7 Conclusion:
In this assignment we learn in detail the concept and working of Pass-2 of two pass assembler.