please can you help me to translate this code from c to c++
/***************************************************************
Program describtion :
=====================
This program is for creating a Lexical Analyzer in c
Created by :
=============
CoMPuTeRQ8
kuwait university
Major : COMPuTeR-SCIeNCe
*****************************************************************/
/****************************************************************
Necessary Header files used in program.
*****************************************************************/
#include<stdio.h>
#include<string.h>
#include<conio.h>
#include<ctype.h>
/****************************************************************
Functions prototype.
*****************************************************************/
void Open_File();
void Demage_Lexeme();
int Search(char[256],int);
void analyze();
void Skip_Comment();
void Read_String();
void Is_Keyword_Or_Not();
void Is_Identifier_Or_Not();
void Is_Operator_Or_Not();
void Read_Number();
void Is_Special_Or_Not();
void Is_Comparison_Or_Not();
void Add_To_Lexical (char[256],int,char[256]);
void Print_ST();
void Print_TOKEN();
void Token_Attribute();
/****************************************************************
Data structure used in program.
*****************************************************************/
struct lexical
{
char data[256]; //Value of token.
int line[256]; //Line # which token appear in input file.
int times; //# of times that token appear in input file.
char type[256]; //Type of each token.
struct lexical *next;
};
typedef struct lexical Lex;
typedef Lex *lex;
/****************************************************************
File pointer for accessing the file.
*****************************************************************/
FILE *fp;
FILE *st;
FILE *token;
char lexeme[256],ch;
int f,flag,line=1,i=1;
lex head=NULL,tail=NULL;
/****************************************************************
Array holding all keywords for checking.
*****************************************************************/
char *keywords[]={"procedure","is","begin","end","var","cin","cout","if",
"then","else","and","or","not","loop","exit","when",
"while","until"};
/****************************************************************
Array holding all arithmetic operations for checking.
*****************************************************************/
char arithmetic_operator[]={'+','-','*','/'};
/****************************************************************
Array holding all comparison operations for checking.
*****************************************************************/
char *comparison_operator[]={"<",">","=","<=","<>",">="};
/****************************************************************
Array holding all special for checking.
*****************************************************************/
char special[]={'%','!','@','~','$'};
/****************************************************************
**************
*MAIN PROGRAM*
**************
*****************************************************************/
void main()
{
Open_File();
analyze();
fclose(fp);
Print_ST();
Print_TOKEN();
}
/****************************************************************
This function open input sourse file.
*****************************************************************/
void Open_File()
{
fp=fopen("source.txt","r"); //provide path for source.txt here
if(fp==NULL)
{
printf("!!!Can't open input file - source.txt!!!");
getch();
exit(0);
}
}
/****************************************************************
Function to add item to structure of array to store data and
information of lexical items.
*****************************************************************/
void Add_To_Lexical (char value[256],int line,char type[256])
{
lex new_lex;
if (!Search(value,line)) //When return 1 the token not found.
{
new_lex=malloc(sizeof(Lex));
if (new_lex!=NULL)
{
strcpy(new_lex->data,value);
new_lex->line[0]=line;
new_lex->times=1;
strcpy(new_lex->type,type);
new_lex->next=NULL;
if (head==NULL)
head=new_lex;
else
tail->next=new_lex;
tail=new_lex;
}
}
}
/****************************************************************
Function to search token.
*****************************************************************/
int Search (char value[256],int line)
{
lex x=head;
int flag=0;
while (x->next!=NULL && !flag)
{
if (strcmp(x->data,value)==0)
{
x->line[x->times]=line;
x->times++;
flag=1;
}
x=x->next;
}
return flag;
}
/****************************************************************
Function to print the ST.TXT .
*****************************************************************/
void Print_ST()
{
lex x=head;
int j;
if ((st=fopen("ST.TXT","w"))==NULL)
printf("The file ST.TXT cat not open. \n");
else
{
fprintf(st,"\t %s \t %s \t %s \n","Line#","Lexeme","Type");
fprintf(st,"\t ---- \t ------ \t ---- \n");
while (x!=NULL)
{
if ((strcmp(x->type,"num")==0) ||
(strcmp(x->type,"keyword")==0) ||
(strcmp(x->type,"identifier")==0))
{
fprintf(st,"\t ");
for (j=0;j<x->times;j++)
{
fprintf(st,"%d",x->line[j]);
if (j!=x->times-1) //This condition to prevent the comma
fprintf(st,",",x->line[j]); //"," to not print after last line #.
}
fprintf(st,"\t %-6s \t%-6s \n",x->data,x->type);
}
x=x->next;
}
fclose(st);
}
}
/****************************************************************
Function to print the TOKENS.TXT .
*****************************************************************/
void Print_TOKEN()
{
int flag=0;
fp=fopen("source.txt","r");
if(fp==NULL)
{
printf("!!!Can't open input file - source.txt!!!");
getch();
exit(0);
}
else
{
if ((token=fopen("TOKENS.TXT","w"))==NULL)
printf("The file ST.TXT cat not open. \n");
else
{
ch=fgetc(fp);
while (!(feof(fp)))
{
if (ch==' ' && !flag)
{
do
ch=fgetc(fp);
while (ch==' ');
fseek(fp,-2,1);
ch=fgetc(fp);
flag=1;
}
if (ch!='\n' && ch!='\t')
fprintf(token,"%c",ch);
if (ch=='\n')
{
fprintf(token,"\n");
Token_Attribute();
i++;
flag=0;
}
ch=fgetc(fp);
}
}
}
fclose(fp);
fclose(token);
}
/****************************************************************
Function to put the token and atrribute in TOKENS.TXT .
*****************************************************************/
void Token_Attribute()
{
lex x=head;
int j;
while (x!=NULL)
{
if (x->line[0]==i)
{
fprintf(token,"token : %-4s\t",x->type);
if ((strcmp(x->type,"num")==0) ||
(strcmp(x->type,"keyword")==0) ||
(strcmp(x->type,"identifier")==0))
{
fprintf(token,"attribute : line#=%-4d \n",i);
}
else
{
fprintf(token,"attribute : %-4s \n",x->data);
}
}
x=x->next;
}
fprintf(token,"\n");
}
/****************************************************************
Function to create lexical analysis.
*****************************************************************/
void analyze()
{
ch=fgetc(fp); //Read character.
while(!feof(fp)) //While the file is not end.
{
if(ch=='\n') //Compute # of lines in source.txt .
{
line++;
ch=fgetc(fp);
}
if(isspace(ch) && ch=='\n' )
{
line++;
ch=fgetc(fp);
}
if(isspace(ch) && ch!='\n' ) //The character is space.
ch=fgetc(fp);
if(ch=='/' || ch=='"') //Function for skipping comments in the file
Skip_Comment(); //and '"' with display statements.
if(isalpha(ch)) //The character is leter.
{
Read_String();
Is_Keyword_Or_Not();
Is_Operator_Or_Not();
Is_Identifier_Or_Not();
}
if(isdigit(ch)) //The character is digit.
Read_Number();
if (ch==';') //The character is semicolon.
Add_To_Lexical(";",line,"semicolon");
if (ch==':') //The character is colon.
Add_To_Lexical(":",line,"colon");
if (ch==',') //The character is comma.
Add_To_Lexical(",",line,"comma");
if (ch=='(') //The character is parenthesis.
Add_To_Lexical("(",line,"parenthesis");
if (ch==')') //The character is parenthesis.
Add_To_Lexical(")",line,"parenthesis");
//The character is comparison_operator
if (ch=='<' || ch=='=' || ch=='>')
Is_Comparison_Or_Not();
Is_Special_Or_Not(); //After failed scaning in before cases
//check the character is special or not.
Demage_Lexeme();
if(isspace(ch) && ch=='\n' )
{
line++;
ch=fgetc(fp);
}
else
ch=fgetc(fp);
}
}
/****************************************************************
This function read all character of strings.
*****************************************************************/
void Read_String()
{
int j=0;
do
{
lexeme[j++]=ch;
ch=fgetc(fp);
} while(isalpha(ch));
fseek(fp,-1,1);
lexeme[j]='\0';
}
/****************************************************************
This function demage the data stored in the lexeme to store
next word without any previous character of previous word .
*****************************************************************/
void Demage_Lexeme()
{
int j=0;
while (lexeme[j]!='\0')
{
lexeme[j]='\0';
j++;
}
}
/****************************************************************
This function check the string is keyword or not.
*****************************************************************/
void Is_Keyword_Or_Not()
{
int j=0;
flag=0;
for (j=0;j<18;j++) //search for keyword & # of keywords = 18.
{
if (strcmp(lexeme,keywords[j])==0)
{
Add_To_Lexical(lexeme,line,"keyword");
flag=1;
break;
}
}
}
/****************************************************************
This function check the string is indentifier or not.
*****************************************************************/
void Is_Identifier_Or_Not()
{
if(flag==0) //identifier
Add_To_Lexical(lexeme,line,"identifier");
}
/*****************************************************************
This function check if the character is operator or not.
******************************************************************/
void Is_Operator_Or_Not()
{
int j;
for (j=0;j<4;j++) //The # of arithmetic_operator is 4.
if (ch==arithmetic_operator[j])
{
lexeme[0]=ch;
lexeme[1]='\0';
Add_To_Lexical(lexeme,line,"operator");
break;
}
}
/*****************************************************************
This function check if the character is special symbol or not.
******************************************************************/
void Is_Special_Or_Not()
{
int j;
for (j=0;j<5;j++) //The # of special symbol is 5.
if (ch==special[j] )
{
lexeme[0]=ch;
lexeme[1]='\0';
Add_To_Lexical(lexeme,line,"special");
break;
}
}
/*****************************************************************
This function check if the character is special symbol or not.
******************************************************************/
void Is_Comparison_Or_Not()
{
int j,flag=0;
char k=ch;
ch=fgetc(fp);
if (isalpha(ch) && k=='<') //Skip words between #include<>.
{
do
ch=fgetc(fp);
while (ch!='>');
flag=1;
}
else
if (ch=='<' && k=='<') //Skip cout <<.
flag=1;
else
if (ch=='>' && k=='>') //Skip cin >>.
flag=1;
if (!flag)
{
lexeme[0]=ch; //We read here to check if the comparision
ch=fgetc(fp); //operator is single which is only (> or < or =)
//or like ( >= or == or <= ).
if (ch=='<' || ch=='=' || ch=='>')
{
lexeme[1]=ch;
lexeme[2]='\0';
}
else
{
lexeme[1]='\0';
fseek(fp,-1,1);
}
for (j=0;j<6;j++) //The # of comparison_operator is 6.
if (strcmp(lexeme,comparison_operator[j])==0)
{
Add_To_Lexical(lexeme,line,"comparision");
break;
}
}
}
/*****************************************************************
This function check if the character is number or not.
******************************************************************/
void Read_Number()
{
int j=0;
while(isdigit(ch) || ch=='.') //search for digits
{
lexeme[j]=ch;
ch=fgetc(fp);
j++;
}
lexeme[j]='\0';
Add_To_Lexical(lexeme,line,"num");
}
/****************************************************************
Function to skip comment statements.
*****************************************************************/
void Skip_Comment()
{
if (ch=='"') //Skipping printf statements and
{ //other such display statements.
if(ch=='"')
while((ch=getc(fp))!='"');
}
else
//Skip comments.
{
ch=getc(fp);
if(ch=='/') //Checking single line comments
{
while((ch=getc(fp))!='\n');
}
else if(ch=='*') //Checking multiple line comments.
{
while(f==0)
{
ch=getc(fp);
if(ch=='*')
{
ch=getc(fp);
if(ch=='/')
f=1;
}
}
f=0;
}
}
}
