home *** CD-ROM | disk | FTP | other *** search
/ PC PowerPlay 58 / pcpp58a.iso / extras / quake 3 source / Q3A_ToolSource.exe / Main / cmdlib.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  2001-01-02  |  8.1 KB  |  551 lines
  1. //
  2. // start of shared cmdlib stuff
  3. // 
  4.  
  5.  
  6. #include "cmdlib.h"
  7. #include "windows.h"
  8.  
  9. #define PATHSEPERATOR   '/'
  10.  
  11. // rad additions
  12. // 11.29.99
  13. PFN_ERR *g_pfnError = NULL;
  14. PFN_PRINTF *g_pfnPrintf = NULL;
  15. PFN_ERR_NUM *g_pfnErrorNum = NULL;
  16. PFN_PRINTF_NUM *g_pfnPrintfNum = NULL;
  17.  
  18.  
  19. void Error(const char *pFormat, ...)
  20. {
  21.   if (g_pfnError)
  22.   {
  23.     va_list arg_ptr;
  24.     va_start(arg_ptr, pFormat);
  25.     g_pfnError(pFormat, arg_ptr);
  26.     va_end(arg_ptr);
  27.   }
  28. }
  29.  
  30. void Printf(const char *pFormat, ...)
  31. {
  32.   if (g_pfnPrintf)
  33.   {
  34.     va_list arg_ptr;
  35.     va_start(arg_ptr, pFormat);
  36.     g_pfnPrintf(pFormat, arg_ptr);
  37.     va_end(arg_ptr);
  38.   }
  39. }
  40.  
  41. void ErrorNum(int nErr, const char *pFormat, ...)
  42. {
  43.   if (g_pfnErrorNum)
  44.   {
  45.     va_list arg_ptr;
  46.     va_start(arg_ptr, pFormat);
  47.     g_pfnErrorNum(nErr, pFormat, arg_ptr);
  48.     va_end(arg_ptr);
  49.   }
  50. }
  51.  
  52. void PrintfNum(int nErr, const char *pFormat, ...)
  53. {
  54.   if (g_pfnPrintfNum)
  55.   {
  56.     va_list arg_ptr;
  57.     va_start(arg_ptr, pFormat);
  58.     g_pfnPrintfNum(nErr, pFormat, arg_ptr);
  59.     va_end(arg_ptr);
  60.   }
  61. }
  62.  
  63.  
  64.  
  65. void SetErrorHandler(PFN_ERR pe)
  66. {
  67.   g_pfnError = pe;
  68. }
  69.  
  70. void SetPrintfHandler(PFN_PRINTF pe)
  71. {
  72.   g_pfnPrintf = pe;
  73. }
  74.  
  75. void SetErrorHandlerNum(PFN_ERR_NUM pe)
  76. {
  77.   g_pfnErrorNum = pe;
  78. }
  79.  
  80. void SetPrintfHandler(PFN_PRINTF_NUM pe)
  81. {
  82.   g_pfnPrintfNum = pe;
  83. }
  84.  
  85.  
  86.  
  87. // rad end
  88.  
  89. #define MEM_BLOCKSIZE 4096
  90. void* qblockmalloc(size_t nSize)
  91. {
  92.     void *b;
  93.   // round up to threshold
  94.   int nAllocSize = nSize % MEM_BLOCKSIZE;
  95.   if ( nAllocSize > 0)
  96.   {
  97.     nSize += MEM_BLOCKSIZE - nAllocSize;
  98.   }
  99.     b = malloc(nSize + 1);
  100.     memset (b, 0, nSize);
  101.     return b;
  102. }
  103.  
  104. void* qmalloc (size_t nSize)
  105. {
  106.     void *b;
  107.     b = malloc(nSize + 1);
  108.     memset (b, 0, nSize);
  109.     return b;
  110. }
  111.  
  112. /*
  113. ================
  114. Q_filelength
  115. ================
  116. */
  117. int Q_filelength (FILE *f)
  118. {
  119.     int        pos;
  120.     int        end;
  121.  
  122.     pos = ftell (f);
  123.     fseek (f, 0, SEEK_END);
  124.     end = ftell (f);
  125.     fseek (f, pos, SEEK_SET);
  126.  
  127.     return end;
  128. }
  129.  
  130.  
  131. // FIXME: need error handler
  132. FILE *SafeOpenWrite (const char *filename)
  133. {
  134.     FILE    *f;
  135.  
  136.     f = fopen(filename, "wb");
  137.  
  138.     if (!f)
  139.   {
  140.         Error ("Error opening %s: %s",filename,strerror(errno));
  141.   }
  142.  
  143.     return f;
  144. }
  145.  
  146. FILE *SafeOpenRead (const char *filename)
  147. {
  148.     FILE    *f;
  149.  
  150.     f = fopen(filename, "rb");
  151.  
  152.     if (!f)
  153.   {
  154.         Error ("Error opening %s: %s",filename,strerror(errno));
  155.   }
  156.  
  157.     return f;
  158. }
  159.  
  160.  
  161. void SafeRead (FILE *f, void *buffer, int count)
  162. {
  163.     if ( (int)fread (buffer, 1, count, f) != count)
  164.         Error ("File read failure");
  165. }
  166.  
  167.  
  168. void SafeWrite (FILE *f, void *buffer, int count)
  169. {
  170.     if ( (int)fwrite (buffer, 1, count, f) != count)
  171.         Error ("File read failure");
  172. }
  173.  
  174.  
  175.  
  176. /*
  177. ==============
  178. LoadFile
  179. ==============
  180. */
  181. int LoadFile (const char *filename, void **bufferptr)
  182. {
  183.     FILE    *f;
  184.     int    length;
  185.     void    *buffer;
  186.  
  187.   *bufferptr = NULL;
  188.   
  189.   if (filename == NULL || strlen(filename) == 0)
  190.   {
  191.     return -1;
  192.   }
  193.  
  194.     f = fopen (filename, "rb");
  195.     if (!f)
  196.     {
  197.         return -1;
  198.     }
  199.     length = Q_filelength (f);
  200.     buffer = qblockmalloc (length+1);
  201.     ((char *)buffer)[length] = 0;
  202.     SafeRead (f, buffer, length);
  203.     fclose (f);
  204.  
  205.     *bufferptr = buffer;
  206.     return length;
  207. }
  208.  
  209.  
  210. /*
  211. ==============
  212. LoadFileNoCrash
  213.  
  214. returns -1 length if not present
  215. ==============
  216. */
  217. int    LoadFileNoCrash (const char *filename, void **bufferptr)
  218. {
  219.     FILE    *f;
  220.     int    length;
  221.     void    *buffer;
  222.  
  223.     f = fopen (filename, "rb");
  224.     if (!f)
  225.         return -1;
  226.     length = Q_filelength (f);
  227.     buffer = qmalloc (length+1);
  228.     ((char *)buffer)[length] = 0;
  229.     SafeRead (f, buffer, length);
  230.     fclose (f);
  231.  
  232.     *bufferptr = buffer;
  233.     return length;
  234. }
  235.  
  236.  
  237. /*
  238. ==============
  239. SaveFile
  240. ==============
  241. */
  242. void    SaveFile (const char *filename, void *buffer, int count)
  243. {
  244.     FILE    *f;
  245.  
  246.     f = SafeOpenWrite (filename);
  247.     SafeWrite (f, buffer, count);
  248.     fclose (f);
  249. }
  250.  
  251.  
  252.  
  253. void DefaultExtension (char *path, char *extension)
  254. {
  255.     char    *src;
  256. //
  257. // if path doesn't have a .EXT, append extension
  258. // (extension should include the .)
  259. //
  260.     src = path + strlen(path) - 1;
  261.  
  262.     while (*src != PATHSEPERATOR && src != path)
  263.     {
  264.         if (*src == '.')
  265.             return;                 // it has an extension
  266.         src--;
  267.     }
  268.  
  269.     strcat (path, extension);
  270. }
  271.  
  272.  
  273. void DefaultPath (char *path, char *basepath)
  274. {
  275.     char    temp[128];
  276.  
  277.     if (path[0] == PATHSEPERATOR)
  278.         return;                   // absolute path location
  279.     strcpy (temp,path);
  280.     strcpy (path,basepath);
  281.     strcat (path,temp);
  282. }
  283.  
  284.  
  285. void    StripFilename (char *path)
  286. {
  287.     int             length;
  288.  
  289.     length = strlen(path)-1;
  290.     while (length > 0 && path[length] != PATHSEPERATOR)
  291.         length--;
  292.     path[length] = 0;
  293. }
  294.  
  295. void    StripExtension (char *path)
  296. {
  297.     int             length;
  298.  
  299.     length = strlen(path)-1;
  300.     while (length > 0 && path[length] != '.')
  301.     {
  302.         length--;
  303.         if (path[length] == '/')
  304.             return;        // no extension
  305.     }
  306.     if (length)
  307.         path[length] = 0;
  308. }
  309.  
  310.  
  311. /*
  312. ====================
  313. Extract file parts
  314. ====================
  315. */
  316. void ExtractFilePath (const char *path, char *dest)
  317. {
  318.     const char *src;
  319.  
  320.     src = path + strlen(path) - 1;
  321.  
  322. //
  323. // back up until a \ or the start
  324. //
  325.     while (src != path && *(src-1) != PATHSEPERATOR)
  326.         src--;
  327.  
  328.     memcpy (dest, path, src-path);
  329.     dest[src-path] = 0;
  330. }
  331.  
  332. void ExtractFileName (const char *path, char *dest)
  333. {
  334.     const char *src;
  335.  
  336.     src = path + strlen(path) - 1;
  337.  
  338. //
  339. // back up until a \ or the start
  340. //
  341.     while (src != path && *(src-1) != '/' 
  342.          && *(src-1) != '\\' )
  343.         src--;
  344.  
  345.     while (*src)
  346.     {
  347.         *dest++ = *src++;
  348.     }
  349.     *dest = 0;
  350. }
  351.  
  352. void ExtractFileBase (const char *path, char *dest)
  353. {
  354.     const char *src;
  355.  
  356.     src = path + strlen(path) - 1;
  357.  
  358. //
  359. // back up until a \ or the start
  360. //
  361.     while (src != path && *(src-1) != '/' 
  362.          && *(src-1) != '\\' )
  363.         src--;
  364.  
  365.     while (*src && *src != '.')
  366.     {
  367.         *dest++ = *src++;
  368.     }
  369.     *dest = 0;
  370. }
  371.  
  372. void ExtractFileExtension (const char *path, char *dest)
  373. {
  374.     const char *src;
  375.  
  376.     src = path + strlen(path) - 1;
  377.  
  378. //
  379. // back up until a . or the start
  380. //
  381.     while (src != path && *(src-1) != '.')
  382.         src--;
  383.     if (src == path)
  384.     {
  385.         *dest = 0;    // no extension
  386.         return;
  387.     }
  388.  
  389.     strcpy (dest,src);
  390. }
  391.  
  392.  
  393. void ConvertDOSToUnixName( char *dst, const char *src )
  394. {
  395.     while ( *src )
  396.     {
  397.         if ( *src == '\\' )
  398.             *dst = '/';
  399.         else
  400.             *dst = *src;
  401.         dst++; src++;
  402.     }
  403.     *dst = 0;
  404. }
  405.  
  406.  
  407. char* StrDup(char* pStr)
  408. { 
  409.   if (pStr)
  410.   {
  411.     return strcpy(new char[strlen(pStr)+1], pStr); 
  412.   }
  413.   return NULL;
  414. }
  415.  
  416. char* StrDup(const char* pStr)
  417. { 
  418.   if (pStr)
  419.   {
  420.     return strcpy(new char[strlen(pStr)+1], pStr); 
  421.   }
  422.   return NULL;
  423. }
  424.  
  425.  
  426. /*
  427. ============================================================================
  428.  
  429.                     BYTE ORDER FUNCTIONS
  430.  
  431. ============================================================================
  432. */
  433.  
  434. #ifdef _SGI_SOURCE
  435. #define    __BIG_ENDIAN__
  436. #endif
  437.  
  438. #ifdef __BIG_ENDIAN__
  439.  
  440. short   LittleShort (short l)
  441. {
  442.     byte    b1,b2;
  443.  
  444.     b1 = l&255;
  445.     b2 = (l>>8)&255;
  446.  
  447.     return (b1<<8) + b2;
  448. }
  449.  
  450. short   BigShort (short l)
  451. {
  452.     return l;
  453. }
  454.  
  455.  
  456. int    LittleLong (int l)
  457. {
  458.     byte    b1,b2,b3,b4;
  459.  
  460.     b1 = l&255;
  461.     b2 = (l>>8)&255;
  462.     b3 = (l>>16)&255;
  463.     b4 = (l>>24)&255;
  464.  
  465.     return ((int)b1<<24) + ((int)b2<<16) + ((int)b3<<8) + b4;
  466. }
  467.  
  468. int    BigLong (int l)
  469. {
  470.     return l;
  471. }
  472.  
  473.  
  474. float    LittleFloat (float l)
  475. {
  476.     union {byte b[4]; float f;} in, out;
  477.     
  478.     in.f = l;
  479.     out.b[0] = in.b[3];
  480.     out.b[1] = in.b[2];
  481.     out.b[2] = in.b[1];
  482.     out.b[3] = in.b[0];
  483.     
  484.     return out.f;
  485. }
  486.  
  487. float    BigFloat (float l)
  488. {
  489.     return l;
  490. }
  491.  
  492.  
  493. #else
  494.  
  495.  
  496. short   BigShort (short l)
  497. {
  498.     byte    b1,b2;
  499.  
  500.     b1 = l&255;
  501.     b2 = (l>>8)&255;
  502.  
  503.     return (b1<<8) + b2;
  504. }
  505.  
  506. short   LittleShort (short l)
  507. {
  508.     return l;
  509. }
  510.  
  511.  
  512. int    BigLong (int l)
  513. {
  514.     byte    b1,b2,b3,b4;
  515.  
  516.     b1 = l&255;
  517.     b2 = (l>>8)&255;
  518.     b3 = (l>>16)&255;
  519.     b4 = (l>>24)&255;
  520.  
  521.     return ((int)b1<<24) + ((int)b2<<16) + ((int)b3<<8) + b4;
  522. }
  523.  
  524. int    LittleLong (int l)
  525. {
  526.     return l;
  527. }
  528.  
  529. float    BigFloat (float l)
  530. {
  531.     union {byte b[4]; float f;} in, out;
  532.     
  533.     in.f = l;
  534.     out.b[0] = in.b[3];
  535.     out.b[1] = in.b[2];
  536.     out.b[2] = in.b[1];
  537.     out.b[3] = in.b[0];
  538.     
  539.     return out.f;
  540. }
  541.  
  542. float    LittleFloat (float l)
  543. {
  544.     return l;
  545. }
  546.  
  547.  
  548.  
  549. #endif
  550.  
  551.