C++ Programming Blog

 
 
 
#include<iostream.h>
#include<conio.h>
#include<string.h>
#include<fstream.h>
#include<stdlib.h>

enum boolean{FALSE,TRUE};
struct mnemonics
{       char statement[10];
    char stat_class[3];
    int  no_or_routine;
    int length;
};
struct symtab           // symbol table
{       char symbol[8];
    int address;
    int length;
};
struct littab        // litral tab
{       char litrel[10];
    int address;
};

struct pooltab   // pool table
{ int no;
};
/////////////////////////////////////////////////////////////////
//////Structure that used to differenciate the instruction
//////////////////////////////////////////////////////////////////

struct instruction
{       char label[15];
    char opcode[10];
    char operand1[10];
    char operand2[10];
};
//////////////////////////////////////////////////////////////////
////////////////////FUNCTIONS////////////////////////////////////
void initalize_tables(mnemonics*);   // for initalize table
void differenciate_instruction(char*,instruction*); //for dividing instrucgtion
boolean checkinstruction(char*,char*,int*,int*); // check validity of instruction
void insertlabel(char*,int *); // function to insert the label in symbol table or inquiry
void processequ(char*,char*); // function to process EQU
void processdc(char*,int);  // function to process DC
void processds(char*,int,int); // function to process DS
void processltorg();  // function to process LTORG
processimp(char*,char*,char*,int); // functio to process imperativer statement
int validcondition(char*);  // check for valid condition
int validregister(char*);  // check for valid  register

//////////////////// Global declaration//////////////////////////////////
    mnemonics  optab[18];
    symtab  stab[31];
    pooltab ptab[31];
    littab  ltab[31];
    int symtab_cntr=0;
    int loc_cntr=0;
    int pooltab_ptr=0;
    int littab_ptr=0;
///////////////////////////////////////////////////////////////////
///////////MAIN PROGRAM////////////////////////////////////////////
///////////////////////////////////////////////////////////////////
int main()
{
    clrscr();
    fstream in_file;
    boolean flag;
    char one_line[80],i_class[3];
    instruction fetched;
    int i_no,i_length,dummy;
    clrscr();

    // calling function and/or initalize tables
    ptab[pooltab_ptr++].no=0;
    initalize_tables(optab);
    in_file.open(\"source.asm\",ios::in);

    // reading from the file
       while(!in_file.eof())
       {

        in_file.getline(one_line,80);
        differenciate_instruction(one_line,&fetched);
       // checking the validity for instruction and fetching
       // parameter as well
        flag = checkinstruction(fetched.opcode,i_class,&i_no,&i_length);
        if(flag==FALSE)
        { cout<<\"\\nInvalid Instruction \"; exit(0);
        }

        // if END instruction encounter
        if(strcmp(fetched.opcode,\"END\")==0)
        {
          processltorg();
          cout<<\"\\n\"<<\"(AD 2)\";
          break;
        }
       // login start from here
       //(a)  if label exists then
         if(strcmp(fetched.label,\"\")!=0)
         {
         insertlabel(fetched.label,&dummy);
         }
       //(B) if LTORG statement

         if(strcmp(fetched.opcode,\"LTORG\")==0)
         {
         processltorg();
         }
        //(C) if START or ORIGIN statement
        else if(strcmp(fetched.opcode,\"START\")==0 ||strcmp(fetched.opcode,\"ORIGIN\")==0)
         {
             if(strcmp(fetched.opcode,\"START\")==0)
             cout<<\"(AD  \"<<1<<\" ) \"<<\"   \"<<
                \"(C  \"<<atoi(fetched.operand1)<<\" ) \";
             loc_cntr=atoi(fetched.operand1);
         }
        else if(strcmp(fetched.opcode,\"EQU\")==0)
         {
         processequ(fetched.label,fetched.operand1);
         }
        //(E) id Declarative statement exits then
        else if(strcmp(i_class,\"DL\")==0)
         {
           if(strcmp(fetched.opcode,\"DS\")==0)
           processds(\"DS\",i_no,atoi(fetched.operand1));
           else
           processdc(one_line,i_no);
         }
       // (F) when imperative statement then
       else if(strcmp(i_class,\"IS\")==0)
       {
       processimp(fetched.opcode,fetched.operand1,fetched.operand2,i_no);
       loc_cntr++;
       }

    }// thile loop

    getch();
    // prinring table
    cout<<\"\\n\\n\\n\";
    for(int i=0;i<symtab_cntr;i++)
    {cout<<endl<<stab[i].symbol<<\"   \"<<stab[i].address;
    }
    cout<<\"\\n\\n\\n\";
    for(i=0;i<littab_ptr;i++)
    {cout<<endl<<ltab[i].litrel<<\"   \"<<ltab[i].address;
    }
    cout<<\"\\n\\n\\n\";
    for(i=0;i<pooltab_ptr;i++)
    {cout<<endl<<ptab[i].no;
    }
    getch();
    return 0;
}// main ends
////////////////////////////////////////////////////////////////////
////FUNCTIONS
/////////////////////////////////////////////////////////////////////
void initalize_tables(mnemonics *m)
{
    // for declarative statement
    strcpy(m[0].statement,\"STOP\");
    strcpy(m[1].statement,\"ADD\");
    strcpy(m[2].statement,\"SUB\");
    strcpy(m[3].statement,\"MULT\");
    strcpy(m[4].statement,\"MOVER\");
    strcpy(m[5].statement,\"MOVEM\");
    strcpy(m[6].statement,\"COMP\");
    strcpy(m[7].statement,\"BC\");
    strcpy(m[8].statement,\"DIV\");
    strcpy(m[9].statement,\"READ\");
    strcpy(m[10].statement,\"PRINT\");
    for(int i=0;i<11;i++)
    {m[i].length=1;
    strcpy(m[i].stat_class,\"IS\");
    m[i].no_or_routine=i;
    }
    // for assembler directive
    strcpy(m[11].statement,\"START\");
    strcpy(m[12].statement,\"END\");
    strcpy(m[13].statement,\"ORIGIN\");
    strcpy(m[14].statement,\"EQU\");
    strcpy(m[15].statement,\"LTORG\");
    for(i=11;i<16;i++)
    {m[i].length=1;
    strcpy(m[i].stat_class,\"AD\");
    m[i].no_or_routine=i-10;
    }
    // declarative statement
    strcpy(m[16].statement,\"DC\");
    m[16].length=1;
    strcpy(m[16].stat_class,\"DL\");
    m[16].no_or_routine=1;
    strcpy(m[17].statement,\"DS\");
    m[17].length=1;
    strcpy(m[17].stat_class,\"DL\");
    m[17].no_or_routine=2;
}

void differenciate_instruction(char *s,instruction *instruct)
{
    int i=0,j=0,counter=1;
    char word[20],c;
    // default setting
    *instruct->opcode=NULL;
    *instruct->operand1=NULL;
    *instruct->operand2=NULL;
        while(s[j]!=NULL)    // 0 loop
        {
              i=0;
              while(s[j]!=\' \'&& s[j]!=NULL)   // differencate words
              {word[i]=s[j];i++; j++;}
              word[i]=NULL;
              while(s[j]==\' \')   // removing extra space
              j++;
            // placing the word in the structure
            if(counter==1)
            {
             if(s[0]==32)
             strcpy(instruct->label,NULL);
             else
             strcpy(instruct->label,word); counter++;
            }
            else if(counter==2)
            { strcpy(instruct->opcode,word); counter++;}
            else if(counter==3)
            { strcpy(instruct->operand1,word); counter++;}
            else
            { strcpy(instruct->operand2,word); counter++;}
               // 0 loop over
          }
}


// check validity of the opcode
boolean checkinstruction(char *opcode,char *i_class,int *i_no ,int *i_length )
{

    for(int i=0;i<18;i++)
    {
     if(strcmp(optab[i].statement,opcode)==0)
     break;
    }
    if(i>17)
    return FALSE;
    strcpy(i_class,optab[i].stat_class);
    *i_no = optab[i].no_or_routine;
    *i_length=optab[i].length;
    return TRUE;
}

// insert label in the symbol table
void insertlabel(char *label,int *located_at)
{
    /// checking wether the symbol already exist or not
    for(int i=0;i< symtab_cntr;i++)
    {
     if(strcmp(stab[i].symbol,label)==0)
     break;
    }

    if(i< symtab_cntr)
    {
    *located_at=i+1;
    return;
    }
    strcpy(stab[symtab_cntr].symbol,label);
    stab[symtab_cntr].address = loc_cntr;
    *located_at=symtab_cntr+1;
    symtab_cntr++;
}

void processds(char *s,int i_no,int length)
{
    cout<<\"\\n\"<<\"( DS \"<<i_no<<\" )\"<<\"   \"
    <<\"( C , \"<<length<<\" )\";
    loc_cntr=loc_cntr+length;
}


// processing DC statement
void processdc(char *s,int i_no)
{
    int i=0,j;
    char word[5];
    while( s[i]!=\'D\'&&s[i+1]!=\'C\')
    i++;
    i=i+2;
    while(s[i]==\' \')    // space ate
    i++;
        while(s[i]!=NULL)
        {
            j=0;
            while(s[i]!=\' \' && s[i]!=NULL)
            {
                if(s[i]!=\'=\')
                { word[j]=s[i];j++;}
                i++;
            }
            word[j]=NULL;
            while(s[i]==\' \')    // space ate
            i++;
            cout<<\"\\n\"<<\"( DC \"<<i_no<<\" )\"<<\"   \"
            <<\"( C , \"<<atoi(word)<<\" )\";
            loc_cntr++;
        }

}
// processing EQU statement

void processequ(char *source, char *desti)
{          int located_at,address;
    insertlabel(desti,&located_at);
    address = stab[located_at].address;
    insertlabel(source,&located_at);
    stab[located_at].address=address;
}
processimp(char *opcode,char *operand1,char *operand2,int i_no)
{
    int i=validregister(operand1);
    int j=validcondition(operand1);
    int located_at;
    char s[20];
    cout<<endl<<\"(IS \"<<i_no<<\" )\";
    if(strcmp(operand1,\"\")!=0)
    {
        if(i!=0)         // valid register
        cout<<\" ( \"<<i<<\" ) \";
        else if(j!=0)   //  valid condition
        cout<<\" ( \"<<j<<\" ) \";
        else          // symbol
        {
        insertlabel(operand1,&located_at);
        cout<<\"( S \"<<located_at<<\") \";
        }
    }
    // because PRINT and READ has only one operand
    if(strcmp(operand2,\"\")!=0)
    {
             i=validregister(operand2);
         if(i!=0)         // valid register
             cout<<\" ( \"<<i<<\" ) \";
         else if(operand2[0]!=\'=\')         // symbol
         {   insertlabel(operand2,&located_at);
             cout<<\"( S \"<<located_at<<\"  ) \";
         }
          else       // litrel
          {
            for(int k=1;k<strlen(operand2);k++)
            s[k-1]=operand2[k];
            s[k-1]=NULL;
            strcpy(ltab[littab_ptr].litrel,s);
            ltab[littab_ptr++].address=0;
             cout<<\"( L \"<<littab_ptr<<\" ) \";

         }
    }
}

// this are the valid register
int validregister(char *s)
{ if(strcmp(s,\"AREG\")==0)
  return 1;
  else if(strcmp(s,\"BREG\")==0)
  return 2;
  else if(strcmp(s,\"CREG\")==0)
  return 3;
  else if(strcmp(s,\"DREG\")==0)
  return 4;
  else if(strcmp(s,\"EREG\")==0)
  return 5;
  else
  return 0;
}
// these are the valid conditions
int validcondition(char *s)
{ if(strcmp(s,\"LT\")==0)
  return 1;
  else if(strcmp(s,\"LE\")==0)
  return 2;
  else if(strcmp(s,\"EQ\")==0)
  return 3;
  else if(strcmp(s,\"GT\")==0)
  return 4;
  else if(strcmp(s,\"GE\")==0)
  return 5;
  else if(strcmp(s,\"ANY\")==0)
  return 6;
  else
  return 0;
  }
  // processing LTORG statement
void processltorg()
{
    for(int i= ptab[pooltab_ptr-1].no;i<littab_ptr;i++)
    {
       cout<<endl<<\"\\n\"<<\"( DC \"<<1<<\" )\"<<\"   \"
       <<\"( C , \"<<atoi(ltab[i].litrel)<<\" )\";
       ltab[i].address=loc_cntr+1;
       loc_cntr++;
    }
    ptab[pooltab_ptr++].no=littab_ptr;
}

 
 
Didn't find what you were looking for? Find more on Program pf parser 1