[BACK]Return to io_win_mini.c CVS log [TXT][DIR] Up to [local] / OpenXM_contrib2 / asir2000 / io

Diff for /OpenXM_contrib2/asir2000/io/io_win_mini.c between version 1.3 and 1.4

version 1.3, 2006/12/05 01:47:08 version 1.4, 2018/03/29 01:32:53
Line 1 
Line 1 
 /* $OpenXM: OpenXM_contrib2/asir2000/io/io_win_mini.c,v 1.2 2006/09/29 09:02:49 noro Exp $ */  /* $OpenXM: OpenXM_contrib2/asir2000/io/io_win_mini.c,v 1.3 2006/12/05 01:47:08 noro Exp $ */
   
 #include "ca.h"  #include "ca.h"
 #include "parse.h"  #include "parse.h"
Line 30  int little_endian=1;
Line 30  int little_endian=1;
 int terminate;  int terminate;
   
 static int available_cmo[] = {  static int available_cmo[] = {
         CMO_NULL, CMO_INT32, CMO_STRING,CMO_LIST,    CMO_NULL, CMO_INT32, CMO_STRING,CMO_LIST,
         CMO_ERROR, CMO_ERROR2, CMO_ZERO,    CMO_ERROR, CMO_ERROR2, CMO_ZERO,
         0    0
 };  };
   
 int ox_data_is_available(int s)  int ox_data_is_available(int s)
 {  {
         return FP_DATA_IS_AVAILABLE(iofp[s].in);    return FP_DATA_IS_AVAILABLE(iofp[s].in);
 }  }
   
 void wait_for_data(int s)  void wait_for_data(int s)
 {  {
         fd_set r;    fd_set r;
         int sock;    int sock;
   
         if ( !FP_DATA_IS_AVAILABLE(iofp[s].in) ) {    if ( !FP_DATA_IS_AVAILABLE(iofp[s].in) ) {
                 sock = iofp[s].in->fildes;      sock = iofp[s].in->fildes;
                 FD_ZERO(&r);      FD_ZERO(&r);
                 FD_SET((unsigned int)sock,&r);      FD_SET((unsigned int)sock,&r);
                 select(0,&r,NULL,NULL,NULL);      select(0,&r,NULL,NULL,NULL);
         }    }
 }  }
   
 void ox_send_data(int s,pointer p)  void ox_send_data(int s,pointer p)
 {  {
         ERR err;    ERR err;
   
         if ( !valid_as_cmo(p) )    if ( !valid_as_cmo(p) )
                 return;      return;
         ox_write_int(s,OX_DATA);    ox_write_int(s,OX_DATA);
         ox_write_int(s,ox_serial++);    ox_write_int(s,ox_serial++);
         ox_write_cmo(s,p);    ox_write_cmo(s,p);
         ox_flush_stream(s);    ox_flush_stream(s);
 }  }
   
 void ox_send_cmd(int s,int id)  void ox_send_cmd(int s,int id)
 {  {
         ox_write_int(s,OX_COMMAND);    ox_write_int(s,OX_COMMAND);
         ox_write_int(s,ox_serial++);    ox_write_int(s,ox_serial++);
         ox_write_int(s,id);    ox_write_int(s,id);
         ox_flush_stream(s);    ox_flush_stream(s);
 }  }
   
 void ox_send_sync(int s)  void ox_send_sync(int s)
 {  {
         ox_write_int(s,OX_SYNC_BALL);    ox_write_int(s,OX_SYNC_BALL);
         ox_write_int(s,ox_serial++);    ox_write_int(s,ox_serial++);
         ox_flush_stream(s);    ox_flush_stream(s);
 }  }
   
 unsigned int ox_recv(int s, int *id, Obj *p)  unsigned int ox_recv(int s, int *id, Obj *p)
 {  {
         unsigned int cmd,serial;    unsigned int cmd,serial;
         USINT ui;    USINT ui;
   
         wait_for_data(s);    wait_for_data(s);
         if ( terminate ) return -1;    if ( terminate ) return -1;
         ox_read_int(s,id);    ox_read_int(s,id);
         ox_read_int(s,&serial);    ox_read_int(s,&serial);
         switch ( *id ) {    switch ( *id ) {
                 case OX_COMMAND:      case OX_COMMAND:
                         ox_read_int(s,&cmd);        ox_read_int(s,&cmd);
                         _MKUSINT(ui,cmd);        _MKUSINT(ui,cmd);
                         *p = (Obj)ui;        *p = (Obj)ui;
                         break;        break;
                 case OX_DATA:      case OX_DATA:
                         ox_read_cmo(s,p);        ox_read_cmo(s,p);
                         break;        break;
                 default:      default:
                         *p = 0;        *p = 0;
                         break;        break;
         }    }
         return serial;    return serial;
 }  }
   
 void ox_get_result(int s,Obj *rp)  void ox_get_result(int s,Obj *rp)
 {  {
         int id;    int id;
         Obj obj,r;    Obj obj,r;
         int level;    int level;
   
         level = 0;    level = 0;
         r = 0;    r = 0;
         do {    do {
                 ox_recv(s,&id,&obj);      ox_recv(s,&id,&obj);
                 if ( id == OX_COMMAND ) {      if ( id == OX_COMMAND ) {
                         switch ( ((USINT)obj)->body ) {        switch ( ((USINT)obj)->body ) {
                                 case SM_beginBlock:          case SM_beginBlock:
                                         level++;            level++;
                                         break;            break;
                                 case SM_endBlock:          case SM_endBlock:
                                         level--;            level--;
                         }        }
                 } else      } else
                         r = obj;        r = obj;
         } while ( level );    } while ( level );
         *rp = r;    *rp = r;
 }  }
   
 void ox_read_int(int s, int *n)  void ox_read_int(int s, int *n)
 {  {
         read_int((FILE *)iofp[s].in,n);    read_int((FILE *)iofp[s].in,n);
 }  }
   
 void ox_read_cmo(int s, Obj *rp)  void ox_read_cmo(int s, Obj *rp)
 {  {
         read_cmo((FILE *)iofp[s].in,rp);    read_cmo((FILE *)iofp[s].in,rp);
 }  }
   
 void ox_write_int(int s, int n)  void ox_write_int(int s, int n)
 {  {
         write_int((FILE *)iofp[s].out,&n);    write_int((FILE *)iofp[s].out,&n);
 }  }
   
 void ox_write_cmo(int s, Obj obj)  void ox_write_cmo(int s, Obj obj)
 {  {
         write_cmo((FILE *)iofp[s].out,obj);    write_cmo((FILE *)iofp[s].out,obj);
 }  }
   
 void ox_flush_stream(int s)  void ox_flush_stream(int s)
 {  {
         if ( ox_batch )    if ( ox_batch )
                 return;      return;
         if ( _fileno(&iofp[s].out->fp) < 0 )    if ( _fileno(&iofp[s].out->fp) < 0 )
                 cflush(iofp[s].out);      cflush(iofp[s].out);
         else    else
                 fflush((FILE *)iofp[s].out);      fflush((FILE *)iofp[s].out);
 }  }
   
 void ox_flush_stream_force(int s)  void ox_flush_stream_force(int s)
 {  {
         if ( _fileno(&iofp[s].out->fp) < 0 )    if ( _fileno(&iofp[s].out->fp) < 0 )
                 cflush(iofp[s].out);      cflush(iofp[s].out);
         else    else
                 fflush((FILE *)iofp[s].out);      fflush((FILE *)iofp[s].out);
 }  }
   
 /* CMO I/O functions */  /* CMO I/O functions */
   
 int valid_as_cmo(Obj obj)  int valid_as_cmo(Obj obj)
 {  {
         NODE m;    NODE m;
   
         if ( !obj )    if ( !obj )
                 return 1;      return 1;
         switch ( OID(obj) ) {    switch ( OID(obj) ) {
                 case O_STR: case O_ERR: case O_USINT:      case O_STR: case O_ERR: case O_USINT:
                         return 1;        return 1;
                 default:      default:
                         return 0;        return 0;
         }    }
 }  }
   
 void write_cmo(FILE *s,Obj obj)  void write_cmo(FILE *s,Obj obj)
 {  {
         int r;    int r;
         char errmsg[BUFSIZ];    char errmsg[BUFSIZ];
   
         if ( !obj ) {    if ( !obj ) {
                 r = CMO_NULL; write_int(s,&r);      r = CMO_NULL; write_int(s,&r);
                 return;      return;
         }    }
         switch ( OID(obj) ) {    switch ( OID(obj) ) {
                 case O_STR:      case O_STR:
                         write_cmo_string(s,(STRING)obj);        write_cmo_string(s,(STRING)obj);
                         break;        break;
                 case O_USINT:      case O_USINT:
                         write_cmo_uint(s,(USINT)obj);        write_cmo_uint(s,(USINT)obj);
                         break;        break;
                 case O_LIST:      case O_LIST:
                         write_cmo_list(s,(LIST)obj);        write_cmo_list(s,(LIST)obj);
                         break;        break;
                 case O_ERR:      case O_ERR:
                         write_cmo_error(s,(ERR)obj);        write_cmo_error(s,(ERR)obj);
                         break;        break;
         }    }
 }  }
   
 int cmo_tag(Obj obj,int *tag)  int cmo_tag(Obj obj,int *tag)
 {  {
         if ( !obj ) {    if ( !obj ) {
                 *tag = CMO_NULL;      *tag = CMO_NULL;
                 return 1;      return 1;
         }    }
         switch ( OID(obj) ) {    switch ( OID(obj) ) {
                 case O_STR:      case O_STR:
                         *tag = CMO_STRING; break;        *tag = CMO_STRING; break;
                 case O_USINT:      case O_USINT:
                         *tag = CMO_INT32; break;        *tag = CMO_INT32; break;
                 case O_LIST:      case O_LIST:
                         *tag = CMO_LIST; break;        *tag = CMO_LIST; break;
                 case O_ERR:      case O_ERR:
                         *tag = CMO_ERROR2; break;        *tag = CMO_ERROR2; break;
                 default:      default:
                         return 0;        return 0;
         }    }
         return 1;    return 1;
 }  }
   
 void write_cmo_uint(FILE *s,USINT ui)  void write_cmo_uint(FILE *s,USINT ui)
 {  {
         unsigned int r;    unsigned int r;
   
         r = CMO_INT32; write_int(s,&r);    r = CMO_INT32; write_int(s,&r);
         r = ui->body; write_int(s,&r);    r = ui->body; write_int(s,&r);
 }  }
   
 void write_cmo_string(FILE *s,STRING str)  void write_cmo_string(FILE *s,STRING str)
 {  {
         int r;    int r;
         int size;    int size;
         char *p;    char *p;
   
         r = CMO_STRING; write_int(s,&r);    r = CMO_STRING; write_int(s,&r);
         p = BDY(str);    p = BDY(str);
         size = p ? strlen(p) : 0;    size = p ? strlen(p) : 0;
         write_int(s,&size);    write_int(s,&size);
         if ( size )    if ( size )
                 write_string(s,p,size);      write_string(s,p,size);
 }  }
   
 void write_cmo_list(FILE *s,LIST list)  void write_cmo_list(FILE *s,LIST list)
 {  {
         NODE m;    NODE m;
         int i,n,r;    int i,n,r;
   
         for ( n = 0, m = BDY(list); m; m = NEXT(m), n++ );    for ( n = 0, m = BDY(list); m; m = NEXT(m), n++ );
         r = CMO_LIST; write_int(s,&r);    r = CMO_LIST; write_int(s,&r);
         write_int(s,&n);    write_int(s,&n);
         for ( i = 0, m = BDY(list); i < n; i++, m = NEXT(m) )    for ( i = 0, m = BDY(list); i < n; i++, m = NEXT(m) )
                 write_cmo(s,BDY(m));      write_cmo(s,BDY(m));
 }  }
   
 void write_cmo_error(FILE *s,ERR e)  void write_cmo_error(FILE *s,ERR e)
 {  {
         int r;    int r;
   
         r = CMO_ERROR2; write_int(s,&r);    r = CMO_ERROR2; write_int(s,&r);
         write_cmo(s,BDY(e));    write_cmo(s,BDY(e));
 }  }
   
 void read_cmo(FILE *s,Obj *rp)  void read_cmo(FILE *s,Obj *rp)
 {  {
         int id;    int id;
         STRING str;    STRING str;
         LIST list;    LIST list;
         USINT t;    USINT t;
         Obj obj;    Obj obj;
         ERR e;    ERR e;
   
         read_int(s,&id);    read_int(s,&id);
         switch ( id ) {    switch ( id ) {
         /* level 0 objects */    /* level 0 objects */
                 case CMO_NULL:      case CMO_NULL:
                         *rp = 0;        *rp = 0;
                         break;        break;
                 case CMO_INT32:      case CMO_INT32:
                         read_cmo_uint(s,&t); *rp = (Obj)t;        read_cmo_uint(s,&t); *rp = (Obj)t;
                         break;        break;
                 case CMO_STRING:      case CMO_STRING:
                         loadstring(s,&str); *rp = (Obj)str;        loadstring(s,&str); *rp = (Obj)str;
                         break;        break;
                 case CMO_LIST:      case CMO_LIST:
                         read_cmo_list(s,&list); *rp = (Obj)list;        read_cmo_list(s,&list); *rp = (Obj)list;
                         break;        break;
                 case CMO_ERROR:      case CMO_ERROR:
                         _MKERR(e,0); *rp = (Obj)e;        _MKERR(e,0); *rp = (Obj)e;
                         break;        break;
                 case CMO_ERROR2:      case CMO_ERROR2:
                         read_cmo(s,&obj); _MKERR(e,obj); *rp = (Obj)e;        read_cmo(s,&obj); _MKERR(e,obj); *rp = (Obj)e;
                         break;        break;
                 case CMO_ZERO:      case CMO_ZERO:
                         *rp = 0;        *rp = 0;
                         break;        break;
                 default:      default:
                         _MKUSINT(t,id);        _MKUSINT(t,id);
                         t->id = O_VOID;        t->id = O_VOID;
                         *rp = (Obj)t;        *rp = (Obj)t;
                         break;        break;
         }    }
 }  }
   
 void read_cmo_uint(FILE *s,USINT *rp)  void read_cmo_uint(FILE *s,USINT *rp)
 {  {
         unsigned int body;    unsigned int body;
   
         read_int(s,&body);    read_int(s,&body);
         _MKUSINT(*rp,body);    _MKUSINT(*rp,body);
 }  }
   
 void read_cmo_list(FILE *s,Obj *rp)  void read_cmo_list(FILE *s,Obj *rp)
 {  {
         int len;    int len;
         Obj *w;    Obj *w;
         int i;    int i;
         NODE n0,n1;    NODE n0,n1;
         LIST list;    LIST list;
   
         read_int(s,&len);    read_int(s,&len);
         w = (Obj *)ALLOCA(len*sizeof(Obj));    w = (Obj *)ALLOCA(len*sizeof(Obj));
         for ( i = 0; i < len; i++ )    for ( i = 0; i < len; i++ )
                 read_cmo(s,&w[i]);      read_cmo(s,&w[i]);
         for ( i = len-1, n0 = 0; i >= 0; i-- ) {    for ( i = len-1, n0 = 0; i >= 0; i-- ) {
                 _MKNODE(n1,w[i],n0); n0 = n1;      _MKNODE(n1,w[i],n0); n0 = n1;
         }    }
         _MKLIST(list,n0);    _MKLIST(list,n0);
         *rp = (Obj)list;    *rp = (Obj)list;
 }  }
   
 void loadstring(FILE *s,STRING *p)  void loadstring(FILE *s,STRING *p)
 {  {
         char *t;    char *t;
   
         loadstr(s,&t); _MKSTR(*p,t);    loadstr(s,&t); _MKSTR(*p,t);
 }  }
   
 void loadstr(FILE *s,char **p)  void loadstr(FILE *s,char **p)
 {  {
         int len;    int len;
         char *t;    char *t;
   
         read_int(s,&len);    read_int(s,&len);
         t = (char *)malloc(len+1);    t = (char *)malloc(len+1);
         if ( len ) read_string(s,t,len);    if ( len ) read_string(s,t,len);
         t[len] = 0;    t[len] = 0;
         *p = t;    *p = t;
 }  }
   
 /* low level buffered I/O functions */  /* low level buffered I/O functions */
   
 int gen_fread (char *ptr,int size,int nitems,FILE *stream)  int gen_fread (char *ptr,int size,int nitems,FILE *stream)
 {  {
         int n;    int n;
   
         if ( _fileno(stream) < 0 )    if ( _fileno(stream) < 0 )
                 n = cread(ptr,size,nitems,(STREAM *)stream);      n = cread(ptr,size,nitems,(STREAM *)stream);
         else    else
                 n = fread(ptr,size,nitems,stream);      n = fread(ptr,size,nitems,stream);
         if ( !n )    if ( !n )
                 return 0;      return 0;
         else    else
                 return n;      return n;
 }  }
   
 int gen_fwrite (char *ptr,int size,int nitems,FILE *stream)  int gen_fwrite (char *ptr,int size,int nitems,FILE *stream)
 {  {
         if ( _fileno(stream) < 0 )    if ( _fileno(stream) < 0 )
                 return cwrite(ptr,size,nitems,(STREAM *)stream);      return cwrite(ptr,size,nitems,(STREAM *)stream);
         else    else
                 return fwrite(ptr,size,nitems,stream);      return fwrite(ptr,size,nitems,stream);
 }  }
   
 void write_char(FILE *f,unsigned char *p)  void write_char(FILE *f,unsigned char *p)
 {  {
         gen_fwrite(p,sizeof(unsigned char),1,f);    gen_fwrite(p,sizeof(unsigned char),1,f);
 }  }
   
 void write_short(FILE *f,unsigned short *p)  void write_short(FILE *f,unsigned short *p)
 {  {
         gen_fwrite((char *)p,sizeof(unsigned short),1,f);    gen_fwrite((char *)p,sizeof(unsigned short),1,f);
 }  }
   
 void write_int(FILE *f,unsigned int *p)  void write_int(FILE *f,unsigned int *p)
 {  {
         gen_fwrite((char *)p,sizeof(unsigned int),1,f);    gen_fwrite((char *)p,sizeof(unsigned int),1,f);
 }  }
   
 void write_string(FILE *f,unsigned char *p,int l)  void write_string(FILE *f,unsigned char *p,int l)
 {  {
         gen_fwrite(p,sizeof(unsigned char),l,f);    gen_fwrite(p,sizeof(unsigned char),l,f);
 }  }
   
 void read_char(FILE *f,unsigned char *p)  void read_char(FILE *f,unsigned char *p)
 {  {
         gen_fread((char *)p,sizeof(unsigned char),1,f);    gen_fread((char *)p,sizeof(unsigned char),1,f);
 }  }
   
 void read_short(FILE *f,unsigned short *p)  void read_short(FILE *f,unsigned short *p)
 {  {
         gen_fread((char *)p,sizeof(unsigned short),1,f);    gen_fread((char *)p,sizeof(unsigned short),1,f);
 }  }
   
 void read_int(FILE *f,unsigned int *p)  void read_int(FILE *f,unsigned int *p)
 {  {
         gen_fread((char *)p,sizeof(unsigned int),1,f);    gen_fread((char *)p,sizeof(unsigned int),1,f);
 }  }
   
 void read_string(FILE *f,unsigned char *p,int l)  void read_string(FILE *f,unsigned char *p,int l)
 {  {
         gen_fread((char *)p,sizeof(unsigned char),l,f);    gen_fread((char *)p,sizeof(unsigned char),l,f);
 }  }
   
 /* dummy functions, alternative functions */  /* dummy functions, alternative functions */
   
 double get_current_time()  double get_current_time()
 {  {
         return GetTickCount()/1000.0;    return GetTickCount()/1000.0;
 }  }
   
 void shutdown_all(){}  void shutdown_all(){}
Legend:
Removed from v.1.3  
changed lines
  Added in v.1.4
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>