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