/**
 * Creates the job-script for the sun grid engine.
 * @return 
 */
bool ClusterNetworkInSimEvaluationMethod::createJobScript() {
	TRACE("EvolutionManager::createJobScript");

	bool ok = true;
	mJobScriptContent = "";
	QTextStream script(&mJobScriptContent, QIODevice::WriteOnly | QIODevice::Truncate);

	QString applicationBinary = mApplication->get();
	applicationBinary = applicationBinary.replace("$HOME$", QDir::currentPath());
	QString applicationCall = mApplication->get() + " " + mApplicationFixedParameters->get();
	applicationCall = applicationCall.replace("$HOME$", QDir::currentPath());
	

	script << "#!" << mShellBinary->get().toStdString().c_str() << endl << endl;
	script << "TASK_ID=$1" << endl;
	script << "ARGUMENT_POSTFIX=" << endl << endl;
	script << "if [ \"${SGE_TASK_ID}\" != \"undefined\" -a \"x${SGE_TASK_ID}\" != \"x\" ]" << endl;
	script << "then TASK_ID=$SGE_TASK_ID" << endl;
	script << "else" << endl;
	script << "  if [ $# -eq 0 ]" << endl;
	script << "  then ARGUMENT_POSTFIX=\"-gui -test -toggle\"" << endl;
	script << "    TASK_ID=1" << endl;
	script << "  fi" << endl << endl;
	script << "fi" << endl;
	script << "EVAL_DIR=" << mEvalCurrentDirectory << "/$TASK_ID" << endl << endl;
	script << "if [ \"x$TASK_ID\" = \"x\" ]" << endl;
	script << "then exit 1" << endl;
	script << "fi" << endl << endl;
	script << "i=1" << endl;
	script << "MAX_RETRIES=10" << endl;
	script << "while [ ! -d $EVAL_DIR -a $i -le $MAX_RETRIES ]" << endl;
	script << "do" << endl;
	script << "#Wait for one second" << endl;
	script << "sleep 1" << endl;
	script << "i='expr $i + 1'" << endl;
	script << "done" << endl;
	script << "if [ ! -d $EVAL_DIR ]" << endl;
	script << "then exit 1" << endl;
	script << "fi" << endl << endl;
	script << "if [ $# -gt 0 ]" << endl;
	script << "then shift" << endl;
	script << "fi" << endl;
	script << "cd $EVAL_DIR" << endl;
	if(mIncludeBacktraceCodeInScripts->get()) {
		script << "ulimit -c unlimited" << endl;
	}
	script << applicationCall << mApplicationParameter << " -nogui -disableLogging $ARGUMENT_POSTFIX $* " << endl << endl;
	if(mIncludeBacktraceCodeInScripts->get()) {
		script << "#This segment creates a backtrace of a core dump when the application crashes." << endl;
		script << "if [ -f core ]" << endl;
		script << "then" << endl;
		script << " echo " << endl << " echo \"There was an error during execution.\"" << endl;
		script << " echo \"Creating backtrace file from dumped core.\"" << endl;
		script << " echo " << endl << " echo \"Please wait...\"" << endl << " echo" << endl << endl;
		script << " gdb " << applicationBinary << " --core core --batch --quiet -ex \"thread apply all bt full\" -ex \"quit\" >> backtrace.txt" << endl;
		script << " rm core;" << endl;
		script << "fi" << endl;
	}
	script << "exit 0" << endl;
	return ok;
}
Exemple #2
0
bool CompileFile(const std::string &inputFilePath, const std::string &outputFilePath) {
    bool result = false;
    std::string ofp;
    if (!outputFilePath.empty()) {
        ofp = outputFilePath;
    }
    else {
        ofp = RemoveFileExt(inputFilePath) + BYTE_CODE_FILE_EXT;
    }
    
    if (!JS_Init())
        return false;
    
    std::cout << "Input file: " << inputFilePath << std::endl;
    JSRuntime * runtime = JS_NewRuntime(10 * 1024 * 1024, JS_NO_HELPER_THREADS);

    JSContext *cx = JS_NewContext(runtime, 10240);
    JS_SetOptions(cx, JSOPTION_TYPE_INFERENCE);
    
    JS::CompartmentOptions options;
    options.setVersion(JSVERSION_LATEST);
    
    JS::RootedObject global(cx, JS_NewGlobalObject(cx, &GlobalClass, NULL, JS::DontFireOnNewGlobalHook, options));
    
    JS_SetErrorReporter(cx, &ReportError);
    
    {
        JSAutoCompartment ac(cx, global);
    
        if (JS_InitStandardClasses(cx, global)) {
            
            JS_InitReflect(cx, global);
            
            JS_FireOnNewGlobalObject(cx, global);
            
            JS::CompileOptions options(cx);
            options.setUTF8(true);
            options.setSourcePolicy(JS::CompileOptions::NO_SOURCE);
            std::cout << "Compiling ..." << std::endl;
            
            JS::RootedScript script(cx, JS::Compile(cx, global, options, inputFilePath.c_str()));
            
            if (script) {
                void *data = NULL;
                uint32_t length = 0;
                std::cout << "Encoding ..." << std::endl;
                data = JS_EncodeScript(cx, script, &length);
                
                if (data) {
                    if (WriteFile(ofp, data, length)) {
                        std::cout << "Done! " << "Output file: " << ofp << std::endl;
                        result = true;
                    }
                }
            }
            else
            {
                std::cout << "Compiled " << inputFilePath << " fails!" << std::endl;
            }
        }
        else
        {
            std::cout << "JS_InitStandardClasses failed! " << std::endl;
        }
    }
    if (cx) {
        JS_DestroyContext(cx);
        cx = NULL;
    }
    if (runtime) {
        JS_DestroyRuntime(runtime);
        runtime = NULL;
    }
    
    JS_ShutDown();
    
    return result;
}
Exemple #3
0
//! (koshi) don't delete commented things please, they might be need in the future and i'm lazy
void IBattle::GetBattleFromScript( bool loadmapmod )
{

	BattleOptions opts;
	std::stringstream ss (GetScript());
	LSL::TDF::PDataList script( LSL::TDF::ParseTDF(ss) );

	LSL::TDF::PDataList replayNode ( script->Find("GAME") );
	if ( replayNode.ok() ) {

		std::string modname = replayNode->GetString("GameType");
		std::string modhash = replayNode->GetString("ModHash");
		if ( !modhash.empty() ) modhash = STD_STRING(MakeHashUnsigned(TowxString(modhash)));
		SetHostMod( modname, modhash );

		//don't have the maphash, what to do?
		//ui download function works with mapname if hash is empty, so works for now
		std::string mapname    = replayNode->GetString("MapName");
		std::string maphash    = replayNode->GetString("MapHash");
		if ( !maphash.empty() ) maphash = STD_STRING(MakeHashUnsigned(TowxString(maphash)));
		SetHostMap( mapname, maphash );

//        opts.ip         = replayNode->GetString( _T("HostIP") );
//        opts.port       = replayNode->GetInt  ( _T("HostPort"), DEFAULT_EXTERNAL_UDP_SOURCE_PORT );
		opts.spectators = 0;

		int playernum = replayNode->GetInt("NumPlayers", 0);
		int usersnum = replayNode->GetInt("NumUsers", 0);
		if ( usersnum > 0 ) playernum = usersnum;
//        int allynum = replayNode->GetInt  ( _T("NumAllyTeams"), 1);
//        int teamnum = replayNode->GetInt  ( _T("NumTeams"), 1);



		LSL::StringVector sides;
		if ( loadmapmod ) {
			sides = LSL::usync().GetSides(modname);
		}

		IBattle::TeamVec parsed_teams = GetParsedTeamsVec();
		IBattle::AllyVec parsed_allies = GetParsedAlliesVec();

		//[PLAYERX] sections
		for ( int i = 0; i < playernum ; ++i ) {
			LSL::TDF::PDataList player ( replayNode->Find(stdprintf("PLAYER%d", i)));
			LSL::TDF::PDataList bot ( replayNode->Find(stdprintf("AI%d", i )));
			if ( player.ok() || bot.ok() ) {
				if ( bot.ok() ) player = bot;
				User user(player->GetString("Name"), boost::to_upper_copy(player->GetString("CountryCode")), 0);
				UserBattleStatus& status = user.BattleStatus();
				status.isfromdemo = true;
				status.spectator = player->GetInt("Spectator", 0 );
				opts.spectators += user.BattleStatus().spectator;
				status.team = player->GetInt("Team");
				if ( !status.spectator ) {
					PlayerJoinedTeam( status.team );
				}
				status.sync = true;
				status.ready = true;
				if ( status.spectator ) m_opts.spectators++;
				else {
					if ( !bot.ok() ) {
						if ( status.ready) m_players_ready++;
						if ( status.sync ) m_players_sync++;
						if ( status.sync && status.ready ) m_players_ok++;
					}
				}

				//! (koshi) changed this from ServerRankContainer to RankContainer
				user.Status().rank = (UserStatus::RankContainer)player->GetInt("Rank", -1 );

				if ( bot.ok() ) {
					status.aishortname = bot->GetString("ShortName");
					status.aiversion = bot->GetString("Version");
					int ownerindex = bot->GetInt("Host");
					LSL::TDF::PDataList aiowner (replayNode->Find(stdprintf("PLAYER%d", ownerindex)));
					if ( aiowner.ok() ) {
						status.owner = aiowner->GetString("Name");
					}
				}

				IBattle::TeamInfoContainer teaminfos = parsed_teams[user.BattleStatus().team];
				if ( !teaminfos.exist ) {
					LSL::TDF::PDataList team( replayNode->Find( stdprintf("TEAM%d", user.BattleStatus().team) ));
					if ( team.ok() ) {
						teaminfos.exist = true;
						teaminfos.TeamLeader = team->GetInt("TeamLeader", 0 );
						teaminfos.StartPosX = team->GetInt("StartPosX", -1 );
						teaminfos.StartPosY = team->GetInt("StartPosY", -1 );
						teaminfos.AllyTeam = team->GetInt("AllyTeam", 0 );
						teaminfos.RGBColor = GetColorFromFloatStrng(TowxString(team->GetString("RGBColor")));
						teaminfos.SideName = team->GetString("Side", "");
						teaminfos.Handicap = team->GetInt("Handicap", 0 );
						const int sidepos = LSL::Util::IndexInSequence(sides, teaminfos.SideName);
						teaminfos.SideNum = sidepos;
						parsed_teams[ user.BattleStatus().team ] = teaminfos;
					}
				}
				if ( teaminfos.exist ) {
					status.ally = teaminfos.AllyTeam;
					status.pos.x = teaminfos.StartPosX;
					status.pos.y = teaminfos.StartPosY;
					status.colour = teaminfos.RGBColor;
					status.handicap = teaminfos.Handicap;
					if ( !status.spectator ) {
						PlayerJoinedAlly( status.ally );
					}
					if ( teaminfos.SideNum >= 0 ) status.side = teaminfos.SideNum;
					IBattle::AllyInfoContainer allyinfos = parsed_allies[user.BattleStatus().ally];
					if ( !allyinfos.exist ) {
						LSL::TDF::PDataList ally( replayNode->Find(stdprintf("ALLYTEAM%d", user.BattleStatus().ally) ) );
						if ( ally.ok() ) {
							allyinfos.exist = true;
							allyinfos.NumAllies = ally->GetInt("NumAllies", 0 );
							allyinfos.StartRectLeft = ally->GetInt("StartRectLeft", 0 );
							allyinfos.StartRectTop = ally->GetInt("StartRectTop", 0 );
							allyinfos.StartRectRight = ally->GetInt("StartRectRight", 0 );
							allyinfos.StartRectBottom = ally->GetInt("StartRectBottom", 0 );
							parsed_allies[ user.BattleStatus().ally ] = allyinfos;
							AddStartRect( user.BattleStatus().ally, allyinfos.StartRectTop, allyinfos.StartRectTop, allyinfos.StartRectRight, allyinfos.StartRectBottom );
						}
					}
				}

				AddUserFromDemo( user );
			}

		}
		SetParsedTeamsVec( parsed_teams );
		SetParsedAlliesVec( parsed_allies );

		//MMoptions, this'll fail unless loading map/mod into wrapper first
		if ( loadmapmod ) {
			LoadScriptMMOpts("mapoptions", replayNode );
			LoadScriptMMOpts("modoptions", replayNode );
		}

		opts.maxplayers = playernum ;

	}
	SetBattleOptions( opts );
}
Exemple #4
0
Director::Director(const string& scriptName, unsigned int playerCount, bool overRide)
{
	isOverride = overRide;
	maximum = 0;
	ifstream infile(scriptName);
	if (!infile.is_open()) {
		string error = "[ERROR]:  Open file fail: " + scriptName;
		throw CodeException(FAIL_FILE_OPEN, error.c_str());
	}
	string currentLine;
	bool followingPL;
	int scriptCounter = 1;
	int lastPartDefCount = 0;

	regex re("^\\[scene\\][\\s]([\\w\\s]*)$");
	smatch sm;
	regex re_config("^[\\s]*(.*.txt)[\\s]*$");
	smatch sm_config;
	regex re_part("^[\\s]*([\\w]+)[\\s]+(.*.txt)[\\s]*$");
	smatch sm_part;

	while (getline(infile, currentLine)) {
		// scan for scene titles
		if (regex_match(currentLine, sm, re)) {
			titles.push_back(sm[1]);
			followingPL = false;
		}
		else {
			// scan for scene fragment config files
			if (regex_match(currentLine, sm_config, re_config)) {
				scripts[scriptCounter] = script();

				if (!followingPL) {
					followingPL = true;
				}
				else {
					titles.push_back(string());
				}
				ifstream configFile(sm_config[1]);
				int partDefinitionLineCount = 0;

				if (!configFile.is_open()) {
					string temp = sm_config[1];
					string error = "[ERROR]:  Open file fail: " + temp;
					throw CodeException(FAIL_FILE_OPEN, error.c_str());
				}
				
				string partDefinitionLine;
				while (getline(configFile, partDefinitionLine)) {
					// scan for part definition files
					if (regex_match(partDefinitionLine, sm_part, re_part)) {
						partDefinitionLineCount++;
						scripts[scriptCounter][sm_part[1]] = sm_part[2];
					}
				}

				scriptCounter++;
				if (!isOverride) {
					int consecutiveSum = partDefinitionLineCount + lastPartDefCount;
					lastPartDefCount = partDefinitionLineCount;
					maximum = maximum > consecutiveSum ? maximum : consecutiveSum;
				}
			}
		}
	}

	//finish reading script
	try {
		play = playPtr(new Play(titles, finished.get_future()));
	}
	catch (exception& e) {
		throw (BAD_ALLOCATION,e);
	}
	
	// check the override option
	if (!isOverride) {
		maximum = maximum > (int)playerCount ? maximum : (int)playerCount;
	}
	else {
		maximum = (int)playerCount;
	}
	
	for (int i = 0; i < maximum; i++) {
		try {
			players.push_back(playerPtr(new Player(*play)));
		}
		catch (exception& e) {
			throw (BAD_ALLOCATION, e);
		}
		
		players[i]->activate();
	}
}
Exemple #5
0
void RunScript(char * sname, int ObjID)
{
    CExoString script(sname);
    g_pVirtualMachine->RunScript(&script, ObjID, 1);
}
Exemple #6
0
unsigned CachedScript::scriptHash()
{
    if (m_decodingState == NeverDecoded)
        script();
    return m_scriptHash;
}
Exemple #7
0
void State::updateObject(dur elapsedTime) {
	// Store current map in case of switch
	GameMap* current_map = m_map;

	if(!enabled) {
		return;
	}

	assert(engine() != NULL);

	// Process input controller
	if(engine()->hardware()) {
		processInput();
	}

	if(!frameCounter) {
		return;
	} else {
		if(frameCounter > 0) {
			frameCounter--;
		}
	}

	// Run scripts
	if(script()->isRunning()) {
		script()->framestep();
	}

	// Update map
	if(current_map != NULL) {
		// Make the cameraman work
		if(cameraman) {
			cameraman->update(elapsedTime);
			current_map->setPosition(cameraman->getCameraPosition());
		}

		// Center map
		if(camTarget) {
			int targetX;
			int targetY;
			int camX;
			int camY;
			int curX;
			int curY;
			int localMaxCamSpeed = maxCamSpeed * elapsedTime;

			// Compute actual target coordinates
			if(camSecondaryTarget) {
				targetX = (camTarget->getX() + camSecondaryTarget->getX()) / 2;
				targetY = (camTarget->getY() + camSecondaryTarget->getY()) / 2;
			} else {
				targetX = camTarget->getX();
				targetY = camTarget->getY();
			}
			// Smooth object switching
			if(camSwitching) {
				camX = (-current_map->getX() * 3 + targetX) / 4;
				camY = (-current_map->getY() * 3 + targetY) / 4;
				curX = current_map->getX();
				curY = current_map->getY();
			} else {
				camX = targetX;
				camY = targetY;
				curX = camX;
				curY = camY;
			}
			// Limit camera speed
			if(camX + current_map->getX() > localMaxCamSpeed) {
				camX = -current_map->getX() + localMaxCamSpeed;
			} else if(-current_map->getX() - camX > localMaxCamSpeed) {
				camX = -current_map->getX() - localMaxCamSpeed;
			}
			if(camY + current_map->getY() > localMaxCamSpeed) {
				camY = -current_map->getY() + localMaxCamSpeed;
			} else if(-current_map->getY() - camY > localMaxCamSpeed) {
				camY = -current_map->getY() - localMaxCamSpeed;
			}

			// set camera position
			current_map->setPosition(-camX, -camY);
			// test if object switching is finished
			if(camSwitching) {
				if(abs(camX - targetX) < 5 && abs(camY - targetY) < 5) {
					camSwitching = false;
				} else if((curX == current_map->getX()) && (curY == current_map->getY())) {
					camSwitching = false;
				}
			}
		}

		// Update map
		current_map->update(elapsedTime);

		// Update mouse cursor
#ifdef MOUSE_SUPPORT
		if(mouseCursor) {
			Collidable* current_mouse = mouseCursor;
			current_mouse->update(elapsedTime);

			Collision c = current_mouse->hitBy(current_map);
			if(c.collided()) {
				current_map->signal(current_mouse, MOUSE_MOVE, 0);
			}

			if(m_hud) {
				c = current_mouse->hitBy(m_hud);
				if(c.collided()) {
					m_hud->signal(current_mouse, MOUSE_MOVE, 0);
				}
			}
		}
#endif
	}

	// Update hud
	if(m_hud != NULL) {
		m_hud->update(elapsedTime);
	}
}
Exemple #8
0
#include "parse.h"

wifstream Parse::infile = wifstream();

script Parse::s = script();

void Parse::init()
{
	infile.open(L"test\\start.txt");
	infile.imbue(locale(".936"));
}

void Parse::load_the_txt(wstring filename)
{
	infile.close();
	infile.open(filename.c_str());
	infile.imbue(locale(".936"));
}

script Parse::read_next_script()
{
	xiayuWString temp;
	temp = parse();
	if (temp == L"<drawbg>")
	{
		s.kind = PARSE::drawbg;
		temp = parse();
		s.file = temp;
		temp = parse();
		s.x = temp;
		temp = parse();
Exemple #9
0
bool osScriptInit(){
	#ifndef XSICONVERT
	script().run("osClock=os.clock");

	LuaType* w=script().add("os");

		script().add("folderExists",&luaFolderExists,w);
		script().add("fileExists",&luaFileExists,w);
		script().add("mkdir",&luaMkdir,w);
		script().add("folderContents",&luaFolderContents,w);
		script().add("exit",&luaExit,w);
		script().add("execute",&luaExecute,w);
		script().add("time",&luaTime,w);
		script().add("error",&luaError,w);
		script().add("name",&osName,w);
		script().add("version",&osVersion,w);

		#ifdef _WIN32
		OSVERSIONINFO m_osinfo;
		m_osinfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
		GetVersionEx(&m_osinfo);

		DWORD dwMinorVersion = m_osinfo.dwMinorVersion;
		DWORD dwMajorVersion = m_osinfo.dwMajorVersion;

		if(dwMajorVersion==5 && dwMinorVersion==1){
			osVersion="xp";
		}else if(dwMajorVersion==5 && dwMinorVersion==0){
			osVersion="2000";
		}else if(dwMajorVersion==4 && dwMinorVersion==0){
			osVersion="nt";
		}else if(dwMajorVersion==4 && dwMinorVersion==90){
			osVersion="me";
		}else if(dwMajorVersion==4 && dwMinorVersion==10){
			osVersion="98";
		}else if(dwMajorVersion==4 && dwMinorVersion==0){
			osVersion="95";
		}else{
			osVersion=String(dwMajorVersion)+String(".")+String(dwMinorVersion);
		}

		logs().main.write("OS:Windows");
		logs().main.write(String("MAJORVERSION:")+dwMajorVersion);
		logs().main.write(String("MINORVERSION:")+dwMinorVersion);
		logs().main.write("VERSION:"+osVersion);
	#elif LINUX
		logs().main.write("OS:Linux");
	#else
		SInt32 MacVersion;

		logs().main.write("OS:Mac");

		if (Gestalt(gestaltSystemVersion, &MacVersion) == noErr){
		
			if(MacVersion<0x1010){
				osVersion="10.0";
			}else if(MacVersion<0x1020){
				osVersion="10.1";
			}else if(MacVersion<0x1030){
				osVersion="10.2";
			}else if(MacVersion<0x1040){
				osVersion="10.3";
			}else if(MacVersion<0x1050){
				osVersion="10.4";
			}else if(MacVersion<0x1060){
				osVersion="10.5";
			}else if(MacVersion<0x1070){
				osVersion="10.6";
			}
		}
		
		logs().main.write("VERSION:"+osVersion);
	#endif
	
	script().run("os.clock=osClock");
	script().run("osClock=nil");
#endif

	return true;
}
Exemple #10
0
static int luaTrace(lua_State *L){

	Array<LuaType> args=script().getArgs(L);

	if(args.size()!=3){
		console().write("Trace Error: bad arguments");
		return 0;
	}

	FloatVector3d from;
	FloatVector3d velocity;
	FloatVector3d rad;

	if(args[0].type==SCRIPT_TABLE){
		if(args[0].children.size()==3){
			for(int i=0; i<3; i++){
				if(args[0].children[i].name=="x"){
					from.x=args[0].children[i].value.ds;
				}else if(args[0].children[i].name=="y"){
					from.y=args[0].children[i].value.ds;
				}else if(args[0].children[i].name=="z"){
					from.z=args[0].children[i].value.ds;
				}
			}
		}else{
			console().write("Trace Error: bad arguments, from wrong size");
			return 0;
		}
	}else{	
		console().write("Trace Error: bad arguments, from must be a vector3d");
		return 0;
	}

	if(args[1].type==SCRIPT_TABLE){
		if(args[1].children.size()==3){
			for(int i=0; i<3; i++){
				if(args[1].children[i].name=="x"){
					velocity.x=args[1].children[i].value.ds;
				}else if(args[1].children[i].name=="y"){
					velocity.y=args[1].children[i].value.ds;
				}else if(args[1].children[i].name=="z"){
					velocity.z=args[1].children[i].value.ds;
				}
			}
		}else{
			console().write("Trace Error: bad arguments, velocity vector wrong size");
			return 0;
		}
	}else{	
		console().write("Trace Error: bad arguments, velocity must be vector3d");
		return 0;
	}

	if(args[2].type==SCRIPT_TABLE){
		if(args[2].children.size()==3){
			for(int i=0; i<3; i++){
				if(args[2].children[i].name=="x"){
					rad.x=args[2].children[i].value.ds;
				}else if(args[2].children[i].name=="y"){
					rad.y=args[2].children[i].value.ds;
				}else if(args[2].children[i].name=="z"){
					rad.z=args[2].children[i].value.ds;
				}
			}
		}else{
			console().write("Trace Error: bad arguments, radius wrong number of arguments");
			return 0;
		}
	}else{	
		console().write("Trace Error: bad arguments, radius vector must be vector3d");
		return 0;
	}

	FloatVector3d oor=level->camera->ellipsoidRadius;
	level->camera->ellipsoidRadius=rad;
	FloatVector3d f=level->camera->GetPosition(from,velocity);
	level->camera->ellipsoidRadius=oor;

	script().resultTable(L);
	script().result(L,"x",f.x);
	script().result(L,"y",f.y);
	script().result(L,"z",f.z);

	return 1;
}
Exemple #11
0
void Model::load(const std::string & file) {
	LuaScript script(file);
	loadImage(script);
	loadTexturePack(script);
	setUp();
}
Exemple #12
0
int wdFindElementsByCss(WebDriver* driver, WebElement* element, const wchar_t* selector, ElementCollection** out)
{
	*out = NULL;
	if (!driver || !driver->ie) { return ENOSUCHDRIVER; }

	try {
		clock_t end = endAt(driver);
		int result = EUNHANDLEDERROR;

		do {
			// Call it
			std::wstring script(L"(function() { return function(){");
			for (int i = 0; SIZZLE[i]; i++) {
				script += SIZZLE[i];
				script += L"\n";
			}
			script += L"var root = arguments[1] ? arguments[1] : document.documentElement;";
			script += L"if (root['querySelectorAll']) { return root.querySelectorAll(arguments[0]); } ";
			script += L"var results = []; Sizzle(arguments[0], root, results);";
			script += L"return results;";
			script += L"};})();";

			// Call it
			ScriptArgs* args;
			result = wdNewScriptArgs(&args, 2);
			if (result != SUCCESS) {
				wdFreeScriptArgs(args);
				continue;
			}
			result = wdAddStringScriptArg(args, selector);
			if (result != SUCCESS) {
				wdFreeScriptArgs(args);
				continue;
			}

			result = wdAddElementScriptArg(args, element);
			if (result != SUCCESS) {
				wdFreeScriptArgs(args);
				continue;
			}

			ScriptResult* queryResult;
			result = wdExecuteScript(driver, script.c_str(), args, &queryResult);
			wdFreeScriptArgs(args);

			// And be done
			if (result != SUCCESS) {
				wdFreeScriptResult(queryResult);
				return result;
			}

			ElementCollection* elements = new ElementCollection();
			elements->elements = new std::vector<ElementWrapper*>();

			int length;
			result = wdGetArrayLengthScriptResult(driver, queryResult, &length);
			if (result != SUCCESS) {
				wdFreeScriptResult(queryResult);
				return result;
			}

			for (long i = 0; i < length; i++) {
				ScriptResult* getElemRes;
				wdGetArrayItemFromScriptResult(driver, queryResult, i, &getElemRes);

				WebElement* e;
				wdGetElementScriptResult(getElemRes, driver, &e);
				elements->elements->push_back(e->element);
				e->element = NULL;
				delete e;
			}
			wdFreeScriptResult(queryResult);

			*out = elements;
			return SUCCESS;
		} while (clock() < end);

		return result;
	} END_TRY;
}
Exemple #13
0
int wdFindElementByCss(WebDriver* driver, WebElement* element, const wchar_t* selector, WebElement** out)
{
	*out = NULL;
	if (!driver || !driver->ie) { return ENOSUCHDRIVER; }

	try {
		clock_t end = endAt(driver);
		int result = ENOSUCHELEMENT;

		do {
			std::wstring script(L"(function() { return function(){");
			for (int i = 0; SIZZLE[i]; i++) {
				script += SIZZLE[i];
				script += L"\n";
			}
			script += L"var root = arguments[1] ? arguments[1] : document.documentElement;";
			script += L"if (root['querySelector']) { return root.querySelector(arguments[0]); } ";
			script += L"var results = []; Sizzle(arguments[0], root, results);";
			script += L"return results.length > 0 ? results[0] : null;";
			script += L"};})();";

			// Call it
			ScriptArgs* args;
			result = wdNewScriptArgs(&args, 2);
			if (result != SUCCESS) {
				wdFreeScriptArgs(args);
				continue;
			}
			result = wdAddStringScriptArg(args, selector);
			if (result != SUCCESS) {
				wdFreeScriptArgs(args);
				continue;
			}
			if (element) {
				result = wdAddElementScriptArg(args, element);
			}
			if (result != SUCCESS) {
				wdFreeScriptArgs(args);
				continue;
			}

			ScriptResult* queryResult;
			result = wdExecuteScript(driver, script.c_str(), args, &queryResult);
			wdFreeScriptArgs(args);

			// And be done
			if (result == SUCCESS) {
				int type = 0;
				result = wdGetScriptResultType(driver, queryResult, &type);
				if (type != TYPE_EMPTY) {
					result = wdGetElementScriptResult(queryResult, driver, out);
				} else {
					result = ENOSUCHELEMENT;
					wdFreeScriptResult(queryResult);
					continue;
				}
			}
			wdFreeScriptResult(queryResult);

			return result;
		} while (clock() < end);

		return result;
	} END_TRY;
}
JSObject *
GlobalObject::initFunctionAndObjectClasses(JSContext *cx)
{
    Rooted<GlobalObject*> self(cx, this);

    JS_THREADSAFE_ASSERT(cx->compartment != cx->runtime->atomsCompartment);
    JS_ASSERT(isNative());

    /*
     * Calling a function from a cleared global triggers this (yeah, I know).
     * Uncomment this once bug 470510 is fixed (if that bug doesn't remove
     * isCleared entirely).
     */
    // JS_ASSERT(!isCleared());

    /* If cx has no global object, make this the global object. */
    if (!cx->globalObject)
        JS_SetGlobalObject(cx, self);

    RootedObject objectProto(cx);

    /*
     * Create |Object.prototype| first, mirroring CreateBlankProto but for the
     * prototype of the created object.
     */
    objectProto = NewObjectWithGivenProto(cx, &ObjectClass, NULL, self);
    if (!objectProto || !objectProto->setSingletonType(cx))
        return NULL;

    /*
     * The default 'new' type of Object.prototype is required by type inference
     * to have unknown properties, to simplify handling of e.g. heterogenous
     * objects in JSON and script literals.
     */
    if (!objectProto->setNewTypeUnknown(cx))
        return NULL;

    /* Create |Function.prototype| next so we can create other functions. */
    RootedFunction functionProto(cx);
    {
        JSObject *functionProto_ = NewObjectWithGivenProto(cx, &FunctionClass, objectProto, self);
        if (!functionProto_)
            return NULL;
        functionProto = functionProto_->toFunction();

        /*
         * Bizarrely, |Function.prototype| must be an interpreted function, so
         * give it the guts to be one.
         */
        JSObject *proto = js_NewFunction(cx, functionProto,
                                         NULL, 0, JSFUN_INTERPRETED, self, NULL);
        if (!proto)
            return NULL;
        JS_ASSERT(proto == functionProto);
        functionProto->flags |= JSFUN_PROTOTYPE;

        const char *rawSource = "() {\n}";
        size_t sourceLen = strlen(rawSource);
        jschar *source = InflateString(cx, rawSource, &sourceLen);
        if (!source)
            return NULL;
        ScriptSource *ss = cx->new_<ScriptSource>();
        if (!ss) {
            cx->free_(source);
            return NULL;
        }
        ScriptSourceHolder ssh(cx->runtime, ss);
        ss->setSource(source, sourceLen);

        CompileOptions options(cx);
        options.setNoScriptRval(true)
               .setVersion(JSVERSION_DEFAULT);
        Rooted<JSScript*> script(cx, JSScript::Create(cx,
                                                      /* enclosingScope = */ NullPtr(),
                                                      /* savedCallerFun = */ false,
                                                      options,
                                                      /* staticLevel = */ 0,
                                                      ss,
                                                      0,
                                                      ss->length()));
        if (!script || !JSScript::fullyInitTrivial(cx, script))
            return NULL;

        functionProto->initScript(script);
        functionProto->getType(cx)->interpretedFunction = functionProto;
        script->setFunction(functionProto);

        if (!functionProto->setSingletonType(cx))
            return NULL;

        /*
         * The default 'new' type of Function.prototype is required by type
         * inference to have unknown properties, to simplify handling of e.g.
         * CloneFunctionObject.
         */
        if (!functionProto->setNewTypeUnknown(cx))
            return NULL;
    }

    /* Create the Object function now that we have a [[Prototype]] for it. */
    RootedFunction objectCtor(cx);
    {
        JSObject *ctor = NewObjectWithGivenProto(cx, &FunctionClass, functionProto, self);
        if (!ctor)
            return NULL;
        objectCtor = js_NewFunction(cx, ctor, js_Object, 1, JSFUN_CONSTRUCTOR, self,
                                    CLASS_NAME(cx, Object));
        if (!objectCtor)
            return NULL;
    }

    /*
     * Install |Object| and |Object.prototype| for the benefit of subsequent
     * code that looks for them.
     */
    self->setObjectClassDetails(objectCtor, objectProto);

    /* Create |Function| so it and |Function.prototype| can be installed. */
    RootedFunction functionCtor(cx);
    {
        // Note that ctor is rooted purely for the JS_ASSERT at the end
        RootedObject ctor(cx, NewObjectWithGivenProto(cx, &FunctionClass, functionProto, self));
        if (!ctor)
            return NULL;
        functionCtor = js_NewFunction(cx, ctor, Function, 1, JSFUN_CONSTRUCTOR, self,
                                      CLASS_NAME(cx, Function));
        if (!functionCtor)
            return NULL;
        JS_ASSERT(ctor == functionCtor);
    }

    /*
     * Install |Function| and |Function.prototype| so that we can freely create
     * functions and objects without special effort.
     */
    self->setFunctionClassDetails(functionCtor, functionProto);

    /*
     * The hard part's done: now go back and add all the properties these
     * primordial values have.
     */
    if (!LinkConstructorAndPrototype(cx, objectCtor, objectProto) ||
        !DefinePropertiesAndBrand(cx, objectProto, NULL, object_methods))
    {
        return NULL;
    }

    /*
     * Add an Object.prototype.__proto__ accessor property to implement that
     * extension (if it's actually enabled).  Cache the getter for this
     * function so that cross-compartment [[Prototype]]-getting is implemented
     * in one place.
     */
    Rooted<JSFunction*> getter(cx, js_NewFunction(cx, NULL, ProtoGetter, 0, 0, self, NULL));
    if (!getter)
        return NULL;
#if JS_HAS_OBJ_PROTO_PROP
    Rooted<JSFunction*> setter(cx, js_NewFunction(cx, NULL, ProtoSetter, 0, 0, self, NULL));
    if (!setter)
        return NULL;
    RootedValue undefinedValue(cx, UndefinedValue());
    if (!objectProto->defineProperty(cx, cx->runtime->atomState.protoAtom, undefinedValue,
                                     JS_DATA_TO_FUNC_PTR(PropertyOp, getter.get()),
                                     JS_DATA_TO_FUNC_PTR(StrictPropertyOp, setter.get()),
                                     JSPROP_GETTER | JSPROP_SETTER | JSPROP_SHARED))
    {
        return NULL;
    }
#endif /* JS_HAS_OBJ_PROTO_PROP */
    self->setProtoGetter(getter);


    if (!DefinePropertiesAndBrand(cx, objectCtor, NULL, object_static_methods) ||
        !LinkConstructorAndPrototype(cx, functionCtor, functionProto) ||
        !DefinePropertiesAndBrand(cx, functionProto, NULL, function_methods) ||
        !DefinePropertiesAndBrand(cx, functionCtor, NULL, NULL))
    {
        return NULL;
    }

    /* Add the global Function and Object properties now. */
    jsid objectId = NameToId(CLASS_NAME(cx, Object));
    if (!self->addDataProperty(cx, objectId, JSProto_Object + JSProto_LIMIT * 2, 0))
        return NULL;
    jsid functionId = NameToId(CLASS_NAME(cx, Function));
    if (!self->addDataProperty(cx, functionId, JSProto_Function + JSProto_LIMIT * 2, 0))
        return NULL;

    /* Heavy lifting done, but lingering tasks remain. */

    /* ES5 15.1.2.1. */
    RootedId id(cx, NameToId(cx->runtime->atomState.evalAtom));
    JSObject *evalobj = js_DefineFunction(cx, self, id, IndirectEval, 1, JSFUN_STUB_GSOPS);
    if (!evalobj)
        return NULL;
    self->setOriginalEval(evalobj);

    /* ES5 13.2.3: Construct the unique [[ThrowTypeError]] function object. */
    RootedFunction throwTypeError(cx, js_NewFunction(cx, NULL, ThrowTypeError, 0, 0, self, NULL));
    if (!throwTypeError)
        return NULL;
    if (!throwTypeError->preventExtensions(cx))
        return NULL;
    self->setThrowTypeError(throwTypeError);

    RootedObject intrinsicsHolder(cx, JS_NewObject(cx, NULL, NULL, self));
    if (!intrinsicsHolder)
        return NULL;
    self->setIntrinsicsHolder(intrinsicsHolder);
    if (!JS_DefineFunctions(cx, intrinsicsHolder, intrinsic_functions))
        return NULL;

    /*
     * The global object should have |Object.prototype| as its [[Prototype]].
     * Eventually we'd like to have standard classes be there from the start,
     * and thus we would know we were always setting what had previously been a
     * null [[Prototype]], but right now some code assumes it can set the
     * [[Prototype]] before standard classes have been initialized.  For now,
     * only set the [[Prototype]] if it hasn't already been set.
     */
    if (self->shouldSplicePrototype(cx) && !self->splicePrototype(cx, objectProto))
        return NULL;

    /*
     * Notify any debuggers about the creation of the script for
     * |Function.prototype| -- after all initialization, for simplicity.
     */
    js_CallNewScriptHook(cx, functionProto->script(), functionProto);
    return functionProto;
}
Exemple #15
0
HRESULT
ComObject::invoke (const Method &method,
                   bool isProperty,
                   REFIID /*riid*/,
                   LCID /*lcid*/,
                   WORD wFlags,
                   DISPPARAMS *pDispParams,
                   VARIANT *pReturnValue,
                   EXCEPINFO *pExcepInfo,
                   UINT *pArgErr)
{

    HRESULT hresult;

    try {
        // Construct Tcl script to invoke operation on the servant.
        TclObject script(m_servant);

        // Get the method or property to invoke on the servant.
        std::string operation;
        if ((wFlags & DISPATCH_PROPERTYGET) != 0 && isProperty) {
            operation = getPrefix + method.name();

        } else if (wFlags & (DISPATCH_PROPERTYPUT | DISPATCH_PROPERTYPUTREF)) {
            operation = setPrefix + method.name();

        } else if (wFlags & DISPATCH_METHOD) {
            operation = method.name();

        } else {
            return DISP_E_MEMBERNOTFOUND;
        }

        script.lappend(
            Tcl_NewStringObj(const_cast<char *>(operation.c_str()), -1));

        // Set the argument error pointer in case we need to use it.
        UINT argErr;
        if (pArgErr == 0) {
            pArgErr = &argErr;
        }

        // Convert arguments to Tcl values.
        // TODO: Should handle named arguments differently than positional
        // arguments.
        const Method::Parameters &parameters = method.parameters();

        int argIndex = pDispParams->cArgs - 1;
        Method::Parameters::const_iterator pParam;
        for (pParam = parameters.begin(); pParam != parameters.end();
         ++pParam, --argIndex) {
            // Append argument value.
            VARIANT *pArg = &(pDispParams->rgvarg[argIndex]);
            try {
                script.lappend(getArgument(pArg, *pParam));
            }
            catch (_com_error &) {
                *pArgErr = argIndex;
                throw;
            }
        }
        
        if (wFlags & (DISPATCH_PROPERTYPUT | DISPATCH_PROPERTYPUTREF)) {
            VARIANT *pArg = &(pDispParams->rgvarg[argIndex]);
            try {
                TclObject value(pArg, method.type(), m_interp);
                script.lappend(value);
            }
            catch (_com_error &) {
                *pArgErr = argIndex;
                throw;
            }
        }

        // Execute the Tcl script.
        TclObject result;
        int completionCode = eval(script, &result);
        if (completionCode == TCL_OK) {
            hresult = S_OK;
        } else {
            if (m_isSink) {
                Tcl_BackgroundError(m_interp);
            }

            hresult = hresultFromErrorCode();
            if (FAILED(hresult)) {
                fillExcepInfo(
                    pExcepInfo,
                    hresult,
                    m_servant.c_str(),
                    result.c_str());
                hresult = DISP_E_EXCEPTION;
            }
        }

        // Copy values to out arguments.
        argIndex = pDispParams->cArgs - 1;
        for (pParam = parameters.begin(); pParam != parameters.end();
         ++pParam, --argIndex) {
            VARIANT *pArg = &(pDispParams->rgvarg[argIndex]);
            if ((pParam->flags() & PARAMFLAG_FOUT) && (V_VT(pArg) & VT_BYREF)) {
                // Get name of Tcl variable that holds out value.
                TclObject varName = getOutVariableName(*pParam);

                // Copy variable value to out argument.
                TclObject value;
                if (getVariable(varName, value) == TCL_OK) {
                    putOutVariant(m_interp, pArg, value, pParam->type());
                }
            }
        }

        // Convert return value.
        if (pReturnValue != 0 && method.type().vartype() != VT_VOID) {
            // Must increment reference count of interface pointers returned
            // from methods.
            result.toVariant(pReturnValue, method.type(), m_interp, true);
        }
    }
    catch (_com_error &e) {
        fillExcepInfo(pExcepInfo, e.Error(), m_servant.c_str(), 0);
        hresult = DISP_E_EXCEPTION;
    }
    return hresult;
}
int main()
{
	sf::RenderWindow window(sf::VideoMode(800, 640), "Scripting");

	Lua lua;
	auto global = lua.GetGlobalEnvironment();
	lua.LoadStandardLibraries();

	std::ifstream file("Entity.lua");
	std::string script((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());

	file.close();

	auto keyPressed = lua.CreateFunction<bool(int)>([&](int key)
	{
		return sf::Keyboard::isKeyPressed(sf::Keyboard::Key(key));
	});

	global.Set("keyPressed", keyPressed);

	global.Set("A", (int)sf::Keyboard::A);
	global.Set("D", (int)sf::Keyboard::D);
	global.Set("W", (int)sf::Keyboard::W);
	global.Set("S", (int)sf::Keyboard::S);

	global.Set("Up", (int)sf::Keyboard::Up);
	global.Set("Down", (int)sf::Keyboard::Down);
	global.Set("Left", (int)sf::Keyboard::Left);
	global.Set("Right", (int)sf::Keyboard::Right);

	auto entity = Entity::createEntity(lua, "Entity_01");
	global.Set("entity", entity);

	lua.RunScript(script);

	auto tick = global.Get<LuaFunction<void(float)>>("tick");
	auto init = global.Get<LuaFunction<void()>>("init");
	
	init.Invoke();

	sf::Clock deltaClock;
	while (window.isOpen())
	{
		sf::Event evt;
		while (window.pollEvent(evt))
		{
			if (evt.type == sf::Event::Closed || evt.key.code == sf::Keyboard::Escape)
			{
				window.close();
			}
			if (evt.key.code == sf::Keyboard::R)
			{
				file.open("Entity.lua");
				script = std::string((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());

				lua.RunScript(script);

				tick = global.Get<LuaFunction<void(float)>>("tick");

				file.close();
			}
		}


		float dt = deltaClock.restart().asSeconds();

		tick.Invoke(dt);

		window.clear();
		
		window.draw(*entity.GetPointer());

		window.display();
	}

	return 0;
}
Exemple #17
0
bool CWebPageDef::WebPageUpdate( bool fNow, LPCTSTR pszDstName, CTextConsole * pSrc )
{
	ADDTOCALLSTACK("CWebPageDef::WebPageUpdate");
	// Generate the status web pages.
	// Read in the Base status page "*STATUSBASE.HTM"
	// Filter the XML type tags.
	// Output the status page "*.HTM"
	// Server name
	// Server email
	// Number of clients, items, NPC's

	if ( ! fNow )
	{
		if ( m_iUpdatePeriod <= 0 )
			return false;
		if ( CServTime::GetCurrentTime() < m_timeNextUpdate )
			return true;	// should stilll be valid
	}

	ASSERT(pSrc);
	m_timeNextUpdate = CServTime::GetCurrentTime() + m_iUpdatePeriod;
	if ( pszDstName == NULL )
	{
		pszDstName = m_sDstFilePath;
	}

	if ( m_type != WEBPAGE_TEMPLATE ||
		*pszDstName == '\0' ||
		m_sSrcFilePath.IsEmpty())
		return false;

	CScript FileRead;
	if ( ! FileRead.Open( m_sSrcFilePath, OF_READ|OF_TEXT|OF_DEFAULTMODE ))
	{
		return false;
	}

	CScriptFileContext context( &FileRead );	// set this as the context.

	CFileConsole FileOut;
	if ( ! FileOut.m_FileOut.Open( pszDstName, OF_WRITE|OF_TEXT ))
	{
		DEBUG_ERR(( "Can't open web page output '%s'\n", static_cast<LPCTSTR>(pszDstName) ));
		return false;
	}

	bool fScriptMode = false;

	while ( FileRead.ReadTextLine( false ))
	{
		TCHAR *pszTmp = Str_GetTemp();
		strcpy( pszTmp, FileRead.GetKey());

		TCHAR * pszHead = strstr( pszTmp, "<script language=\"Sphere\">" );
		if ( pszHead != NULL )
		{
			// Deal with the stuff preceding the scripts.
			*pszHead = '\0';
			pszHead += 26;
			ParseText( pszTmp, pSrc, 1 );
			FileOut.SysMessage( pszTmp );
			fScriptMode = true;
		}
		else
		{
			pszHead = pszTmp;
		}

		// Look for the end of </script>
		if ( fScriptMode )
		{
			GETNONWHITESPACE(pszHead);
			TCHAR * pszFormat = pszHead;

			pszHead = strstr( pszFormat, "</script>" );
			if ( pszHead != NULL )
			{
				*pszHead = '\0';
				pszHead += 9;
				fScriptMode = false;
			}

			if ( pszFormat[0] != '\0' )
			{
				// Allow if/then logic ??? OnTriggerRun( CScript &s, TRIGRUN_SINGLE_EXEC, &FileOut )
				CScript script( pszFormat );
				if ( ! r_Verb( script, &FileOut ))
				{
					DEBUG_ERR(( "Web page source format error '%s'\n", static_cast<LPCTSTR>(pszTmp) ));
					continue;
				}
			}

			if ( fScriptMode )
				continue;
		}

		// Look for stuff we can displace here. %STUFF%
		ParseText( pszHead, pSrc, 1 );
		FileOut.SysMessage( pszHead );
	}

	return( true );
}
Exemple #18
0
bool executeCommand(const UINT cmd, const csWStringList& files)
{
  const csWString parallel  = regReadParallel();
  const DWORD parallelCount = regReadParallelCount();
  const bool    hasParallel = !parallel.empty()  &&  parallelCount > 1;

  const DWORD flags      = regReadFlags();
  const bool  isBatch    = testFlags(flags, CMD_FLAG_BATCH);
  const bool  isParallel = testFlags(flags, CMD_FLAG_PARALLEL)  &&  hasParallel;
  const bool  isUnc      = testFlags(flags, CMD_FLAG_UNC)  &&  cmd != Cmd_List;
  const bool  isUnix     = testFlags(flags, CMD_FLAG_UNIX);

  const csWString  scriptPath = regReadScriptsPath();
  const csWStringList scripts = regReadScripts();

  if(        cmd == Cmd_List                ||
             cmd == Cmd_ListWithPath        ||
             cmd == Cmd_ListWithPathTabular ) {
    int size = 0;
    for(csWStringList::const_iterator it = files.begin(); it != files.end(); it++) {
      wchar_t *uncName = 0;
      if( isUnc  &&  (uncName = resolveUNC(it->c_str())) != 0 ) {
        size += lenFN(csWString(uncName), cmd);
        delete[] uncName;
      } else {
        size += lenFN(*it, cmd);
      }
    }

    wchar_t *text = new wchar_t[size+1];
    if( text == 0 ) {
      return false;
    }

    int pos = 0;
    for(csWStringList::const_iterator it = files.begin(); it != files.end(); it++) {
      wchar_t *uncName = 0;
      if( isUnc  &&  (uncName = resolveUNC(it->c_str())) != 0 ) {
        catFN(text, pos, csWString(uncName), cmd);
        delete[] uncName;
      } else {
        catFN(text, pos, *it, cmd);
      }
    }
    text[size] = L'\0';

    if( files.size() == 1 ) {
      // Overwrite trailing <CR><LF>
      text[size-1] = text[size-2] = L'\0';
    }

    if( isUnix ) {
      replace(text, size, L'\\', L'/');
    }

    setClipboardText(text);
    delete[] text;

    return true;

  } else if( cmd == Cmd_CreateSymbolicLink ) {

    csWString symLink;

    IFileSaveDialog *saveDialog = NULL;
    HRESULT hr = CoCreateInstance(CLSID_FileSaveDialog, NULL, CLSCTX_INPROC_SERVER,
                                  IID_IFileSaveDialog, (LPVOID*)&saveDialog);
    if( hr == S_OK ) {
      saveDialog->SetTitle(L"Create symbolic link");

      const int index = files.front().lastIndexOf(L'\\');
      if( index >= 0 ) {
        const csWString path = files.front().mid(0, index);
        const csWString name = files.front().mid(index+1);

        PIDLIST_ABSOLUTE pidl = NULL;
        SHParseDisplayName(path.c_str(), NULL, &pidl, 0, NULL);
        if( pidl != NULL ) {
          IShellItem *item = NULL;
          SHCreateItemFromIDList(pidl, IID_IShellItem, (LPVOID*)&item);
          if( item != NULL ) {
            saveDialog->SetFolder(item);
            item->Release();
          }
          CoTaskMemFree(pidl);
        }

        saveDialog->SetFileName(name.c_str());
      }

      const COMDLG_FILTERSPEC filterSpec = {
        L"All files", L"*.*"
      };
      saveDialog->SetFileTypes(1, &filterSpec);

      const FILEOPENDIALOGOPTIONS opts
          = FOS_OVERWRITEPROMPT
          | FOS_FORCEFILESYSTEM
          | FOS_PATHMUSTEXIST
          | FOS_CREATEPROMPT
          | FOS_NOREADONLYRETURN
          | FOS_NODEREFERENCELINKS
          | FOS_DONTADDTORECENT;
      saveDialog->SetOptions(opts);

      if( saveDialog->Show(NULL) == S_OK ) {
        IShellItem *item = NULL;
        if( saveDialog->GetResult(&item) == S_OK ) {
          wchar_t *filename = NULL;
          if( item->GetDisplayName(SIGDN_FILESYSPATH, &filename) == S_OK ) {
            symLink = filename;
            CoTaskMemFree(filename);
          }

          item->Release();
        }
      }

      saveDialog->Release();
    }

    if( !symLink.empty() ) {
      if( csFileExists(symLink.c_str()) ) {
        MessageBoxW(NULL, L"Symbolic link target already exists!",
                    L"Error", MB_OK | MB_ICONERROR);
        return false;
      }

      const DWORD linkFlags = csIsDirectory(files.front().c_str())
          ? SYMBOLIC_LINK_FLAG_DIRECTORY
          : 0;

      if( CreateSymbolicLinkW(symLink.c_str(),
                              files.front().c_str(),
                              linkFlags) == 0 ) {
        const DWORD lastError = GetLastError();

        csWString msg(L"ERROR(0x");
        msg += csWString::number(lastError, 16);
        msg += L"): ";
        msg += formatError(lastError);

        MessageBoxW(NULL, msg.c_str(),
                    L"Error", MB_OK | MB_ICONERROR);
        return false;
      }
    }

    return true;

  } else if( cmd == Cmd_CheckBatchProcessing ) {
    regWriteFlags(flags ^ CMD_FLAG_BATCH);
    return true;

  } else if( cmd == Cmd_CheckParallelExecution ) {
    regWriteFlags(flags ^ CMD_FLAG_PARALLEL);
    return true;

  } else if( cmd == Cmd_CheckResolveUncPaths ) {
    regWriteFlags(flags ^ CMD_FLAG_UNC);
    return true;

  } else if( cmd == Cmd_CheckUnixPathSeparators ) {
    regWriteFlags(flags ^ CMD_FLAG_UNIX);
    return true;

  } else if( Cmd_ExecuteScripts <= cmd  &&  cmd < Cmd_ExecuteScripts+scripts.size() ) {
    csWString script(scriptPath + L"\\");
    UINT i = 0;
    for(csWStringList::const_iterator it = scripts.begin(); it != scripts.end(); it++) {
      if( i == cmd-Cmd_ExecuteScripts ) {
        script += *it;
        break;
      }
      i++;
    }

    if( isParallel ) {
      csWStringList args(files);
      args.push_front(script);
      args.push_front(csWString::number(parallelCount));
      ShellExecuteW(NULL, L"open", parallel.c_str(), joinFileNames(args).c_str(),
                    NULL, SW_SHOWNORMAL);
    } else { // DO NOT use parallelizer
      if( isBatch ) {
        const csWString args = joinFileNames(files);
        ShellExecuteW(NULL, L"open", script.c_str(), args.c_str(), NULL, SW_SHOWNORMAL);
      } else { // NO batch processing
        for(csWStringList::const_iterator it = files.begin();
            it != files.end(); it++) {
          ShellExecuteW(NULL, L"open", script.c_str(), quoteFileName(*it).c_str(),
                        NULL, SW_SHOWNORMAL);
        }
      }
    }
    return true;

  }

  return false;
}
Exemple #19
0
void EnvSettingsPrivate::unset()
{
    QFile script(QStandardPaths::writableLocation(QStandardPaths::ConfigLocation) + "/plasma-workspace/env/kimtoy-env.sh");
    script.remove();
}
Exemple #20
0
bool WebView::popupSpellMenu(QContextMenuEvent *event)
{
    // return false if not handled
    if (!ReKonfig::automaticSpellChecking())
        return false;

    QWebElement element(m_contextMenuHitResult.element());
    if (element.isNull())
        return false;

    int selStart = element.evaluateJavaScript("this.selectionStart").toInt();
    int selEnd = element.evaluateJavaScript("this.selectionEnd").toInt();
    if (selEnd != selStart)
        return false; // selection, handle normally

    // No selection - Spell Checking only
    // Get word
    QString text = element.evaluateJavaScript("this.value").toString();
    QRegExp ws("\\b");
    int s1 = text.lastIndexOf(ws, selStart);
    int s2 = text.indexOf(ws, selStart);
    QString word = text.mid(s1, s2 - s1).trimmed();

    // sanity check
    if (word.isEmpty())
        return false;

    kDebug() << s1 << ":" << s2 << ":" << word << ":";
    Sonnet::Speller spellor;
    if (spellor.isCorrect(word))
        return false; // no need to popup spell menu

    // find alternates
    QStringList words = spellor.suggest(word);

    // Construct popup menu
    QMenu mnu(this);

    // Add alternates
    if (words.isEmpty())
    {
        QAction *a = mnu.addAction(i18n("No suggestions for %1", word));
        a->setEnabled(false);
    }
    else
    {
        QStringListIterator it(words);
        while (it.hasNext())
        {
            QString w = it.next();
            QAction *aWord = mnu.addAction(w);
            aWord->setData(w);
        }
    }

    // Add dictionary options
    mnu.addSeparator();
    QAction *aIgnore = mnu.addAction(i18n("Ignore"));
    QAction *aAddToDict = mnu.addAction(i18n("Add to Dictionary"));

    QAction *aSpellChoice = mnu.exec(event->globalPos());
    if (aSpellChoice)
    {
        if (aSpellChoice == aAddToDict)
            spellor.addToPersonal(word);
        else if (aSpellChoice == aIgnore)
        {
            // Ignore :)
        }
        else
        {
            // Choose a replacement word
            QString w = aSpellChoice->data().toString();
            if (!w.isEmpty())
            {
                // replace word
                QString script(QL1S("this.value=this.value.substring(0,"));
                script += QString::number(s1);
                script += QL1S(") + \'");
                script +=  w.replace('\'', "\\\'"); // Escape any Quote marks in replacement word
                script += QL1C('\'') + QL1S("+this.value.substring(");
                script += QString::number(s2);
                script += QL1C(')');
                
                element.evaluateJavaScript(script);
                // reposition cursor
                element.evaluateJavaScript("this.selectionEnd=this.selectionStart=" + QString::number(selStart) + QL1C(';'));
            }
        }
    }

    return true;
}
bool WorkerGlobalScope::idleNotification()
{
    return script()->idleNotification();
}
Exemple #22
0
char *gettxt_fig(char *s)
{
   char *p;
   int i, c;
   char *script(char *s, int i);

   while (*s && *s != '"')
      ++s;
   if (*s++ == '\0')
      return (s - 1);
   for (p = s, nsub = i = 0; *s && (*s != '"' || *(s + 1) == '"'); ++s) {
      if (*s == '\\') {         /* escape sequence */
         if ((c = greek(s + 1)) >= 0) {
            s += strlen(grk[c]);
            c += 193;
         } else {
            switch (c = *++s) {
            case 'b':
               c = 0x08;
               break;
            case 'n':
               c = 0x0a;
               break;
            case 'r':
               c = 0x0d;
               break;
            case '^':
               c = '^';
               break;
            case '_':
               c = '_';
               break;
            case '\\':
               c = '\\';
               break;
            case 'd':
            case 'u':
               s = script(s, i);
               c = ' ';
               break;
            default:
               sscanf(s, "%3d", &c);
               s += 2;
               break;
            }
         }
         p[i++] = c;
      } else if ((c = *s) == '^' || c == '_') {
         if (*(s + 1) == '{') {
            for (*++s = c; *(s + 1) != '}'; p[i++] = ' ') {
               s = script(s, i);
               *s = c;
            }
            ++s;
         } else {
            s = script(s, i);
            p[i++] = ' ';
         }
      } else {
         if (*s == '"')
            ++s;
         p[i++] = *s;
      }
   }
   sub[nsub] = p[i] = '\0';
   while (p + i < s)
      p[++i] = ' ';
   return (p);
}
void VlcEncodingSystem::_DoEncode(const QString &paramFile)
{
	QFileInfo	videoFile(QFileInfo(QFileInfo(paramFile).completeBaseName()).completeBaseName());

	QDir		dir(VlcStreamerApp::Instance()->DocumentRoot());
	QString		name;
	if(dir.exists(videoFile.completeBaseName())) {
		for(unsigned i = 1; i != ~0U; ++i) {
			if(dir.exists(videoFile.completeBaseName() + "_" + QString::number(i)) == false) {
				name = videoFile.completeBaseName() + "_" + QString::number(i);
				break;
			}
		}
	} else {
		name = videoFile.completeBaseName();
	}

	if(name.isEmpty() == false) {
		dir.mkdir(name);
		dir.cd(name);
		dir.rename(paramFile, "params.txt");

#ifdef Q_WS_WIN
		QFileInfo	scriptInfo(dir.path() + "/encode.bat");
#else
		QFileInfo	scriptInfo(dir.path() + "/encode.sh");
#endif
		QFile		script(scriptInfo.filePath());
		QFile		params(dir.path() + "/params.txt");

		if(params.open(QIODevice::ReadWrite)) {
			QString paramData = params.readAll();
			params.close();

			bool ok;
			QJson::Parser	parser;
			QVariantMap		map = parser.parse(paramData.toAscii(), &ok).toMap();
			if(ok && script.open(QIODevice::WriteOnly)) {
				QString	scriptData;
				//#!/bin/bash 
				//vlc -I dummy --ignore-config "/home/paulm/Videos/troops.avi" 
				//		'--sout=#transcode{vcodec=h264,soverlay,acodec=mp3,channels=2,venc=x264{profile=baseline,level=2.2,keyint=30,bframes=0,ref=1,nocabac},width=480,vb=200,ab=40,fps=25,deinterlace}:
				//				std{access=livehttp{seglen=10,index="/home/paulm/.Hobbyist_Software/VLC_Streamer/Root/troops/stream.m3u8",index-url=stream-###.ts},
				//				mux=ts{use-key-frames},
				//				dst="/home/paulm/.Hobbyist_Software/VLC_Streamer/Root/troops/stream-###.ts"}'
				//		vlc://quit
				scriptData = "#!/bin/bash\n";
				QString	temp = map.value("sout").toString();
				temp.replace("##dest##", dir.path());
				scriptData += "vlc -I dummy --ignore-config " + map.value("args").toString() + " \"" + map.value("file").toString() + "\" vlc://quit " + "'" + temp + "' -vvv\n";
				script.write(scriptData.toAscii());
				script.close();
				script.setPermissions(QFile::ReadUser | QFile::WriteUser | QFile::ExeUser);

				VlcEncoder *encoder = new VlcEncoder(scriptInfo.filePath());
				QThreadPool::globalInstance()->start(encoder);
			} else {
				qDebug() << "Not ok or script didn't open" << ok << script.error();
			}
		}
	}
}
void GuiWindowDef::constructFromTokens(parser::DefTokeniser& tokeniser)
{
	// The windowDef keyword has already been parsed, so expect a name plus an opening brace here
	name = tokeniser.nextToken();

	tokeniser.assertNextToken("{");

	while (tokeniser.hasMoreTokens())
	{
		std::string token = tokeniser.nextToken();
		boost::algorithm::to_lower(token);

		if (token == "rect")
		{
			rect = parseVector4(tokeniser);
		}
		else if (token == "visible")
		{
			visible = parseBool(tokeniser);
		}
		else if (token == "notime")
		{
			notime = parseBool(tokeniser);
		}
		else if (token == "forecolor")
		{
			forecolor = parseVector4(tokeniser);
		}
		else if (token == "backcolor")
		{
			backcolor = parseVector4(tokeniser);
		}
		else if (token == "bordercolor")
		{
			bordercolor = parseVector4(tokeniser);
		}
		else if (token == "matcolor")
		{
			matcolor = parseVector4(tokeniser);
		}
		else if (token == "rotate")
		{
			rotate = parseFloat(tokeniser);
		}
		else if (token == "text")
		{
			setText(parseString(tokeniser));
		}
		else if (token == "font")
		{
			font = parseString(tokeniser);

			// Cut off the "fonts/" part
			boost::algorithm::replace_first(font, "fonts/", "");
		}
		else if (token == "textscale")
		{
			textscale = parseFloat(tokeniser);
		}
		else if (token == "textalign")
		{
			textalign = parseInt(tokeniser);
		}
		else if (token == "textalignx")
		{
			textalignx = parseFloat(tokeniser);
		}
		else if (token == "textaligny")
		{
			textaligny = parseFloat(tokeniser);
		}
		else if (token == "forceaspectwidth")
		{
			forceaspectwidth = parseFloat(tokeniser);
		}
		else if (token == "forceaspectheight")
		{
			forceaspectheight = parseFloat(tokeniser);
		}
		else if (token == "background")
		{
			background = parseString(tokeniser);
		}
		else if (token == "noevents")
		{
			noevents = parseBool(tokeniser);
		}
		else if (token == "nocursor")
		{
			nocursor = parseBool(tokeniser);
		}
		else if (token == "noclip")
		{
			noclip = parseBool(tokeniser);
		}
		else if (token == "nowrap")
		{
			nowrap = parseBool(tokeniser);
		}
		else if (token == "modal")
		{
			noevents = parseBool(tokeniser);
		}
		else if (token == "menugui")
		{
			menugui = parseBool(tokeniser);
		}
		else if (token == "windowdef")
		{
			// Child windowdef
			GuiWindowDefPtr window(new GuiWindowDef(_owner));
			window->constructFromTokens(tokeniser);

			addWindow(window);
		}
		else if (token == "ontime")
		{
			std::string timeStr = tokeniser.nextToken();

			// Check the time for validity
			std::size_t time = string::convert<std::size_t>(
                timeStr, std::numeric_limits<std::size_t>::max()
            );

			if (time == std::numeric_limits<std::size_t>::max())
			{
				rWarning() << "Invalid time encountered in onTime event in "
					<< name << ": " << timeStr << std::endl;
			}

			// Allocate a new GuiScript
			GuiScriptPtr script(new GuiScript(*this));

			script->constructFromTokens(tokeniser);

			_timedEvents.insert(TimedEventMap::value_type(time, script));
		}
		else if (token == "onnamedevent")
		{
			std::string eventName = tokeniser.nextToken();

			// Parse the script
			GuiScriptPtr script(new GuiScript(*this));
			script->constructFromTokens(tokeniser);

			// TODO: Save event
		}
		else if (token == "onevent")
		{
			GuiScriptPtr script(new GuiScript(*this));
			script->constructFromTokens(tokeniser);

			// TODO
		}
		else if (token == "onesc")
		{
			GuiScriptPtr script(new GuiScript(*this));
			script->constructFromTokens(tokeniser);

			// TODO
		}
		else if (token == "onmouseenter" || token == "onmouseexit")
		{
			GuiScriptPtr script(new GuiScript(*this));
			script->constructFromTokens(tokeniser);

			// TODO
		}
		else if (token == "onaction")
		{
			GuiScriptPtr script(new GuiScript(*this));
			script->constructFromTokens(tokeniser);

			// TODO
		}
		else if (token == "float" || token == "definefloat")
		{
			// TODO: Add variable
			std::string variableName = tokeniser.nextToken();
		}
		else if (token == "definevec4")
		{
			// TODO: Add variable
			std::string variableName = tokeniser.nextToken();
			parseVector4(tokeniser);
		}
		else if (token == "}")
		{
			break;
		}
		else
		{
			rWarning() << "Unknown token encountered in GUI: " << token << std::endl;
		}
	}
}
Exemple #25
0
void YumScriptJob::process(){try{
	rwfile rw(QString("scripts/%1.src").arg(number));
	TASSUME(rw.issue.isEmpty(),rw.issue);

	ImasScript script(&rw);
	TASSUME(script.issue.isEmpty(),QString("scripts/%1.src: %2").arg(number).arg(script.issue));

	ImasScriptText text(file);
	TASSUME(text.issue.isEmpty(),text.issue);

	int lineno=0;
	for(int i=0;i<script.nodes.count();i++){
		QString errstr;
		ImasScriptNode *node=script.nodes.value(i);

		if(node->group==SCIPT_GROUP_TEXT){
			if(text.lines.count()<=lineno){
				issue="Not enough lines in script file you supplied";
				state=JOB_STATE_FAILED;
				return;
			}

			node->text=text_encode(text.line(lineno),&errstr);
			if(!errstr.isEmpty()){
				output.append(QString("line %1: couldn't encode text: %2")
						.arg(text.lineno(lineno))
						.arg(errstr));
			}

			lineno++;
		} else if(node->group>=SCIPT_GROUP_NAME){
			int nameno=node->group-SCIPT_GROUP_NAME;

			if(text.names.count()<nameno){
				issue="Not enough names in script file you supplied";
				state=JOB_STATE_FAILED;
				return;
			}

			node->text=text_encode(text.name(nameno),&errstr);
			if(!errstr.isEmpty()){
				output.append(QString("Couldn't encode name ``%1'': %2")
						.arg(text.name(nameno))
						.arg(errstr));
			}
		}
	}

	if(text.lines.count()!=lineno)
		output.append("Too many lines in script file you supplied");

	QByteArray bytes=script.spit();
	TASSUME(script.issue.isEmpty(),script.issue);

	Yum y(isofile,number);
	TASSUME(y.issue.isEmpty(),y.issue);

	y.spit(bytes.data(),bytes.size());
	TASSUME(y.issue.isEmpty(),y.issue);

	if(output.isEmpty()){
		state=JOB_STATE_OK;
	} else{
		state=JOB_STATE_WARNINGS;
	}
} catch(QString ss){
	state=JOB_STATE_FAILED;
}}
void MatWindow::processMat(QTreeWidgetItem* currentItem)
{
    if(!currentItem)
        return;

    return;

    //clean old values
    strAllMat = "";
    matText->clear();
    textureLbl->setPixmap(QPixmap(""));
    textureLbl->setText("Texture Unavailable");

    //We'll seek for the material to include it in matText.
    QDir dir(scriptPath);
    QStringList listFiles(dir.entryList(QStringList() << "*.material", QDir::Files));

    for(int i = 0; i < listFiles.size(); i++)
    {
        QFile file(dir.path() + QDir::separator() + listFiles.at(i));
        if(file.open(QIODevice::ReadOnly))
        {
            QTextStream script(&file);
            //Search our mat
            QString strMat = script.readAll();
            QString nameMat("material "+currentItem->text(0));
            posMat = strMat.indexOf(nameMat);
            if(posMat != -1)
            {
                matText->setPlainText(strMat);//insert all the text and keep it in strAllMat
                strAllMat = matText->toPlainText();
                matText->clear();//clear it so the user don't see anything

                //Process: we cut the beginning of the string. Then we cut all others material
                //So we only have the material wich interest us
                strMat.remove(0, posMat);//we cut the firt part of the string
                nextMat = strMat.indexOf("material ", 8);//search the next material at pos 8 because we want the next material (not the first one)
                if(nextMat != -1)
                    strMat.remove(nextMat, strMat.size());//we cut from this next material to the end so we only have the material we want

                //Processing strMat
                for(int i=0; i<strMat.size(); ++i)
                {
                    if(strMat.at(i) == '\t')
                        strMat.replace(i, 1, "          ");
                }
                matText->setPlainText(strMat);
                QFont f("Arial", 8);
                matText->setFont(f);

                //Now we're looking for the texture
                int posText = strMat.indexOf("texture ");
                if(posText != -1)
                {
                    QString textureName;
                    for(int i=posText+8; i<strMat.size(); ++i)
                    {
                        textureName += strMat.at(i);
                    }
                    textureName.truncate(textureName.indexOf('.'));
                    QPixmap img;
                    if(img.load(texturePath+textureName))
                    {
                        img = img.scaled(150, 150);
                        textureLbl->setText(textureName);
                        textureLbl->setPixmap(img);
                    }
                    else
                    {
                        textureLbl->setText("Image Unavailable");
                    }
                }
                matFile.setFileName(file.fileName());//Finally we keep matFile in memory so that we can open the file later --> saveMat()
            }
        }
        file.close();
    }
}
v8::Handle<v8::Value> PoiMergerJs::jsPoiMerge(const v8::Arguments& args)
{
  HandleScope scope;

  try{
    if (args.Length() != 2)
    {
      return v8::ThrowException(HootExceptionJs::create(IllegalArgumentException(
        "Expected exactly two arguments to 'poiMerge'.")));
    }

    // Argument 1: script -- note second param is directory to search under (~/hoot/rules)
    const QString scriptPath = ConfPath::search(toCpp<QString>(args[0]), "rules");

    // Argument 2: Map with POIs
    OsmMapJs* mapJs = node::ObjectWrap::Unwrap<OsmMapJs>(args[1]->ToObject());

    // Pull out internal POI map
    OsmMapPtr map( mapJs->getMap() );

    // Instantiate script merger
    shared_ptr<PluginContext> script(new PluginContext());
    v8::HandleScope handleScope;
    v8::Context::Scope context_scope(script->getContext());
    script->loadScript(scriptPath, "plugin");

    v8::Handle<v8::Object> global = script->getContext()->Global();

    if (global->Has(String::New("plugin")) == false)
    {
      return v8::ThrowException(HootExceptionJs::create(IllegalArgumentException(
        "Expected the script to have exports.")));
    }

    v8::Handle<v8::Value> pluginValue = global->Get(String::New("plugin"));
    v8::Persistent<v8::Object> plugin = v8::Persistent<v8::Object>::New(v8::Handle<v8::Object>::Cast(pluginValue));
    if (plugin.IsEmpty() || plugin->IsObject() == false)
    {
      return v8::ThrowException(HootExceptionJs::create(IllegalArgumentException(
        "Expected plugin to be a valid object.")));
    }

    // Got in Map with POIs A, B, C, D, E
    //
    // Make a set of pairs to indicate all are same object:
    //   A->B, A->C, A->D, A->E
    //
    // ...then pass those pairs one at a time through the merger, since it only merges pairs
    OsmMap::NodeMap nodes = map->getNodeMap();
    OsmMapPtr mergedMap(map);
    const ElementId firstId = ElementId::node((*(nodes.constBegin()))->getId());
    //LOG_DEBUG("First ID: " << firstId.getId());
    for (OsmMap::NodeMap::const_iterator it = nodes.constBegin() + 1; it != nodes.constEnd(); ++it)
    {
      const boost::shared_ptr<const Node>& n = it.value();

      std::set< std::pair< ElementId, ElementId> > matches;
      matches.insert(std::pair<ElementId,ElementId>(firstId, ElementId::node(n->getId())));

      // Now create scriptmerger, and invoke apply method which will apply apply merge transformation, reducing the POIs down to one
      ScriptMerger merger(script, plugin, matches);
      OsmMapPtr mergedMap(map);
      std::vector< std::pair< ElementId, ElementId > > replacedNodes;
      merger.apply(mergedMap, replacedNodes );

      if ( replacedNodes.size() == 1 )
      {
        /*
        LOG_DEBUG("POI merge: replacing node #" << replacedNodes[0].first.getId() <<
          " with updated version of node #" << replacedNodes[0].second.getId() );
        */
        mergedMap->replaceNode(replacedNodes[0].first.getId(), replacedNodes[0].second.getId());
      }
    }

    // Hand merged POIs back to caller in OsmMap
    v8::Handle<v8::Object> returnMap = OsmMapJs::create(mergedMap);
    return scope.Close(returnMap);
  }
  catch ( const HootException& e )
  {
    return v8::ThrowException(HootExceptionJs::create(e));
  }
}
Exemple #28
0
void Config::read()
{
    if (d->configPath.isEmpty()) return;

    LOG_AS("Config::read");

    // Current version.
    Version verInfo = Version::currentBuild();
    QScopedPointer<ArrayValue> version(new ArrayValue);
    *version << NumberValue(verInfo.major)
             << NumberValue(verInfo.minor)
             << NumberValue(verInfo.patch)
             << NumberValue(verInfo.build);

    File &scriptFile = App::rootFolder().locate<File>(d->configPath);
    bool shouldRunScript = App::commandLine().has("-reconfig");

    try
    {
        // If we already have a saved copy of the config, read it.
        d->refuge.read();

        LOG_DEBUG("Found serialized Config:\n") << objectNamespace();

        // If the saved config is from a different version, rerun the script.
        if (objectNamespace().has("__version__"))
        {
            Value const &oldVersion = objectNamespace()["__version__"].value();
            d->setOldVersion(oldVersion);
            if (oldVersion.compare(*version))
            {
                // Version mismatch: store the old version in a separate variable.
                d->config.globals().add(new Variable("__oldversion__", oldVersion.duplicate(),
                                                 Variable::AllowArray | Variable::ReadOnly));
                shouldRunScript = true;
            }
            else
            {
                // Versions match.
                LOG_MSG("") << d->refuge.path() << " matches version " << version->asText();
            }
        }
        else
        {
            // Don't know what version this is, run script to be sure.
            shouldRunScript = true;
        }

        // Also check the timestamp of written config vs. the config script.
        // If script is newer, it should be rerun.
        if (scriptFile.status().modifiedAt > d->refuge.lastWrittenAt())
        {
            LOG_MSG("%s is newer than %s, rerunning the script")
                    << d->configPath << d->refuge.path();
            shouldRunScript = true;
        }

        // Check the container, too.
        if (!shouldRunScript &&
            Package::containerOfFileModifiedAt(scriptFile) > d->refuge.lastWrittenAt())
        {
            LOG_MSG("Package '%s' is newer than %s, rerunning the script")
                    << Package::identifierForContainerOfFile(scriptFile)
                    << d->refuge.path();
            shouldRunScript = true;
        }
    }
    catch (Archive::NotFoundError const &)
    {
        // It is missing from persist.pack if the config hasn't been written yet.
        shouldRunScript = true;
    }
    catch (IByteArray::OffsetError const &)
    {
        // Empty or missing serialization?
        shouldRunScript = true;
    }
    catch (Error const &error)
    {
        LOG_WARNING(error.what());

        // Something is wrong, maybe rerunning will fix it.
        shouldRunScript = true;
    }

    // The version of libcore is automatically included in the namespace.
    d->config.globals().add(new Variable("__version__", version.take(),
                                         Variable::AllowArray | Variable::ReadOnly));

    if (shouldRunScript)
    {
        // Read the main configuration.
        Script script(scriptFile);
        d->config.run(script);
        d->config.execute();
    }
}
Exemple #29
0
bool Game::initialize(ENetAddress *address, const char *baseKey){
    if (enet_initialize () != 0)
        return false;
    atexit(enet_deinitialize);

    _server = enet_host_create(address, 32, 0, 0);
    if(_server == NULL)
        return false;

    std::string key = base64_decode(baseKey);
    if(key.length() <= 0)
        return false;

    _blowfish = new BlowFish((uint8*)key.c_str(), 16);
    initHandlers();
   
   map = new SummonersRift(this);
   
   //TODO: better lua implementation
   
   LuaScript script(false);
   
   script.loadScript("../../lua/config.lua");
   
  //  sol::state lua;
  //  lua.open_libraries(sol::lib::base, sol::lib::table);
    
  //  lua.open_file("../../lua/config.lua");
    sol::table playerList = script.getTable("players");
    for (int i=1;i<12;i++) {
        try {
            std::string playerIndex = "player"+toString(i);
        
            sol::table playerData = playerList.get<sol::table>(playerIndex);

            std::string rank = playerData.get<std::string>("rank");
            std::string name = playerData.get<std::string>("name");
            std::string champion = playerData.get<std::string>("champion");
            std::string team = playerData.get<std::string>("team");
            int skin = playerData.get<int>("skin");
            int ribbon = playerData.get<int>("ribbon");
            int icon = playerData.get<int>("icon");
            std::string summoner1 = playerData.get<std::string>("summoner1");
            std::string summoner2 = playerData.get<std::string>("summoner2");

            ClientInfo* player = new ClientInfo(rank, ((team == "BLUE") ? TEAM_BLUE : TEAM_PURPLE), ribbon, icon);

           player->setName(name);


		   player->setSkinNo(skin);
		   static int id = 1;
		   player->userId = id; // same as StartClient.bat
		   id++;
		   player->setSummoners(strToId(summoner1), strToId(summoner2));
           Champion* c = ChampionFactory::getChampionFromType(champion, map, GetNewNetID(), player->userId);
		   float respawnX, respawnY;
		   std::tie(respawnX, respawnY) = c->getRespawnPosition();
           c->setPosition(respawnX, respawnY);
           c->setSide((team == "BLUE") ? 0 : 1);
           c->levelUp();

           map->addObject(c);


           player->setChampion(c);




           players.push_back(player);
   
        } catch(sol::error e) {
            //printf("Error loading champion: \n%s", e.what());
            break;  
        }
    }
   
   // Uncomment the following to get 2-players
   /*ClientInfo* player2 = new ClientInfo("GOLD", TEAM_PURPLE);
   player2->setName("tseT");
   Champion* c2 = ChampionFactory::getChampionFromType("Ezreal", map, GetNewNetID());
   c2->setPosition(100.f, 273.55f);
   c2->setSide(1);
   map->addObject(c2);
   player2->setChampion(c2);
   player2->setSkinNo(4);
   player2->userId = 2; // same as StartClient.bat
   player2->setSummoners(SPL_Ignite, SPL_Flash);
   
   players.push_back(player2);*/
	
	return _isAlive = true;
}
Exemple #30
0
nsresult
ProxyAutoConfig::SetupJS()
{
  mJSNeedsSetup = false;
  NS_ABORT_IF_FALSE(!sRunning, "JIT is running");

  delete mJSRuntime;
  mJSRuntime = nullptr;

  if (mPACScript.IsEmpty())
    return NS_ERROR_FAILURE;

  mJSRuntime = JSRuntimeWrapper::Create();
  if (!mJSRuntime)
    return NS_ERROR_FAILURE;

  JSContext* cx = mJSRuntime->Context();
  JSAutoRequest ar(cx);
  JSAutoCompartment ac(cx, mJSRuntime->Global());

  // check if this is a data: uri so that we don't spam the js console with
  // huge meaningless strings. this is not on the main thread, so it can't
  // use nsIRUI scheme methods
  bool isDataURI = nsDependentCSubstring(mPACURI, 0, 5).LowerCaseEqualsASCII("data:", 5);

  sRunning = this;
  JS::Rooted<JSObject*> global(cx, mJSRuntime->Global());
  JS::CompileOptions options(cx);
  options.setFileAndLine(mPACURI.get(), 1);
  JS::Rooted<JSScript*> script(cx, JS_CompileScript(cx, global, mPACScript.get(),
                                                    mPACScript.Length(), options));
  if (!script || !JS_ExecuteScript(cx, global, script, nullptr)) {
    nsString alertMessage(NS_LITERAL_STRING("PAC file failed to install from "));
    if (isDataURI) {
      alertMessage += NS_LITERAL_STRING("data: URI");
    }
    else {
      alertMessage += NS_ConvertUTF8toUTF16(mPACURI);
    }
    PACLogToConsole(alertMessage);
    sRunning = nullptr;
    return NS_ERROR_FAILURE;
  }
  sRunning = nullptr;

  mJSRuntime->SetOK();
  nsString alertMessage(NS_LITERAL_STRING("PAC file installed from "));
  if (isDataURI) {
    alertMessage += NS_LITERAL_STRING("data: URI");
  }
  else {
    alertMessage += NS_ConvertUTF8toUTF16(mPACURI);
  }
  PACLogToConsole(alertMessage);

  // we don't need these now
  mPACScript.Truncate();
  mPACURI.Truncate();

  return NS_OK;
}