home *** CD-ROM | disk | FTP | other *** search
/ ST-Computer Leser-CD 2000 January / LCD_01_2000.iso / games / doom / pmdoom / src / w_wad.c < prev    next >
Encoding:
C/C++ Source or Header  |  1999-12-17  |  11.8 KB  |  611 lines
  1. /*  Emacs style mode select   -*- C++ -*-  */
  2. /* ----------------------------------------------------------------------------- */
  3. /*  */
  4. /*  $Id:$ */
  5. /*  */
  6. /*  Copyright (C) 1993-1996 by id Software, Inc. */
  7. /*  */
  8. /*  This source is available for distribution and/or modification */
  9. /*  only under the terms of the DOOM Source Code License as */
  10. /*  published by id Software. All rights reserved. */
  11. /*  */
  12. /*  The source is distributed in the hope that it will be useful, */
  13. /*  but WITHOUT ANY WARRANTY; without even the implied warranty of */
  14. /*  FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License */
  15. /*  for more details. */
  16. /*  */
  17. /*  $Log:$ */
  18. /*  */
  19. /*  DESCRIPTION: */
  20. /*     Handles WAD file header, directory, lump I/O. */
  21. /*  */
  22. /* ----------------------------------------------------------------------------- */
  23.  
  24.  
  25. static const char
  26. rcsid[] = "$Id: w_wad.c,v 1.5 1997/02/03 16:47:57 b1 Exp $";
  27.  
  28.  
  29. #ifdef NORMALUNIX
  30. #include <ctype.h>
  31. #include <sys/types.h>
  32. #include <string.h>
  33. #include <unistd.h>
  34. #include <malloc.h>
  35. #include <fcntl.h>
  36. #include <sys/stat.h>
  37. #ifndef ATARI
  38. #include <alloca.h>
  39. #endif
  40. #define O_BINARY        0
  41. #endif
  42.  
  43. #include "doomtype.h"
  44. #include "m_swap.h"
  45. #include "i_system.h"
  46. #include "z_zone.h"
  47.  
  48. #ifdef __GNUG__
  49. #pragma implementation "w_wad.h"
  50. #endif
  51. #include "w_wad.h"
  52.  
  53.  
  54.  
  55.  
  56.  
  57.  
  58. /*  */
  59. /*  GLOBALS */
  60. /*  */
  61.  
  62. /*  Location of each lump on disk. */
  63. lumpinfo_t*        lumpinfo;        
  64. int            numlumps;
  65.  
  66. void**            lumpcache;
  67.  
  68.  
  69. #define strcmpi    strcasecmp
  70.  
  71. #ifndef ATARI
  72. void strupr (char* s)
  73. {
  74.     while (*s) { *s = toupper(*s); s++; }
  75. }
  76. #endif
  77.  
  78. int filelength (int handle) 
  79. { 
  80.     struct stat    fileinfo;
  81.     
  82.     if (fstat (handle,&fileinfo) == -1)
  83.     I_Error ("Error fstating");
  84.  
  85.     return fileinfo.st_size;
  86. }
  87.  
  88.  
  89. void
  90. ExtractFileBase
  91. ( char*        path,
  92.   char*        dest )
  93. {
  94.     char*    src;
  95.     int        length;
  96.  
  97.     src = path + strlen(path) - 1;
  98.     
  99.     /*  back up until a \ or the start */
  100.     while (src != path
  101.        && *(src-1) != '\\'
  102.        && *(src-1) != '/')
  103.     {
  104.     src--;
  105.     }
  106.     
  107.     /*  copy up to eight characters */
  108.     memset (dest,0,8);
  109.     length = 0;
  110.     
  111.     while (*src && *src != '.')
  112.     {
  113.     if (++length == 9)
  114.         I_Error ("Filename base of %s >8 chars",path);
  115.  
  116.     *dest++ = toupper((int)*src++);
  117.     }
  118. }
  119.  
  120.  
  121.  
  122.  
  123.  
  124. /*  */
  125. /*  LUMP BASED ROUTINES. */
  126. /*  */
  127.  
  128. /*  */
  129. /*  W_AddFile */
  130. /*  All files are optional, but at least one file must be */
  131. /*   found (PWAD, if all required lumps are present). */
  132. /*  Files with a .wad extension are wadlink files */
  133. /*   with multiple lumps. */
  134. /*  Other files are single lumps with the base filename */
  135. /*   for the lump name. */
  136. /*  */
  137. /*  If filename starts with a tilde, the file is handled */
  138. /*   specially to allow map reloads. */
  139. /*  But: the reload feature is a fragile hack... */
  140.  
  141. int            reloadlump;
  142. char*            reloadname;
  143.  
  144.  
  145. void W_AddFile (char *filename)
  146. {
  147.     wadinfo_t        header;
  148.     lumpinfo_t*        lump_p;
  149.     unsigned        i;
  150.     int            handle;
  151.     int            length;
  152.     int            startlump;
  153.     filelump_t*        fileinfo;
  154.     filelump_t        singleinfo;
  155.     int            storehandle;
  156.     
  157.     /*  open the file and add to directory */
  158.  
  159.     /*  handle reload indicator. */
  160.     if (filename[0] == '~')
  161.     {
  162.     filename++;
  163.     reloadname = filename;
  164.     reloadlump = numlumps;
  165.     }
  166.         
  167.     if ( (handle = open (filename,O_RDONLY | O_BINARY)) == -1)
  168.     {
  169.     printf (" couldn't open %s\n",filename);
  170.     return;
  171.     }
  172.  
  173.     printf (" adding %s\n",filename);
  174.     startlump = numlumps;
  175.     
  176.     if (strcmpi (filename+strlen(filename)-3 , "wad" ) )
  177.     {
  178.     /*  single lump file */
  179.     fileinfo = &singleinfo;
  180.     singleinfo.filepos = 0;
  181.     singleinfo.size = LONG(filelength(handle));
  182.     ExtractFileBase (filename, singleinfo.name);
  183.     numlumps++;
  184.     }
  185.     else 
  186.     {
  187.     /*  WAD file */
  188.     read (handle, &header, sizeof(header));
  189.     if (strncmp(header.identification,"IWAD",4))
  190.     {
  191.         /*  Homebrew levels? */
  192.         if (strncmp(header.identification,"PWAD",4))
  193.         {
  194.         I_Error ("Wad file %s doesn't have IWAD "
  195.              "or PWAD id\n", filename);
  196.         }
  197.         
  198.         /*  ???modifiedgame = true;         */
  199.     }
  200.     header.numlumps = LONG(header.numlumps);
  201.     header.infotableofs = LONG(header.infotableofs);
  202.     length = header.numlumps*sizeof(filelump_t);
  203.     fileinfo = alloca (length);
  204.     lseek (handle, header.infotableofs, SEEK_SET);
  205.     read (handle, fileinfo, length);
  206.     numlumps += header.numlumps;
  207.     }
  208.  
  209.     
  210.     /*  Fill in lumpinfo */
  211.     lumpinfo = realloc (lumpinfo, numlumps*sizeof(lumpinfo_t));
  212.  
  213.     if (!lumpinfo)
  214.     I_Error ("Couldn't realloc lumpinfo");
  215.  
  216.     lump_p = &lumpinfo[startlump];
  217.     
  218.     storehandle = reloadname ? -1 : handle;
  219.     
  220.     for (i=startlump ; i<numlumps ; i++,lump_p++, fileinfo++)
  221.     {
  222.     lump_p->handle = storehandle;
  223.     lump_p->position = LONG(fileinfo->filepos);
  224.     lump_p->size = LONG(fileinfo->size);
  225.     strncpy (lump_p->name, fileinfo->name, 8);
  226.     }
  227.     
  228.     if (reloadname)
  229.     close (handle);
  230. }
  231.  
  232.  
  233.  
  234.  
  235. /*  */
  236. /*  W_Reload */
  237. /*  Flushes any of the reloadable lumps in memory */
  238. /*   and reloads the directory. */
  239. /*  */
  240. void W_Reload (void)
  241. {
  242.     wadinfo_t        header;
  243.     int            lumpcount;
  244.     lumpinfo_t*        lump_p;
  245.     unsigned        i;
  246.     int            handle;
  247.     int            length;
  248.     filelump_t*        fileinfo;
  249.     
  250.     if (!reloadname)
  251.     return;
  252.         
  253.     if ( (handle = open (reloadname,O_RDONLY | O_BINARY)) == -1)
  254.     I_Error ("W_Reload: couldn't open %s",reloadname);
  255.  
  256.     read (handle, &header, sizeof(header));
  257.     lumpcount = LONG(header.numlumps);
  258.     header.infotableofs = LONG(header.infotableofs);
  259.     length = lumpcount*sizeof(filelump_t);
  260.     fileinfo = alloca (length);
  261.     lseek (handle, header.infotableofs, SEEK_SET);
  262.     read (handle, fileinfo, length);
  263.     
  264.     /*  Fill in lumpinfo */
  265.     lump_p = &lumpinfo[reloadlump];
  266.     
  267.     for (i=reloadlump ;
  268.      i<reloadlump+lumpcount ;
  269.      i++,lump_p++, fileinfo++)
  270.     {
  271.     if (lumpcache[i])
  272.         Z_Free (lumpcache[i]);
  273.  
  274.     lump_p->position = LONG(fileinfo->filepos);
  275.     lump_p->size = LONG(fileinfo->size);
  276.     }
  277.     
  278.     close (handle);
  279. }
  280.  
  281.  
  282.  
  283. /*  */
  284. /*  W_InitMultipleFiles */
  285. /*  Pass a null terminated list of files to use. */
  286. /*  All files are optional, but at least one file */
  287. /*   must be found. */
  288. /*  Files with a .wad extension are idlink files */
  289. /*   with multiple lumps. */
  290. /*  Other files are single lumps with the base filename */
  291. /*   for the lump name. */
  292. /*  Lump names can appear multiple times. */
  293. /*  The name searcher looks backwards, so a later file */
  294. /*   does override all earlier ones. */
  295. /*  */
  296. void W_InitMultipleFiles (char** filenames)
  297. {    
  298.     int        size;
  299.     
  300.     /*  open all the files, load headers, and count lumps */
  301.     numlumps = 0;
  302.  
  303.     /*  will be realloced as lumps are added */
  304.     lumpinfo = malloc(1);    
  305.  
  306.     for ( ; *filenames ; filenames++)
  307.     W_AddFile (*filenames);
  308.  
  309.     if (!numlumps)
  310.     I_Error ("W_InitFiles: no files found");
  311.     
  312.     /*  set up caching */
  313.     size = numlumps * sizeof(*lumpcache);
  314.     lumpcache = malloc (size);
  315.     
  316.     if (!lumpcache)
  317.     I_Error ("Couldn't allocate lumpcache");
  318.  
  319.     memset (lumpcache,0, size);
  320. }
  321.  
  322.  
  323.  
  324.  
  325. /*  */
  326. /*  W_InitFile */
  327. /*  Just initialize from a single file. */
  328. /*  */
  329. void W_InitFile (char* filename)
  330. {
  331.     char*    names[2];
  332.  
  333.     names[0] = filename;
  334.     names[1] = NULL;
  335.     W_InitMultipleFiles (names);
  336. }
  337.  
  338.  
  339.  
  340. /*  */
  341. /*  W_NumLumps */
  342. /*  */
  343. int W_NumLumps (void)
  344. {
  345.     return numlumps;
  346. }
  347.  
  348.  
  349.  
  350. /*  */
  351. /*  W_CheckNumForName */
  352. /*  Returns -1 if name not found. */
  353. /*  */
  354.  
  355. int W_CheckNumForName (char* name)
  356. {
  357.     union {
  358.     char    s[9];
  359.     int    x[2];
  360.     
  361.     } name8;
  362.     
  363.     int        v1;
  364.     int        v2;
  365.     lumpinfo_t*    lump_p;
  366.  
  367.     /*  make the name into two integers for easy compares */
  368.     strncpy (name8.s,name,8);
  369.  
  370.     /*  in case the name was a fill 8 chars */
  371.     name8.s[8] = 0;
  372.  
  373.     /*  case insensitive */
  374.     strupr (name8.s);        
  375.  
  376.     v1 = name8.x[0];
  377.     v2 = name8.x[1];
  378.  
  379.  
  380.     /*  scan backwards so patch lump files take precedence */
  381.     lump_p = lumpinfo + numlumps;
  382.  
  383.     while (lump_p-- != lumpinfo)
  384.     {
  385.     if ( *(int *)lump_p->name == v1
  386.          && *(int *)&lump_p->name[4] == v2)
  387.     {
  388.         return lump_p - lumpinfo;
  389.     }
  390.     }
  391.  
  392.     /*  TFB. Not found. */
  393.     return -1;
  394. }
  395.  
  396.  
  397.  
  398.  
  399. /*  */
  400. /*  W_GetNumForName */
  401. /*  Calls W_CheckNumForName, but bombs out if not found. */
  402. /*  */
  403. int W_GetNumForName (char* name)
  404. {
  405.     int    i;
  406.  
  407.     i = W_CheckNumForName (name);
  408.     
  409.     if (i == -1)
  410.       I_Error ("W_GetNumForName: %s not found!", name);
  411.       
  412.     return i;
  413. }
  414.  
  415.  
  416. /*  */
  417. /*  W_LumpLength */
  418. /*  Returns the buffer size needed to load the given lump. */
  419. /*  */
  420. int W_LumpLength (int lump)
  421. {
  422.     if (lump >= numlumps)
  423.     I_Error ("W_LumpLength: %i >= numlumps",lump);
  424.  
  425.     return lumpinfo[lump].size;
  426. }
  427.  
  428.  
  429.  
  430. /*  */
  431. /*  W_ReadLump */
  432. /*  Loads the lump into the given buffer, */
  433. /*   which must be >= W_LumpLength(). */
  434. /*  */
  435. void
  436. W_ReadLump
  437. ( int        lump,
  438.   void*        dest )
  439. {
  440.     int        c;
  441.     lumpinfo_t*    l;
  442.     int        handle;
  443.     
  444.     if (lump >= numlumps)
  445.     I_Error ("W_ReadLump: %i >= numlumps",lump);
  446.  
  447.     l = lumpinfo+lump;
  448.     
  449.     /*  ??? I_BeginRead (); */
  450.     
  451.     if (l->handle == -1)
  452.     {
  453.     /*  reloadable file, so use open / read / close */
  454.     if ( (handle = open (reloadname,O_RDONLY | O_BINARY)) == -1)
  455.         I_Error ("W_ReadLump: couldn't open %s",reloadname);
  456.     }
  457.     else
  458.     handle = l->handle;
  459.         
  460.     lseek (handle, l->position, SEEK_SET);
  461.     c = read (handle, dest, l->size);
  462.  
  463.     if (c < l->size)
  464.     I_Error ("W_ReadLump: only read %i of %i on lump %i",
  465.          c,l->size,lump);    
  466.  
  467.     if (l->handle == -1)
  468.     close (handle);
  469.         
  470.     /*  ??? I_EndRead (); */
  471. }
  472.  
  473.  
  474.  
  475.  
  476. /*  */
  477. /*  W_CacheLumpNum */
  478. /*  */
  479. void*
  480. W_CacheLumpNum
  481. ( int        lump,
  482.   int        tag )
  483. {
  484.     byte*    ptr;
  485.  
  486.     if ((unsigned)lump >= numlumps)
  487.     I_Error ("W_CacheLumpNum: %i >= numlumps",lump);
  488.         
  489.     if (!lumpcache[lump])
  490.     {
  491.     /*  read the lump in */
  492.     
  493.     /* printf ("cache miss on lump %i\n",lump); */
  494.     ptr = Z_Malloc (W_LumpLength (lump), tag, &lumpcache[lump]);
  495.     W_ReadLump (lump, lumpcache[lump]);
  496.     }
  497.     else
  498.     {
  499.     /* printf ("cache hit on lump %i\n",lump); */
  500.     Z_ChangeTag (lumpcache[lump],tag);
  501.     }
  502.     
  503.     return lumpcache[lump];
  504. }
  505.  
  506.  
  507.  
  508. /*  */
  509. /*  W_CacheLumpName */
  510. /*  */
  511. void*
  512. W_CacheLumpName
  513. ( char*        name,
  514.   int        tag )
  515. {
  516.     return W_CacheLumpNum (W_GetNumForName(name), tag);
  517. }
  518.  
  519. void *W_CacheLumpNumPadded
  520. ( int        lump,
  521.   int        tag,
  522.   int paddedsize )
  523. {
  524.     byte*    ptr;
  525.  
  526.     if ((unsigned)lump >= numlumps)
  527.     I_Error ("W_CacheLumpNum: %i >= numlumps",lump);
  528.         
  529.     if (!lumpcache[lump])
  530.     {
  531.     /*  read the lump in */
  532.     
  533.     /* printf ("cache miss on lump %i\n",lump); */
  534. /*
  535.     ptr = Z_Malloc (W_LumpLength (lump), tag, &lumpcache[lump]);
  536. */
  537.     ptr = Z_Malloc (paddedsize, tag, &lumpcache[lump]);
  538.     W_ReadLump (lump, lumpcache[lump]);
  539.     }
  540.     else
  541.     {
  542.     /* printf ("cache hit on lump %i\n",lump); */
  543.     Z_ChangeTag (lumpcache[lump],tag);
  544.     }
  545.     
  546.     return lumpcache[lump];
  547. }
  548.  
  549. /*  */
  550. /*  W_Profile */
  551. /*  */
  552. int        info[2500][10];
  553. int        profilecount;
  554.  
  555. void W_Profile (void)
  556. {
  557.     int        i;
  558.     memblock_t*    block;
  559.     void*    ptr;
  560.     char    ch;
  561.     FILE*    f;
  562.     int        j;
  563.     char    name[9];
  564.     
  565.     
  566.     for (i=0 ; i<numlumps ; i++)
  567.     {    
  568.     ptr = lumpcache[i];
  569.     if (!ptr)
  570.     {
  571.         ch = ' ';
  572.         continue;
  573.     }
  574.     else
  575.     {
  576.         block = (memblock_t *) ( (byte *)ptr - sizeof(memblock_t));
  577.         if (block->tag < PU_PURGELEVEL)
  578.         ch = 'S';
  579.         else
  580.         ch = 'P';
  581.     }
  582.     info[i][profilecount] = ch;
  583.     }
  584.     profilecount++;
  585.     
  586.     f = fopen ("waddump.txt","w");
  587.     name[8] = 0;
  588.  
  589.     for (i=0 ; i<numlumps ; i++)
  590.     {
  591.     memcpy (name,lumpinfo[i].name,8);
  592.  
  593.     for (j=0 ; j<8 ; j++)
  594.         if (!name[j])
  595.         break;
  596.  
  597.     for ( ; j<8 ; j++)
  598.         name[j] = ' ';
  599.  
  600.     fprintf (f,"%s ",name);
  601.  
  602.     for (j=0 ; j<profilecount ; j++)
  603.         fprintf (f,"    %c",info[i][j]);
  604.  
  605.     fprintf (f,"\n");
  606.     }
  607.     fclose (f);
  608. }
  609.  
  610.  
  611.