DECLARE_EXPORT void SetupMatrix::beginElement(XMLInput& pIn, const Attribute& pAttr)
{
if (pAttr.isA(Tags::tag_rule)
&& pIn.getParentElement().first.isA(Tags::tag_rules))
// A new rule
pIn.readto(createRule(pIn.getAttributes()));
}
BNFRule *EBNFParser::rule()
{
//match name
if(token.tokenType!=EBNFToken::ID){
error("Rule must start with name");
return 0;
}
BNFRule *r=createRule(token.lexeme);
r->startAlternatives();
match(EBNFToken::ID);
if(token.tokenType==EBNFToken::OPTIONS_BLOCK){
//set rule options
r->readOptions(token.lexeme);
//read next token
token = scanner->getToken();
}
match(EBNFToken::COLON);
exp(r);
match(EBNFToken::SEMICOLON);
if(r->alternatives.size()>0 && r->alternatives.at(r->alternatives.size()-1).isEmpty()){
r->alternatives[r->alternatives.size()-1].append(createEpsilonItem());
}
return r;
}
void removeSignalWatch(
Signals* signals,
char* busname,
char* objectpath,
char* interface,
char* signalname)
{
DBusError dbusError;
dbus_error_init(&dbusError);
bstring rule = createRule(busname, objectpath, interface, signalname);
char* cstr_rule = bstr2cstr(rule,'\0');
printf("Rule : %s\n",cstr_rule);
pthread_mutex_lock(&signals->dbus_mutex);
dbus_bus_remove_match(signals->con,cstr_rule,&dbusError);
pthread_mutex_unlock(&signals->dbus_mutex);
if (dbus_error_is_set(&dbusError)) {
fprintf(stderr, "%s %d: Error occurred: %s\n",__FILE__,__LINE__, dbusError.message);
dbus_error_free(&dbusError);
}
bcstrfree(cstr_rule);
bdestroy(rule);
}
void OsmAnd::ObfMapSectionReader_P::readRules(
const std::unique_ptr<ObfReader_P>& reader,
const std::shared_ptr<ObfMapSectionInfo_P::Rules>& rules)
{
auto cis = reader->_codedInputStream.get();
uint32_t defaultId = 1;
for(;;)
{
gpb::uint32 tag = cis->ReadTag();
switch(gpb::internal::WireFormatLite::GetTagFieldNumber(tag))
{
case 0:
{
auto free = rules->_decodingRules.size() * 2 + 1;
rules->_coastlineBrokenEncodingType = free++;
createRule(rules, 0, rules->_coastlineBrokenEncodingType, QString::fromLatin1("natural"), QString::fromLatin1("coastline_broken"));
if(rules->_landEncodingType == -1)
{
rules->_landEncodingType = free++;
createRule(rules, 0, rules->_landEncodingType, QString::fromLatin1("natural"), QString::fromLatin1("land"));
}
}
return;
case OBF::OsmAndMapIndex::kRulesFieldNumber:
{
gpb::uint32 length;
cis->ReadVarint32(&length);
auto oldLimit = cis->PushLimit(length);
readRule(reader, defaultId++, rules);
cis->PopLimit(oldLimit);
}
break;
default:
ObfReaderUtilities::skipUnknownField(cis, tag);
break;
}
}
}
RulesConfigWidget::RulesConfigWidget(QWidget* parent): QWidget(parent)
{
layout = new QHBoxLayout(this);
leftWidget = new QWidget(this);
leftLayout = new QVBoxLayout(leftWidget);
rulesList = new QListWidget(this);
leftLayout->addWidget(rulesList);
QPushButton* upButton = new QPushButton(i18n("Up"), leftWidget);
leftLayout->addWidget(upButton);
QPushButton* downButton = new QPushButton(i18n("Down"), leftWidget);
leftLayout->addWidget(downButton);
newRuleButton = new QPushButton(i18n("New"));
leftLayout->addWidget(newRuleButton);
deleteRuleButton = new QPushButton(i18n("Delete"));
leftLayout->addWidget(deleteRuleButton);
layout->addWidget(leftWidget);
rightWidget = new QWidget(this);
rightLayout = new QFormLayout(rightWidget);
QLabel *groupLabel = new QLabel(i18n("Group"));
groupSelect = new QComboBox(rightWidget);
rightLayout->addRow(groupLabel, groupSelect);
QLabel *keyLabel = new QLabel(i18n("Key"));
keySelect = new QComboBox;
rightLayout->addRow(keyLabel, keySelect);
QLabel *valueLabel = new QLabel(i18n("Value"));
valueInput = new QLineEdit;
rightLayout->addRow(valueLabel, valueInput);
layout->addWidget(rightWidget);
QObject::connect(rulesList, SIGNAL(currentItemChanged(QListWidgetItem*,QListWidgetItem*)),
this, SLOT(currentItemChanged(QListWidgetItem*,QListWidgetItem*)));
QObject::connect(newRuleButton, SIGNAL(clicked()), this, SLOT(createRule()));
QObject::connect(deleteRuleButton, SIGNAL(clicked()), this, SLOT(deleteRule()));
QObject::connect(upButton, SIGNAL(clicked()), this, SLOT(ruleUp()));
QObject::connect(downButton, SIGNAL(clicked()), this, SLOT(ruleDown()));
load();
configureKeys();
}
BNFRuleItem *EBNFParser::convertToZeroOrOneItem(const QString &newRuleName, BNFRuleItem *item)
{
//Convert every option E? to a fresh non-terminal X and add
//X = epsilon | E.
//create X
BNFRule *r=createRule(newRuleName);
r->startAlternatives();
//add epsilon
r->addRuleItem(createEpsilonItem());
//start new alternatives section
r->startAlternatives();
//add pointer to E
item->token.lexeme=item->pointsTo;
r->addRuleItem(item);
//return item to point to X
return createRulePointerItem(r);
}
BNFRuleItem *EBNFParser::convertToOneOrMoreItem(const QString &newRuleName, BNFRuleItem *item)
{
//BNF can express 1 or more repetitions by e.g.:
//X = E | X E
//create X
BNFRule *r=createRule(newRuleName);
r->startAlternatives();
//add pointer to copy of E
item->token.lexeme=item->pointsTo;
r->addRuleItem(new BNFRuleItem(*item));
//start new alternatives section
r->startAlternatives();
//add pointer to X
r->addRuleItem(createRulePointerItem(r));
//add pointer to E
r->addRuleItem(item);
//return item to point to X
return createRulePointerItem(r);
}
void OsmAnd::ObfMapSectionReader_P::readRule(
const std::unique_ptr<ObfReader_P>& reader,
uint32_t defaultId, const std::shared_ptr<ObfMapSectionInfo_P::Rules>& rules)
{
auto cis = reader->_codedInputStream.get();
gpb::uint32 ruleId = defaultId;
gpb::uint32 ruleType = 0;
QString ruleTag;
QString ruleVal;
for(;;)
{
auto tag = cis->ReadTag();
switch(gpb::internal::WireFormatLite::GetTagFieldNumber(tag))
{
case 0:
createRule(rules, ruleType, ruleId, ruleTag, ruleVal);
return;
case OBF::OsmAndMapIndex_MapEncodingRule::kValueFieldNumber:
ObfReaderUtilities::readQString(cis, ruleVal);
break;
case OBF::OsmAndMapIndex_MapEncodingRule::kTagFieldNumber:
ObfReaderUtilities::readQString(cis, ruleTag);
break;
case OBF::OsmAndMapIndex_MapEncodingRule::kTypeFieldNumber:
cis->ReadVarint32(&ruleType);
break;
case OBF::OsmAndMapIndex_MapEncodingRule::kIdFieldNumber:
cis->ReadVarint32(&ruleId);
break;
default:
ObfReaderUtilities::skipUnknownField(cis, tag);
break;
}
}
}
bool EBNFParser::atom(BNFRule *rule)
{
if(token.tokenType==EBNFToken::RPAREN ||
token.tokenType==EBNFToken::SEMICOLON ||
token.tokenType==EBNFToken::PIPE){
return false;
}
BNFRuleItem *item=new BNFRuleItem();
if(token.tokenType==EBNFToken::NEGATION){
item->isNegated=true;
match(EBNFToken::NEGATION);
}
if(token.tokenType==EBNFToken::LPAREN){
//Convert every group ( E ) to a fresh non-terminal X and add
//X = E
match(EBNFToken::LPAREN);
BNFRule *r=createRule(QString("%1_%2").arg(rule->ruleName).arg(++rule->subruleCount));
r->startAlternatives();
item->isTerminal=false;
item->pointsTo=r->ruleName;
item->token=token;
exp(r);
match(EBNFToken::RPAREN);
}else if(token.tokenType==EBNFToken::ID){
item->isTerminal=false;
item->pointsTo=token.lexeme;
item->token=token;
match(EBNFToken::ID);
}else if(token.tokenType==EBNFToken::TERMINAL){
item->isTerminal=true;
item->token=token;
match(EBNFToken::TERMINAL);
}else{
error("Could not match atom");
}
if(token.tokenType==EBNFToken::RANGE){
if(item->token.tokenType!=EBNFToken::TERMINAL){
error("Range start must be a terminal");
}
match(EBNFToken::RANGE);
if(token.tokenType!=EBNFToken::TERMINAL){
error("Range end must be a terminal");
}
item->rangeEndToken=token;
match(EBNFToken::TERMINAL);
}else if(token.tokenType==EBNFToken::STAR){
item=convertToKleeneItem(QString("%1_%2_kleene").arg(rule->ruleName).arg(++rule->subruleCount), item);
match(EBNFToken::STAR);
}else if(token.tokenType==EBNFToken::PLUS){
item=convertToOneOrMoreItem(QString("%1_%2_plus").arg(rule->ruleName).arg(++rule->subruleCount), item);
match(EBNFToken::PLUS);
}else if(token.tokenType==EBNFToken::QUESTION){
item=convertToZeroOrOneItem(QString("%1_%2_question").arg(rule->ruleName).arg(++rule->subruleCount), item);
match(EBNFToken::QUESTION);
}
rule->addRuleItem(item);
return true;
}
void *NclPresentationControlParser::parseRule(
DOMElement *parentElement, void *objGrandParent) {
wclog << "parseRule" << endl;
return createRule(parentElement, objGrandParent);
}
