Lex and Yacc Calculator code-Lex

%{  
 # include  
 # include "y.tab.h"  
 # include  
 %}  
 %%  
 [0-9]+(\.[0-9]+)? { yylval.dval=atof(yytext);return NUMBER;}  
 [\t] ; /* ignore whitespace */  
 \n {return 0;}  
 . return yytext[0];  
 %%  
 int yywrap(void)  
 {  
   return 1;  
 }

Lex and Yacc Calculator code-Yacc

 

 %{  
 # include  
 # include  
 %}  
 %union  
 {  
   double dval;  
 }  
 %token  NUMBER ;  
 %left '-''+'  
 %left '*''/'  
 %right '^'  
 %type  expr  
 %%  
 result:    
   '='expr   
   |expr {printf("%f",$1);}  
   ;  
 expr:  
   expr'+'expr {$$=$1+$3;}  
   | expr'-'expr {$$=$1-$3;}  
   | expr'*'expr {$$=$1*$3;}  
   | expr'^'expr   {  
       $$=pow($1,$3);}  
   | expr'/'expr {  
     if($3==0)  
       yyerror("devide by zero");  
     else  
       $$=$1/$3;}  
   | '-'expr   {$$=-$2;}  
   | '('expr')' { $$=$2;}  
   | NUMBER {$$=$1;}  
   ;  
 %%  
 void yyerror(char *s)  
 {  
   fprintf(stdout,"%s\n",s);  
 }  
 int main()  
 {  
   yyparse();  
   return 0;  
 }

 

 

Macro Processor Pass Two in C Language

Macro definition and Call Macro Expansion,Design of Macro Processor Definition and expansion processing.Algorithms along with Data structures Nested Macro calls,Call within a call and definition within a definition.

Macro Processor Pass Two Code

 #include  
 #include  
 #include  
 #include  
 FILE *fp;  
 FILE *fp1;  
 FILE *fp2;  
 typedef struct pntab  
 {  
   char par[10];  
 }ptab;  
 typedef struct MNT  
 {  
   char name[10];  
   int nop;  
   int nok;  
   int mdtp;  
   int kpdtp;  
   int noe;  
 }MT;  
 MT mnt[1];  
 ptab pntab[100];  
 /*  
 typedef struct ssntab  
 {  
   char name[50];  
 }ssnt;  
 typedef struct sstab  
 {  
   int val;  
 }sst;  
 sst sstab[50];  
 ssnt ssntab[50];  
 */  
 typedef struct evntab  
 {  
   char name[50];  
 }evnt;  
 evnt evntab[50];  
 typedef struct evtab  
 {  
   int val;  
 }evt;  
 evt evtab[50];  
 typedef struct mdt  
 {  
   char entry[100];  
 }MDT;  
 MDT mdt[100];  
 typedef struct aptab  
 {  
   char value[10];  
 }at;  
 at aptab[100];  
 typedef struct kpdtab  
 {  
   char name[10];  
   char value[10];  
 }ktab;  
 ktab kpdtab[10];  
 void disp_aptab(int len)  
 {  
   printf("\nAPTAB:\n");  
   int i;  
   for(i=0;i<=len;++i)  
   {  
     printf("%d.%s\n",i+1,aptab[i].value);  
   }  
 }  
 void disp_mdt(int len)  
 {  
   printf("MDT:\n");  
   int i=1;  
   while(i<=len)  
   {  
     printf("%d.%s\n",i,mdt[i-1].entry);  
     i++;  
   }  
 }  
 void disp_pntab(int len)  
 {  
   int i;  
   for(i=0;i<=len;++i)  
   {  
     printf("%d.%s\n",i+1,pntab[i].par);  
   }  
 }  
 int search_pntab(char str[],int len)  
 {  
   int i;  
   for(i=0;i<=len;++i)  
   {  
     if(strcmp(str,pntab[i].par)==0)  
     {  
       return i;  
     }  
   }  
   return -1;  
 }  
 void disp_mnt()  
 {  
   printf("\tName\tPP\tKP\tMDTP\tKPDTP\n");  
   printf("\t%s\t%d\t%d\t%d\t%d\n",mnt[0].name,mnt[0].nop,mnt[0].nok,mnt[0].mdtp,mnt[0].kpdtp);  
 }  
 void main()  
 {  
   clrscr();  
   char str[100];  
   int i=0,ptr=-1,j;  
   int nop=0,nok=0,noe=0;  
   fp=fopen("mac.txt","r");  
   if(fp==NULL)  
   {  
     printf("File not found\n");  
     getch();  
     return;  
   }  
   fgets(str,100,fp);  
   if(strcmp("MACRO\n",str)==0)  
     printf("MAcro detected\nExecuting Pass1\n");  
   fgets(str,100,fp);  
   //Creating PNTAB and MNT  
   j=0;  
   while(str[i]!='\t')  
   {  
     mnt[0].name[j]=str[i];  
     i++;j++;  
   }  
   int kpdtab_ptr=0;  
   while(str[i]!='\n')  
   {  
     pntab[ptr].par[j]=NULL;  
     j=0;  
     ptr++;i++;  
     if(str[i]=='&')  
     {  
       i++;  
       ++nop;  
       while(str[i]!=','&&str[i]!='\n')  
       {  
         if(str[i]=='=')  
         {  
           nop--;  
           nok++;  
           i++;  
           strcpy(kpdtab[kpdtab_ptr].name,pntab[ptr].par);  
           if(str[i]!=',')  
           {  
             int k=0;  
             while(str[i]!=','&&str[i]!='\n')  
             {  
               kpdtab[kpdtab_ptr].value[k]=str[i];  
               i++;  
               k++;  
             }  
           }  
         }  
         else  
         {  
           pntab[ptr].par[j]=str[i];  
           j++;i++;  
         }  
       }  
     }  
   }  
   printf("\nPNTAB is\n");  
   disp_pntab(ptr);  
   mnt[0].nop=nop;  
   mnt[0].nok=nok;  
   mnt[0].mdtp=0;  
   mnt[0].kpdtp=0;  
   char label[10],mneu[10],op1[10],op2[10];  
   char intercode[100],buff[10];  
   int x;  
   int mdtp=0;  
   while(!feof(fp))  
   {  
     fgets(str,100,fp);  
     i=0;  
     if(str[0]=='\t')  
     {  
       strcpy(label,NULL);  
       i++;  
     }  
     else  
     {  
       j=0;  
       while(str[i]!='\t'&&str[i]!='\n')  
       {  
         label[j]=str[i];  
         i++;j++;  
       }  
       label[j]=NULL;  
       if(strcmp(label,"MEND")==0)  
       {  
         strcpy(intercode,"\tMEND\n");  
         strcat(intercode,NULL);  
         strcpy(mdt[mdtp].entry,intercode);  
         mdtp++;  
         break;  
       }  
       i++;  
     }  
     j=0;  
     while(str[i]!='\t')  
     {  
       mneu[j]=str[i];  
       i++;j++;  
     }  
     mneu[j]=NULL;  
     j=0;i+=2;  
     while(str[i]!=',')  
     {  
       op1[j]=str[i];  
       i++;j++;  
     }  
     op1[j]=NULL;  
     j=0;i+=2;  
     while(str[i]!='\n')  
     {  
       op2[j]=str[i];  
       i++;j++;  
     }  
     op2[j]=NULL;  
     if(strcmp(mneu,"LCL")==0)  
     {  
       noe++;  
     }  
     strcpy(intercode,NULL);  
     if(strcmp(label,NULL)==0)  
     {  
       strcat(intercode,"\t");  
     }  
     strcat(intercode,mneu);  
     strcat(intercode,"\t");  
     x=search_pntab(op1,ptr);  
     if(x!=-1)  
     {  
       strcat(intercode,"(P,");  
       itoa(x,buff,10);  
       strcat(intercode,buff);  
       strcat(intercode,"),");  
     }  
     if(op2[0]=='=')  
     {  
       strcat(intercode,op2);  
     }  
     else  
     {  
       x=search_pntab(op2,ptr);  
       if(x!=-1)  
       {  
         strcat(intercode,"(P,");  
         itoa(x,buff,10);  
         strcat(intercode,buff);  
         strcat(intercode,")\n\0");  
       }  
     }  
     end:  
     strcat(intercode,NULL);  
     strcpy(mdt[mdtp].entry,intercode);  
     mdtp++;  
 //    getch();  
   }  
   printf("\nMNT:\n");  
   disp_mnt();  
   disp_mdt(mdtp);  
   fp2=fopen("mca.txt","r");//other file is mcal  
   fgets(str,100,fp2);  
   i=0;  
   while(str[i]!=' ')  
     i++;  
   strcpy(buff,NULL);  
   int k=0;  
   int aptab_ptr=0;  
   while(str[i]!='\n')  
   {  
     j=0; i++;  
     while(str[i]!=',' && str[i]!='\n')  
     {  
       if(str[i]=='=')  
       {  
         buff[j]=NULL;  
         x=search_pntab(buff,ptr);  
         strcpy(buff,NULL);  
         j=0;  
         i++;  
         while(str[i]!=',' && str[i]!='\n')  
         {  
           buff[j]=str[i];  
           i++;j++;  
         }  
         buff[j]=NULL;  
         strcpy(aptab[x].value,buff);  
         goto yo;  
       }  
       buff[j]=str[i];  
       i++;j++;  
     }  
     buff[j]=NULL;  
     strcpy(aptab[aptab_ptr++].value,buff);  
     yo:  
   }  
   aptab_ptr+=nok;  
   i=0;  int y;  
   while(i<aptab_ptr) <br="">   {  
     if(strcmp(aptab[i].value,NULL)==0)  
     {  
       y=i-nop;  
       strcpy(aptab[i].value,kpdtab[y].value);  
     }  
     i++;  
   }  
   i=0;           j=0;  
   disp_aptab(ptr);  
   getch();  
   printf("Expanded MAcro is:\n");  
   strcpy(intercode,NULL);  
   while(i<mdtp-1) <br="">   {  
     strcpy(intercode,NULL);  
     j=0;  
     while(mdt[i].entry[j]!='\n')  
     {  
       if(mdt[i].entry[j]=='(')  
       {  
         if(mdt[i].entry[j+1]=='P')  
         {  
           x=(int)mdt[i].entry[j+3]-48;  
           //itoa(aptab[x].value,buff,10);  
           strcat(intercode,aptab[x].value);  
           j=j+4;  
         }  
       }  
       else  
       {  
         x=strlen(intercode);  
         intercode[x]=mdt[i].entry[j];  
         intercode[x+1]=NULL;  
       }  
       j++;  
     }  
     intercode[j]=NULL;  
     printf("%s \n",intercode);  
     i++;  
     //mdt[i].entry  
   }  
   /*while(!feof(fp))  
   {  
     fgets(str,100,fp);  
     printf(str);  
   } */  
   getch();  
 }

Input File

MACRO
INCR    &MEM_VAL,&INCR_VAL,&REG
MOVER    &REG,&MEM_VAL
ADD    &REG,&INCR_VAL
MOVEM    &REG,&MEM_VAL
MEND

Regular Expression to DFA Code in C Language 

Regular Expression to DFA ( To be taken from compiler point of view) .The implementation to be done as per the algorithm covered in the book Compiler Design and Principles.

Regular Expression to DFA Code

 #include  
 #include  
 #include  
 #include  
 typedef struct tree  
 {  
   char ch;  
   int pos;  
   int nullable;  
   int fpos[5];  
   int lpos[5];  
   struct tree * lc;  
   struct tree * rc;  
 }node;  
 int dfaa[30],df=0;  
 typedef struct foll  
 {  
   int follpos[10];  
   char ch;  
 }follpos;  
 follpos folltab[100];  
 char inpt[10];  
 void follow(node *);  
 node* alloc(char ch)  
 {  
   node * temp;  
   temp=(node *)malloc(sizeof(node));  
   temp->nullable=1;  
   temp->lc=NULL;  
   temp->rc=NULL;  
   temp->ch=ch;  
   temp->fpos[0]=-1;  
   temp->lpos[0]=-1;  
   return temp;  
 }  
 void unio(int [],int []);  
 void sort(int []);  
 int check(int[] ,int);  
 void print_follow(int n)  
 {  
   printf("FOLLOWPOS\n");  
   printf("POS\tNAME\tFOLLOWPOS\n");  
   for(int i=1;i<=n;++i)  
   {  
     printf("%d\t%c\t",i,folltab[i].ch);  
     int j=0;  
     while(folltab[i].follpos[j]!=-1)  
     {  
       printf("%d ",folltab[i].follpos[j]);  
       j++;  
     }  
     printf("\n");  
   }  
 }  
 void print_nullable(node *root)  
 {  
   if(root!=NULL)  
   {  
     print_nullable(root->lc);  
     print_nullable(root->rc);  
     printf("%c\t",root->ch);  
     int i=0;  
     while(root->fpos[i]!=-1)  
     {  
       printf("%d ",root->fpos[i]);  
       i++;  
     }  
     printf("\t");  
     i=0;  
     while(root->lpos[i]!=-1)  
     {  
       printf("%d ",root->lpos[i]);  
       i++;  
     }  
     printf("\n");  
   }  
 }  
 node * create(char str[],int *l)  
 {  
   node * nw;  
   nw=alloc(str[*l]);  
   if(str[*l]=='*'||str[*l]=='|'||str[*l]=='.')  
   {  
     if(str[*l]!='*')  
     {  
       (*l)--;  
       nw->nullable=0;  
       nw->rc=create(str,l);  
     }  
     (*l)--;  
     nw->lc=create(str,l);  
   }  
   else  
     nw->nullable=0;  
   return nw;  
 }  
 void inorder(node *root)  
 {  
   if(root!=NULL)  
   {  
     inorder(root->lc);  
     printf("%c",root->ch);  
     inorder(root->rc);  
   }  
 }  
 void create_nullable(node * root,int *pos)  
 {  
   if(root->lc!=NULL)  
     create_nullable(root->lc,pos);  
   if(root->rc!=NULL)  
     create_nullable(root->rc,pos);  
   if(root->lc==NULL && root->rc==NULL)  
   {  
     root->pos=(*pos);  
     root->fpos[0]=root->lpos[0]=(*pos);  
     root->fpos[1]=root->lpos[1]=-1;  
     folltab[*pos].ch=root->ch;  
     folltab[*pos].follpos[0]=-1;  
     (*pos)++;  
   }  
   else  
   {  
     if(root->ch=='|')  
     {  
       unio(root->fpos,root->lc->fpos);  
       unio(root->fpos,root->rc->fpos);  
       unio(root->lpos,root->lc->lpos);  
       unio(root->lpos,root->rc->lpos);  
     }  
     else if(root->ch=='*')  
     {  
       unio(root->fpos,root->lc->fpos);  
       unio(root->lpos,root->lc->lpos);  
     }  
     else if(root->ch=='.')  
     {  
       if(root->lc->nullable==1)  
       {  
         unio(root->fpos,root->rc->fpos);  
       }  
         unio(root->fpos,root->lc->fpos);  
         sort(root->fpos);  
       if(root->rc->nullable==1)  
       {  
         unio(root->lpos,root->lc->lpos);  
       }  
         unio(root->lpos,root->rc->lpos);  
         sort(root->lpos);  
     }  
     follow(root);  
   }  
 }  
 void follow(node *root)  
 {  
   int i=0;  
   if(root->ch=='*')  
   {  
     while(root->lpos[i]!=-1)  
     {  
       unio(folltab[root->lpos[i]].follpos,root->fpos);  
       i++;  
     }  
   }  
   else if(root->ch=='.')  
   {  
      while(root->lc->lpos[i]!=-1)  
      {  
       unio(folltab[root->lc->lpos[i]].follpos,root->rc->fpos);  
       i++;  
      }  
   }  
 }  
 void unio(int arr1[],int arr2[])  
 {  
   int i=0;  
   while(arr1[i]!=-1)  
     i++;  
   int j=0;int k=0;  
   while(arr2[j]!=-1)  
   {  
     for(k=0;k<i;++k) <br="">     {  
       if(arr2[j]==arr1[k])  
         break;  
     }  
     if(k==i)  
     {  
       arr1[i]=arr2[j];  
       i++;  
     }  
     j++;  
   }  
   arr1[i]=-1;  
 }  
 void sort(int a[])//insertion sort  
 {  
   int i,j,temp;  
   for(i=1;a[i]!=-1;i++)  
   {  
     temp=a[i];  
     for(j=i-1;j>=0&&temp<a[j];j--) <br="">       a[j+1]=a[j];  
     a[j+1]=temp;  
   }  
 }  
 int state[10][10];  
 void dfa()  
 {  
   int j=0,k=0,temp[10];  
   temp[0]=-1;  
   int nos=1;  
   for(int i=0;i<10;++i)  
     state[i][0]=-1;  
   i=0;    int m;  
   unio(state[0],folltab[1].follpos);  
   while(1)  
   {  
     for(i=0;inpt[i]!=NULL;++i)  
     {  
       for(j=0;state[k][j]!=-1;++j)  
       {  
         if(folltab[state[k][j]].ch==inpt[i])  
           { unio(temp,folltab[state[k][j]].follpos);  }  
         }  
           m=check(temp,nos);  
            if(m==-1)  
            {  
             unio(state[nos++],temp);  
             m=nos-1;  
            }  
           dfaa[df++]=m;  
       temp[0]=-1;  
     }  
     if(k==nos-1)  
       break;  
     k++;  
   }  
 }  
 int check(int temp[],int nos)  
 {  
   for(int i=0;i<nos;++i) <br="">   {  
     for(int j=0;temp[j]!=-1;++j)  
     {  
       if(temp[j]!=state[i][j])  
         break;  
     }  
     if(temp[j]==-1 && state[i][j]==-1)  
       return i;  
   }  
   return -1;  
 }  
 void display_dfa()//displaying DFA table  
 {  
   int i,j,k;  
   printf("\nDFA TABLE\n ");  
   for(i=0;inpt[i]!=NULL;i++)  
     printf("\t%c",inpt[i]);  
   for(j=0;j<(df/i);j++)  
   {  
     printf("\n%c\t",j+65);  
     for(k=j*i;k<(j*i)+i;k++)  
       printf("%c\t",dfaa[k]+65);  
   }  
   getch();  
 }  
 void main()  
 {  
   clrscr();  
   char str[50];  
   inpt[0]=NULL;  
   printf("Enter the postfix expression\n");  
   scanf("%s",str);  
   node * root;   
   int l;  
   strcat(str,"#.\0");  
   l=strlen(str);  
   l--;  
   int j=0;  
   for(int i=0;i<l-1;++i) <br="">   {  
     j=0;  
     while(inpt[j]!=NULL)  
     {  
       if(inpt[j]==str[i])  
         break;  
       j++;  
     }  
     if(inpt[j]!=str[i] && str[i]!='|' && str[i]!='*' && str[i]!='.')  
     {  
       inpt[j]=str[i];  
       inpt[j+1]=NULL;  
     }  
   }  
   int pos=1;  
   root=create(str,&l);  
   create_nullable(root,&pos);  
   printf("NULLABLE TABLE\nElement\tFPOS\tLPOS\n");  
   print_nullable(root->lc);  
   print_follow(pos-2);  
   dfa();  
   display_dfa();  
 }