ExpPtr parseCall (Lexer& lex, ExpPtr in)
{
auto args = parseTuple(lex);
ExpList exps;
exps.reserve(args->subexps.size() + 1);
exps.push_back(in);
exps.insert(exps.end(), args->subexps.begin(), args->subexps.end());
return Exp::make(eCall, exps, in->span + args->span);
}
ParseStatus Parser::parseFunction() {
assert(lex[0].type == TT_KEYWORD && lex[0].value == KW_FUNCTION);
lex++;
ParseStatus error = parseTuple();
if (error) return error;
assert(lex[0].type == TT_OPERATOR && lex[0].value == OP_RARROW);
error = parseTuple();
if (error) return error;
error = parseBlock();
if (error) return error;
// Args, result, and block are on the stack.
// Create a new function to hold them and push it on the stack.
assert(false);
return PARSE_OK;
}
ExpPtr parseTermPrefix (Lexer& lex)
{
Token tok = lex.current();
switch (tok.tok)
{
case tNumberInt:
tok = lex.advance();
return Exp::make(eInt, tok.valueInt, {}, tok.span);
case tNumberReal:
tok = lex.advance();
return Exp::make(eReal, tok.valueReal, {}, tok.span);
case tString:
tok = lex.advance();
return Exp::make(eString, tok.str, {}, tok.span);
case tTrue:
case tFalse:
tok = lex.advance();
return Exp::make(eBool, tok == tTrue, {}, tok.span);
case tIdent:
tok = lex.advance();
return Exp::make(eVar, tok.str, bool(true), {}, tok.span);
case tLParen:
return parseTuple(lex);
case tIf:
return parseCond(lex);
case tLCurl:
return parseBlock(lex);
case tLBrack:
return parseList(lex);
case tFunc: case tLambda:
return parseLambda(lex);
case tiMake: return parseiMake(lex);
case tiGet: return parseiGet(lex);
case tiPut: return parseiPut(lex);
case tiCall: return parseiCall(lex);
default:
//lex.expect("term");
lex.unexpect();
return nullptr;
}
}
void DemandListModel::parseCsvString(QString const& csvText, QString const& sep){
QStringList lines = csvText.split("\n");
for(QString line : lines){
bool ok;
DemandTuple tup = parseTuple(line, sep, ok);
if(ok){
insertDemandTuple(tup);
}
}
}
void GdbMi::parseValue(const char *&from, const char *to)
{
//qDebug() << "parseValue: " << QByteArray(from, to - from);
switch (*from) {
case '{':
parseTuple(from, to);
break;
case '[':
parseList(from, to);
break;
case '"':
m_type = Const;
m_data = parseCString(from, to);
break;
default:
break;
}
}
void DemandListModel::parseJsonObject(QJsonObject const& rep){
if(rep.contains(nextInsertIdIndex)){
_nextInsertId = rep.value(nextInsertIdIndex).toInt();
}
if(rep.contains(numberOfChoicesIndex)){
setNumberOfChoices(rep.value(numberOfChoicesIndex).toInt());
}
if(rep.contains(additionalVarsIndex)){
if(rep.value(additionalVarsIndex).isArray()){
QVector<QString> additionals;
for(QJsonValue val: rep.value(additionalVarsIndex).toArray()){
if(val.isString()) {
additionals.push_back(val.toString());
}
}
_additionalVariablesName = additionals;
}
}
if(rep.contains(tuplesIndex)){
if(rep.value(tuplesIndex).isArray()){
emptyTuples();
for(QJsonValue val: rep.value(tuplesIndex).toArray()){
if(val.isObject()){
bool ok;
DemandTuple tuple = parseTuple(val.toObject(), ok);
if(ok){
insertDemandTuple(tuple);
}
}
}
}
}
emit(changedDatas());
}
virtual void visitOperator(POETOperator *op)
{
switch (op->get_op()) {
case POET_OP_TUPLE: {
parseTuple(op->get_arg(0));
break;
}
case TYPE_LIST1:
case TYPE_LIST: {
POETCode* arg = op->get_arg(0);
POETCode* matchSave = fullmatch; fullmatch = EMPTY;
std::vector<POETCode*> match_res;
do {
POETCode* r1_first=match_eval(arg);
if (r1_first == 0) {
fullmatch = matchSave;
if (fullmatch != 0) {
res = Vector2List(match_res);
if (res == EMPTY && op->get_op() == TYPE_LIST1)
PARSE_MISMATCH(r1,op,lineno);
return;
}
else PARSE_MISMATCH(r1,op,lineno);
}
match_res.push_back(r1_first);
} while (r1 != 0);
fullmatch = matchSave;
if (match_res.size() == 0) PARSE_MISMATCH(r1,op,lineno);
res = Vector2List(match_res);
assert(res != EMPTY);
return;
}
case TYPE_TOR: {
POETCode* r1_first = get_head(r1);
if (r1_first->get_enum() == SRC_CVAR &&
static_cast<CodeVar*>(r1_first)->get_parseInfo() != EMPTY)
{ /*QY: r1_first is already parsed and is not a token*/
if (!match_eval(op)) PARSE_MISMATCH(r1,op,lineno);
return;
}
if (!backtrack) {
POETTypeTor* tor = static_cast<POETTypeTor*>(op);
POETCode* arg = tor->get_parseInfo(this, r1);
apply(arg, fullmatch);
if (fullmatch != 0) fullmatch=EMPTY;
return;
}
else {
POETCode* r1save = r1;
size_t size = op->numOfArgs();
for (unsigned i = 0; i < size; ++i) {
POETCode* arg = op->get_arg(i);
POETCode* filter = 0;
switch (arg->get_enum()) {
case SRC_STRING: if (arg != EMPTY) filter = arg; break;
case SRC_CVAR:
filter=static_cast<CodeVar*>(arg)->get_parseInfo();
if (filter != 0 && filter->get_enum() == SRC_LIST)
filter = static_cast<POETList*>(filter)->get_first();
else filter = 0;
break;
default: ; /* no filtering */
}
if (filter != 0 && filter->get_enum()==SRC_STRING && filter != r1_first) {
continue;
}
try { apply(arg, EMPTY);
if (res != 0) return; }
catch (ParseError err) { r1 = r1save; }
}
}
PARSE_MISMATCH(r1,op,lineno);
return;
}
case POET_OP_EXP: {
ParseExp::Result exp_res = ParseExp::inst()->parse(r1, &lineno);
res = exp_res.first;
if (res == 0) PARSE_MISMATCH(r1,op,lineno);
if (fullmatch != 0) r1 = exp_res.second;
else if (exp_res.second != 0 && exp_res.second != EMPTY)
{ PARSE_MISMATCH_LEFT(exp_res.second,lineno); }
else r1 = 0;
break;
}
case POET_OP_LIST1:
case POET_OP_LIST: {
POETParseList* oplist = dynamic_cast<POETParseList*>(op);
assert(oplist != 0);
std::string sepString;
POETCode* sep = op->get_arg(1);
if (sep != 0) {
sep = eval_AST(sep);
POETString* sep1 = AST2String(sep);
if (sep1 == 0) INCORRECT_STRING(sep);
sepString = sep1->get_content();
}
else sep = EMPTY;
if (IS_SPACE(sepString)) sep = EMPTY;
try { parseList(oplist, op->get_arg(0), sep); }
catch (ParseError err) {
if (op->get_op() == POET_OP_LIST && backtrack && fullmatch != 0) res = EMPTY;
else throw err; }
break;
}
default:
defaultVisit(eval_AST(op));
}
}
