// IfThenElse -> Condition (? Condition : Condition)?
Expression::Node *Expression::parseIfThenElse() {
//printf("parsing if then else\n");
Node *result = parseCondition();
if (consume("?")) {
Node *then = parseCondition();
assert(consume(":"), "If Then Else missing else case\n");
result = new IfThenElse(result, then, parseCondition());
}
return result;
}
void Condition::parseCondition()
{
curToken=t.getToken();
if(curToken == 20) {
altNum=1;
comp.parseCompare();
}
else if(curToken == 15) {
altNum=2;
t.skipToken();
parseCondition();
}
else if(curToken == 16) {
t.skipToken();
parseCondition();
curToken=t.getToken();
if(curToken == 18){
altNum=3;
}
else if(curToken == 19){
altNum=4;
}
else{
cout<<"Error-expecting && or ||"<<endl;
exit(0);
}
t.skipToken();
parseCondition();
curToken=t.getToken();
if(curToken == 17) {
t.skipToken();
}
else {
cout<<"Error-expecting ]"<<endl;
exit(0);
}
}
else {
cout<<"Error. Exiting"<<endl;
exit(0);
}
}
void KConfigPropagator::readKcfgFile()
{
QString filename = locate( "kcfg", mKcfgFile );
if ( filename.isEmpty() ) {
kdError() << "Unable to find kcfg file '" << mKcfgFile << "'" << endl;
return;
}
QFile input( filename );
QDomDocument doc;
QString errorMsg;
int errorRow;
int errorCol;
if ( !doc.setContent( &input, &errorMsg, &errorRow, &errorCol ) ) {
kdError() << "Parse error in " << mKcfgFile << ", line " << errorRow << ", col " << errorCol << ": " << errorMsg << endl;
return;
}
QDomElement cfgElement = doc.documentElement();
if ( cfgElement.isNull() ) {
kdError() << "No document in kcfg file" << endl;
return;
}
mRules.clear();
QDomNode n;
for ( n = cfgElement.firstChild(); !n.isNull(); n = n.nextSibling() ) {
QDomElement e = n.toElement();
QString tag = e.tagName();
if ( tag == "propagation" ) {
Rule rule = parsePropagation( e );
mRules.append( rule );
} else if ( tag == "condition" ) {
Condition condition = parseCondition( e );
QDomNode n2;
for( n2 = e.firstChild(); !n2.isNull(); n2 = n2.nextSibling() ) {
QDomElement e2 = n2.toElement();
if ( e2.tagName() == "propagation" ) {
Rule rule = parsePropagation( e2 );
rule.condition = condition;
mRules.append( rule );
} else {
kdError() << "Unknow tag: " << e2.tagName() << endl;
}
}
}
}
}
Liquid::Condition Liquid::IfTag::parseLogicalCondition(Parser& parser)
{
Condition cond = parseCondition(parser);
Condition::LogicalOperator logicalOp = Condition::LogicalOperator::None;
if (parser.consumeId("and")) {
logicalOp = Condition::LogicalOperator::And;
} else if (parser.consumeId("or")) {
logicalOp = Condition::LogicalOperator::Or;
}
if (logicalOp != Condition::LogicalOperator::None) {
cond.setLogicalCondition(logicalOp, std::make_shared<Condition>(parseLogicalCondition(parser)));
}
return cond;
}
PARSENODE_PTR SQLParser::parseDelete() {
if (!startsDelete(nowReading)) {
syntaxError(nowReading, "expect delete!");
return nullptr;
}
PARSENODE_PTR deleteNode = PARSENODE_PTR(new ParseNode(DELETE));
readToken();
expect(FROM);
deleteNode->children.push_back(parseIdentifier());
if (nowReading == WHERE) {
readToken();
deleteNode->children.push_back(parseCondition());
}
expect(TERMINATOR);
return deleteNode;
}
PARSENODE_PTR SQLParser::parseSelect() {
if (!startsSelect(nowReading)) {
syntaxError(nowReading, "expect select token!");
return nullptr;
}
PARSENODE_PTR selectNode = PARSENODE_PTR(new ParseNode(SELECT));
readToken();
expect(STAR);
expect(FROM);
selectNode->children.push_back(parseIdentifier());
if (nowReading == WHERE) {
readToken();
selectNode->children.push_back(parseCondition());
}
expect(TERMINATOR);
return selectNode;
}
void SVGSMILElement::parseBeginOrEnd(const String& parseString, BeginOrEnd beginOrEnd)
{
Vector<SMILTimeWithOrigin>& timeList = beginOrEnd == Begin ? m_beginTimes : m_endTimes;
if (beginOrEnd == End)
m_hasEndEventConditions = false;
HashSet<double> existing;
for (unsigned n = 0; n < timeList.size(); ++n)
existing.add(timeList[n].time().value());
Vector<String> splitString;
parseString.split(';', splitString);
for (unsigned n = 0; n < splitString.size(); ++n) {
SMILTime value = parseClockValue(splitString[n]);
if (value.isUnresolved())
parseCondition(splitString[n], beginOrEnd);
else if (!existing.contains(value.value()))
timeList.append(SMILTimeWithOrigin(value, SMILTimeWithOrigin::ParserOrigin));
}
sortTimeList(timeList);
}
static CondResult parseConditionString (const Key * meta, const Key * suffixList, Key * parentKey, Key * key, KeySet * ks, Operation op)
{
const char * conditionString = keyString (meta);
const char * regexString1 = "(\\(((.*)?)\\))[[:space:]]*\\?";
const char * regexString2 = "\\?[[:space:]]*(\\(((.*)?)\\))";
const char * regexString3 = "[[:space:]]*:[[:space:]]*(\\(((.*)?)\\))";
regex_t regex1, regex2, regex3;
CondResult ret;
if ((ret = regcomp (®ex1, regexString1, REGEX_FLAGS_CONDITION)))
{
ELEKTRA_SET_ERROR (87, parentKey, "Couldn't compile regex: most likely out of memory"); // the regex compiles so the only
// possible error would be out of
// memory
ksDel (ks);
return ERROR;
}
if ((ret = regcomp (®ex2, regexString2, REGEX_FLAGS_CONDITION)))
{
ELEKTRA_SET_ERROR (87, parentKey, "Couldn't compile regex: most likely out of memory"); // the regex compiles so the only
// possible error would be out of
// memory
regfree (®ex1);
ksDel (ks);
return ERROR;
}
if ((ret = regcomp (®ex3, regexString3, REGEX_FLAGS_CONDITION)))
{
ELEKTRA_SET_ERROR (87, parentKey, "Couldn't compile regex: most likely out of memory"); // the regex compiles so the only
// possible error would be out of
// memory
regfree (®ex1);
regfree (®ex2);
ksDel (ks);
return ERROR;
}
int subMatches = 6;
regmatch_t m[subMatches];
int nomatch = regexec (®ex1, conditionString, subMatches, m, 0);
if (nomatch)
{
ELEKTRA_SET_ERRORF (134, parentKey, "Invalid syntax: \"%s\". Check kdb info conditionals for additional information",
conditionString);
regfree (®ex1);
regfree (®ex2);
regfree (®ex3);
ksDel (ks);
return ERROR;
}
if (m[1].rm_so == -1)
{
ELEKTRA_SET_ERRORF (134, parentKey, "Invalid syntax: \"%s\". Check kdb info conditionals for additional information",
conditionString);
regfree (®ex1);
regfree (®ex2);
regfree (®ex3);
ksDel (ks);
return ERROR;
}
int startPos = m[1].rm_so;
int endPos = m[1].rm_eo;
char * condition = elektraMalloc (endPos - startPos + 1);
char * thenexpr = NULL;
char * elseexpr = NULL;
strncpy (condition, conditionString + startPos, endPos - startPos);
condition[endPos - startPos] = '\0';
nomatch = regexec (®ex2, conditionString, subMatches, m, 0);
if (nomatch)
{
ELEKTRA_SET_ERRORF (134, parentKey, "Invalid syntax: \"%s\". Check kdb info conditionals for additional information",
conditionString);
regfree (®ex1);
regfree (®ex2);
regfree (®ex3);
ksDel (ks);
return ERROR;
}
if (m[1].rm_so == -1)
{
ELEKTRA_SET_ERRORF (134, parentKey, "Invalid syntax: \"%s\". Check kdb info conditionals for additional information",
conditionString);
regfree (®ex1);
regfree (®ex2);
regfree (®ex3);
ksDel (ks);
return ERROR;
}
startPos = m[1].rm_so;
endPos = m[1].rm_eo;
thenexpr = elektraMalloc (endPos - startPos + 1);
strncpy (thenexpr, conditionString + startPos, endPos - startPos);
thenexpr[endPos - startPos] = '\0';
nomatch = regexec (®ex3, conditionString, subMatches, m, 0);
if (!nomatch)
{
if (m[1].rm_so == -1)
{
ELEKTRA_SET_ERRORF (134, parentKey,
"Invalid syntax: \"%s\". Check kdb info conditionals for additional information",
conditionString);
regfree (®ex1);
regfree (®ex2);
regfree (®ex3);
ksDel (ks);
return ERROR;
}
thenexpr[strlen (thenexpr) - ((m[0].rm_eo - m[0].rm_so))] = '\0';
startPos = m[1].rm_so;
endPos = m[1].rm_eo;
elseexpr = elektraMalloc (endPos - startPos + 1);
strncpy (elseexpr, conditionString + startPos, endPos - startPos);
elseexpr[endPos - startPos] = '\0';
}
ret = parseCondition (key, condition, suffixList, ks, parentKey);
if (ret == TRUE)
{
if (op == ASSIGN)
{
const char * assign = isAssign (key, thenexpr, parentKey, ks);
if (assign != NULL)
{
keySetString (key, assign);
ret = TRUE;
goto CleanUp;
}
else
{
ret = ERROR;
goto CleanUp;
}
}
else
{
ret = parseCondition (key, thenexpr, suffixList, ks, parentKey);
if (ret == FALSE)
{
ELEKTRA_SET_ERRORF (135, parentKey, "Validation of Key %s: %s failed. (%s failed)",
keyName (key) + strlen (keyName (parentKey)) + 1, conditionString, thenexpr);
}
else if (ret == ERROR)
{
ELEKTRA_SET_ERRORF (134, parentKey,
"Invalid syntax: \"%s\". Check kdb info conditionals for additional information",
thenexpr);
}
}
}
else if (ret == FALSE)
{
if (elseexpr)
{
if (op == ASSIGN)
{
const char * assign = isAssign (key, elseexpr, parentKey, ks);
if (assign != NULL)
{
keySetString (key, assign);
ret = TRUE;
goto CleanUp;
}
else
{
ret = ERROR;
goto CleanUp;
}
}
else
{
ret = parseCondition (key, elseexpr, suffixList, ks, parentKey);
if (ret == FALSE)
{
ELEKTRA_SET_ERRORF (135, parentKey, "Validation of Key %s: %s failed. (%s failed)",
keyName (key) + strlen (keyName (parentKey)) + 1, conditionString, elseexpr);
}
else if (ret == ERROR)
{
ELEKTRA_SET_ERRORF (
134, parentKey,
"Invalid syntax: \"%s\". Check kdb info conditionals for additional information", elseexpr);
}
}
}
else
{
ret = NOEXPR;
}
}
else if (ret == ERROR)
{
ELEKTRA_SET_ERRORF (134, parentKey, "Invalid syntax: \"%s\". Check kdb info conditionals for additional information",
condition);
}
CleanUp:
elektraFree (condition);
elektraFree (thenexpr);
if (elseexpr) elektraFree (elseexpr);
regfree (®ex1);
regfree (®ex2);
regfree (®ex3);
ksDel (ks);
return ret;
}
/**
* parse a condition recursively.
*/
PDDLGoalDescription DomainParser::parseCondition(const VAL::goal* goal) {
// simple proposition (base case 1)
const VAL::simple_goal* sg = dynamic_cast<const VAL::simple_goal*>(goal);
if (sg) {
const VAL::proposition* valprop = sg->getProp();
PDDLAtomicFormula prop;
prop.name = valprop->head->symbol::getName();
for (VAL::parameter_symbol_list::const_iterator ci = valprop->args->begin(); ci != valprop->args->end(); ci++) {
const VAL::parameter_symbol* param = *ci;
PDDLTypedSymbol sym;
sym.type = param->type->getName();
sym.name = param->pddl_typed_symbol::getName();
prop.vars.push_back(sym);
}
PDDLGDAtomic pgda(prop);
return pgda;
}
// function inequality (base case 2)
const VAL::comparison* co = dynamic_cast<const VAL::comparison*>(goal);
if (co) {
PDDLFunctionInequality bin_expression = EQ;
switch(co->getOp()) {
case VAL::E_GREATER: bin_expression = GT; break;
case VAL::E_GREATEQ: bin_expression = EQGT; break;
case VAL::E_LESS: bin_expression = LT; break;
case VAL::E_LESSEQ: bin_expression = EQLT; break;
};
PDDLFunction lhs = parseExpression(co->getLHS());
PDDLFunction rhs = parseExpression(co->getRHS());
PDDLGDFunction pgdf(lhs, rhs, bin_expression);
return pgdf;
}
// negative condition
const VAL::neg_goal* ng = dynamic_cast<const VAL::neg_goal*>(goal);
if (ng) {
PDDLGDConjunction pgda(NOT);
PDDLGoalDescription inner = parseCondition(ng->getGoal());
pgda.goal_conditions.push_back(inner);
return pgda;
}
// conjunctive condition
const VAL::conj_goal* cg = dynamic_cast<const VAL::conj_goal*>(goal);
if (cg) {
PDDLGDConjunction pgda(AND);
const VAL::goal_list* goals = cg->getGoals();
for (VAL::goal_list::const_iterator ci = goals->begin(); ci != goals->end(); ci++) {
PDDLGoalDescription inner = parseCondition((*ci));
pgda.goal_conditions.push_back(inner);
}
return pgda;
}
// disjunctive condition
const VAL::disj_goal* dg = dynamic_cast<const VAL::disj_goal*>(goal);
if (dg) {
PDDLGDConjunction pgda(OR);
const VAL::goal_list* goals = dg->getGoals();
for (VAL::goal_list::const_iterator ci = goals->begin(); ci != goals->end(); ci++) {
PDDLGoalDescription inner = parseCondition((*ci));
pgda.goal_conditions.push_back(inner);
}
return pgda;
}
// timed condition
const VAL::timed_goal* tg = dynamic_cast<const VAL::timed_goal*>(goal);
if (tg) {
PDDLTimeSpecifier time_spec = START;
switch(tg->getTime()) {
case VAL::E_AT_END: time_spec = END; break;
case VAL::E_OVER_ALL: time_spec = ALL; break;
};
PDDLGDTimed pgdt(time_spec);
PDDLGoalDescription inner = parseCondition(tg->getGoal());
pgdt.goal_conditions.push_back(inner);
return pgdt;
}
}
/**
* parse the domain file
*/
void DomainParser::parseDomain(const std::string domainPath) {
// only parse domain once
if(domain_parsed) return;
domain_parsed = true;
std::string domainFileName = (domainPath);
ROS_INFO("KCL: (KB) Parsing domain: %s.", domainFileName.c_str());
// save filename for VAL
std::vector<char> writable(domainFileName.begin(), domainFileName.end());
writable.push_back('\0');
current_filename = &writable[0];
// parse domain
VAL::current_analysis = &VAL::an_analysis;
std::ifstream domainFile;
domainFile.open(domainFileName.c_str());
yydebug = 0;
VAL::yfl = new yyFlexLexer;
if (domainFile.bad()) {
ROS_ERROR("KCL: (KB) Failed to open domain file.");
line_no = 0;
VAL::log_error(VAL::E_FATAL,"Failed to open file");
} else {
line_no = 1;
VAL::yfl->switch_streams(&domainFile, &std::cout);
yyparse();
// domain name
VAL::domain* domain = VAL::current_analysis->the_domain;
domain_name = domain->name;
// types
VAL::pddl_type_list* types = domain->types;
for (VAL::pddl_type_list::const_iterator ci = types->begin(); ci != types->end(); ci++) {
const VAL::pddl_type* type = *ci;
domain_types.push_back(type->getName());
}
// predicates
VAL::pred_decl_list* predicates = domain->predicates;
if(predicates) {
for (VAL::pred_decl_list::const_iterator ci = predicates->begin(); ci != predicates->end(); ci++) {
const VAL::pred_decl* predicate = *ci;
// predicate name
PDDLAtomicFormula pred;
pred.name = predicate->getPred()->symbol::getName();
domain_predicates[pred.name] = pred;
// predicate variables
for (VAL::var_symbol_list::const_iterator vi = predicate->getArgs()->begin(); vi != predicate->getArgs()->end(); vi++) {
const VAL::var_symbol* var = *vi;
PDDLTypedSymbol sym;
sym.type = var->type->getName();
sym.name = var->pddl_typed_symbol::getName();
domain_predicates[pred.name].vars.push_back(sym);
}
}
}
// functions
VAL::func_decl_list* functions = domain->functions;
if(functions) {
for (VAL::func_decl_list::const_iterator ci = functions->begin(); ci != functions->end(); ci++) {
const VAL::func_decl* function = *ci;
// function name
PDDLAtomicFormula func;
func.name = function->getFunction()->symbol::getName();
domain_functions[func.name] = func;
// parameters
for (VAL::var_symbol_list::const_iterator vi = function->getArgs()->begin(); vi != function->getArgs()->end(); vi++) {
const VAL::var_symbol* var = *vi;
PDDLTypedSymbol sym;
sym.type = var->type->getName();
sym.name = var->pddl_typed_symbol::getName();
domain_functions[func.name].vars.push_back(sym);
}
}
}
// operators
VAL::operator_list* operators = domain->ops;
for (VAL::operator_list::const_iterator ci = operators->begin(); ci != operators->end(); ci++) {
const VAL::operator_* op = *ci;
// name
std::string name = op->name->symbol::getName();
// condition
const VAL::goal* precondition = op->precondition;
PDDLGoalDescription c = parseCondition(precondition);
// duration
PDDLFunctionNumber n(0);
PDDLDuration d(n, EQ);
const VAL::durative_action* da = dynamic_cast<const VAL::durative_action*>(op);
if (da) {
// TODO get the real duration from VAL
PDDLFunctionNumber n(1);
d = PDDLDuration(n, EQ);
}
// operator
PDDLOperator oper(d, c);
oper.name = name;
// parameters
for (VAL::var_symbol_list::const_iterator vi = op->parameters->begin(); vi != op->parameters->end(); vi++) {
const VAL::var_symbol* var = *vi;
PDDLTypedSymbol sym;
sym.type = var->type->getName();
sym.name = var->pddl_typed_symbol::getName();
oper.parameters.push_back(sym);
}
domain_operators.insert( std::pair<std::string,PDDLOperator>(name, oper) );
}
}
domainFile.close();
delete VAL::yfl;
}
