1.i)Write a C program to simulate the following DFA.
The program should accept a
string from user and print 'valid' if it is accepted or 'invalid', if not accepted.
Consider that the input are {0,1}
#include <stdio.h>
int main()
{
char pat[50],*str ,ch;
int state = 1;
printf("enter pattern");
scanf("%s",pat);
str = pat;
while (*str)
{
/* code */
ch = *str;
switch(ch){
case '0':
if(state ==1)
state=1;
else
state=3;
break;
case '1':
if (state == 1)
state =2;
else
state = 3;
break; }
str++;
}
if (state ==2)
printf("valid");
else
printf("invalid");
}
*****************************************************
ii)Consider that identifies define a program language are as follows:-
Every identify is a combination of later (a-z,A-Z) and digit (0-9) only.
It can only start with a letter.
#include <stdio.h>
int main()
{
char check[50],*s,ch;
int state=0;
printf("Enter a pattern:");
scanf("%s",check);
s=check;
while(*s)
{
if(((*s>='a')&&(*s<='z'))||((*s>='A')&&(*s<='Z')))
{
if(state==0)
state=1;
else
state=1;
s=s+1;
}
else if ((*s>='0')&&(*s<='9'))
{
if(state==0)
state=0;
else
state=1;
s=s+1;
}
}
if(state==0)
printf("Invalid");
else
printf("Valid");
}
***************************************************************************
2. Write a lex program to recognise and display keyword, number and words in a
given statement.
%{
#include<stdio.h>
%}
%%
if |
else |
printf {printf("\n%s is a keyword",yytext);}
[0-9]+ {printf("\n%s is a number",yytext);}
[a-zA-Z]+ {printf("\n%s is a word",yytext);}
.|\n {ECHO;}
%%
int main()
{
printf("enter a string");
yylex();
}
int yywrap()
{
return 1;
}
*****************************************************************************
3.i) Write a lex program to display capital words from the given input string.
%{
#include<stdio.h>
%}
%%
[A-Z]+[\t\n ] { printf("%s",yytext); }
. ;
%%
int main( )
{
printf("Enter some string with capital words in between\n");
yylex();
}
int yywrap( )
{
return 1;
}
********************************************************************************
3)ii) write a program in lex to count the number of vowels and consonants.
%{
int vow_count=0;
int const_count =0;
%}
%%
[aeiouAEIOU] {vow_count++;}
[a-zA-Z] {const_count++;}
%%
int yywrap(){}
int main()
{
printf("Enter the string of vowels and consonants:");
yylex();
printf("Number of vowels are: %d\n", vow_count);
printf("Number of consonants are: %d\n", const_count);
return 0;
}
***********************************************************************************
*
4)i) write a lex code to remove the comment from any C program given at runtime and
stored into out.c file.
/*Definition Section*/
%{
#include <stdio.h>
%}
/*Rule Section*/
%%
\/\/(.*) {};
\/\*(.*\n)*.*\*\/ {};
%%
/*call the yywrap function*/
int yywrap()
{
return 1;
}
/*Auxiliary function*/
/*Driver function*/
int main()
{
yyin=fopen("comm.c","r");
yyout=fopen("out.c","w");
/*call the yylex function.*/
yylex();
return 0;
}
******************************************************************************
4)ii) write a lex program to check whether a number is Armstrong number or not.
/* Lex program to check whether given - number is armstrong number or not */
%{
/* Definition section */
#include <math.h>
#include <string.h>
void check(char*);
%}
/* Rule Section */
%%
[0-9]+ check(yytext);
%%
int main()
{
/* yyin as pointer of File type */
extern FILE* yyin;
yyin = fopen("num", "r");
// The function that starts the analysis
yylex();
return 0;
}
void check(char* a)
{
int len = strlen(a), i, num = 0;
for (i = 0; i < len; i++)
num = num * 10 + (a[i] - '0');
int x = 0, y = 0, temp = num;
while (num > 0) {
y = pow((num % 10), len);
x = x + y;
num = num / 10;
}
if (x == temp)
printf("%d is armstrong number \n", temp);
else
printf("%d is not armstrong number\n", temp);
}
int yywrap()
{
return 1;
}
*********************************************************
5)i) write a lex program to check odd and even number
%{
/* Definition section */
#include<stdio.h>
int num, r, b=0, p=1;
%}
DIGIT [0-9]
/* Rule Section */
%%
{DIGIT}+ { num=atoi(yytext);
while (num > 0)
{
r= num % 2;
b+= r*p;
p*= 10;
num/= 2;
}
printf("%d", b);
}
.|\n ECHO;
%%
// driver code
int main()
{
yylex();
return 0;
}
int yywrap()
{
return 0;
}
*********************************************************
5)ii) Write a lex program for decimal to binary conversion
%{
/* Definition section */
#include<stdio.h>
int num, r, b=0, p=1;
%}
DIGIT [0-9]
/* Rule Section */
%%
{DIGIT}+ { num=atoi(yytext);
while (num > 0)
{
r= num % 2;
b+= r*p;
p*= 10;
num/= 2;
}
printf("%d", b);
}
.|\n ECHO;
%%
// driver code
int main()
{
yylex();
return 0;
}
int yywrap()
{
return 0;
}
**********************************************************************
5)iii) Write a lex program for binary to decimal conversion
%{
#include <stdio.h>
#include <math.h>
%}
%%
[01]+ {
int decimal = 0;
int length = yyleng;
int i;
for (i = 0; i < length; i++) {
if (yytext[i] == '1') {
decimal += pow(2, length - i - 1);
}
}
printf("Binary: %s -> Decimal: %d\n", yytext, decimal);
}
\n |
. {}
%%
int yywrap() {
return 1;
}
int main() {
printf("Enter a binary number:\n");
yylex();
return 0;
}
***********************************************************************
6)i) write a YACC program to recognise a valid arithmetic expression that user
operator +,-,*,/
LEX:
%{
#include"y.tab.h"
%}
%%
[0-9]+ {yylval=atoi(yytext); return NUMBER;}
[a-zA-Z]+ {return ID;}
[\t]+ ;
\n {return 0;}
. {return yytext[0];}
%%
int yywrap() {
return 1;
}
YACC:
%{
#include<stdio.h>
int flag = 1;
%}
%token NUMBER ID
%left '+' '-'
%left '*' '/'
%%
expr: expr '+' expr
| expr '-' expr
| expr '*' expr
| expr '/' expr
| '-'NUMBER
| '-'ID
|'('expr')'
|NUMBER
|ID
;
%%
int main()
{
printf("Enter the expression:\n");
yyparse();
if (flag)
printf("\nExpression valid");
else
printf("\nExpression invalid");
}
int yyerror(char *s)
{
flag = 0;
}
*************************************************************************
6)ii)Write a YACC program to implement a calculator and recognise a valid
arithmetic expression
LEX:
%{
/* Definition section */
#include<stdio.h>
#include "y.tab.h"
extern int yylval;
%}
/* Rule Section */
%%
[0-9]+ {
yylval=atoi(yytext);
return NUMBER;
}
[\t] ;
[\n] return 0;
. return yytext[0];
%%
int yywrap()
{
return 1;
}
YACC:
%{
/* Definition section */
#include<stdio.h>
int flag=0;
%}
%token NUMBER
%left '+' '-'
%left '*' '/' '%'
%left '(' ')'
/* Rule Section */
%%
ArithmeticExpression: E{
printf("\nResult=%d\n", $$);
return 0;
};
E :E'+'E {$$=$1+$3;}
|E'-'E {$$=$1-$3;}
|E'*'E {$$=$1*$3;}
|E'/'E {$$=$1/$3;}
|E'%'E {$$=$1%$3;}
|'('E')' {$$=$2;}
| NUMBER {$$=$1;}
;
%%
//driver code
void main()
{
printf("\nEnter Any Arithmetic Expression:\n");
yyparse();
if(flag==0)
printf("\nEntered arithmetic expression is Valid\n\n");
}
void yyerror()
{
printf("\nEntered arithmetic expression is Invalid\n\n");
flag=1;
}
************************************************************************
7) Write a YACC program for the following grammar:-
E-> E+T | T
T->T*F | F
F->(E) | id
LEX:
%{
#include<stdio.h>
#include "y.tab.h"
%}
%%
[a-zA-Z][0-9a-zA-Z]* { return ID; }
[\t] ;
[\n] {return 0;}
. {return yytext[0];}
%%
int yywrap()
{
return 1;
}
YACC:
%{
#include<stdio.h>
int flag=0;
%}
%token ID
%%
E : E'+'T {printf("Rule 1\n");}
| T {printf("Rule 2\n");}
;
T : T'*'F {printf("Rule 3\n");}
| F {printf("Rule 4\n");}
;
F : '('E')' {printf("Rule 5\n");}
| ID {printf("Rule 6\n");}
;
%%
void main()
{
printf("Enter arithmetic expression:\n");
yyparse();
if (flag==0)
printf("Valid\n");
}
int yyerror(char *s)
{
flag = 1;
printf("Invalid\n");
}
*******************************************************************************
8) write a YACC program to recognise string 'aaab','abbb','ab','a' using
grammar(a^n, b^n, n>1)
LEX:
%{
#include "y.tab.h"
%}
%%
a return A;
b return B;
.|\n return yytext[0];
%%
int yywrap()
{
return 1;
}
YACC:
%{
#include<stdio.h>
int valid=1;
%}
%token A B
%%
str:S'\n' {return 0;}
S:A S B
|
;
%%
main()
{
printf("Enter the string:\n");
yyparse();
if(valid==1)
printf("\nvalid string");
}
int yyerror(char *msg)
{
printf("invalid string\n");
exit(0);
}
****************************************************************************
n) Program to recognize nested IF control statements and display the levels of
nesting.
LEX:
%{
#include "y.tab.h"
%}
%%
"if" {return IF;}
[sS][0-9]* {return S;}
"<"|">"|"=="|"<="|">="|"!=" {return RELOP;}
[0-9]+ {return NUMBER;}
[a-z][a-zA-Z0-9_]* {return ID;}
\n {return NL;}
. {return yytext[0];}
%%
YACC:
%{
#include<stdio.h>
#include<stdlib.h>
int count=0;
%}
%token IF RELOP S NUMBER ID NL
%%
stmt: if_stmt NL {printf("No. of nested if statements=%d\n",count);exit(0);}
;
if_stmt : IF'('cond')''{'if_stmt'}' {count++;}
|S
;
cond: x RELOP x
;
x:ID | NUMBER
;
%%
int yyerror(char *msg)
{
printf("the statement is invalid\n");
exit(0);
}
main()
{
printf("enter the statement\n");
yyparse();
}
