Lp Lab Manual

NARAYANA ENGINEERING COLLEGE::NELLORE CSE DEPARTMENT

III-B.TECH II-SEM

LANGUAGE PROCESSORS LAB

NARAYANA ENGINEERING COLLEGE::NELLORE DEPARTMENT : CSE

LANGUAGE PROCESSORS LAB III-B.TECH II-SEM (2007-08)

1. Develop a lexical analyzer to recognize a few patterns in PASCL, C and FORTRAN (EX: identifiers, Constants, comments, operators, etc)

2. Write a program to parse using brute force technique of top down parsing

3. Develop on LL(1) parser (construct parse table also).

4. Develop an operator precedence parsed (construct parse table also)

5. Develop a recursive descent parser

6. Write a program for generating for various intermediate code forms

i) Three address code ii) Polish notation

7. Write a program to simulate heap storage allocation strategy

8. Generate Lexical analyzer using LEX.

9.Generate YACC specification for a few syntactic categories.

10.Given any intermediate code form implement code optimization techniques.

PROGRAM ---1

/**********************************************************************

C-program to implement Lexical Analyzer to recognize keywords, Data types, identifiers, numbers, parenthesis, symbols, and operators....

**********************************************************************/

Algorithm: -

1.start.

2.Intialize the symbol table with keywords.

3.Read token by token from the input string.

4.Using finite automation check for keywords, identifiers, constants & then

Operators successively.

5.If nothing matches print an error message.

6.Until all tokens are over, repeat above three steps.

7.Print token information.

8.Stop.

Aim:- C-program to implement Lexical Analyzer to recognize keywords, Data types, identifiers, numbers, parenthesis, symbols, and operators.... #include<stdio.h>#include<conio.h>#include<ctype.h>#include<stdlib.h>#include<conio.h>void main(){

char ipstr[300],temp,tmp[15],fname[50]; char parn[6]={'(',')','{','}','[',']'}; char symb[10]={'.',',',':',';','<','>','?','$','#'}; char ops[6]={'+','-','=','/','*','^'}; char keywd[8][10]={"main","if","else","switch","void","do","while","for"}; char daty[6][10]={"int","char","float","double","string","longint"}; int pos=0,i,j,k,flagi,ip; FILE *fid; clrscr(); /* Input is taken from fname file*/ printf("enter filename which is to be parsed\n"); scanf("%s",fname); fid=fopen(fname,"r"); while((ip=getc(fid))!=EOF)

ipstr[pos++]=ip; ipstr[pos]='\0'; printf("%s",ipstr);

printf("\t\tlexicanalysis\n________________________________________\n");for(i=0;ipstr[i]!='\0';i++){ if((ipstr[i]!=' ')&&(ipstr[i]!='\0')&&(ipstr[i]!='@')&&(ipstr[i]!='\n')) {

temp=ipstr[i];/* Check for parenthesis*/for(j=0;j<6;j++){

if(temp==parn[j])printf("\n%c \t paranthesis",temp);

}/*Check for symbols*/for(j=0;j<10;j++){

if(temp==symb[j])printf("\n%c \t symbol",temp);

}

/* Check for operators*/for(j=0;j<6;j++){

if(temp==ops[j])printf("\n%c \t operator",temp);

} /* Check for digits*/

if(isdigit(ipstr[i])){ k=0; while((isdigit(ipstr[i]))||ipstr[i]=='.') tmp[k++]=ipstr[i++];

tmp[k]='\0';i--; printf("\n%s \t number",tmp);

}/* Check for alphabets (keywords, data types, identifiers) */if(isalpha(ipstr[i])){ k=0; while(isalpha(ipstr[i])) tmp[k++]=ipstr[i++]; tmp[k]='\0';i--; flagi=1; for(j=0;j<8;j++) {

if((strcmp(tmp,keywd[j]))==0) { printf("\n %s keyword",tmp);flagi=0;break;}

} for(j=0;j<6;j++) {

if((strcmp(tmp,daty[j]))==0) { printf("\n %s DataType",tmp);flagi=0;break;}

}

if(flagi==1) printf("\n %s \t Identifiers",tmp);

}/*Alphabets loop closing*/ }/*If loop closing*/}/* Main for loop closing*/getch();

}

Output:-Enter file name to be parsed: d:/padmaja/lp/ip.txt

void min(){a=b-c;234=200+34;}

Lexical analysis void ------ keyword min ------ Identifiers( ------ Parenthesis) ------ Parenthesis{ ------ parenthesis a ------ Identifiers= ------ Operator b ------ Identifiers- ------ Operator c ------ Identifiers; ------ Symbol234 ------ Number= ------ operator200 ------ number+ ------ Operator34 ------ number; ------ Symbol} ------ Parenthesis

PROGRAM --- 2/**********************************************************************

Write a C-program to delete comment lines from a file and print with line numbers**********************************************************************/

Algorithm: -

Start

Read file name

Copy entire file content in to rr.txt file by removing comment

lines

Read the contents of file rr.txt and print them.

If new line comes then first print the line number.

Stop.

Aim:- Write a C-program to delete comment lines from a file and print with line numbers

#include<stdio.h>#include<conio.h>main(){ int ln_no=1; char fname[20],ch1,ch2,ch; FILE *fp1,*fp2,*fp; clrscr(); printf("Enter filename with path"); gets(fname); fp=fopen(fname,"r"); fp1=fopen("rr.txt","w"); while((ch1=fgetc(fp))!=EOF) {

if(ch1=='/'){ if((ch2=fgetc(fp))=='*') {

while((ch1!='*')&&(ch2=fgetc(fp))!='/') {ch1=ch2;ch2=fgetc(fp);}

} else

{fputc(ch1,fp1);fputc(ch2,fp1);

}

}else fputc(ch1,fp1);

} fclose(fp); fclose(fp1); getch(); /* Reading data from file rr.txt which contains xxx.txt file data

by removing the comment linesread contents from file rr.txt and print them with line numbers*/

fp2=fopen("rr.txt","r"); printf("%d",ln_no); while((ch=fgetc(fp2))!=EOF) {

if(ch=='\n') printf("\n%d ",++ln_no);

else printf("%c",ch);

} fclose(fp2); getch();

}

Output:-

Enter filename with path d:/padmaja/lp/ip.txt

1/program for checking comment lines/23 void min()4 { a=b-c;56 234=200+34;7 }

PROGRAM ---3/**********************************************************************

C-program to generate intermediate codesa) Polish notationb) Reverse polish notationc) Three address code generation

**********************************************************************/

Program 3 a) To convert a infix expression into reverse polish (postfix) expression.

ALGORITHM:-

1. Start

2. Read the infix expression from keyboard.

3. Assume that the infix expression you have read is stored in the character

Array infix.

4. Push # in to stack.

5. For each character in infix array perform the following actions

Begin

if character is digit or alphabet then enter the same in to postfix

array(resultant array) .

if character is open braces then , push that into the stack

if character is closed braces then, pop the stack top elements

until top of the stack contains open braces.

if character contains any arithmetic operators,

Begin

if top of stack element is equal to # then, push the

operator into stack.

Else if the top of stack element priority is less than the

priority of the new character then push the character in to

stack.

Else pop the elements from stack until the priority of the top

of the stack element is less than the character priority that is

to be inserted.

End

End

6. If no more characters are presented in infix expression then pop elements from

Stack until top of stack element is # and push that element in to postfix array.

Push Function:

1. Start

2. If top of the stack is reached max size of the stack then, the stack is full.

3.Else

Insert the element into stack

4. End

Pop Function:

1. start

2. if top of the stack is null then, the stack is empty

3.else

Delete the element from the stack positioned by the top

4. End

Aim:- Generating intermediate code in reverse polish notation.

# include<stdio.h>#include<conio.h>#include<ctype.h>#include<math.h>int top=-1;char stack[20];main(){char infix[20];clrscr();printf("enter the infix expression");/* Read infix expression */gets(infix);/* Convert infix to reverse polish notation */intopo(infix);getch();}

intopo(char infix[20]){char postfix[20],s,t;int index=0,pos=0,l;l=strlen(infix); /* L string length*/push('#');/* Read one by one character */while(index<l){s=infix[index];switch(s){case '(': push(s);

break;case ')':t=pop();

while(t!='(') {

postfix[pos++]=t; t=pop();

}

break;case'+':case'-':case'*':case'/':case'^':while(pre(stack[top])>=pre(s))

{t=pop();postfix[pos++]=t;

} push(s); break;

default: postfix[pos++]=s; break;

}index++;}while(top>0){t=pop();postfix[pos++]=t;}postfix[pos++]='\0';puts(postfix);}

push(char c){top++;stack[top]=c;}

pop(){char c;c=stack[top];top--;return(c);}

pre(char c )

{if(c=='^')return(5);else if(c=='/'|| c=='*')return (4);else if( c=='+'|| c== '-')return(3);elsereturn(2);}

OUTPUT :-

1) Enter the infix expression a+b*c/(d-e^f) The equivalent reverse polish notation is…. abc*def^-/+

2) Enter the infix expression a*b^c The equivalent reverse polish notation is…. abc^*

Program 3 b) To convert a infix expression into polish (prefix) expression.

ALGORITHM:-

1. Start


3. Assume that the infix expression you have read is stored in the character

Array infix.


7. For each character in infix array perform the following actions read

characters from last

Begin



if character is closed braces then , push that into the stack

if character is open braces then, pop the stack top elements



Begin



Else if the top of stack element priority is greater than or

equal to the priority of the new character then push the

character in to stack.



to be inserted.

End

End



7. Finally reverse the resultant array then that is the polish notation for the infix

expression.

Push Function:

1. Start


3.Else


4. End

Pop Function:

1. start


3.else


4. End

Program 3 b) To convert a infix expression into polish (prefix) expression.

/* INFIX TO PREFIX */

# include<stdio.h>#include<conio.h>#include<ctype.h>#include<math.h>int top=-1;char stack[20];main(){char infix[20];clrscr();printf("enter the infix expression");/* Read infix expression */gets(infix);/* Convert infix to polish notation */

intopo(infix);getch();}

intopo(char infix[20]){char prefix[20],s,t;int index,pos=0,l,i,len;l=strlen(infix);index=l-1;push('#');while(index>=0){s=infix[index];switch(s){case ')': push(s);

break;case '(':t=pop();

while(t!=')') {

prefix[pos++]=t;

t=pop(); } break;

case'+':case'-':case'*':case'/':case'^':while(pre(stack[top])<pre(s))

{t=pop();prefix[pos++]=t;

} push(s); break;

default: prefix[pos++]=s; break;

}index--;}while(top>0){t=pop();prefix[pos++]=t;}prefix[pos++]='\0';len=strlen(prefix)-1;for(i=len;i>=0;i--)

printf("%c",prefix[i]);

}


pop(){char c;c=stack[top];top--;

return(c);}

pre(char c ){if(c=='^')return(5);else if(c=='/'|| c=='*')return (4);else if( c=='+'|| c== '-')return(3);elsereturn(6);}

OUTPUT :-

1) Enter the infix expression a+b*c/(dê+f) The equivalent reverse polish notation is…. /*+abc^d+ef

2) Enter the infix expression a*b^c The equivalent reverse polish notation is….^*abc

Program 3 c) To generate Three Address code.

ALGORITHM:-

1. Start


3. Assume that the input expression you have read is stored in the character

Array infix.


9. For each character in infix array perform the following actions

Begin



if character is open braces then , push that into the stack

if character is closed braces then, pop the stack top elements



Begin



Else if the top of stack element priority is less than the

priority of the new character then push the character in to

stack.



to be inserted.

End

End



7. For each character in postfix array do the following operation.

Begin

If the character is alphabet push character in to stack.

If the character is operator then pop two characters from stack and

store those in op1 and op2 variables.

begin

Print those in the format of Ti=op1 character op2

Increment I for generating temporary variables.

Push the new temporary variable Ti in to stack.

End

End.

Push Function:

1. Start


3.Else


4. End

Pop Function:

1. start


3.else


4. End

Aim:- Generating intermediate code in reverse polish notation.

/* INFIX TO POSTFIX */

# include<stdio.h>#include<conio.h>#include<ctype.h>#include<math.h>int top=-1;char stack[20],postfix[20],infix[20],ipst[20];main(){int i;clrscr();printf("Enter infix expression\n in the form of assignment stmt.like var=exp...");gets(ipst);for(i=2;i<strlen(ipst);i++)

infix[i-2]=ipst[i];infix[i-2]='\0';puts(infix);intopo();getch();evalua();getch();}

intopo(){char s,t;int index=0,pos=0,l;l=strlen(infix);push('#');while(index<l){s=infix[index];switch(s){case '(': push(s);

break;case ')':t=pop();

while(t!='(') {

postfix[pos++]=t;

t=pop(); } break;

case'+':case'-':case'*':case'/':case'^':while(pre(stack[top])>=pre(s))

{t=pop();postfix[pos++]=t;

} push(s); break;

default: postfix[pos++]=s; break;

}index++;}while(top>0){t=pop();postfix[pos++]=t;}postfix[pos++]='\0';}



pre(char c ){if(c=='^')return(5);else if(c=='/'|| c=='*')return (4);else if( c=='+'|| c== '-')return(3);elsereturn(2);}

evalua(){ char res[20],ch,ch1,ch2; int i,t=1; for(i=0;i<strlen(postfix);i++) {

ch=postfix[i];if(isalnum(ch)) push(ch);else{

ch1=pop(); ch2=pop(); printf("\n T%d=",t); if(ch2=='1'||ch2=='2'||ch2=='3'||ch2=='4'||ch==’5’||ch==’6’||

ch=’7’||ch=’8’||ch=’9’)printf("T%c",ch2);

elseprintf("%c",ch2);

printf("%c",ch); if(ch1=='1'||ch1=='2'||ch1=='3'||ch1=='4'||ch==’5’||ch==’6’||

ch=’7’||ch=’8’||ch=’9’) printf("T%c",ch1);

elseprintf("%c",ch1);

switch(t) {

case 1:ch='1';break;









} push(ch); t++;

} }/* for loop closing*/ ch=pop();

printf("\n %c=T%c",ipst[0],ch);

}

OUTPUT :-

1) Enter the infix expression In the form of assignment statement like var=exp...R=(a+b*c)-(dê+f)

T1=b*c T2=a+T1 T3=dê T4=T3+f T5=T2-T4 R=T5

2) Enter the infix expression in the form of assignment statement like var=exp...R=(a^b*c)-(d-e)

T1=a^b T2=T1*c T3=d-e T4=T2-T3 R=T4

PROGRAM --- 4/**********************************************************************

Write a C-program to implement BRUTE FORCE Method of parses(with backtracking)

**********************************************************************/

ALGORITHM:-

Arithmetic: procedure S() begin

if input symbol ='a' then begin advance the input pointer; if B() then begin

if input symbol = 'c' begin advance the input pointer;

if input pointer character is end of string then return true;

else return false;

end; else return false; end; else return false end; end;

procedure a()

begin binpt :=inputpointer; if inputsymbol ='c' then begin advance the input pointer;

binpt1:=inputpointer; if inputsymbol='d' then begin advance the input pointer; return true; end;

else begin inputpointer:=binpt1;

if inputsymbol='e' then begin advance the input pointer; return true; end;

else return false; end; Input pointer :=binpt; if inputsymbol =’b' then begin advance the input pointer; return true; end; else return false; end;

begin /*main procedure */ read the terminal string if S() then print "string in passed" else print "invalid string" end;

/* Program to develop recursive decent parsing with backtracking*/

#include<stdio.h>#include<conio.h>

char *inpt; /* pointer to the input*/

main(){

char ipst[20]; int len;

clrscr(); printf("The productions are.....\n s->aBc \n B->b/cd/ce\n"); printf("Enter the string to be parsed \t "); gets(ipst); inpt=ipst; if(S())

printf("****String is Parsed***\n"); else

printf("****Invalid String******\n"); getch();

} /* closing of main*/

S(){ if(*inpt=='a') {

inpt++; if(B()) {

if(*inpt=='c') {

inpt++;if(*inpt=='\0')

return(1);else return(0);

} else

return(0); } else return(0);

}}/* closing of s procedure*/

B(){ char *binpt,*binpt1; binpt=inpt; if(*inpt=='c') {

inpt++; binpt1=inpt; if(*inpt=='d') {

inpt++; return(1);

} else {

inpt=binpt1; if(*inpt=='e') {

inpt++; return(1);

} else

return(0); }

} else {

inpt=binpt; if(*inpt=='b') {

inpt++; return(1);

} else

return(0); }}/* Closing of B procedure */

OUTPUT :-

1 ) The productions are.....

s->aBc B->b/cd/ce

Enter the string to be parsed abc

****string is parsed***


s->aBc B->b/cd/ce

Enter the string to be parsed acdc



s->aBc B->b/cd/ce

Enter the string to be parsed acec



s->aBc B->b/cd/ce

Enter the string to be parsed acecd

****Invaid string ***

PROGRAM --- 5/**********************************************************************

Write a C-program to implement Recursive Decent parsing with out backtracking)

**********************************************************************/

ALGORITHM:- procedure e() begin

T(); EPRIME(); end

procedure EPRIME()

begin if inputsymbol='+' then begin advance the input pointer; T(); EPRIME(); end; end;

procedure T() begin F(); TPRIME(); end;

procedure T() begin F(); TPRIME(); end;

procedure TPRIME() begin if inputsymbol='*' then begin advance the input pointer; F(); TPRIME(); end; end; procedure f()

begin if inputsymbol = 'id' then advance the input pointer; else if inputsymbol='l' then begin advance the input pointer; E(); if inputsymbol =')' then advance the input pointer; else error();

end; else error(); end; begin /*main program */ read any terminal string E(); end;

/* Program to develop recursive decent parsing with backtracking*/ #include<stdio.h> char *a; main() { char s[10]; clrscr(); printf("ENTER THE STRING"); gets(s); a=s; if(E()) printf("STRING IS PARSED"); else printf(invalid string"); getch(); } int E() { T(); EPRIME(); } int EPRIME() { if(*a=='+'' ) { a++;; T(); EPRIME(); } } int T() { F(); TPRIME(); } int TPRIME() { if(*a=='*') {

a++;; F(); TPRIME(); } } int F() { if(*a=='i') a++ ; else if(*a==')') { a++;; E(); if(*a==')') a++ ; else error(); } else error(); } int error() { return(0); }

input:-ENTER THE STRING :(i+i)

output:-STRING IS PARSED

PROGRAM ---6

/**********************************************************************

C-program to implement Heap storage Allocation…**********************************************************************/

ALGORITHM:-“To implement dynamic memory allocation and deal location we are Implementing heap storage allocation”

1. Start

2. Assume memory size as 50 bytes

3. Allocation:---

Read variable name and size.

If continuous available free space is greater than or equal to variable

size then allocate. And make those bits in allocation array as 1.

If space not sufficient then allocation is not possible.

4. Deal location:---

Read variable name

Compare variable name with variable name presented in heap

allocated array. If match is found free the memory space allocated for

that variable.

Make valid bit as zero in heap array for that variable.

Allocation bits in array make as 0 for that particular variable memory.

5. Deal located memory space will be utilized when new variable requires

Memory….

6. Stop.

Aim:- “To implement dynamic memory allocation and deal location we are Implementing heap storage allocation”

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

struct heaps{

char var[10];int no_byte;int st_byte;int valid;

}heaparr[20];

int alloc[50],harpos=0;

void main(){

int ch,i;/* if memory allocated then alloc[pos]=1 else 0*/for(i=0;i<50;i++)

alloc[i]=0;while(1){

clrscr();printf("\n enter u r choice\n");

scanf("%d",&ch); switch(ch) {

case 1:allocat();break;

case 2:deallocat();break;

case 3: disp();break;

case 4: exit(0);getch();

}/*Closing of switch*/ }/* Closing of while*/}/* Closing of main*/

allocat(){

char vname[10],s;int vsize,i,count,st,k;printf("\n enter variable name:");scanf("%s",&vname);printf("\n enter how many bytes required for %s",vname);scanf("%d",&vsize);for(i=0;i<50;i++){ count=0;

while((alloc[i]==1)&&(i<50))i++;

st=i;while(count<vsize){

if(alloc[i]==0)count++;

elsebreak;

i++;}if(count==vsize){

strcpy(heaparr[harpos].var,vname);heaparr[harpos].valid=1;heaparr[harpos].no_byte=vsize;heaparr[harpos].st_byte=st;for(k=st;k<st+vsize;k++)

alloc[k]=1;harpos++;break;

}}/*Closing of for loop*/

if(i>50) printf("\n Allocation is not possible\n");else printf("\n Allocated succesfully\n");

}/*Closing of allocation*/

disp(){

int i;for(i=0;i<harpos;i++){if(heaparr[i].valid==1){printf("\n Name of variable %s",heaparr[i].var);printf("\n starting byte %d",heaparr[i].st_byte);printf("\n number of bytes%d",heaparr[i].no_byte);}}

}/* Closing of display*/

deallocat(){

int i;char vnam[10];int sta_byte,len_byte,end_byte;printf("variables presented are...\t");for(i=0;i<harpos;i++)

printf("%s",heaparr[i].var);printf("ENTER VARIABLE NAME WHICH IS TO BE DEALLOCATED\

t");scanf("%s",vnam);

for(i=0;i<harpos;i++){

if(heaparr[i].valid==1){ if(strcmp(vnam,heaparr[i].var)==0)

break;}

}if(i<harpos){

heaparr[i].valid=0;sta_byte=heaparr[i].st_byte;len_byte=heaparr[i].no_byte;end_byte=sta_byte+len_byte;for(i=sta_byte;i<end_byte;i++)

alloc[i]=0;}

}/* Closing of deal location*/

OUTPUT :-

enter u r choice 1enter variable name: aenter how many bytes required for a 10 Allocated successfully

Enter u r choice 1Enter variable name: bEnter how many bytes required for b 20 Allocated successfully

Enter u r choice 1Enter variable name:cEnter how many bytes required for c 30 Allocation is not possible

Enter u r choice 3

Name of variable a starting byte 0 number of bytes10 bytes allocated are 0..9

Name of variable b starting byte 10 number of bytes20 bytes allocated are 10..29

Enter u r choice 1

Enter variable name:cEnter how many bytes required for c 10Allocated successfully

Enter u r choice 3

Name of variable a Starting byte 0 Number of bytes10 Bytes allocated are 0..9

Name of variable b Starting byte 10 Number of bytes20 Bytes allocated are 10..29

Name of variable c Starting byte 30 Number of bytes10 Bytes allocated are 30..39

Enter u r choice 2variables presented are... a b cENTER VARIABLE NAME, WHICH IS TO BE DEALLOCATED bDeal located successfully

Enter u r choice 3

Name of variable a Starting byte 0 Number of bytes10 Bytes allocated are 0..9

Name of variable c Starting byte 30 Number of bytes10 Bytes allocated are 30..39 Enter u r choice 4.

#include<stdio.h>#include<ctype.h>int top=-1;char stack[20],inpst[20];main(){clrscr();printf("enter the string that is to be parsed...\t");gets(inpst);strcat(inpst,"$");/*puts(inpst);*/constructop();opprec();getch();}

constructop(){ int len,i,j=0,oplen; char op[20],prect[20][20]; len=strlen(inpst); for(i=0;i<len;i++) {

if(!present(inpst[i],op))op[j++]=inpst[i];

} op[j]='\0'; printf("THE OPERATOR PRECEDANCE PARSER IS.....\n\t"); for(i=0;i<strlen(op);i++)

printf("%c\t",op[i]); oplen=strlen(op)-1; for(i=0;i<=oplen;i++) {

printf("\n%c",op[i]); for(j=0;j<=oplen;j++) {

if(((i==0)&&(j==0))||((i==oplen)&&(j==oplen)))prect[i][j]=' ';

else if(prec(op[i])>prec(op[j]))prect[i][j]='>';

else if(prec(op[i])<prec(op[j]))prect[i][j]='<';

else if(op[i]==op[j])prect[i][j]='>';

else prect[i][j]='=';printf("\t%c",prect[i][j]);

} printf("\n");

}}

present(char ch,char opt[20]){

int i; for(i=0;i<strlen(opt);i++) {

if(ch==opt[i]) return(1);

} return(0);}

opprec(){char ch,ch2,s1[20],tost;int len,i,le;len=strlen(inpst);push('$');tost='$';for(i=0;i<len;i++){ch=inpst[i];if((tost=='$')&&(ch=='$')) break;if(prec(tost)<prec(ch)){ tost=ch; push(ch);}else{ strcpy(s1,"\0"); le=strlen(s1); while(prec(tost)>prec(ch)) {

ch=pop(); s1[le++]=ch; while((isalpha(stack[top]))&&(stack[top]!='i')) {

s1[le++]=pop(); } tost=stack[top];}

s1[le]='\0'; tost=stack[top]; if(strcmp(s1,"i")==0)

push('E'); if(strcmp(s1,"E+E")==0)

push('E'); if(strcmp(s1,"E*E")==0)

push('E'); if(strcmp(s1,"E-E")==0)

push('E'); i--;}/*closing of ELSE*/

}/*closing of for loop*/stack[++top]='\0';if((strcmp(stack,"$E")==0)&&(ch=='$')) printf("string acepted");else printf("string is not parsed \n");}/*closing of MAIN*/



int prec(char c){if(c=='i') return(5);else if(c=='^')return(4);else if(c=='/'|| c=='*')return (3);else if( c=='+'|| c== '-')return(2);else if(c=='$') return(1);elsereturn(0);}

Documents

Lp Lab Manual