‭Index‬

‭S. No.‬ ‭List of Experiments‬ ‭Page No.‬ ‭Date‬ ‭Signature‬

‭1‬ ‭Write a LEX Program to scan reserved word &‬
‭Identifiers of C Language language.‬

‭2‬ ‭Implement Predictive Parsing algorithm‬

‭3‬ ‭Write a C program to generate three address codes.‬

‭4‬ ‭Implement SLR(1) Parsing algorithm‬

‭5‬ ‭Design LALR bottom up parser for the given language‬

‭6‬ ‭Write a C program for implementing the functionalities of‬

‭predictive parser for the mini language specified in Note 1.‬
‭7‬ ‭a)‬ ‭*Write a C program for constructing LL (1) parsing.‬
*‭ Write a C program for constructing recursive descent‬
‭b)‬
‭parsing.‬
‭8‬ ‭ rite a program to accept a string (ab).‬
W

‭9‬ ‭Write a program to generate a parse tree.‬

‭10‬ ‭Write a program to find leading terminals.‬

‭11‬ ‭Write a program to find trailing terminals.‬

‭12‬ ‭Write a program to compute FIRST of non-terminal.‬

‭13‬ ‭Write a program to compute FOLLOW of non-terminal‬

‭14‬ ‭Write a program to check whether a grammar is left Recursion‬

‭and remove left Recursion.‬
‭15‬ ‭Write a program to remove left factoring.‬

‭16‬ ‭Write a program to check whether a grammar is operator‬

‭precedence.‬
 ‭Program-1‬
‭OBJECTIVE:‬
‭Implement the lexical analyzer using JLex, flex or other lexical analyzer generating tools.‬

‭AIM:‬
‭To analyze JLex, flex or other lexical analyzer generating tools.‬

‭RESOURCE:‬
‭●‬ ‭Linux using Putty‬

‭PROGRAM LOGIC:‬
‭●‬ ‭Read the input string.‬
‭●‬ C
‭ heck whether the string is identifier/ keyword /symbol by using the rules of‬
‭identifier and keywords using LEX Tool‬
‭ ROCEDURE:‬
P

‭●‬ ‭Go to terminal‬

‭●‬ ‭Open vi editor,‬
‭●‬ ‭Compile using Lex lex.l , cc lex.yy.c , ./a.out‬

‭PROGRAM:‬
‭%{‬
‭/* program to recognize a c program */ int COMMENT=0;‬
‭%}‬
‭identifier [a-zA-Z][a-zA-Z0-9]*‬
‭%%‬
‭#.* { printf("\n%s is a PREPROCESSOR DIRECTIVE",yytext);}‬
‭int | float | char | double | while | for | do | if | break | continue | void | switch | case | long | struct | const |‬
‭typedef | return |else |‬
‭goto{printf("\n\t%s is a KEYWORD",yytext);} "/*" {COMMENT = 1;}‬
‭/*{printf("\n\n\t%s is a COMMENT\n",yytext);}*/ "*/" {COMMENT = 0;}‬
‭/* printf("\n\n\t%s is a COMMENT\n",yytext);}*/‬
‭{identifier}\( {if(!COMMENT)printf("\n\nFUNCTION\n\t%s",yytext);}‬
‭\{ {if(!COMMENT) printf("\n BLOCK BEGINS");}‬
‭\} {if(!COMMENT) printf("\n BLOCK ENDS");}‬
‭{identifier}(\[[0-9]*\])? {if(!COMMENT) printf("\n %s IDENTIFIER",yytext);}‬
‭\".*\" {if(!COMMENT) printf("\n\t%s is a STRING",yytext);}‬
‭[0-9]+ {if(!COMMENT) printf("\n\t%s is a NUMBER",yytext);}‬
\‭)(\;)? {if(!COMMENT) printf("\n\t");ECHO;printf("\n");}‬
‭\(‬
‭\( ECHO;‬
‭ {if(!COMMENT)printf("\n\t%s is an ASSIGNMENT OPERATOR",yytext);}‬
=
‭\<= | \>= | \< | == |‬
‭\> {if(!COMMENT) printf("\n\t%s is a RELATIONAL OPERATOR",yytext);}‬
‭%%‬
‭int main(int argc,char **argv)‬
‭{‬
‭if (argc > 1)‬
‭{‬
‭FILE *file;‬
‭file = fopen(argv[1],"r"); if(!file)‬
‭{‬
‭printf("could not open %s \n",argv[1]); exit(0);‬
‭}‬
‭yyin = file;‬
‭}‬
‭yylex(); printf("\n\n"); return 0;‬
‭}‬
‭int yywrap()‬
‭{‬
‭return 0;‬
‭}‬

I‭ nput:‬
‭$vi var.c‬
‭#include<stdio.h> main()‬
‭{‬
‭int a,b;‬
‭}‬

‭ utput:‬
O
‭$lex lex.l‬
‭$cc lex.yy.c‬
‭$./a.out var.c‬
‭#include<stdio.h> is a PREPROCESSOR DIRECTIVE FUNCTION main ( )‬
‭ LOCK BEGINS‬
B
‭int is a KEYWORD a IDENTIFIER‬
‭b IDENTIFIER BLOCK ENDS‬
 ‭Program-2‬
‭OBJECTIVE:‬

‭Write a C program for implementing the functionalities of predictive parser .‬

‭Understanding the functionalities of predictive parser for a given language.‬

‭RESOURCE:‬
‭●‬ ‭Turbo C++‬

‭PROGRAM LOGIC:‬

‭●‬ ‭Read the input string.‬

‭●‬ ‭By using the FIRST AND FOLLOW values.‬

‭●‬ ‭Verify the FIRST of non terminal and insert the production in the FIRST value‬

‭●‬ ‭If we have any @ terms in FIRST then insert the productions in FOLLOW values‬

‭●‬ ‭Constructing the predictive parser table‬

‭PROCEDURE:‬

‭●‬ ‭Go to debug -> run or press CTRL + F9 to run the program.‬

‭PROGRAM:‬

‭ include<stdio.h> #include<conio.> #include<string.>‬

#
‭char prol[7][10]={"s","A","A","B","B","C","C"};‬
‭char pror[7][10]={"Aa","Bb","Cd","aB","@","Cc","@"};‬
‭char prod[7][10]={"s-->A","A-->Bb","A-->Cd","B-->aB","B-->@","C-->Cc","C-->@"};‬
‭char first[7][10]={"abcd","ab",cd","a@","@","c@","@"};‬
‭char follow[7][10]={"$","$","$","a$","b$","c$","d$"‬
‭char table[5][6][10];‬
‭{‬
‭switch(c)‬
‭{‬
‭case 'S':return0; case 'A':return1;‬

‭ ase 'B':return2; case 'C':return3; case 'a':return0; case 'b':return1; case 'c':return2; case 'd':return3; case‬
c
‭'$':return4;‬
‭}‬
‭retun(2);‬
‭}‬
‭void main()‬
{‭ ‬
‭int i,j,k;‬
‭clrscr(); for(i=0;i<5;i++) for(j=0;j<6;j++) strcpy(table[i][j]," ");‬
‭printf("\n The following is the predictive parsing table for the following grammar:\n"); for(i=0;i<7;i++)‬
‭printf("%s\n",prod[i]);‬
‭printf("\n Predictive parsing table is:\n "); fflush(stdin);‬
‭for(i=0;i<7;i++)‬
‭{‬
‭k=strlen(first[i]);‬
‭for(j=0;j<10;j++)‬
‭if(first[i][j]!='@')‬
‭strcpy(table[numr(prol[i][0])+1][numr(first[i][j])+1],prod[i]);‬
‭}‬
‭for(i=0;i<7;i++)‬
‭{‬
‭if(strlen(pror[i])==1)‬
‭{‬
‭if(pror[i][0]=='@')‬
‭{‬
‭k=strlen(follow[i]);‬

f‭ or(j=0;j<k;j++) strcpy(table[numr(prol[i][0])+1][numr(follow[i][j])+1]prod[i]);‬
‭}‬
‭}‬
‭}‬
‭strcpy(table[0][0]," ");‬
‭strcpy(table[0][1],"a");‬
‭strcpy(table[0][2],"b");‬
‭strcpy(table[0][3],"c");‬
‭strcpy(table[0][4],"d");‬
‭strcpy(table[0][5],"$");‬
‭strcpy(table[1][0],"S");‬
‭strcpy(table[2][0],"A");‬
‭strcpy(table[3][0],"B");‬
‭strcpy(table[4][0],"C");‬
‭printf("\n\n");‬
‭for(i-0;i<5;i++) for(j=0;j<6;j++)‬
‭{‬
‭printf("%s_10S",table[i][j]); if(j==5)‬
‭printf("\n\n");‬
‭}‬
‭getch();‬
‭}‬
‭INPUT & OUTPUT:‬
‭ he following is the predictive parsing table for the following grammar: S->A‬
T
‭A->Bb A->Cd B->aB B->@ C->Cc C->@‬

‭Predictive parsing table is‬

‭a‬ ‭b‬ ‭c‬ ‭d‬ ‭$‬

‭S‬ ‭S->A‬ ‭S->A‬ ‭S->A‬ ‭S->A‬

‭A‬ ‭A->Bb‬ ‭A->Bb‬ ‭A->Cd‬ ‭A->Cd‬

‭B‬ ‭B->aB‬ ‭B->@‬ ‭B->@‬ ‭B->@‬

‭C‬ ‭C->@‬ ‭C->@‬ ‭C->@‬

 ‭Program-3‬
‭OBJECTIVE: Write a C program to generate three address codes.‬

‭ ESOURCE:‬
R
‭Turbo C++ ALGORITHM:‬
‭Step1: Begin the program‬

‭Step2 : The expression is read from the file using a file pointer‬

‭Step3 : Each string is read and the total no. of strings in the file is calculated.‬

‭ tep4: Each string is compared with an operator; if any operator is seen then the previous string and next string are‬
S
‭concatenated and stored in a first temporary value and the three address code expression is printed‬
‭Step5 : Suppose if another operand is seen then the first temporary value is concatenated to the next string using the‬
‭operator and the expression is printed.‬
‭Step6 : The final temporary value is replaced to the left operand value.‬

‭Step7 : End the program‬

‭PROGRAM:‬

‭#include<stdio.h> #include<conio.h> #include<stdlib.h> #include<string.h>‬

s‭ truct three‬
‭{‬
‭char data[10],temp[7];‬

}‭ s[30];‬
‭void main()‬
‭{‬
‭char d1[7],d2[7]="t"; int i=0,j=1,len=0; FILE *f1,*f2; clrscr();‬
‭f1=fopen("sum.txt","r");‬
‭f2=fopen("out.txt","w");‬
‭while(fscanf(f1,"%s",s[len].data)!=EOF) len++;‬
‭itoa(j,d1,7); strcat(d2,d1); strcpy(s[j].temp,d2);‬
‭strcpy(d1,"");‬
‭strcpy(d2,"t"); if(!strcmp(s[3].data,"+"))‬
‭{‬
‭fprintf(f2,"%s=%s+%s",s[j].temp,s[i+2].data,s[i+4].data); j++;‬
‭}‬
‭else if(!strcmp(s[3].data,"-"))‬
‭{‬
‭fprintf(f2,"%s=%s-%s",s[j].temp,s[i+2].data,s[i+4].data); j++;‬
‭}‬
‭for(i=4;i<len-2;i+=2)‬
‭{‬
‭itoa(j,d1,7); strcat(d2,d1); strcpy(s[j].temp,d2);‬
‭if(!strcmp(s[i+1].data,"+")) fprintf(f2,"\n%s=%s+%s",s[j].temp,s[j-1].temp,s[i+2].data); else‬
‭if(!strcmp(s[i+1].data,"-"))‬
‭fprintf(f2,"\n%s=%s-%s",s[j].temp,s[j-1].temp,s[i+2].data); strcpy(d1,"");‬
‭strcpy(d2,"t"); j++;‬
‭}‬
‭fprintf(f2,"\n%s=%s",s[0].data,s[j-1].temp);‬
‭fclose(f1); fclose(f2); getch();‬
}‭ ‬
‭Input: sum.txt‬

‭out = in1 + in2 + in3 - in4‬

‭Output :‬ ‭out.txt‬

‭t1=in1+in2 t2=t1+in3 t3=t2-in4 out=t3‬

‭ ESULT:‬
R
‭Thus a C program to generate a three address code for a given expression is written, executed and the output is‬
‭verified.‬
 ‭Program-4‬
‭OBJECTIVE: Implement SLR(1) Parsing algorithm‬

‭ include<stdio.h>‬
#
‭#include<string.h>‬
‭#include<stdlib.h>‬
‭#include<unistd.h>‬
‭int i,j,k,m,n=0,o,p,ns=0,tn=0,rr=0,ch=0;‬
‭char cread[15][10],gl[15],gr[15][10],temp,templ[15],tempr[15][10],*ptr,temp2[5];‬
‭char dfa[15][10];‬
‭struct states‬
‭{‬
‭char lhs[15],rhs[15][10];‬
‭int n;//state number‬
‭}I[15];‬
‭int compstruct(struct states s1,struct states s2)‬
‭{‬
‭int t;‬
‭if(s1.n!=s2.n)‬
‭return 0;‬
‭if( strcmp(s1.lhs,s2.lhs)!=0 )‬
‭return 0;‬
‭for(t=0;t<s1.n;t++)‬
‭if( strcmp(s1.rhs[t],s2.rhs[t])!=0 )‬
‭return 0;‬
‭return 1;‬
‭}‬
‭void moreprod()‬
‭{‬
‭int r,s,t,l1=0,rr1=0;‬
‭char *ptr1,read1[15][10];‬
‭for(r=0;r<I[ns].n;r++)‬
‭{‬
‭ptr1=strchr(I[ns].rhs[l1],'.');‬
‭t=ptr1-I[ns].rhs[l1];‬
‭if( t+1==strlen(I[ns].rhs[l1]) )‬
‭{‬
‭l1++;‬
‭continue;‬
‭}‬
‭temp=I[ns].rhs[l1][t+1];‬
‭l1++;‬
‭for(s=0;s<rr1;s++)‬
‭if( temp==read1[s][0] )‬
‭break;‬
‭if(s==rr1)‬
‭{‬
‭read1[rr1][0]=temp;‬
‭rr1++;‬
‭}‬
‭else‬
‭continue;‬
‭for(s=0;s<n;s++)‬
‭{‬
‭if(gl[s]==temp)‬
{‭ ‬
‭I[ns].rhs[I[ns].n][0]='.';‬
‭I[ns].rhs[I[ns].n][1]='\0';‬
‭strcat(I[ns].rhs[I[ns].n],gr[s]);‬
‭I[ns].lhs[I[ns].n]=gl[s];‬
‭I[ns].lhs[I[ns].n+1]='\0';‬
‭I[ns].n++;‬
‭}}}}‬
‭void canonical(int l)‬
‭{‬
‭int t1;‬
‭char read1[15][10],rr1=0,*ptr1;‬
‭for(i=0;i<I[l].n;i++)‬
‭{‬
‭temp2[0]='.';‬
‭ptr1=strchr(I[l].rhs[i],'.');‬
‭t1=ptr1-I[l].rhs[i];‬
‭if( t1+1==strlen(I[l].rhs[i]) )‬
‭continue;‬
‭temp2[1]=I[l].rhs[i][t1+1];‬
‭temp2[2]='\0';‬
‭if( strcmp(temp2,read1[j])==0 )‬
‭break;‬
‭if(j==rr1)‬
‭{‬
‭strcpy(read1[rr1],temp2);‬
‭read1[rr1][2]='\0';‬
‭rr1++;‬
‭}‬
‭else‬
‭continue;‬
‭for(j=0;j<I[0].n;j++)‬
‭{‬
‭ptr=strstr(I[l].rhs[j],temp2);‬
‭if( ptr )‬
‭{‬
‭templ[tn]=I[l].lhs[j];‬
‭templ[tn+1]='\0';‬
‭strcpy(tempr[tn],I[l].rhs[j]);‬
‭tn++;‬
‭}‬
‭}‬
‭for(j=0;j<tn;j++)‬
‭{‬
‭ptr=strchr(tempr[j],'.');‬
‭p=ptr-tempr[j];‬
‭tempr[j][p]=tempr[j][p+1];‬
‭tempr[j][p+1]='.';‬
‭I[ns].lhs[I[ns].n]=templ[j];‬
‭I[ns].lhs[I[ns].n+1]='\0';‬
‭strcpy(I[ns].rhs[I[ns].n],tempr[j]);‬
‭I[ns].n++;‬
‭}‬
‭moreprod();‬
‭for(j=0;j<ns;j++)‬
‭{‬
/‭/if ( memcmp(&I[ns],&I[j],sizeof(struct states))==1 )‬
‭if( compstruct(I[ns],I[j])==1 )‬
‭{‬
‭I[ns].lhs[0]='\0';‬
‭for(k=0;k<I[ns].n;k++)‬
‭I[ns].rhs[k][0]='\0';‬
‭I[ns].n=0;‬
‭}}‬
‭if(j<ns)‬
‭{‬
‭tn=0;‬
‭for(j=0;j<15;j++)‬
‭{‬
‭templ[j]='\0';‬
‭tempr[j][0]='\0';‬
‭}‬
‭continue;‬
‭}‬
‭dfa[l][j]=temp2[1];‬
‭printf("\n\nI%d :",ns);‬
‭for(j=0;j<I[ns].n;j++)‬
‭printf("\n\t%c -> %s",I[ns].lhs[j],I[ns].rhs[j]);‬
‭//getch();‬
‭ns++;‬
‭tn=0;‬
‭for(j=0;j<15;j++)‬
‭{‬
‭templ[j]='\0';‬
‭tempr[j][0]='\0';‬
‭}}}‬
‭void main()‬
‭{‬
‭FILE *f;‬
‭int l;‬
‭//clrscr();‬
‭for(i=0;i<15;i++)‬
‭{‬
‭I[i].n=0;‬
‭I[i].lhs[0]='\0';‬
‭I[i].rhs[0][0]='\0';‬
‭dfa[i][0]= '\0';‬
‭}‬
‭n++;‬
‭}‬
‭printf("THE GRAMMAR IS AS FOLLOWS\n");‬
‭for(i=0;i<n;i++)‬
‭printf("\t\t\t\t%c -> %s\n",gl[i],gr[i]);‬
‭I[0].lhs[0]='Z';‬
‭strcpy(I[0].rhs[0],".S");‬
‭I[0].n++;‬
‭l=0;‬
‭for(i=0;i<n;i++)‬
‭{‬
‭temp=I[0].rhs[l][1];‬
‭l++;‬
‭for(j=0;j<rr;j++)‬
i‭f( temp==cread[j][0] )‬
‭break;‬
‭if(j==rr)‬
‭{‬
‭cread[rr][0]=temp;‬
‭rr++;‬
‭}‬
‭else‬
‭continue;‬
‭for(j=0;j<n;j++)‬
‭{‬
‭if(gl[j]==temp)‬
‭{‬
‭I[0].rhs[I[0].n][0]='.';‬
‭strcat(I[0].rhs[I[0].n],gr[j]);‬
‭I[0].lhs[I[0].n]=gl[j];‬
‭I[0].n++;‬
‭}‬
‭}‬
‭}‬
‭ns++;‬
‭printf("\nI%d :\n",ns-1);‬
‭for(i=0;i<I[0].n;i++)‬
‭printf("\t%c -> %s\n",I[0].lhs[i],I[0].rhs[i]);‬
‭for(l=0;l<ns;l++)‬
‭canonical(l);‬
‭printf("\n\n\t\tPRESS ANY KEY FOR TABLE");‬
‭//getch();‬
‭clrscr();‬
‭printf("\t\t\t\nDFA TABLE IS AS FOLLOWS\n\n\n");‬
‭for(i=0;i<ns;i++)‬
‭{‬
‭printf("I%d : ",i);‬
‭for(j=0;j<ns;j++)‬
‭if(dfa[i][j]!='\0')‬
‭printf("'%c'->I%d | ",dfa[i][j],j);‬
‭printf("\n\n\n");‬
‭}‬
‭printf("\n\n\n\t\tPRESS ANY KEY TO EXIT");‬
‭//getch();‬
‭}‬

‭3 OUTPUT‬
‭4‬

‭5‬
‭6‬

‭7 \\\‬

‭8‬
‭Program-5‬
‭AIM: C program to Design LALR Bottom up Parser‬

‭ ROGRAM‬
P
‭#include<stdio.h>‬
‭#include<conio.h>‬
‭#include<stdlib.h>‬
‭#include<string.h>‬
‭void push(char *,int *,char);‬
‭char stacktop(char *);‬
‭void isproduct(char,char);‬
‭int ister(char);‬
‭int isnter(char);‬
‭int isstate(char);‬
‭void error();‬
‭void isreduce(char,char);‬
‭char pop(char *,int *);‬
‭void printt(char *,int *,char [],int);‬
‭void rep(char [],int);‬
‭struct action‬
‭{‬
‭char row[6][5];‬
‭};‬
‭const struct action A[12]={‬
‭{"sf","emp","emp","se","emp","emp"},‬
‭{"emp","sg","emp","emp","emp","acc"},‬
‭{"emp","rc","sh","emp","rc","rc"},‬
‭{"emp","re","re","emp","re","re"},‬
‭{"sf","emp","emp","se","emp","emp"},‬
‭{"emp","rg","rg","emp","rg","rg"},‬
‭{"sf","emp","emp","se","emp","emp"},‬
‭{"sf","emp","emp","se","emp","emp"},‬
‭{"emp","sg","emp","emp","sl","emp"},‬
‭{"emp","rb","sh","emp","rb","rb"},‬
‭{"emp","rb","rd","emp","rd","rd"},‬
‭{"emp","rf","rf","emp","rf","rf"}‬
‭};‬
‭struct gotol‬
‭{‬
‭char r[3][4];‬
‭};‬
‭const struct gotol G[12]={‬
‭{"b","c","d"},‬
‭{"emp","emp","emp"},‬
‭{"emp","emp","emp"},‬
‭{"emp","emp","emp"},‬
‭{"i","c","d"},‬
‭{"emp","emp","emp"},‬
‭{"emp","j","d"},‬
‭{"emp","emp","k"},‬
‭{"emp","emp","emp"},‬
‭{"emp","emp","emp"},‬
‭};‬
‭char ter[6]={'i','+','*',')','(','$'};‬
‭char nter[3]={'E','T','F'};‬
‭char states[12]={'a','b','c','d','e','f','g','h','m','j','k','l'};‬
c‭ har stack[100];‬
‭int top=-1;‬
‭char temp[10];‬
‭struct grammar‬
‭{‬
‭char left;‬
‭char right[5];‬
‭};‬
‭const struct grammar rl[6]={‬
‭{'E',"e+T"},‬
‭{'E',"T"},‬
‭{'T',"T*F"},‬
‭{'T',"F"},‬
‭{'F',"(E)"},‬
‭{'F',"i"},‬
‭};‬
‭void main()‬
‭{‬
‭char inp[80],x,p,dl[80],y,bl='a';‬
‭int i=0,j,k,l,n,m,c,len;‬
‭printf(" Enter the input :");‬
‭scanf("%s",inp);‬
‭len=strlen(inp);‬
‭inp[len]='$';‬
‭inp[len+1]='\0';‬
‭push(stack,&top,bl);‬
‭printf("\n stack \t\t\t input");‬
‭printt(stack,&top,inp,i);‬
‭do‬
‭{‬
‭x=inp[i];‬
‭p=stacktop(stack);‬
‭isproduct(x,p);‬
‭if(strcmp(temp,"emp")==0)‬
‭error();‬
‭if(strcmp(temp,"acc")==0)‬
‭break;‬
‭else‬
‭{‬
‭if(temp[0]=='s')‬
‭{‬
‭push(stack,&top,inp[i]);‬
‭push(stack,&top,temp[1]);‬
‭i++;‬
‭}‬
‭else‬
‭{‬
‭if(temp[0]=='r')‬
‭{‬
‭j=isstate(temp[1]);‬
‭strcpy(temp,rl[j-2].right);‬
‭dl[0]=rl[j-2].left;‬
‭dl[1]='\0';‬
‭n=strlen(temp);‬
‭for(k=0;k<2*n;k++)‬
‭pop(stack,&top);‬
f‭ or(m=0;dl[m]!='\0';m++)‬
‭push(stack,&top,dl[m]);‬
‭l=top;‬
‭y=stack[l-1];‬
‭isreduce(y,dl[0]);‬
‭for(m=0;temp[m]!='\0';m++)‬
‭push(stack,&top,temp[m]);‬
‭}‬
‭}‬
‭}‬
‭printt(stack,&top,inp,i);‬
‭}while(inp[i]!='\0');‬
‭if(strcmp(temp,"acc")==0)‬
‭printf(" \n accept the input ");‬
‭else‬
‭printf(" \n do not accept the input ");‬
‭getch();‬
‭}‬
‭void push(char *s,int *sp,char item)‬
‭{‬
‭if(*sp==100)‬
‭printf(" stack is full ");‬
‭else‬
‭{‬
‭*sp=*sp+1; s[*sp]=item;‬
‭}‬
‭}‬
‭char stacktop(char *s)‬
‭{‬
‭char i;‬
‭i=s[top];‬
‭return i;‬
‭}‬
‭void isproduct(char x,char p)‬
‭{‬
‭int k,l;‬
‭k=ister(x);‬
‭l=isstate(p);‬
‭strcpy(temp,A[l-1].row[k-1]);‬
‭}‬
‭int ister(char x)‬
‭{‬
‭int i;‬
‭for(i=0;i<6;i++)‬
‭if(x==ter[i])‬
‭return i+1;‬
‭return 0;‬
‭}‬
‭int isnter(char x)‬
‭{‬
‭int i;‬
‭for(i=0;i<3;i++)‬
‭if(x==nter[i])‬
‭return i+1;‬
‭return 0;‬
‭}‬
i‭nt isstate(char p)‬
‭{‬
‭int i;‬
‭for(i=0;i<12;i++)‬
‭if(p==states[i]) return i+1;‬
‭return 0;‬
‭}‬
‭void error()‬
‭{‬
‭printf(" error in the input ");‬
‭exit(0);‬
‭}‬
‭void isreduce(char x,char p)‬
‭{‬
‭int k,l;‬
‭k=isstate(x);‬
‭l=isnter(p);‬
‭strcpy(temp,G[k-1].r[l-1]);‬
‭}‬
‭char pop(char *s,int *sp)‬
‭{‬
‭char item;‬
‭if(*sp==-1)‬
‭printf(" stack is empty ");‬
‭else‬
‭{‬
‭item=s[*sp];‬
‭*sp=*sp-1;‬
‭}‬
‭return item;‬
‭}‬
‭void printt(char *t,int *p,charinp[],int i)‬
‭{‬
‭int r;‬
‭printf("\n");‬
‭for(r=0;r<=*p;r++)‬
‭rep(t,r);‬
‭printf("\t\t\t");‬
‭for(r=i;inp[r]!='\0';r++)‬
‭printf("%c",inp[r]);‬
‭}‬
‭void rep(char t[],int r)‬
‭{‬
‭char c;‬
‭c=t[r];‬
‭switch(c)‬
‭{‬
‭case 'a': printf("0");‬
‭break;‬
‭case 'b': printf("1");‬
‭break;‬
‭case 'c': printf("2");‬
‭break;‬
‭case 'd': printf("3");‬
‭break;‬
‭case 'e': printf("4");‬
‭ reak;‬
b
‭case 'f': printf("5");‬
‭break;‬
‭case 'g': printf("6");‬
‭break;‬
‭case 'h': printf("7");‬
‭break;‬
‭case 'm': printf("8");‬
‭break;‬
‭case 'j': printf("9");‬
‭break;‬
‭case 'k': printf("10");‬
‭break;‬
‭case 'l': printf("11");‬
‭break;‬
‭default :printf("%c",t[r]);‬
‭break;‬
‭}‬
‭}‬

‭Output:‬
 ‭PROGRAM-6‬
‭ BJECTIVE:‬
O
‭*Write a C program for constructing LL (1) parsing.‬
‭AIM:‬
‭Analyzing the construction of LL (1) parser.‬
‭RESOURCE:‬
‭Turbo C++‬
‭PROGRAM LOGIC:‬
∙‭the input string.‬
‭∙predictive parsing table parse the given input using stack .‬
‭∙stack [i] matches with token input string pop the token else shift it repeat the process until it reaches to $.‬
‭PROCEDURE:‬
‭∙to debug -> run or press CTRL + F9 to run the program.‬

‭PROGRAM‬

‭ include<stdio.h> #include<conio.h> #include<string.h> char s[20],stack[20]; void main()‬

#
‭{‬
‭char m[5][6][3]={"tb"," "," ","tb"," "," "," ","+tb"," "," ","n","n","fc"," "," ","fc"," "," ","‬
‭","n","*fc"," ","n","n","i"," "," ","(e)"," "," "};‬
‭int size[5][6]={2,0,0,2,0,0,0,3,0,0,1,1,2,0,0,2,0,0,0,1,3,0,1,1,1,0,0,3,0,0};‬
‭int i,j,k,n,str1,str2; clrscr();‬
‭printf("\n Enter the input string: "); scanf("%s",s);‬
‭strcat(s,"$"); n=strlen(s); stack[0]='$';‬
‭stack[1]='e'; i=1;‬
‭j=0;‬
‭printf("\nStack‬ ‭Input\n"); printf("‬ ‭\n"); while((stack[i]!='$')&&(s[j]!='$'))‬
‭{‬
‭if(stack[i]==s[j])‬
‭{‬
‭i--; j++;‬
‭}‬
‭switch(stack[i])‬
‭{‬
‭case 'e': str1=0; break;‬
‭case 'b': str1=1; break;‬
‭case 't': str1=2; break;‬
‭case 'c': str1=3; break;‬
‭case 'f': str1=4; break;‬
‭}‬
‭switch(s[j])‬
‭{‬
‭case 'i': str2=0; break;‬
‭case '+': str2=1; break;‬
‭case '*': str2=2; break;‬
‭case '(': str2=3; break;‬
‭case ')': str2=4; break;‬
‭case '$': str2=5; break;‬
‭}‬
‭if(m[str1][str2][0]=='\0')‬
‭{‬
‭printf("\nERROR"); exit(0);‬
‭}‬
‭else if(m[str1][str2][0]=='n') i--;‬
e‭ lse if(m[str1][str2][0]=='i') stack[i]='i';‬
‭else‬
‭{‬
‭for(k=size[str1][str2]-1;k>=0;k--)‬
‭{‬
‭stack[i]=m[str1][str2][k]; i++;‬
‭}‬
‭i--;‬
‭}‬
‭for(k=0;k<=i;k++)‬
‭printf(" %c",stack[k]); printf("‬ ‭"); for(k=j;k<=n;k++) printf("%c",s[k]); printf(" \n ");‬
‭}‬
‭printf("\n SUCCESS"); getch();‬
‭}‬

‭INPUT & OUTPUT:‬

‭Enter the input string:i*i+i‬

‭ TACK‬
S I‭ NPUT‬
‭$bt‬ ‭i*i+i$‬
‭$bcf‬ ‭i*i+i$‬
‭$bci‬ ‭i*i+i$‬
‭$bc‬ ‭*i+i$‬
‭$bcf*‬ ‭*i+i$‬
‭$bcf‬ ‭i+i$‬
‭$bci‬ ‭i+i$‬
‭$bc‬ ‭+i$‬
‭$b‬ ‭+i$‬
‭$bt+‬ ‭+i$‬
‭$bt‬ ‭i$‬
‭$bcf‬ ‭i$‬
‭$ bci‬ ‭i$‬
‭$bc‬ ‭$‬
‭$b‬ ‭$‬
‭$‬ ‭$‬
‭success‬
 ‭Program-7‬

‭OBJECTIVE:‬
‭ onstruction of recursive descent parsing for the following grammar E->TE'‬
C
‭E'->+TE/@‬ ‭"@ represents null character" T->FT'‬
‭T`->*FT'/@ F->(E)/ID‬

‭AIM:‬
‭Analyzing recursive descent parsing grammar.‬

‭RESOURCE:‬
‭Turbo C++‬

‭PROGRAM LOGIC:‬
‭‬ R
● ‭ ead the input string.‬
‭●‬ ‭Write procedures for the non terminals‬
‭●‬ ‭Verify the next token equals to non terminals if it satisfies match the non terminal. If the input string does not‬
‭match print error.‬

‭PROCEDURE:‬
‭Go to debug -> run or press CTRL + F9 to run the program.‬

‭PROGRAM:‬

‭ include<stdio.h> #include<conio.h> #include<string.h>‬

#
‭char input[100]; int i,l;‬
‭void main()‬
‭{‬
‭clrscr();‬
‭printf("\nRecursive descent parsing for the following grammar\n");‬
‭printf("\nE->TE'\nE'->+TE'/@\nT->FT'\nT'->*FT'/@\nF->(E)/ID\n"); printf("\nEnter the string to be checked:");‬
‭gets(input); if(E())‬
‭{‬
‭if(input[i+1]=='\0') printf("\nString is accepted"); else‬
‭printf("\nString is not accepted");‬
‭}‬
‭else‬
‭printf("\nString not accepted"); getch();‬
‭} E()‬
‭{‬
‭if(T())‬
‭{‬
‭if(EP())‬
‭return(1); else return(0);‬
‭}‬
‭else return(0);‬
‭} EP()‬
‭{‬
‭if(input[i]=='+')‬
‭{‬
‭i++; if(T())‬
‭{ if(EP())‬
r‭ eturn(1); else‬
‭return(0);‬
‭}‬
‭else‬
‭return(0);‬
‭}‬
‭else‬
‭return(1);‬
‭} T()‬
‭{‬
‭if(F())‬
‭{‬
‭if(TP())‬
‭return(1); else return(0);‬
‭}‬
‭else return(0);‬
‭} TP()‬
‭{‬
‭if(input[i]=='*')‬

{‭ ‬
‭i++; if(F())‬
‭{‬
‭if(TP())‬
‭return(1); else return(0);‬
‭}‬
‭else return(0);‬
‭}‬
‭else return(1);‬
‭} F()‬
‭{‬
‭if(input[i]=='(')‬
‭{‬
‭i++; if(E())‬
‭{‬
‭if(input[i]==')')‬
‭{‬
‭i++;‬
‭return(1);‬
‭}‬
‭else‬
‭return(0);‬
‭}‬
‭else return(0);‬
‭}‬
‭else if(input[i]>='a'&&input[i]<='z'||input[i]>='A'&&input[i]<='Z')‬
{‭ ‬
‭i++;‬
‭return(1);‬
‭}‬
‭else‬
‭return(0);‬
‭}‬

‭INPUT & OUTPUT:‬

I‭ NPUT:‬
‭Recursive descent parsing for the following grammar‬
‭E->TE'‬
‭E'->+TE'/@ T->FT'‬
‭T'->*FT'/@ F->(E)/ID‬

‭Enter the string to be checked:(a+b)*c‬

‭OUTPUT:‬

‭String is accepted‬

‭INPUT:‬

‭ ecursive descent parsing for the following grammar E->TE'‬

R
‭E'->+TE'/@ T->FT'‬
‭T'->*FT'/@ F->(E)/ID‬

‭Enter the string to be checked:a/c+d‬

‭OUTPUT:‬

‭String is not accepted‬

 ‭Program-8‬
‭ rite a program to accept a string (ab)‬
W
‭#include<iostream.h>‬
‭#include<conio.h>‬
‭#include<string.h>‬
‭enum position{true,false};‬
‭int main()‬
‭{‬
‭clrscr();‬
‭enum position postn=true;‬
‭char*str;‬
‭cout<<"Place an input string:: ";‬
‭cin>>str;‬
‭int lng=strlen(str);‬
‭for(int count=0;count<lng-1;count++)‬
‭{‬
‭if(*str=='a' && count%2==0)‬
‭{‬
‭postn=true;‬
‭}‬
‭else if(*str=='b' && count%2==1)‬
‭{‬
‭postn=true;‬
‭}‬
‭else if(*str=='a' && count%2==1)‬
‭{‬
‭postn=false;‬
‭break;‬
‭}‬
‭str++;‬
‭}‬
‭if(*str=='b' && postn==true)‬
‭{‬
‭cout<<"\nInput string belongs to the given grammar";‬
‭}‬
‭else‬
‭cout<<"\nInput string does not belong to given grammar";‬
‭getch();‬
‭return 0;‬
‭}‬

‭OUTPUT:‬
 ‭Program-9‬
‭ rite a program to generate a parse tree‬
W
‭#include<iostream.h>‬
‭#include<conio.h>‬
‭void main()‬
‭{‬
‭clrscr();‬
‭char op;‬
‭int ans,val1,val2;‬
‭cout<<"\n Enter the first operand:- ";‬
‭cin>>val1;‬
‭cout<<"\n Enter the second operand:- ";‬
‭cin>>val2;‬
‭cout<<"\n Enter the operation you want to perform:- ";‬
‭cin>>op;‬

s‭ witch(op)‬
‭{‬
‭case '+' :{ ans=val1+val2;}‬
‭break;‬
‭case '-' :{ ans=val1-val2;}‬
‭break;‬
‭case '*' :{ ans=val1*val2;}‬
‭break;‬
‭case '/' :{ ans=val1/val2;}‬
‭break;‬
‭}‬
‭cout<<"\n The Parse Tree for the Equation "<<num1<<operatr<<num2<<"="<<ans" is:";‬
‭cout<<"\n\n";‬
‭cout<<"\n = ";‬
‭cout<<"\n / \\" ;‬
‭cout<<"\n / \\";‬
‭cout<<"\n‬ ‭"<<op<<" "<<ans;‬
‭cout<<"\n / \\ ";‬
‭cout<<"\n / \\ ";‬
‭cout<<"\n "<<val1<<" "<<val2;‬
‭cout<<"\n\n\n";‬
‭getch();‬
‭}‬

‭OUTPUT:‬
 ‭Program-10‬
‭Write a program to find leading terminals.‬

‭ include<iostream.h>‬
#
‭#include<stdio.h>‬
‭#include<conio.h>‬
‭#include<string.h>‬

‭ oid install(char x,char y);‬

v
‭void pop();‬
‭int pon(char u);‬
‭int pot(char v);‬
‭int checkstatus(int a,int b);‬

i‭nt n,d,f,xn,xt,top=-1;‬
‭char X,Y;‬
‭int a[20][20];‬
‭char terminal[20],nonterm[20];‬

‭struct production‬
‭{‬
‭char l;‬
‭char r[10];‬
‭};‬

‭struct stack‬
‭{‬
‭char nt;‬
‭char t;‬
‭};‬

s‭ truct stack st[20];‬

‭struct production prod[20];‬

‭void main()‬
‭{‬

‭clrscr();‬

c‭ out<<"Provide the number of terminals: ";‬

‭cin>>d;‬
‭cout<<"Provide the terminal symbols for your production: ";‬
‭for(int k=0;k<d;k++)‬
‭{‬
‭cin>>terminal[k];‬
‭}‬

c‭ out<<"\n Provide the number of non-terminals: ";‬

‭cin>>f;‬
‭cout<<"Provide the non-terminal symbols for your production:";‬
‭for(k=0;k<f;k++)‬
‭{‬
‭cin>>nonterm[k];‬
‭}‬
 c‭ out<< "\nHow many productions you want to Provide?? ";‬
‭cin>>n;‬
‭for(int i=0;i<=n-1;i++)‬
‭{‬
‭cout<<"Provide the "<< i+1<<" production: ";‬
‭cin>>prod[i].l;‬
‭cout<<"->";‬
‭cin>>prod[i].r;‬
‭}‬

f‭ or(int p=0;p<f;p++)‬
‭{‬
‭for(int q=0;q<d;q++)‬
‭{‬
‭a[p][q]=0;‬
‭}‬
‭}‬
‭for(i=0;i<=n-1;i++)‬
‭{‬
‭for(int j=0;j<d;j++)‬
‭{‬
‭if(prod[i].r[0]==terminal[j])‬
‭install(prod[i].l,prod[i].r[0]);‬
‭else if(prod[i].r[1]==terminal[j])‬
‭install(prod[i].l,prod[i].r[1]);‬
‭}‬
‭}‬

‭ hile(top>-1)‬
w
‭{‬
‭pop();‬
‭for(int c=0;c<=n-1;c++)‬
‭{‬
‭if(prod[c].r[0]==X)‬
‭install(prod[c].l,Y);‬
‭}‬
‭}‬

‭//Output‬
c‭ out<<"\n\n----------------------------------------------------------------";‬
‭cout<<"\n leading elements are:- " ;‬
‭cout<<"\n\n-----------------------------------------------------------------";‬

‭cout<<endl<<" ";‬
‭for(int w=0;w<d;w++)‬
‭cout<<" "<<terminal[w];‬
‭cout<<endl;‬
‭for(p=0;p<f;p++)‬
‭{‬
‭cout<<nonterm[p]<<" ";‬
‭for(int q=0;q<d;q++)‬
‭{‬
‭cout<<a[p][q]<<" ";‬
 }‭ ‬
‭cout<<endl;‬
‭}‬

‭ etch();‬
g
‭}‬

‭ oid install(char x,char y)‬

v
‭{‬
‭int g;‬
‭xn=pon(x);‬
‭xt=pot(y);‬
‭g=checkstatus(xn,xt);‬
‭if(g==0)‬
‭return;‬
‭else if(g==1)‬
‭{‬
‭top++;‬
‭st[top].nt=x;‬
‭st[top].t=y;‬
‭a[xn][xt]=1;‬
‭}‬
‭}‬

‭ oid pop()‬
v
‭{‬
‭X=st[top].nt;‬
‭Y=st[top].t;‬
‭top--;‬
‭}‬

i‭nt pon(char u)‬

‭{‬
‭for(int x=0;x<f;x++)‬
‭{‬
‭if(u==nonterm[x])‬
‭return x;‬
‭}‬
‭}‬

i‭nt pot(char v)‬

‭{‬
‭for(int x=0;x<d;x++)‬
‭{‬
‭if(v==terminal[x])‬
‭return x;‬
‭}‬
‭}‬
‭int checkstatus(int xn,int xt)‬
‭{‬
‭if(a[xn][xt]==1)‬
‭return 0;‬
‭else‬
‭return 1;‬
‭}‬
‭OUTPUT:‬
 ‭Program-11‬
‭Write a program to find Trailing elements‬

‭ include<iostream.h>‬
#
‭#include<stdio.h>‬
‭#include<conio.h>‬
‭#include<string.h>‬

‭ oid install(char x,char y);‬

v
‭void pop();‬
‭int pon(char u);‬
‭int pot(char v);‬
‭int checkstatus(int a,int b);‬

i‭nt n,d,f,xn,xt,top=-1;‬
‭char X,Y;‬
‭int a[20][20];‬
‭char terminal[20],nonterm[20];‬

s‭ truct production‬
‭{‬
‭char l;‬
‭char r[10];‬
‭int rear;‬
‭};‬
‭struct stack‬
‭{‬
‭char nt;‬
‭char t;‬
‭};‬
‭struct stack st[20];‬
‭struct production prod[20];‬

‭ oid main()‬
v
‭{‬
‭clrscr();‬
‭cout<<"Enter the number of terminals: ";‬
‭cin>>d;‬
‭cout<<"Enter the terminal symbols for your production: ";‬
‭for(int k=0;k<d;k++)‬
‭{‬
‭cin>>terminal[k];‬
‭}‬

‭//Input of non-terminal symbols‬

‭cout<<"\nEnter the number of non-terminals: ";‬
‭cin>>f;‬
‭cout<<"Enter the non-terminal symbols for your production: ";‬
‭for(k=0;k<f;k++)‬
‭{‬
‭cin>>nonterm[k];‬
‭}‬

c‭ out<< "\nEnter the number of productions: ";‬

‭cin>>n;‬
 f‭ or(int i=0;i<=n-1;i++)‬
‭{‬
‭cout<<"Enter the "<< i+1<<" production: ";‬
‭cin>>prod[i].l;‬
‭cout<<"->";‬
‭cin>>prod[i].r;‬
‭prod[i].rear=strlen(prod[i].r);‬
‭}‬

‭for(int p=0;p<f;p++)‬
‭{‬
‭for(int q=0;q<d;q++)‬
‭{‬
‭a[p][q]=0;‬
‭}‬
‭}‬
‭for(i=0;i<=n-1;i++)‬
‭{‬
‭for(int j=0;j<d;j++)‬
‭{‬
‭if(prod[i].r[prod[i].rear-1]==terminal[j])‬
‭install(prod[i].l,prod[i].r[prod[i].rear-1]);‬
‭else if(prod[i].r[prod[i].rear-2]==terminal[j])‬
‭install(prod[i].l,prod[i].r[prod[i].rear-2]);‬
‭}‬
‭}‬

‭ hile(top>-1)‬
w
‭{‬
‭pop();‬
‭for(int c=0;c<=n-1;c++)‬
‭{‬
‭if(prod[c].r[prod[c].rear-1]==X)‬
‭install(prod[c].l,Y);‬
‭}‬
‭}‬

c‭ out<<"\n\n****************************************************";‬
‭cout<<"\n TRAILING ELEMENTS OF GIVEN PRODUCTION ";‬
‭cout<<"\n****************************************************** ";‬
‭cout<<endl<<" ";‬
‭for(int w=0;w<d;w++)‬
‭cout<<" "<<terminal[w];‬
‭cout<<endl;‬
‭for(p=0;p<f;p++)‬
‭{‬
‭cout<<nonterm[p]<<" ";‬
‭for(int q=0;q<d;q++)‬
‭{‬
‭cout<<a[p][q]<<" ";‬
‭}‬
‭cout<<endl;‬
‭}‬
‭cout<<endl<<endl;‬
‭for(i=0;i<f;i++)‬
‭{‬
 c‭ out<<"Leading("<<nonterm[i]<<")="<<" "<<"{";‬
‭for(int j=0;j<d;j++)‬
‭{‬
‭if(a[i][j]==1)‬
‭cout<<terminal[j]<<",";‬
‭}‬
‭cout<<"}"<<endl;‬
}‭ ‬
‭getch();‬
‭}‬
‭ oid install(char x,char y)‬
v
‭{‬
‭int g;‬
‭xn=pon(x);‬
‭xt=pot(y);‬
‭g=checkstatus(xn,xt);‬
‭if(g==0)‬
‭return;‬
‭else if(g==1)‬
‭{‬
‭top++;‬
‭st[top].nt=x;‬
‭st[top].t=y;‬
‭a[xn][xt]=1;‬
‭}‬
‭}‬
‭void pop()‬
‭{‬
‭X=st[top].nt;‬
‭Y=st[top].t;‬
‭top--;‬
‭}‬
‭int pon(char u)‬
‭{‬
‭for(int x=0;x<f;x++)‬
‭{‬
‭if(u==nonterm[x])‬
‭return x;‬
‭}‬
‭}‬
‭int pot(char v)‬
‭{‬
‭for(int x=0;x<d;x++)‬
‭{‬
‭if(v==terminal[x])‬
‭return x;‬
‭}‬
‭}‬

i‭nt checkstatus(int xn,int xt)‬

‭{‬
‭if(a[xn][xt]==1)‬
‭return 0;‬
‭else‬
‭return 1;‬
‭}‬
‭OUTPUT:‬
 ‭Program-12‬
‭Write a program to compute FIRST of non-terminal.‬

‭ include<iostream.h>‬
#
‭#include<stdio.h>‬
‭#include<conio.h>‬
‭#include<string.h>‬
‭void install(char a,char b);‬
‭void pop();‬
‭int pontr(char t);‬
‭int potr(char s);‬
‭int checkstatus(int x1,int x2);‬
‭struct prod‬
‭{‬
‭char lf;‬
‭char rt[10];‬
‭int rear1;‬
‭};‬
‭struct mystack‬
‭{‬
‭char u;‬
‭char v;‬
‭};‬
‭struct mystack stk[25];‬
‭struct prod pr[25];‬
‭int q,w,e,xn1,xt1,tn0,tn1,tn2,top1=-1;‬
‭char A,B,epsiln='^';‬
‭int ar1[25][25];‬
‭char term[25],nterm[25];‬
‭void main()‬
‭{‬
‭clrscr();‬
‭cout<<"provide no. of terminal::";‬
‭cin>>q;‬
‭cout<<"provide the terminal symbols::";‬
‭for(int cnt=0;cnt<q;cnt++)‬
‭{‬
‭cin>>term[cnt];‬
‭}‬
‭cout<<"provide no. of nonterminal::";‬
‭cin>>w;‬
‭cout<<"provide the nonterminal symbols::";‬
‭for(cnt=0;cnt<w;cnt++)‬
‭{‬
‭cin>>nterm[cnt];‬
‭}‬
‭cout<<"provide no. of production rules::";‬
‭cin>>e;‬
‭for(cnt=0;cnt<=e-1;cnt++)‬
‭{‬
‭cout<<"provide "<<cnt+1<<".)production rule::";‬
‭cin>>pr [cnt].lf;‬
‭cout<<"->";‬
‭cin>>pr [cnt].rt;‬
‭pr [cnt].rear1=strlen(pr [cnt].rt);‬
}‭ ‬
‭for(int cnt1=0;cnt1<=w+q;cnt1++)‬
‭{‬
‭for(int cnt2=0;cnt2<=q;cnt2++)‬
‭{‬
‭ar1[cnt1][cnt2]=0;‬
‭}‬
‭}‬
‭for(cnt1=w;cnt1<w+q;cnt1++)‬
‭{‬
‭for(int cnt2=0;cnt2<q;cnt2++)‬
‭{‬
‭if(cnt1-w==cnt2)‬
‭ar1[cnt1][cnt2]=1;‬
‭}‬
‭}‬
‭for(cnt1=0;cnt1<=e-1;cnt1++)‬
‭{‬
‭for(int cnt2=0;cnt2<q;cnt2++)‬
‭{‬
‭if(pr[cnt1].rt[0]==term[cnt2]);‬
‭install(pr[cnt1].lf,pr[cnt1].rt[0]);‬
‭}‬
‭if(pr[cnt1].rt[0]==epsiln)‬
‭ar1[pontr(pr[cnt1].lf)][q]=1;‬
‭}‬
‭while(top1>-1)‬
‭{‬
‭pop();‬
‭for(int i=0;i<=e-1;i++)‬
‭{‬
‭if(pr[i].rt[0]==A)‬
‭{‬
‭install(pr[i].lf,B);‬
‭for(int q=1;q<pr[i].rear1;q++)‬
‭{‬
‭tn0=pontr(pr[i].rt[q-1]);‬
‭if(ar1[tn0][q]!=1)‬
‭break;‬
‭for(int l=0;l<w;l++)‬
‭{‬
‭if(pr[i].rt[0]==nterm[l])‬
‭{‬
‭tn1=pontr(pr[i].rt[q]);‬
‭tn2=pontr(pr[i].lf);‬
‭for(int h=0;h<q;h++)‬
‭{‬
‭if(ar1[tn1][h]==1)‬
‭ar1[tn2][h]=1;‬
‭}‬
‭}‬
‭}‬
‭for(l=0;l<q;l++)‬
‭{‬
‭if(pr[i].rt[q]==term [l])‬
‭{‬
t‭n1=potr(pr[i].rt[q]);‬
‭tn2=pontr(pr[i].lf);‬
‭ar1[tn2][tn1]=1;‬
‭}‬
‭}‬
‭}‬
‭}}}‬
‭cout<<"<Leading Of productions are::->";‬
‭cout<<endl<<"";‬
‭for(int g=0;g<q;g++)‬
‭cout<<""<<term[g];‬
‭cout<<""<<epsiln;‬
‭cout<<endl;‬
‭for(cnt1=0;cnt1<w;cnt1++)‬
‭{cout<<nterm[cnt1]<<"";‬
‭for(int cnt2=0;cnt2<=q;cnt2++)‬
‭cout<<ar1[cnt1][cnt2]<<"";‬
‭cout<<endl;‬
‭}‬
‭for(cnt1=w;cnt1<q+w;cnt1++)‬
‭{‬
‭cout<<term[cnt1-w]<<"";‬
‭for(int cnt2=0;cnt2<=q;cnt2++)‬
‭cout<<ar1[cnt1][cnt2]<<"";‬
‭cout<<endl;‬
‭}‬
‭cout<<epsiln<<"";‬
‭for(int cnt2=0;cnt2<=q;cnt2++)‬
‭cout<<ar1[q+w][cnt2]<<"";‬
‭cout<<endl<<endl;‬
‭for(cnt1=0;cnt1<w;cnt1++)‬
‭{‬
‭cout<<"Leading("<<nterm[cnt1]<<")="<<""<<"{";‬
‭for(int cnt2=0;cnt2<q;cnt2++)‬
‭{‬
‭if(ar1[cnt1][cnt2]==1)‬
‭cout<<term[cnt2];‬
‭}‬
‭if(ar1[cnt1][q]==1)‬
‭cout<<epsiln;‬
‭cout<<"}"<<endl;‬
‭}‬
‭getch();}‬
‭void install(char a,char b)‬
‭{‬
‭xn1=pontr(a);‬
‭xt1=potr(b);‬
‭e=checkstatus(xn1,xt1);‬
‭if(e==0)‬
‭return;‬
‭else if(e==1)‬
‭{‬
‭top1++;‬
‭stk[top1].u=a;‬
‭stk[top1].v=b;‬
‭ar1[xn1][xt1]=1;‬
 }‭ ‬
‭}‬
‭void pop()‬
‭{‬
‭A=stk[top1].u;‬
‭B=stk[top1].v;‬
‭top1--;‬
‭}‬
‭int pontr(char t)‬
‭{‬
‭for(int a=0;a<w;a++)‬
‭{‬
‭if(t==nterm[a])‬
‭return a;‬
‭}‬
‭}‬
‭int potr(char s)‬
‭{‬
‭for(int a=0;a<q;a++)‬
‭{‬
‭if(s==term[a])‬
‭return a;‬
‭}‬
‭}‬
‭int checkstatus(int xn1,int xt1)‬
‭{‬
‭if(ar1[xn1][xt1]==1)‬
‭return 0;‬
‭else‬
‭return 1;‬

‭OUTPUT:‬
 ‭Program-13‬
‭Write a program to compute FOLLOW of non-terminal‬

‭ include<stdio.h>‬
#
‭#include<ctype.h>‬
‭#include<string.h>‬

/‭/ Functions to calculate Follow‬

‭void followfirst(char, int, int);‬
‭void follow(char c);‬

/‭/ Function to calculate First‬

‭void findfirst(char, int, int);‬

‭int count, n = 0;‬

/‭/ Stores the final result ‬

‭// of the First Sets‬
‭char calc_first[10][100];‬

/‭/ Stores the final result‬

‭// of the Follow Sets‬
‭char calc_follow[10][100];‬
‭int m = 0;‬

/‭/ Stores the production rules‬

‭char production[10][10];‬
‭char f[10], first[10];‬
‭int k;‬
‭char ck;‬
‭int e; ‬
‭int main(int argc, char **argv)‬
‭{‬
‭ int jm = 0;‬
‭ int km = 0;‬
‭ int i, choice;‬
‭ char c, ch;‬
‭ count = 8;‬
‭ // The Input grammar‬
‭ strcpy(production[0], "E=TR");‬
‭ strcpy(production[1], "R=+TR");‬
‭ strcpy(production[2], "R=#");‬
‭ strcpy(production[3], "T=FY");‬
‭ strcpy(production[4], "Y=*FY");‬
‭ strcpy(production[5], "Y=#");‬
‭ strcpy(production[6], "F=(E)");‬
‭ strcpy(production[7], "F=i");‬

‭ int kay;‬
‭ char done[count];‬
‭ int ptr = -1;‬

‭ // Initializing the calc_first array‬

‭ for(k = 0; k < count; k++) {‬
‭ for(kay = 0; kay < 100; kay++) {‬
‭ calc_first[k][kay] = '!';‬
‭ }‬
‭ }‬
‭ int point1 = 0, point2, xxx;‬

‭ for(k = 0; k < count; k++)‬

‭ {‬
‭ c = production[k][0];‬
‭ point2 = 0;‬
‭ xxx = 0;‬

‭ // Checking if First of c has‬

‭ // already been calculated‬
‭ for(kay = 0; kay <= ptr; kay++)‬
‭ if(c == done[kay])‬
‭ xxx = 1;‬

‭ if (xxx == 1)‬
‭ continue;‬

‭ // Function call ‬
‭ findfirst(c, 0, 0);‬
‭ ptr += 1;‬

‭ // Adding c to the calculated list‬

‭ done[ptr] = c;‬
‭ printf("\n First(%c) = { ", c);‬
‭ calc_first[point1][point2++] = c;‬

‭ // Printing the First Sets of the grammar‬

‭ for(i = 0 + jm; i < n; i++) {‬
‭ int lark = 0, chk = 0;‬

‭ for(lark = 0; lark < point2; lark++) {‬

‭ if (first[i] == calc_first[point1][lark])‬
‭ {‬
‭ chk = 1;‬
‭ break;‬
‭ }‬
‭ }‬
‭ if(chk == 0)‬
‭ {‬
‭ printf("%c, ", first[i]);‬
‭ calc_first[point1][point2++] = first[i];‬
‭ }‬
‭ }‬
‭ printf("}\n");‬
‭ jm = n;‬
‭ point1++;‬
‭ }‬
‭ printf("\n");‬
‭ printf("-----------------------------------------------\n\n");‬
‭ char donee[count];‬
‭ ptr = -1;‬

‭ // Initializing the calc_follow array‬

‭ for(k = 0; k < count; k++) {‬
‭ for(kay = 0; kay < 100; kay++) {‬
‭ calc_follow[k][kay] = '!';‬
‭ }‬
‭ }‬
‭ point1 = 0;‬
‭ int land = 0;‬
‭ for(e = 0; e < count; e++)‬
‭ {‬
‭ ck = production[e][0];‬
‭ point2 = 0;‬
‭ xxx = 0;‬

‭ // Checking if Follow of ck‬

‭ // has alredy been calculated‬
‭ for(kay = 0; kay <= ptr; kay++)‬
‭ if(ck == donee[kay])‬
‭ xxx = 1;‬

‭ if (xxx == 1)‬
‭ continue;‬
‭ land += 1;‬

‭ // Function call‬
‭ follow(ck);‬
‭ ptr += 1;‬

‭ // Adding ck to the calculated list‬

‭ donee[ptr] = ck;‬
‭printf(" Follow(%c) = { ", ck);‬
‭ calc_follow[point1][point2++] = ck;‬

‭ // Printing the Follow Sets of the grammar‬

‭ for(i = 0 + km; i < m; i++) {‬
‭ int lark = 0, chk = 0;‬
‭ for(lark = 0; lark < point2; lark++) ‬
‭ {‬
‭ if (f[i] == calc_follow[point1][lark])‬
‭ {‬
‭ chk = 1;‬
‭ break;‬
‭ }‬
‭ }‬
‭ if(chk == 0)‬
‭ {‬
‭ printf("%c, ", f[i]);‬
‭ calc_follow[point1][point2++] = f[i];‬
‭ }‬
‭ }‬
‭ printf(" }\n\n");‬
‭ km = m;‬
‭ point1++; ‬
‭ }‬
‭}‬

‭void follow(char c)‬

{‭ ‬
‭ int i, j;‬

‭ // Adding "$" to the follow‬

‭ // set of the start symbol‬
‭ if(production[0][0] == c) {‬
‭ f[m++] = '$';‬
‭ }‬
‭ for(i = 0; i < 10; i++)‬
‭ {‬
‭ for(j = 2;j < 10; j++)‬
‭ {‬
‭ if(production[i][j] == c)‬
‭ {‬
‭ if(production[i][j+1] != '\0')‬
‭ {‬
‭ // Calculate the first of the next‬
‭ // Non-Terminal in the production‬
‭ followfirst(production[i][j+1], i, (j+2));‬
‭ }‬

‭ if(production[i][j+1]=='\0' && c!=production[i][0])‬

‭ {‬
‭ // Calculate the follow of the Non-Terminal‬
‭ // in the L.H.S. of the production‬
‭ follow(production[i][0]);‬
‭ }‬
‭ }‬
‭ }‬
‭ }‬
‭}‬

‭ oid findfirst(char c, int q1, int q2)‬

v
‭{‬
‭ int j;‬

‭ // The case where we ‬

‭ // encounter a Terminal‬
‭ if(!(isupper(c))) {‬
‭ first[n++] = c;‬
‭ }‬
‭ for(j = 0; j < count; j++)‬
‭ {‬
‭ if(production[j][0] == c)‬
‭ {‬
‭ if(production[j][2] == '#')‬
‭ {‬
‭ if(production[q1][q2] == '\0')‬
‭ first[n++] = '#';‬
‭ else if(production[q1][q2] != '\0' ‬
‭ && (q1 != 0 || q2 != 0))‬
‭ {‬
‭ // Recursion to calculate First of New‬
‭ // Non-Terminal we encounter after epsilon‬
‭ findfirst(production[q1][q2], q1, (q2+1));‬
‭ }‬
‭ else‬
‭ first[n++] = '#';‬
‭ }‬
‭ else if(!isupper(production[j][2]))‬
‭ {‬
‭ first[n++] = production[j][2];‬
‭ }‬
‭ else ‬
‭ {‬
‭ // Recursion to calculate First of‬
‭ // New Non-Terminal we encounter ‬
‭ // at the beginning‬
‭ findfirst(production[j][2], j, 3);‬
‭ }‬
‭ }‬
‭ }‬
‭}‬

‭ oid followfirst(char c, int c1, int c2)‬

v
‭{‬
‭ int k;‬
‭ // The case where we encounter‬
‭ // a Terminal‬
‭ if(!(isupper(c)))‬
‭ f[m++] = c;‬
‭ else‬
‭ {‬
‭ int i = 0, j = 1;‬
‭ for(i = 0; i < count; i++)‬
‭ {‬
‭ if(calc_first[i][0] == c)‬
‭ break;‬
‭ }‬

‭ //Including the First set of the‬

‭ // Non-Terminal in the Follow of‬
‭ // the original query‬
‭ while(calc_first[i][j] != '!')‬
‭ {‬
‭ if(calc_first[i][j] != '#') ‬
‭ {‬
‭ f[m++] = calc_first[i][j];‬
‭ }‬
‭ else‬
‭ {‬
‭ if(production[c1][c2] == '\0')‬
‭ {‬
‭ // Case where we reach the‬
‭ // end of a production‬
‭ follow(production[c1][0]);‬
‭ }‬
‭ else‬
‭ {‬
‭ // Recursion to the next symbol‬
‭ // in case we encounter a "#"‬
‭ followfirst(production[c1][c2], c1, c2+1);‬
‭ }‬
‭ }‬
‭ j++;‬
‭ }‬
‭ }‬
‭}‬

‭Output‬

‭ ollow(E) = { $, ), }‬
F
‭Follow(R) = { $, ), }‬
‭Follow(T) = { +, $, ), }‬
‭Follow(Y) = { +, $, ), }‬
‭Follow(F) = { *, +, $, ), }‬
‭Program-14‬

‭Write a program to check whether a grammar is left Recursion and remove left Recursion of grammar‬

‭ include<iostream.h>‬
#
‭#include<stdio.h>‬
‭#include<conio.h>‬
‭#include<string.h>‬

s‭ truct production‬
‭{‬
‭char l;‬
‭char r[10];‬
‭int rear;‬
‭};‬
‭struct production prod[20],pr_new[20];‬

i‭nt p=0,b=0,d,f,q,n,flag=0;‬
‭char terminal[20],nonterm[20],alpha[10];‬
‭char x,epsilon='^';‬

‭ oid main()‬
v
‭{‬
‭clrscr();‬

c‭ out<<"Enter the number of terminals: ";‬

‭cin>>d;‬
‭cout<<"Enter the terminal symbols for your production: ";‬
‭for(int k=0;k<d;k++)‬
‭{‬
‭cin>>terminal[k];‬
‭}‬

c‭ out<<"\nEnter the number of non-terminals: ";‬

‭cin>>f;‬
‭cout<<"Enter the non-terminal symbols for your production: ";‬
‭for(k=0;k<f;k++)‬
‭{‬
‭cin>>nonterm[k];‬
‭}‬

c‭ out<<"\nEnter the number of Special characters(except non-terminals): ";‬

‭cin>>q;‬
‭cout<<"Enter the special characters for your production: ";‬
‭for(k=0;k<q;k++)‬
‭{‬
‭cin>>alpha[k];‬
‭}‬

c‭ out<<"\nEnter the number of productions: ";‬

‭cin>>n;‬
‭for(k=0;k<=n-1;k++)‬
‭{‬
‭cout<<"Enter the "<< k+1<<" production: ";‬
‭cin>>prod[k].l;‬
‭cout<<"->";‬
 ‭cin>>prod[k].r;‬
‭prod[k].rear=strlen(prod[k].r);‬
‭}‬

f‭ or(int m=0;m<f;m++)‬
‭{‬
‭x=nonterm[m];‬
‭for(int j=0;j<n;j++)‬
‭{‬
‭if((prod[j].l==x)&&(prod[j].r[0]==prod[j].l))‬
‭flag=1;‬
‭}‬
‭for(int i=0;i<n;i++)‬
‭{‬
‭if((prod[i].l==x)&&(prod[i].r[0]!=x)&&(flag==1))‬
‭{‬
‭pr_new[b].l=x;‬
‭for(int c=0;c<prod[i].rear;c++)‬
‭pr_new[b].r[c]=prod[i].r[c];‬
‭pr_new[b++].r[c]=alpha[p];‬
‭}‬
‭else if((prod[i].l==x)&&(prod[i].r[0]==x)&&(flag==1))‬
‭{‬
‭pr_new[b].l=alpha[p];‬
‭for(int a=0;a<=prod[i].rear-2;a++)‬
‭pr_new[b].r[a]=prod[i].r[a+1];‬
‭pr_new[b++].r[a]=alpha[p];‬
‭pr_new[b].l=alpha[p];‬
‭pr_new[b++].r[0]=epsilon;‬
‭}‬
‭else if((prod[i].l==x)&&(prod[i].r[0]!=x)&&(flag==0))‬
‭{‬
‭pr_new[b].l=prod[i].l;‬
‭strcpy(pr_new[b].r,prod[i].r);‬
‭b++;‬
‭}}‬
‭flag=0;‬
‭p++;‬
‭}‬
‭cout<<"\n\n*******************************************";‬
‭cout<<"\n AFTER REMOVING LEFT RECURSION ";‬
‭cout<<"\n*******************************************"<<endl;‬
‭for(int s=0;s<=b-1;s++)‬
‭{‬
‭cout<<"Production "<<s+1<<" is: ";‬
‭cout<<pr_new[s].l;‬
‭cout<<"->";‬
‭cout<<pr_new[s].r;‬
‭cout<<endl;‬
‭}‬
‭getche(); }‬
‭OUTPUT:‬
‭Program-15‬

‭Write a program to remove left factoring of grammar.‬

‭ include<iostream.h>‬
#
‭#include<stdio.h>‬
‭#include<conio.h>‬
‭#include<string.h>‬

‭//Structure Declaration‬

s‭ truct production‬
‭{‬
‭char lf;‬
‭char rt[10];‬
‭int prod_rear;‬
‭int fl;‬
‭};‬
‭struct production prodn[20],prodn_new[20];‬ ‭//Creation of object‬

/‭/Variables Declaration‬
‭int b=-1,d,f,q,n,m=0,c=0;‬
‭char terminal[20],nonterm[20],alpha[10],extra[10];‬
‭char epsilon='^';‬

/‭/Beginning of Main Program‬

‭void main()‬
‭{‬
‭clrscr();‬

/‭/Input of Special characters‬

‭cout<<"\nEnter the number of Special characters(except non-terminals): ";‬
‭cin>>q;‬
‭cout<<"Enter the special characters for your production: ";‬
‭for(int cnt=0;cnt<q;cnt++)‬
‭{‬
‭cin>>alpha[cnt];‬
‭}‬

/‭/Input of Productions‬
‭cout<<"\nEnter the number of productions: ";‬
‭cin>>n;‬
‭for(cnt=0;cnt<=n-1;cnt++)‬
‭{‬
‭cout<<"Enter the "<< cnt+1<<" production: ";‬
‭cin>>prodn[cnt].lf;‬
‭cout<<"->";‬
‭cin>>prodn[cnt].rt;‬
‭prodn[cnt].prod_rear=strlen(prodn[cnt].rt);‬
‭prodn[cnt].fl=0;‬
‭}‬

/‭/Condition for left factoring‬

‭for(int cnt1=0;cnt1<n;cnt1++)‬
‭{‬
‭for(int cnt2=cnt1+1;cnt2<n;cnt2++)‬
 ‭{‬
i‭f(prodn[cnt1].lf==prodn[cnt2].lf)‬
‭{‬
‭cnt=0;‬
‭int p=-1;‬
‭while((prodn[cnt1].rt[cnt]!='\0')&&(prodn[cnt2].rt[cnt]!='\0'))‬
‭{‬
‭if(prodn[cnt1].rt[cnt]==prodn[cnt2].rt[cnt])‬
‭{‬
‭extra[++p]=prodn[cnt1].rt[cnt];‬
‭prodn[cnt1].fl=1;‬
‭prodn[cnt2].fl=1;‬
‭}‬
‭else‬
‭{‬
‭if(p==-1)‬
‭break;‬
‭else‬
‭{‬
i‭nt h=0,u=0;‬
‭prodn_new[++b].lf=prodn[cnt1].lf;‬
‭strcpy(prodn_new[b].rt,extra);‬
‭prodn_new[b].rt[p+1]=alpha[c];‬
‭prodn_new[++b].lf=alpha[c];‬
‭for(int g=cnt;g<prodn[cnt2].prod_rear;g++)‬
‭prodn_new[b].rt[h++]=prodn[cnt2].rt[g];‬
‭prodn_new[++b].lf=alpha[c];‬
‭for(g=cnt;g<=prodn[cnt1].prod_rear;g++)‬
‭prodn_new[b].rt[u++]=prodn[cnt1].rt[g];‬
‭m=1;‬
‭break;‬
}‭ ‬
‭}‬
‭cnt++;‬
‭}‬
‭if((prodn[cnt1].rt[cnt]==0)&&(m==0))‬
‭{‬
‭int h=0;‬
‭prodn_new[++b].lf=prodn[cnt1].lf;‬
‭strcpy(prodn_new[b].rt,extra);‬
‭prodn_new[b].rt[p+1]=alpha[c];‬
‭prodn_new[++b].lf=alpha[c];‬
‭prodn_new[b].rt[0]=epsilon;‬
‭prodn_new[++b].lf=alpha[c];‬
‭for(int g=cnt;g<prodn[cnt2].prod_rear;g++)‬
‭prodn_new[b].rt[h++]=prodn[cnt2].rt[g];‬
‭}‬
‭if((prodn[cnt2].rt[cnt]==0)&&(m==0))‬
‭{‬
‭int h=0;‬
‭prodn_new[++b].lf=prodn[cnt1].lf;‬
‭strcpy(prodn_new[b].rt,extra);‬
‭prodn_new[b].rt[p+1]=alpha[c];‬
‭prodn_new[++b].lf=alpha[c];‬
‭prodn_new[b].rt[0]=epsilon;‬
‭prodn_new[++b].lf=alpha[c];‬
 f‭ or(int g=cnt;g<prodn[cnt1].prod_rear;g++)‬
‭prodn_new[b].rt[h++]=prodn[cnt1].rt[g];‬
‭}‬
‭c++;‬
‭m=0;‬
‭}‬
‭}‬
‭}‬

/‭/Display of Output‬
‭cout<<"\n\n********************************";‬
‭cout<<"\n AFTER LEFT FACTORING ";‬
‭cout<<"\n********************************";‬
‭cout<<endl;‬
‭for(int cnt3=0;cnt3<=b;cnt3++)‬
‭{‬
‭cout<<"Production "<<cnt3+1<<" is: ";‬
‭cout<<prodn_new[cnt3].lf;‬
‭cout<<"->";‬
‭cout<<prodn_new[cnt3].rt;‬
‭cout<<endl<<endl;‬
‭}‬

f‭ or(int cnt4=0;cnt4<n;cnt4++)‬
‭{‬
‭if(prodn[cnt4].fl==0)‬
‭{‬
‭cout<<"Production "<<cnt3++<<" is: ";‬
‭cout<<prodn[cnt4].lf;‬
‭cout<<"->";‬
‭cout<<prodn[cnt4].rt;‬
‭cout<<endl<<endl;‬
‭}‬
‭}‬
‭getche();‬
‭}//end of main program‬

‭OUTPUT‬
‭ rogram-16‬
P
‭Write a program to check whether a grammar is operator precedent‬

‭ include<stdio.h>‬
#
‭#include<conio.h>‬
‭void main(){‬
‭/*OPERATOR PRECEDENCE PARSER*/‬
‭char stack[20],ip[20],opt[10][10][1],ter[10];‬
‭int i,j,k,n,top=0,col,row;‬
‭clrscr();‬
‭for(i=0;i<10;i++)‬
‭{‬
‭stack[i]=NULL;‬
‭ip[i]=NULL;‬
‭for(j=0;j<10;j++)‬
‭{‬
‭opt[i][j][1]=NULL;‬
‭}}‬
‭printf("Enter the no.of terminals :\n");‬
‭scanf("%d",&n);‬
‭printf("\nEnter the terminals :\n");‬
‭scanf("%s",&ter);‬
‭printf("\nEnter the table values :\n");‬
‭for(i=0;i<n;i++)‬
‭{‬
‭for(j=0;j<n;j++)‬
‭{‬
‭printf("Enter the value for %c %c:",ter[i],ter[j]);‬
‭scanf("%s",opt[i][j]);‬
‭}}‬
‭printf("\n**** OPERATOR PRECEDENCE TABLE ****\n");‬
‭for(i=0;i<n;i++)‬
‭{‬
‭printf("\t%c",ter[i]);‬
‭}‬
‭printf("\n");‬
‭for(i=0;i<n;i++){printf("\n%c",ter[i]);‬
‭for(j=0;j<n;j++){printf("\t%c",opt[i][j][0]);}}‬
‭stack[top]='$';‬
‭printf("\nEnter the input string:");‬
‭scanf("%s",ip);‬
‭i=0;‬
‭printf("\nSTACK\t\t\tINPUT STRING\t\t\tACTION\n");‬
‭printf("\n%s\t\t\t%s\t\t\t",stack,ip);‬
‭while(i<=strlen(ip))‬
‭{‬
‭for(k=0;k<n;k++)‬
‭{‬
‭if(stack[top]==ter[k])‬
‭col=k;‬
‭if(ip[i]==ter[k])‬
‭row=k;‬
‭}‬
‭if((stack[top]=='$')&&(ip[i]=='$')){‬
‭printf("String is accepted\n");‬
‭break;}‬
e‭ lse if((opt[col][row][0]=='<') ||(opt[col][row][0]=='='))‬
‭{ stack[++top]=opt[col][row][0];‬
‭stack[++top]=ip[i];‬
‭printf("Shift %c",ip[i]);‬
‭i++;‬
‭ }‬
‭else{‬
‭if(opt[col][row][0]=='>')‬
‭{‬
‭while(stack[top]!='<'){--top;}‬
‭top=top-1;‬
‭printf("Reduce");‬
‭}‬
‭else‬
‭{‬
‭printf("\nString is not accepted");‬
‭break;‬
‭}}‬
‭printf("\n");‬
‭for(k=0;k<=top;k++)‬
‭{‬
‭printf("%c",stack[k]);‬
‭}‬
‭printf("\t\t\t");‬
‭for(k=i;k<strlen(ip);k++){‬
‭printf("%c",ip[k]);‬
‭}‬
‭printf("\t\t\t");‬
‭}‬
‭getch();‬

‭ UTPUT‬
O
‭Enter the value for * *:>‬
‭Enter the value for * $:> ‬
‭Enter the value for $ i:< ‬
‭Enter the value for $ +:< ‬
‭Enter the value for $ *:< ‬
‭Enter the value for $ $:accept ‬

‭ *** OPERATOR PRECEDENCE TABLE ****

* ‬
‭ i + * $ ‬
‭i e > > > ‬
‭+ < > < > ‬
‭* < > > > ‬
‭$ < < < a‬
‭*/‬
‭Enter the input string: ‬
‭i*i ‬

‭ TACK INPUT STRING

S ACTION ‬
‭$ i*i Shift i ‬
‭$<i *i Reduce ‬
‭$ *i Shift * ‬
‭$<* i Shift i ‬
‭$<*<i ‬
‭String is not accepted‬