[BACK]Return to file2.c CVS log [TXT][DIR] Up to [local] / OpenXM / src / kan96xx / plugin

Diff for /OpenXM/src/kan96xx/plugin/file2.c between version 1.1 and 1.10

version 1.1, 1999/10/08 02:12:05 version 1.10, 2004/02/25 23:14:35
Line 1 
Line 1 
   /*$OpenXM: OpenXM/src/kan96xx/plugin/file2.c,v 1.9 2004/02/23 09:03:43 takayama Exp $ */
 #include <stdio.h>  #include <stdio.h>
 #include <sys/time.h>  #include <sys/time.h>
 #include <sys/types.h>  #include <sys/types.h>
 #include <unistd.h>  #include <unistd.h>
   #include <errno.h>
 #include "file2.h"  #include "file2.h"
   
   /* If you use file2 standalone to output string,
       make the following dummy definition;
   int KsocketSelect0(int a,int b) { return(0); }
   int oxSocketSelect0(int a,int b) { return(0); }
   or define FORSTRING
   */
   #ifdef  FORSTRING
   #define KsocketSelect0(a,b) 0
   #define oxSocketSelect0(a,b) 0
   #endif
   
 #ifdef KXX  #ifdef KXX
 #define GC_malloc(n) malloc(n)  #define sGC_malloc(n) malloc(n)
 #else  #else
 void *GC_malloc(int size);  void *sGC_malloc(int size);
 #endif  #endif
   int WatchStream = 0;
 /*  Note:  1997, 12/6   cf. SS475/kxx/openxxx.tex, SS475/memo1.txt  /*  Note:  1997, 12/6   cf. SS475/kxx/openxxx.tex, SS475/memo1.txt
     The functions in file2.c should not accept interruptions      The functions in file2.c should not accept interruptions
     during its critical operations.  The synchronization mechanism      during its critical operations.  The synchronization mechanism
Line 18  void *GC_malloc(int size);
Line 31  void *GC_malloc(int size);
   
 static int debug1 = 0;  static int debug1 = 0;
 static int checkfp2(FILE2 *fp2,char *s);  static int checkfp2(FILE2 *fp2,char *s);
   static int fp2fputcString(int c,FILE2 *fp2);
 static int checkfp2(FILE2 *fp2,char *s)  static int checkfp2(FILE2 *fp2,char *s)
 {  {
   if (fp2 == NULL) {    if (fp2 == NULL) {
Line 36  FILE2 *fp2open(int fd) {
Line 50  FILE2 *fp2open(int fd) {
   if (debug1) {    if (debug1) {
     printf("fp2open is called. \n");      printf("fp2open is called. \n");
   }    }
   fp2 = (FILE2 *) GC_malloc(sizeof(FILE2));    fp2 = (FILE2 *) sGC_malloc(sizeof(FILE2));
   if (fd < 0) {    if (fd < -1) {
     fprintf(stderr,"fp2open  Invalid file descriptor %d\n",fd);      fprintf(stderr,"fp2open  Invalid file descriptor %d\n",fd);
     return(NULL);      return(NULL);
   }    }
     /* fd == -1 ==> store in string. */
   if (fp2 == NULL) {    if (fp2 == NULL) {
     fprintf(stderr,"fp2open.  No memory.\n");      fprintf(stderr,"fp2open.  No memory.\n");
     return(NULL);      return(NULL);
Line 52  FILE2 *fp2open(int fd) {
Line 67  FILE2 *fp2open(int fd) {
   fp2->readsize = 0;    fp2->readsize = 0;
   fp2->writepos = 0;    fp2->writepos = 0;
   fp2->limit = FILE2BSIZE;    fp2->limit = FILE2BSIZE;
     fp2->readBuf = (char *) sGC_malloc(FILE2BSIZE);
     fp2->writeBuf = (char *) sGC_malloc(FILE2BSIZE);
     if ((fp2->readBuf == NULL) || (fp2->writeBuf == NULL)) {
           fprintf(stderr,"fp2open. No more memory.\n");
           return(NULL);
     }
   fp2->watch = 0;    fp2->watch = 0;
   fp2->watchFile = NULL;    fp2->watchFile = NULL;
   fp2->mathcapList = NULL;    fp2->mathcapList = NULL;
     fp2->log_incomming = NULL;
     fp2->log_outgoing = NULL;
   return(fp2);    return(fp2);
 }  }
   
Line 67  int fp2fflush(FILE2 *fp2) {
Line 90  int fp2fflush(FILE2 *fp2) {
     printf("--------------------------\n");      printf("--------------------------\n");
   }    }
   if (checkfp2(fp2,"fp2fflush ") == -1) return(-1);    if (checkfp2(fp2,"fp2fflush ") == -1) return(-1);
     if (fp2->fd == -1) return(0);
   if (fp2->writepos > 0) {    if (fp2->writepos > 0) {
     r = write(fp2->fd,fp2->writeBuf,fp2->writepos);      r = write(fp2->fd,fp2->writeBuf,fp2->writepos);
     fp2->writepos = 0;      fp2->writepos = 0;
Line 82  int fp2fflush(FILE2 *fp2) {
Line 106  int fp2fflush(FILE2 *fp2) {
 int fp2fclose(FILE2 *fp2) {  int fp2fclose(FILE2 *fp2) {
   int r;    int r;
   if (checkfp2(fp2," fp2fclose ") == -1) return(-1);    if (checkfp2(fp2," fp2fclose ") == -1) return(-1);
     if (fp2->fd == -1) return(0);
   r = fp2fflush(fp2);    r = fp2fflush(fp2);
   if (r < 0) {    if (r < 0) {
     fprintf(stderr,"fp2fclose: flush error.\n");      fprintf(stderr,"fp2fclose: flush error.\n");
Line 91  int fp2fclose(FILE2 *fp2) {
Line 116  int fp2fclose(FILE2 *fp2) {
 }  }
   
 int fp2fputc(int c,FILE2 *fp2) {  int fp2fputc(int c,FILE2 *fp2) {
     FILE *fp;
   if (debug1) {    if (debug1) {
     printf("fp2fputc is called with %2x, fp2->writepos=%d, ",c,fp2->writepos);      printf("fp2fputc is called with %2x, fp2->writepos=%d, ",c,fp2->writepos);
     printf("fp2 = %x.\n",(int) fp2);      printf("fp2 = %x.\n",(int) fp2);
   }    }
   if (fp2->watch) {    if (fp2->watch || WatchStream) {
       if (fp2->watch) fp = fp2->watchFile;
       else fp = stderr;
           fprintf(stderr,"put to <%x> ",fp2->fd); /* output the channel for debug */
     if (c >= ' ' && c <='z') {      if (c >= ' ' && c <='z') {
       fprintf(fp2->watchFile," %2x(%c)-> ",c,c);        fprintf(fp," %2x(%c)-> ",c& 0xff,c);
     }else{      }else{
       fprintf(fp2->watchFile," %2x( )-> ",c);        fprintf(fp," %2x( )-> ",c& 0xff);
     }      }
     fflush(NULL);      fflush(NULL);
   }    }
     if (fp2->log_outgoing != NULL) fputc(c,fp2->log_outgoing);
   if (checkfp2(fp2," fp2fputc ") == -1) return(-1);    if (checkfp2(fp2," fp2fputc ") == -1) return(-1);
   (fp2->writeBuf)[fp2->writepos] = c;    (fp2->writeBuf)[fp2->writepos] = c;
   (fp2->writepos)++;    (fp2->writepos)++;
     if (fp2->fd == -1) return(fp2fputcString(c,fp2));
   if (fp2->writepos < fp2->limit) {    if (fp2->writepos < fp2->limit) {
     return(c);      return(c);
   }else{    }else{
Line 116  int fp2fputc(int c,FILE2 *fp2) {
Line 147  int fp2fputc(int c,FILE2 *fp2) {
   
 int fp2fgetc(FILE2 *fp2) {  int fp2fgetc(FILE2 *fp2) {
   int c;    int c;
     FILE *fp;
   /* printf("fp2fgetc is called. "); fflush(NULL); */    /* printf("fp2fgetc is called. "); fflush(NULL); */
   if (checkfp2(fp2," fp2fgetc ") == -1) return(-1);    if (checkfp2(fp2," fp2fgetc ") == -1) return(-1);
   if (fp2->readpos < fp2->readsize) {    if (fp2->readpos < fp2->readsize) {
     fp2->readpos++;      fp2->readpos++;
     c = fp2->readBuf[fp2->readpos -1];      c = fp2->readBuf[fp2->readpos -1];
     if (fp2->watch) {      if (fp2->watch || WatchStream) {
         if (fp2->watch) fp = fp2->watchFile;
         else fp = stderr;
         fprintf(fp,"get from <%x> ",fp2->fd); /* output the channel for debug*/
       if (c >= ' ' && c <= 'z') {        if (c >= ' ' && c <= 'z') {
         fprintf(fp2->watchFile," %2x(%c) ",c,c);          fprintf(fp," %2x(%c) ",c,c);
       }else{        }else{
         fprintf(fp2->watchFile," %2x( ) ",c);          fprintf(fp," %2x( ) ",c);
       }        }
       fflush(NULL);        fflush(NULL);
     }      }
       if (fp2->log_incomming != NULL) fputc(c,fp2->log_incomming);
     return(c);      return(c);
   }else{    }else{
           if (fp2->fd == -1) return(-1);
     fp2->readpos = 0;      fp2->readpos = 0;
     fp2 ->readsize =      fp2 ->readsize =
       read(fp2->fd, fp2->readBuf, fp2->limit);        read(fp2->fd, fp2->readBuf, fp2->limit);
     if (fp2->readsize == 0) {      if (fp2->readsize == 0) {
       if (fp2->watch) {        if (fp2->watch || WatchStream) {
         fprintf(fp2->watchFile," <%2x ",c);          if (fp2->watch) fp = fp2->watchFile;
         fflush(NULL);          else fp = stderr;
           fprintf(fp," <%2x ",c);
           fflush(NULL);
       }        }
       return(-1);        return(-1);
     }      }
Line 148  int fp2fgetc(FILE2 *fp2) {
Line 187  int fp2fgetc(FILE2 *fp2) {
 }  }
   
 int fp2select(FILE2 *fp2, int t) {  int fp2select(FILE2 *fp2, int t) {
     if (fp2->fd == -1) {
           if (fp2->readpos < fp2->readsize) return(1);
           else return(0);
     }
   if (fp2->readpos < fp2->readsize) return(1);    if (fp2->readpos < fp2->readsize) return(1);
   else {    else {
 #ifdef KXX  #ifdef KXX
Line 182  int fp2dumpBuffer(FILE2 *fp2) {
Line 225  int fp2dumpBuffer(FILE2 *fp2) {
 int fp2clearReadBuf(FILE2 *fp2) {  int fp2clearReadBuf(FILE2 *fp2) {
   fd_set readfds;    fd_set readfds;
   struct timeval timeout;    struct timeval timeout;
   extern int errno;  
   int fd;    int fd;
 #define TMP00SIZE  2000  #define TMP00SIZE  2000
   char tmp00[TMP00SIZE];    char tmp00[TMP00SIZE];
Line 191  int fp2clearReadBuf(FILE2 *fp2) {
Line 233  int fp2clearReadBuf(FILE2 *fp2) {
   if (checkfp2(fp2," fp2clearReadBuf ") == -1) {    if (checkfp2(fp2," fp2clearReadBuf ") == -1) {
     return(-1);      return(-1);
   }    }
     if (fp2->fd == -1) return(0);
   
   fp2->readsize=0; fp2->readpos = 0;  /* Clear the buffer. */    fp2->readsize=0; fp2->readpos = 0;  /* Clear the buffer. */
   
Line 208  int fp2clearReadBuf(FILE2 *fp2) {
Line 251  int fp2clearReadBuf(FILE2 *fp2) {
     if (FD_ISSET(fd,&readfds)) {      if (FD_ISSET(fd,&readfds)) {
       n = read(fd,tmp00, TMP00SIZE);        n = read(fd,tmp00, TMP00SIZE);
       if (n <=  0) {        if (n <=  0) {
         fprintf(stderr,"fp2clearReadBuf: File is closed or read error.\n");          fprintf(stderr,"fp2clearReadBuf: File is closed or read error.\n");
         return(-1);          return(-1);
       }        }
       if ( n < TMP00SIZE ) {        if ( n < TMP00SIZE ) {
         return(0);          return(0);
       }        }
     }else {      }else {
       return(0);        return(0);
Line 262  int fp2stopWatch(FILE2 *fp2)
Line 305  int fp2stopWatch(FILE2 *fp2)
   }    }
 }  }
   
   int fp2log(FILE2 *fp,FILE *incomming,FILE *outgoing) {
     fp->log_incomming = incomming;
     fp->log_outgoing = outgoing;
     return 0;
   }
   int fp2stopLog(FILE2 *fp) {
     if (fp->log_incomming != NULL) fclose(fp->log_incomming);
     if (fp->log_outgoing != NULL) fclose(fp->log_outgoing);
     fp->log_incomming = fp->log_outgoing = NULL;
     return 0;
   }
   
   static int fp2fputcString(int c,FILE2 *fp2) {
     unsigned char *newwrite,*newread;
     int newsize;
     int i;
     (fp2->readBuf)[fp2->readsize] = c;
     (fp2->readsize)++;
     if ((fp2->writepos < fp2->limit) && (fp2->readsize < fp2->limit)) return(c);
     if ((fp2->limit)*2 >=0x3000000) {
           fprintf(stderr,"Too big output string.\n");
           return(-1);
     }
     newsize = (fp2->limit)*2;
     newwrite = (char *)sGC_malloc(newsize);
     newread = (char *)sGC_malloc(newsize);
     if ((newwrite == NULL) || (newread == NULL)) {
           fprintf(stderr,"fp2fputcString: No more memory.\n");
           return(-1);
     }
     for (i=0; i<fp2->writepos; i++) {
           newwrite[i] = fp2->writeBuf[i];
     }
     for (i=0; i<fp2->readsize; i++) {
           newread[i] = fp2->readBuf[i];
     }
     fp2->writeBuf = newwrite;
     fp2->readBuf = newread;
     fp2->limit = newsize;
     return(c);
   }
   
   char *fp2fcloseInString(FILE2 *fp2, int *sizep)
   {
     if (fp2->fd == -1) {
           fp2fputc(0,fp2);
           *sizep = fp2->writepos-1;
           return(fp2->writeBuf);
     }else{
           fprintf(stderr,"fp2fcloseInString is called for a file stream that is not associated to a string.\n");
     }
   }
   
   int fp2fputs(char *s,FILE2 *fp) {
     int i,n;
     n = strlen(s);
     for (i=0; i<n; i++) {
           if (fp2fputc(s[i],fp) < 0) return(-1);
     }
     return(0);
   }
   
   /* Sample program  FORSTRING
    FILE2 *fp2;
    int c;
    char *s;
    int size;
    fp2 = fp2fopen(-1);
    while ((c = getchar()) != EOF) {
      fp2fputc(c,fp2);
    }
    s = fp2fcloseInString(fp2,&size);
   
    or
   
    while ((c = fp2fgetc(fp2)) != EOF) {
       ....
    }
   */
Legend:
Removed from v.1.1  
changed lines
  Added in v.1.10
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>