Don't like ads? PRO users don't see any ads ;-)
Public Pastes
Guest

Untitled

By: a guest on Apr 29th, 2012  |  syntax: None  |  size: 27.75 KB  |  hits: 19  |  expires: Never
download  |  raw  |  embed  |  report abuse  |  print
Text below is selected. Please press Ctrl+C to copy to your clipboard. (⌘+C on Mac)
  1. diff --git a/Sources/Plasma/CoreLib/hsUtils.cpp b/Sources/Plasma/CoreLib/hsUtils.cpp
  2. index 5815f5d..f8cb29b 100644
  3. --- a/Sources/Plasma/CoreLib/hsUtils.cpp
  4. +++ b/Sources/Plasma/CoreLib/hsUtils.cpp
  5. @@ -52,90 +52,102 @@ extern "C" {
  6.  #include "hsTemplates.h"
  7.  
  8.  
  9. -char * hsFormatStr(const char * fmt, ...)
  10. +char* hsFormatStr(const char* fmt, ...)
  11.  {
  12.      va_list args;
  13. -    va_start(args,fmt);
  14. -    char * result = hsFormatStrV(fmt,args);
  15. +    va_start(args, fmt);
  16. +    char* result = hsFormatStrV(fmt, args);
  17.      va_end(args);
  18.      return result;
  19.  }
  20.  
  21. -char * hsFormatStrV(const char * fmt, va_list args)
  22. +char* hsFormatStrV(const char* fmt, va_list args)
  23.  {
  24.      std::string buf;
  25. -    xtl::formatv(buf,fmt,args);
  26. +    xtl::formatv(buf, fmt, args);
  27.      return hsStrcpy(buf.c_str());
  28.  }
  29.  
  30.  static char hsStrBuf[100];
  31.  
  32. -char *hsScalarToStr(hsScalar s)
  33. +char* hsScalarToStr(hsScalar s)
  34.  {
  35.  #if !(HS_BUILD_FOR_REFERENCE)
  36. -    if (s == hsIntToScalar(hsScalarToInt(s)))
  37. +
  38. +    if (s == hsIntToScalar(hsScalarToInt(s))) {
  39.          sprintf(hsStrBuf, "%d", hsScalarToInt(s));
  40. -    else
  41. -    #if HS_CAN_USE_FLOAT
  42. +    } else
  43. +#if HS_CAN_USE_FLOAT
  44.          sprintf(hsStrBuf, "%f", hsScalarToFloat(s));
  45. -    #else
  46. +
  47. +#else
  48.          sprintf(hsStrBuf, "%d:%lu", hsFixedToInt(s), (UInt16)s);
  49. -    #endif
  50. +#endif
  51.  #endif
  52.      return hsStrBuf;
  53.  }
  54.  
  55.  bool hsMessageBox_SuppressPrompts = false;
  56.  
  57. -int hsMessageBoxWithOwner(void * owner, const char message[], const char caption[], int kind, int icon)
  58. +int hsMessageBoxWithOwner(void* owner, const char message[], const char caption[], int kind, int icon)
  59.  {
  60. -    if (hsMessageBox_SuppressPrompts)
  61. +    if (hsMessageBox_SuppressPrompts) {
  62.          return hsMBoxOk;
  63. +    }
  64.  
  65.  #if HS_BUILD_FOR_WIN32
  66.      UInt32 flags = 0;
  67.  
  68. -    if (kind == hsMessageBoxNormal)
  69. +    if (kind == hsMessageBoxNormal) {
  70.          flags |= MB_OK;
  71. -    else if (kind == hsMessageBoxAbortRetyIgnore)
  72. +    } else if (kind == hsMessageBoxAbortRetyIgnore) {
  73.          flags |= MB_ABORTRETRYIGNORE;
  74. -    else if (kind == hsMessageBoxOkCancel)
  75. +    } else if (kind == hsMessageBoxOkCancel) {
  76.          flags |= MB_OKCANCEL;
  77. -    else if (kind == hsMessageBoxRetryCancel)
  78. +    } else if (kind == hsMessageBoxRetryCancel) {
  79.          flags |= MB_RETRYCANCEL;
  80. -    else if (kind == hsMessageBoxYesNo)
  81. +    } else if (kind == hsMessageBoxYesNo) {
  82.          flags |= MB_YESNO;
  83. -    else if (kind == hsMessageBoxYesNoCancel)
  84. +    } else if (kind == hsMessageBoxYesNoCancel) {
  85.          flags |= MB_YESNOCANCEL;
  86. -    else
  87. +    } else {
  88.          flags |= MB_OK;
  89. +    }
  90.  
  91. -    if (icon == hsMessageBoxIconError)
  92. +    if (icon == hsMessageBoxIconError) {
  93.          flags |= MB_ICONERROR;
  94. -    else if (icon == hsMessageBoxIconQuestion)
  95. +    } else if (icon == hsMessageBoxIconQuestion) {
  96.          flags |= MB_ICONQUESTION;
  97. -    else if (icon == hsMessageBoxIconExclamation)
  98. +    } else if (icon == hsMessageBoxIconExclamation) {
  99.          flags |= MB_ICONEXCLAMATION;
  100. -    else if (icon == hsMessageBoxIconAsterisk)
  101. +    } else if (icon == hsMessageBoxIconAsterisk) {
  102.          flags |= MB_ICONASTERISK;
  103. -    else
  104. +    } else {
  105.          flags |= MB_ICONERROR;
  106. +    }
  107.  
  108.  #ifdef CLIENT
  109.      ErrorMinimizeAppWindow();
  110.  #endif
  111.      int ans = MessageBox((HWND)owner, message, caption, flags);
  112.  
  113. -    switch (ans)
  114. -    {
  115. -    case IDOK:          return hsMBoxOk;
  116. -    case IDCANCEL:      return hsMBoxCancel;
  117. -    case IDABORT:       return hsMBoxAbort;
  118. -    case IDRETRY:       return hsMBoxRetry;
  119. -    case IDIGNORE:      return hsMBoxIgnore;
  120. -    case IDYES:         return hsMBoxYes;
  121. -    case IDNO:          return hsMBoxNo;
  122. -    default:            return hsMBoxCancel;
  123. +    switch (ans) {
  124. +        case IDOK:
  125. +            return hsMBoxOk;
  126. +        case IDCANCEL:
  127. +            return hsMBoxCancel;
  128. +        case IDABORT:
  129. +            return hsMBoxAbort;
  130. +        case IDRETRY:
  131. +            return hsMBoxRetry;
  132. +        case IDIGNORE:
  133. +            return hsMBoxIgnore;
  134. +        case IDYES:
  135. +            return hsMBoxYes;
  136. +        case IDNO:
  137. +            return hsMBoxNo;
  138. +        default:
  139. +            return hsMBoxCancel;
  140.      }
  141.  
  142.  #endif
  143. @@ -143,96 +155,106 @@ int hsMessageBoxWithOwner(void * owner, const char message[], const char caption
  144.      DebugStr(message);
  145.  #endif
  146.  #if HS_BUILD_FOR_PS2
  147. -    printf("Cap:%s Message:%s\n",caption, message);
  148. +    printf("Cap:%s Message:%s\n", caption, message);
  149.  #endif
  150.  }
  151.  
  152. -int hsMessageBoxWithOwner(void * owner, const wchar_t message[], const wchar_t caption[], int kind, int icon)
  153. +int hsMessageBoxWithOwner(void* owner, const wchar_t message[], const wchar_t caption[], int kind, int icon)
  154.  {
  155. -    if (hsMessageBox_SuppressPrompts)
  156. +    if (hsMessageBox_SuppressPrompts) {
  157.          return hsMBoxOk;
  158. +    }
  159.  
  160.  #if HS_BUILD_FOR_WIN32
  161.      UInt32 flags = 0;
  162. -    
  163. -    if (kind == hsMessageBoxNormal)
  164. +
  165. +    if (kind == hsMessageBoxNormal) {
  166.          flags |= MB_OK;
  167. -    else if (kind == hsMessageBoxAbortRetyIgnore)
  168. +    } else if (kind == hsMessageBoxAbortRetyIgnore) {
  169.          flags |= MB_ABORTRETRYIGNORE;
  170. -    else if (kind == hsMessageBoxOkCancel)
  171. +    } else if (kind == hsMessageBoxOkCancel) {
  172.          flags |= MB_OKCANCEL;
  173. -    else if (kind == hsMessageBoxRetryCancel)
  174. +    } else if (kind == hsMessageBoxRetryCancel) {
  175.          flags |= MB_RETRYCANCEL;
  176. -    else if (kind == hsMessageBoxYesNo)
  177. +    } else if (kind == hsMessageBoxYesNo) {
  178.          flags |= MB_YESNO;
  179. -    else if (kind == hsMessageBoxYesNoCancel)
  180. +    } else if (kind == hsMessageBoxYesNoCancel) {
  181.          flags |= MB_YESNOCANCEL;
  182. -    else
  183. +    } else {
  184.          flags |= MB_OK;
  185. -    
  186. -    if (icon == hsMessageBoxIconError)
  187. +    }
  188. +
  189. +    if (icon == hsMessageBoxIconError) {
  190.          flags |= MB_ICONERROR;
  191. -    else if (icon == hsMessageBoxIconQuestion)
  192. +    } else if (icon == hsMessageBoxIconQuestion) {
  193.          flags |= MB_ICONQUESTION;
  194. -    else if (icon == hsMessageBoxIconExclamation)
  195. +    } else if (icon == hsMessageBoxIconExclamation) {
  196.          flags |= MB_ICONEXCLAMATION;
  197. -    else if (icon == hsMessageBoxIconAsterisk)
  198. +    } else if (icon == hsMessageBoxIconAsterisk) {
  199.          flags |= MB_ICONASTERISK;
  200. -    else
  201. +    } else {
  202.          flags |= MB_ICONERROR;
  203. -    
  204. +    }
  205. +
  206.  #ifdef CLIENT
  207.      ErrorMinimizeAppWindow();
  208.  #endif
  209.      int ans = MessageBoxW((HWND)owner, message, caption, flags);
  210. -    
  211. -    switch (ans)
  212. -    {
  213. -    case IDOK:          return hsMBoxOk;
  214. -    case IDCANCEL:      return hsMBoxCancel;
  215. -    case IDABORT:       return hsMBoxAbort;
  216. -    case IDRETRY:       return hsMBoxRetry;
  217. -    case IDIGNORE:      return hsMBoxIgnore;
  218. -    case IDYES:         return hsMBoxYes;
  219. -    case IDNO:          return hsMBoxNo;
  220. -    default:            return hsMBoxCancel;
  221. +
  222. +    switch (ans) {
  223. +        case IDOK:
  224. +            return hsMBoxOk;
  225. +        case IDCANCEL:
  226. +            return hsMBoxCancel;
  227. +        case IDABORT:
  228. +            return hsMBoxAbort;
  229. +        case IDRETRY:
  230. +            return hsMBoxRetry;
  231. +        case IDIGNORE:
  232. +            return hsMBoxIgnore;
  233. +        case IDYES:
  234. +            return hsMBoxYes;
  235. +        case IDNO:
  236. +            return hsMBoxNo;
  237. +        default:
  238. +            return hsMBoxCancel;
  239.      }
  240. -    
  241. +
  242.  #endif
  243.  #if HS_BUILD_FOR_MACPPC
  244.      DebugStr(message);
  245.  #endif
  246.  #if HS_BUILD_FOR_PS2
  247. -    printf("Cap:%s Message:%s\n",caption, message);
  248. +    printf("Cap:%s Message:%s\n", caption, message);
  249.  #endif
  250.  }
  251.  
  252.  int hsMessageBox(const char message[], const char caption[], int kind, int icon)
  253.  {
  254.  #if HS_BUILD_FOR_WIN32
  255. -    return hsMessageBoxWithOwner(nil/*GetActiveWindow()*/,message,caption,kind,icon);
  256. +    return hsMessageBoxWithOwner(nil/*GetActiveWindow()*/, message, caption, kind, icon);
  257.  #else
  258. -    return hsMessageBoxWithOwner(nil,message,caption,kind,icon);
  259. +    return hsMessageBoxWithOwner(nil, message, caption, kind, icon);
  260.  #endif
  261.  }
  262.  
  263.  int hsMessageBox(const wchar_t message[], const wchar_t caption[], int kind, int icon)
  264.  {
  265.  #if HS_BUILD_FOR_WIN32
  266. -    return hsMessageBoxWithOwner(nil/*GetActiveWindow()*/,message,caption,kind,icon);
  267. +    return hsMessageBoxWithOwner(nil/*GetActiveWindow()*/, message, caption, kind, icon);
  268.  #else
  269. -    return hsMessageBoxWithOwner(nil,message,caption,kind,icon);
  270. +    return hsMessageBoxWithOwner(nil, message, caption, kind, icon);
  271.  #endif
  272.  }
  273.  
  274.  
  275. -/* Generic psuedo RNG used in ANSI C. */
  276. +/* Generic psuedo RNG used in ANSI C. */
  277.  static unsigned long SEED = 1;
  278.  int hsRand()
  279.  {
  280.      register int temp;
  281.      SEED = SEED * 1103515245 + 12345;
  282. -    temp = (int)((SEED/65536)&32767);
  283. +    temp = (int)((SEED / 65536) & 32767);
  284.      return (temp);
  285.  }
  286.  
  287. @@ -243,31 +265,36 @@ void hsRandSeed(int seed)
  288.  /**************************************/
  289.  int hsStrlen(const char src[])
  290.  {
  291. -    if (src==nil)
  292. +    if (src == nil) {
  293.          return 0;
  294. +    }
  295.  
  296.      int i = 0;
  297. -    while (src[i])
  298. +
  299. +    while (src[i]) {
  300.          i++;
  301. +    }
  302. +
  303.      return i;
  304.  }
  305.  
  306.  char* hsStrcpy(char dst[], const char src[])
  307.  {
  308. -    if (src)
  309. -    {
  310. -        if (dst == nil)
  311. -        {
  312. +    if (src) {
  313. +        if (dst == nil) {
  314.              int count = hsStrlen(src);
  315. -            dst = (char *)ALLOC(count + 1);
  316. +            dst = (char*)ALLOC(count + 1);
  317.              memcpy(dst, src, count);
  318.              dst[count] = 0;
  319.              return dst;
  320.          }
  321.  
  322.          Int32 i;
  323. -        for (i = 0; src[i] != 0; i++)
  324. +
  325. +        for (i = 0; src[i] != 0; i++) {
  326.              dst[i] = src[i];
  327. +        }
  328. +
  329.          dst[i] = 0;
  330.      }
  331.  
  332. @@ -276,11 +303,12 @@ char* hsStrcpy(char dst[], const char src[])
  333.  
  334.  hsBool hsStrEQ(const char s1[], const char s2[])
  335.  {
  336. -    if (s1 && s2)
  337. -    {
  338. +    if (s1 && s2) {
  339.          while (*s1)
  340. -            if(*s1++ != *s2++)
  341. +            if (*s1++ != *s2++) {
  342.                  return false;
  343. +            }
  344. +
  345.          return *s2 == 0;
  346.      }
  347.  
  348. @@ -289,11 +317,12 @@ hsBool hsStrEQ(const char s1[], const char s2[])
  349.  
  350.  hsBool hsStrCaseEQ(const char* s1, const char* s2)
  351.  {
  352. -    if (s1 && s2)
  353. -    {
  354. +    if (s1 && s2) {
  355.          while (*s1)
  356. -            if(tolower(*s1++) != tolower(*s2++))
  357. +            if (tolower(*s1++) != tolower(*s2++)) {
  358.                  return false;
  359. +            }
  360. +
  361.          return *s2 == 0;
  362.      }
  363.  
  364. @@ -302,22 +331,25 @@ hsBool hsStrCaseEQ(const char* s1, const char* s2)
  365.  
  366.  void hsStrcat(char dst[], const char src[])
  367.  {
  368. -    if (src && dst)
  369. -    {
  370. +    if (src && dst) {
  371.          dst += hsStrlen(dst);
  372. -        while(*src)
  373. +
  374. +        while (*src) {
  375.              *dst++ = *src++;
  376. +        }
  377. +
  378.          *dst = 0;
  379.      }
  380.  }
  381.  
  382. -void hsStrLower(char *s)
  383. +void hsStrLower(char* s)
  384.  {
  385. -    if (s)
  386. -    {
  387. +    if (s) {
  388.          int i;
  389. -        for (i = 0; i < hsStrlen(s); i++)
  390. -            s[i] = tolower(s[i]);
  391. +
  392. +        for (i = 0; i < hsStrlen(s); i++) {
  393. +            s[i] = tolower(s[i]);
  394. +        }
  395.      }
  396.  }
  397.  
  398. @@ -325,10 +357,12 @@ char* hsP2CString(const UInt8 pstring[], char cstring[])
  399.  {
  400.      char*        cstr = cstring;
  401.      const UInt8* stop = &pstring[1] + pstring[0];
  402. -    
  403.      pstring += 1;   //  skip length byte
  404. -    while (pstring < stop)
  405. +
  406. +    while (pstring < stop) {
  407.          *cstr++ = *pstring++;
  408. +    }
  409. +
  410.      *cstr = 0;
  411.      return cstring;
  412.  }
  413. @@ -337,8 +371,10 @@ UInt8* hsC2PString(const char cstring[], UInt8 pstring[])
  414.  {
  415.      int i;
  416.  
  417. -    for (i = 1; *cstring; i++)
  418. +    for (i = 1; *cstring; i++) {
  419.          pstring[i] = *cstring++;
  420. +    }
  421. +
  422.      pstring[0] = i - 1;
  423.      return pstring;
  424.  }
  425. @@ -346,13 +382,16 @@ UInt8* hsC2PString(const char cstring[], UInt8 pstring[])
  426.  //// IStringToWString /////////////////////////////////////////////////////////
  427.  // Converts a char * string to a wchar_t * string
  428.  
  429. -wchar_t *hsStringToWString( const char *str )
  430. +wchar_t* hsStringToWString(const char* str)
  431.  {
  432.      // convert the char string to a wchar_t string
  433.      int len = strlen(str);
  434. -    wchar_t *wideString = TRACKED_NEW wchar_t[len+1];
  435. -    for (int i=0; i<len; i++)
  436. +    wchar_t* wideString = TRACKED_NEW wchar_t[len + 1];
  437. +
  438. +    for (int i = 0; i < len; i++) {
  439.          wideString[i] = btowc(str[i]);
  440. +    }
  441. +
  442.      wideString[len] = L'\0';
  443.      return wideString;
  444.  }
  445. @@ -360,98 +399,91 @@ wchar_t *hsStringToWString( const char *str )
  446.  //// IWStringToString /////////////////////////////////////////////////////////
  447.  // Converts a wchar_t * string to a char * string
  448.  
  449. -char    *hsWStringToString( const wchar_t *str )
  450. +char*    hsWStringToString(const wchar_t* str)
  451.  {
  452.      // convert the wchar_t string to a char string
  453.      int len = wcslen(str);
  454. -    char *sStr = TRACKED_NEW char[len+1];
  455. -
  456. +    char* sStr = TRACKED_NEW char[len + 1];
  457.      int i;
  458. -    for (i = 0; i < len; i++)
  459. -    {
  460. +
  461. +    for (i = 0; i < len; i++) {
  462.          char temp = wctob(str[i]);
  463. -        if (temp == WEOF)
  464. -        {
  465. +
  466. +        if (temp == WEOF) {
  467.              sStr[i] = '\0';
  468.              i = len;
  469. -        }
  470. -        else
  471. +        } else {
  472.              sStr[i] = temp;
  473. +        }
  474.      }
  475. -    sStr[len] = '\0';
  476.  
  477. +    sStr[len] = '\0';
  478.      return sStr;
  479.  }
  480.  
  481.  void hsCPathToMacPath(char* dst, char* fname)
  482.  {
  483.      int i;
  484. -    
  485.      int     offset = 0;
  486.      hsBool  prefix = 1;     // Assume its a relative path.
  487. -    
  488. -    // KLUDGE: this determines whether a PC path is
  489. +    // KLUDGE: this determines whether a PC path is
  490.      // relative or absolute. True if relative, therefore
  491.      // we prefix the pathname with a colon.
  492. -    
  493.      hsStrcpy(dst, "");
  494.  
  495. -    if(strstr(fname, ":"))
  496. -    {
  497. +    if (strstr(fname, ":")) {
  498.          prefix = 0;
  499. -    }
  500. -    else if(strstr(fname, "\\\\"))
  501. -    {
  502. +    } else if (strstr(fname, "\\\\")) {
  503.          prefix = 0;
  504. -        offset = 2;         // copy fname from 2-bytes in. This removes
  505. -                            // the first two chars...
  506. +        offset = 2;         // copy fname from 2-bytes in. This removes
  507. +        // the first two chars...
  508.      }
  509.  
  510. -    if(prefix)
  511. -    {
  512. +    if (prefix) {
  513.          hsStrcpy(dst, ":");
  514.      }
  515. -    
  516. +
  517.      hsStrcat(dst, &fname[offset]);
  518. -    
  519. +
  520.      // No more slashes? We're done. (Optimization? Not really I guess.)
  521. -    if(!strstr(dst, "\\") && !strstr(dst, "/")) return;
  522. -    
  523. -    for(i =0; i < hsStrlen(dst); i++)
  524. -    {
  525. -        if(dst[i] == '\\' || dst[i] == '/')
  526. -        {
  527. +    if (!strstr(dst, "\\") && !strstr(dst, "/")) {
  528. +        return;
  529. +    }
  530. +
  531. +    for (i = 0; i < hsStrlen(dst); i++) {
  532. +        if (dst[i] == '\\' || dst[i] == '/') {
  533.              dst[i] = ':';
  534.          }
  535.      }
  536.  }
  537.  
  538. -int hsRemove(const char * fname)
  539. +int hsRemove(const char* fname)
  540.  {
  541.  #if HS_BUILD_FOR_MACPPC
  542.      char buf[500];
  543. -    hsStrcpy(buf,":");
  544. -    hsStrcat(buf,fname);
  545. +    hsStrcpy(buf, ":");
  546. +    hsStrcat(buf, fname);
  547.      int i;
  548. -    for(i =0; i < hsStrlen(buf); i++)
  549. -        if(buf[i] == '\\')
  550. +
  551. +    for (i = 0; i < hsStrlen(buf); i++)
  552. +        if (buf[i] == '\\') {
  553.              buf[i] = ':';
  554. +        }
  555. +
  556.      return remove(buf);
  557.  #endif
  558.      return remove(fname);
  559. -    
  560.  }
  561.  
  562.  UInt32 hsPhysicalMemory()
  563.  {
  564.  #define HS_ONE_MEGABYTE 1048576 // 1024 * 1024
  565. -
  566.  #if HS_BUILD_FOR_WIN32
  567.      MEMORYSTATUS ms;
  568.      GlobalMemoryStatus(&ms);
  569.      return (ms.dwTotalPhys / HS_ONE_MEGABYTE);
  570.  #elif HS_BUILD_FOR_MAC
  571. -    // Silver, figure out the physical memory here (in MB)  
  572. +    // Silver, figure out the physical memory here (in MB)
  573.      OSErr err;
  574.      SInt32 TotPhysicalRAM;
  575.      err = Gestalt(gestaltPhysicalRAMSize, &TotPhysicalRAM);
  576. @@ -466,66 +498,74 @@ MemSpec hsMemorySpec()
  577.      // Currently adding a little margin of error here
  578.      // due to the fact that Windows doesn't seem to
  579.      // be totally accurate in it's calculations.
  580. -    if (mem < 127)
  581. +    if (mem < 127) {
  582.          return kBlows;
  583. -    else if (mem < 255)
  584. +    } else if (mem < 255) {
  585.          return kAcceptable;
  586. -    else
  587. +    } else {
  588.          return kOptimal;
  589. +    }
  590.  }
  591.  
  592.  #if HS_BUILD_FOR_MAC
  593. -FILE *hsFopen(const char *fname, const char *mode)
  594. +FILE* hsFopen(const char* fname, const char* mode)
  595.  {
  596.      char buf[500];
  597.  #if 0
  598. -    FILE *f;
  599. -
  600. -    hsStrcpy(buf,":");
  601. -    hsStrcat(buf,fname);
  602. +    FILE* f;
  603. +    hsStrcpy(buf, ":");
  604. +    hsStrcat(buf, fname);
  605.      int i;
  606. -    for(i =0; i < hsStrlen(buf); i++)
  607. -        if(buf[i] == '\\')
  608. +
  609. +    for (i = 0; i < hsStrlen(buf); i++)
  610. +        if (buf[i] == '\\') {
  611.              buf[i] = ':';
  612. -    
  613. +        }
  614. +
  615.  #endif
  616.      hsCPathToMacPath(buf, (char*)fname);
  617. -    return fopen(buf,mode);
  618. +    return fopen(buf, mode);
  619.  }
  620.  
  621.  #endif
  622.  #if HS_BUILD_FOR_PS2
  623.  int hsPS2Open(const char name[], const char mode[])
  624.  {
  625. -  char buf[500];
  626. -  int newMode;
  627. -  int i;
  628. -  hsStrcpy(buf,"sim:");
  629. +    char buf[500];
  630. +    int newMode;
  631. +    int i;
  632. +    hsStrcpy(buf, "sim:");
  633.  //hsStrcpy(buf,"");
  634. -  hsStrcat(buf,name);
  635. -  for(i =0; i < hsStrlen(buf); i++)
  636. -    if(buf[i] == '\\')
  637. -        buf[i] = '/';
  638. -  printf("Opening File %s\n",buf);
  639. -  if(mode[0] == 'r')
  640. -    newMode = SCE_RDONLY;
  641. -  else if(mode[0] == 'w')
  642. -    newMode = SCE_WRONLY|SCE_CREAT;
  643. -  else
  644. -    hsAssert(0,"Bad mode in hsPS2Open\n");
  645. -
  646. -  printf("Opening File %s mode =%d\n",buf,newMode);
  647. -   return  sceOpen(buf,newMode);
  648. +    hsStrcat(buf, name);
  649. +
  650. +    for (i = 0; i < hsStrlen(buf); i++)
  651. +        if (buf[i] == '\\') {
  652. +            buf[i] = '/';
  653. +        }
  654. +
  655. +    printf("Opening File %s\n", buf);
  656. +
  657. +    if (mode[0] == 'r') {
  658. +        newMode = SCE_RDONLY;
  659. +    } else if (mode[0] == 'w') {
  660. +        newMode = SCE_WRONLY | SCE_CREAT;
  661. +    } else {
  662. +        hsAssert(0, "Bad mode in hsPS2Open\n");
  663. +    }
  664. +
  665. +    printf("Opening File %s mode =%d\n", buf, newMode);
  666. +    return  sceOpen(buf, newMode);
  667.  }
  668.  
  669. -void hsPS2Close( int file )
  670. +void hsPS2Close(int file)
  671.  {
  672. -    if( file != -1 )
  673. -        sceClose( file );
  674. +    if (file != -1) {
  675. +        sceClose(file);
  676. +    }
  677.  }
  678.  
  679.  //FILE *hsFopen(const char *fname, const char *mode)
  680. -//{
  681. +//{
  682.  //  FILE *f;
  683.  //  char buf[500];
  684.  //  char newMode[10];
  685. @@ -557,41 +597,60 @@ void hsPS2Close( int file )
  686.  
  687.  #if !(HS_BUILD_FOR_WIN32 || HS_BUILD_FOR_UNIX)
  688.  
  689. -int hsStrcasecmp(const char *s1, const char *s2)
  690. +int hsStrcasecmp(const char* s1, const char* s2)
  691.  {
  692. -    if (s1 && s2)
  693. -    {
  694. +    if (s1 && s2) {
  695.          char c1, c2;
  696. -        while (1)
  697. -        {
  698. +
  699. +        while (1) {
  700.              c1 = tolower(*s1++);
  701.              c2 = tolower(*s2++);
  702. -            if (c1 < c2) return -1;
  703. -            if (c1 > c2) return 1;
  704. -            if (c1 == '\0') return 0;
  705. +
  706. +            if (c1 < c2) {
  707. +                return -1;
  708. +            }
  709. +
  710. +            if (c1 > c2) {
  711. +                return 1;
  712. +            }
  713. +
  714. +            if (c1 == '\0') {
  715. +                return 0;
  716. +            }
  717.          }
  718.      }
  719. +
  720.      return !s1 ? -1 : 1;
  721.  }
  722.  
  723.  // Compare lexigraphically two strings up to a max length
  724.  
  725. -int hsStrncasecmp(const char *s1, const char *s2, int n)
  726. +int hsStrncasecmp(const char* s1, const char* s2, int n)
  727.  {
  728. -    if (s1 && s2)
  729. -    {
  730. +    if (s1 && s2) {
  731.          int i;
  732.          char c1, c2;
  733. -        for (i=0; i<n; i++)
  734. -        {
  735. +
  736. +        for (i = 0; i < n; i++) {
  737.              c1 = tolower(*s1++);
  738.              c2 = tolower(*s2++);
  739. -            if (c1 < c2) return -1;
  740. -            if (c1 > c2) return 1;
  741. -            if (!c1) return 0;
  742. +
  743. +            if (c1 < c2) {
  744. +                return -1;
  745. +            }
  746. +
  747. +            if (c1 > c2) {
  748. +                return 1;
  749. +            }
  750. +
  751. +            if (!c1) {
  752. +                return 0;
  753. +            }
  754.          }
  755. +
  756.          return 0;
  757.      }
  758. +
  759.      return !s1 ? -1 : 1;
  760.  }
  761.  #endif
  762. @@ -609,128 +668,124 @@ char** DisplaySystemVersion()
  763.      hsTArray<char*> versionStrs;
  764.      OSVERSIONINFOEX osvi;
  765.      BOOL bOsVersionInfoEx;
  766. -    
  767.      // Try calling GetVersionEx using the OSVERSIONINFOEX structure.
  768.      //
  769.      // If that fails, try using the OSVERSIONINFO structure.
  770. -    
  771.      ZeroMemory(&osvi, sizeof(OSVERSIONINFOEX));
  772.      osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
  773. -    
  774. -    if( !(bOsVersionInfoEx = GetVersionEx ((OSVERSIONINFO *) &osvi)) )
  775. -    {
  776. +
  777. +    if (!(bOsVersionInfoEx = GetVersionEx((OSVERSIONINFO*) &osvi))) {
  778.          // If OSVERSIONINFOEX doesn't work, try OSVERSIONINFO.
  779. -        
  780. -        osvi.dwOSVersionInfoSize = sizeof (OSVERSIONINFO);
  781. -        if (! GetVersionEx ( (OSVERSIONINFO *) &osvi) )
  782. +        osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
  783. +
  784. +        if (! GetVersionEx((OSVERSIONINFO*) &osvi)) {
  785.              return FALSE;
  786. +        }
  787.      }
  788. -    
  789. -    switch (osvi.dwPlatformId)
  790. -    {
  791. -    case VER_PLATFORM_WIN32_NT:
  792. -        
  793. -        // Test for the product.
  794. -        
  795. -        if ( osvi.dwMajorVersion <= 4 )
  796. -            versionStrs.Append(hsStrcpy("Microsoft Windows NT "));
  797. -        
  798. -        if ( osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 0 )
  799. -            versionStrs.Append(hsStrcpy ("Microsoft Windows 2000 "));
  800. -        
  801. -        if ( osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 1 )
  802. -            versionStrs.Append(hsStrcpy ("Microsoft Windows XP "));
  803. -        
  804. -        // Test for product type.
  805. -        
  806. -        if( bOsVersionInfoEx )
  807. -        {
  808. -            if ( osvi.wProductType == VER_NT_WORKSTATION )
  809. -            {
  810. -                if( osvi.wSuiteMask & VER_SUITE_PERSONAL )
  811. -                    versionStrs.Append(hsStrcpy ( "Personal " ));
  812. -                else
  813. -                    versionStrs.Append(hsStrcpy ( "Professional " ));
  814. +
  815. +    switch (osvi.dwPlatformId) {
  816. +        case VER_PLATFORM_WIN32_NT:
  817. +
  818. +            // Test for the product.
  819. +
  820. +            if (osvi.dwMajorVersion <= 4) {
  821. +                versionStrs.Append(hsStrcpy("Microsoft Windows NT "));
  822. +            }
  823. +
  824. +            if (osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 0) {
  825. +                versionStrs.Append(hsStrcpy("Microsoft Windows 2000 "));
  826.              }
  827. -            
  828. -            else if ( osvi.wProductType == VER_NT_SERVER )
  829. -            {
  830. -                if( osvi.wSuiteMask & VER_SUITE_DATACENTER )
  831. -                    versionStrs.Append(hsStrcpy ( "DataCenter Server " ));
  832. -                else if( osvi.wSuiteMask & VER_SUITE_ENTERPRISE )
  833. -                    versionStrs.Append(hsStrcpy ( "Advanced Server " ));
  834. -                else
  835. -                    versionStrs.Append(hsStrcpy ( "Server " ));
  836. +
  837. +            if (osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 1) {
  838. +                versionStrs.Append(hsStrcpy("Microsoft Windows XP "));
  839.              }
  840. -        }
  841. -        else
  842. -        {
  843. -            HKEY hKey;
  844. -            char szProductType[80];
  845. -            DWORD dwBufLen;
  846. -            
  847. -            RegOpenKeyEx( HKEY_LOCAL_MACHINE,
  848. -                "SYSTEM\\CurrentControlSet\\Control\\ProductOptions",
  849. -                0, KEY_QUERY_VALUE, &hKey );
  850. -            RegQueryValueEx( hKey, "ProductType", NULL, NULL,
  851. -                (LPBYTE) szProductType, &dwBufLen);
  852. -            RegCloseKey( hKey );
  853. -            if ( lstrcmpi( "WINNT", szProductType) == 0 )
  854. -                versionStrs.Append(hsStrcpy( "Professional " ));
  855. -            if ( lstrcmpi( "LANMANNT", szProductType) == 0 )
  856. -                versionStrs.Append(hsStrcpy( "Server " ));
  857. -            if ( lstrcmpi( "SERVERNT", szProductType) == 0 )
  858. -                versionStrs.Append(hsStrcpy( "Advanced Server " ));
  859. -        }
  860. -        
  861. -        // Display version, service pack (if any), and build number.
  862. -        
  863. -        if ( osvi.dwMajorVersion <= 4 )
  864. -        {
  865. -            versionStrs.Append(hsStrcpy (xtl::format("version %d.%d %s (Build %d)\n",
  866. -                osvi.dwMajorVersion,
  867. -                osvi.dwMinorVersion,
  868. -                osvi.szCSDVersion,
  869. -                osvi.dwBuildNumber & 0xFFFF).c_str()));
  870. -        }
  871. -        else
  872. -        {
  873. -            versionStrs.Append(hsStrcpy (xtl::format("%s (Build %d)\n",
  874. -                osvi.szCSDVersion,
  875. -                osvi.dwBuildNumber & 0xFFFF).c_str()));
  876. -        }
  877. -        break;
  878. -        
  879. -    case VER_PLATFORM_WIN32_WINDOWS:
  880. -        
  881. -        if (osvi.dwMajorVersion == 4 && osvi.dwMinorVersion == 0)
  882. -        {
  883. -            versionStrs.Append(hsStrcpy ("Microsoft Windows 95 "));
  884. -            if ( osvi.szCSDVersion[1] == 'C' || osvi.szCSDVersion[1] == 'B' )
  885. -                versionStrs.Append(hsStrcpy("OSR2 " ));
  886. -        }
  887. -        
  888. -        if (osvi.dwMajorVersion == 4 && osvi.dwMinorVersion == 10)
  889. -        {
  890. -            versionStrs.Append(hsStrcpy ("Microsoft Windows 98 "));
  891. -            if ( osvi.szCSDVersion[1] == 'A' )
  892. -                versionStrs.Append(hsStrcpy("SE " ));
  893. -        }
  894. -        
  895. -        if (osvi.dwMajorVersion == 4 && osvi.dwMinorVersion == 90)
  896. -        {
  897. -            versionStrs.Append(hsStrcpy ("Microsoft Windows Me "));
  898. -        }
  899. -        break;
  900. -        
  901. -    case VER_PLATFORM_WIN32s:
  902. -        
  903. -        versionStrs.Append(hsStrcpy ("Microsoft Win32s "));
  904. -        break;
  905. +
  906. +            // Test for product type.
  907. +
  908. +            if (bOsVersionInfoEx) {
  909. +                if (osvi.wProductType == VER_NT_WORKSTATION) {
  910. +                    if (osvi.wSuiteMask & VER_SUITE_PERSONAL) {
  911. +                        versionStrs.Append(hsStrcpy("Personal "));
  912. +                    } else {
  913. +                        versionStrs.Append(hsStrcpy("Professional "));
  914. +                    }
  915. +                } else if (osvi.wProductType == VER_NT_SERVER) {
  916. +                    if (osvi.wSuiteMask & VER_SUITE_DATACENTER) {
  917. +                        versionStrs.Append(hsStrcpy("DataCenter Server "));
  918. +                    } else if (osvi.wSuiteMask & VER_SUITE_ENTERPRISE) {
  919. +                        versionStrs.Append(hsStrcpy("Advanced Server "));
  920. +                    } else {
  921. +                        versionStrs.Append(hsStrcpy("Server "));
  922. +                    }
  923. +                }
  924. +            } else {
  925. +                HKEY hKey;
  926. +                char szProductType[80];
  927. +                DWORD dwBufLen;
  928. +                RegOpenKeyEx(HKEY_LOCAL_MACHINE,
  929. +                             "SYSTEM\\CurrentControlSet\\Control\\ProductOptions",
  930. +                             0, KEY_QUERY_VALUE, &hKey);
  931. +                RegQueryValueEx(hKey, "ProductType", NULL, NULL,
  932. +                                (LPBYTE) szProductType, &dwBufLen);
  933. +                RegCloseKey(hKey);
  934. +
  935. +                if (lstrcmpi("WINNT", szProductType) == 0) {
  936. +                    versionStrs.Append(hsStrcpy("Professional "));
  937. +                }
  938. +
  939. +                if (lstrcmpi("LANMANNT", szProductType) == 0) {
  940. +                    versionStrs.Append(hsStrcpy("Server "));
  941. +                }
  942. +
  943. +                if (lstrcmpi("SERVERNT", szProductType) == 0) {
  944. +                    versionStrs.Append(hsStrcpy("Advanced Server "));
  945. +                }
  946. +            }
  947. +
  948. +            // Display version, service pack (if any), and build number.
  949. +
  950. +            if (osvi.dwMajorVersion <= 4) {
  951. +                versionStrs.Append(hsStrcpy(xtl::format("version %d.%d %s (Build %d)\n",
  952. +                                                        osvi.dwMajorVersion,
  953. +                                                        osvi.dwMinorVersion,
  954. +                                                        osvi.szCSDVersion,
  955. +                                                        osvi.dwBuildNumber & 0xFFFF).c_str()));
  956. +            } else {
  957. +                versionStrs.Append(hsStrcpy(xtl::format("%s (Build %d)\n",
  958. +                                                        osvi.szCSDVersion,
  959. +                                                        osvi.dwBuildNumber & 0xFFFF).c_str()));
  960. +            }
  961. +
  962. +            break;
  963. +        case VER_PLATFORM_WIN32_WINDOWS:
  964. +
  965. +            if (osvi.dwMajorVersion == 4 && osvi.dwMinorVersion == 0) {
  966. +                versionStrs.Append(hsStrcpy("Microsoft Windows 95 "));
  967. +
  968. +                if (osvi.szCSDVersion[1] == 'C' || osvi.szCSDVersion[1] == 'B') {
  969. +                    versionStrs.Append(hsStrcpy("OSR2 "));
  970. +                }
  971. +            }
  972. +
  973. +            if (osvi.dwMajorVersion == 4 && osvi.dwMinorVersion == 10) {
  974. +                versionStrs.Append(hsStrcpy("Microsoft Windows 98 "));
  975. +
  976. +                if (osvi.szCSDVersion[1] == 'A') {
  977. +                    versionStrs.Append(hsStrcpy("SE "));
  978. +                }
  979. +            }
  980. +
  981. +            if (osvi.dwMajorVersion == 4 && osvi.dwMinorVersion == 90) {
  982. +                versionStrs.Append(hsStrcpy("Microsoft Windows Me "));
  983. +            }
  984. +
  985. +            break;
  986. +        case VER_PLATFORM_WIN32s:
  987. +            versionStrs.Append(hsStrcpy("Microsoft Win32s "));
  988. +            break;
  989.      }
  990. -    
  991. +
  992.      versionStrs.Append(nil);    // terminator
  993. -    
  994.      return versionStrs.DetachArray();
  995.  #else
  996.      return nil;
create a new version of this paste RAW Paste Data