/**
相等类表达式
<equality_expression>::=<relational_expression>{
<TK_EQ><relational_expression>
|<TK_NEQ><relational_expression>}
*/
void equality_expression(){
relational_expression();
while(TK_EQ == token || TK_NEQ == token){
get_token();
relational_expression();
}
}
struct Symbol* equality_expression(struct EqualityExpression* node)
{
if (node->type == 0)
return relational_expression(node->relationalExpression);
struct Symbol* symbol1 = load_symbol(equality_expression(node->equalityExpression));
struct Symbol* symbol2 = load_symbol(relational_expression(node->relationalExpression));
return equality_symbol(symbol1, symbol2, node->type, 0);
}
int equality_expression(void) {
if( relational_expression() ) {
} else if( equality_expression() ) {
switch( lookaheadT.type ) {
case EQ_OP:
match(EQ_OP);
break;
case NE_OP:
match(NE_OP);
break;
}
relational_expression();
} else {
abort();
}
}
int PP_Expression::relational_expression()
{
int value = shift_expression();
switch (next()) {
case PP_LANGLE:
return value < relational_expression();
case PP_RANGLE:
return value > relational_expression();
case PP_LE:
return value <= relational_expression();
case PP_GE:
return value >= relational_expression();
default:
prev();
return value;
}
}
// Parse an equality expression.
//
// equality-expression:
// relational-expression:
// equality-expression '==' relational-expression
// equality-expression '!=' relational-expression
Expr&
Parser::equality_expression()
{
Expr* e1 = &relational_expression();
while (true) {
if (Token tok = match_if(tk::eq_eq_tok)) {
Expr& e2 = relational_expression();
e1 = &on_eq_expression(tok, *e1, e2);
} else if (Token tok = match_if(tk::bang_eq_tok)) {
Expr& e2 = relational_expression();
e1 = &on_ne_expression(tok, *e1, e2);
} else {
break;
}
}
return *e1;
}
Expression *ExpressionBuilder::relational_expression()
{
Expression *value = shift_expression();
switch (next()) {
case '<':
return createBinaryExpression('<', value, relational_expression());
case '>':
return createBinaryExpression('>', value, relational_expression());
case Token_leq:
return createBinaryExpression(Expression::LtEqOp, value, relational_expression());
case Token_geq:
return createBinaryExpression(Expression::GtEqOp, value, relational_expression());
default:
prev();
return value;
}
}
struct Symbol* relational_expression(struct RelationalExpression* node)
{
if (node->type == 0)
return shift_expression(node->shiftExpression);
struct Symbol* symbol1 = load_symbol(relational_expression(node->relationalExpression));
struct Symbol* symbol2 = load_symbol(shift_expression(node->shiftExpression));
test_relation(&symbol1, &symbol2);
struct Symbol* symbol3;
if (node->type == 1)
symbol3 = test_calculable2(&symbol1, &symbol2, '<');
else
symbol3 = test_calculable2(&symbol1, &symbol2, '>');
if (symbol3)
return symbol3;
symbol3 = new_symbol("", 0, 2, 1, 0, 0, 0);
char c = 's';
if ((symbol1->specifier & (1 << 9)) > 0 || symbol1->stars)
c = 'u';
ADDSTRING(" ");
code_gen_symbol('%', symbol3);
if (symbol2->stars == 0 && (symbol2->specifier & (3 << 6)) != 0)
{
ADDSTRING(" = fcmp ");
if (node->type == 1 || node->type == 3)
{
ADDSTRING("olt ");
}
else
{
ADDSTRING("ogt ");
}
}
else
{
ADDSTRING(" = icmp ");
*g_ptr++ = c;
if (node->type == 1 || node->type == 3)
{
ADDSTRING("lt ");
}
else
{
ADDSTRING("gt ");
}
}
code_gen_type_specifier(symbol1->specifier,0, symbol1->length, symbol1->stars);
ADDSTRING(" ");
code_gen_symbol('%', symbol1);
ADDSTRING(", ");
code_gen_symbol('%', symbol2);
ADDSTRING("\n");
return symbol3;
}
int PP_Expression::equality_expression()
{
int value = relational_expression();
switch (next()) {
case PP_EQEQ:
return value == equality_expression();
case PP_NE:
return value != equality_expression();
default:
prev();
return value;
}
}
static sl_node_base_t*
logical_expression(sl_parse_state_t* ps)
{
sl_node_base_t* left = relational_expression(ps);
sl_node_base_t* right;
while(1) {
switch(peek_token(ps)->type) {
case SL_TOK_OR:
next_token(ps);
right = relational_expression(ps);
left = sl_make_binary_node(ps, left, right, SL_NODE_OR);
break;
case SL_TOK_AND:
next_token(ps);
right = relational_expression(ps);
left = sl_make_binary_node(ps, left, right, SL_NODE_AND);
break;
default:
return left;
}
}
}
Expression *ExpressionBuilder::equality_expression()
{
Expression *value = relational_expression();
switch (next()) {
case Token_eq:
return createBinaryExpression(Expression::EqOp, value, equality_expression());
case Token_not_eq:
return createBinaryExpression(Expression::NotEqOp, value, equality_expression());
default:
prev();
return value;
}
}
/* FIRST(logical AND expression’)={.AMD., e}
<logical AND expression’> ->
.AND. <relational expression> <logical AND expression’> | e
Author: Kwok Hong Kelvin Chan */
void logical_AND_expression_p(void){
switch(lookahead_token.code){
case LOG_OP_T:
switch (lookahead_token.attribute.log_op){
case AND:
match(LOG_OP_T, AND);
relational_expression();
logical_AND_expression_p();
gen_incode("Logical AND expression parsed");
break;
}
}
}
static struct block *equality_expression(struct block *block)
{
struct var value;
block = relational_expression(block);
while (1) {
value = block->expr;
if (peek().token == EQ) {
consume(EQ);
block = relational_expression(block);
block->expr = eval_expr(block, IR_OP_EQ, value, block->expr);
} else if (peek().token == NEQ) {
consume(NEQ);
block = relational_expression(block);
block->expr =
eval_expr(block, IR_OP_EQ, var_int(0),
eval_expr(block, IR_OP_EQ, value, block->expr));
} else break;
}
return block;
}
/*
* Production: Logical AND Expression (P)
* FIRST set: { ., e }
*/
void logical_and_expression_p(void) {
switch (lookahead.code) {
case LOG_OP_T:
/* The token attribute must be AND. */
if (lookahead.attribute.log_op == AND) {
match(LOG_OP_T, AND);
relational_expression();
logical_and_expression_p();
gen_incode("PLATY: Logical AND expression parsed");
return;
}
return;
default:
return;
}
}
int relational_expression(void) {
if( shift_expression() ) {
} else if( relational_expression() ) {
switch( lookaheadT.type ) {
case LTHAN:
match(LTHAN);
break;
case GTHAN:
match(GTHAN);
break;
case LE_OP:
match(LE_OP);
break;
case GE_OP:
match(GE_OP);
break;
}
shift_expression();
} else {
abort();
}
}
/*
* Production: Logical AND Expression
* FIRST set: { AVID_T, FPL_T, INL_T, SVID_T, STR_T }
*/
void logical_and_expression(void) {
relational_expression();
logical_and_expression_p();
}
