PTqlItem TTqlExp::ParseExp(TTqlLx& Lx, const TFSet& Expect){
PTqlItem Item=ParseTerm(Lx, TFSet(Expect)|tsyOr);
while (Lx.Sym==tsyOr){
Lx.GetSym(TermExpect);
PTqlItem RItem=ParseTerm(Lx, TFSet(Expect)|tsyOr);
Item=PTqlItem(new TTqlItem(titOr, Item, RItem));
}
return Item;
}
PWixExpItem TWixExp::ParseExp(TWixExpLx& Lx, const TFSet& Expect){
PWixExpItem ExpItem=ParseTerm(Lx, TFSet(Expect)|wesyOr);
while (Lx.Sym==wesyOr){
Lx.GetSym(TermExpect);
PWixExpItem RExpItem=ParseTerm(Lx, TFSet(Expect)|wesyOr);
ExpItem=PWixExpItem(new TWixExpItem(weitOr, ExpItem, RExpItem));
}
return ExpItem;
}
PRIVATE void ParseCompoundTerm( void )
{
int op;
ParseTerm();
while ((op = CurrentToken.code) == MULTIPLY || op == DIVIDE ) {
Accept( op );
ParseTerm();
if ( op == MULTIPLY ) _Emit( I_MULT ); else _Emit( I_DIV );
}
}
Expresion* Sintactico::_ParseSimpleExpression(Expresion* her)
{
//Utilizamos Primeros(additive-operator)
if ( proximo_token.GetTipo() == op_suma || proximo_token.GetTipo() == op_resta || proximo_token.GetTipo() == kw_or )
{
tipo_token tipo_adicion = ParseAdditiveOperator();
Expresion* expr = ParseTerm();
Expresion* sin;
switch ( tipo_adicion )
{
case op_suma:
sin = new Suma(her,expr);
break;
case op_resta:
sin = new Resta(her,expr);
break;
case kw_or:
sin = new OrBinario(her,expr);
break;
default:
break;
}
return _ParseSimpleExpression(sin);
}
return her;
}
StringParseResult ParseStringExpression(const char *expr, int start, int end)
{
StringParseResult lhs = ParseTerm(expr, start, end);
if (lhs.result)
{
StringParseResult rhs = ParseStringExpression(expr, lhs.position, end);
if (rhs.result)
{
StringExpression *ret = xcalloc(1, sizeof(StringExpression));
ret->op = CONCAT;
ret->val.concat.lhs = lhs.result;
ret->val.concat.rhs = rhs.result;
return (StringParseResult) {ret, rhs.position};
}
else
{
return lhs;
}
}
else
{
return lhs;
}
}
TBool CSL_ExprBase::ParseTerms(const string& aData, size_t& aPos, vector<string>& aRes)
{
TBool res = ETrue;
while (aPos != string::npos && res && (aData[aPos] != ')')) {
res = ParseTerm(aData, aPos, aRes);
}
return res;
}
ParsingResult Parser::ParseExpr(ArithmExpr& expr, TokIterator& it) {
expr.SetLineNumber(current_line_);
ArithmExpr term;
ParsingResult term_res = ParseTerm(term, it);
if(term_res != CORRECT) {
return term_res;
}
expr.AddElem(PtrVisitable(new ArithmExpr(term)));
return ParseExprLoop(expr, it) ? CORRECT : INCORRECT;
}
static NodeRef ParseExpr( char **spec, int *status )
{
NodeRef node = NIL;
LegalToken optok;
node = ParseTerm( spec, status );
while ( ((curtok == TOK_PLUS) || (curtok==TOK_MINUS)) && _ok(status) )
{
optok = curtok;
NextToken( spec, status );
node = NewNode( optok, 0, node,
ParseTerm( spec, status),
status );
}
return node;
}
NodeExpression* Parser::ParseExpression()
{
NodeExpression* r = ParseTerm();
while(t.GetValue() == "+" || t.GetValue() == "-" || t.GetValue() == "or")
{
Token _t = t;
string op = t.GetValue();
t = sc.GetNextToken();
NodeExpression* rr = ParseTerm();
if (_t.GetValue() == "or")
{
if (!r->GetType()->IsInt() || !rr->GetType()->IsInt())
throw Error("type mismatch", _t);
}
else
CheckTypes(r, rr, false);
r = new NodeBinaryOp(new Symbol(op), r, rr);
r->SetType(rr->GetType());
}
return r;
}
void test_compiles()
{
QueryTestHelper(
ParseTerm("p", ParseTerm("h", ParseTerm("X"), ParseTerm("Y")), ParseTerm("f", ParseTerm("Z"))),
"set_variable\t\tx3\n"
"set_value\t\tx5\n");
}
const char* RegExp::ParseExpression(StrPP& expr)
{
StrPP term;
expr = "";
if(ParseTerm(term) == "") // get the first term
return(NULL);
while(reExpression == OR) // parse all subsequent terms
{
expr += OR;
expr += term;
expr += END_TERM;
reExpression++;
if(ParseTerm(term) == "")
return (NULL);
}
expr += term;
expr += END_TERM;
return expr;
}
AST* ParseTerm(ParserState* parser) {
AST* valueNode = ParseValue(parser);
if(parser->currentToken.type == TOKEN_STAR) {
Match(parser, TOKEN_STAR);
AST* exprNode = CreateASTNode(SEM_MULTIPLICATION, VALUE_EMPTY);
AddASTChild(exprNode, valueNode);
AddASTChild(exprNode, ParseTerm(parser));
return exprNode;
} else if(parser->currentToken.type == TOKEN_SLASH) {
Match(parser, TOKEN_SLASH);
AST* exprNode = CreateASTNode(SEM_DIVISION, VALUE_EMPTY);
AddASTChild(exprNode, valueNode);
AddASTChild(exprNode, ParseTerm(parser));
return exprNode;
} else {
return valueNode;
}
}
bool Parser::ParseExprLoop(ArithmExpr& expr, TokIterator& it) {
if(it->type_ != PLUS_OP &&
it->type_ != MINUS_OP)
{
return true;
}
expr.AddOperation(it->value_);
ArithmExpr term;
ParsingResult term_res = ParseTerm(term, ++it);
if(term_res != CORRECT) {
return false;
}
expr.AddElem(PtrVisitable(new ArithmExpr(term)));
return ParseExprLoop(expr, it);
}
TermList*
Parser::ParseTermList(int for_struct)
{
TermList* tlist = new(__FILE__, __LINE__) TermList;
Term* term = ParseTerm();
while (term) {
if (for_struct && !term->isDef()) {
return (TermList*) error("(Parse) non-definition term in struct");
}
else if (!for_struct && term->isDef()) {
return (TermList*) error("(Parse) illegal definition in array");
}
tlist->append(term);
Token t = lexer->Get();
/*** OLD WAY: COMMA SEPARATORS REQUIRED ***
if (t.type() != Token::Comma) {
lexer->PutBack();
term = 0;
}
else
term = ParseTerm();
/*******************************************/
// NEW WAY: COMMA SEPARATORS OPTIONAL:
if (t.type() != Token::Comma) {
lexer->PutBack();
}
term = ParseTerm();
}
return tlist;
}
Term*
Parser::ParseTermRest(Term* base)
{
Token t = lexer->Get();
switch (t.type()) {
default:
lexer->PutBack();
return base;
case Token::StringLiteral: {
// concatenate adjacent string literal tokens:
TermText* text = base->isText();
if (text) {
TermText* base2 = new(__FILE__, __LINE__) TermText(text->value() + t.symbol()(1, t.symbol().length()-2));
delete base;
return ParseTermRest(base2);
}
else {
lexer->PutBack();
}
}
break;
case Token::Keyword:
switch (t.key()) {
case KEY_DEF:
if (base->isText())
return new(__FILE__, __LINE__) TermDef(base->isText(), ParseTerm());
else
return error("(Parse) illegal lhs in def", t);
default:
lexer->PutBack();
return base;
}
break;
}
return base;
}
AST* ParseArithmeticalExpression(ParserState* parser) {
AST* termNode = ParseTerm(parser);
if(parser->currentToken.type == TOKEN_PLUS) {
Match(parser, TOKEN_PLUS);
AST* exprNode = CreateASTNode(SEM_ADDITION, VALUE_EMPTY);
AddASTChild(exprNode, termNode);
AddASTChild(exprNode, ParseArithmeticalExpression(parser));
return exprNode;
} else if(parser->currentToken.type == TOKEN_MINUS) {
Match(parser, TOKEN_MINUS);
AST* exprNode = CreateASTNode(SEM_SUBTRACTION, VALUE_EMPTY);
AddASTChild(exprNode, termNode);
AddASTChild(exprNode, ParseArithmeticalExpression(parser));
return exprNode;
} else {
return termNode;
}
}
Expresion* Sintactico::ParseSimpleExpression()
{
Expresion* expr = ParseTerm();
return _ParseSimpleExpression(expr);
}
