string Parser::RelationExpression() {
_message.print(DBUG, "PARSER: In RelationExpression()\n");
// SimpleExpression,
// [ ( “<=” | “<” | “>=” | “>” | “==” | “!=” ),
// SimpleExpression ]
static tokenType firstSet[] = {SYM_PLUS, SYM_MINUS, SYM_NOT, SYM_OPEN, LIT_INT, LIT_FLOAT, LIT_STR, TOK_IDENT, (tokenType) - 1};
static tokenType followSet[] = {SYM_AND, SYM_OR, SYM_ASSIGN, SYM_SEMICOLON, SYM_OPEN, SYM_SQ_OPEN, SYM_COMMA, SYM_CLOSE, (tokenType) - 1};
static tokenType set[] = {SYM_LESS_EQ, SYM_LESS, SYM_GREATER_EQ, SYM_GREATER, SYM_EQUAL, SYM_NOT_EQ, (tokenType) -1};
string type, type1;
if ( synchronized(firstSet, followSet, "Expected Relational Expression") ) {
type = SimpleExpression();
if ( memberOf(_lookAhead.getTokenType(), set) ) {
//check to make sure both types of simpleexpression are numeric
type = "i";
if ( _lookAhead.getTokenType() == SYM_LESS_EQ ) {
match(SYM_LESS_EQ);
} else if( _lookAhead.getTokenType() == SYM_LESS) {
match(SYM_LESS);
} else if( _lookAhead.getTokenType() == SYM_GREATER_EQ ) {
match(SYM_GREATER_EQ);
} else if( _lookAhead.getTokenType() == SYM_GREATER ) {
match(SYM_GREATER);
} else if( _lookAhead.getTokenType() == SYM_EQUAL ) {
match(SYM_EQUAL);
} else if( _lookAhead.getTokenType() == SYM_NOT_EQ ) {
match(SYM_NOT_EQ);
}
type1 = SimpleExpression();
if(!((type == "f" && type1 == "i") ||
(type == "i" && type1 == "i") ||
(type == "f" && type1 == "f") ||
(type == "i" && type1 == "f"))) {
_message.print(ERROR, "SEMANTIC-ANALYZER: Semantic issue on line: %i col: %i. Incompatible comparision", _lookAhead.getRow() , _lookAhead.getCol());
}
}
}
_message.print(DBUG, "PARSER: End of RelationExpression()\n");
return type;
}
/*----------------------------------------------------------
* AndExpression
* Evaluate an AND expression
*----------------------------------------------------------*/
static int AndExpression(s_token *token_p, bool skip)
{
int match;
match = SimpleExpression(token_p, skip);
while (token_p->tt == T_AND) {
NextToken(token_p, skip); /* Negative logic 0=true, or is and */
if (match!=0) {
SimpleExpression(token_p, true); /* skip other for false */
} else {
match = SimpleExpression(token_p, skip);
}
}
return match;
}
SimpleExpression Parser::simple_expression(){
std::string field = id();
enum Operator oper = op();
std::string value = id_list();
if (field == "" || oper == OP_BAD_OPERATOR || value == ""){
std::cout << lexer->getLinenumber() << ": Error: Broken expression '" << field << "' '" << oper << "' '" << value <<"'\n";
exit(1);
}
return SimpleExpression(field, oper, value);
}
/*----------------------------------------------------------
* SimpleExpression
* Evalute a simple expression
* this can be a "expression"
* 1) we can match with fnmatch()
* 2) !expression
* 3) (exp)
*----------------------------------------------------------*/
static int SimpleExpression(s_token *token_p, bool skip)
{
int match;
if (token_p->tt==T_ERROR) {
match = -1;
} else if (token_p->tt == T_BRACEOPEN) {
match = OrExpression(token_p, skip);
if (token_p->tt != T_BRACECLOSE) {
match = Error(token_p, T_BRACECLOSE); /*Indicate what I need? */
return match;
}
NextToken(token_p, skip);
} else if (token_p->tt == T_EXP) {
match=MatchPattern(token_p, skip);
NextToken(token_p, skip);
} else if (token_p->tt == T_NOT) {
NextToken(token_p, skip);
match = SimpleExpression(token_p, skip);
match = !match;
} else {
match = Error(token_p, token_p->et);
}
return match;
}
