Saffrony Institute of Technology

S.P.B.Patel Engineering College

Linch, Mehsana

Department of
Computer Engineering & Information Technology

Laboratory Manual

“Compiler Design”
Subject Code: 3170701

Student Name

Enrollment Number

Semester & Branch

Academic Term
 Certificate

This is to certify that Mr/Ms.

Enrolment No. of 7th Semester Degree Course in
Computer Engineering Department has satisfactorily completed and
submitted his Laboratory work in the subject of ‘Compiler Design
(3170701)’within four walls of the Laboratory of the Institute during
Winter 2023.

Subject In-charge Head of Department

Date: / /
Teaching and Examination Scheme

Course Outcome
 Index

Sr. Page
Date Title of Experiments Signature Remarks
no. No.

1 Introduction of LEX

2 Lex program to print “hello world”.

Lex program for identifying and

3 classifying the input as keywords,
identifiers, digits, or words.
Lex program for displaying a message
4
when the Enter key is pressed.
Lex program for checking whether the
5 input string contains all lowercase
characters, all uppercase characters, or
a mixture of both.
Lex program for checking whether
6
the input string contains both
consonants and vowels.
Lex program for creating a Lexer
7
that takes input from a text file and
counts the number of characters,
number of lines, and other relevant
metrics.
Lex program for implementing the
8
Caesar cipher encryption
algorithm on a given string.
Lex program for extracting single and
9 multi-line comments from a C
program.
C program for implementing a
10
recursive descent parsing
algorithm.
C program for implementing an
11
LL(1) parsing algorithm.

C program for implementing an

12
LALR parsing algorithm.
PRACTICAL – 1

Aim: Introduction of LEX

A lexical analyzer takes input streams and divides into tokens. This division into units is known as
lexical analysis. Lex takes set of rules for valid tokens and produce C program which we call lexical
analyzer or lexer that can identify these tokens.

Lex is a lexical analyzer generator-a tool for programming that recognizes lexical patterns in the input
with the help of Lex specifications. Lex is generally used in the manner as shown below.

First, a specification of a lexical analyzer is prepared by creating a program lex.l in the Lex language.
Then, the lex.l is run through the Lex compiler to produce a c program lex.yy.c. This program consists
of a tabular representation of a transition diagram constructed from the regular expression of lex.l,
together with a standard routine that uses the table to recognize lexemes.

The action associated with regular expression in lex.l is pieces of C code and are carried over directly
to lex.yy.c. Finally lex.yy.c is run through the C compiler to produce an object program a.out, which is
the lexical analyzer that transforms an input stream into a sequence of tokens.

1 Compiler Design (3170701)

Structure of Lex Program

Declarations

%%
Rules Section
%%

User Code(Auxiliary) Section

Definition Section

It contains different user defined Lex options used by the lexer. It also creates an environment for the
execution of the Lex program.

The definition section creates an environment for the lexer, which is a C code. This area of the Lex
specification is separated by “ %{ “ , and it contains C statements, such as global declarations,
commands, including library files and other declarations, which will be copied to the lexical
analyzer(lex.yy.c) when it passed through the Lex tool.

The definition section provides an environment for the Lex tool to convert the Lex specifications
correctly and efficiently to a lexical analyzer. This section mainly contains declarations of simple name
definitions to simplify the scanner specifications and declarations of start condition. The statement in
this section will help the Lex rules to run efficiently.
Example:

%{
#include "calc.h"
#include <stdio.h>
#include <stdlib.h>
char name[10];
%}

/* Regular expressions */
/* ------------------- */

white [\t\n ]+
letter [A-Za-z]
digit [0-9]
identifier
{letter}(_|{letter}|{digit10})*

Rule Section
It contains the patterns and actions that specify the lex specifications. A pattern is in the form of a
regular expression to match the largest possible string.
Once the pattern is matched, the corresponding action part is invoked. The action part contains normal
C language statements. They are enclosed within braces ( “{“ and “}”), if there is more than one
statement then make these component statements into single block of statements.

2 Compiler Design (3170701)

Example:

%%
{LETTER}({LETTER}| {DIGIT})* {
printf(“\n It is a Identifier: %s \n”, yytext);
}

%%

Always use braces to make the code clear, if the action has more than one statement or more than one
line large. The lexer always tries to match the largest possible string, but when there are two possible
rules that match the same length, the lexer uses the first rule in the Lex specification to invoke its
corresponding action.

User defined section

This section contains any valid C code. Lex copies the contents of this section into generated lexical
analyzer as it is. Lex itself does not produce an executable program; instead, it translates the Lex specifications into a
file containing a C subroutine called yylex().

All the rules in the rule section will automatically be converted into C statements by the Lex tool and will be put under the
function name of yylex(). Whenever, we call the function yylex, C statements corresponding to the rules will be executed.
That is we called the function yylex() in main function, even though we have not defined it anywhere in the program.

Example:

/* ……………User define Function………………..*/

void display(int a)
{
………
………..
}

main()
{
yylex();
}

3 Compiler Design (3170701)

Compiling and executing the Lex program
%{
%}

%%
%%

main()
{
yylex();
}

Let above program be in file called practical.l. To create or generate a lexical analyzer we must enter
the following command
$ lex practical.l
When, the above command is executed, Lex translates the Lex specification into a C source file called
lex.yy.c, which is a lexical analyzer. Any lexical analyzer can be compiled using the following
command
$ cc lex.yy.c –ll
This will compile the lexical analyzer, lex.yy.c, using any C compiler by linking it with Lex library
using the extension –ll. After compilation, the output, by default, will write to “a.out” file.
The resulting program is executed using the following command
$ ./a.out or $ ./a.out < filename

Lex variables
yyin Of the type FILE*. This points to the current file being
parsed by the lexer.
yyout Of the type FILE*. This points to the location where
the output of the lexer will be written. By default, both
yyin and yyout point to standard input and output.
yytext The text of the matched pattern is stored in this
variable (char*).
yyleng Gives the length of the matched pattern.
yylineno Provides current line number information

4 Compiler Design (3170701)

PRACTICAL – 2

Aim: Lex program to print “hello world”.

Program:
%{
%}

%%
.{
printf("hello world\n");
exit(0);
}
Output:

5 Compiler Design (3170701)

PRACTICAL – 3

Aim: Lex program for identifying and classifying the input as keywords,
identifiers, digits, or words.

Program:
%{
#include <stdio.h>
#include <string.h>
#include <ctype.h>
%}
keyword "if"|"else"|"for"|"while"
digit [0-9]+
identifier [a-zA-Z_][a-zA-Z0-9_]*
word [a-zA-Z]+
%%
{keyword} {
printf("Keyword: %s\n", yytext);
}
{digit} {
printf("Digit: %s\n", yytext);
}
{identifier}{
printf("Identifier: %s\n", yytext);
}
{word} {
printf("Word: %s\n", yytext);
6 Compiler Design (3170701)
 }
[ \t\n]+ ; /* skip white spaces */
. {
printf("Unknown: %c\n", yytext[0]);
}
%%
int yywrap() {
return 1;
}
int main() {
yylex();
return 0;
}
Output:

7 Compiler Design (3170701)

PRACTICAL – 4

Aim: Lex program for displaying a message when the Enter key is
pressed.

Program:
%{
#include <stdio.h>
%}
%%
\n {
printf("Enter key pressed!\n");
};
%%
int yywrap() {
return 1;
}
int main() {
yylex();
return 0;
}
Output:

8 Compiler Design (3170701)

PRACTICAL – 5

Aim: Lex program for checking whether the input string contains all
lowercase characters, all uppercase characters, or a mixture of both.

Program:
%{
#include <stdio.h>
#include <string.h>
#include <ctype.h>
%}
alpha [a-zA-Z]+
%%
{alpha} {
int lower_count = 0;
int upper_count = 0;
for (int i = 0; i < strlen(yytext); ++i) {
if (islower(yytext[i])) {
++lower_count;
} else if (isupper(yytext[i])) {
++upper_count;
}
}
if (lower_count == strlen(yytext)) {
printf("All lowercase\n");
} else if (upper_count == strlen(yytext)) {
printf("All uppercase\n");
9 Compiler Design (3170701)
 } else {
printf("Mixture of both\n");
}
}
[ \t\n]+ ; /* skip white spaces */
. { /* ignore other characters */ }
%%
int yywrap() {
return 1;
}
int main() {
yylex();
return 0;
}

Output:

10 Compiler Design (3170701)

PRACTICAL – 6

Aim: Lex program for checking whether the input string contains both
consonants and vowels.

Program:
%{
#include <stdio.h>
#include <string.h>
#include <ctype.h>
%}
alpha [a-zA-Z]+
%%
{alpha} {
int vowel_count = 0;
int consonant_count = 0;
for (int i = 0; i < strlen(yytext); ++i) {
if (tolower(yytext[i]) == 'a' || tolower(yytext[i]) == 'e' ||
tolower(yytext[i]) == 'i' || tolower(yytext[i]) == 'o' ||
tolower(yytext[i]) == 'u') {
++vowel_count;
} else if (isalpha(yytext[i])) {
++consonant_count;
}
}
if (vowel_count > 0 && consonant_count > 0) {
printf("Contains both vowels and consonants\n");
11 Compiler Design (3170701)
 } else {
printf("Does not contain both vowels and consonants\n");
}
}
[ \t\n]+ ; /* skip white spaces */
. { /* ignore other characters */ }
%%
int yywrap() {
return 1;
}
int main() {
yylex();
return 0;
}

Output:

12 Compiler Design (3170701)

PRACTICAL – 7

Aim: Lex program for creating a Lexer that takes input from a text file
and counts the number of characters, number of lines, and other relevant
metrics.

Program:
%{
#include <stdio.h>

int char_count = 0;
int line_count = 0;
int word_count = 0;
int non_whitespace_count = 0;
%}

%%

\n {
++line_count;
++char_count;
}

[ \t\r]+ ; /* skip white spaces */

[^\s]+ {
++word_count;

13 Compiler Design (3170701)

 non_whitespace_count += strlen(yytext);
}

.{
++char_count;
}

%%

int yywrap() {
return 1;
}

int main(int argc, char *argv[]) {

if (argc != 2) {
fprintf(stderr, "Usage: %s <filename>\n", argv[0]);
return 1;
}

FILE *file = fopen(argv[1], "r");

if (file == NULL) {
fprintf(stderr, "Error opening file: %s\n", argv[1]);
return 1;
}

yyin = file;

14 Compiler Design (3170701)

 yylex();
fclose(file);

printf("Number of characters: %d\n", char_count);

printf("Number of lines: %d\n", line_count);
printf("Number of words: %d\n", word_count);
printf("Number of non-whitespace characters: %d\n",
non_whitespace_count);

return 0;
}
Output:

15 Compiler Design (3170701)

PRACTICAL – 8

Aim: Lex program for implementing the Caesar cipher encryption

algorithm on a given string.

Program:
%{
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#define SHIFT 3

void caesar_cipher(char *str) {

for (int i = 0; i < strlen(str); ++i) {
if (isalpha(str[i])) {
char base = isupper(str[i]) ? 'A' : 'a';
str[i] = (str[i] - base + SHIFT) % 26 + base;
}
}
}
%}
%%

[a-zA-Z]+ {
caesar_cipher(yytext);
printf("Encrypted: %s\n", yytext);
}
16 Compiler Design (3170701)
[ \t\n]+ ; /* skip white spaces */

. { /* ignore other characters */ }

%%
int yywrap() {
return 1;
}

int main() {
yylex();
return 0;
}
Output:

17 Compiler Design (3170701)

PRACTICAL – 9

Aim: Lex program for extracting single and multi-line comments from a
C program.

Program:
%{
#include <stdio.h>
%}

single_comment "//"[^\n]*
multi_comment "/\\*"[^*]*"\\*/"

%%

{single_comment} {
printf("Single line comment: %s\n", yytext);
}

{multi_comment} {
printf("Multi line comment: %s\n", yytext);
}

[ \t\n]+ ; /* skip white spaces */

. ; /* ignore other characters */

18 Compiler Design (3170701)

%%

int yywrap() {
return 1;
}

int main() {
yylex();
return 0;
}
Output:

19 Compiler Design (3170701)

PRACTICAL – 10

Aim: C program for implementing a recursive descent parsing

algorithm.

Program:
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
char s[20],stack[20];
int 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]) {

20 Compiler Design (3170701)

 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--;
} else if(m[str1][str2][0]=='i') {
stack[i]='i';
} else {

21 Compiler Design (3170701)

 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");
return 0;
}
Output:

22 Compiler Design (3170701)

PRACTICAL – 11

Aim: C program for implementing an LL(1) parsing algorithm.

Program:
#include<stdio.h>
#include<string.h>
#include<stdlib.h>

char s[20], stack[20];

int main() {
char m[5][6][3] = {
{"tb"," "," ","tb"," "," "},
{" ","+tb"," "," ","n","n"},
{"fc"," "," ","fc"," "," "},
{" "," "," ","n" ,"*fc"," a"},
{"n","n","i"," "," ","("}
};

int size[5][6] = {
{2,0,0,2,0,0},
{0,3,0,0,1,1},
{2,0,0,2,0,0},
{0,0,0,1,3,0},
{1,1,1,0,0,3}

23 Compiler Design (3170701)

 };

int i, j, k, n, str1, str2;

char e = 'e';

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;

24 Compiler Design (3170701)

 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--;
} else 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++;
}

25 Compiler Design (3170701)

 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");

return 0;
}
Output:

26 Compiler Design (3170701)

PRACTICAL – 12

Aim: C program for implementing an LALR parsing algorithm.

Program:
#include<stdio.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"},

27 Compiler Design (3170701)

 {"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', '+', '*', ')', '(', '$'};

28 Compiler Design (3170701)

char nter[3] = {'E', 'T', 'F'};
char states[12] = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'm', 'j', 'k', 'l'};
char 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"},
};
int 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);

29 Compiler Design (3170701)

 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);
for (m = 0; dl[m] != '\0'; m++)
push(stack, &top, dl[m]);

30 Compiler Design (3170701)

 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 ");
getchar();
return 0;
}
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) {

31 Compiler Design (3170701)

 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;
}
int isstate(char p) {
int i;

32 Compiler Design (3170701)

 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, char inp[], int i) {

33 Compiler Design (3170701)

 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");

34 Compiler Design (3170701)

 break;
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;
}

35 Compiler Design (3170701)

}

Output:

36 Compiler Design (3170701)