static AST asnstmt(AST name) {
Token *t = &tok;
AST a=0;
AST a1=0,a2=0;
int idx,op;
switch (t->sym) {
case ASNOP: /* change name to VREF */
set_nodetype(name, nVREF);
idx = lookup_SYM_all(get_text(name));
set_ival(name,idx);
a1 = name;
break;
case '[': /* change name to LVAL */
set_nodetype(name, nVREF);
a2 = exprs();
a1 = make_AST(nLVAL, name, a2, 0, 0) ;
break;
default:
break;
}
op = t->ival;
gettoken();
a2 = expr();
a = make_AST_asn(op,a1,a2);
return a;
}
static AST lval() {
Token *t = &tok;
AST a=0;
AST a1=0,a2=0;
a1 = vref();
if (t->sym == '[') {
a2 = exprs();
a = make_AST(nLVAL, a1, a2, 0, 0);
} else
a = a1;
return a;
}
QVariantMap WebBridgeRS::searchKeywords(const QString& keywords, QVariantMap searchOptions)
{
std::cerr << "webscriptrs: keywords in " << keywords.toStdString().c_str() << std::endl;
QVariantMap qReturn;
QVariantList qResults;
if (keywords.length() < 3){
std::cerr << "webscriptrs: not searching due to keywords.length = " << keywords.length() << std::endl;
qReturn.insert("message","search terms < 3 chars");
qReturn.insert("status","fail");
qReturn.insert("results",qResults);
return qReturn;
}
QStringList qWords = keywords.split(" ", QString::SkipEmptyParts);
std::list<std::string> words;
QStringListIterator qWordsIter(qWords);
while (qWordsIter.hasNext())
words.push_back(qWordsIter.next().toUtf8().constData());
int n = words.size() ;
if (n < 1){
std::cerr << "webscriptrs: searching due to words.size() = " << n << std::endl;
qReturn.insert("message","search terms < 1 word");
qReturn.insert("status","fail");
qReturn.insert("results",qResults);
return qReturn;
}
NameExpression exprs(ContainsAllStrings,words,true) ;
LinearizedExpression lin_exp ;
exprs.linearize(lin_exp) ;
TurtleRequestId req_id ;
if(searchOptions.value("turtle", false).toBool())
{
if(n==1)
req_id = rsTurtle->turtleSearch(words.front()) ;
else
req_id = rsTurtle->turtleSearch(lin_exp) ;
qReturn.insert("turtleID",req_id);
}
else
req_id = ((((uint32_t)rand()) << 16)^0x1e2fd5e4) + (((uint32_t)rand())^0x1b19acfe) ; // generate a random 32 bits request id
/* extract keywords from lineEdit */
// make a compound expression with an AND
//
//std::list<DirDetails> finalResults ;
std::list<DirDetails> initialResults;
//RS_FILE_HINTS_REMOTE
//rsFiles->SearchBoolExp(&exprs, initialResults, RS_FILE_HINTS_LOCAL);// | DIR_FLAGS_NETWORK_WIDE | DIR_FLAGS_BROWSABLE) ;
FileSearchFlags fsf;
if (searchOptions.value("localindexed", false).toBool()){
//std::cerr << "incuding local\n";
fsf = RS_FILE_HINTS_LOCAL;
}
if (searchOptions.value("remoteindexed", false).toBool()){
//std::cerr << "incuding remote\n";
fsf |= RS_FILE_HINTS_REMOTE;
}
if (searchOptions.value("boolexp", false).toBool()){
rsFiles->SearchBoolExp(&exprs, initialResults, fsf);
}else{
rsFiles->SearchKeywords(words, initialResults, fsf);
}
//if(searchFriends) fsf = RS_FILE_HINTS_REMOTE;
//rsFiles->getSharedDirectories();
//SharedDirInfo sdinfo;
//sdinfo.
std::cerr << "webscriptrs: result count: " << initialResults.size() << std::endl;
/* which extensions do we use? */
DirDetails dd;
for(std::list<DirDetails>::iterator resultsIter = initialResults.begin(); resultsIter != initialResults.end(); resultsIter ++)
{
//std::cout << "webscriptrs: " << dd.hash << std::endl;
dd = *resultsIter;
QVariantMap qdd;
qdd.insert("age",dd.age);//QString::number(dir.age)?
//qdd.insert("message",dd.children);
qdd.insert("size",QString::number(dd.count));
//qdd.insert("message",dd.flags);
qdd.insert("hash",QString::fromStdString(dd.hash.toStdString()));
qdd.insert("id",QString::fromStdString(dd.id.toStdString()));
qdd.insert("mind_age",dd.min_age);
qdd.insert("srname",QString::fromUtf8(dd.name.c_str()));
//qdd.insert("message",dd.parent);
//qdd.insert("message",dd.parent_groups);
qdd.insert("path",QString::fromUtf8(dd.path.c_str()));
qdd.insert("prow",dd.prow);
//qdd.insert("message",dd.ref);
qdd.insert("type",dd.type);
FileInfo info;
//The flags copied from SearchDialog.cpp:1096
if (rsFiles->FileDetails(dd.hash, RS_FILE_HINTS_EXTRA | RS_FILE_HINTS_LOCAL | RS_FILE_HINTS_BROWSABLE | RS_FILE_HINTS_NETWORK_WIDE | RS_FILE_HINTS_SPEC_ONLY, info)){
/* make path for downloaded or downloading files */
//QFileInfo qinfo;
std::string path;
path = info.path.substr(0,info.path.length()-info.fname.length());
QDir apath = QDir(QString::fromUtf8(path.c_str()));
qdd.insert("fullpath", apath.absolutePath());
/* open folder with a suitable application */
/*qinfo.setFile(QString::fromUtf8(path.c_str()));
if (qinfo.exists() && qinfo.isDir()) {
if (!RsUrlHandler::openUrl(QUrl::fromLocalFile(qinfo.absoluteFilePath()))) {
std::cerr << "openFolderSearch(): can't open folder " << path << std::endl;
}
}*/
} else {
std::cout << "file details failed\n";
}
qResults.push_back(qdd);
//finalResults.push_back(dd);
}
/* abstraction to allow reusee of tree rendering code */
//resultsToTree(keywords,req_id, finalResults);
qReturn.insert("status","sucess");
qReturn.insert("results",qResults);
return qReturn;
}
void aig_exporter::operator()(std::ostream& out) {
expr_ref_vector transition_function(m), output_preds(m);
var_ref_vector input_vars(m);
rule_counter& vc = m_rm.get_counter();
expr_ref_vector exprs(m);
substitution subst(m);
for (rule_set::decl2rules::iterator I = m_rules.begin_grouped_rules(),
E = m_rules.end_grouped_rules(); I != E; ++I) {
for (rule_vector::iterator II = I->get_value()->begin(),
EE = I->get_value()->end(); II != EE; ++II) {
rule *r = *II;
unsigned numqs = r->get_positive_tail_size();
if (numqs > 1) {
std::cerr << "non-linear clauses not supported\n";
exit(-1);
}
if (numqs != r->get_uninterpreted_tail_size()) {
std::cerr << "negation of queries not supported\n";
exit(-1);
}
exprs.reset();
assert_pred_id(numqs ? r->get_tail(0)->get_decl() : 0, m_ruleid_var_set, exprs);
assert_pred_id(r->get_head()->get_decl(), m_ruleid_varp_set, exprs);
subst.reset();
subst.reserve(1, vc.get_max_rule_var(*r)+1);
if (numqs)
collect_var_substs(subst, r->get_tail(0), m_latch_vars, exprs);
collect_var_substs(subst, r->get_head(), m_latch_varsp, exprs);
for (unsigned i = numqs; i < r->get_tail_size(); ++i) {
expr_ref e(m);
subst.apply(r->get_tail(i), e);
exprs.push_back(e);
}
transition_function.push_back(m.mk_and(exprs.size(), exprs.c_ptr()));
}
}
// collect table facts
if (m_facts) {
for (fact_vector::const_iterator I = m_facts->begin(), E = m_facts->end(); I != E; ++I) {
exprs.reset();
assert_pred_id(0, m_ruleid_var_set, exprs);
assert_pred_id(I->first, m_ruleid_varp_set, exprs);
for (unsigned i = 0; i < I->second.size(); ++i) {
exprs.push_back(m.mk_eq(get_latch_var(i, m_latch_varsp), I->second[i]));
}
transition_function.push_back(m.mk_and(exprs.size(), exprs.c_ptr()));
}
}
expr *tr = m.mk_or(transition_function.size(), transition_function.c_ptr());
aig_ref aig = m_aigm.mk_aig(tr);
expr_ref aig_expr(m);
m_aigm.to_formula(aig, aig_expr);
#if 0
std::cout << mk_pp(tr, m) << "\n\n";
std::cout << mk_pp(aig_expr, m) << "\n\n";
#endif
// make rule_id vars latches
for (unsigned i = 0; i < m_ruleid_var_set.size(); ++i) {
m_latch_vars.push_back(m_ruleid_var_set.get(i));
m_latch_varsp.push_back(m_ruleid_varp_set.get(i));
}
// create vars for latches
for (unsigned i = 0; i < m_latch_vars.size(); ++i) {
mk_var(m_latch_vars.get(i));
mk_input_var(m_latch_varsp.get(i));
}
unsigned tr_id = expr_to_aig(aig_expr);
// create latch next state variables: (ite tr varp var)
unsigned_vector latch_varp_ids;
for (unsigned i = 0; i < m_latch_vars.size(); ++i) {
unsigned in_val = mk_and(tr_id, get_var(m_latch_varsp.get(i)));
unsigned latch_val = mk_and(neg(tr_id), get_var(m_latch_vars.get(i)));
latch_varp_ids.push_back(mk_or(in_val, latch_val));
}
m_latch_varsp.reset();
// create output variable (true iff an output predicate is derivable)
unsigned output_id = 0;
{
expr_ref_vector output(m);
const func_decl_set& preds = m_rules.get_output_predicates();
for (func_decl_set::iterator I = preds.begin(), E = preds.end(); I != E; ++I) {
exprs.reset();
assert_pred_id(*I, m_ruleid_var_set, exprs);
output.push_back(m.mk_and(exprs.size(), exprs.c_ptr()));
}
expr *out = m.mk_or(output.size(), output.c_ptr());
aig = m_aigm.mk_aig(out);
m_aigm.to_formula(aig, aig_expr);
output_id = expr_to_aig(aig_expr);
#if 0
std::cout << "output formula\n";
std::cout << mk_pp(out, m) << "\n\n";
std::cout << mk_pp(aig_expr, m) << "\n\n";
#endif
}
// 1) print header
// aag var_index inputs latches outputs andgates
out << "aag " << (m_next_aig_expr_id-1)/2 << ' ' << m_input_vars.size()
<< ' ' << m_latch_vars.size() << " 1 " << m_num_and_gates << '\n';
// 2) print inputs
for (unsigned i = 0; i < m_input_vars.size(); ++i) {
out << m_input_vars[i] << '\n';
}
// 3) print latches
for (unsigned i = 0; i < m_latch_vars.size(); ++i) {
out << get_var(m_latch_vars.get(i)) << ' ' << latch_varp_ids[i] << '\n';
}
// 4) print outputs (just one for now)
out << output_id << '\n';
// 5) print formula
out << m_buffer.str();
}
