[BACK]Return to textfile.c CVS log [TXT] [DIR] Up to [RetroPC.NET] / np2 / common

Diff for /np2/common/textfile.c between versions 1.2 and 1.7

version 1.2, 2003/11/07 18:31:24 version 1.7, 2005/03/20 06:09:16
Line 1 Line 1
 #include        "compiler.h"  #include        "compiler.h"
   #include        "strres.h"
 #include        "dosio.h"  #include        "dosio.h"
 #include        "textfile.h"  #include        "textfile.h"
   
   
 TEXTFILEH textfile_open(const char *filename, UINT buffersize) {  enum {
           TFMODE_READ             = 0x01,
         FILEH           fh;          TFMODE_WRITE    = 0x02
         TEXTFILEH       ret;  };
   
   typedef struct {
           UINT8   mode;
           UINT8   access;
           UINT8   srcwidth;
           UINT8   xendian;
           FILEH   fh;
           long    fpos;
           void    *buf;
           UINT    bufsize;
           UINT    bufpos;
           UINT    bufrem;
   } _TEXTFILE, *TEXTFILE;
   
   
   static TEXTFILEH registfile(FILEH fh, UINT buffersize,
                                                                                           const UINT8 *hdr, UINT hdrsize) {
   
           long            fpos;
           UINT8           srcwidth;
           UINT8           xendian;
           TEXTFILE        ret;
   
           buffersize = buffersize & (~3);
         if (buffersize < 256) {          if (buffersize < 256) {
                 buffersize = 256;                  buffersize = 256;
         }          }
         fh = file_open(filename);          fpos = 0;
         if (fh != FILEH_INVALID) {          srcwidth = 1;
                 ret = (TEXTFILEH)_MALLOC(sizeof(_TEXTFILE) + buffersize, filename);          xendian = FALSE;
                 if (ret) {          if ((hdrsize >= 3) &&
                         ZeroMemory(ret, sizeof(_TEXTFILE) + buffersize);                  (hdr[0] == 0xef) && (hdr[1] == 0xbb) && (hdr[2] == 0xbf)) {
                         ret->fh = (long)fh;                  // UTF-8
                         ret->buffersize = buffersize;                  fpos = 3;
                         return(ret);  
                 }  
                 file_close(fh);  
         }          }
         return(NULL);          else if ((hdrsize >= 2) && (hdr[0] == 0xff) && (hdr[1] == 0xfe)) {
 }                  // UCSLE
                   fpos = 2;
                   srcwidth = 2;
   #if defined(BYTESEX_BIG)
                   xendian = TRUE;
   #endif
           }
           else if ((hdrsize >= 2) && (hdr[0] == 0xfe) && (hdr[1] == 0xff)) {
                   // UCS2BE
                   fpos = 2;
                   srcwidth = 2;
   #if defined(BYTESEX_LITTLE)
                   xendian = TRUE;
   #endif
           }
   
           if (srcwidth != sizeof(OEMCHAR)) {
                   return(NULL);
           }
           buffersize = buffersize * sizeof(OEMCHAR);
   
           ret = (TEXTFILE)_MALLOC(sizeof(_TEXTFILE) + buffersize, "TEXTFILE");
           if (ret == NULL) {
                   return(NULL);
           }
           ZeroMemory(ret, sizeof(_TEXTFILE));
   //      ret->mode = 0;
           ret->srcwidth = srcwidth;
           ret->xendian = xendian;
           ret->fh = fh;
           ret->fpos = fpos;
           ret->buf = (UINT8 *)(ret + 1);
           ret->bufsize = buffersize;
           return((TEXTFILEH)ret);
   }
   
 void textfile_close(TEXTFILEH fh) {  static BRESULT flushfile(TEXTFILE tf) {
   
         if (fh) {          if (tf->mode & TFMODE_READ) {
                 file_close((FILEH)fh->fh);                  tf->fpos -= tf->bufrem * tf->srcwidth;
                 _MFREE(fh);          }
           tf->mode = 0;
           tf->bufpos = 0;
           tf->bufrem = 0;
           if (file_seek(tf->fh, tf->fpos, FSEEK_SET) == tf->fpos) {
                   return(SUCCESS);
           }
           else {
                   return(FAILURE);
         }          }
 }  }
   
   
 static BOOL getnextstring(TEXTFILEH fh) {  // ---- A
   
   static UINT fillbufferA(TEXTFILE tf) {
   
         UINT    rsize;          UINT    rsize;
   
         if (!fh) {          if (tf->bufrem == 0) {
                 return(FAILURE);                  rsize = file_read(tf->fh, tf->buf, tf->bufsize);
                   rsize = rsize / sizeof(char);
                   tf->fpos += rsize * sizeof(char);
                   tf->bufpos = 0;
                   tf->bufrem = rsize;
         }          }
         if (file_seek((FILEH)fh->fh, fh->fhpos, 0) != fh->fhpos) {          return(tf->bufrem);
                 return(FAILURE);  }
   
   static BRESULT readlineA(TEXTFILE tf, void *buffer, UINT size) {
   
           char    *dst;
           BOOL    crlf;
           BRESULT ret;
           char    c;
   const char      *src;
           UINT    pos;
   
           if (size == 0) {
                   dst = NULL;
                   size = 0;
         }          }
         rsize = file_read((FILEH)fh->fh, fh + 1, fh->buffersize);          else {
         if (rsize == (UINT)-1) {                  dst = (char *)buffer;
                 return(FAILURE);                  size--;
         }          }
         fh->fhpos += rsize;  
         fh->pos = 0;          crlf = FALSE;
         fh->remain = rsize;          ret = FAILURE;
         return(SUCCESS);          c = 0;
           do {
                   if (fillbufferA(tf) == 0) {
                           break;
                   }
                   ret = SUCCESS;
                   src = (char *)tf->buf;
                   src += tf->bufpos;
                   pos = 0;
                   while(pos<tf->bufrem) {
                           c = src[pos];
                           pos++;
                           if ((c == 0x0d) || (c == 0x0a)) {
                                   crlf = TRUE;
                                   break;
                           }
                           if (size) {
                                   size--;
                                   *dst++ = c;
                           }
                   }
                   tf->bufpos += pos;
                   tf->bufrem -= pos;
           } while(!crlf);
           if ((crlf) && (c == 0x0d)) {
                   if (fillbufferA(tf) != 0) {
                           src = (char *)tf->buf;
                           src += tf->bufpos;
                           if (*src == 0x0a) {
                                   tf->bufpos++;
                                   tf->bufrem--;
                           }
                   }
           }
           if (dst) {
                   *dst = '\0';
           }
           return(ret);
 }  }
   
   
 BOOL textfile_read(TEXTFILEH fh, char *buffer, UINT size) {  // ---- W
   
         char    c = '\0';  static UINT fillbufferW(TEXTFILE tf) {
         char    *p;  
         BOOL    crlf;  
         BOOL    ret = FAILURE;  
   
         if ((fh) && (size > 0)) {          UINT    rsize;
                 size--;          UINT8   *buf;
                 crlf = FALSE;          UINT8   tmp;
                 do {  
                         if ((!fh->remain) && (getnextstring(fh))) {          if (tf->bufrem == 0) {
                                 return(FAILURE);                  buf = tf->buf;
                   rsize = file_read(tf->fh, buf, tf->bufsize);
                   rsize = rsize / sizeof(UINT16);
                   tf->fpos += rsize * sizeof(UINT16);
                   tf->bufpos = 0;
                   tf->bufrem = rsize;
                   if (tf->xendian) {
                           while(rsize) {
                                   tmp = buf[0];
                                   buf[0] = buf[1];
                                   buf[1] = tmp;
                                   buf += 2;
                                   rsize--;
                         }                          }
                         if (!fh->remain) {                  }
           }
           return(tf->bufrem);
   }
   
   static BRESULT readlineW(TEXTFILE tf, void *buffer, UINT size) {
   
           UINT16          *dst;
           BOOL            crlf;
           BRESULT         ret;
           UINT16          c;
   const UINT16    *src;
           UINT            pos;
   
           if (size == 0) {
                   dst = NULL;
                   size = 0;
           }
           else {
                   dst = (UINT16 *)buffer;
                   size--;
           }
           crlf = FALSE;
           ret = FAILURE;
           c = 0;
           do {
                   if (fillbufferW(tf) == 0) {
                           break;
                   }
                   ret = SUCCESS;
                   src = (UINT16 *)tf->buf;
                   src += tf->bufpos;
                   pos = 0;
                   while(pos<tf->bufrem) {
                           c = src[pos];
                           pos++;
                           if ((c == 0x0d) || (c == 0x0a)) {
                                   crlf = TRUE;
                                 break;                                  break;
                         }                          }
                         ret = SUCCESS;                          if (size) {
                         p = (char *)(fh + 1);  
                         p += fh->pos;  
                         while((fh->remain) && (size)) {  
                                 c = *p++;  
                                 fh->pos++;  
                                 fh->remain--;  
                                 if ((c == 0x0d) || (c == 0x0a)) {  
                                         crlf = TRUE;  
                                         break;  
                                 }  
                                 *buffer++ = c;  
                                 size--;                                  size--;
                                   *dst++ = c;
                         }                          }
                         if (!crlf) {                  }
                                 while((fh->remain) && (size)) {                  tf->bufpos += pos;
                                         c = *p++;                  tf->bufrem -= pos;
                                         fh->pos++;          } while(!crlf);
                                         fh->remain--;          if ((crlf) && (c == 0x0d)) {
                                         if ((c == 0x0d) || (c == 0x0a)) {                  if (fillbufferW(tf) != 0) {
                                                 crlf = TRUE;                          src = (UINT16 *)tf->buf;
                                                 break;                          src += tf->bufpos;
                                         }                          if (*src == 0x0a) {
                                 }                                  tf->bufpos++;
                         }                                  tf->bufrem--;
                 } while(!crlf);  
                 if ((crlf) && (c == 0x0d)) {  
                         if ((!fh->remain) && (getnextstring(fh))) {  
                                 return(FAILURE);  
                         }  
                         if (fh->remain) {  
                                 p = (char *)(fh + 1);  
                                 p += fh->pos;  
                                 if (*p == 0x0a) {  
                                         fh->pos++;  
                                         fh->remain--;  
                                 }  
                         }                          }
                 }                  }
                 *buffer = '\0';          }
           if (dst) {
                   *dst = '\0';
         }          }
         return(ret);          return(ret);
 }  }
   
   
   // ----
   
   TEXTFILEH textfile_open(const OEMCHAR *filename, UINT buffersize) {
   
           FILEH           fh;
           UINT8           hdr[4];
           UINT            hdrsize;
           TEXTFILEH       ret;
   
           fh = file_open_rb(filename);
           if (fh == FILEH_INVALID) {
                   goto tfo_err;
           }
           hdrsize = file_read(fh, hdr, sizeof(hdr));
           ret = registfile(fh, buffersize, hdr, hdrsize);
           if (ret) {
                   return(ret);
           }
           file_close(fh);
   
   tfo_err:
           return(NULL);
   }
   
   TEXTFILEH textfile_create(const OEMCHAR *filename, UINT buffersize) {
   
           FILEH           fh;
   const UINT8             *hdr;
           UINT            hdrsize;
           TEXTFILEH       ret;
   
           fh = file_create(filename);
           if (fh == FILEH_INVALID) {
                   goto tfc_err1;
           }
   #if defined(OSLANG_UTF8)
           hdr = str_utf8;
           hdrsize = sizeof(str_utf8);
   #elif defined(OSLANG_UCS2) 
           hdr = (UINT8 *)str_ucs2;
           hdrsize = sizeof(str_ucs2);
   #else
           hdr = NULL;
           hdrsize = 0;
   #endif
           if ((hdrsize) && (file_write(fh, hdr, hdrsize) != hdrsize)) {
                   goto tfc_err2;
           }
           ret = registfile(fh, buffersize, hdr, hdrsize);
           if (ret) {
                   return(ret);
           }
   
   tfc_err2:
           file_close(fh);
   
   tfc_err1:
           return(NULL);
   }
   
   BRESULT textfile_read(TEXTFILEH tfh, OEMCHAR *buffer, UINT size) {
   
           TEXTFILE        tf;
   
           tf = (TEXTFILE)tfh;
           if (tf) {
                   if (!(tf->mode & TFMODE_READ)) {
                           flushfile(tf);
                           tf->mode = TFMODE_READ;
                   }
                   if (sizeof(OEMCHAR) == 1) {
                           return(readlineA(tf, buffer, size));
                   }
                   else if (sizeof(OEMCHAR) == 2) {
                           return(readlineW(tf, buffer, size));
                   }
           }
           return(FAILURE);
   }
   
   BRESULT textfile_write(TEXTFILEH tfh, const OEMCHAR *buffer) {
   
           TEXTFILE        tf;
           UINT            leng;
           UINT            wsize;
   
           tf = (TEXTFILE)tfh;
           if (tf) {
                   if (!(tf->mode & TFMODE_WRITE)) {
                           flushfile(tf);
                           tf->mode = TFMODE_WRITE;
                   }
                   leng = OEMSTRLEN(buffer);
                   leng = leng * sizeof(OEMCHAR);
                   wsize = file_write(tf->fh, buffer, leng);
                   tf->fpos += wsize;
                   if (wsize == leng) {
                           return(SUCCESS);
                   }
           }
           return(FAILURE);
   }
   
   void textfile_close(TEXTFILEH tfh) {
   
           if (tfh) {
                   file_close(((TEXTFILE)tfh)->fh);
                   _MFREE(tfh);
           }
   }
   
Removed from v.1.2  
changed lines
  Added in v.1.7

RetroPC.NET-CVS <cvs@retropc.net>