0
#include
#include
#include
void main()
{
char opcode[10],operand[10],label[10],code[10][10],ch;
char mnemonic[10][10]={"START","LDA","STA","LDCH","STCH","END"};
int locctr,start,len,i=0,j=0;
FILE *fp1,*fp2,*fp3;
clrscr();
fp1=fopen("INPUT.DAT","r");
fp2=fopen("SYMTAB.DAT","w");fp3=fopen("OUT.DAT","w");
fscanf(fp1,"%s%s%s",label,opcode,operand);
if(strcmp(opcode,"START")==0)
{
start=atoi(operand);
locctr=start;
fprintf(fp3,"%s\t%s\t%s\n",label,opcode,operand);
fscanf(fp1,"%s%s%s",label,opcode,operand);
}
else
locctr=0;
while(strcmp(opcode,"END")!=0)
{
fprintf(fp3,"%d",locctr);
if(strcmp(label,"**")!=0)
fprintf(fp2,"%s\t%d\n",label,locctr);
strcpy(code[i],mnemonic[j]);
while(strcmp(mnemonic[j],"END")!=0)
{
if(strcmp(opcode,mnemonic[j])==0)
{
locctr+=3;
break;
}
strcpy(code[i],mnemonic[j]);
j++;
}
if(strcmp(opcode,"WORD")==0)
locctr+=3;
else if(strcmp(opcode,"RESW")==0)
locctr+=(3*(atoi(operand)));
else if(strcmp(opcode,"RESB")==0)
locctr+=(atoi(operand));
else if(strcmp(opcode,"BYTE")==0)
++locctr;
fprintf(fp3,"\t%s\t%s\t%s\n",label,opcode,operand);
fscanf(fp1,"%s%s%s",label,opcode,operand);
}
fprintf(fp3,"%d\t%s\t%s\t%s\n",locctr,label,opcode,operand);
fcloseall();
printf("\n\nThe contents of Input Table :\n\n");
fp1=fopen("INPUT.DAT","r");
ch=fgetc(fp1);
while(ch!=EOF)
{
printf("%c",ch);
ch=fgetc(fp1);
}
printf("\n\nThe contents of Output Table :\n\n\t");
fp3=fopen("OUT.DAT","r");
ch=fgetc(fp3);
while(ch!=EOF)
{
printf("%c",ch);
ch=fgetc(fp3);
}
len=locctr-start;
printf("\nThe length of the program is %d.\n\n",len);
printf("\n\nThe contents of Symbol Table :\n\n");
fp2=fopen("SYMTAB.DAT","r");
ch=fgetc(fp2);
while(ch!=EOF)
{
printf("%c",ch);
ch=fgetc(fp2);
}
fcloseall();
getch();
}
INPUT FILE:
INPUT.DAT
** START 2000
** LDA FIVE
** STA ALPHA
** LDCH CHARZ
** STCH C1
ALPHA RESW 1
FIVE WORD 5
CHARZ BYTE C'Z'
C1 RESB 1
** END **
-Fabianski Benjamin
What else can I help you with?
Use of two pass assembler?
A two-pass assembler reads through the source code twice. Each read-through is called a pass. On pass one the assembler doesn't write any code. It builds up a table of symbolic names against values or addresses. On pass two, the assembler generates the output code, using the table to resolve symbolic names, enabling it to enter the correct values. The advantage of a two-pass assember is that it allows forward referencing in the source code because when the assembler is generating code it has already found all references.
What is the output of the parser from a compiler?
The output of an assembler is a part or all of a product. An assembler can work in a variety of manufacturing operations with the right training.
What is the Design of single pass assembler?
Single Pass Assembler A single pass assembler scans the program only once and creates the equivalent binary program. The assembler substitute all of the symbolic instruction with machine code in one pass. AdvantagesEvery source statement needs to be processed once.DisadvantagesWe cannot use any forward reference in our program. Forward ReferenceForward reference means; reference to an instruction which has not yet been encountered by the assembler. In order to handle forward reference, the program needs to be scanned twice. In other words a two pass assembler is needed.
What is multi pass assembler?
multipass assembler means more than one pass is used by assembler.multipass assembler is used to eliminate forward references in sybol definition.it creates a number of passes that is necessary to process the definition of symbols•Multi pass assembler:-Does the work in two pass-Resolves the forward references•First pass:-Scans the code-Validates the tokens-Creates a symbol table•Second Pass:-Solves forward references-Converts the code to the machine code
Assembler design options?
Two main options for the design of assembler are: 1. One pass assembler 2. Multi-pass assembler One pass assemblers generally have problem of "forward referencing" which is resolved by using mulitpasses
What is the difference between one pass and two pass assembler?
The difference between one pass and two pass assemblers is basically in the name. A one pass assembler passes over the source file exactly once, in the same pass collecting the labels, resolving future references and doing the actual assembly. The difficult part is to resolve future label references and assemble code in one pass. A two pass assembler does two passes over the source file ( the second pass can be over a file generated in the first pass ). In the first pass all it does is looks for label definitions and introduces them in the symbol table. In the second pass, after the symbol table is complete, it does the actual assembly by translating the operations and so on.
What is pass1 assembler?
pass 1 assembler is assembler which convert assembly level language into machine level language in one pass only
Advantages of one pass assembler over two pass assembler?
In theory the only advantage is Speed simply because one pass is faster than two passes. However a properly written two pass assembler can be faster than a poorly written one pass assembler because the two pass assembler spends alot less time doing memory intensive lookups, look-aheads, and back-tracking.
Is there any programming language that does not use compiler or interpreter?
Not really. You need some program to interpret your source code. There is the "assembler", but that can be thought of as a simpler version of a compiler - simpler, because the assembler basically just converts the source code instructions one-to-one to machine instructions.
What is forward reference in one pass assembler?
When one pass assembler constructing the object code, if it finds usage of the variables before the declaration then forward reference problem will occur. To avoid forward reference problem: i) Declare the symbols before using it ii) Use more than one pass assembler(multi pass assembler)
What is the Difference between assembler and macro?
I am not sure about the answer but think so, Assembler: Its a program that converts a low level language into machine code, and there is a one-to-one correspondence between the source language statements and machine instructions Macro- Assembler: It performs the same task as does the assembler but there is some times a one-to-many correspondence between the source language statements and machine instructions. Please discuss further...
Explain the working of two pass assembler with an example Draw the flowchart of two pass assembler also?
Pass One: Read the source code and build the symbol table. Pass Two: Read the source code again and generate the object code. Both passes do pretty much the same things; parsing, tokenizing, processing expressions, etc. The difference is that in pass one you do not know "a priori" what the type, offset, and size of objects are that you have not yet encountered, so you must do the assembly in two passes. You can assemble in one pass if you constrain the coder to define symbols before they are referenced.
