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");
}
