int MetaConfig::flushNodeSrvs(TiXmlHandle *meta)
{
std::vector<NodeService> tmp;
TiXmlHandle srvs = meta->FirstChildElement("services");
if(srvs.Element()){
TiXmlHandle srv = srvs.FirstChildElement("service");
while(srv.Element()){
NodeService ns;
loadInt(&srv, "gid", ns.gid, -1);
loadString(&srv, "name", ns.service, "");
loadString(&srv, "ip", ns.ip, "");
loadInt(&srv, "port", ns.port, -1);
if(!(ns.gid != -1 && !ns.service.empty() && !ns.ip.empty() && ns.port != -1)){
std::cerr << "load service error name:" << ns.service << " ip:" << ns.ip << " port:" << ns.port << " node:" << ns.gid<< std::endl;
return -1;
}
tmp.push_back(ns);
srv = srv.Element()->NextSibling("service");
}
std::sort(tmp.begin(), tmp.end());
std::unique(tmp.begin(), tmp.end());
}
boost::mutex::scoped_lock lock(mtx);
ndSrvs.swap(tmp);
return 0;
}
void appendHeapSize(char *dst, const int megabytesID, const int percentID,
const DWORDLONG availableMemory, const char *option)
{
const int mb = 1048576; // 1 MB
const int mbLimit32 = 1024; // Max heap size in MB on 32-bit JREs
const int megabytes = loadInt(megabytesID);
const int percent = loadInt(percentID);
const int availableMb = availableMemory * percent / (100 * mb); // 100% * 1 MB
int heapSizeMb = availableMb > megabytes ? availableMb : megabytes;
if (heapSizeMb > 0)
{
if (!(foundJava & KEY_WOW64_64KEY) && heapSizeMb > mbLimit32)
{
debug("Heap limit:\tReduced %d MB heap size to 32-bit maximum %d MB\n",
heapSizeMb, mbLimit32);
heapSizeMb = mbLimit32;
}
debug("Heap %s:\tRequested %d MB / %d%%, Available: %d MB, Heap size: %d MB\n",
option, megabytes, percent, (int)(availableMemory / mb), heapSizeMb);
strcat(dst, option);
_itoa(heapSizeMb, dst + strlen(dst), 10); // 10 -- radix
strcat(dst, "m ");
}
}
void Serializer::loadEntries(Entry *entry) {
debug(DBG_SER, "Serializer::loadEntries()");
for (; entry->type != SET_END; ++entry) {
if (_saveVer >= entry->minVer && _saveVer <= entry->maxVer) {
switch (entry->type) {
case SET_INT:
loadInt(entry->size, entry->data);
_bytesCount += entry->size;
break;
case SET_ARRAY:
if (entry->size == Serializer::SES_INT8) {
_stream->read(entry->data, entry->n);
_bytesCount += entry->n;
} else {
uint8 *p = (uint8 *)entry->data;
for (int i = 0; i < entry->n; ++i) {
loadInt(entry->size, p);
p += entry->size;
_bytesCount += entry->size;
}
}
break;
case SET_PTR:
*(uint8 **)(entry->data) = _ptrBlock + _stream->readUint32BE();
_bytesCount += 4;
break;
case SET_END:
break;
}
}
}
}
void SimpleMCModelerWidget::loadModel()
{
ComputationParameters params;
params.setInt(SimpleMCModeler::PARAM_NUMDSTEPS, loadInt(SimpleMCModeler::PARAM_NUMDSTEPS));
numdstepsEdit->setValue(loadInt(SimpleMCModeler::PARAM_NUMDSTEPS));
params.setInt(SimpleMCModeler::PARAM_NUMSTATES, loadInt(SimpleMCModeler::PARAM_NUMSTATES));
numstatesEdit->setValue(loadInt(SimpleMCModeler::PARAM_NUMSTATES));
modeler->setParameters(params);
}
void appendHeapSize(const HMODULE hLibrary, char *dst,
const int absID, const int percentID,
const DWORD freeMemory, const char *option) {
int abs = loadInt(hLibrary, absID);
int percent = loadInt(hLibrary, percentID);
int free = (long long) freeMemory * percent / (100 * 1048576); // 100% * 1 MB
int size = free > abs ? free : abs;
if (size > 0) {
strcat(dst, option);
_itoa(size, dst + strlen(dst), 10); // 10 -- radix
strcat(dst, "m ");
}
}
Magic3D::XMLElement* Magic3D::Object::load(XMLElement* root)
{
if (root)
{
script = loadString(root, M3D_OBJECT_XML_SCRIPT);
parentPosition = loadBool(root, M3D_OBJECT_XML_PARENT_POSITION);
parentRotation = loadBool(root, M3D_OBJECT_XML_PARENT_ROTATION);
parentScale = loadBool(root, M3D_OBJECT_XML_PARENT_SCALE);
flag = loadInt(root, M3D_OBJECT_XML_FLAG);
billboard = (BILLBOARD)loadInt(root, M3D_OBJECT_XML_BILLBOARD);
enabled = loadBool(root, M3D_OBJECT_XML_ENABLED);
visible = loadBool(root, M3D_OBJECT_XML_VISIBLE);
zOrder = loadBool(root, M3D_OBJECT_XML_ZORDER);
pick = loadBool(root, M3D_OBJECT_XML_PICK);
position = loadVector3(root, M3D_OBJECT_XML_POSITION);
setRotation(Quaternion(loadVector4(root, M3D_OBJECT_XML_ROTATION)));
scale = loadVector3(root, M3D_OBJECT_XML_SCALE);
bool sc = loadBool(root, M3D_OBJECT_XML_SCRIPTED);
if (sc)
{
setScripted(true);
}
else
{
this->scripted = false;
}
XMLElement* xml = root->FirstChildElement(M3D_MESH_XML);
unsigned int meshIndex = 0;
while (xml)
{
Mesh* mesh = NULL;
if (meshIndex < meshes.size())
{
mesh = meshes[meshIndex++];
}
if (mesh)
{
mesh->load(xml);
}
xml = xml->NextSiblingElement(M3D_MESH_XML);
}
PhysicsObject::load(root);
}
return root;
}
void appendHeapSize(char *dst, const int absID, const int percentID,
const DWORD freeMemory, const char *option) {
const int mb = 1048576; // 1 MB
int abs = loadInt(absID);
int percent = loadInt(percentID);
int free = (long long) freeMemory * percent / (100 * mb); // 100% * 1 MB
int size = free > abs ? free : abs;
if (size > 0) {
debug("Heap %s:\t%d MB / %d%%, Free: %d MB, Heap size: %d MB\n",
option, abs, percent, freeMemory / mb, size);
strcat(dst, option);
_itoa(size, dst + strlen(dst), 10); // 10 -- radix
strcat(dst, "m ");
}
}
void appendHeapSize(char *dst, const int absID, const int percentID,
const DWORD freeMemory, const char *option) {
const int mb = 1048576; // 1 MB
const int mbLimit32 = 1500; // Max heap size in MB on 32-bit JREs
int abs = loadInt(absID);
int percent = loadInt(percentID);
int free = (long long) freeMemory * percent / (100 * mb); // 100% * 1 MB
int size = free > abs ? free : abs;
if (size > 0) {
if (!(foundJava & KEY_WOW64_64KEY) && size > mbLimit32) {
debug("Heap limit:\tReduced %d MB heap size to 32-bit maximum %d MB\n",
size, mbLimit32);
size = mbLimit32;
}
debug("Heap %s:\t%d MB / %d%%, Free: %d MB, Heap size: %d MB\n",
option, abs, percent, freeMemory / mb, size);
strcat(dst, option);
_itoa(size, dst + strlen(dst), 10); // 10 -- radix
strcat(dst, "m ");
}
}
/* Precondition: f needs to be pointing to the start of the central
* directory. If you know you haven't reached path yet, you're still
* OK as long as f is pointing to the start of a central directory
* record.*/
static int
find_file_in_zip(FILE *f, const char *path, struct zip_entry *ze)
{
while (1) {
short fnameLen;
int magic, suffixLen;
long offset;
magic = loadInt(f);
if (magic == 0x06054b50 || magic == 0x05054b50 || magic == 0x06064b50) {
/* We've hit the End of Central Directory record, a
* digital signature block, or a Zip64 end of directory
* record. We're done, and we didn't find what we were
* looking for. */
return 0;
}
if (magic != 0x02014b50) {
/* ZIP directory corrupt */
return 0;
}
loadSkip(f, 6);
ze->compression = loadShort(f);
loadSkip(f, 4);
ze->crc32 = loadInt(f);
ze->compressedSize = loadInt(f);
ze->uncompressedSize = loadInt(f);
fnameLen = loadShort(f);
suffixLen = loadShort(f);
suffixLen += loadShort(f);
loadSkip(f, 8);
offset = loadInt(f);
if (!fstrncmp(f, fnameLen, path)) {
if (ze->compression != 0 && ze->compression != 8) {
/* Unknown compression type */
return 0;
}
fseek(f, offset, SEEK_SET);
suffixLen = 0;
magic = loadInt(f);
if (magic != 0x04034b50) {
/* ZIP directory corrupt */
return 0;
}
loadSkip(f, 22);
suffixLen += loadShort(f);
suffixLen += loadShort(f);
loadSkip(f, suffixLen);
return 1;
}
/* That wasn't it. Skip the suffix to get to the next
* entry */
loadSkip(f, suffixLen);
}
/* This should really qualify as unreachable code */
return 0;
}
void AutoSMPModelerWidget::loadModel()
{
ComputationParameters params;
params.setInt(AutoSMPModeler::PARAM_NUMDSTEPS, loadInt(AutoSMPModeler::PARAM_NUMDSTEPS));
numdstepsEdit->setValue(loadInt(AutoSMPModeler::PARAM_NUMDSTEPS));
params.setInt(AutoSMPModeler::PARAM_NUMSTATES, loadInt(AutoSMPModeler::PARAM_NUMSTATES));
numstatesEdit->setValue(loadInt(AutoSMPModeler::PARAM_NUMSTATES));
params.setInt(AutoSMPModeler::PARAM_CONFNIVEAU, loadInt(AutoSMPModeler::PARAM_CONFNIVEAU));
confniveauEdit->setValue(loadInt(AutoSMPModeler::PARAM_CONFNIVEAU));
modeler->setParameters(params);
}
void regSearchWow(const char* keyName, const int searchType)
{
HKEY hKey;
if (runtimeBits == INIT_RUNTIME_BITS)
{
runtimeBits = loadInt(RUNTIME_BITS);
}
if ((runtimeBits & USE_64_BIT_RUNTIME) && wow64)
{
debug("64-bit search:\t%s...\n", keyName);
if (RegOpenKeyEx(HKEY_LOCAL_MACHINE,
keyName,
0,
KEY_READ | KEY_WOW64_64KEY,
&hKey) == ERROR_SUCCESS)
{
regSearch(hKey, keyName, searchType | KEY_WOW64_64KEY);
RegCloseKey(hKey);
if ((foundJava & KEY_WOW64_64KEY) != NO_JAVA_FOUND)
{
return;
}
}
}
if (runtimeBits & USE_32_BIT_RUNTIME)
{
debug("32-bit search:\t%s...\n", keyName);
if (RegOpenKeyEx(HKEY_LOCAL_MACHINE,
keyName,
0,
KEY_READ,
&hKey) == ERROR_SUCCESS)
{
regSearch(hKey, keyName, searchType);
RegCloseKey(hKey);
}
}
}
Magic3D::XMLElement* Magic3D::TextData::load(XMLElement* root)
{
if (root)
{
text = loadString(root, M3D_TEXT_XML_TEXT);
if (text.compare(M3D_XML_NULL) == 0)
{
text.clear();
}
std::string fontName = loadString(root, M3D_TEXT_XML_FONT);
if (fontName.compare(M3D_XML_NULL) != 0)
{
bool created;
font = ResourceManager::getFonts()->load(fontName, created);
}
textAlignment = (HORIZONTAL_ALIGN)loadInt(root, M3D_TEXT_XML_ALIGNMENT);
textColor = loadColorRGBA(root, M3D_TEXT_XML_COLOR);
textSize = loadFloat(root, M3D_TEXT_XML_SIZE);
changed = true;
}
return root;
}
int prepare(const char *lpCmdLine) {
char tmp[MAX_ARGS] = {0};
hModule = GetModuleHandle(NULL);
if (hModule == NULL) {
return FALSE;
}
// Get executable path
char exePath[_MAX_PATH] = {0};
int pathLen = getExePath(exePath);
if (pathLen == -1) {
return FALSE;
}
// Initialize logging
if (strstr(lpCmdLine, "--l4j-debug") != NULL) {
hLog = openLogFile(exePath, pathLen);
if (hLog == NULL) {
return FALSE;
}
debug("\n\nCmdLine:\t%s %s\n", exePath, lpCmdLine);
}
setWow64Flag();
// Set default error message, title and optional support web site url.
loadString(SUPPORT_URL, errUrl);
loadString(ERR_TITLE, errTitle);
if (!loadString(STARTUP_ERR, errMsg)) {
return FALSE;
}
// Single instance
loadString(MUTEX_NAME, mutexName);
if (*mutexName) {
SECURITY_ATTRIBUTES security;
security.nLength = sizeof(SECURITY_ATTRIBUTES);
security.bInheritHandle = TRUE;
security.lpSecurityDescriptor = NULL;
CreateMutexA(&security, FALSE, mutexName);
if (GetLastError() == ERROR_ALREADY_EXISTS) {
debug("Instance already exists.");
return ERROR_ALREADY_EXISTS;
}
}
// Working dir
char tmp_path[_MAX_PATH] = {0};
GetCurrentDirectory(_MAX_PATH, oldPwd);
if (loadString(CHDIR, tmp_path)) {
strncpy(workingDir, exePath, pathLen);
appendPath(workingDir, tmp_path);
_chdir(workingDir);
debug("Working dir:\t%s\n", workingDir);
}
// Use bundled jre or find java
if (loadString(JRE_PATH, tmp_path)) {
char jrePath[MAX_ARGS] = {0};
expandVars(jrePath, tmp_path, exePath, pathLen);
debug("Bundled JRE:\t%s\n", jrePath);
if (jrePath[0] == '\\' || jrePath[1] == ':') {
// Absolute
strcpy(cmd, jrePath);
} else {
// Relative
strncpy(cmd, exePath, pathLen);
appendPath(cmd, jrePath);
}
}
if (!isJrePathOk(cmd)) {
if (!loadString(JAVA_MIN_VER, javaMinVer)) {
loadString(BUNDLED_JRE_ERR, errMsg);
return FALSE;
}
loadString(JAVA_MAX_VER, javaMaxVer);
if (!findJavaHome(cmd, loadInt(JDK_PREFERENCE))) {
loadString(JRE_VERSION_ERR, errMsg);
strcat(errMsg, " ");
strcat(errMsg, javaMinVer);
if (*javaMaxVer) {
strcat(errMsg, " - ");
strcat(errMsg, javaMaxVer);
}
loadString(DOWNLOAD_URL, errUrl);
return FALSE;
}
if (!isJrePathOk(cmd)) {
loadString(LAUNCHER_ERR, errMsg);
return FALSE;
}
}
// Append a path to the Path environment variable
char jreBinPath[_MAX_PATH];
strcpy(jreBinPath, cmd);
strcat(jreBinPath, "\\bin");
if (!appendToPathVar(jreBinPath)) {
return FALSE;
}
// Set environment variables
char envVars[MAX_VAR_SIZE] = {0};
loadString(ENV_VARIABLES, envVars);
char *var = strtok(envVars, "\t");
while (var != NULL) {
char *varValue = strchr(var, '=');
*varValue++ = 0;
*tmp = 0;
expandVars(tmp, varValue, exePath, pathLen);
debug("Set var:\t%s = %s\n", var, tmp);
SetEnvironmentVariable(var, tmp);
var = strtok(NULL, "\t");
}
*tmp = 0;
// Process priority
priority = loadInt(PRIORITY_CLASS);
// Custom process name
const BOOL setProcName = loadBool(SET_PROC_NAME)
&& strstr(lpCmdLine, "--l4j-default-proc") == NULL;
const BOOL wrapper = loadBool(WRAPPER);
char jdk_path[_MAX_PATH] = {0}; // fry
strcpy(jdk_path, cmd);
//msgBox(jdk_path);
appendLauncher(setProcName, exePath, pathLen, cmd);
// Heap sizes
appendHeapSizes(args);
// JVM options
if (loadString(JVM_OPTIONS, tmp)) {
strcat(tmp, " ");
} else {
*tmp = 0;
}
/*
* Load additional JVM options from .l4j.ini file
* Options are separated by spaces or CRLF
* # starts an inline comment
*/
strncpy(tmp_path, exePath, strlen(exePath) - 3);
strcat(tmp_path, "l4j.ini");
long hFile;
if ((hFile = _open(tmp_path, _O_RDONLY)) != -1) {
const int jvmOptLen = strlen(tmp);
char* src = tmp + jvmOptLen;
char* dst = src;
const int len = _read(hFile, src, MAX_ARGS - jvmOptLen - BIG_STR);
BOOL copy = TRUE;
int i;
for (i = 0; i < len; i++, src++) {
if (*src == '#') {
copy = FALSE;
} else if (*src == 13 || *src == 10) {
copy = TRUE;
if (dst > tmp && *(dst - 1) != ' ') {
*dst++ = ' ';
}
} else if (copy) {
*dst++ = *src;
}
}
*dst = 0;
if (len > 0 && *(dst - 1) != ' ') {
strcat(tmp, " ");
}
_close(hFile);
}
// Expand environment %variables%
expandVars(args, tmp, exePath, pathLen);
// MainClass + Classpath or Jar
char mainClass[STR] = {0};
char jar[_MAX_PATH] = {0};
loadString(JAR, jar);
if (loadString(MAIN_CLASS, mainClass)) {
if (!loadString(CLASSPATH, tmp)) {
return FALSE;
}
char exp[MAX_ARGS] = {0};
expandVars(exp, tmp, exePath, pathLen);
strcat(args, "-classpath \"");
if (wrapper) {
appendAppClasspath(args, exePath, exp);
} else if (*jar) {
appendAppClasspath(args, jar, exp);
}
// add tools.jar for JDK [fry]
char tools[_MAX_PATH] = { 0 };
sprintf(tools, "%s\\lib\\tools.jar", jdk_path);
appendAppClasspath(args, tools, exp);
// Deal with wildcards or >> strcat(args, exp); <<
char* cp = strtok(exp, ";");
while(cp != NULL) {
debug("Add classpath:\t%s\n", cp);
if (strpbrk(cp, "*?") != NULL) {
int len = strrchr(cp, '\\') - cp + 1;
strncpy(tmp_path, cp, len);
char* filename = tmp_path + len;
*filename = 0;
struct _finddata_t c_file;
long hFile;
if ((hFile = _findfirst(cp, &c_file)) != -1L) {
do {
strcpy(filename, c_file.name);
strcat(args, tmp_path);
strcat(args, ";");
debug(" \" :\t%s\n", tmp_path);
} while (_findnext(hFile, &c_file) == 0);
}
_findclose(hFile);
} else {
strcat(args, cp);
strcat(args, ";");
}
cp = strtok(NULL, ";");
}
*(args + strlen(args) - 1) = 0;
strcat(args, "\" ");
strcat(args, mainClass);
} else if (wrapper) {
strcat(args, "-jar \"");
strcat(args, exePath);
strcat(args, "\"");
} else {
strcat(args, "-jar \"");
strncat(args, exePath, pathLen);
appendPath(args, jar);
strcat(args, "\"");
}
// Constant command line args
if (loadString(CMD_LINE, tmp)) {
strcat(args, " ");
strcat(args, tmp);
}
// Command line args
if (*lpCmdLine) {
strcpy(tmp, lpCmdLine);
char* dst;
while ((dst = strstr(tmp, "--l4j-")) != NULL) {
char* src = strchr(dst, ' ');
if (src == NULL || *(src + 1) == 0) {
*dst = 0;
} else {
strcpy(dst, src + 1);
}
}
if (*tmp) {
strcat(args, " ");
strcat(args, tmp);
}
}
debug("Launcher:\t%s\n", cmd);
debug("Launcher args:\t%s\n", args);
debug("Args length:\t%d/32768 chars\n", strlen(args));
return TRUE;
}
int MetaConfig::parse()
{
FILE *fp = fopen(fname.c_str(), "r");
if(!fp){
std::cerr << "load file " << fname << " error" << std::endl;
return -1;
}
TiXmlDocument doc;
doc.LoadFile(fp);
TiXmlHandle docH( &doc );
TiXmlHandle meta = docH.FirstChildElement( "conf" ).FirstChildElement( "servers" ).FirstChildElement("meta");
if(meta.Element()){
std::string lip;
loadString(&meta, "ip", lip, "");
if(lip.empty())
{
ip = 0;
}
else
{
ip = sox::aton_addr(lip.c_str());
if (ip == INADDR_NONE)
{
log(Error, "invalid ip:%s", lip.c_str());
return -1;
}
}
loadInt(&meta, "session_port", sessionPort, 2001);
loadInt(&meta, "lostcheck_port", lostCheckPort, 2010);
loadInt(&meta, "snap_port", snapPort, 2014);
loadInt(&meta, "sys_port", sysPort, 2018);
loadInt(&meta, "thread", threadNum, 10);
loadInt(&meta, "psync_limit", pSyncLogLimit, 10);
pSyncLogLimit *= 1024; // kbyte-> byte
loadBool(&meta, "sync", bsync, false);
loadBool(&meta, "session_on",isSessionOn, false);
loadString(&meta, "type", type, "");
if(type == "daemon")
{
// do nothing
}
else if(type == "localDaemon")
{
// do nothing
}
else
{
std::cerr << "invalid type" << type << std::endl;
fclose(fp);
return -1;
}
if(!isLocalDaemon()) // daemon
{
TiXmlHandle daemon = meta.FirstChildElement("daemon");
TiXmlHandle node = daemon.FirstChildElement("node");
if(node.Element())
{
loadInt(&node, "gid", gid, -1);
loadInt(&node, "lid", lid, -1);
if(gid == -1 || lid == -1){
std::cerr << "read from config gid:" << gid << " lid:" << lid << " must be set" << std::endl;
fclose(fp);
return -1;
}
}
else
{
std::cerr << "xml path conf.servers.meta.node not found" << std::endl;
fclose(fp);
return -1;
}
TiXmlHandle db = daemon.FirstChildElement("db").FirstChildElement("mysql");
if(db.Element()){
loadString(&db, "host", config.host, "localhost");
loadInt(&db, "port", config.port, 3306);
loadString(&db, "user", config.user, "root");
loadString(&db, "passwd", config.passwd, "");
loadString(&db, "database", config.database, "daemon");
loadString(&db, "charset", config.charset, "utf8");
}else{
config.host = "localhost";
config.port = 3306;
config.user = "******";
config.passwd = "";
config.database = "daemon";
config.charset = "utf8";
log(Debug, "use default mysql config setting");
}
int ret = flushNodeSrvs(&daemon);
if(ret != 0){
fclose(fp);
return ret;
}
}
else // localDaemon
{
TiXmlHandle localdaemon = meta.FirstChildElement("localdaemon");
if(localdaemon.Element()){
loadString(&localdaemon,"luser", luser,"");
loadString(&localdaemon,"lpasswd", lpasswd,"");
loadString(&localdaemon,"chost", chost,"meta.yy.com");
loadString(&localdaemon,"lname",lname,"");
loadInt(&localdaemon, "csession_port", cSessionPort, 2001);
loadInt(&localdaemon, "csnap_port", cSnapPort, 2014);
loadInt(&localdaemon, "groupid", groupId, -1);
loadString(&localdaemon,"db_path", dbPath, "");
if(groupId == -1 || lname.empty() || dbPath.empty())
{
std::cerr << "read from config ,lname, dbPath and groupId:" << groupId <<" must be set at localDaemon" << std::endl;
fclose(fp);
return -1;
}
}
}
}
fclose(fp);
return 0;
}
int prepare(const char *lpCmdLine)
{
char tmp[MAX_ARGS] = {0};
hModule = GetModuleHandle(NULL);
if (hModule == NULL)
{
return FALSE;
}
// Get executable path
char exePath[_MAX_PATH] = {0};
int pathLen = getExePath(exePath);
if (pathLen == -1)
{
return FALSE;
}
if (!initializeLogging(lpCmdLine, exePath, pathLen))
{
return FALSE;
}
debug("\n\nVersion:\t%s\n", VERSION);
debug("CmdLine:\t%s %s\n", exePath, lpCmdLine);
setWow64Flag();
// Set default error message, title and optional support web site url.
loadString(SUPPORT_URL, errUrl);
loadString(ERR_TITLE, errTitle);
if (!loadString(STARTUP_ERR, errMsg))
{
debug(ERROR_FORMAT, "Startup error message not defined.");
return FALSE;
}
// Single instance
loadString(MUTEX_NAME, mutexName);
if (*mutexName)
{
SECURITY_ATTRIBUTES security;
security.nLength = sizeof(SECURITY_ATTRIBUTES);
security.bInheritHandle = TRUE;
security.lpSecurityDescriptor = NULL;
CreateMutexA(&security, FALSE, mutexName);
if (GetLastError() == ERROR_ALREADY_EXISTS)
{
debug(ERROR_FORMAT, "Instance already exists.");
return ERROR_ALREADY_EXISTS;
}
}
// Working dir
char tmp_path[_MAX_PATH] = {0};
GetCurrentDirectory(_MAX_PATH, oldPwd);
if (loadString(CHDIR, tmp_path))
{
strncpy(workingDir, exePath, pathLen);
appendPath(workingDir, tmp_path);
_chdir(workingDir);
debug("Working dir:\t%s\n", workingDir);
}
// Use bundled jre or find java
if (loadString(JRE_PATH, tmp_path))
{
char jrePath[MAX_ARGS] = {0};
expandVars(jrePath, tmp_path, exePath, pathLen);
debug("Bundled JRE:\t%s\n", jrePath);
if (jrePath[0] == '\\' || jrePath[1] == ':')
{
// Absolute
strcpy(cmd, jrePath);
}
else
{
// Relative
strncpy(cmd, exePath, pathLen);
appendPath(cmd, jrePath);
}
if (isLauncherPathValid(cmd))
{
foundJava = (wow64 && loadBool(BUNDLED_JRE_64_BIT))
? FOUND_BUNDLED | KEY_WOW64_64KEY
: FOUND_BUNDLED;
}
}
if (foundJava == NO_JAVA_FOUND)
{
if (!loadString(JAVA_MIN_VER, javaMinVer))
{
loadString(BUNDLED_JRE_ERR, errMsg);
return FALSE;
}
loadString(JAVA_MAX_VER, javaMaxVer);
if (!findJavaHome(cmd, loadInt(JDK_PREFERENCE)))
{
loadString(JRE_VERSION_ERR, errMsg);
strcat(errMsg, " ");
strcat(errMsg, javaMinVer);
if (*javaMaxVer)
{
strcat(errMsg, " - ");
strcat(errMsg, javaMaxVer);
}
if (runtimeBits == USE_64_BIT_RUNTIME
|| runtimeBits == USE_32_BIT_RUNTIME)
{
strcat(errMsg, " (");
strcat(errMsg, runtimeBits == USE_64_BIT_RUNTIME ? "64" : "32");
strcat(errMsg, "-bit)");
}
if (corruptedJreFound)
{
char launcherErrMsg[BIG_STR] = {0};
if (loadString(LAUNCHER_ERR, launcherErrMsg))
{
strcat(errMsg, "\n");
strcat(errMsg, launcherErrMsg);
}
}
loadString(DOWNLOAD_URL, errUrl);
return FALSE;
}
}
// Store the JRE Home Dir
strcpy(jreHomeDir, cmd);
// Append a path to the Path environment variable
char jreBinPath[_MAX_PATH] = {0};
strcpy(jreBinPath, cmd);
strcat(jreBinPath, "\\bin");
if (!appendToPathVar(jreBinPath))
{
debug(ERROR_FORMAT, "appendToPathVar failed.");
return FALSE;
}
// Set environment variables
char envVars[MAX_VAR_SIZE] = {0};
loadString(ENV_VARIABLES, envVars);
char *var = strtok(envVars, "\t");
while (var != NULL)
{
char *varValue = strchr(var, '=');
*varValue++ = 0;
*tmp = 0;
expandVars(tmp, varValue, exePath, pathLen);
debug("Set var:\t%s = %s\n", var, tmp);
SetEnvironmentVariable(var, tmp);
var = strtok(NULL, "\t");
}
*tmp = 0;
// Process priority
priority = loadInt(PRIORITY_CLASS);
// Launcher
appendJavaw(cmd);
// Heap sizes
appendHeapSizes(args);
// JVM options
char jvmOptions[MAX_ARGS] = {0};
setJvmOptions(jvmOptions, exePath);
// Expand environment %variables%
expandVars(args, jvmOptions, exePath, pathLen);
// MainClass + Classpath or Jar
char mainClass[STR] = {0};
char jar[_MAX_PATH] = {0};
const BOOL wrapper = loadBool(WRAPPER);
loadString(JAR, jar);
if (loadString(MAIN_CLASS, mainClass))
{
if (!loadString(CLASSPATH, tmp))
{
debug("Info:\t\tClasspath not defined.\n");
}
char exp[MAX_ARGS] = {0};
expandVars(exp, tmp, exePath, pathLen);
strcat(args, "-classpath \"");
if (wrapper)
{
appendAppClasspath(args, exePath);
}
else if (*jar)
{
appendAppClasspath(args, jar);
}
// Deal with wildcards or >> strcat(args, exp); <<
char* cp = strtok(exp, ";");
while(cp != NULL)
{
debug("Add classpath:\t%s\n", cp);
if (strpbrk(cp, "*?") != NULL)
{
int len = strrchr(cp, '\\') - cp + 1;
strncpy(tmp_path, cp, len);
char* filename = tmp_path + len;
*filename = 0;
struct _finddata_t c_file;
long hFile;
if ((hFile = _findfirst(cp, &c_file)) != -1L)
{
do
{
strcpy(filename, c_file.name);
appendAppClasspath(args, tmp_path);
debug(" \" :\t%s\n", tmp_path);
} while (_findnext(hFile, &c_file) == 0);
}
_findclose(hFile);
}
else
{
appendAppClasspath(args, cp);
}
cp = strtok(NULL, ";");
}
*(args + strlen(args) - 1) = 0;
strcat(args, "\" ");
strcat(args, mainClass);
}
else if (wrapper)
{
strcat(args, "-jar \"");
strcat(args, exePath);
strcat(args, "\"");
}
else
{
strcat(args, "-jar \"");
strncat(args, exePath, pathLen);
appendPath(args, jar);
strcat(args, "\"");
}
// Constant command line args
if (loadString(CMD_LINE, tmp))
{
strcat(args, " ");
strcat(args, tmp);
}
// Command line args
if (*lpCmdLine)
{
strcpy(tmp, lpCmdLine);
char* dst;
while ((dst = strstr(tmp, "--l4j-")) != NULL)
{
char* src = strchr(dst, ' ');
if (src == NULL || *(src + 1) == 0)
{
*dst = 0;
}
else
{
strcpy(dst, src + 1);
}
}
if (*tmp)
{
strcat(args, " ");
strcat(args, tmp);
}
}
debug("Launcher:\t%s\n", cmd);
debug("Launcher args:\t%s\n", args);
debug("Args length:\t%d/32768 chars\n", strlen(args));
return TRUE;
}
void Interpreter::executeFun(uint16_t id)
{
_bc = ((BytecodeFunction*)_code->functionById(id))->bytecode();
_insPtr = 0;
Instruction inst;
while (true) {
inst = nextInsn();
//cout << "Current instruction " << inst << endl;
//cout << "__STACK:" << endl;
//printStack();
switch (inst) {
case BC_INVALID:
_out << inst << " Invalid instruction" << endl;
assert(false);
break;
case BC_DLOAD:
loadDouble();
break;
case BC_ILOAD:
loadInt();
break;
case BC_SLOAD:
loadString();
break;
case BC_DLOAD0:
_out << inst << " Not implemented" << endl;
assert(false);
break;
case BC_ILOAD0:
pushInt(0);
break;
case BC_SLOAD0:
_out << inst << " Not implemented" << endl;
exit(EXIT_FAILURE);
break;
case BC_DLOAD1:
_out << inst << " Not implemented" << endl;
exit(EXIT_FAILURE);
break;
case BC_ILOAD1:
pushInt(1);
break;
case BC_DLOADM1:
_out << inst << " Not implemented" << endl;
exit(EXIT_FAILURE);
break;
case BC_ILOADM1:
pushInt(-1);
break;
case BC_DADD:
addDoubles();
break;
case BC_IADD:
addInts();
break;
case BC_DSUB:
subDoubles();
break;
case BC_ISUB:
subInts();
break;
case BC_DMUL:
dMul();
break;
case BC_IMUL:
iMul();
break;
case BC_DDIV:
divDoubles();
break;
case BC_IDIV:
divInts();
break;
case BC_IMOD:
_out << inst << " Not implemented" << endl;
exit(EXIT_FAILURE);
break;
case BC_DNEG:
dNeg();
break;
case BC_INEG:
iNeg();
break;
case BC_IPRINT:
printInt();
break;
case BC_DPRINT:
printDouble();
break;
case BC_SPRINT:
printString();
break;
case BC_I2D:
_out << inst << " Not implemented" << endl;
exit(EXIT_FAILURE);
break;
case BC_D2I:
_out << inst << " Not implemented" << endl;
exit(EXIT_FAILURE);
break;
case BC_S2I:
_out << inst << " Not implemented" << endl;
exit(EXIT_FAILURE);
break;
case BC_SWAP:
swap();
break;
case BC_POP:
_out << inst << " Not implemented" << endl;
exit(EXIT_FAILURE);
break;
case BC_LOADDVAR0:
_out << inst << " Not implemented" << endl;
exit(EXIT_FAILURE);
break;
case BC_LOADDVAR1:
_out << inst << " Not implemented" << endl;
exit(EXIT_FAILURE);
break;
case BC_LOADDVAR2:
_out << inst << " Not implemented" << endl;
exit(EXIT_FAILURE);
break;
case BC_LOADDVAR3:
_out << inst << " Not implemented" << endl;
exit(EXIT_FAILURE);
break;
case BC_LOADIVAR0:
_out << inst << " Not implemented" << endl;
exit(EXIT_FAILURE);
break;
case BC_LOADIVAR1:
_out << inst << " Not implemented" << endl;
exit(EXIT_FAILURE);
break;
case BC_LOADIVAR2:
_out << inst << " Not implemented" << endl;
exit(EXIT_FAILURE);
break;
case BC_LOADIVAR3:
_out << inst << " Not implemented" << endl;
exit(EXIT_FAILURE);
break;
case BC_LOADSVAR0:
_out << inst << " Not implemented" << endl;
exit(EXIT_FAILURE);
break;
case BC_LOADSVAR1:
_out << inst << " Not implemented" << endl;
exit(EXIT_FAILURE);
break;
case BC_LOADSVAR2:
_out << inst << " Not implemented" << endl;
exit(EXIT_FAILURE);
break;
case BC_LOADSVAR3:
_out << inst << " Not implemented" << endl;
exit(EXIT_FAILURE);
break;
case BC_STOREDVAR0:
_out << inst << " Not implemented" << endl;
exit(EXIT_FAILURE);
break;
case BC_STOREDVAR1:
_out << inst << " Not implemented" << endl;
exit(EXIT_FAILURE);
break;
case BC_STOREDVAR2:
_out << inst << " Not implemented" << endl;
exit(EXIT_FAILURE);
break;
case BC_STOREDVAR3:
_out << inst << " Not implemented" << endl;
exit(EXIT_FAILURE);
break;
case BC_STOREIVAR0:
_out << inst << " Not implemented" << endl;
exit(EXIT_FAILURE);
break;
case BC_STOREIVAR1:
_out << inst << " Not implemented" << endl;
exit(EXIT_FAILURE);
break;
case BC_STOREIVAR2:
_out << inst << " Not implemented" << endl;
exit(EXIT_FAILURE);
break;
case BC_STOREIVAR3:
_out << inst << " Not implemented" << endl;
exit(EXIT_FAILURE);
break;
case BC_STORESVAR0:
_out << inst << " Not implemented" << endl;
exit(EXIT_FAILURE);
break;
case BC_STORESVAR1:
_out << inst << " Not implemented" << endl;
exit(EXIT_FAILURE);
break;
case BC_STORESVAR2:
_out << inst << " Not implemented" << endl;
exit(EXIT_FAILURE);
break;
case BC_STORESVAR3:
_out << inst << " Not implemented" << endl;
exit(EXIT_FAILURE);
break;
case BC_LOADDVAR:
_out << inst << " Not implemented" << endl;
exit(EXIT_FAILURE);
break;
case BC_LOADIVAR:
_out << inst << " Not implemented" << endl;
exit(EXIT_FAILURE);
break;
case BC_LOADSVAR:
_out << inst << " Not implemented" << endl;
exit(EXIT_FAILURE);
break;
case BC_STOREDVAR:
_out << inst << " Not implemented" << endl;
exit(EXIT_FAILURE);
break;
case BC_STOREIVAR:
_out << inst << " Not implemented" << endl;
exit(EXIT_FAILURE);
break;
case BC_STORESVAR:
_out << inst << " Not implemented" << endl;
exit(EXIT_FAILURE);
break;
case BC_LOADCTXDVAR:
loadCtxDouble();
break;
case BC_LOADCTXIVAR:
loadCtxInt();
break;
case BC_LOADCTXSVAR:
_out << inst << " Not implemented" << endl;
exit(EXIT_FAILURE);
break;
case BC_STORECTXDVAR:
storeCtxDouble();
break;
case BC_STORECTXIVAR:
storeCtxInt();
break;
case BC_STORECTXSVAR:
_out << inst << " STORE STRING ? Not implemented" << endl;
exit(EXIT_FAILURE);
break;
case BC_DCMP:
_out << inst << " Not implemented" << endl;
exit(EXIT_FAILURE);
break;
case BC_ICMP:
compareInts();
break;
case BC_JA:
jumpAlways();
break;
case BC_IFICMPNE:
intsNotEqualJMP();
break;
case BC_IFICMPE:
intsEqualJMP();
break;
case BC_IFICMPG:
GJump();
break;
case BC_IFICMPGE:
GEJump();
break;
case BC_IFICMPL:
//cout << "IFLESS" << endl;
assert(false);
break;
case BC_IFICMPLE:
LEJump();
break;
case BC_DUMP:
_out << inst << " Not implemented" << endl;
exit(EXIT_FAILURE);
break;
case BC_STOP:
this->popContext();
return;
case BC_CALL:
//cout << "CALLING. STACK SIZE: " << _stack.size() << endl;
call();
break;
case BC_CALLNATIVE:
_out << inst << " Not implemented" << endl;
exit(EXIT_FAILURE);
break;
case BC_RETURN:
doReturn();
break;
case BC_BREAK:
_out << inst << " Not implemented" << endl;
exit(EXIT_FAILURE);
break;
default:
_out << "Bad instruction" << endl;
break;
}
}
this->popContext();
}
void GeneticFrameModelerWidget::loadModel()
{
ComputationParameters params;
params.setInt(GeneticFrameModeler::PARAM_NUMDSTEPS, loadInt(GeneticFrameModeler::PARAM_NUMDSTEPS));
numdstepsEdit->setValue(loadInt(GeneticFrameModeler::PARAM_NUMDSTEPS));
params.setInt(GeneticFrameModeler::PARAM_NUMSTATES, loadInt(GeneticFrameModeler::PARAM_NUMSTATES));
numstatesEdit->setValue(loadInt(GeneticFrameModeler::PARAM_NUMSTATES));
params.setInt(GeneticFrameModeler::PARAM_AUTOC, loadInt(GeneticFrameModeler::PARAM_AUTOC));
numautocEdit->setValue(loadInt(GeneticFrameModeler::PARAM_AUTOC));
params.setInt(GeneticFrameModeler::PARAM_NUMITERATIONS, loadInt(GeneticFrameModeler::PARAM_NUMITERATIONS));
numiterationsEdit->setValue(loadInt(GeneticFrameModeler::PARAM_NUMITERATIONS));
params.setInt(GeneticFrameModeler::PARAM_NUMPOOLSIZE, loadInt(GeneticFrameModeler::PARAM_NUMPOOLSIZE));
numpoolEdit->setValue(loadInt(GeneticFrameModeler::PARAM_NUMPOOLSIZE));
params.setReal(GeneticFrameModeler::PARAM_MUTBLOCK, loadReal(GeneticFrameModeler::PARAM_MUTBLOCK));
mutBlock->setValue(_double ( loadReal(GeneticFrameModeler::PARAM_MUTBLOCK) ));
params.setReal(GeneticFrameModeler::PARAM_MUTINVERSE, loadReal(GeneticFrameModeler::PARAM_MUTINVERSE));
mutInverse->setValue(_double ( loadReal(GeneticFrameModeler::PARAM_MUTINVERSE) ));
params.setReal(GeneticFrameModeler::PARAM_MUTSHUFFLE, loadReal(GeneticFrameModeler::PARAM_MUTSHUFFLE));
mutShuffle->setValue(_double ( loadReal(GeneticFrameModeler::PARAM_MUTSHUFFLE) ));
params.setReal(GeneticFrameModeler::PARAM_MUTSWAP, loadReal(GeneticFrameModeler::PARAM_MUTSWAP));
mutSwap->setValue(_double ( loadReal(GeneticFrameModeler::PARAM_MUTSWAP) ));
params.setReal(GeneticFrameModeler::PARAM_MUTCROSSOVER, loadReal(GeneticFrameModeler::PARAM_MUTCROSSOVER));
mutCrossover->setValue(_double ( loadReal(GeneticFrameModeler::PARAM_MUTCROSSOVER) ));
params.setInt( GeneticFrameModeler::PARAM_FRAMELEVEL, loadInt(GeneticFrameModeler::PARAM_FRAMELEVEL));
framelevel->setValue( loadInt( GeneticFrameModeler::PARAM_FRAMELEVEL ) );
modeler->setParameters(params);
}
