Compiler Construction

LAB-5
PART-1 Test your Lexical analyzer by: Part-1 Results:

a. Call with wrong file name.

b. Submit an empty file and see how your lex
behaves.
c. Test whether your lexical analyzer handles
single c style one-line comments.
// abcdefgh
//jjhhtyuuiii

d. Test single character lexical units. With

and without space in between
()[]{},;:
([)]{,;]:

e. Test operators with and without spaces in

between
+ += ++ * == * * * ++ += ==<< >==
++++++******======➔>>>>>>>
f. Mix single character and operators (+-) ==

Part-1 Results:
g. Test keywords and identifiers and symbol
table.
If21 if while while123 xyzif foryes
// abcdefgh
//jjhhtyuuiii (
)[]{},;:
([)]{,;]:
+ += ++ * == * * * ++ += ==<< >==
++++++******======➔>>>>>>>

Your task is to write a program which processes a file containing any number of
abovementioned keywords or operators. your program reads characters, groups them in an
internal buffer and if the characters in the buffer match with any of the above it prints a
message.

Strategy:

1- Open input text file in read mode Task 1. Skip

white space.
2- Read file character by character in a char variable.

1
Compiler Construction

3- Check whether the character read is a space, tab, newline, if so skip ot and read next
character, --- we skip space characters because C language uses space characters for
formatting purpose only.
4- Consume C style comments starting with // consume all character until newline char
found.

Task 2. Detect single character patterns and return corresponding tokens.

Task 3. Detect character patterns for operators and return corresponding

tokens.

Task 4. Detect integer numbers and return corresponding tokens.

Task 5. Detect key words return corresponding tokens.

Task 6. Detect identifiers return corresponding tokens.

Task -7 Make a symbol table for identifiers with the following functions: entry

*Search(string) . entry * make_entry(string) .

Get your code checked by lab engineer.

#include<iostream>
#include<conio.h>
#include <string>
#include <fstream>
using namespace std;
fstream AMINA;
enum tokentype { A_PLUS_PLUS, A_EQUALSTO, A_plus, A_MINUS_MINUS, A_MINUS_EQUALS,
A_MINUS, A_MULTIPLY_EQUALS, A_MULTIPLY, A_DIVIDE_EQUALS, A_DIVIDE,
A_MOD_EQUALS, A_MOD, A_EQUALSTO_EQUALSTO, A_EQUAL, A_NOT_EQUALS, A_NOT_EQUALS_TO,
A_AND_AND, A_AND, A_OR_OR, A_OR, A_right_opening_bracket,
A_left_opening_bracket, A_right_round_bracket, A_left_round_bracket, A_comma_op,
A_semicolon, A_GREATER_OR_EQUALTO, A_input, A_GREATER_THAN,
A_LESS_OR_EQUALTO, A_output, A_LESS_THAN, A_num, A_if, A_elseif, A_int, A_while, A_do,
A_for, A_return, A_float, A_double, A_string, A_variable };

struct AMINA_STRUCTURE
{
tokentype t;
string identifier;
string name = "";
int val = 0;
};
int maximum = 0;
string array1[10];
int insertsymboltable(string name)
{
int returnvalue;
int flag = 0;
for (int i = 0; i <= maximum; i++)
{
if (array1[i] == name)
{
flag = 0;
returnvalue = i;
return returnvalue;
}
else
{
flag = 1;
}
}
if (flag == 1)
{
array1[maximum] = name;
maximum++;
return maximum;
}
}

AMINA_STRUCTURE lexical()
{
AMINA_STRUCTURE A1;
char character;
//Check for operators
if (character == '+')
{
AMINA.get(character);
if (character == '+')
{
A1.t = A_PLUS_PLUS;
A1.name = "PLUS_PLUS";
A1.val;
return A1;
}
else if (character == '=')
{
A1.t = A_EQUALSTO;
A1.name = "A_EQUALSTO";
A1.val;
 return A1;

}
else
{
A1.t = A_plus;
A1.name = "A_plus";
A1.val;
return A1;

}
}
else if (character == '-')
{
AMINA.get(character);
if (character == '-')
{
A1.t = A_MINUS_MINUS;
A1.name = "A_MINUS_MINUS";
A1.val;
return A1;

}
else if (character == '=')
{
A1.t = A_MINUS_EQUALS;
A1.name = "A_MINUS_EQUALS";
A1.val;
return A1;

}
else
{
A1.t = A_MINUS;
A1.name = "A_MINUS";
A1.val;
return A1;

}
}
else if (character == '*')
{
AMINA.get(character);
if (character == '=')
{
A1.t = A_MULTIPLY_EQUALS;
A1.name = "A_MULTIPLY_EQUALS";
A1.val;
return A1;

}
else
{
A1.t = A_MULTIPLY;
A1.name = "A_MULTIPLY";
A1.val;
return A1;

}
}
else if (character == '/')
{
AMINA.get(character);
if (character == '=')
 {
A1.t = A_DIVIDE_EQUALS;
A1.name = "A_DIVIDE_EQUALS";
A1.val;
return A1;

}
else {
A1.t = A_DIVIDE;
A1.name = "A_DIVIDE";
A1.val;
return A1;

}
}
else if (character == '%')
{
AMINA.get(character);
if (character == '=')
{
A1.t = A_MOD_EQUALS;
A1.name = "A_MOD_EQUALS";
A1.val;
return A1;

}
else {
A1.t = A_MOD;
A1.name = "A_MOD";
A1.val;
return A1;

}
}
else if (character == '=')
{
AMINA.get(character);
if (character == '=')
{
A1.t = A_EQUALSTO_EQUALSTO;
A1.name = "A_EQUALSTO_EQUALSTO";
A1.val;
return A1;

}
else {
A1.t = A_EQUAL;
A1.name = "A_EQUAL";
A1.val;
return A1;

}
}
else if (character == '!')
{
AMINA.get(character);
if (character == '=')
{
A1.t = A_NOT_EQUALS;
A1.name = "A_NOT_EQUALS";
A1.val;
return A1;

}
else {
 A1.t = A_NOT_EQUALS_TO;
A1.name = " A_NOT_EQUALS_TO";
A1.val;
return A1;

}
}
else if (character == '&')
{
AMINA.get(character);
if (character == '&')
{
A1.t = A_AND_AND;
A1.name = "A_AND_AND";
A1.val;
return A1;

}
else {
A1.t = A_AND;
A1.name = "A_AND";
A1.val;
return A1;

}
}
else if (character == '|')
{
AMINA.get(character);
if (character == '|')
{
A1.t = A_OR_OR;
A1.name = "A_OR_OR";
A1.val;
return A1;

}
else
{
A1.t = A_OR;
A1.name = "A_OR";
A1.val;
return A1;

}
}
else if (character == '{')
{

A1.t = A_right_opening_bracket;
A1.name = "A_right_opening_bracket";
A1.val;
return A1;

}
else if (character == '}')
{
A1.t = A_left_opening_bracket;
A1.name = "A_left_opening_bracket";
A1.val;
return A1;
}
else if (character == '(')
{
A1.t = A_right_round_bracket;
A1.name = "A_right_round_bracket";
A1.val;
return A1;

}
else if (character == ')')
{
A1.t = A_left_round_bracket;
A1.name = "A_left_round_bracket";
A1.val;
return A1;

}
else if (character == ',')
{
A1.t = A_comma_op;
A1.name = "A_comma_op";
A1.val;
return A1;
}
else if (character == ';')
{
A1.t = A_semicolon;
A1.name = "A_semicolon";
A1.val;
return A1;

}
else if (character == '>')
{
AMINA.get(character);
if (character == '=')
{
A1.t = A_GREATER_OR_EQUALTO;
A1.name = "A_GREATER_OR_EQUALTO";
A1.val;
return A1;

}
else if (character == '>')
{
A1.t = A_input;
A1.name = "A_input";
A1.val;
return A1;

}
else
{
A1.t = A_GREATER_THAN;
A1.name = "A_GREATER_THAN ";
A1.val;
return A1;

}
}
else if (character == '<')
{
AMINA.get(character);
if (character == '=')
{
 A1.t = A_LESS_OR_EQUALTO;
A1.name = "A_LESS_OR_EQUALTO";
A1.val;
return A1;

}
else if (character == '<')
{
A1.t = A_output;
A1.name = "A_output";
A1.val;
return A1;

}
else
{
A1.t = A_LESS_THAN;
A1.name = "A_LESS_THAN";
A1.val;
return A1;

}
}
else if (isdigit(character))
{
string s;
do
{
s += character;
AMINA.get(character);
} while (isdigit(character));
AMINA.putback(character);
A1.t = A_num;
A1.name = "IS A NUMBER";
A1.val;
return A1;
}
else if (isalpha(character))
{
string s;
do
{
s += character;
AMINA.get(character);
} while (isalpha(character) || isdigit(character));
AMINA.putback(character);
if (s == "if")
{
A1.t = A_if;
A1.name = "..IF..";
A1.val;
return A1;

}
else if (s == "else if")
{
A1.t = A_elseif;
A1.name = "..ELSE_IF..";
A1.val;
return A1;

}
else if (s == "int")
{
A1.t = A_int;
 A1.name = "..INT..";
A1.val;
return A1;

}
else if (s == "while")
{
A1.t = A_while;
A1.name = "..WHILE..";
A1.val;
return A1;
}
else if (s == "do")
{
A1.t = A_do;
A1.name = "..DO..";
A1.val;
return A1;

}
else if (s == "return")
{
A1.t = A_return;
A1.name = "..RETURN..";
A1.val;
return A1;

}
else if (s == "for")
{
A1.t = A_for;
A1.name = "..FOR..";
A1.val;
return A1;

}
else if (s == "float")
{
A1.t = A_float;
A1.name = "..FLOAT..";
A1.val;
return A1;

}
else if (s == "double")
{
A1.t = A_double;
A1.name = "..DOUBLE..";
A1.val;
return A1;

}
else if (s == "string")
{
A1.t = A_string;
A1.name = "..STRING..";
A1.val;
return A1;

}
else if (s == "variable")
{
A1.t = A_variable;
A1.name = "..variable..";
A1.val;
 return A1;

}
else {
AMINA_STRUCTURE AM;
int val = insertsymboltable(s);
AM.t = A_variable;
AM.identifier = "A_variable,";
AM.identifier += val;
AM.val = NULL;
return AM;
}

}
}

int main()
{
AMINA.open("C:\\Users\\amina\\OneDrive\\Desktop\\AMINA.txt");
if (!AMINA)
{
cout << "file does not exist";
}
else
{
char character;

while (!AMINA.eof())
{
AMINA.get(character);
if (AMINA.eof())
{
break;
}
else if (character == ' ' || character == '\n' || character == '\
t')
{
continue;
}
else if (character == '/')
{
AMINA.get(character);
if (character == '/')
{
while (character != '\n')
{
AMINA.get(character);
continue;
}
}
}
system("pause");
return 0;
}
}
}
2