void ExpressionPrime(void)
{
switch (Symb.type) {
case PLUS:
/* E' -> + T BinOp E' */
Symb = readLexem();
Term();
Gener(BinOp, '+'); /* BinOp.dop = '+' */
ExpressionPrime();
break;
case MINUS:
/* E' -> - T BinOp E' */
Symb = readLexem();
Term();
Gener(BinOp, '-'); /* BinOp.dop = '-' */
ExpressionPrime();
break;
case RPAR:
case EOI:
/* E' -> e */
break;
default:
ExpansionError("E'", Symb.type);
}
}
Node *ExpressionPrime(Node *Dvalue)
{
switch (Symb.type) {
case PLUS:
/* E' -> + T E' */
Symb = readLexem();
return ExpressionPrime(new BinOp('+', Dvalue, Term()));
case MINUS:
/* E' -> - T E' */
Symb = readLexem();
return ExpressionPrime(new BinOp('-', Dvalue, Term()));
case RPAR: case EOI:
/* E' -> e */
return Dvalue;
default:
ExpansionError((char*) "E'", Symb.type);
}
}
bool syntaxparser::Expression(){
bool bExpression = false;
if(displayFlag){
cout << "<Expression> ::= <Term><ExpressionPrime>" << endl;
printproduction("<Expression> ::= <Term><ExpressionPrime>");
}
Term();
ExpressionPrime();
bExpression = true;
return bExpression;
}
void Expression(void) {
switch (Symb.type) {
case IDENT:
case LPAR:
printf("(1) E -> T E'\n");
Term();
ExpressionPrime();
break;
default:
ExpansionError("E", Symb.type);
}
}
void ExpressionPrime(void) {
switch (Symb.type) {
case PLUS:
printf("(2) E' -> + T E'\n");
Compare(PLUS);
Term();
ExpressionPrime();
break;
case MINUS:
printf("(2) E' -> - T E'\n");
Compare(MINUS);
Term();
ExpressionPrime();
break;
case RPAR:
case EOI:
printf("(3) E' -> e\n");
break;
default:
ExpansionError("E'", Symb.type);
}
}
/* <Expression Prime> ::= + <Term> <Expression Prime> | - <Term> <Expression Prime> | epsilon */
void SyntaxAnalyzer::ExpressionPrime()
{
if(rrr == o_plus)
{
NextRecord();
Term();
ExpressionPrime();
logger.Log("<Expression Prime> ::= + <Term> <Expression Prime>");
}
else if(rrr == o_minus)
{
NextRecord();
Term();
ExpressionPrime();
logger.Log("<Expression Prime> ::= + <Term> <Expression Prime>");
}
else// if(epsilon())
{
logger.Log(" <Expression Prime> ::= epsilon");
}
}
Node *Expression(void)
{
/* E -> T E' */
return ExpressionPrime(Term());
}
bool syntaxparser::ExpressionPrime(){
bool bExpressionPrime = false;
if (lexeme == "+"){
print();
cout<<endl;
Lexer();
if(displayFlag){
cout << "<ExpressionPrime> ::= +<Term><ExpressionPrime>" << endl;
printproduction("<ExpressionPrime> ::= +<Term><ExpressionPrime>");
}
bExpressionPrime = true;
Term();
project3.gen_inst("ADD", "-999");
string type1, type2;
type1 = project3.returnSymbolType(2);
type2 = project3.returnSymbolType(3);
if(type1 == "boolean")
error("Cannot perform '+' on boolean");
if (type2 == "boolean")
error("Cannot perform '+' on boolean");
ExpressionPrime();
}
else if (lexeme == "-"){
print();
cout<<endl;
Lexer();
if(displayFlag){
cout << "<ExpressionPrime> ::= -<Term><ExpressionPrime>" << endl;
printproduction("<ExpressionPrime> ::= -<Term><ExpressionPrime>");
}
bExpressionPrime = true;
Term();
project3.gen_inst("SUB", "-999");
string type1, type2;
type1 = project3.returnSymbolType(2);
type2 = project3.returnSymbolType(3);
if(type1 == "boolean")
error("Cannot perform '-' on boolean");
if (type2 == "boolean")
error("Cannot perform '-' on boolean");
ExpressionPrime();
}
else{
bExpressionPrime = true;
if(displayFlag){
cout << "<ExpressionPrime> ::= epsilon" << endl;
printproduction("<ExpressionPrime> ::= epsilon");
}
}
return bExpressionPrime;
}
void Expression(void)
{
/* E -> T E' */
Term();
ExpressionPrime();
}
/* <Expression> ::= <Term> <Expression Prime> */
void SyntaxAnalyzer::Expression()
{
Term();
ExpressionPrime();
logger.Log("<Expression ::= <Term><Expression Prime>");
}
