struct Symbol* shift_expression(struct ShiftExpression* node)
{
if (node->type == 0)
return additive_expression(node->additiveExpression);
struct Symbol* symbol1 = load_symbol(shift_expression(node->shiftExpression));
struct Symbol* symbol2 = load_symbol(additive_expression(node->additiveExpression));
return shift_symbol(symbol1, symbol2, node->type);
}
/**
关系表达式
<relational_expression>::=<additive_expression>{
<TK_LF><additive_expression>
|<TK_GT><additive_expression>
|<TK_LEQ><additive_expression>
|<TK_GEQ><additive_expression>
}
*/
void relational_expression(){
additive_expression();
while((TK_LT == token || TK_LEQ == token) ||
TK_GT == token || TK_GEQ == token){
get_token();
additive_expression();
}
}
int PP_Expression::additive_expression()
{
int value = multiplicative_expression();
switch (next()) {
case PP_PLUS:
return value + additive_expression();
case PP_MINUS:
return value - additive_expression();
default:
prev();
return value;
}
}
Expression *ExpressionBuilder::additive_expression()
{
Expression *value = multiplicative_expression();
switch (next()) {
case '+':
return createBinaryExpression('+', value, additive_expression());
case '-':
return createBinaryExpression('-', value, additive_expression());
default:
prev();
return value;
}
}
int shift_expression(void) {
if( additive_expression() ) {
} else if( shift_expression() ) {
switch( lookaheadT.type ) {
case LEFT_OP:
match(LEFT_OP);
break;
case RIGHT_OP:
match(RIGHT_OP);
break;
}
additive_expression();
} else {
abort();
}
}
// Parse a shift expression.
//
// shift-expression:
// additive_expression:
// shift-expression '<<' additive_expression
// shift-expression '>>' additive_expression
//
Expr&
Parser::shift_expression()
{
Expr* e1 = &additive_expression();
while (true) {
if (Token tok = match_if(tk::lt_lt_tok)) {
Expr& e2 = additive_expression();
e1 = &on_lsh_expression(tok, *e1, e2);
} else if (Token tok = match_if(tk::gt_gt_tok)) {
Expr& e2 = additive_expression();
e1 = &on_rsh_expression(tok, *e1, e2);
} else {
break;
}
}
return *e1;
}
struct Symbol* additive_expression(struct AdditiveExpression* node)
{
if (node->type == 0)
return multiplicative_expression(node->multiplicativeExpression);
struct Symbol* symbol1 = load_symbol(additive_expression(node->additiveExpression));
struct Symbol* symbol2 = load_symbol(multiplicative_expression(node->multiplicativeExpression));
return additive_symbol(symbol1, symbol2, node->type);
}
/* EBNF: simple-expression ->
* addtivite-expression [relop additivie-expression] */
static TreeNode * simple_expression (void)
{ TreeNode * t = additive_expression();
TreeNode * newNode;
while (token == COMMENT) unexpectedTokenHandling();
/* [relop additive-expression] */
if (isRelop(token))
{ newNode = newExpNode (OpK);
if (newNode != NULL)
{ newNode->child[0] = t;
newNode->attr.op = token;
t = newNode;
}
match (token); // match relop
if (t != NULL)
t->child[1] = additive_expression();
}
return t;
}
static struct block *shift_expression(struct block *block)
{
struct var value;
block = additive_expression(block);
while (1) {
value = block->expr;
if (peek().token == LSHIFT) {
consume(LSHIFT);
block = additive_expression(block);
block->expr = eval_expr(block, IR_OP_SHL, value, block->expr);
} else if (peek().token == RSHIFT) {
consume(RSHIFT);
block = additive_expression(block);
block->expr = eval_expr(block, IR_OP_SHR, value, block->expr);
} else break;
}
return block;
}
int PP_Expression::shift_expression()
{
int value = additive_expression();
switch (next()) {
case PP_LTLT:
return value << shift_expression();
case PP_GTGT:
return value >> shift_expression();
default:
prev();
return value;
}
}
Expression *ExpressionBuilder::shift_expression()
{
Expression *value = additive_expression();
switch (next()) {
case Token_left_shift:
return createBinaryExpression(Expression::LShiftOp, value, shift_expression());
case Token_right_shift:
return createBinaryExpression(Expression::RShiftOp, value, shift_expression());
default:
prev();
return value;
}
}
int additive_expression(void) {
if( multiplicative_expression() ) {
} else if( additive_expression() ) {
switch( lookaheadT.type ) {
case PLUS:
match(PLUS);
break;
case MINUS:
match(MINUS);
break;
}
multiplicative_expression();
} else {
abort();
}
}
/* expression -> var "=" expression | simple-expression
* var -> ID ["["expression"]"]*/
static TreeNode * expression (void)
{ TreeNode * t = newExpNode(IdK);
TreeNode * p = NULL;
TreeNode * newNode = NULL;
#define CALL 1
#define ARRAY 2
int factorType = 0;
while (token == COMMENT) unexpectedTokenHandling();
if (token == ID)
{
if (t != NULL)
t->attr.name = copyString(tokenString);
match (ID);
/* var -> ID "["expression"]" */
if (token == SLPAREN)
{ factorType = ARRAY;
match (SLPAREN);
t->child[0] = expression();
match (SRPAREN);
/* ID "["expression"]" "=" expression */
if (token == ASSIGN)
{ match (ASSIGN);
newNode = newStmtNode(AssignK);
if (t != NULL)
{ newNode->child[0] = t;
t= newNode;
t->child[1] = expression();
if (token != SEMI)
unexpectedTokenHandling();
}
}
}
/* simple-expression => call => ID "("args")" */
else if (token == LPAREN)
{ factorType = CALL;
match (LPAREN);
if (t != NULL)
{ t->nodekind = ExpK;
t->kind.exp = CallK;
t->child[0] = args();
}
match (RPAREN);
}
/* var | call is followed by assignment, operation,
* semi-colon or comma. */
while (token == COMMENT) unexpectedTokenHandling();
if (token == ASSIGN)
{ if ((factorType == CALL) || (factorType == ARRAY))
unexpectedTokenHandling();
/* ID "=" expression */
else
{ match (ASSIGN);
newNode = newStmtNode(AssignK);
if (t != NULL)
{ newNode->child[0] = t;
t= newNode;
t->child[1] = expression();
if (token != SEMI)
unexpectedTokenHandling();
}
}
}
/* ID [("("args")"|"["expression"]")]
* op additivie-expression */
else if (isOp (token))
{ newNode = newExpNode (OpK);
if (newNode != NULL)
{ newNode->child[0] = t;
newNode->attr.op = token;
t = newNode;
}
match (token);
if (t != NULL)
t->child[1] = additive_expression();
}
else if ((token != SEMI) && (token != COMMA) && (token != RPAREN))
unexpectedTokenHandling();
}
else if ((token == LPAREN) || (token == NUM))
t = simple_expression();
else
unexpectedTokenHandling();
return t;
}
static void expression()
{
int op_token;
int first_label = -1;
int second_label = -1;
additive_expression();
if(!(token==TOK_LE||token==TOK_LT
||token==TOK_GT||token==TOK_GE
||token==TOK_EQ||token==TOK_NE))
{
return ;
}
while(token==TOK_LE||token==TOK_LT||
token==TOK_GT||token==TOK_GE||
token==TOK_EQ||token==TOK_NE)
{
op_token = token;
match(token);
additive_expression();
//gen_code("sbi\n");
//gen_code("exc\n");
//gen_code("cmp\n");
first_label = get_label();
switch(op_token)
{
case TOK_LE: // <=
gen_code("leq L%d\n", first_label);
break;
case TOK_LT: // <
gen_code("les L%d\n", first_label);
break;
case TOK_GT: // >
gen_code("grt L%d\n", first_label);
break;
case TOK_GE: // >=
gen_code("geq L%d\n", first_label);
break;
case TOK_EQ: // ==
gen_code("equ L%d\n", first_label);
break;
case TOK_NE: // !=
gen_code("neq L%d\n", first_label);
break;
}
second_label = get_label();
gen_code("ldc %d\n", false);
gen_code("ujp L%d\n", second_label);
gen_code("lab %d:\n", first_label);
gen_code("ldc %d\n", true);
gen_code("lab %d:\n", second_label);
}
}
