diff --git a/source/lib/misc.cpp b/source/lib/misc.cpp index 5a55a97013..694fd3ca71 100755 --- a/source/lib/misc.cpp +++ b/source/lib/misc.cpp @@ -58,7 +58,40 @@ u32 fnv_hash(const void* buf, const size_t len) } +// FNV1-A hash - good for strings. +// if len = 0 (default), treat buf as a C-string; +// otherwise, hash bytes of buf. +u64 fnv_hash64(const void* buf, const size_t len) +{ + u64 h = 0xCBF29CE484222325; + // give distinct values for different length 0 buffers. + // value taken from FNV; it has no special significance. + const u8* p = (const u8*)buf; + + // expected case: string + if(!len) + { + while(*p) + { + h ^= *p++; + h *= 0x100000001B3; + } + } + else + { + size_t bytes_left = len; + while(bytes_left != 0) + { + h ^= *p++; + h *= 0x100000001B3; + + bytes_left--; + } + } + + return h; +} void bswap32(const u8* data, int cnt) @@ -173,6 +206,26 @@ float fminf(float a, float b) +long round(double x) +{ + return (long)(x + 0.5); +} + +// input in [0, 1); convert to u16 range +u16 fp_to_u16(double in) +{ + if(!(0 <= in && in < 1.0)) + { + debug_warn("clampf not in [0,1)"); + return 65535; + } + + long l = round(in * 65535.0); + assert((unsigned long)l <= 65535); + return (u16)l; +} + + // big endian! void base32(const int len, const u8* in, u8* out) diff --git a/source/lib/misc.h b/source/lib/misc.h index 565a6c1732..0db44b6810 100755 --- a/source/lib/misc.h +++ b/source/lib/misc.h @@ -32,6 +32,7 @@ // if len = 0 (default), treat buf as a C-string; // otherwise, hash bytes of buf. extern u32 fnv_hash(const void* buf, const size_t len = 0); +extern u64 fnv_hash64(const void* buf, const size_t len); // hash (currently FNV) of a filename typedef u32 FnHash; @@ -104,6 +105,8 @@ extern float fminf(float, float); +extern long round(double); +extern u16 fp_to_u16(double in); // big endian! extern void base32(const int len, const u8* in, u8* out); diff --git a/source/lib/precompiled.h b/source/lib/precompiled.h index 67125a7ccf..354f759dd3 100755 --- a/source/lib/precompiled.h +++ b/source/lib/precompiled.h @@ -22,3 +22,5 @@ #include #include + +#pragma warning(disable:4996) \ No newline at end of file diff --git a/source/lib/res/res.cpp b/source/lib/res/res.cpp index 1f57f229c1..bdae50146e 100755 --- a/source/lib/res/res.cpp +++ b/source/lib/res/res.cpp @@ -5,4 +5,12 @@ int res_reload(const char* const fn) { return h_reload(fn); -} \ No newline at end of file +} + + + + + +// purpose of this routine (intended to be called once a frame): +// file notification may come at any time. by forcing the reloads +// to take place here, we don't require everything to be thread-safe. \ No newline at end of file diff --git a/source/lib/sysdep/ia32.cpp b/source/lib/sysdep/ia32.cpp index 2ff4945d1b..26a56efd3d 100755 --- a/source/lib/sysdep/ia32.cpp +++ b/source/lib/sysdep/ia32.cpp @@ -96,10 +96,14 @@ __asm long cpu_caps = 0; long cpu_ext_caps = 0; +int tsc_is_safe = -1; + + static char cpu_vendor[13]; static int family, model; // used to detect cpu_type -int tsc_is_safe = -1; +static int have_brand_string = 0; + // int instead of bool for easier setting from asm // optimized for size @@ -148,11 +152,11 @@ __asm mov esi, 0x80000000 mov eax, esi cpuid - cmp eax, esi - jbe no_ext_funcs - lea esi, [esi+4] - cmp eax, esi - jb no_brand_str + cmp eax, esi ; max ext <= 0x80000000? + jbe no_ext_funcs ; yes - no ext funcs at all + lea esi, [esi+4] ; esi = 0x80000004 + cmp eax, esi ; max ext < 0x80000004? + jb no_brand_str ; yes - brand string not available, skip ; get CPU brand string (>= Athlon XP, P4) mov edi, offset cpu_type @@ -171,6 +175,8 @@ $1: lea eax, [ebp+esi] ; 0x80000002 .. 4 jle $1 ; (already 0 terminated) + mov [have_brand_string], ebp ; ebp = 1 = true + no_brand_str: ; get extended feature flags @@ -194,8 +200,54 @@ void ia32_get_cpu_info() if(cpu_caps == 0) // cpuid not supported - can't do the rest return; - // cpu_type set from brand string - clean it up some - if(strcmp(cpu_type, "unknown") != 0) + // fall back to manual detect of CPU type if it didn't supply + // a brand string, or if the brand string is useless (i.e. "Unknown"). + if(!have_brand_string || strncmp(cpu_type, "Unknow", 6) == 0) + // we use an extra flag to detect if we got the brand string: + // safer than comparing against the default name, which may change. + // + // some older boards reprogram the brand string with + // "Unknow[n] CPU Type" on CPUs the BIOS doesn't recognize. + // in that case, we ignore the brand string and detect manually. + { + // AMD + if(!strcmp(cpu_vendor, "AuthenticAMD")) + { + // everything else is either too old, or should have a brand string. + if(family == 6) + { + if(model == 3 || model == 7) + strcpy(cpu_type, "AMD Duron"); + else if(model <= 5) + strcpy(cpu_type, "AMD Athlon"); + else + { + if(cpu_ext_caps & EXT_MP_CAPABLE) + strcpy(cpu_type, "AMD Athlon MP"); + else + strcpy(cpu_type, "AMD Athlon XP"); + } + } + } + // Intel + else if(!strcmp(cpu_vendor, "GenuineIntel")) + { + // everything else is either too old, or should have a brand string. + if(family == 6) + { + if(model == 1) + strcpy(cpu_type, "Intel Pentium Pro"); + else if(model == 3 || model == 5) + strcpy(cpu_type, "Intel Pentium II"); + else if(model == 6) + strcpy(cpu_type, "Intel Celeron"); + else + strcpy(cpu_type, "Intel Pentium III"); + } + } + } + // we have a valid brand string; try to pretty it up some + else { // strip (tm) from Athlon string if(!strncmp(cpu_type, "AMD Athlon(tm)", 14)) @@ -209,22 +261,11 @@ void ia32_get_cpu_info() if(sscanf(cpu_type, " Intel(R) Pentium(R) 4 CPU %fGHz", &a) == 1) strcpy(cpu_type, "Intel Pentium 4"); } - // detect cpu_type ourselves - else - { - // AMD - if(!strcmp(cpu_vendor, "AuthenticAMD")) - { - if(family == 6) - strcpy(cpu_type, (model == 3)? "AMD Duron" : "AMD Athlon"); - } - // Intel - else if(!strcmp(cpu_vendor, "GenuineIntel")) - { - if(family == 6 && model >= 7) - strcpy(cpu_type, "Intel Pentium III / Celeron"); - } - } + + + // + // measure CPU frequency + // // .. get old policy and priority int old_policy; diff --git a/source/lib/sysdep/ia32.h b/source/lib/sysdep/ia32.h index ba7a31f290..fb6070d835 100755 --- a/source/lib/sysdep/ia32.h +++ b/source/lib/sysdep/ia32.h @@ -52,8 +52,9 @@ enum extern long cpu_caps; // define instead of enum to avoid stupid sign conversion warning -#define EXT_3DNOW_PRO BIT(30) -#define EXT_3DNOW BIT(31) +#define EXT_MP_CAPABLE BIT(19) +#define EXT_3DNOW_PRO BIT(30) +#define EXT_3DNOW BIT(31) extern long cpu_ext_caps; diff --git a/source/lib/sysdep/win/wdetect.cpp b/source/lib/sysdep/win/wdetect.cpp index 4ee60902c8..615be926de 100755 --- a/source/lib/sysdep/win/wdetect.cpp +++ b/source/lib/sysdep/win/wdetect.cpp @@ -29,10 +29,11 @@ // powrprof is loaded manually - we only need 1 function. #endif +#include "Tlhelp32.h" + // EnumDisplayDevices is not available on Win95 or NT. // try to import it manually here; return -1 if not available. -// note: FreeLibrary at exit avoids BoundsChecker resource leak warnings. static BOOL (WINAPI *pEnumDisplayDevicesA)(void*, DWORD, void*, DWORD); static int import_EnumDisplayDevices() { @@ -40,7 +41,10 @@ static int import_EnumDisplayDevices() { static HMODULE hUser32Dll = LoadLibrary("user32.dll"); *(void**)&pEnumDisplayDevicesA = GetProcAddress(hUser32Dll, "EnumDisplayDevicesA"); - ONCE(atexit2(FreeLibrary, (uintptr_t)hUser32Dll, CC_STDCALL_1)); + FreeLibrary(hUser32Dll); + // make sure the reference is released so BoundsChecker + // doesn't complain. it won't actually be unloaded anyway - + // there is at least one other reference. } return pEnumDisplayDevicesA? 0 : -1; @@ -94,21 +98,53 @@ int win_get_gfx_card() } +/* +get ogl client DLL name + enum loaded dlls + ogl must be running; ambiguous (need to eliminate MCD and opengl32.dll) + */ +// no .dll appended +// +static int get_ogl_drv_name(char* const ogl_drv_name, const size_t max_name_len) +{ + int ret = -1; + + HKEY hkOglDrivers; + const char* key = "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\OpenGLDrivers"; + if(RegOpenKeyEx(HKEY_LOCAL_MACHINE, key, 0, KEY_ENUMERATE_SUB_KEYS, &hkOglDrivers) != 0) + return -1; + + char key_name[32]; + DWORD key_name_len = sizeof(key_name); + if(RegEnumKeyEx(hkOglDrivers, 0, key_name, &key_name_len, 0, 0, 0, 0) == 0) + { + HKEY hkClass; + if(RegOpenKeyEx(hkOglDrivers, key_name, 0, KEY_QUERY_VALUE, &hkClass) == 0) + { + DWORD size = (DWORD)max_name_len; + if(RegQueryValueEx(hkClass, "Dll", 0, 0, (LPBYTE)ogl_drv_name, &size) == 0) + ret = 0; // success + + RegCloseKey(hkClass); + } + } + + RegCloseKey(hkOglDrivers); + + return ret; +} + + // split out so we can return on failure, instead of goto // method: http://www.opengl.org/discussion_boards/ubb/Forum3/HTML/009679.html int win_get_gfx_drv() { - // get driver DLL name - DEVMODEA dm; - // note: dmDriverVersion is not what we're looking for - memset(&dm, 0, sizeof(dm)); - dm.dmSize = sizeof(dm); - // note: dmSize isn't the first member! - if(!EnumDisplaySettingsA(0, ENUM_CURRENT_SETTINGS, &dm)) - return -1; - char drv_name[CCHDEVICENAME+5]; // we add ".dll" - strcpy(drv_name, (const char*)dm.dmDeviceName); - strcat(drv_name, ".dll"); + +/* want ogl icd, instead of 2d driver */ + + char ogl_drv_name[MAX_PATH]; + CHECK_ERR(get_ogl_drv_name(ogl_drv_name, sizeof(ogl_drv_name))); + // don't want to return 0 on success - we'd need to duplicate free(buf). // instead, set this variable and return that. @@ -116,21 +152,21 @@ int win_get_gfx_drv() // read the DLL's version info DWORD unused; - DWORD ver_size = GetFileVersionInfoSize(drv_name, &unused); + const DWORD ver_size = GetFileVersionInfoSize(ogl_drv_name, &unused); if(!ver_size) return -1; - void* buf = malloc(ver_size); + void* const buf = malloc(ver_size); if(!buf) return -1; - if(GetFileVersionInfo(drv_name, 0, ver_size, buf)) + if(GetFileVersionInfo(ogl_drv_name, 0, ver_size, buf)) { u16* lang; // -> 16 bit language ID, 16 bit codepage uint lang_len; - BOOL ok = VerQueryValue(buf, "\\VarFileInfo\\Translation", (void**)&lang, &lang_len); + const BOOL ok = VerQueryValue(buf, "\\VarFileInfo\\Translation", (void**)&lang, &lang_len); if(ok && lang && lang_len == 4) { char subblock[64]; - sprintf(subblock, "\\StringFileInfo\\%04X%04X\\ProductName", lang[0], lang[1]); + sprintf(subblock, "\\StringFileInfo\\%04X%04X\\FileVersion", lang[0], lang[1]); const char* ver; uint ver_len; if(VerQueryValue(buf, subblock, (void**)&ver, &ver_len)) diff --git a/source/lib/sysdep/win/wfam.cpp b/source/lib/sysdep/win/wfam.cpp index 349d91820b..2edb029e33 100755 --- a/source/lib/sysdep/win/wfam.cpp +++ b/source/lib/sysdep/win/wfam.cpp @@ -17,9 +17,90 @@ #include "precompiled.h" -#include "res/res.h" +#include "wfam.h" +#include "win_internal.h" + +#if 0 + +static const size_t CHANGE_BUF_SIZE = 15000; + // better be enough - if too small, we miss changes made to a directory. + + +// don't worry about size: the user only passes around a pointer +// to this struct, due to the pImpl idiom. this is heap-allocated. +struct FAMRequest_ +{ + std::string dir_name; + HANDLE hDir; + + // history to detect series of notifications, so we can skip + // redundant reloads (slow) + std::string last_path; + DWORD last_action; // FILE_ACTION_* codes or 0 + DWORD last_ticks; // timestamp via GetTickCount + + OVERLAPPED ovl; + // we don't use any of its fields. + // overlapped I/O completation notification is via IOCP. + // rationale: see below. + char changes[CHANGE_BUF_SIZE]; + + + FAMRequest_(const char* _dir_name) + : dir_name(_dir_name), last_path("") + { + last_action = 0; + last_ticks = 0; + + memset(&ovl, 0, sizeof(ovl)); + + // changes[] doesn't need init + } +}; + + +// don't worry about size: the user only passes around a pointer +// to this struct, due to the pImpl idiom. this is heap-allocated. +struct FAMConnection_ +{ + std::string app_name; + + + HANDLE hIOCP; + +// queue necessary - race condition if pass to app and re-issue +// needs to be FIFO, and don't want to constantly shuffle items (can be rather large) +// around => list + typedef std::list Events; + Events pending_events; + + // list of all pending requests to detect duplicates and + // for easier cleanup. only store pointer in container - + // they're not copy-equivalent. + typedef std::map Requests; + typedef Requests::iterator RequestIt; + Requests requests; + + FAMConnection_(const char* _app_name) + : app_name(_app_name) + { + hIOCP = 0; + // not INVALID_HANDLE_VALUE! (CreateIoCompletionPort requirement) + } + + ~FAMConnection_() + { + CloseHandle(hIOCP); + hIOCP = INVALID_HANDLE_VALUE; + + // container holds dynamically allocated Watch structs + // for(WatchIt it = watches.begin(); it != watches.end(); ++it) + // delete it->second; + } +}; + + -#include "sysdep/win/win_internal.h" // rationale for using I/O completion ports for notification: @@ -43,118 +124,158 @@ // IOCPs work well and are elegant; have not yet noticed any drawbacks. -static HANDLE hIOCP = 0; - // not INVALID_HANDLE_VALUE! (CreateIoCompletionPort requirement) - -static const size_t WATCH_BUF_SIZE = 16384; - // better be enough - if too small, we miss changes made to a directory. + // ReadDirectoryChangesW must be called again after each time it returns data, -// so we need to pass this struct to the notification "callback". -// we do this implicitly with the guarantee that &ovl = &Watch (verified via -// assert). rationale: the Key param is already in use (tells the callback to -// call RDC - see KEY_ADD_WATCH_ONLY); this way of passing the parameter is -// cleaner IMO than stuffing the address in an unused member of OVERLAPPED. -struct Watch -{ - OVERLAPPED ovl; - // we don't use any of its fields. - - void* buf; - - HANDLE hDir; - - bool watch_subdirs; - - // history to detect series of notifications, so we can skip - // redundant reloads (slow) - std::string last_path; - DWORD last_action; // FILE_ACTION_* codes or 0 - DWORD last_ticks; // timestamp via GetTickCount +// so we need to pass along the associated Request. +// since we issue RDC immediately, instead of sending a bogus packet +// to the IOCP that triggers the issue, we don't need the key parameter +// for anything - use it to pass along the Request. +// cleaner than assuming &ovl = &Request, or stuffing it in an unused +// member of OVERLAPPED. - Watch(HANDLE hDir, bool watch_subdirs) - { - this->hDir = hDir; - this->watch_subdirs = watch_subdirs; - buf = mem_alloc(WATCH_BUF_SIZE, 32); - // ReadDirectoryChangesW requirement: at least 4-byte alignment. - - memset(&ovl, 0, sizeof(ovl)); - - last_action = 0; - } - - ~Watch() - { -// mem_free(buf); -// FIXME: mem has already shut down when this is called. - - CancelIo(hDir); - - CloseHandle(hDir); - hDir = INVALID_HANDLE_VALUE; - } -}; - - -// don't store directly in container - not copy-equivalent. -typedef std::map Watches; -typedef Watches::iterator WatchIt; -static Watches watches; - - -static void cleanup(void) -{ - CloseHandle(hIOCP); - - // container holds dynamically allocated Watch structs - for(WatchIt it = watches.begin(); it != watches.end(); ++it) - delete it->second; -} int dir_watch_abort(const char* const dir) { // find watch - const std::string dir_s(dir); +/* const std::string dir_s(dir); WatchIt it = watches.find(dir_s); if(it == watches.end()) return -1; delete it->second; watches.erase(it); +*/ return 0; } -// it's nice to have only 1 call site of ReadDirectoryChangesW, namely -// in the notification "callback". posting an event to the IOCP with -// KEY_ADD_WATCH_ONLY tells it to call RDC; normal events pass KEY_NORMAL. -static enum +// it'd be nice to have only 1 call site of ReadDirectoryChangesW, namely +// in the notification "callback". however, posting a dummy event to the IOCP +// and having the callback issue RDC is a bit ugly, and loses changes made +// before the poll routine is first called. + +static int dir_watch_issue(FAMRequest_* fr) { - KEY_NORMAL, - KEY_ADD_WATCH_ONLY -}; + // (re-)request change notification from now on + const DWORD filter = FILE_NOTIFY_CHANGE_FILE_NAME | FILE_NOTIFY_CHANGE_DIR_NAME | + FILE_NOTIFY_CHANGE_SIZE | FILE_NOTIFY_CHANGE_LAST_WRITE | + FILE_NOTIFY_CHANGE_CREATION; + BOOL ret = ReadDirectoryChangesW(fr->hDir, fr->changes, CHANGE_BUF_SIZE, FALSE, filter, 0, &fr->ovl, 0); + return ret? 0 : -1; +} int dir_add_watch(const char* const dir, const bool watch_subdirs) { - ONCE(atexit2(cleanup)); +return 0; +} +void FAMCancelMonitor(FAMConnection*, FAMRequest* req) +{ +} + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +void wfam_shutdown() +{ +} + + + +int FAMOpen2(FAMConnection* const fc, const char* app_name) +{ + try + { + fc->internal = new FAMConnection_(app_name); + } + catch(std::bad_alloc) + { + fc->internal = 0; + } + + // either (VC6) new returned 0, or we caught bad_alloc => fail. + if(!fc->internal) + return -1; + + return 0; +} + + +int FAMClose(FAMConnection* const fc) +{ + FAMConnection_*& fc_ = (FAMConnection_*)fc->internal; + if(!fc_) + { + debug_warn("FAMClose: already closed"); + return -1; + } + + delete fc_; + fc_ = 0; + return 0; +} + + +int FAMMonitorDirectory(FAMConnection* fc, char* dir, FAMRequest* fr, void* user) +{ + FAMConnection_* fc_ = (FAMConnection_*)fc->internal; + +/* // make sure dir is not already being watched const std::string dir_s(dir); WatchIt it = watches.find(dir_s); if(it != watches.end()) return -1; +*/ + HANDLE hDir = INVALID_HANDLE_VALUE; + HANDLE& hIOCP = fc_->hIOCP; // open handle to directory const DWORD share = FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE; const DWORD flags = FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OVERLAPPED; - const HANDLE hDir = CreateFile(dir, FILE_LIST_DIRECTORY, share, 0, OPEN_EXISTING, flags, 0); + hDir = CreateFile(dir, FILE_LIST_DIRECTORY, share, 0, OPEN_EXISTING, flags, 0); if(hDir == INVALID_HANDLE_VALUE) return -1; @@ -162,105 +283,139 @@ int dir_add_watch(const char* const dir, const bool watch_subdirs) hIOCP = CreateIoCompletionPort(hDir, hIOCP, KEY_NORMAL, 0); if(hIOCP == 0 || hIOCP == INVALID_HANDLE_VALUE) { +fail: CloseHandle(hDir); return -1; } + + // insert Watch* const w = new Watch(hDir, watch_subdirs); watches[dir_s] = w; - // tell the notification "callback" to actually add the watch - const DWORD bytes_transferred = 0; - PostQueuedCompletionStatus(hIOCP, bytes_transferred, KEY_ADD_WATCH_ONLY, &w->ovl); + dir_watch_issue(w); return 0; + } -static int dir_changed(const FILE_NOTIFY_INFORMATION*, Watch*); - -// purpose of this routine (intended to be called once a frame): -// file notification may come at any time. by forcing the reloads -// to take place here, we don't require everything to be thread-safe. -// // added bonus: can actually "poll" for changes here - obviates a worker // thread, mutex, and 2 queues. -int allow_reload() + + + +static int extract_events(FAMConnection* conn, FAMRequest* req) { - // deque and process all pending IOCP packets + FAMConnection_ conn_ = (FAMConnection_*)conn->internal; + const FILE_NOTIFY_INFORMATION* fni = (const FILE_NOTIFY_INFORMATION*)req->changes; + Events& events = fc_->pending_events; + + FAMEvent event_template; + event_template.conn = conn; + event_template.req = req; + + // for every packet in buffer: (there's at least one) for(;;) { - // check for change_notification or add_watch packets - DWORD bytes_transferred; // unused - ULONG_PTR key; - OVERLAPPED* povl; - BOOL got_packet = GetQueuedCompletionStatus(hIOCP, &bytes_transferred, &key, &povl, 0); - if(!got_packet) - break; + // many apps save by creating a temp file, deleting the original, + // and renaming the temp file. that leads to 2 reloads, which is slow. + // try to detect this case with a simple state machine - we assume + // the notification order is always the same. - // retrieve the corresponding Watch - // (see Watch definition for rationale) - Watch* const w = (Watch*)povl; - assert(offsetof(struct Watch, ovl) == 0); + // TODO: - // (re-)request change notification from now on - const DWORD filter = FILE_NOTIFY_CHANGE_FILE_NAME | FILE_NOTIFY_CHANGE_DIR_NAME | - FILE_NOTIFY_CHANGE_SIZE | FILE_NOTIFY_CHANGE_LAST_WRITE | - FILE_NOTIFY_CHANGE_CREATION; - ReadDirectoryChangesW(w->hDir, w->buf, WATCH_BUF_SIZE, TRUE, filter, 0, &w->ovl, 0); + const char* actions[] = { "", "FILE_ACTION_ADDED", "FILE_ACTION_REMOVED", "FILE_ACTION_MODIFIED", "FILE_ACTION_RENAMED_OLD_NAME", "FILE_ACTION_RENAMED_NEW_NAME" }; + const char* action = actions[fni->Action]; - // dir_add_watch requests the watch be added; - // we didn't actually receive any change notification - if(key == KEY_ADD_WATCH_ONLY) - continue; - - FILE_NOTIFY_INFORMATION* fni = (FILE_NOTIFY_INFORMATION*)w->buf; - for(;;) + // convert Windows BSTR-style path to + // portable C string path for the resource manager. + // HACK: convert in place, we copy it into + char fn[MAX_PATH]; + char* p = fn; + const int num_chars = fni->FileNameLength/2; + for(int i = 0; i < num_chars; i++) { - dir_changed(fni, w); - - DWORD ofs = fni->NextEntryOffset; - // this was the last entry - if(!ofs) - break; - - // advance to next FILE_NOTIFY_INFORMATION (variable length) - (char*&)fni += ofs; + char c = (char)fni->FileName[i]; + if(c == '\\') + c = '/'; + *p++ = c; } + *p = '\0'; + + // don't want to expose details + + events.push_back(event_template); + + + const DWORD ofs = fni->NextEntryOffset; + // advance to next FILE_NOTIFY_INFORMATION (variable length) + if(ofs) + (char*&)fni += ofs; + // this was the last entry - no more elements left in buffer. + else + break; } return 0; -} -int dir_changed(const FILE_NOTIFY_INFORMATION* const fni, Watch* const w) -{ - // many apps save by creating a temp file, deleting the original, - // and renaming the temp file. that leads to 2 reloads, which is slow. - // try to detect this case with a simple state machine - we assume - // the notification order is always the same. - - // TODO: - - const char* actions[] = { "", "FILE_ACTION_ADDED", "FILE_ACTION_REMOVED", "FILE_ACTION_MODIFIED", "FILE_ACTION_RENAMED_OLD_NAME", "FILE_ACTION_RENAMED_NEW_NAME" }; - const char* action = actions[fni->Action]; - - // convert Windows BSTR-style path to - // portable C string path for the resource manager. - char fn[MAX_PATH]; - char* p = fn; - const int num_chars = fni->FileNameLength/2; - for(int i = 0; i < num_chars; i++) - { - char c = (char)fni->FileName[i]; - if(c == '\\') - c = '/'; - *p++ = c; - } - *p = '\0'; - res_reload(fn); return 0; } + + +int FAMPending(FAMConnection* fc) +{ + FAMConnection_* const fc_ = (FAMConnection_*)fc->internal; + Events& pending_events = fc_->pending_events; + + if(!pending_events.empty()) + return 1; + + // check if new buffer has been filled + DWORD bytes_transferred; // unused + ULONG_PTR key; + OVERLAPPED* povl; + BOOL got_packet = GetQueuedCompletionStatus(fc_->hIOCP, &bytes_transferred, &key, &povl, 0); + if(!got_packet) + return 0; + + CHECK_ERR(extract_events(conn, req)); + +// dir_watch_issue(buf); + + + + + fc->fni = (FILE_NOTIFY_INFORMATION*)w->buf; + return 1; +} + + +int FAMNextEvent(FAMConnection* const fc, FAMEvent* const fe) +{ + FAMConnection_* const fc_ = (FAMConnection_*)fc->internal; + Events& pending_events = fc_->pending_events; + + if(!fe) + { + debug_warn("FAMNextEvent: fe = 0"); + return ERR_INVALID_PARAM; + } + + if(pending_events.empty()) + { + debug_warn("FAMNextEvent: no pending events"); + return -1; + } + + *fe = pending_events.front(); + pending_events.pop_front(); + return 0; +} + + +#endif diff --git a/source/lib/sysdep/win/wsdl.cpp b/source/lib/sysdep/win/wsdl.cpp index 0b298c4b41..98f8ff3083 100755 --- a/source/lib/sysdep/win/wsdl.cpp +++ b/source/lib/sysdep/win/wsdl.cpp @@ -466,6 +466,41 @@ inline void SDL_GL_SwapBuffers() } +static int calc_gamma(float gamma, u16* ramp) +{ + if(gamma <= 0.0f) + return ERR_INVALID_PARAM; + + // identity + // (special-case it to make sure we get the exact value) + if(gamma == 1.0f) + { + for(u16 i = 0; i < 256; i++) + ramp[i] = (i << 8); + return 0; + } + + const double inv_gamma = 1.0 / gamma; + for(int i = 0; i < 256; i++) + { + const double frac = i / 256.0; + // make sure pow arg types are unambiguous + ramp[i] = fp_to_u16(pow(frac, inv_gamma)); + // 8.8 fixed point + } + + return 0; +} + + +int SDL_SetGamma(float r, float g, float b) +{ + u16 ramp[3][256]; + CHECK_ERR(calc_gamma(r, ramp[0])); + CHECK_ERR(calc_gamma(g, ramp[1])); + CHECK_ERR(calc_gamma(b, ramp[2])); + return SetDeviceGammaRamp(hDC, ramp)? 0 : -1; +} diff --git a/source/lib/sysdep/win/wsdl.h b/source/lib/sysdep/win/wsdl.h index 393e710195..01f2c0fa4e 100755 --- a/source/lib/sysdep/win/wsdl.h +++ b/source/lib/sysdep/win/wsdl.h @@ -87,7 +87,7 @@ extern int SDL_KillThread(SDL_Thread*); extern int __stdcall SDL_WarpMouse(int, int); - +extern int SDL_SetGamma(float r, float g, float b); /* macros */ diff --git a/source/main.cpp b/source/main.cpp index 201992c865..003700450a 100755 --- a/source/main.cpp +++ b/source/main.cpp @@ -1,539 +1,562 @@ -#include -#include -#include - -#include "sdl.h" -#include "ogl.h" -#include "detect.h" -#include "timer.h" -#include "input.h" -#include "lib.h" -#include "posix.h" -#include "res/res.h" -#ifdef _M_IX86 -#include "sysdep/ia32.h" -#endif -#include "ps/Config.h" -#include "MapReader.h" -#include "Terrain.h" -#include "Renderer.h" -#include "Model.h" -#include "UnitManager.h" -#include "BaseEntityCollection.h" -#include "Entity.h" -#include "EntityHandles.h" -#include "EntityManager.h" - -#ifndef NO_GUI -#include "gui/GUI.h" -#endif - - - -u32 game_ticks; - -bool keys[SDLK_LAST]; - -#include - -// flag to disable extended GL extensions until fix found - specifically, crashes -// using VBOs on laptop Radeon cards -static bool g_NoGLVBO=false; -// mapfile to load or null for no map (and to use default terrain) -static const char* g_MapFile=0; - - -static Handle font; - - -extern CCamera g_Camera; - -extern void terr_init(); -extern void terr_update(float time); -extern bool terr_handler(const SDL_Event& ev); - -extern int allow_reload(); -extern int dir_add_watch(const char* const dir, bool watch_subdirs); - - - -static int write_sys_info() -{ - get_gfx_info(); - - struct utsname un; - uname(&un); - - FILE* const f = fopen("../system/system_info.txt", "w"); - if(!f) - return -1; - - // .. OS - fprintf(f, "%s %s (%s)\n", un.sysname, un.release, un.version); - // .. CPU - fprintf(f, "%s, %s", un.machine, cpu_type); - if(cpu_freq != 0.0f) - { - if(cpu_freq < 1e9) - fprintf(f, ", %.2f MHz\n", cpu_freq*1e-6); - else - fprintf(f, ", %.2f GHz\n", cpu_freq*1e-9); - } - else - fprintf(f, "\n"); - // .. memory - fprintf(f, "%lu MB RAM; %lu MB free\n", tot_mem/MB, avl_mem/MB); - // .. graphics card - fprintf(f, "%s\n", gfx_card); - fprintf(f, "%s\n", gfx_drv); - // .. network name / ips - char hostname[100]; // possibly nodename != hostname - gethostname(hostname, sizeof(hostname)); - fprintf(f, "%s\n", hostname); - hostent* h = gethostbyname(hostname); - if(h) - { - struct in_addr** ips = (struct in_addr**)h->h_addr_list; - for(int i = 0; ips && ips[i]; i++) - fprintf(f, "%s ", inet_ntoa(*ips[i])); - fprintf(f, "\n"); - } - - fclose(f); - return 0; -} - - -// error before GUI is initialized: display message, and quit -// TODO: localization -static void display_startup_error(const wchar_t* msg) -{ - const wchar_t* caption = L"0ad startup problem"; - - write_sys_info(); - wdisplay_msg(caption, msg); - exit(1); -} - -// error before GUI is initialized: display message, and quit -// TODO: localization -static void display_startup_error(const char* msg) -{ - const char* caption = "0ad startup problem"; - - write_sys_info(); - display_msg(caption, msg); - exit(1); -} - - -static int set_vmode(int w, int h, int bpp) -{ - SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24); - SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1); - - if(!SDL_SetVideoMode(w, h, bpp, SDL_OPENGL|SDL_FULLSCREEN)) - return -1; - - glViewport(0, 0, w, h); - -#ifndef NO_GUI - g_GUI.UpdateResolution(); -#endif - - oglInit(); // required after each mode change - - return 0; -} - - -// break out of main loop -static bool quit = false; - -static bool handler(const SDL_Event& ev) -{ - int c; - - switch(ev.type) - { - case SDL_KEYDOWN: - c = ev.key.keysym.sym; - keys[c] = true; - switch(c) - { - case SDLK_ESCAPE: - quit = true; - break; - } - break; - - case SDL_KEYUP: - c = ev.key.keysym.sym; - keys[c] = false; - break; - } - - return 0; -} - - -////////////////////////////////////////////////////////////////////////////////////////////////// -// RenderTerrain: iterate through all terrain patches and submit all patches in viewing frustum to -// the renderer -void RenderTerrain() -{ - CFrustum frustum=g_Camera.GetFustum(); - u32 patchesPerSide=g_Terrain.GetPatchesPerSide(); - for (uint j=0; jGetBounds())) { - g_Renderer.Submit(patch); - } - } - } -} - -////////////////////////////////////////////////////////////////////////////////////////////////// -// RenderModels: iterate through model list and submit all models in viewing frustum to the -// Renderer -void RenderModels() -{ - CFrustum frustum=g_Camera.GetFustum(); - - const std::vector& units=g_UnitMan.GetUnits(); - uint i; - for (i=0;im_Model->GetBounds())) { - g_Renderer.Submit(units[i]->m_Model); - } - } -} - -///////////////////////////////////////////////////////////////////////////////////////////// -// RenderNoCull: render absolutely everything to a blank frame to force renderer -// to load required assets -void RenderNoCull() -{ - g_Renderer.BeginFrame(); - g_Renderer.SetCamera(g_Camera); - - uint i,j; - const std::vector& units=g_UnitMan.GetUnits(); - for (i=0;im_Model); - } - - u32 patchesPerSide=g_Terrain.GetPatchesPerSide(); - for (j=0; j& units=g_UnitMan.GetUnits(); - for (uint i=0;im_Model->Update(time); - } - g_EntityManager.updateAll( time ); - -} - - -void ParseArgs(int argc, char* argv[]) -{ - for (int i=1;i TICK_TIME) - { - game_ticks++; - in_get_events(); - do_tick(); - time0 += TICK_TIME; - } - UpdateWorld(float(time1-time0)); - terr_update(float(time1-time0)); - Render(); - SDL_GL_SwapBuffers(); - - calc_fps(); - -#else - - double time1 = get_time(); - - in_get_events(); - UpdateWorld(float(time1-time0)); - terr_update(float(time1-time0)); - Render(); - SDL_GL_SwapBuffers(); - - calc_fps(); - time0=time1; -#endif - } - -#ifndef NO_GUI - g_GUI.Destroy(); - delete CGUI::GetSingletonPtr(); // again, we should have all singleton deletes somewhere -#endif - - delete &g_Config; - delete &g_EntityManager; - delete &g_EntityTemplateCollection; - - return 0; -} +#include +#include +#include + +#include "sdl.h" +#include "ogl.h" +#include "detect.h" +#include "timer.h" +#include "input.h" +#include "lib.h" +#include "posix.h" +#include "res/res.h" +#ifdef _M_IX86 +#include "sysdep/ia32.h" +#endif +#include "ps/Config.h" +#include "MapReader.h" +#include "Terrain.h" +#include "Renderer.h" +#include "Model.h" +#include "UnitManager.h" + +#include "BaseEntityCollection.h" +#include "Entity.h" +#include "EntityHandles.h" +#include "EntityManager.h" + +#ifndef NO_GUI +#include "gui/GUI.h" +#endif + + + +u32 game_ticks; + +bool keys[SDLK_LAST]; + +#include + +// flag to disable extended GL extensions until fix found - specifically, crashes +// using VBOs on laptop Radeon cards +static bool g_NoGLVBO=false; + +static bool g_VSync = false; + +static float g_Gamma = 1.0f; + +// mapfile to load or null for no map (and to use default terrain) +static const char* g_MapFile=0; + + +static Handle font; + + +extern CCamera g_Camera; + +extern void terr_init(); +extern void terr_update(float time); +extern bool terr_handler(const SDL_Event& ev); + +extern int allow_reload(); +extern int dir_add_watch(const char* const dir, bool watch_subdirs); + + + +static int write_sys_info() +{ + get_gfx_info(); + + struct utsname un; + uname(&un); + + FILE* const f = fopen("../system/system_info.txt", "w"); + if(!f) + return -1; + + // .. OS + fprintf(f, "%s %s (%s)\n", un.sysname, un.release, un.version); + // .. CPU + fprintf(f, "%s, %s", un.machine, cpu_type); + if(cpus > 1) + fprintf(f, " (x%d)", cpus); + if(cpu_freq != 0.0f) + { + if(cpu_freq < 1e9) + fprintf(f, ", %.2f MHz\n", cpu_freq*1e-6); + else + fprintf(f, ", %.2f GHz\n", cpu_freq*1e-9); + } + else + fprintf(f, "\n"); + // .. memory + fprintf(f, "%lu MB RAM; %lu MB free\n", tot_mem/MB, avl_mem/MB); + // .. graphics card + fprintf(f, "%s\n", gfx_card); + fprintf(f, "%s\n", gfx_drv); + // .. network name / ips + char hostname[100]; // possibly nodename != hostname + gethostname(hostname, sizeof(hostname)); + fprintf(f, "%s\n", hostname); + hostent* h = gethostbyname(hostname); + if(h) + { + struct in_addr** ips = (struct in_addr**)h->h_addr_list; + for(int i = 0; ips && ips[i]; i++) + fprintf(f, "%s ", inet_ntoa(*ips[i])); + fprintf(f, "\n"); + } + + fclose(f); + return 0; +} + + +// error before GUI is initialized: display message, and quit +// TODO: localization +static void display_startup_error(const wchar_t* msg) +{ + const wchar_t* caption = L"0ad startup problem"; + + write_sys_info(); + wdisplay_msg(caption, msg); + exit(1); +} + +// error before GUI is initialized: display message, and quit +// TODO: localization +static void display_startup_error(const char* msg) +{ + const char* caption = "0ad startup problem"; + + write_sys_info(); + display_msg(caption, msg); + exit(1); +} + + +static int set_vmode(int w, int h, int bpp) +{ + SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24); + SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1); + + if(!SDL_SetVideoMode(w, h, bpp, SDL_OPENGL|SDL_FULLSCREEN)) + return -1; + + glViewport(0, 0, w, h); + +#ifndef NO_GUI + g_GUI.UpdateResolution(); +#endif + + oglInit(); // required after each mode change + + return 0; +} + + +// break out of main loop +static bool quit = false; + +static bool handler(const SDL_Event& ev) +{ + int c; + + switch(ev.type) + { + case SDL_KEYDOWN: + c = ev.key.keysym.sym; + keys[c] = true; + switch(c) + { + case SDLK_ESCAPE: + quit = true; + break; + } + break; + + case SDL_KEYUP: + c = ev.key.keysym.sym; + keys[c] = false; + break; + } + + return 0; +} + + +////////////////////////////////////////////////////////////////////////////////////////////////// +// RenderTerrain: iterate through all terrain patches and submit all patches in viewing frustum to +// the renderer +void RenderTerrain() +{ + CFrustum frustum=g_Camera.GetFustum(); + u32 patchesPerSide=g_Terrain.GetPatchesPerSide(); + for (uint j=0; jGetBounds())) { + g_Renderer.Submit(patch); + } + } + } +} + +////////////////////////////////////////////////////////////////////////////////////////////////// +// RenderModels: iterate through model list and submit all models in viewing frustum to the +// Renderer +void RenderModels() +{ + CFrustum frustum=g_Camera.GetFustum(); + + const std::vector& units=g_UnitMan.GetUnits(); + uint i; + for (i=0;im_Model->GetBounds())) { + g_Renderer.Submit(units[i]->m_Model); + } + } +} + +///////////////////////////////////////////////////////////////////////////////////////////// +// RenderNoCull: render absolutely everything to a blank frame to force renderer +// to load required assets +void RenderNoCull() +{ + g_Renderer.BeginFrame(); + g_Renderer.SetCamera(g_Camera); + + uint i,j; + const std::vector& units=g_UnitMan.GetUnits(); + for (i=0;im_Model); + } + + u32 patchesPerSide=g_Terrain.GetPatchesPerSide(); + for (j=0; j& units=g_UnitMan.GetUnits(); + for (uint i=0;im_Model->Update(time); + } + + g_EntityManager.updateAll( time ); + +} + + +void ParseArgs(int argc, char* argv[]) +{ + for (int i=1;i TICK_TIME) + { + game_ticks++; + in_get_events(); + do_tick(); + time0 += TICK_TIME; + } + UpdateWorld(float(time1-time0)); + terr_update(float(time1-time0)); + Render(); + SDL_GL_SwapBuffers(); + + calc_fps(); + +#else + + double time1 = get_time(); + + in_get_events(); + UpdateWorld(float(time1-time0)); + terr_update(float(time1-time0)); + Render(); + SDL_GL_SwapBuffers(); + + calc_fps(); + time0=time1; +#endif + } + +#ifndef NO_GUI + g_GUI.Destroy(); + delete CGUI::GetSingletonPtr(); // again, we should have all singleton deletes somewhere +#endif + + delete &g_Config; + delete &g_EntityManager; + delete &g_EntityTemplateCollection; + + return 0; +} diff --git a/source/ps/CStr.cpp b/source/ps/CStr.cpp index 8d33d4936e..25871998a3 100755 --- a/source/ps/CStr.cpp +++ b/source/ps/CStr.cpp @@ -400,16 +400,9 @@ ostream &operator<<(ostream &os, CStr &Str) size_t CStr::GetHashCode() const { - // FNV-1 hash for 64 bit integers. - size_t hash = 14695981039346656037; - const char* data = m_String.data(); - for( int t = 0; t < m_String.length(); t++ ) - { - hash *= 1099511628211; - hash ^= *(data++); - } - return( hash ); - + return (size_t)fnv_hash64(m_String.data(), m_String.length()); + // janwas asks: do we care about the hash being 64 bits? + // it is truncated here on 32-bit systems; why go 64 bit at all? } uint CStr::GetSerializedLength() const diff --git a/source/ps/Parser.cpp b/source/ps/Parser.cpp index ce45b4a57d..df216ede19 100755 --- a/source/ps/Parser.cpp +++ b/source/ps/Parser.cpp @@ -18,7 +18,7 @@ using namespace std; // use GetDouble and type-cast it to <> #define FUNC_IMPL_CAST_GETDOUBLE(func_name,type) \ -_bool CParserValue::func_name(type &ret) \ +bool CParserValue::func_name(type &ret) \ { \ _double d; \ if (GetDouble(d)) \ @@ -31,7 +31,7 @@ _bool CParserValue::func_name(type &ret) \ // Get%type% from the CParserValue // func_name must belong to CParserFile #define FUNC_IMPL_GETARG(func_name, get_name, type) \ -_bool CParserLine::func_name(const _int & arg, type &ret) \ +bool CParserLine::func_name(const int & arg, type &ret) \ { \ if (GetArgCount() <= arg) \ return false; \ @@ -42,15 +42,15 @@ _bool CParserLine::func_name(const _int & arg, type &ret) \ // Function definitions //------------------------------------------------- -static _bool _IsStrictNameChar(const _char& c); -static _bool _IsValueChar(const _char& c); +static bool _IsStrictNameChar(const _char& c); +static bool _IsValueChar(const _char& c); // Functions used for checking a character if it belongs to a value // or not // Checks ident -static _bool _IsStrictNameChar(const _char& c) +static bool _IsStrictNameChar(const _char& c) { return ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || @@ -58,7 +58,7 @@ static _bool _IsStrictNameChar(const _char& c) } // Checks value -static _bool _IsValueChar(const _char& c) +static bool _IsValueChar(const _char& c) { return ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || @@ -80,7 +80,7 @@ CParserValue::~CParserValue() // Parse the string in Value to different types // bool -_bool CParserValue::GetBool(_bool &ret) +bool CParserValue::GetBool(bool &ret) { // TODO Raj Add or remove some? I can make it all lowercase // first so True and TRUE also works, or you could just @@ -111,16 +111,16 @@ _bool CParserValue::GetBool(_bool &ret) } // double -_bool CParserValue::GetDouble(_double &ret) +bool CParserValue::GetDouble(_double &ret) { // locals _double TempRet = 0.0; - _int Size = m_String.size(); - _int i; - _bool AtLeastOne = false; // Checked if at least one of the loops + int Size = m_String.size(); + int i; + bool AtLeastOne = false; // Checked if at least one of the loops // run, otherwise "." would parse OK - _int DecimalPos; - _bool Negative = false; // "-" is found + int DecimalPos; + bool Negative = false; // "-" is found // Check if '-' is found if (m_String[0]=='-') @@ -180,7 +180,7 @@ _bool CParserValue::GetDouble(_double &ret) } // string - only return m_String, can't fail -_bool CParserValue::GetString(std::string &ret) +bool CParserValue::GetString(std::string &ret) { ret = m_String; return true; @@ -192,7 +192,7 @@ _bool CParserValue::GetString(std::string &ret) FUNC_IMPL_CAST_GETDOUBLE(GetFloat, _float) FUNC_IMPL_CAST_GETDOUBLE(GetChar, _char) FUNC_IMPL_CAST_GETDOUBLE(GetShort, _short) -FUNC_IMPL_CAST_GETDOUBLE(GetInt, _int) +FUNC_IMPL_CAST_GETDOUBLE(GetInt, int) FUNC_IMPL_CAST_GETDOUBLE(GetLong, _long) FUNC_IMPL_CAST_GETDOUBLE(GetUnsignedShort, _ushort) FUNC_IMPL_CAST_GETDOUBLE(GetUnsignedInt, _uint) @@ -264,7 +264,7 @@ CParserLine::~CParserLine() } // Clear arguments (deleting m_Memory -_bool CParserLine::ClearArguments() +bool CParserLine::ClearArguments() { // Now we can actually clear it m_Arguments.clear(); @@ -275,10 +275,10 @@ _bool CParserLine::ClearArguments() // it just checks if argument isn't out of range, and // then it uses the the respective function in CParserValue FUNC_IMPL_GETARG(GetArgString, GetString, string) -FUNC_IMPL_GETARG(GetArgBool, GetBool, _bool) +FUNC_IMPL_GETARG(GetArgBool, GetBool, bool) FUNC_IMPL_GETARG(GetArgChar, GetChar, _char) FUNC_IMPL_GETARG(GetArgShort, GetShort, _short) -FUNC_IMPL_GETARG(GetArgInt, GetInt, _int) +FUNC_IMPL_GETARG(GetArgInt, GetInt, int) FUNC_IMPL_GETARG(GetArgLong, GetLong, _long) FUNC_IMPL_GETARG(GetArgUnsignedShort, GetUnsignedShort, _ushort) FUNC_IMPL_GETARG(GetArgUnsignedInt, GetUnsignedInt, _uint) @@ -293,7 +293,7 @@ FUNC_IMPL_GETARG(GetArgDouble, GetDouble, _double) // ex: // variable = 5 => variable, =, 5 // CallFunc(4,2) => CallFunc, 4, 2 -_bool CParserLine::ParseString(const CParser& Parser, string strLine) +bool CParserLine::ParseString(const CParser& Parser, string strLine) { // Don't process empty string if (strLine == string()) @@ -303,13 +303,13 @@ _bool CParserLine::ParseString(const CParser& Parser, string strLine) } // Locals - _bool Extract=false; - _int ExtractPos=0; + bool Extract=false; + int ExtractPos=0; _char Buffer[256]; _char Letter[] = {'\0','\0'}; // Letter as string vector Segments; string strSub; - _int i; + int i; // Set result to false, then if a match is found, turn it true m_ParseOK = false; @@ -343,7 +343,7 @@ _bool CParserLine::ParseString(const CParser& Parser, string strLine) if (strLine[i] == '\"') { // Extract a string, search for another " - _int pos = strLine.find("\"", i+1); + int pos = strLine.find("\"", i+1); // If matching can't be found, // the parsing will fail! @@ -419,23 +419,23 @@ _bool CParserLine::ParseString(const CParser& Parser, string strLine) // * * * * // Locals - _int Progress; // progress in Segments index - _int Lane=0; // Have many alternative routes we are in - _bool Match; // If a task-type match has been found + int Progress; // progress in Segments index + int Lane=0; // Have many alternative routes we are in + bool Match; // If a task-type match has been found // The vector of these three represents the different lanes // LastValidProgress[1] takes you back to lane 1 and how // the variables was set at that point - vector<_int> LastValidProgress; // When diving into a dynamic argument store store + vector LastValidProgress; // When diving into a dynamic argument store store // the last valid so you can go back to it - vector<_int> LastValidArgCount; // If an alternative route turns out to fail, we + vector LastValidArgCount; // If an alternative route turns out to fail, we // need to know the amount of arguments on the last // valid position, so we can remove them. - vector<_bool> LastValidMatch; // Match at that point - _bool BlockAltNode = false; // If this turns true, the alternative route + vector LastValidMatch; // Match at that point + bool BlockAltNode = false; // If this turns true, the alternative route // tested was not a success, and the settings // should be set back in order to test the // next node instead - _bool LookNoFurther = false; // If this turns true, it means a definite match has been + bool LookNoFurther = false; // If this turns true, it means a definite match has been // found and no further looking is required CParserTaskTypeNode *CurNode=NULL; // Current node on task type CParserTaskTypeNode *PrevNode=NULL; // Last node @@ -626,7 +626,7 @@ _bool CParserLine::ParseString(const CParser& Parser, string strLine) { // Store argument in CParserValue! CParserValue value; - _int i; + int i; switch(CurNode->m_Type) { @@ -754,7 +754,7 @@ _bool CParserLine::ParseString(const CParser& Parser, string strLine) // if _minus is found as argument, remove it and add "-" to the one after that // note, it's easier if std::iterator isn't used here - for (i=1; im_AltNode->m_ParentNode = CurNode; // It's repeatable - CurNode->m_AltNodeRepeatable = _bool(strSyntax[i]==START_DYNAMIC); + CurNode->m_AltNodeRepeatable = bool(strSyntax[i]==START_DYNAMIC); // Set to current CurNode = CurNode->m_AltNode; @@ -974,7 +974,7 @@ _bool CParser::InputTaskType(const string& strName, const string& strSyntax) } // Now try finding the second ')' - _int Pos = strSyntax.find(")", ExtractPos+5); + size_t Pos = strSyntax.find(")", ExtractPos+5); // Check if ')' exists at all if (Pos == string::npos)