bool Unify::IsGroundQuestion(const Argument* arg, const VariableMap& v_map) { std::stack<const Argument*> S; S.push(arg); while(!S.empty()) { const Argument* temp = S.top(); S.pop(); if(temp->IsVariable()) { VariableMap::const_iterator it; while(temp->IsVariable() && (it = v_map.find(temp)) != v_map.end()) { temp = it->second; } if(temp->IsVariable()) return false; } else for(size_t i = 0;i < temp->args.size();i++) { S.push(temp->args[i]); } } return true; }
TEST(ForgetOperator,NumAndAtomGoodDeletion) { LiteralsStack stack; VariableMap variableMap; ProgramMap programMap; Lexer *lexer = new Lexer(); lexer->addDefinition(new WhitespaceLiteralDefinition()); lexer->addDefinition(new NumericLiteralDefinition); lexer->addDefinition(new OperatorNumericLiteralDefinition); lexer->addDefinition(new OperatorEqualComparisonLiteralDefinition); lexer->addDefinition(new OperatorStrictComparisonLiteralDefinition); lexer->addDefinition(new ExpressionLiteralDefinition); lexer->addDefinition(new ProgramLiteralDefinition); lexer->addDefinition(new AtomLiteralDefinition); stack.push(LiteralPointer(new NumericLiteral(4,5,4,5))); stack.push(LiteralPointer(new ExpressionLiteral("'AFR'"))); EXPECT_EQ(2, stack.size()); StoOperator stoOperator(variableMap,programMap,*lexer); stoOperator.apply(stack); EXPECT_EQ(0, stack.size()); EXPECT_EQ(1,variableMap.size()); EXPECT_EQ("4/5$4/5",variableMap.get("AFR")->toString()); stack.push(LiteralPointer(new ExpressionLiteral("'AFR'"))); EXPECT_EQ(1, stack.size()); ForgetOperator forgetOperator(variableMap,programMap); forgetOperator.apply(stack); EXPECT_EQ(0,variableMap.size()); }
void printVariableMap(std::ostream & o, const VariableMap & vars) { for ( VariableMap::const_iterator it = vars.begin(); it != vars.end();++it) { it->second.print(o); o << " "; } }
Variables::VariableUsage *Variables::find(unsigned int varid) { if (varid) { VariableMap::iterator i = _varUsage.find(varid); if (i != _varUsage.end()) return &i->second; } return 0; }
bool SUIPictureList::SetProperties( VariableMap args ) { for(VariableMap::iterator iter = args.begin(); iter != args.end(); iter++) { properties[iter->first] = iter->second; } return true; }
bool SScriptManager::SetSystemVariables( VariableMap setVars ) { for(VariableMap::iterator iter = setVars.begin(); iter != setVars.end(); iter++) { systemVariables[iter->first] = iter->second; } return true; }
bool SScriptManager::InitializeSystemVariables( VariableMap setVars ) { for(VariableMap::iterator iter = setVars.begin(); iter != setVars.end(); iter++) { if (systemVariables.find(iter->first) == systemVariables.end()) { systemVariables[iter->first] = iter->second;; } } return true; }
bool Unify::mgu(const Argument& arg1, const Argument& arg2, VariableMap& theta) { stack<pair<const Argument*, const Argument*> > S; S.push(pair<const Argument*, const Argument*>(&arg1, &arg2)); while(!S.empty()) { pair<const Argument*, const Argument*>& p = S.top(); S.pop(); const Argument* s = p.first; const Argument* t = p.second; VariableMap::iterator it; while(s->IsVariable() && (it = theta.find(s)) != theta.end()) { s = it->second; } while(t->IsVariable() && (it = theta.find(t)) != theta.end()) { t = it->second; } if(s->IsVariable() && t->IsVariable()) { if(s != t) theta[s] = t; } else if(s->IsVariable()) { theta[s] = t; } else if(t->IsVariable()) { theta[t] = s; } else if(s->value == t->value) { if(s->args.size() != t->args.size()) return false; for(size_t i = 0; i < s->args.size(); i++) { S.push(pair<const Argument*, const Argument*>(s->args[i], t->args[i])); } } else return false; } return true; }
VariableMap Argument::ConvertMapToArg(const Argument* arg, const Argument* con_to, const VariableMap& v_map) { VariableMap out; stack<pair<const Argument*, const Argument*>> s; s.emplace(arg, con_to); while(!s.empty()) { auto& tup = s.top(); const Argument* arg1 = get<0>(tup); const Argument* arg2 = get<1>(tup); s.pop(); if(arg1->t == Argument::Var) { out[arg2] = v_map.find(arg1)->second; continue; } for(size_t i = 0;i < arg->args.size();i++) { s.emplace(arg2->args[i], arg2->args[i]); } } return out; }
void Variables::addVar(const Token *name, VariableType type, const Scope *scope, bool write_) { if (name->varId() > 0) _varUsage.insert(std::make_pair(name->varId(), VariableUsage(name, type, scope, false, write_, false))); }
bool KeyboardLayout::_SubstituteVariables(BString& term, VariableMap& variables, BString& unknown) { while (true) { int32 index = term.FindFirst('$'); if (index < 0) break; // find variable name VariableMap::iterator iterator = variables.begin(); VariableMap::iterator best = variables.end(); int32 bestLength = 0; for (; iterator != variables.end(); iterator++) { const BString& name = iterator->first; if (!name.Compare(&term[index], name.Length()) && name.Length() > bestLength) { best = iterator; bestLength = name.Length(); } } if (best != variables.end()) { // got one, replace it term.Remove(index, bestLength); term.Insert(best->second.String(), index); } else { // variable has not been found unknown = &term[index]; int32 length = 1; while (isalpha(unknown[length])) { length++; } unknown.Truncate(length); return false; } } return true; }
bool Unify::EquateWithSubstitution(const Argument& arg1, const Argument& arg2, const VariableMap& v_map) { typedef pair<const Argument*, const Argument*> ArgPair; stack<ArgPair> S; S.push(ArgPair(&arg1, &arg2)); while(!S.empty()) { ArgPair& p = S.top(); S.pop(); const Argument* s = p.first; const Argument* t = p.second; if(s->IsVariable() && t->IsVariable()) { S.push(ArgPair(v_map.find(s)->second, v_map.find(t)->second)); } else if(s->IsVariable()) { S.push(ArgPair(v_map.find(s)->second, t)); } else if(t->IsVariable()) { S.push(ArgPair(s, v_map.find(t)->second)); } else if(s->value == t->value && s->args.size() == t->args.size()) { for(size_t i = 0; i < s->args.size(); i++) { S.push(ArgPair(s->args[i], t->args[i])); } } else return false; } return true; }
void Unify::SpecialMapCompression(VariableMap& v_map, const VariableMap& e_map, const VariableMap& o_v_map) { VariableMap out; for(VariableMap::const_iterator it = e_map.begin();it != e_map.end();it++) { const Argument* temp = it->second; if(temp->IsVariable()) { temp = v_map.find(temp)->second; } out[it->first] = temp; } for(VariableMap::const_iterator it = o_v_map.begin();it != o_v_map.end();it++) { out[it->first] = it->second; } v_map = out; }
Unify::VariableMap Unify::DecodeSubstitutions(const VariableMap& v_map, const Argument* question, const VariableMap& o_v_map, list<Argument*>& to_del) { VariableMap out = o_v_map; std::stack<const Argument*> S; S.push(question); while(!S.empty()) { const Argument* t = S.top(); S.pop(); if(t->IsVariable()) { const Argument* temp = t; while(temp->IsVariable()) { temp = v_map.find(temp)->second; } if(temp->HasVariables()) { Argument* temp2 = Unify::GetSubstitutedArgument(temp, v_map); to_del.push_back(temp2); out[t] = temp2; } else out[t] = temp; } else { for(size_t i = 0;i < t->args.size();i++) { S.push(t->args[i]); } } } return out; }
int main() { LogMessage::LogThreads(true); LogMessage::LogTimestamps(true); LogMessage::LogToDebug(LS_VERBOSE); xnbase::AsyncInet::Init(); Site site; Dictionary dict; { VariableMap vm; vm.insert(VariableMap::value_type(L"male", L"1")); vm.insert(VariableMap::value_type(L"female", L"2")); dict.Insert(L"sex", vm); } site.SetDict(dict); site.homepage = L"http://baidu.com"; { Action act; act.aid = 0; act.type = AT_REGISTER; act.url = L"http://www.baidu.com/"; act.method = HV_GET; act.restype = ART_NONE; site.AddAction(&act); } { Action act; act.aid = 1; // http://www.baidu.com/s?wd=sex act.url = L"http://www.baidu.com/s"; act.referrer = L"http://www.baidu.com/"; act.method = HV_GET; act.vars = L"?wd={key}"; act.type = AT_UTILITY; act.restype = ART_NONE; site.AddAction(&act); } // sites_.push_back(site); UserInfo userinfo_; userinfo_.insert(L"sex", L"male"); userinfo_.insert(L"pasw", L"strongpsw"); userinfo_.insert(L"mail", L"*****@*****.**"); userinfo_.insert(L"key", L"sex"); WindowPump pump; HWND h = pump.Create(0); ATLASSERT(h); WindowRunner wr(pump); foo bar; SiteTask * nrt = new SiteTask(&wr, site, userinfo_); nrt->SignalDone.connect(&bar, &foo::Quit); nrt->SignalActionResponse.connect(&bar, &foo::OnAction); nrt->Start(); Wait(); // avoid assert failed ::DestroyWindow(pump.Detach()); xnbase::AsyncInet::Release(); return 0; }
void fillVariableMap(VariableMap & vars) { vars.insert(std::pair<const char*, Variable>("y",Variable("y",0))); vars.insert(std::pair<const char*, Variable>("r",Variable("r",0))); vars.insert(std::pair<const char*, Variable>("p",Variable("p",0))); vars.insert(std::pair<const char*, Variable>("TrX",Variable("TrX",0))); vars.insert(std::pair<const char*, Variable>("TrY",Variable("TrY",0))); vars.insert(std::pair<const char*, Variable>("TrZ",Variable("TrZ",0))); vars.insert(std::pair<const char*, Variable>("Tpy",Variable("Tpy",0))); vars.insert(std::pair<const char*, Variable>("Tpp",Variable("Tpp",0))); vars.insert(std::pair<const char*, Variable>("j",Variable("j",0))); // Lens variables vars.insert(std::pair<const char*, Variable>("v",Variable("v",51))); vars.insert(std::pair<const char*, Variable>("a",Variable("a",0.0))); vars.insert(std::pair<const char*, Variable>("b",Variable("b",0.0))); vars.insert(std::pair<const char*, Variable>("c",Variable("c",0.0))); vars.insert(std::pair<const char*, Variable>("d",Variable("d",0))); vars.insert(std::pair<const char*, Variable>("e",Variable("e",0))); vars.insert(std::pair<const char*, Variable>("g",Variable("g",0))); vars.insert(std::pair<const char*, Variable>("t",Variable("t",0))); vars.insert(std::pair<const char*, Variable>("Va",Variable("Va",1))); vars.insert(std::pair<const char*, Variable>("Vb",Variable("Vb",0))); vars.insert(std::pair<const char*, Variable>("Vc",Variable("Vc",0))); vars.insert(std::pair<const char*, Variable>("Vd",Variable("Vd",0))); vars.insert(std::pair<const char*, Variable>("Vx",Variable("Vx",0))); vars.insert(std::pair<const char*, Variable>("Vy",Variable("Vy",0))); // exposure value and white balance vars.insert(std::pair<const char*, Variable>("Eev",Variable("Eev",0.0))); vars.insert(std::pair<const char*, Variable>("Er",Variable("Er",1.0))); vars.insert(std::pair<const char*, Variable>("Eb",Variable("Eb",1.0))); // emor response variables vars.insert(std::pair<const char*, Variable>("Ra",Variable("Ra",0.0))); vars.insert(std::pair<const char*, Variable>("Rb",Variable("Rb",0.0))); vars.insert(std::pair<const char*, Variable>("Rc",Variable("Rc",0.0))); vars.insert(std::pair<const char*, Variable>("Rd",Variable("Rd",0.0))); vars.insert(std::pair<const char*, Variable>("Re",Variable("Re",0.0))); }
std::string QueryMap::Apply(const VariableMap & vm, const Dictionary & dict , SiteCharset charset) { using namespace std; // split to vector // find value in dict stringstream ss; UrlQueryEscape uqe; vector<wstring> v; boost::split(v, text_, boost::is_any_of(L"&")); vector<pair<wstring, wstring> > w; int i; for (i=0; i<v.size(); ++i) { vector<wstring> eq; boost::split(eq, v[i], boost::is_any_of(L"=")); if (eq.size() == 2) w.push_back(make_pair(eq[0], eq[1])); } for (i=0; i<w.size(); ++i) { const wstring & key = w[i].first; wstring domain = w[i].second, val; // 1 find in vm, get value // 2 find in dict, get value's value if (boost::starts_with(domain, L"{") && boost::ends_with(domain, L"}") ) { domain = domain.substr(1); domain.resize(domain.size() - 1); VariableMap::const_iterator i_vm = vm.find(domain); ASSERT(i_vm != vm.end()); const VariableMap & vm_domain = dict.Find(domain); if (!vm_domain.empty()) { VariableMap::const_iterator j_vm = vm_domain.find(i_vm->second); ASSERT(j_vm != vm_domain.end()); if (j_vm != vm_domain.end()) val = j_vm->second; } else val = i_vm->second; } else val = domain; if (charset == SC_ANSI) ss << w2string(key) << "=" << uqe(w2string(val)) << "&"; else ss << string2utf8(key) << "=" << uqe(string2utf8(val)) << "&"; } std::string ret = ss.str(); // remove last & ret.resize(ret.size() - 1); return ret; }
void nsPluginInstance::threadMain(void) { DBG("nsPluginInstance::threadMain started\n"); DBG("URL: %s\n", _url.c_str()); PR_Lock(playerLock); // Initialize Gnash core library. DBG("Gnash core initialized.\n"); // Init logfile. gnash::RcInitFile& rcinit = gnash::RcInitFile::getDefaultInstance(); std::string logfilename = std::string("T:npgnash.log"); rcinit.setDebugLog(logfilename); gnash::LogFile& dbglogfile = gnash::LogFile::getDefaultInstance(); dbglogfile.setWriteDisk(true); dbglogfile.setVerbosity(GNASH_DEBUG_LEVEL); DBG("Gnash logging initialized: %s\n", logfilename.c_str()); // Init sound. //_sound_handler.reset(gnash::sound::create_sound_handler_sdl()); //gnash::set_sound_handler(_sound_handler.get()); DBG("Gnash sound initialized.\n"); // Init GUI. int old_mouse_x = 0, old_mouse_y = 0, old_mouse_buttons = 0; _render_handler = (gnash::render_handler *) gnash::create_render_handler_agg("BGR24"); // _memaddr = (unsigned char *) malloc(getMemSize()); static_cast<gnash::render_handler_agg_base *>(_render_handler)->init_buffer( getMemAddr(), getMemSize(), _width, _height, _rowstride); gnash::set_render_handler(_render_handler); DBG("Gnash GUI initialized: %ux%u\n", _width, _height); gnash::URL url(_url); VariableMap vars; gnash::URL::parse_querystring(url.querystring(), vars); for (VariableMap::iterator i = vars.begin(), ie = vars.end(); i != ie; i++) { _flashVars[i->first] = i->second; } gnash::set_base_url(url); gnash::movie_definition* md = NULL; try { md = gnash::createMovie(url, _url.c_str(), false); } catch (const gnash::GnashException& err) { md = NULL; } if (!md) { /* * N.B. Can't use the goto here, as C++ complains about "jump to * label 'done' from here crosses initialization of ..." a bunch * of things. Sigh. So, instead, I duplicate the cleanup code * here. TODO: Remove this duplication. */ // goto done; PR_Unlock(playerLock); DBG("Clean up Gnash.\n"); //gnash::clear(); DBG("nsPluginInstance::threadMain exiting\n"); return; } DBG("Movie created: %s\n", _url.c_str()); int movie_width = static_cast<int>(md->get_width_pixels()); int movie_height = static_cast<int>(md->get_height_pixels()); float movie_fps = md->get_frame_rate(); DBG("Movie dimensions: %ux%u (%.2f fps)\n", movie_width, movie_height, movie_fps); gnash::SystemClock clock; // use system clock here... gnash::movie_root& root = gnash::VM::init(*md, clock).getRoot(); DBG("Gnash VM initialized.\n"); // Register this plugin as listener for FsCommands from the core // (movie_root) #if 0 /* Commenting out for now as registerFSCommandCallback() has changed. */ root.registerFSCommandCallback(FSCommand_callback); #endif // Register a static function to handle ActionScript events such // as Mouse.hide, Stage.align etc. // root.registerEventCallback(&staticEventHandlingFunction); md->completeLoad(); DBG("Movie loaded.\n"); std::auto_ptr<gnash::Movie> mr(md->createMovie()); mr->setVariables(_flashVars); root.setRootMovie(mr.release()); //root.set_display_viewport(0, 0, _width, _height); root.set_background_alpha(1.0f); gnash::Movie* mi = root.getRootMovie(); DBG("Movie instance created.\n"); //ShowWindow(_window, SW_SHOW); IIntuition->ShowWindow(_window,NULL); for (;;) { // DBG("Inside main thread loop.\n"); if (_shutdown) { DBG("Main thread shutting down.\n"); break; } size_t cur_frame = mi->get_current_frame(); // DBG("Got current frame number: %d.\n", cur_frame); size_t tot_frames = mi->get_frame_count(); // DBG("Got total frame count: %d.\n", tot_frames); // DBG("Advancing one frame.\n"); root.advance(); // DBG("Going to next frame.\n"); root.goto_frame(cur_frame + 1); // DBG("Ensuring frame is loaded.\n"); //root.get_movie_definition()->ensure_frame_loaded(tot_frames); // DBG("Setting play state to PLAY.\n"); root.set_play_state(gnash::MovieClip::PLAYSTATE_PLAY); if (old_mouse_x != mouse_x || old_mouse_y != mouse_y) { old_mouse_x = mouse_x; old_mouse_y = mouse_y; //root.notify_mouse_moved(mouse_x, mouse_y); } if (old_mouse_buttons != mouse_buttons) { old_mouse_buttons = mouse_buttons; int mask = 1; //root.notify_mouse_clicked(mouse_buttons > 0, mask); } root.display(); #if 0 RECT rt; GetClientRect(_window, &rt); InvalidateRect(_window, &rt, FALSE); InvalidatedRanges ranges; ranges.setSnapFactor(1.3f); ranges.setSingleMode(false); root.add_invalidated_bounds(ranges, false); ranges.growBy(40.0f); ranges.combine_ranges(); if (!ranges.isNull()) { InvalidateRect(_window, &rt, FALSE); } root.display(); #endif // DBG("Unlocking playerLock mutex.\n"); PR_Unlock(playerLock); // DBG("Sleeping.\n"); PR_Sleep(PR_INTERVAL_MIN); // DBG("Acquiring playerLock mutex.\n"); PR_Lock(playerLock); } done: PR_Unlock(playerLock); DBG("Clean up Gnash.\n"); /* * N.B. As per server/impl.cpp:clear(), all of Gnash's threads aren't * guaranteed to be terminated by this, yet. Therefore, when Firefox * unloads npgnash.dll after calling NS_PluginShutdown(), and there are * still Gnash threads running, they will try and access memory that was * freed as part of the unloading of npgnash.dll, resulting in a process * abend. */ //gnash::clear(); DBG("nsPluginInstance::threadMain exiting\n"); }