void Component::parseBCLSearchResult(const BCLSearchResult & bclSearchResult) { m_componentType = bclSearchResult.componentType().c_str(); m_name = bclSearchResult.name().c_str(); m_uid = bclSearchResult.uid().c_str(); m_versionId = bclSearchResult.versionId().c_str(); m_description = bclSearchResult.description().c_str(); m_fidelityLevel = bclSearchResult.fidelityLevel().c_str(); m_attributes = bclSearchResult.attributes(); m_files = bclSearchResult.files(); m_provenances = bclSearchResult.provenances(); m_tags = bclSearchResult.tags(); std::string componentVersion; Q_FOREACH(const BCLFile & file, m_files){ if (file.usageType() == "script" && file.softwareProgram() == "OpenStudio"){ componentVersion = file.identifier(); break; } } if (!componentVersion.empty() && VersionString(componentVersion) > VersionString(openStudioVersion())){ m_available = false; }else{ m_available = true; } }
static void FChecks_VersionResponse (void) { if (Modules_SecurityLoaded()) Cbuf_AddText (va("say ezQuake %s " QW_PLATFORM ":" QW_RENDERER " crc: %s\n", VersionString(), Auth_Generate_Crc())); else Cbuf_AddText (va("say ezQuake %s " QW_PLATFORM ":" QW_RENDERER "\n", VersionString())); }
VersionString extractOpenStudioVersion(const QVariant& variant) { QJsonObject topLevel = QJsonDocument::fromVariant(variant).object(); if (topLevel.contains("metadata")) { topLevel = topLevel["metadata"].toObject(); } OptionalVersionString version; if (topLevel.contains("openstudio_version")) { version = VersionString(topLevel["openstudio_version"].toString().toStdString()); } else if (topLevel.contains("version")) { version = VersionString(topLevel["version"].toString().toStdString()); } else { LOG_FREE_AND_THROW("openstudio.core.Json","No version identifier found in QJSON variant."); } OS_ASSERT(version); if (version.get() > VersionString(openStudioVersion())) { LOG_FREE(Warn,"openstudio.Json","Loading json file from version " << version << " with OpenStudio version " << VersionString(openStudioVersion()) << ". OpenStudio json files are not designed to be forwards-compatible. " << "Unexpected behavior may result.") } return version.get(); }
void ServersListModel::setVersionString(int index, const std::string &version) { if (version.empty()) mVersionStrings[index] = VersionString(0, ""); else { int width = gui->getFont()->getWidth(version); mVersionStrings[index] = VersionString(width, version); } }
FileReference toFileReference(const QVariant& variant, const VersionString& version) { QVariantMap map = variant.toMap(); OptionalDateTime timestampCreate, timestampLast; if (version < VersionString("1.0.4")) { timestampCreate = DateTime(map["timestamp_create"].toString().toStdString()); timestampLast = DateTime(map["timestamp_last"].toString().toStdString()); } else { timestampCreate = DateTime::fromISO8601(map["timestamp_create"].toString().toStdString()); timestampLast = DateTime::fromISO8601(map["timestamp_last"].toString().toStdString()); } OS_ASSERT(timestampCreate); OS_ASSERT(timestampLast); return FileReference(toUUID(map["uuid"].toString().toStdString()), toUUID(map["version_uuid"].toString().toStdString()), map.contains("name") ? map["name"].toString().toStdString() : std::string(), map.contains("display_name") ? map["display_name"].toString().toStdString() : std::string(), map.contains("description") ? map["description"].toString().toStdString() : std::string(), toPath(map["path"].toString()), FileReferenceType(map["file_type"].toString().toStdString()), timestampCreate.get(), timestampLast.get(), map["checksum_create"].toString().toStdString(), map["checksum_last"].toString().toStdString()); }
std::pair<VersionString, std::string> IddFile::parseVersionBuild(const openstudio::path &p) { std::ifstream ifs(openstudio::toString(p)); if (!ifs.good()) { throw std::runtime_error("Unable to open file for reading: " + openstudio::toString(p)); } ifs.seekg(0, std::ios_base::end); const auto end = ifs.tellg(); ifs.seekg(0, std::ios_base::beg); const auto length_to_read = std::min(std::streampos(10000), end); std::vector<char> data(length_to_read); ifs.read(data.data(), length_to_read); const std::string strdata(data.cbegin(), data.cend()); std::string build; boost::smatch matches; if (boost::regex_search(strdata, matches, iddRegex::build())) { build = std::string(matches[1].first,matches[1].second); } if (boost::regex_search(strdata, matches, iddRegex::version())) { return std::make_pair(VersionString(std::string(matches[1].first, matches[1].second)), build); } throw std::runtime_error("Unable to parse version from IDD: " + openstudio::toString(p)); }
bool GLContext::MarkExtensionGroupUnsupported(GLExtensionGroup extensionGroup) { MOZ_ASSERT(IsExtensionSupported(extensionGroup), "extension group is already unsupported!"); if (IsExtensionGroupIsPartOfProfileVersion(extensionGroup, mProfile, mVersion)) { NS_WARNING(nsPrintfCString("%s marked as unsupported, but it's supposed to be supported by %s %s", GetExtensionGroupName(extensionGroup), ProfileString(), VersionString()).get()); return false; } const ExtensionGroupInfo& groupInfo = GetExtensionGroupInfo(extensionGroup); for (size_t i = 0; true; i++) { MOZ_ASSERT(i < kMAX_EXTENSION_GROUP_SIZE, "kMAX_EXTENSION_GROUP_SIZE too small"); if (groupInfo.mExtensions[i] == GLContext::Extensions_End) { break; } MarkExtensionUnsupported(groupInfo.mExtensions[i]); } MOZ_ASSERT(!IsExtensionSupported(extensionGroup), "GLContext::MarkExtensionGroupUnsupported has failed!"); NS_WARNING(nsPrintfCString("%s marked as unsupported", GetExtensionGroupName(extensionGroup)).get()); return true; }
// Prints a directory of contents. void TessdataManager::Directory() const { tprintf("Version string:%s\n", VersionString().c_str()); int offset = TESSDATA_NUM_ENTRIES * sizeof(int64_t); for (int i = 0; i < TESSDATA_NUM_ENTRIES; ++i) { if (!entries_[i].empty()) { tprintf("%d:%s:size=%d, offset=%d\n", i, kTessdataFileSuffixes[i], entries_[i].size(), offset); offset += entries_[i].size(); } } }
/// <summary>Loads game data</summary> /// <param name="data">arguments.</param> /// <returns></returns> DWORD WINAPI GameDataWorker::ThreadMain(GameDataWorkerData* data) { try { XFileSystem vfs; HRESULT hr; // Init COM if (FAILED(hr=CoInitialize(NULL))) throw ComException(HERE, hr); // Feedback Console << Cons::UserAction << L"Loading " << VersionString(data->Version) << L" game data from " << data->GameFolder << ENDL; data->SendFeedback(ProgressType::Operation, 0, VString(L"Loading %s game data from '%s'", VersionString(data->Version).c_str(), data->GameFolder.c_str())); // Build VFS. vfs.Enumerate(data->GameFolder, data->Version, data); // language files StringLib.Enumerate(vfs, data->Language, data); // script/game objects ScriptObjectLib.Enumerate(data); GameObjectLib.Enumerate(vfs, data); // Descriptions DescriptionLib.Enumerate(data); // legacy syntax file SyntaxLib.Enumerate(data); // Cleanup data->SendFeedback(Cons::UserAction, ProgressType::Succcess, 0, VString(L"Loaded %s game data successfully", VersionString(data->Version).c_str())); CoUninitialize(); return 0; } catch (ExceptionBase& e) { // Feedback Console.Log(HERE, e); Console << ENDL; data->SendFeedback(Cons::Error, ProgressType::Failure, 0, GuiString(L"Failed to load game data : ") + e.Message); // BEEP! MessageBeep(MB_ICONERROR); // Cleanup CoUninitialize(); return 0; } }
AnalysisJSONLoadResult loadJSON(const openstudio::path& p) { OptionalAnalysisObject result; StringStreamLogSink logger; logger.setLogLevel(Error); try { QVariant variant = openstudio::loadJSON(p); VersionString version = extractOpenStudioVersion(variant); QVariantMap map = variant.toMap(); QVariantMap objectMap; if (map.contains("data_point")) { // leave objectMap blank, because it cannot contain project_dir result = detail::DataPoint_Impl::factoryFromVariant(map["data_point"],version,boost::none); } else if (map.contains("analysis")) { objectMap = map["analysis"].toMap(); result = detail::Analysis_Impl::fromVariant(objectMap,version); } else { LOG_FREE_AND_THROW("openstudio.analysis.AnalysisObject", "The file at " << toString(p) << " does not contain a data_point or " << "an analysis."); } OS_ASSERT(result); openstudio::path projectDir; if (version < VersionString("1.1.2")) { OS_ASSERT(map.contains("metadata")); if (map["metadata"].toMap().contains("project_dir")) { projectDir = toPath(map["metadata"].toMap()["project_dir"].toString()); } } else { if (objectMap.contains("project_dir")) { projectDir = toPath(objectMap["project_dir"].toString()); } } return AnalysisJSONLoadResult(*result,projectDir,version); } catch (std::exception& e) { LOG_FREE(Error,"openstudio.analysis.AnalysisObject", "The file at " << toString(p) << " cannot be parsed as an OpenStudio " << "analysis framework json file, because " << e.what()); } catch (...) { LOG_FREE(Error,"openstudio.analysis.AnalysisObject", "The file at " << toString(p) << " cannot be parsed as an OpenStudio " << "analysis framework json file."); } return AnalysisJSONLoadResult(logger.logMessages()); }
BCLFile::BCLFile(const QDomElement& fileElement) { QDomElement softwareProgramElement = fileElement.firstChildElement("version").firstChildElement("software_program"); QDomElement identifierElement = fileElement.firstChildElement("version").firstChildElement("identifier"); QDomElement minCompatibleElement = fileElement.firstChildElement("version").firstChildElement("min_compatible"); QDomElement maxCompatibleElement = fileElement.firstChildElement("version").firstChildElement("max_compatible"); QDomElement filenameElement = fileElement.firstChildElement("filename"); QDomElement urlElement = fileElement.firstChildElement("url"); QDomElement filetypeElement = fileElement.firstChildElement("filetype"); QDomElement usageTypeElement = fileElement.firstChildElement("usage_type"); QDomElement checksumElement = fileElement.firstChildElement("checksum"); m_softwareProgram = softwareProgramElement.firstChild().nodeValue().toStdString(); m_identifier = identifierElement.firstChild().nodeValue().toStdString(); if (minCompatibleElement.isNull()){ try{ // if minCompatibleVersion not explicitly set, assume identifier is min m_minCompatibleVersion = VersionString(m_identifier); } catch (const std::exception&){ } }else{ try{ m_minCompatibleVersion = VersionString(minCompatibleElement.firstChild().nodeValue().toStdString()); } catch (const std::exception&){ } } if (!maxCompatibleElement.isNull()){ try{ m_maxCompatibleVersion = VersionString(maxCompatibleElement.firstChild().nodeValue().toStdString()); } catch (const std::exception&){ } } m_filename = filenameElement.firstChild().nodeValue().toStdString(); m_url = urlElement.firstChild().nodeValue().toStdString(); m_filetype = filetypeElement.firstChild().nodeValue().toStdString(); m_usageType = usageTypeElement.firstChild().nodeValue().toStdString(); m_checksum = checksumElement.firstChild().nodeValue().toStdString(); }
std::string User::InfoText() const { std::ostringstream ss; ss << std::setw(22) << std::left << "Name: " << std::setw(32) << std::left << name << '\r' << std::setw(22) << std::left << "Login: "******"Password Hash: " << std::setw(32) << std::left << PasswordSumString() << '\r' << std::setw(22) << std::left << "Address: " << std::setw(32) << std::left << sock.remote_endpoint().address().to_string() << '\r' << std::setw(22) << std::left << "Port: " << std::setw(32) << std::left << sock.remote_endpoint().port() << '\r' << std::setw(22) << std::left << "Hostname: " << std::setw(32) << std::left << host << '\r' << std::setw(22) << std::left << "User ID: " << std::setw(32) << std::left << id << '\r' << std::setw(22) << std::left << "Version: " << std::setw(32) << std::left << VersionString() << '\r' << std::setw(22) << std::left << "Icon: " << std::setw(32) << std::left << icon << '\r' << std::setw(22) << std::left << "Last Transaction ID: " << std::setw(32) << std::left << last_trans_id << '\r' << std::setw(22) << std::left << "Transaction Replies: " << std::setw(32) << std::left << nreplies << '\r'; return ss.str(); }
static void Config_PrintPreamble(FILE *f) { extern cvar_t name; char *newlines = "\n"; Config_PrintBorder(f); Config_PrintBorder(f); Config_PrintLine(f, "", 3); Config_PrintLine(f, "", 3); Config_PrintLine(f, "E Z Q U A K E C O N F I G U R A T I O N", 3); Config_PrintLine(f, "", 3); Config_PrintLine(f, "", 3); Config_PrintBorder(f); Config_PrintBorder(f); fprintf(f,"\n// %s's config\n\n", name.string); fprintf(f,"// ezQuake %s " __DATE__ ", " __TIME__"\n", VersionString()); if (cfg_save_cmdline.value) { DumpCmdLine(f); fprintf(f, "%s", newlines); } }
/// <summary>Writes a revision</summary> /// <param name="r">Revision.</param> /// <param name="parent">root node.</param> /// <exception cref="Logic::ArgumentNullException">Parent is nullptr</exception> void BackupFileWriter::WriteRevision(const ScriptRevision& r, XmlElementPtr& parent) { REQUIRED(parent); // <revision title="third revision" date="2013-03-12 18:00:00" path="D:\X3 Albion Prelude\scripts\plugin.piracy.lib.logic.xml"> auto node = WriteElement(parent, L"revision"); WriteAttribute(node, L"title", r.Title); WriteAttribute(node, L"date", (LPCWSTR)r.Date.Format(L"%Y-%m-%d %H:%M:%S")); // yyyy-mm-dd hh:mm:ss WriteAttribute(node, L"path", r.FullPath.c_str()); // <scriptname>plugin.piracy.lib.logic</scriptname> // <version>102</version> // <game>X3TC</game> // <description>Piracy logic library</description> // <command>1019</command> // <text>* Validate Parameters...</text> WriteElement(node, L"scriptname", r.ScriptName); WriteElement(node, L"version", VString(L"%d", r.Version)); WriteElement(node, L"game", VersionString(r.Game, true)); WriteElement(node, L"description", r.Description); WriteElement(node, L"command", VString(L"%d", r.CommandID)); WriteElement(node, L"text", r.Content); }
/* * Print information related to the rVersion resource * passed as a parameter. */ static void PrintVersionResource(ptr rezPtr) { rVersPtr rVers_addr; String(9) string_version; unsigned long moreInfo; int country_num; char *country; /* Translate version from raw number to string */ rVers_addr = (rVersPtr)rezPtr; VersionString(0, rVers_addr->version, (Ptr)&string_version); /* Print product name and string version */ Print8bitString((ptr) &(rVers_addr->product)); putchar(' '); PrintPString((ptr) &string_version); putchar('\n'); /* All done if -b (brief) option was specified */ if ( bflag ) return; /* The "moreInfo" p-string follows the product p-string */ moreInfo = (unsigned long)&(rVers_addr->product) + rVers_addr->product.textLength + 1; Print8bitString((Ptr)moreInfo); putchar('\n'); /* Print the country information */ if ( (country_num=rVers_addr->country) < NUM_COUNTRY) country = countryTbl[country_num]; if (country_num >= NUM_COUNTRY || country == NULL ) (void)printf("Country: %d unknown to this version of getvers\n", country_num); else (void)printf("Country: %s\n", country); }
//childloop int ChildLoop(int acc, char *client_address, char *greeting){ fd_set read_mask; fd_set write_mask; fd_set mask; int width; struct timeval timeout; int end_flag; int i; int comm_ptr = 0; int comm_esc = 0; int flag_comm_end = 0; int skip = 0; int is_exec = 0; DB(fprintf(stderr,"ChildLoop\n")); //block mode SetBlock(acc,0); //mask width=0; FD_ZERO(&mask); DB(fprintf(stderr,"sizeof(fd_set):%ld:\n",sizeof(fd_set))); DB(fprintf(stderr,"size of fds_bits:%ld:\n",sizeof(mask.__fds_bits))); DB(fprintf(stderr,"fds_bits[0]:%ld:\n",mask.__fds_bits[0])); DB(fprintf(stderr,"acc before FD_SET:%d:\n",acc)); FD_SET(acc,&mask); DB(fprintf(stderr,"acc after FD_SET:%d:\n",acc)); width=acc+1; //acc: (maximam during read_mask and write_mask) + 1 DB(fprintf(stderr,"width (acc+1):%d:\n",width)); //init data for sending SendBuf.size=SHORT_BUFF_SIZE; if((SendBuf.buf=calloc(SendBuf.size,sizeof(char))) == NULL){perror("calloc"); exit(1);} sprintf(SendBuf.buf,"Ready %s",VersionString()); SendBuf.len=strlen(SendBuf.buf); //send-secv loop end_flag=0; while(1){ is_exec = 0; read_mask=mask; if(SendBuf.len>0){ write_mask=mask; }else{ FD_ZERO(&write_mask); } timeout.tv_sec=TIMEOUT_S; timeout.tv_usec=TIMEOUT_US; switch(select(width,(fd_set *)&read_mask,&write_mask,NULL,&timeout)){ case -1: if(errno!=EINTR){ perror("select"); } break; case 0: break; default: //recv if(FD_ISSET(acc,&read_mask)){ //end_flag=RecvData(acc); RecvData(acc); } //operation after recv DB(fprintf(stderr,"after RecvData() RecvBuf.buf:%s:\n",RecvBuf.buf)); DB(fprintf(stderr,"after RecvData() RecvBuf.len:%d:\n",RecvBuf.len)); if((CommBuf.size - CommBuf.len) > RecvBuf.size){ for(i=0;i<RecvBuf.len;i++){ //if((RecvBuf.buf[i] == ';')&&(comm_esc == 0)){ if((RecvBuf.buf[i] == 0x04)&&(comm_esc == 0)){ CommBuf.buf[comm_ptr + i] = '\0'; CommBuf.len = comm_ptr + i; flag_comm_end = 1; comm_esc = 0; }else if((RecvBuf.buf[i] == '\\')&&(comm_esc == 0)){ comm_ptr = comm_ptr - 1; comm_esc = 1; }else if((RecvBuf.buf[i] == '\\')&&(comm_esc > 0)){ CommBuf.buf[comm_ptr + i] = '\\'; CommBuf.len = comm_ptr + i; comm_esc = 0; }else{ CommBuf.buf[comm_ptr + i] = RecvBuf.buf[i]; comm_esc = 0; } //DB(fprintf(stderr,"commesc:%d:%c:",comm_esc,RecvBuf.buf[i])); } }else{ flag_comm_end = 2; } /* if(strncmp(CommBuf.buf,"end",3) == 0){ end_flag = 1; } */ //command operation if(flag_comm_end == 1){ //preprocess skip=0; comm_esc = 0; for(i=0;i<CommBuf.len;i++){ if((CommBuf.buf[i] >= 33)&&(CommBuf.buf[i] <= 126)){ break; }else{ skip++; } } for(i=skip; i<CommBuf.len; i++){ CommBuf.buf[i - skip] = CommBuf.buf[i]; } CommBuf.buf[i - skip] = '\0'; CommBuf.len = CommBuf.len - skip; DB(fprintf(stderr,"preprocessed COMMSIZE:%d:\n",CommBuf.len)); DB(fprintf(stderr,"preprocessed COMM:")); DB(fprintf(stderr,"%s",CommBuf.buf)); DB(fprintf(stderr,":\n")); //exec comm and write to RsltBuf is_exec = ExecComm(); //create SendData if((SendBuf.buf = malloc(sizeof(char) * (CommBuf.len + 40 + RsltBuf.len))) == NULL){perror("malloc()"); exit(1);} sprintf(SendBuf.buf,"%s","comm:"); sprintf(SendBuf.buf+5,"%s",CommBuf.buf); sprintf(SendBuf.buf+5+CommBuf.len,"%s",":\n"); SendBuf.len = strlen(SendBuf.buf); if(is_exec > 0){ sprintf(SendBuf.buf+SendBuf.len,"%s",RsltBuf.buf); SendBuf.len = strlen(SendBuf.buf); if(RsltBuf.buf != NULL){ free(RsltBuf.buf); RsltBuf.buf = NULL; RsltBuf.size = 0; RsltBuf.len = 0; } } }else if(flag_comm_end == 2){ if((SendBuf.buf = malloc(sizeof(char) * (40))) == NULL){perror("malloc()"); exit(1);} sprintf(SendBuf.buf,"%s","error: commsize over.\n"); SendBuf.len = strlen(SendBuf.buf); } //cleaning if(flag_comm_end == 1){ if((CommBuf.len > 0) && (strncmp(CommBuf.buf,"end;",4) == 0)){ end_flag = 1; } for(i=0;i<CommBuf.len;i++){ CommBuf.buf[i] = '\0'; } for(i=0;i<RecvBuf.len;i++){ RecvBuf.buf[i] = '\0'; } comm_ptr = 0; flag_comm_end = 0; }else{ comm_ptr = comm_ptr + i; } //send if(FD_ISSET(acc,&write_mask)){ SendData(acc,&SendBuf); } break; } if(end_flag == 1){ DB(fprintf(stderr,"session break.\n")); break; } } return(0); }
/* =============== SV_InitLocal =============== */ void SV_InitLocal (void) { int i; extern cvar_t sv_spectalk; extern cvar_t sv_mapcheck; extern cvar_t sv_minping; extern cvar_t sv_maxpitch; extern cvar_t sv_minpitch; extern cvar_t sv_nailhack; extern cvar_t sv_loadentfiles; extern cvar_t sv_maxvelocity; extern cvar_t sv_gravity; extern cvar_t pm_stopspeed; extern cvar_t pm_spectatormaxspeed; extern cvar_t pm_accelerate; extern cvar_t pm_airaccelerate; extern cvar_t pm_wateraccelerate; extern cvar_t pm_friction; extern cvar_t pm_waterfriction; extern cvar_t pm_bunnyspeedcap; extern cvar_t pm_ktjump; extern cvar_t pm_slidefix; extern cvar_t pm_airstep; extern cvar_t pm_pground; packet_t *packet_freeblock; // initialise delayed packet free block SV_InitOperatorCommands (); Cvar_Register (&sv_rconPassword); Cvar_Register (&sv_password); Cvar_Register (&sv_spectatorPassword); Cvar_Register (&sv_phs); Cvar_Register (&sv_paused); Cvar_Register (&sv_pausable); Cmd_AddLegacyCommand ("pausable", "sv_pausable"); Cvar_Register (&sv_nailhack); Cvar_Register (&sv_maxrate); Cvar_Register (&sv_fastconnect); Cvar_Register (&sv_loadentfiles); if (!dedicated) sv_mintic.string = "0"; // a value of 0 will tie physics tics to screen updates Cvar_Register (&sv_mintic); Cvar_Register (&sv_maxtic); Cvar_Register (&sv_timeout); Cmd_AddLegacyCommand ("timeout", "sv_timeout"); Cvar_Register (&sv_zombietime); Cmd_AddLegacyCommand ("zombietime", "sv_zombietime"); Cvar_Register (&sv_spectalk); Cvar_Register (&sv_mapcheck); if (dedicated) Cvar_Register (&sv_minping); Cvar_Register (&sv_maxpitch); Cvar_Register (&sv_minpitch); Cvar_Register (&deathmatch); Cvar_Register (&teamplay); Cvar_Register (&skill); Cvar_Register (&coop); Cvar_Register (&fraglimit); Cvar_Register (&timelimit); Cvar_Register (&samelevel); Cvar_Register (&maxclients); Cvar_Register (&maxspectators); Cvar_Register (&hostname); Cvar_Register (&watervis); Cvar_Register (&sv_maxvelocity); Cvar_Register (&sv_gravity); Cvar_Register (&pm_stopspeed); Cvar_Register (&pm_maxspeed); Cvar_Register (&pm_spectatormaxspeed); Cvar_Register (&pm_accelerate); Cvar_Register (&pm_airaccelerate); Cvar_Register (&pm_wateraccelerate); Cvar_Register (&pm_friction); Cvar_Register (&pm_waterfriction); Cvar_Register (&pm_bunnyspeedcap); Cvar_Register (&pm_ktjump); Cvar_Register (&pm_slidefix); Cvar_Register (&pm_airstep); Cvar_Register (&pm_pground); Cvar_Register (&allow_download); Cvar_Register (&allow_download_skins); Cvar_Register (&allow_download_models); Cvar_Register (&allow_download_sounds); Cvar_Register (&allow_download_maps); Cvar_Register (&allow_download_pakmaps); Cvar_Register (&allow_download_gfx); Cvar_Register (&allow_download_other); Cvar_Register (&filterban); Cmd_AddCommand ("addip", SV_AddIP_f); Cmd_AddCommand ("removeip", SV_RemoveIP_f); Cmd_AddCommand ("listip", SV_ListIP_f); Cmd_AddCommand ("writeip", SV_WriteIP_f); for (i=1 ; i<MAX_MODELS ; i++) sprintf (localmodels[i], "*%i", i); Info_SetValueForStarKey (svs.info, "*version", va(PROGRAM " %s", VersionString()), MAX_SERVERINFO_STRING); Info_SetValueForStarKey (svs.info, "*z_ext", va("%i", SUPPORTED_EXTENSIONS), MAX_SERVERINFO_STRING); #ifdef VWEP_TEST Info_SetValueForStarKey (svs.info, "*vwtest", "1", MAX_SERVERINFO_STRING); #endif if (strcmp(com_gamedirfile, "qw")) Info_SetValueForStarKey (svs.info, "*gamedir", com_gamedirfile, MAX_SERVERINFO_STRING); // init fraglog stuff svs.logsequence = 1; svs.logtime = svs.realtime; SZ_Init (&svs.log[0], svs.log_buf[0], sizeof(svs.log_buf[0])); svs.log[0].allowoverflow = true; SZ_Init (&svs.log[1], svs.log_buf[1], sizeof(svs.log_buf[1])); svs.log[1].allowoverflow = true; packet_freeblock = Hunk_AllocName(MAX_DELAYED_PACKETS * sizeof(packet_t), "delayed_packets"); for (i = 0; i < MAX_DELAYED_PACKETS; i++) { SZ_Init (&packet_freeblock[i].msg, packet_freeblock[i].buf, sizeof(packet_freeblock[i].buf)); packet_freeblock[i].next = &packet_freeblock[i + 1]; } packet_freeblock[MAX_DELAYED_PACKETS - 1].next = NULL; svs.free_packets = &packet_freeblock[0]; #ifdef MAUTH // Set up queues for temporary auth tokens and auth'd clients... authtokq.maxlen = MAX_AUTH_TOK_QUEUE; authtokq.curlen = 0; authtokq.start = NULL; authclientq.maxlen = MAX_AUTH_CLIENT_QUEUE; authclientq.curlen = 0; authclientq.start = NULL; #endif }
extern "C" int HandleCommandLine(int argc, char** argv) { bool displayHelp = false; bool displayBuild = false; bool displayCopyright = false; bool displayVersion = false; bool argError = false; char* iniFile = strdup("/afc/etc/dc.ini"); std::vector<int> commandLineDebugSettings; int flag = 1; int c; CsGetoptReset(); while ( (c = CsGetoptl(argc, argv, Option::shortOptions, Option::longOptions, 1)) != EOF ) { switch ( c ) { case Option::ERROROPT: if ( optopt == Option::ERROROPT ) displayHelp = true; else argError = true; break; case Option::HELP: displayHelp = true; break; case Option::BUILD: displayBuild = true; break; case Option::COPYRIGHT: displayCopyright = true; break; case Option::VERSION: displayVersion = true; break; case Option::NOT: flag = 0; break; case Option::CONSOLE: CsMsgOptset(CSMSGOP_CONSOLE, &flag, (uint32_t)sizeof(int32_t)); flag = 1; commandLineDebugSettings.push_back(CSMSGOP_CONSOLE); break; case Option::VERBOSE: CsMsgOptset(CSMSGOP_VERBOSE, &flag, (uint32_t)sizeof(int32_t)); flag = 1; commandLineDebugSettings.push_back(CSMSGOP_VERBOSE); break; case Option::WARNINGS: CsMsgOptset(CSMSGOP_WARNING, &flag, (uint32_t)sizeof(int32_t)); flag = 1; commandLineDebugSettings.push_back(CSMSGOP_WARNING); break; case Option::DEBUG_HIRES: CsMsgOptset(CSMSGOP_HIGHRES, &flag, (uint32_t)sizeof(int32_t)); commandLineDebugSettings.push_back(CSMSGOP_HIGHRES); /*FALLTHROUGH*/ case Option::DEBUG_LEVEL: flag = atoi(optarg); if ( (flag <= 0) || (flag > 9) ) { fprintf(stderr, "illegal debug level -- %s\n", optarg); argError = true; } CsMsgOptset(CSMSGOP_DEBUG, &flag, (uint32_t)sizeof(int32_t)); commandLineDebugSettings.push_back(CSMSGOP_DEBUG); commandLineDebugSettings.push_back(CSMSGOP_DEBUGENABLED); flag = 1; break; case Option::LOGGER: CsMsgOptset(CSMSGOP_LOGGER, &optarg, (uint32_t)sizeof(char*)); commandLineDebugSettings.push_back(CSMSGOP_LOGGER); break; case Option::INI_FILE: if ( iniFile != 0 ) free(iniFile); iniFile = strdup(optarg); break; default: argError = true; } // switch if ( (c != Option::NOT) && (flag != 1) ) { argError = true; fprintf(stderr, "! applied to incorrect argument '%c'\n", c); } } // while getting options if ( argc != optind ) { argError = true; if ( argc > optind ) { char* name = strrchr(argv[0], CsGetcds()); fprintf(stderr, "%s: unexpected argument -- %s\n", (name == 0 ? argv[0] : name+1), argv[optind]); } } // If all the args are ok, do some logical testing of the arguments. if ( !argError && !displayCopyright && !displayBuild && !displayVersion && !displayHelp ) { // check arguments here if ( (iniFile == 0) || (iniFile[0] == '\0') ) { fprintf(stderr, "Must supply a .ini file\n"); argError = true; } } // See if we should display a usage message if ( argError ) CsfUsage(0, argv[0], &usage, help); if ( displayBuild ) fprintf(stderr, "%s\n", VersionString()); if ( displayVersion && !displayCopyright ) fprintf(stderr, "%s %s\n", usage.ou_version, usage.ou_build); if ( displayCopyright ) CsfUsage(2, argv[0], &usage, help); if ( displayHelp ) CsfUsage(1, argv[0], &usage, help); if ( displayBuild || displayVersion ) exit(3); // Open the ini file CsfIniOpen(iniFile, ""); if ( commandLineDebugSettings.empty() ) { CsMsgOptsetFromIni(0, 0); } else { int* temp = new int[commandLineDebugSettings.size()]; std::copy(commandLineDebugSettings.begin(), commandLineDebugSettings.end(), temp); CsMsgOptsetFromIni(temp, commandLineDebugSettings.size()); delete[] temp; } // Set up the command server stuff if ( CsfCmdRegister(&statusCommand) != 0 ) CsErrx("CsfCmdRegister failed for 'status'"); else if ( CsfCmdRegister(&initCommand) != 0 ) CsErrx("CsfCmdRegister failed for 'init'"); else if ( CsfCmdRegister(&refreshCommand) != 0 ) CsErrx("CsfCmdRegister failed for 'refresh'"); else if ( CsfCmdRegister(&scheduleCommand) != 0 ) CsErrx("CsfCmdRegister failed for 'schedule'"); else if ( CsfCmdRegister(&CDCommand) != 0 ) CsErrx("CsfCmdRegister failed for 'cd'"); else if ( CsfCmdRegister(&enableAllCommand) != 0 ) CsErrx("CsfCmdRegister failed for 'enableAll'"); else if ( CsfCmdRegister(&disableAllCommand) != 0 ) CsErrx("CsfCmdRegister failed for 'disableAll'"); else if ( CsfCmdRegister(&sendLocCommand) != 0 ) CsErrx("CsfCmdRegister failed for 'sendloc'"); else if ( CsfCmdRegister(&debugCommand) != 0 ) CsErrx("CsfCmdRegister failed for 'debug'"); else if ( CsfCmdServer("", "Command", NULL, 0, "DC Command Server\n", "DC cmd>" ) != 0 ) { CsErrx("CsfCmdServer failed to start the command server"); } free(iniFile); return 0; }
VersionString IdfFile::version() const { return VersionString(m_iddFileAndFactoryWrapper.version()); }
int PrintVersion(){ DB(fprintf(stderr,"PrintVersion()\n")); printf("%s\n",VersionString()); return(0); }
void VersionInfo::ShowAboutWindow() { AboutBrowserStudio about(VersionString(), ServerName); about.exec(); }
ServersListModel::ServersListModel(ServerInfos *servers, ServerDialog *parent): mServers(servers), mVersionStrings(servers->size(), VersionString(0, "")), mParent(parent) { }
bool VersionString::isNextVersion(const VersionString& nextVersionCandidate) const { VersionString variantOnThis(str()); VersionString variantOnCandidate = nextVersionCandidate; if (variantOnCandidate <= variantOnThis) { return false; } // now know nextVersionCandidate > this if (build() && fidelityEqual(nextVersionCandidate)) { // true if versions except for build number are equal variantOnThis = VersionString(major(),minor(),patch().get()); variantOnCandidate = VersionString(nextVersionCandidate.major(), nextVersionCandidate.minor(), nextVersionCandidate.patch().get()); if (variantOnCandidate == variantOnThis) { return true; } } else { // strip out build numbers as needed, because that is not the level at which the // versions differ if (build()) { variantOnThis = VersionString(major(),minor(),patch().get()); } if (nextVersionCandidate.build()) { variantOnCandidate = VersionString(nextVersionCandidate.major(), nextVersionCandidate.minor(), nextVersionCandidate.patch().get()); } } // now have major.minor or major.minor.patch for both if (variantOnThis.patch()) { if (variantOnCandidate.patch()) { VersionString thisIncremented(major(),minor(),patch().get() + 1); if (variantOnCandidate == thisIncremented) { return true; } // candidate has patch, but is not next patch version. to be next version, // must have patch == 0 if (variantOnCandidate.patch().get() != 0) { return false; } } } // now major.minor.patch v. major.minor or major.minor.patch v. major.minor.0 // strip out patch numbers if (variantOnThis.patch()) { variantOnThis = VersionString(variantOnThis.major(),variantOnThis.minor()); } if (variantOnCandidate.patch()) { variantOnCandidate = VersionString(variantOnCandidate.major(),variantOnCandidate.minor()); } // minor increment VersionString thisIncremented(variantOnThis.major(),variantOnThis.minor() + 1); if (variantOnCandidate == thisIncremented) { return true; } // major increment thisIncremented = VersionString(variantOnThis.major() + 1,0); if (variantOnCandidate == thisIncremented) { return true; } return false; }
void Host_Init (int argc, char **argv, int default_memsize) { vfsfile_t *vf; cvar_t *v; char cfg[MAX_PATH] = {0}; int i; char *cfg_name; COM_InitArgv (argc, argv); COM_StoreOriginalCmdline(argc, argv); #ifdef WITH_DP_MEM Memory2_Init (); #endif Host_InitMemory (default_memsize); #ifdef WITH_TCL // interpreter should be initialized // before any cvar definitions TCL_InterpInit (); #endif Cbuf_Init (); Cmd_Init (); Cvar_Init (); COM_Init (); Key_Init (); #ifdef WITH_DP_MEM Memory2_Init_Commands (); #endif Cache_Init_Commands (); FS_InitFilesystem (); NET_Init (); Commands_For_Configs_Init (); ConfigManager_Init(); ResetBinds(); i = COM_CheckParm("+cfg_load"); if (i && (i + 1 < COM_Argc())) { cfg_name = COM_Argv(i + 1); } else { cfg_name = MAIN_CONFIG_FILENAME; } snprintf(cfg, sizeof(cfg), "%s", cfg_name); COM_ForceExtensionEx (cfg, ".cfg", sizeof (cfg)); Cbuf_AddText(va("cfg_load %s\n", cfg)); Cbuf_Execute(); Cbuf_AddEarlyCommands (); Cbuf_Execute (); Con_Init (); NET_InitClient (); Netchan_Init (); #if (!defined WITH_PNG_STATIC || !defined WITH_JPEG_STATIC || defined WITH_MP3_PLAYER) QLib_Init(); #endif Sys_Init (); CM_Init (); PM_Init (); Mod_Init (); SV_Init (); CL_Init (); Cvar_CleanUpTempVars (); SYSINFO_Init(); #ifdef WITH_TCL if (!TCL_InterpLoaded()) Com_Printf_State (PRINT_FAIL, "Could not load "TCL_LIB_NAME", embedded Tcl disabled\n"); #endif Hunk_AllocName (0, "-HOST_HUNKLEVEL-"); host_hunklevel = Hunk_LowMark (); host_initialized = true; // walk through all vars and forse OnChange event if cvar was modified, // also apply that to variables which mirrored in userinfo because of cl_parsefunchars was't applyed as this moment, // same for serverinfo and may be this fix something also. for ( v = NULL; (v = Cvar_Next ( v )); ) { char val[2048]; // if ( !v->modified ) // continue; // not modified even that strange at this moment if ( Cvar_GetFlags( v ) & (CVAR_ROM | CVAR_INIT) ) continue; snprintf(val, sizeof(val), "%s", v->string); Cvar_Set(v, val); } Hud_262LoadOnFirstStart(); Com_Printf_State (PRINT_INFO, "Exe: "__TIME__" "__DATE__"\n"); Com_Printf_State (PRINT_INFO, "Hunk allocation: %4.1f MB.\n", (float) host_memsize / (1024 * 1024)); Com_Printf ("\nezQuake %s\n\n", VersionString()); Com_Printf(Host_PrintBars("ezQuake\x9c" "SourceForge\x9c" "net", 38)); Com_Printf(Host_PrintBars("ezQuake Initialized", 38)); Com_Printf("\n"); Com_Printf ("\nType /help to access the manual.\nUse /describe to learn about commands.\n", VersionString()); if ((vf = FS_OpenVFS("autoexec.cfg", "rb", FS_ANY))) { Cbuf_AddText ("exec autoexec.cfg\n"); VFS_CLOSE(vf); } Cmd_StuffCmds_f (); // process command line arguments Cbuf_AddText ("cl_warncmd 1\n"); #ifdef WIN32 // // Verify that ezQuake is associated with the QW:// protocl handler. // { extern qbool CL_CheckIfQWProtocolHandler(); extern cvar_t cl_verify_qwprotocol; if (cl_verify_qwprotocol.integer >= 2) { // Always register the qw:// protocol. Cbuf_AddText("register_qwurl_protocol\n"); } else if (cl_verify_qwprotocol.integer == 1 && !CL_CheckIfQWProtocolHandler()) { // Check if the running exe is the one associated with the qw:// protocol. Com_PrintVerticalBar(0.8 * vid.conwidth / 8); Com_Printf("\n"); Com_Printf("This ezQuake is not associated with the "); Com_Printf("\x02QW:// protocol.\n"); Com_Printf("Register it using "); Com_Printf("\x02/register_qwurl_protocol\n"); Com_Printf("(set "); Com_Printf("\x02 cl_verify_qwprotocol "); Com_Printf("to 0 to hide this warning)\n"); Com_PrintVerticalBar(0.8 * vid.conwidth / 8); Com_Printf("\n"); } } #endif // WIN32 // Check if a qtv/demo file is specified as the first argument, in that case play that // otherwise, do some more checks of what to show at startup. { char cmd[1024] = {0}; if (COM_CheckArgsForPlayableFiles(cmd, sizeof(cmd))) { Cbuf_AddText(cmd); } else { Startup_Place(); } } #ifdef _WIN32 SetForegroundWindow(mainwindow); SetActiveWindow(mainwindow); #endif host_everything_loaded = true; }