Lexical analyzer, Compare two different lines of a text file - visual-c++

Question

I have to use a lexical analyzer to compare 2 lines of a text file, if the 2 lines are identical I merge them this way:
STATE a TO a b b b OUT 0 1 1 0
STATE b TO a b b b OUT 0 1 1 0
STATE ab TO a b b b OUT 0 1 1 0
Current_State = a
Next_States = a b b b
Outputs = 0 1 1 0
I've ignored in the text file everything that comes before the state,
my code is as follows :
#pragma warning(disable:4786)
#include <string>
#include <map>
#include <vector>
#include <iostream>
#include <stdio.h>
using namespace std;
#define Getc(s) getc(s)
#define Ungetc(c) {ungetc(c,IP_Input); ugetflag=1;}
typedef vector<string> list; // Um Eingänge ausgänge zu speichern
list next_states;
list Outputs;
int tok = 0;
/*
* Lexical analyzer states.
*/
enum parcases { // Case that can occur C_.....
c_SkipBegin, // When State is found go to DEFCURRENTSTATE
c_DEFCURRENTSTATE, // DEFCURRENTSTATE occurs scan the states
c_DEFNEXTSTATES, // DEFNEXTSTATES occurs scan the next states
c_DEFOUT, //DEFOUT occurs scan the outputs
c_FINISHED
};
enum lexstate {
L_START, L_INT, L_IDENT, L_STRING, L_STRING2,
L_COMMENT, L_TEXT_COMMENT, L_LINE_COMMENT, L_END_TEXT_COMMENT
};
const int STRING1 = 3;
const int IDENTIFIER = 4;
const int INTEGER1 = 5;
const int TOKENSTART = 300;
class CParser
{
public:
string yytext; //input buffer
struct tyylval { //value return structure
string s; //string
int i; //integer
}yylval;
FILE* IP_Input; //Input File
FILE* IP_Error; //Error Output
FILE* IP_List; //List Output
int IP_LineNumber; //Line counter
int ugetflag; //checks ungets
int prflag; //controls printing
map<string, int> IP_Token_table; //Tokendefinitions
map<int, string> IP_revToken_table; //reverse Tokendefinitions
string current_states; // Vector um scanned_states zu speichern
list first_lines;
list next_states; // Vector um scanned_inputs zu speichern
list Outputs; // Vector um scanned_outputs zu speichern
int yylex(); //lexical analyser
void yyerror(char* ers); //error reporter
int IP_MatchToken(string& tok); //checks the token
void InitParse(FILE* inp, FILE* err, FILE* lst); //Sets the File pointers
int yyparse(); //parser
list fusion_lines(list& list_one, list& list_two);
bool compare(list& list_one, list& list_two);
void pr_tokentable(); //test output for tokens
void IP_init_token_table(); //loads the tokens
void Load_tokenentry(string str, int index); //load one token
void PushString(char c); //Used for dtring assembly
parcases SkipTillBegin(int tok, list& first_lines);// Skip till begin is found
parcases ScanTheCurrentState(int tok, string& current_states); // Scan the STATE
parcases ScanTheNextStates(int tok, list& next_states); // Scan the TO STATE
parcases ScanTheOutputs(int tok, list& Outputs); // Scan the Outputs
CParser() { IP_LineNumber = 1; ugetflag = 0; prflag = 0; }; //Constructor
};
//------------------------------------------------------------------------
// Adds a character to the string value
void CParser::PushString(char c)
{
yylval.s += c;
}
//------------------------------------------------------------------------
void CParser::Load_tokenentry(string str, int index)
{
IP_Token_table[str] = index;
IP_revToken_table[index] = str;
}
void CParser::IP_init_token_table()
{
Load_tokenentry("STRING1", 3);
Load_tokenentry("IDENTIFIER", 4);
Load_tokenentry("INTEGER1", 5);
int ii = TOKENSTART;
Load_tokenentry("AND", ii++);
Load_tokenentry("OR", ii++);
Load_tokenentry("Begin", ii++);
Load_tokenentry("End", ii++);
}
//------------------------------------------------------------------------
void CParser::pr_tokentable()
{
typedef map<string, int>::const_iterator CI;
const char* buf;
printf("Symbol Table ---------------------------------------------\n");
for (CI p = IP_Token_table.begin(); p != IP_Token_table.end(); ++p) {
buf = p->first.c_str();
printf(" key:%s val:%d\n ", buf, p->second);
}
}
int CParser::yyparse()
{
string Current_state;
list given_first_lines;
list given_Next_states;
list given_outputs;
// Define the first state first we read the file till begin Occur what is befor "State" is ignored.
parcases Case = c_SkipBegin;
printf(" %s ", first_lines, "/ln");
while ((tok = yylex()) != IP_Token_table["End"])
{
if (Case == c_SkipBegin)
{
Case = SkipTillBegin(tok, first_lines);
}
else if (Case == c_DEFCURRENTSTATE)
{
}
}
return 0;
}
//------------------------------------------------------------------------
parcases CParser::SkipTillBegin(int tok, list& first_lines)
{
parcases retval;
if (tok != IP_Token_table["STATE"])
{
first_lines.push_back(string(yylval.s)); // the 2 IN lines
retval = c_SkipBegin;
}
else {
retval = c_DEFCURRENTSTATE;
}
return retval;
}
parcases CParser::ScanTheCurrentState(int tok, string& current_state)
{
parcases retval = c_DEFCURRENTSTATE;
if (tok == IDENTIFIER) //IDENTIFIER = a
{
current_state = string(yylval.s); // a,b,c
retval = c_DEFCURRENTSTATE;
}
else if (tok == 'TO') { // State is done
retval = c_DEFNEXTSTATES;
}
return retval;
}
parcases CParser::ScanTheNextStates(int tok, list& next_states)
{
parcases retval = c_DEFNEXTSTATES;
if (tok == IDENTIFIER) //IDENTIFIER = a
{
next_states.push_back(string(yylval.s)); //a, b,x
retval = c_DEFNEXTSTATES;
}
else if (tok == 'OUT') { // States are done
retval = c_DEFOUT;
}
return retval;
}
parcases CParser::ScanTheOutputs(int tok, list& Outputs)
{
parcases retval = c_DEFOUT;
if ((tok == INTEGER1) || (tok == IDENTIFIER)) //IDENTIFIER = 1,0,x
{
Outputs.push_back(string(yylval.s)); //1,0,x
retval = c_DEFOUT;
}
else if (tok == '\n') { // Outputs are done
retval = c_FINISHED;
}
return retval;
}
bool CParser::compare(list& list_one, list& list_two)
{
bool match = false;
if (list_one == list_two)
{
match = true;
//list_two = 0;
}
return match;
}
list CParser::fusion_lines(list& list_one, list& list_two)
{
}
//------------------------------------------------------------------------
/*
* Parse File:
*
*/
void CParser::InitParse(FILE* inp, FILE* err, FILE* lst)
{
/*
* Set up the file state to something useful.
*/
IP_Input = inp;
IP_Error = err;
IP_List = lst;
IP_LineNumber = 1;
ugetflag = 0;
/*
* Define both the enabled token and keyword strings.
*/
IP_init_token_table();
}
//------------------------------------------------------------------------
int CParser::IP_MatchToken(string& tok)
{
int retval;
if (IP_Token_table.find(tok) != IP_Token_table.end()) {
retval = (IP_Token_table[tok]);
}
else {
retval = (0);
}
return retval;
}
//------------------------------------------------------------------------
/*
* yylex:
*
*/
int CParser::yylex()
{
//Locals
int c;
lexstate s;
/*
* Keep on sucking up characters until we find something which
* explicitly forces us out of this function.
*/
for (s = L_START, yytext = ""; 1;) {
c = Getc(IP_Input);
yytext = yytext + (char)c;
if (!ugetflag) {
if (c != EOF)if (prflag)fprintf(IP_List, "%c", c);
}
else ugetflag = 0;
switch (s) {
//Starting state, look for something resembling a token.
case L_START:
if (isdigit(c)) {
s = L_INT;
}
else if (isalpha(c) || c == '\\') {
s = L_IDENT;
}
else if (isspace(c)) {
if (c == '\n') {
IP_LineNumber += 1;
if (prflag)
fprintf(IP_List, "%5d ", (int)IP_LineNumber);
}
yytext = "";
}
else if (c == '/') {
yytext = "";
s = L_COMMENT;
}
else if (c == '"') {
s = L_STRING;
}
else if (c == EOF) {
return ('\0');
}
else {
return (c);
}
break;
case L_COMMENT:
if (c == '/')
s = L_LINE_COMMENT;
else if (c == '*')
s = L_TEXT_COMMENT;
else {
Ungetc(c);
return('/'); /* its the division operator not a comment */
}
break;
case L_LINE_COMMENT:
if (c == '\n') {
s = L_START;
Ungetc(c);
}
yytext = "";
break;
case L_TEXT_COMMENT:
if (c == '\n') {
IP_LineNumber += 1;
}
else if (c == '*')
s = L_END_TEXT_COMMENT;
yytext = "";
break;
case L_END_TEXT_COMMENT:
if (c == '/') {
s = L_START;
}
else {
s = L_TEXT_COMMENT;
}
yytext = "";
break;
/*
* Suck up the integer digits.
*/
case L_INT:
if (isdigit(c)) {
break;
}
else {
Ungetc(c);
yylval.s = yytext.substr(0, yytext.size() - 1);
yylval.i = atoi(yylval.s.c_str());
return (INTEGER1);
}
break;
/*
* Grab an identifier, see if the current context enables
* it with a specific token value.
*/
case L_IDENT:
if (isalpha(c) || isdigit(c) || c == '_')
break;
Ungetc(c);
yytext = yytext.substr(0, yytext.size() - 1);
yylval.s = yytext;
if (c = IP_MatchToken(yytext)) {
return (c);
}
else {
return (IDENTIFIER);
}
/*
* Suck up string characters but once resolved they should
* be deposited in the string bucket because they can be
* arbitrarily long.
*/
case L_STRING2:
s = L_STRING;
if (c == '"') {
PushString((char)c);
}
else {
if (c == '\\') {
PushString((char)c);
}
else {
PushString((char)'\\');
PushString((char)c);
}
}
break;
case L_STRING:
if (c == '\n')
IP_LineNumber += 1;
else if (c == '\r')
;
else if (c == '"' || c == EOF) {
return (STRING1);
}
else if (c == '\\') {
s = L_STRING2;
}
else
PushString((char)c);
break;
default: printf("***Fatal Error*** Wrong case label in yylex\n");
}
}
}
//------------------------------------------------------------------------
int main(int argc, char* argv[])
{
FILE* inf;
CParser obj;
//char fistr[100];
string fistr;
printf("Enter filename:\n");
//gets(fistr);
cin >> fistr;
inf = fopen(fistr.c_str(), "r");
if (inf == NULL) {
printf("Cannot open input file %s\n", fistr);
return 0;
}
CParser obj;
obj.InitParse(inf, stderr, stdout);
// obj.pr_tokentable();
obj.yyparse();
return 0;
//system("pause");
}
I wrote this classes to put the current state, the next states and the output in a vector
parcases CParser::SkipTillBegin(int tok, list& first_lines)
parcases CParser::ScanTheCurrentState(int tok, string& current_state)
parcases CParser::ScanTheNextStates(int tok, list& next_states)
parcases CParser::ScanTheOutputs(int tok, list& Outputs)
this class is the lexical analyzer it differentiates the integers of identifiers and strings
int CParser::yylex()
The other classes aren't really important to understand.
I wrote this class to compare
bool CParser::compare(list& list_one, list& list_two)
{
bool match = false;
if (list_one == list_two)
{
match = true;
//list_two = 0;
}
return match;
}
and I started this one to merge two lines together
list CParser::fusion_lines(list& list_one, list& list_two) but i am stuck here and on the output class int CParser::yyparse()
I couldn't find a way to do it correctly and to compare two different lines of the text file with the lexical analyzer.