Department of Computer Science and Engineering

RAYAT GROUP Of INSTITUTIONS

LAB PRACTICAL FILE

Course Title: Cloud Computing Lab

Course CODE: BTCS 612-18
Semester: 6th

Submitted By: Submitted To:

MRS. MEENAKSHI
VISHAL KUMAR SHARMA

Roll No. 2107225(LEET)

B.TECH CSE
 INDEX

Sr. No. Experiment Name Page No. Remarks

Design a lexical analyser for given language and the lexical
analyser should ignore redundant spaces, tabs and new lines. It
should also ignore comments. Although the syntax
1. U3-5
specification states that identifiers can be arbitrarily long,
you may restrict the length to some reasonable value.
Simulate the same in C language.
Write a C program to identify whether a given line is a
2. 6
comment or not.
Write a C program to recognize strings under 'a', 'a*b+', 'abb'
3. 7-8
Write a C program to test whether a given identifier is
valid or not. 9
4.
Write a C program to simulate lexical analyzer for
validating operators. 10-11
5.
Implement the lexical analyzer using JLex, flex or
12-13
other lexical analyzer generating toolsWrite a C program
for implementing the functionalities
of predictive parser for the mini language specified in 14-15
7. Note 1.
a) Write a C program for constructing of LL (1)
parsing.
b) Construction of recursive descent parsing for the
following grammar
8.
E->TE' 16-20
E'->+TE/@ "@ represents null character" T-
>FT'
T`->*FT'/@
F->(E)/ID
9. Write a program to Design LALR Bottom up Parser. 21-25
a) Write a C program to implement operator
precedence parsing.
b) Write a C program to implement Program
10. 26-30
semantic rules to calculate the expression that
takes an expression with digits, + and * and
computes the value
Convert the BNF rules into YACC form and write code to generate
11. abstract syntax tree for the mini language 31-35
specified in Note 1.
Write a C program to generate machine code from abstract
syntax tree generated by the parser. The instruction set
12. 36-38
specified in Note 2 may be considered as the target code.
 Experiment No. 1
AIM: Design a lexical analyzer for given language and the lexical analyzer should ignore
redundant spaces, tabs and new lines. It should also ignore comments.
Although the syntax specification states that identifiers can be arbitrarily long, you may
restrict the length to some reasonable value. Simulate the same in C language.
DESCRIPTION:

CODE:-

#include <stdio.h>
#include <stdbool.h>
#include <string.h>
#include <stdlib.h>
bool isDelimiter(char ch)
{
if (ch == ' ' || ch == '+' || ch == '-' || ch == '*' || ch
== '/' || ch == ',' || ch == ';' || ch == '>' || ch == '<'
|| ch == '=' || ch == '(' || ch == ')' || ch == '[' || ch
== ']' || ch == '{' || ch == '}') return (true);
return (false);
}
bool isOperator(char ch)
{ if (ch == '+' || ch == '-' || ch == '*' ||
ch == '/' || ch == '>' || ch == '<' ||
ch == '=')
return (true);
return (false);
}

bool validIdentifier(char* str)

{
if (str[0] == '0' || str[0] == '1' || str[0] == '2' ||
str[0] == '3' || str[0] == '4' || str[0] == '5' ||
str[0] == '6' || str[0] == '7' || str[0] == '8' ||
str[0] == '9' || isDelimiter(str[0]) == true)
return (false);
return (true);
}

bool isKeyword(char* str)

{ if (!strcmp(str, "if") || !strcmp(str, "else") ||
!strcmp(str, "while") || !strcmp(str, "do") ||
!strcmp(str, "break") ||
!strcmp(str, "continue") || !strcmp(str, "int")
 ||!strcmp(str, "double") || !strcmp(str, "float")
||!strcmp(str, "return") || !strcmp(str, "char")
|| !strcmp(str, "case") || !strcmp(str, "char")
|| !strcmp(str, "sizeof") || !strcmp(str, "long")
|| !strcmp(str, "short") || !strcmp(str, "typedef")
|| !strcmp(str, "switch") || !strcmp(str, "unsigned")
|| !strcmp(str, "void") || !strcmp(str, "static") || !strcmp(str, "struct") || !strcmp(str,
"goto")) return
(true); return
(false);
}
bool isInteger(char* str)
{
int i, len = strlen(str);
if (len == 0)
return (false);
for (i = 0; i < len; i++){
if (str[i] != '0'&& str[i] != '1'&& str[i] != '2'&& str[i] != '3'&& str[i] != '4'&& str[i] != '5'&&
str[i] != '6'&& str[i] != '7'&& str[i] != '8'&& str[i] != '9' || (str[i] == '-'&& i > 0)) return
(false);
}return (true);
}
bool isRealNumber(char* str)
{
int i, len = strlen(str); bool
hasDecimal = false; if (len
== 0)
return (false);
for (i = 0; i < len; i++)
{
if (str[i] != '0'&& str[i] != '1'&& str[i] != '2'&& str[i] != '3'&& str[i] != '4'&& str[i] != '5'&&
str[i] != '6'&& str[i] != '7'&& str[i] != '8'
&& str[i] != '9'&& str[i] != '.' || (str[i] == '-'&& i >
0)) return (false);
if (str[i] == '.')
hasDecimal = true;
}
return (hasDecimal);
}
char* subString(char* str, int left, int right)
{
int i;
char* subStr = (char*)malloc( sizeof(char) * (right - left + 2)); for
(i = left; i <= right; i++)
subStr[i - left] = str[i];
subStr[right - left + 1] = '\0';
return (subStr);
}
void parse(char* str)
{
int left = 0, right = 0;
int len = strlen(str);
while (right <= len && left <= right) {
if (isDelimiter(str[right]) == false)
right++;
if (isDelimiter(str[right]) == true && left ==
right){ if (isOperator(str[right]) == true)
printf("'%c' IS AN OPERATOR\n", str[right]);
right++;
left = right;
}
else if (isDelimiter(str[right]) == true && left != right || (right == len && left != right))
{
char* subStr = subString(str, left, right - 1); if
(isKeyword(subStr) == true)
printf("'%s' IS A KEYWORD\n", subStr);
else if (isInteger(subStr) == true)
printf("'%s' IS AN INTEGER\n", subStr);
else if (isRealNumber(subStr) == true)
printf("'%s' IS A REAL NUMBER\n", subStr);
else if (validIdentifier(subStr) == true && isDelimiter(str[right - 1]) == false)
printf("'%s' IS A VALID IDENTIFIER\n", subStr);
else if (validIdentifier(subStr) == false && isDelimiter(str[right - 1]) == false)
printf("'%s' IS NOT A VALID IDENTIFIER\n", subStr);
left = right;
}}
return;
}
int main()
{
char str[100] = "int z = q + 20; ";
parse(str);
return (0);
}
OUTPUT:-
 Experiment No. 2
AIM:- Write a C program to identify whether a given line is a comment or not.

DESCRIPTION:

CODE:-

#include<stdio.h>
#include<conio.h>
void main(){
char com[30];
int i=2,a=0;
printf("\n Enter comment:");
gets(com);
if(com[0]=='/'){
if(com[1]=='/')
printf("\n It is a comment"); else
if(com[1]=='*') {
for(i=2;i<=30;i++){
if(com[i]=='*'&&com[i+1]=='/'){
printf("\n It is a comment"); a=1;
break;}
else
continue;}
if(a==0)
printf("\n It is not a comment");}
else
printf("\n It is not a comment");}
else
printf("\n It is not a comment");
getch();}

OUTPUT:-
 Experiment No. 3
AIM:- Write a C program to recognize strings under 'a', 'a*b+', 'abb'.

DESCRIPTION:

CODE:-

#include<stdio.h>
#include<conio.h>
#include<string.h>
#include<stdlib.h>
void main()
{
char s[20],c; int
state=0,i=0;
printf("\n Enter a string:");
gets(s);
while(s[i]!='\0')
{ switch(state)
{ case 0: c=s[i++];
if(c=='a') state=1; else
if(c=='b') state=2; else
state=6;
break;
case 1: c=s[i++];
if(c=='a') state=3; else
if(c=='b') state=4; else
state=6;
break;
case 2: c=s[i++];
if(c=='a') state=6; else
if(c=='b') state=2; else
state=6;
break;
case 3: c=s[i++];
if(c=='a') state=3; else
if(c=='b') state=2; else
state=6;
break;
case 4: c=s[i++];
if(c=='a') state=6; else
if(c=='b') state=5; else
state=6;
break;
case 5: c=s[i++];
if(c=='a') state=6; else
if(c=='b') state=2; else
state=6;
 break;
case 6: printf("\n %s is not recognised.",s);
exit(0);} }
if(state==1) printf("\n %s is accepted under rule 'a'",s);
else if((state==2)||(state==4)) printf("\n %s is accepted under rule
'a*b+'",s); else if(state==5) printf("\n %s is accepted under rule
'abb'",s); getch();}

OUTPUT:-
 Experiment No. 4
AIM:- Write a C program to test whether a given identifier is valid or not..

DESCRIPTION:

CODE:-

#include<stdio.h>
#include<ctype.h>
void main()
{
char a[10];
int flag, i=1;
printf("Enter an identifier: ");
gets(a);
if(isalpha(a[0]))
flag=1;
else
printf("\nNot a valid identifier");
while(a[i]!='\0'){ if(!isdigit(a[i])&&!
isalpha(a[i]))
{
flag=0;
break;
} i+
+;
}
if(flag==1)
printf("\nValid identifier");
getch();
}

OUTPUT:-
 Experiment No. 5
AIM:- Write a C program to simulate lexical analyzer for validating operators.

DESCRIPTION:

CODE:-

#include<stdio.h>
void main()
{
char s[5];
printf("\nEnter any operator: ");
gets(s);
switch(s[0]){ case'>':
if(s[1]=='=')
printf("\nGreater than or equal");
else
printf("\nGreater than");
break;
case'<': if(s[1]=='=') printf("\
nLess than or equal"); else
printf("\nLess than");
break;
case'=': if(s[1]=='=')
printf("\nEqual to"); else
printf("\nAssignment");
break;
case'!': if(s[1]=='=')
printf("\nNot Equal");
else
printf("\nBit Not");
break;
case'&': if(s[1]=='&')
printf("\nLogical AND");
else
printf("\n Bitwise AND");
break;
case'|': if(s[1]=='|')
printf("\nLogical OR");
else
printf("\nBitwise OR");
break;
case'+': printf("\nAddition");
break;
case'-': printf("\nSubstraction");
break;
 case'*': printf("\nMultiplication");
break;
case'/': printf("\nDivision");
break;
case'%': printf("Modulus");
break;
default: printf("\nNot a operator");
}}

OUTPUT:-
 Experiment No. 6
AIM: - Implement the lexical analyzer using JLex, flex or other lexical analyzer generating tools

DESCRIPTION:

CODE:-

#include<string.h>
#include<conio.h>
#include<ctype.h>
#include<stdio.h>
int main()
{
FILE *f1;
char c,str[10];
int lineno=1,num=0,i=0; printf("\
nEnter the c program\n");
f1=fopen("input.txt","w");
while((c=getchar())!=EOF)
putc(c,f1);
fclose(f1);
f1=fopen("input.txt","r");
while((c=getc(f1))!=EOF)
{
if(isdigit(c))
{
num=c-48;
c=getc(f1);
while(isdigit(c))
{
num=num*10+(c-48);
c=getc(f1);
}
printf("%d is a number \n",num);
ungetc(c,f1);
}
else if(isalpha(c))
{
str[i++]=c;
c=getc(f1);
while(isdigit(c)||isalpha(c)||c=='_'||c=='$')
{
str[i++]=c;
c=getc(f1);
}
str[i++]='\0'; if(strcmp("for",str)==0||strcmp("while",str)==0||strcmp("do",str)==0||
 strcmp("int",str)==0||strcmp("float",str)==0||strcmp("char",str)==0|| strcmp("double",str)==0||
strcmp("static",str)==0|| strcmp("switch",str)==0||strcmp("case",str)==0)
printf("%s is a keyword\n",str);
else
printf("%s is a identifier\n",str);
ungetc(c,f1);
i=0;
}
else if(c==' '||c=='\t')
printf("\n");
else if(c=='\n')
lineno++; else
printf("%c is a special symbol\n",c);
}
printf("Total no. of lines are: %d\n",lineno);
fclose(f1);
getch();
return 0;
}
OUTPUT:-
 Experiment No. 7
AIM: - Write a C program for implementing the functionalities of predictive parser for the
mini language specified in Note 1.
DESCRIPTION:

CODE:-

#include<stdio.h>
#include<string.h>
char prol[7][10]={"S","A","A","B","B","C","C"};
char pror[7][10]={"A","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];
int numr(char c)
{
switch(c){
case 'S': return 0;
case 'A': return 1;
case 'B': return 2;
case 'C': return 3;
case 'a': return 0;
case 'b': return 1;
case 'c': return 2;
case 'd': return 3;
case '$': return 4;
}
return(2);
}
void main()
{
int i,j,k;
for(i=0;i<5;i++)
for(j=0;j<6;j++)
strcpy(table[i][j]," ");
printf("\nThe following is the predictive parsing table for the following grammar:\
n"); for(i=0;i<7;i++)
printf("%s\n",prod[i]); printf("\
nPredictive 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]);
for(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("%-10s",table[i][j]);
if(j==5)
printf("\n --\n");
}
}

OUTPUT:-
 Experiment No. 8a
AIM: - Write a C program for constructing of LL (1) parsing.

DESCRIPTION:

CODE:-

#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"," a","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;
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;
 Experiment No. 8b
AIM:- Construction of recursive descent parsing for the following grammar E-
>TE'
E'->+TE/@ "@ represents null character"
T->FT'
T`->*FT'/@
F->(E)/ID
DESCRIPTION:
CODE:-

#include<stdio.h>
#include<conio.h>
#include<string.h>
char input[100]; int
i,l;
void main()
{
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]=='+'){
OUTPUT:-
 Experiment No. 9

AIM: - Write a program to Design LALR Bottom up Parser.

DESCRIPTION:

CODE:-

#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"},
 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:-
 Experiment No. 10a
AIM: - Write a C program to implement operator precedence parsing.

DESCRIPTION:

CODE:-
#include<stdio.h>
#include<string.h>
char str[50],opstr[75];
int f[2][9]={2,3,4,4,4,0,6,6,0,1,1,3,3,5,5,0,5,0};
int col,col1,col2;
char c;
swt(){
switch(c){
case'+':col=0;break;
case'-':col=1;break;
case'*':col=2;break;
case'/':col=3;break;
case'^':col=4;break;
case'(':col=5;break;
case')':col=6;break;
case'd':col=7;break;
case'$':col=8;break;
default:printf("\nTERMINAL MISSMATCH\n");
exit(1);
break;}
}
main(){
int i=0,j=0,col1,cn,k=0;
int t1=0,foundg=0; char
temp[20];
printf("\nEnter arithmetic expression:");
scanf("%s",&str);
while(str[i]!='\0')
i++;
str[i]='$';
str[++i]='\0';
printf("%s\n",str);
come:
i=0;
opstr[0]='$';
j=1;
c='$';
swt();
col1=col;
c=str[i];
swt();
col2=col;
if(f[1][col1]>f[2][col2]){
opstr[j]='>';
 printf("\n%s",opstr);
i=1;}
redone:k=0;
while(opstr[k]!='\0'){
k++;
if(opstr[k]=='<'){
printf("\nError");
exit(1);}}
if((opstr[0]=='$')&&(opstr[2]=='$'))
goto sue;
i=1;
while(opstr[i]!='\0'){
c=opstr[i];
if(c=='+'||c=='*'||c=='/'||c=='$'){ temp[j]=c;j++;}
i++;}
temp[j]='\0';
strcpy(str,temp);
goto come;
sue:
printf("\n success");
return 0;}

OUTPUT:-
 Experiment No. 10b
AIM: - Write a C program to implement Program semantic rules to calculate the expression that
takes an expression with digits, + and * and computes the value.

DESCRIPTION:

CODE:-

cal.l
%{
#include<stdio.h>
#include<math.h>
#include"y.tab.h"
%}
%%
([0-9]+|([0-9]*\.[0-9]+)([eE][-+]?[0-9]+)?)
{yylval.dval=atof(yytext); return NUMBER;}
MEM {return MEM;}
[\t];
\$ {return 0;}
\n {return yytext[0];}
. {return yytext[0];}
%%
cal.y
{
#include<stdio.h>
#include<math.h>
double memvar;
%}
%union
{
double dval;
}
%token<dval> NUMBER
%token<dval> MEM
%left '-' '+'
%left '*' '/' %nonassoc
UMINUS %type<dval>
expression
%%
start:statement '\n'
|start statement '\n'
statement:MEM '=' expression {memvar=$3;}
|expression {printf("Result=%g\n",$1);}
;
expression:expression'+'expression
{$$=$1+$3;} |expression'-'expression
{$$=$1-$3;} |expression'*'expression
{$$=$1*$3;} |expression'/'expression
{if($3==0) yyerror("divide by zero");
 else
$$=$1/$3;
};
expression:'-'expression %prec UMINUS {$$= -$2;}
|'('expression')' {$$=$2;}
|NUMBER {$$=$1;}
|MEM {$$=memvar;};
%%
int main(void)
{
printf("Enter the expression:");
yyparse();
printf("\n\n");
return 0;
}
int yywrap()
{
return 0;
}
int yyerror(char *error)
{
printf("%s\n",error);
return 0;
}

OUTPUT:-
 Experiment No. 12
AIM: - Write a C program to generate machine code from abstract syntax tree generated by the
parser. The instruction set specified in Note 2 may be considered as the target code.

DESCRIPTION:

CODE:-

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
int label[20];
int no=0;
int main()
{
FILE *fp1,*fp2;
char fname[10],op[10],ch;
char operand1[8],operand2[8],result[8]; int
i=0,j=0;
printf("\n Enter filename of the intermediate code");
scanf("%s",&fname);
fp1=fopen(fname,"r");
fp2=fopen("target.txt","w");
if(fp1==NULL || fp2==NULL)
{
printf("\n Error opening the file");
exit(0);}
while(!feof(fp1)){
fprintf(fp2,"\n");
fscanf(fp1,"%s",op); i++;
if(check_label(i))
fprintf(fp2,"\nlabel#%d",i);
if(strcmp(op,"print")==0)
{
fscanf(fp1,"%s",result); fprintf(fp2,"\
n\t OUT %s",result);
}
if(strcmp(op,"goto")==0){
fscanf(fp1,"%s %s",operand1,operand2); fprintf(fp2,"\n\t
JMP %s,label#%s",operand1,operand2); label[no+
+]=atoi(operand2);
}
if(strcmp(op,"[]=")==0){
fscanf(fp1,"%s %s %s",operand1,operand2,result); fprintf(fp2,"\n\t
STORE %s[%s],%s",operand1,operand2,result);
}
if(strcmp(op,"uminus")==0){ fscanf(fp1,"%s
%s",operand1,result); fprintf(fp2,"\n\t LOAD
-%s,R1",operand1); fprintf(fp2,"\n\t STORE
R1,%s",result);
}
 exit(0);}
do{
ch=fgetc(fp2);
printf("%c",ch);
}
while(ch!=EOF);
fclose(fp1);
return 0;
}
int check_label(int k)
{int i;
for(i=0;i<no;i++)
{
if(k==label[i]) return1;}
return0;}

OUTPUT:-