SYSTEMS PROGRAMMING LABORATORY … PROGRAMMING LABORATORY [10MCA36] ... Write a LEX program to recognize a valid arithmetic ... The LEX program to recognize valid arithmetic expression

SYSTEM PROGRAMMING LABORATORY [10MCA36]

[email protected] fb.com/hegde.ganesh7 Page 1

LEX:-

1. Lex: a tool for automatically generating a lexer or scanner given a lex

specification (.l file)

2. A lexer or scanner is used to perform lexical analysis, or the breaking up of an

input stream into meaningful units, or tokens.

3. For example, consider breaking a text file up into individual words.

Skeleton of a lex specification (.l file)

x.l

%{

< C global variables, prototypes, comments >

%}

[DEFINITION SECTION]

%%

[RULES SECTION]

%%

< C auxiliary subroutines>

The rules section

%%

[RULES SECTION]

<pattern> { <action to take when matched> }


…

%%

Patterns are specified by regular expressions.

For example:

%%

[A-Za-z]* { printf(“this is a word”); }

%%

Regular Expression Basics

. : matches any single character except \n

* : matches 0 or more instances of the preceding regular expression

+ : matches 1 or more instances of the preceding regular expression

? : matches 0 or 1 of the preceding regular expression



| : matches the preceding or following regular expression

[ ] : defines a character class

() : groups enclosed regular expression into a new regular expression

“…”: matches everything within the “ “ literally

x|y : x or y

{i} : definition of i

x/y : x, only if followed by y (y not removed from input)

x{m,n} : m to n occurrences of x

x : x, but only at beginning of line

x$ : x, but only at end of line

"s" : exactly what is in the quotes (except for "\" and following character)

A regular expression finishes with a space, tab or newline

Meta-characters

– meta-characters (do not match themselves, because they are used in

the preceding reg exps):

• ( ) [ ] { } < > + / , ^ * | . \ " $ ? - %

– to match a meta-character, prefix with "\"

– to match a backslash, tab or newline, use \\, \t, or \n

Steps for executing a lex program:-

1. Create a file.

2. Save it with .l extension.

3. Use the lex command with the file name.

4. Then compile it using C compiler (cc) using, cc lex.yy.c –lfl.

5. Execute the file using ./a.out (the standard output file).



PNO: 1 COUNTING NUMBER OF VOWELS & CONSONANTS

DATE: 02/08/2011

AIM:

To write a LEX program to count no of vowels and consonants in a given string.

COMMAND DESCRIPTION:

yylex(): It is a c routine which scans the input string and recognizes the

tokens. Definition of this sub-routine is available in lex.yy.c, which is a C file

automatically generated by lex.

SOURCE CODE:

%{

int vow=0,con=0;

%}

%%

[aeiouAEIOU] {vow++;}

[a-zA-Z] {con++;}

%%

main()

{

printf("\n---------------------------------------------------------\n");

printf("\nenter the sentences : ");

yylex();

printf("\n no of vowels =%d, no of consonent =%d\n",vow,con);

printf("\n----------------------------------------------------------\n");

}

OUTPUT:

$ lex lex1.l

$ cc lex.yy.c –lfl

$ ./a.out

---------------------------------------------------------

enter the sentences : This is mca system software lab

no of vowels =8,

no of consonent =18

----------------------------------------------------------

RESULT:

The LEX program for counting number of vowels and consonants in a given

string is executed successfully and the output is verified.



PNO: 2 COUNTING NUMBER OF CHARACTERS, WORDS, SPACES & LINES

DATE: 02/08/2011

AIM:

To write a LEX program to count the number of characters, words ,spaces and

lines in a given input file.


[ ] :A character class which matches any character within brackets.




SOURCE CODE:

%{

int c,w,s,l;

%}

%%

[a-zA-Z] c++;

[a-zA-Z][ ] c++,w++,s++;

[a-zA-Z][\n] c++,w++,l++;

[ ] s++;

[\n] l++;

%%

main()

{ printf("\n------------------------------\n");

printf("Enter the string:\n");

yylex();

printf("The no of characters=%d\n",c);

printf("The no of words=%d\n", w);

printf("The no of spaces=%d\n", s);

printf("The no of lines=%d\n", l);

printf("---------------------------------\n");

return 0;

}



OUTPUT:

$ lex lex2.l


$ ./a.out

------------------------------

Enter the string:

We are studying in Sir.MVIT

The no of characters=22

The no of words=5

The no of spaces=4

The no of lines=1

---------------------------------

RESULT:

The LEX program for counting number of characters, words, spaces and lines

in a given input file is executed successfully and the output is verified.



PNO: 3 COUNTING NUMBER OF INTEGERS AND FRACTIONS

DATE: 09/08/2011

AIM:

To write a LEX program to count the number of

a) Positive and negative integers.

b) Positive and negative fractions.


[ ] : A character class which matches any character within brackets.

\ : Used to escape metacharacters.

* : Matches zero or more copies of the preceding expression.

. : Matches zero or more copies of the preceding expression.




SOURCE CODE:

%{

int pos,neg;

float posf,negf;

%}

%%

[0-9]+ pos++;

-[0-9]+ neg++;

[0-9]*\.[0-9]+ posf++;

-[0-9]*\.[0-9]+ negf++;

%%

main()

{

printf("enter input\n");

yylex();

printf("The number of positive integers =%d\n",pos);

printf("The number of negative integers =%d\n",neg);

printf("The number of positive fraction =%d\n",posf);

printf("The number of negative integers =%d\n",negf);

printf("-------------------------------------------------\n");

return 0;}



OUTPUT :

$ lex lex3.l


$ ./a.out

-------------------------------------------

Enter input

34

-68

89

-9.53

0.876

9.765

-89

The number of positive integers=2

The number of negative integers=2

The number of positive fractions=2

The number of negative fractions=1

-------------------------------------------

RESULT:

The LEX program for counting number of positive and negative integers and

fractions is executed successfully and the output is verified.



PNO: 4 COUNTING NUMBER OF COMMENT LINES

DATE: 16/08/2011

AIM:

To write a LEX program to count the numbers of comment lines in a given C

program. Also eliminate them and copy that program into separate file.


/ : Matches the preceding regular expression.



SOURCE CODE:

%{

int i=0;

%}

%%

^"/*".*"*/"\n {i++;}

"/*".*[\n]*.*"*/" {i++;}

[a-z A-Z 0-9]"/*" { printf( " ");}

%%

main()

{

printf("-------------------------------------\n");

FILE *fp;

fp=fopen("input.c", "r");

yyin=fp;

fp=fopen("out.c","w");

yyout=fp;

yylex();

printf("The number of comment lines =%d\n", i);

printf("---------------------------------------\n");

}



Input file:

input.c

/*fourth program*/

void main()

{

printf("hello");

/*output

display hello*/

}

OUTPUT:

$ lex lex4.l


$ ./a.out

------------------------------------------

The number of comment lines =2

-------------------------------------------

out.c

void main()

{

printf("hello");

}

RESULT:

The LEX program for counting number of comment lines in a given C program

is executed successfully and the output is verified.



PNO: 5 RECOGNIZING PRINTF AND SCANF STATEMENTS

DATE: 23/08/2011

AIM:

To write a LEX program to count the no of „scanf‟ and „printf‟ statements in a

given C program. Replace them with „readf‟ and „writef‟ statements respectively.





yyin :A lex lexer reads its input from yyin, which points to the standard I/O

file.

SOURCE CODE:

%{

int sc,pf;

%}

%%

"scanf" {sc++,fprintf(f2,"readf");}

"printf" {pf++,fprintf(f2,"writef");}

%%

main()

{

FILE *fpf,*f2;

printf("-------------------------------\n");

fpf=fopen("input.c","r");

f2=fopen(“output.c”, “w”);

yyin=fpf;

yyout=f2;

yylex();

printf("No of scanf statements=%d\n",sc);

printf("No of printf statements=%d\n",pf);

printf("--------------------------------\n");

}



Input file:

input.c

void main()

{

char a[30];

printf("welcome");

printf("enter your name");

scanf("%s",a);

}

OUTPUT:

$ lex lex5.l


$ ./a.out

-------------------------------

No of scanf statements=1

No of printf statements=2

--------------------------------

output.c

void main()

{

char a[30];

writef("welcome");

writef("enter your name");

readf("%s",a);

}

RESULT:

The LEX program for counting the number of printf and scanf statements in a

C program and replacing them with readf and writef statements respectively is

executed successfully and the output is verified.



PNO: 6 RECOGNIZING VALIDITY OF ARITHMETIC EXPRESSION

DATE: 30/08/2011

AIM:

Write a LEX program to recognize a valid arithmetic expression and identify the

identifiers and operators present .Print them separately.


/ : Matches the preceding regular expression.


\ : Used to escape metacharacters.

+ : matches one or more occurrence of the preceding regular

expression.




yyin :A lex lexer reads its input from yyin, which points to the standard I/O

file.

SOURCE CODE:

%{

int id=0,op=0;

%}

%%

[a-zA-Z][a-zA-Z0-9]* {id++,printf("%s is a operand\n",yytext);};

[*/\-+] {op++;printf("%s is a operator\n",yytext);}

. {printf(" ");}

%%

main()

{ FILE *fp;

printf("---------------------------------\n");

fp=fopen("lab6.c","r");

yyin=fp;

yylex();

printf("No. of identifiers=%d\n",id);

printf("No. of operators=%d\n",op);

printf("-----------------------------------\n");

}



INPUT FILE:

Lab6.c

a*bvb+3m/f*34

OUTPUT:

$ lex lex6.l


$ ./a.out

---------------------------------

a is a operand

* is a operator

bvb is a operand

+ is a operator

m is a operand

/ is a operator

f is a operand

* is a operator

No. of identifiers=4

No. of operators=4

RESULT:

The LEX program to recognize valid arithmetic expression and to count

number of identifiers and operators is executed successfully and the output is

verified.



PNO: 7 RECOGNIZING AND COUNTING THE NUMBER OF IDENTIFIERS

DATE: 30/08/2011

AIM:

To write a LEX program to recognize and count the number of identifiers in a

given input file.


[ ] : A character class which matches any character within the

brackets.


( ) : Groups a series of regular expressions together into a new

regular expression.


tokens. Definition of this sub-routine is available in lex.yy.c, which is a C

file automatically generated by lex.

yyin :A lex lexer reads its input from yyin, which points to the standard

I/O file.

SOURCE CODE:

%{

int id=0,noi=0;

%}

%%

[a-zA-Z][a-zA-Z0-9]* {id++;printf("%s",yytext);}

[0-9]+[!a-zA-Z]* {noi++;printf("%s",yytext);}

%%

main()

{

FILE *fp;

printf("-----------------------------------\n");

fp=fopen("lab6.c","r");

yyin=fp; yylex();

printf("No. of identifiers=%d\n",id);

printf("No. of not valid identifiers=%d\n",noi);

printf("-----------------------------------\n");

}



Input file:

Lab6.c

a*bvb+3m/f*34

OUTPUT:

$ lex lex7.l


$ ./a.out

-----------------------------------

a*bvb+3m/f*34

No. of identifiers=3

No. of not valid identifiers=2

-----------------------------------

RESULT:

The LEX program for counting number of identifiers in a given input file is

executed successfully and the output is verified.



YACC: YET ANOTHER COMPILER-COMPILER

Yacc provides a general tool for imposing structure on the input to a computer

program. The Yacc user prepares a specification of the input process; this includes

rules describing the input structure, code to be invoked when these rules are

recognized, and a low-level routine to do the basic input. Yacc then generates a

function to control the input process. This function, called a parser, calls the user-

supplied low-level input routine (the lexical analyzer) to pick up the basic items

(called tokens) from the input stream. These tokens are organized according to the

input structure rules, called grammar rules; when one of these rules has been

recognized, then user code supplied for this rule, an action, is invoked; actions have

the ability to return values and make use of the values of other actions.

1. Based on its current state, the parser decides whether it needs a lookahead

token to decide what action should be done; if it needs one, and does not have one,

it calls yylex to obtain the next token.

2. Using the current state, and the lookahead token if needed, the parser

decides on its next action, and carries it out. This may result in states being pushed

onto the stack, or popped off of the stack, and in the lookahead token being

processed or left alone.

3: Ambiguity and Conflicts

A set of grammar rules is ambiguous if there is some input string that can be

structured in two or more different ways. For example, the grammar rule

expr : expr '-' expr

is a natural way of expressing the fact that one way of forming an arithmetic

expression is to put two other expressions together

with a minus sign between them. Unfortunately, this grammar rule does not

completely specify the way that all complex inputs should be structured. For

example, if the input is

expr - expr - expr

the rule allows this input to be structured as either

( expr - expr ) - expr

or as

expr - ( expr - expr )



Skeleton of a yacc specification (.y file)

x.y

%{

< C global variables, prototypes, comments >

%}

[DEFINITION SECTION]

%%

[RULES SECTION]

%%

< C auxiliary subroutines>

The rules section

%%

[RULES SECTION]



…

%%

Patterns are specified by regular expressions.

For example:

%%

[A-Za-z]* { printf(“this is a word”); }

%%

Regular Expression Basics

. : matches any single character except \n

* : matches 0 or more instances of the preceding regular expression

+ : matches 1 or more instances of the preceding regular expression

? : matches 0 or 1 of the preceding regular expression

| : matches the preceding or following regular expression

[ ] : defines a character class

() : groups enclosed regular expression into a new regular expression

“…”: matches everything within the “ “ literally

x|y x or y

{i} definition of i

x/y x, only if followed by y (y not removed from input)

x{m,n} m to n occurrences of x



x x, but only at beginning of line

x$ x, but only at end of line

"s" exactly what is in the quotes (except for "\" and

following character)

A regular expression finishes with a space, tab or newline

Meta-characters

– meta-characters (do not match themselves, because they are used in

the preceding reg exps):

• ( ) [ ] { } < > + / , ^ * | . \ " $ ? - %

– to match a meta-character, prefix with "\"

– to match a backslash, tab or newline, use \\, \t, or \n

Steps to execute a yacc program:-

1. Create a lex file save it with an extension (.l)

2. Create a yacc file save it with an extension (.y)

3. Create a lexer using lex command.

4. Create a parser using yacc –d command.(-d specifies file of token definitions

created by the –d switch.)

5. Compile using lex.yy.c y.tab.c –lfl(y.tab.h or y.tab.c does parsing)

6. yyerror() specifies error code on fail of a condition.

7. Then execute using ./a.out (the standard output file).



PNO: 1 CHECKING VALIDITY OF ARITHMETIC EXPRESSION

DATE: 06/09/2011

AIM:

Program to test the validity of simple expression involving operators +,-,* and /.


+ : matches one or more occurrence of the preceding regular expr.



yyparse() : The enter point to a yacc-generated parser is yyparse(). when

your program calls yyparse(), the parser attempts to parse an input stream.

The parser returns a value of zero if the parse succeeds and non-zero if not.

yyerror() : Whenever a yacc parser detects a syntax error, it calls

yyerror() to report the error to the user, passing it a single argument, a string

describing error.

SOURCE CODE:

lex11.l

%{

#include"y.tab.h"

%}

%%

[0-9]+(\.[0-9]+)? {return NUM;}

[A-Za-z]+[A-Za-z0-9]* {return ID;}

. {return yytext[0];}

%%



yacc1.y

%{

#include<stdio.h>

%}

%token NUM,ID;

%left '+' '-'

%left '*' '/'

%%

expn:expn '+' expn

| expn '-' expn

| expn '*' expn

| expn '/' expn

| '(' expn ')'

| NUM

| ID

;

%%

int yyerror()

{

printf("Invalid expression \n");

exit(0);

}

main()

{

printf("---------------------------\n");

printf("Enter the expression\n");

yyparse();

printf("----------------------------\n");

printf("Valid expression\n");

printf("------------------------------\n");

}



OUTPUT:

$ lex lex11.l

$ yacc –d yacc1.y

$ cc y.tab.c lex.yy.c –lfl

$ ./a.out

1

---------------------------

Enter the expression

1+2

----------------------------

Valid expression

------------------------------

2./a.out

---------------------------


a*3+(4-2)

----------------------------

Valid expression

------------------------------

3./a.out

---------------------------


*l

Invalid expression

4./a.out

---------------------------


a+c*

Invalid expression

RESULT:

The YACC program for checking validity of arithmetic expression is executed

successfully and the output is verified.



PNO: 2 RECOGNIZING NESTED IF STATEMENTS

DATE: 20/09/2011

AIM:

To write a yacc program to recognize nested IF control statements and display the no

of level of nesting.



. : Matches zero or more copies of the preceding

expression.

( ) : Groups a series of regular expressions together into a new

regular

yyparse() : The enter point to a yacc-generated parser is yyparse().

when your program calls yyparse(), the parser attempts to parse an input

stream. The parser returns a value of zero if the parse succeeds and non-

zero if not.


yyerror() to report the error to the user, passing it a single argument, a

string describing error.

SOURCE CODE:

lex12.l

%{

#include"y.tab.h"

int level=0,maxlevel=0;

%}

%%

"if" return IF;

"(".*")" return CON;

"{" { level++;

if(maxlevel<level)

maxlevel=level;

return OB;

}

"}" { level--;return CB;}

. ;

\n ;

%%



yacc2.y

%{

#include<stdio.h>

#include<stdlib.h>

%}

%token IF CON OB CB

%%

line:

|line ifstmt

;

ifstmt: IF CON OB line CB

;

%%

int main()

{

extern int maxlevel;

printf("\nEnter the Program Block\n");

yyparse();

if(!yyparse())

{

printf("\nValid if Statement\n");

printf("\nNumber of level of nesting = %d\n",maxlevel);

}

return 0;

}

int yyerror(){

printf("\nINvalid if statement\n");

exit(0);

}



OUTPUT:

$ lex lex12.l

$ yacc –d yacc2.y


$ ./a.out

1.

--------------------------------------------------------

Enter IF statement

if(4<5){ if(9>0){a=a+b;}}

Valid if and nesting=2

--------------------------------------------------------------------

2.

$ ./a.out

---------------------------------------------------------------------

Enter IF statement

if(g>9)

{}

Not a nesting.

---------------------------------------------------------------------

RESULT:

The YACC program for recognizing nested IF statements and displaying the number

of level of nesting is executed successfully and the output is verified.



PNO: 3 RECOGNIZING VALIDITY OF AN ARITHMETIC EXPRESSION

DATE: 20/09/2011

AIM:

To write a yacc program to recognize a valid arithmetic expression that uses

operators +,-,* and /.



| : Matches the preceding regular expression.

[] : A character class which matches any character within the

o brackets.

yytext[] : Whenever a lexer matches a token ,the text of the token is

stored in this null terminated string. Its content is replaced each time a new

token is matched.






describing error.

SOURCE CODE:

lex13.l

%{

#include<stdio.h>

#include"y.tab.h"

%}

%%

"("|")" ;

[0-9]+|[a-z A-Z] {return A;}

[+] {return ADD;}

[-] {return SUB;}

[*] {return MUL;}

[/] {return DIV;}

%%



yacc3.y

%{

#include<stdio.h>

%}

%token A ADD SUB MUL DIV

%%

e: '('e')'

|e ADD A

|e MUL A

|e DIV A

|A;

%%

int yyerror()

{

printf("\nInvalid Expression\n");

printf("-------------------\n");

exit(0);

}

int main()

{

printf("--------------------------\n");

printf("Enter the expression:\n");

yyparse();

printf("\nValid expression\n");

printf("----------------------------\n");

}



OUTPUT:

$ lex lex13.l

$ yacc –d yacc3.y


$ ./a.out

1./a.out

--------------------------

Enter the expression:

a*4*(5+9)

Valid expression

----------------------------

2 ./a.out

--------------------------


q+c(5)

Invalid Expression

-------------------

3 ./a.out

--------------------------


a+b/4

Valid expression

----------------------------

RESULT:

The YACC program for recognizing valid arithmetic expression that uses operators

+,-,* and / is executed successfully and the output is verified.



PNO: 4 RECOGNIZING VALID VARIABLE NAMES

DATE: 04/10/2011

AIM:

To write a YACC program to recognize valid variable, which starts with a letter,

followed by any number of letters or digits?



o brackets.



token is matched.






describing error.

SOURCE CODE:

lex14.l

%{

#include"y.tab.h"

%}

%%

[A-Za-z] { return ALPHA;}

[0-9] { return DIGIT;}

. { return yytext[0];}

%%



yacc4.y

%{

#include<stdio.h>

%}

%token ALPHA DIGIT

%%

variable: ALPHA

| variable DIGIT

| variable ALPHA;

%%

int yyerror()

{

printf("Invalid input\n");

printf("------------------------------\n");

exit(0);

}

int main()

{

printf("------------------------------\n");

printf("Enter the variable:\n");

yyparse();

printf("------------------------------\n");

printf("Valid variable\n");

printf("------------------------------\n");

}



OUTPUT:

$ lex lex14.l

$ yacc –d yacc4.y


$ ./a.out

1

Enter the variable:

12

Invalid input

------------------------------

2./a.out

------------------------------

Enter the variable:

q23f

------------------------------

Valid variable

------------------------------

3./a.out

------------------------------

Enter the variable:

qwww

------------------------------

Valid variable

------------------------------

4./a.out

------------------------------

Enter the variable:

2w

Invalid input

RESULT:

The YACC program for recognizing valid variable name which starts with a letter

followed by any no digit is executed successfully and the output is verified.



PNO: 5 EVALUATION OF ARITHMETIC EXPRESSION

DATE: 04/10/2011

AIM:

To write a YACC program to evaluate an arithmetic expression involving operators

+,-,* and /.



brackets.



token is matched.






describing error.

SOURCE CODE:

lex15.l

%{

#include"y.tab.h"

#include<math.h>

extern yylval;

%}

%%

[0-9] {yylval=atoi(yytext);

return num;}

. {return yytext[0];}

%%



yacc5.y

%{

#include"stdio.h"

int valid=1;

%}

%token num

%left'+''-'

%left'*''/'

%nonassoc uminus

%%

statement: expr{if(valid)printf("%d\n",$$);}

expr: '(' statement ')'

|expr'+'expr{$$=$1+$3;}

|expr'-'expr{$$=$1-$3;}

|expr'*'expr{$$=$1*$3;}

|expr'/'expr{if($3==0)valid=0; else($$=$1/$3);}

|'-'expr%prec uminus{$$=-$2;}

|num{$$=$1;} ;

%%

int yyerror()

{

valid=0;

}

int main()

{

printf("---------------------------------\n");

printf("enter valid expression\n");

yyparse();

if(valid)

printf("valid expr\n");

else

printf("invalid expr\n");

printf("------------------------------------\n");

}



OUTPUT:

$ lex lex15.l

$ yacc –d yacc5.y


$ ./a.out

1 ./a.out

---------------------------------

enter valid expression

(5*)

invalid expr

------------------------------------

2 ./a.out

---------------------------------


(6*9)

54

valid expr

------------------------------------

3 ./a.out

---------------------------------


9+9

18

valid expr

------------------------------------

RESULT:

The YACC program for evaluation of arithmetic expression is executed successfully

and the output is verified.



PNO: 6 RECOGNIZING GRAMMARS OF THE FORM AMBN (M,N>=0)

DATE: 18/10/2011

AIM:

To write a YACC program to recognize strings „aaab‟,‟abbb‟,‟ab‟ and „a‟ using

the grammar.



brackets.



token is matched.






describing error.

SOURCE CODE:

lex16.l

%{

#include “y.tab.h”

%}

%%

a return A;

b return B;

. return yytext[0];

\n return 0;

%%



yacc6.y

%{#include<stdio.h>%}

%token A B

%%

start:sa sb

|sa

|sb;

sa: A sa | A;

sb: B sb

|B;

%%

int main()

{

printf(“\nEnter a string of A‟s followed by B: - ”);

printf(“For the following grammer a^nb^n,n,m>=0\n”);

yyparse();

printf(“\nValid input\n”);

return 0;

}

void yyerror(){ printf(“\nInvalid input\n”);exit(0);}



OUTPUT:

$ lex prog6b.l

$ yacc –d prog6b.y

$ cc lex.yy.c y.tab.c –ll

$ ./a.out

Enter a string of A‟s followed by B: - abbb

For the following grammer a^nb^n,n,m>=0

Valid input

$ ./a.out

Enter a string of A‟s followed by B: - bbba

For the following grammer a^nb^n,n,m>=0

Invalid input

RESULT:

The YACC program for recognizing grammar of the form anbm is executed




PNO: 7 RECOGNIZING GRAMMARS OF THE FORM ANB (N>=10)

DATE: 18/10/2011

AIM:

To write a YACC program to recognize the grammar(anb,n>=10)



o brackets.



token is matched.






describing error.

SOUCE CODE:

lex17.l

%{

#include"y.tab.h"

%}

%%

[a] return A;

[b] return B;

%%



yacc7.y

%{

#include<stdio.h>

%}

%token A B

%%

S: A A A A A A A A A P;

P : A P|B

;

%%

main()

{

printf("Enter the string\n");

if(yyparse()==0)

printf("Valid grammer\n");

}

yyerror(char *s)

{

printf("Invalid grammer\n");

}



OUTPUT:

$lex prog7l.l

$yacc –d prog7y.y

$cc lex.yy.c y.tab.c –ll

$./a.out

Enter the string

aaaaaaaaaaab

Valid grammer

$./a.out

Enter the string

aab

Invalid grammar

a

RESULT:

The YACC program for recognizing grammar of the form (anb,n>=10) is executed


Documents

SYSTEMS PROGRAMMING LABORATORY … PROGRAMMING LABORATORY [10MCA36] ... Write a LEX program to recognize a valid arithmetic ... The LEX program to recognize valid arithmetic expression