home *** CD-ROM | disk | FTP | other *** search
/ GEMini Atari / GEMini_Atari_CD-ROM_Walnut_Creek_December_1993.iso / files / program / funnel / mapper.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-10-23  |  17.0 KB  |  376 lines
  1. /*##############################################################################
  2.  
  3. FUNNNELWEB COPYRIGHT
  4. ====================
  5. FunnelWeb is a literate-programming macro preprocessor.
  6.  
  7. Copyright (C) 1992 Ross N. Williams.
  8.  
  9.    Ross N. Williams
  10.    ross@spam.adelaide.edu.au
  11.    16 Lerwick Avenue, Hazelwood Park 5066, Australia.
  12.  
  13. This program is free software; you can redistribute it and/or modify
  14. it under the terms of Version 2 of the GNU General Public License as
  15. published by the Free Software Foundation.
  16.  
  17. This program is distributed WITHOUT ANY WARRANTY; without even the implied
  18. warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  19. See Version 2 of the GNU General Public License for more details.
  20.  
  21. You should have received a copy of Version 2 of the GNU General Public
  22. License along with this program. If not, you can FTP the license from
  23. prep.ai.mit.edu/pub/gnu/COPYING-2 or write to the Free Software
  24. Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  25.  
  26. Section 2a of the license requires that all changes to this file be
  27. recorded prominently in this file. Please record all changes here.
  28.  
  29. Programmers:
  30.    RNW  Ross N. Williams  ross@spam.adelaide.edu.au
  31.  
  32. Changes:
  33.    07-May-1992  RNW  Program prepared for release under GNU GPL V2.
  34.  
  35. ##############################################################################*/
  36.  
  37.  
  38. /******************************************************************************/
  39. /*                                   MAPPER.C                                 */
  40. /******************************************************************************/
  41.  
  42. #include <limits.h>
  43. #include "style.h"
  44.  
  45. #include "as.h"
  46. #include "machin.h"
  47. #include "mapper.h"
  48. #include "memory.h"
  49.  
  50. /******************************************************************************/
  51.  
  52. /* When we allocate a block of memory for a mapped file, we have to allocate  */
  53. /* a little more than the official length of the file. Here are some reasons: */
  54. /*                                                                            */
  55. /*    - We may wish to append an EOF character later on in the program.       */
  56. /*    - fgets, when requested to fetch n characters, fetches n characters and */
  57. /*      then puts an EOS on the end of them.                                  */
  58. /*    - It is conceivable that fgets will insert a "\n" at the end of the     */
  59. /*      block if it doesn't see a "\n" just before the end of file.           */
  60. /*                                                                            */
  61. /* For all these reasons, we allocate a little more memory than we need. How  */
  62. /* much more is determined by BLK_FUDGE which is set to be on the safe side.  */
  63. #define BLK_FUDGE (20)
  64.  
  65. /* The following fudge is useful for avoiding the limits of types.            */
  66. #define LIM_FUDGE (10)
  67.  
  68. /* On PCs, size_t is 16 bits and malloc cannot allocate contiguous chunks of  */
  69. /* memory of more than about 64K. This really stuffs up FunnelWeb's capacity  */
  70. /* map in files of length greater than 64K. I didn't think of this problem    */
  71. /* when I designed FunnelWeb because I was thinking of the VOLUME of memory   */
  72. /* available nowadays, rather than its organization on small computers.       */
  73. /* Anyway, this problem should really be fixed by allowing files to be read   */
  74. /* in in segments. Perhaps the mapper should hand over a linked list of       */
  75. /* chunks rather than a single chunk. Unfortunately, I don't have the time to */
  76. /* do this now, so users of the PC version of FunnelWeb will have to be       */
  77. /* content with an (approx) 64K limit to input files. This isn't as bad as it */
  78. /* sounds, as large input files can be split using the include facility.      */
  79. /* 63K is chosen instead of 64K so as to be paranoid.                         */
  80. #define PCFILEMX  (63L*1024L)
  81.  
  82. /******************************************************************************/
  83. /*                                                                            */
  84. /* Error Strings                                                              */
  85. /* -------------                                                              */
  86. /* Routines in this package return pointers to error strings. These pointers  */
  87. /* are subsequently bandied about by other packages. Therefore, they must be  */
  88. /* pointers to constant strings. The trick of returning a pointer to a static */
  89. /* character array containing a specific sprintf message will backfire here   */
  90. /* if there is an error opening more than one input file. Using mm_* to       */
  91. /* create space for each error string would work though.                      */
  92. /* STOP PRESS: Now that the lister copies error messages, there may no longer */
  93. /* be a problem here.                                                         */
  94. /*                                                                            */
  95. /******************************************************************************/
  96.  
  97. /* Finding The Length of a File                                               */
  98. /* ----------------------------                                               */
  99. /* We have to be able to find out the length of a file before reading it in   */
  100. /* because, in this version of FunnelWeb, the entire file must be read into   */
  101. /* one contiguous block of memory.                                            */
  102. /*                                                                            */
  103. /* As it turns out, finding the length of a file in portable C turns out to   */
  104. /* be a very hard problem. Here are some possible solutions:                  */
  105. /*                                                                            */
  106. /*    1. Read the entire file in and see how long it is.                      */
  107. /*    2. Use fseek to move to the end of the file and then use ftell.         */
  108. /*    3. Use the Unix 'stat' call.                                            */
  109. /*                                                                            */
  110. /* Of these, only the first is portable. The second alternative is            */
  111. /* non-portable because some environments do not support the SEEK_END symbol  */
  112. /* required to perform a seek to the end of file.                             */
  113. /* Alternatives to needing the length are as follows:                         */
  114. /*                                                                            */
  115. /*    4. Read the file/allocate memory in 64K blocks.                         */
  116. /*    5. Read the file in 64K blocks and then copy them to a contiguous one.  */
  117. /*                                                                            */
  118. /* Perhaps options 4 or 5 could be implemented later. However, right now I    */
  119. /* haven't got the time to do anything except strive for portability, so      */
  120. /* option 1 it is.                                                            */
  121.  
  122. LOCAL char *file_len P_((char *,ulong *));
  123. LOCAL char *file_len (p_name,p_length)
  124. /* Given a filename (in 'p_name'), returns the length of the binary image of  */
  125. /* the file in *p_length. Returns NULL upon success or a pointer to a string  */
  126. /* describing an error upon failure. The length is measured in bytes.         */
  127. char  *p_name;
  128. ulong *p_length;
  129. {
  130.  FILE *infile;
  131.  STAVAR char *p_buf = NULL;
  132.  
  133. /* The length of the buffer handed to fgets is non-critical. However, it      */
  134. /* mustn't be bigger than 15 bits, as we are passing it as an int to fgets.   */
  135. #define LENBUFLEN (1024L)
  136. #if LENBUFLEN > 30000L
  137.    #error "mapper.c: LENBUFLEN must be less than 15 bits."
  138. #endif
  139.  
  140.  /* Allocate the buffer if it has not already been allocated. */
  141.  if (p_buf == NULL)
  142.     p_buf=mm_perm((size_t) LENBUFLEN);
  143.  
  144.  /* Open for TEXT reading. Earlier, I tried this using a binary read, but     */
  145.  /* I had problems with this on the VAX (I forget what the problems were) and */
  146.  /* so I have switched back to a text read which is slower, but more reliable.*/
  147.  infile=fopen(p_name,"r");
  148.  if (infile == FOPEN_F)
  149.     return "Error fopen()ing input file (to determine its length).";
  150.  
  151.  /* Start with a zero length. */
  152.  *p_length=0;
  153.  
  154.  /* Read the file as text and count the number of bytes it contains. */
  155.  while (!feof(infile))
  156.    {
  157.     /* Set the buffer to the empty string so it is valid even if fgets fails. */
  158.     p_buf[0]=EOS;
  159.     
  160.     /* Read in a whole lot of bytes. */
  161.     fgets(p_buf,LENBUFLEN,infile);
  162.     
  163.     /* If there is an error, abort. */
  164.     if (ferror(infile))
  165.       {
  166.        fclose(infile);
  167.        return "Error fgets()ing input file (as part of determining its length).";
  168.       }
  169.       
  170.     /* Count the bytes that we have got. If EOF occurred above AND no bytes   */
  171.     /* were read, the EOS we planted earlier saves us.                        */
  172.     (*p_length)+=strlen(p_buf);
  173.    }
  174.  
  175.  if (fclose(infile) == FCLOSE_F)
  176.     return "Error fclose()ing input file (as part of determining its length).";
  177.  
  178.  return NULL;
  179. }
  180.  
  181. /******************************************************************************/
  182.  
  183. #if PC & UNIX_EOL
  184.    #error Attempt to use unix_map function on a PC!
  185. #endif
  186.  
  187. #if UNIX_EOL
  188. LOCAL char *unix_map P_((char *,char **,ulong *));
  189. LOCAL char *unix_map(p_name,pp_mem,p_length)
  190. /* If we know that the enclosing environment represents text files in UNIX    */
  191. /* form, then there is no need to process the file on the way in. All we need */
  192. /* to do is map it directly into memory. This will be very fast.              */
  193. char   *p_name;
  194. char  **pp_mem;
  195. ulong  *p_length;
  196. {
  197.  ulong  file_length;  /* Number of bytes in the target input file.            */
  198.  char  *p_err;        /* Temporary to store pointer to error message.         */
  199.  FILE  *infile;       /* The file variable for the input file we are reading. */
  200.  ulong  num_bytes;    /* Number of bytes actually read in (may be different). */
  201.  char  *p_bytes;      /* Pointer to the memory block where all the action is. */
  202.  
  203.  /* Obtain the length of the file we are about to map in. */
  204.  p_err=file_len(p_name,&file_length);
  205.  if (p_err != NULL)
  206.     return p_err;
  207.  
  208.  /* Allocate memory to hold the mapped file.                                  */
  209.  /* Note: The memory allocation package bombs if there is no more memory.     */
  210.  p_bytes=(char *) mm_temp((size_t) file_length+BLK_FUDGE);
  211.  
  212.  /* Open the file in BINARY mode. */
  213.  infile=fopen(p_name,"rb");
  214.  if (infile==FOPEN_F)
  215.     return "Error fopen()ing the input file (binary open).";
  216.  
  217.  /* Read in the file and complain if we haven't read in enough bytes. */
  218.  num_bytes=fread(p_bytes,(size_t) 1L,(size_t) file_length,infile);
  219.  if (num_bytes != file_length)
  220.     return "Error fread()ing the input file.";
  221.  
  222.  if (fclose(infile) == FCLOSE_F)
  223.     return "Error fclose()ing the input file.";
  224.  
  225.  /* Success. We got through the IO calls. Now fill in the blanks and go home. */
  226.  *pp_mem   =p_bytes;
  227.  *p_length =num_bytes;
  228.  return NULL;
  229. }
  230. #endif
  231.  
  232. /******************************************************************************/
  233.  
  234. #if !UNIX_EOL
  235. LOCAL char *stan_map P_((char *,char **,ulong *));
  236. LOCAL char *stan_map(p_name,pp_mem,p_length)
  237. /* Maps in a file using refined text stream IO calls. */
  238. char   *p_name;
  239. char  **pp_mem;
  240. ulong  *p_length;
  241. {
  242.  ulong  file_length;  /* Number of bytes in the target input file.            */
  243.  char  *p_err;        /* Temporary to store pointer to error message.         */
  244.  FILE  *infile;       /* The file variable for the input file we are reading. */
  245.  ulong  num_bytes;    /* Number of bytes actually read in (may be different). */
  246.  char  *p_bytes;      /* Pointer to the memory block where all the action is. */
  247.  char  *p_curr;       /* Pointer to current position in memory block.         */
  248.  long  bytes_left;    /* Number of bytes still left to read.                  */
  249.  
  250.  /* Obtain the length of the file we are about to map in. */
  251.  p_err=file_len(p_name,&file_length);
  252.  if (p_err != NULL)
  253.     return p_err;
  254.  
  255.  /* Complain on the PC if the file is too big to fit in one 64K segment. */
  256. #if PC
  257.  if (file_length+BLK_FUDGE > PCFILEMX)
  258.     return
  259.       "Error: Input file too big for PC FunnelWeb. Split using include files.";
  260. #endif
  261.  
  262.  /* TRACE printf("MAPPER: LENGTH OF INPUT FILE=%lu\n",file_length); */
  263.  
  264.  /* Allocate memory to hold the mapped file.                                  */
  265.  /* Note: The memory allocation package bombs if there is no more memory.     */
  266.  /* Note: As Unix stream format (the format to which we are converting) uses  */
  267.  /*       just one byte to mark the end of file, it seems highly unlikely     */
  268.  /*       that the file read in will be longer than the binary image.         */
  269.  p_bytes=(char *) mm_temp((size_t) file_length+BLK_FUDGE);
  270.  
  271.  /* If the file is of zero length, we already know its contents!              */
  272.  /* This is probably not strictly necessary, but why pressure the code below? */
  273.  if (file_length==0)
  274.    {
  275.     *pp_mem   = p_bytes;
  276.     *p_length = 0;
  277.     return NULL;
  278.    }
  279.  
  280.  /* Open the file afresh in TEXT mode for portable reading. */
  281.  infile=fopen(p_name,"r");
  282.  if (infile==FOPEN_F)
  283.     return "Error fopen()ing input file (for reading).";
  284.  
  285.  /* Read in as much of the file as we can without actually overflowing the    */
  286.  /* buffer. If the file finished before the buffer, things have probably gone */
  287.  /* OK. If the buffer finishes before the file, we have a problem.            */
  288.  /* Note: bytes_left = file_length+1 because in the following loop, we might  */
  289.  /* read exactly up to the EOF and then be unable to actually trigger the EOF */
  290.  /* condition without another read. So we add one on to allow this extra read */
  291.  /* to take place. I don't know if this is necessary, but I certainly can't   */
  292.  /* find anything in all my C books that will tell me. Anyway, it doesn't     */
  293.  /* matter because we fudged in a few extra bytes earlier.                    */
  294.  
  295.  p_curr     = p_bytes;        /* p_curr runs through the memory.              */
  296.  bytes_left = file_length+1;  /* Bytes left in memory allocated to hold file. */
  297.  
  298.  while (!feof(infile))
  299.    {
  300.     int bytes_try;
  301.     int bytes_read;
  302.     
  303.     /* Try to read as much as we possibly can, but not more than the integer  */
  304.     /* limit (which can be as low as 15 bits).                                */
  305.     bytes_try = bytes_left >= ((ulong) (INT_MAX-LIM_FUDGE)) ?
  306.                   (int) INT_MAX-LIM_FUDGE : (int) bytes_left;
  307.     
  308.     /* Plan an EOS to cover the EOF case. */
  309.     *p_curr=EOS;
  310.     
  311.     /* Attempt to read bytes_try bytes. +1 is because fgets reads n-1 bytes.  */
  312.     fgets(p_curr,bytes_try+1,infile);
  313.     if (ferror(infile))
  314.       {
  315.        fclose(infile);
  316.        return "Error fgets()ing the input file.";
  317.       }
  318.       
  319.     /* fgets doesn't return a length so we have to hobble behind with strlen. */
  320.     /* It's still probably better than using lots of fgetc calls.             */
  321.     /* If we hit EOF and no bytes were read, the EOS we planted saves us.     */
  322.     bytes_read  = strlen(p_curr);
  323.     p_curr     += bytes_read;
  324.     bytes_left -= bytes_read;
  325.  
  326.     /* If we have run out of bytes in our allocated memory zone, then the     */
  327.     /* file is longer than the length reported earlier. This is a bad thing.  */
  328.     as_cold(bytes_left >=0,
  329.             "stan_map: Text representation was longer than binary rep.");
  330.    }
  331.    
  332.  num_bytes=(file_length+1)-bytes_left; /* See earlier to undserstand +1.      */
  333.  
  334.  /* Note: We can't get fussy here and check the read in length with the       */
  335.  /* official length, as the read-in length is the text representation which   */
  336.  /* is allowed to be shorter than the physical (binary) length of the file.   */
  337.  
  338.  if (fclose(infile) == FCLOSE_F)
  339.     return "Error fclose()ing input file.";
  340.  
  341.  /* Success. We got through the IO calls. Now fill in the blanks and go home. */
  342.  *pp_mem   = p_bytes;
  343.  *p_length = num_bytes;
  344.  return NULL;
  345. }
  346. #endif
  347.  
  348. /******************************************************************************/
  349.  
  350. EXPORT char *map_file(p_name,pp_mem,p_length)
  351. char   *p_name;
  352. char  **pp_mem;
  353. ulong  *p_length;
  354. {
  355.  /* We choose one of two mapper routines depending on where the operating     */
  356.  /* system represents text files using EOL (\n) as end of line markers.       */
  357.  /* The UNIX_EOL symbol is defined in the machin.h file.                      */
  358.  /* Note: I thought of using sprintf to test to see what "\n" translated into */
  359.  /* so I wouldn't need the UNIXEOL symbol. However, unlike printf (which it   */
  360.  /* is supposed to be like), sprintf does not translate "\n" into its outside */
  361.  /* form. The only other alternative is writing a short text file and reading */
  362.  /* it back in binary - an action that would probably take longer than        */
  363.  /* reading the original file to be read using fgetc()!                       */
  364.  
  365. #if UNIX_EOL
  366.    return unix_map(p_name,pp_mem,p_length);
  367. #else
  368.    return stan_map(p_name,pp_mem,p_length);
  369. #endif
  370. }
  371.  
  372. /******************************************************************************/
  373. /*                               End of MAPPER.C                              */
  374. /******************************************************************************/
  375.  
  376.