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

Diff for /OpenXM_contrib2/asir2000/plot/ox_plot.c between version 1.6 and 1.32

version 1.6, 2000/08/22 05:04:31 version 1.32, 2020/10/04 03:14:09
Line 45 
Line 45 
  * DEVELOPER SHALL HAVE NO LIABILITY IN CONNECTION WITH THE USE,   * DEVELOPER SHALL HAVE NO LIABILITY IN CONNECTION WITH THE USE,
  * PERFORMANCE OR NON-PERFORMANCE OF THE SOFTWARE.   * PERFORMANCE OR NON-PERFORMANCE OF THE SOFTWARE.
  *   *
  * $OpenXM: OpenXM_contrib2/asir2000/plot/ox_plot.c,v 1.5 2000/08/21 08:31:50 noro Exp $   * $OpenXM: OpenXM_contrib2/asir2000/plot/ox_plot.c,v 1.31 2018/03/29 01:32:55 noro Exp $
 */  */
 #include "ca.h"  #include "ca.h"
 #include "parse.h"  #include "parse.h"
Line 53 
Line 53 
 #include "ifplot.h"  #include "ifplot.h"
 #include "version.h"  #include "version.h"
 #include <signal.h>  #include <signal.h>
 #if PARI  #if defined(PARI)
 #include "genpari.h"  #include "genpari.h"
 #endif  #endif
   
 void ox_usr1_handler();  int objcp(NODE arg);
   
   extern int asir_OperandStackSize;
   extern Obj *asir_OperandStack;
   extern int asir_OperandStackPtr;
   
   // environement is defined in libpari.a
   #if !(PARI_VERSION_CODE > 131588)
 extern jmp_buf environnement;  extern jmp_buf environnement;
   #endif
   
 extern int do_message;  extern int do_message;
 extern int ox_flushing;  extern int ox_flushing;
 extern jmp_buf ox_env;  extern JMP_BUF ox_env;
 extern MATHCAP my_mathcap;  extern MATHCAP my_mathcap;
   extern char LastError[];
   
 static int plot_OperandStackSize;  void create_error(ERR *,unsigned int ,char *,LIST );
 static Obj *plot_OperandStack;  
 static int plot_OperandStackPtr = -1;  
   
 static void create_error(ERR *,unsigned int ,char *);  void ox_io_init();
   void ox_asir_init(int,char **,char *);
   Obj asir_pop_one();
   void asir_push_one(Obj);
   void asir_end_flush();
   int asir_executeString();
   void asir_evalName(unsigned int);
   void asir_setName(unsigned int);
   void asir_pops();
   void asir_popString();
   void asir_popCMO(unsigned int);
   void asir_popSerializedLocalObject();
   char *name_of_cmd(unsigned int);
   char *name_of_id(int);
   LIST asir_GetErrorList();
   
   static void asir_do_cmd(unsigned int,unsigned int);
 static void process_ox();  static void process_ox();
 static void ox_io_init();  
 static void ox_asir_init(int,char **);  
 static Obj asir_pop_one();  
 static void asir_push_one(Obj);  
 static void asir_end_flush();  
 static void asir_executeFunction();  static void asir_executeFunction();
 static int asir_executeString();  
 static void asir_evalName(unsigned int);  
 static void asir_setName(unsigned int);  
 static void asir_pops();  
 static void asir_popString();  
 static void asir_popCMO(unsigned int);  
 static void asir_popSerializedLocalObject();  
 static char *name_of_cmd(unsigned int);  
 static char *name_of_id(int);  
 static void asir_do_cmd(unsigned int,unsigned int);  
 static LIST asir_GetErrorList();  
   
 static void create_error(ERR *err,unsigned int serial,char *msg)  #if defined(VISUAL) || defined(__MINGW32__)
   void ox_plot_main()
   #else
   void ox_plot_main(int argc,char **argv)
   #endif
 {  {
         USINT ui;    int ds;
         NODE n,n1;    fd_set r;
         LIST list;    int n;
         STRING errmsg;    int use_x;
   
         MKUSINT(ui,serial);  #if !defined(VISUAL) && !defined(__MINGW32__)
         MKSTR(errmsg,msg);    ox_asir_init(argc,argv,"ox_plot");
         MKNODE(n1,errmsg,0); MKNODE(n,ui,n1); MKLIST(list,n);    use_x=init_plot_display(argc,argv);
         MKERR(*err,list);    if(use_x) ds=ConnectionNumber(display);
 }    else fprintf(stderr,"Entering no X mode\n");
   
 void ox_plot_main(int argc,char **argv) {  
         int ds;  
         fd_set r;  
         int n;  
   
         ox_asir_init(argc,argv);  
         init_plot_display(argc,argv);  
         ds = ConnectionNumber(display);  
         if ( do_message )  
                 fprintf(stderr,"I'm an ox_plot, Version %d.\n",ASIR_VERSION);  
   
         if ( setjmp(ox_env) ) {  
                 while ( NEXT(asir_infile) )  
                         closecurrentinput();  
                 reset_current_computation();  
                 ox_send_sync(0);  
         }  
         while ( 1 ) {  
                 if ( ox_data_is_available(0) )  
                         process_ox();  
                 else {  
                         FD_ZERO(&r);  
                         FD_SET(3,&r); FD_SET(ds,&r);  
                         select(FD_SETSIZE,&r,NULL,NULL,NULL);  
                         if ( FD_ISSET(3,&r) )  
                                 process_ox();  
                         else if ( FD_ISSET(ds,&r) )  
                                 process_xevent();  
                 }  
         }  
 }  
   
 static void process_ox()  
 {  
         int id;  
         unsigned int cmd;  
         Obj obj;  
         ERR err;  
         unsigned int serial;  
         int ret;  
         extern char LastError[];  
   
         serial = ox_recv(0,&id,&obj);  
         if ( do_message )  
                 fprintf(stderr,"#%d Got %s",serial,name_of_id(id));  
         switch ( id ) {  
                 case OX_COMMAND:  
                         cmd = ((USINT)obj)->body;  
                         if ( ox_flushing )  
                                 break;  
                         if ( do_message )  
                                 fprintf(stderr," %s\n",name_of_cmd(cmd));  
                         if ( ret = setjmp(env) ) {  
                                 if ( ret == 1 ) {  
                                         create_error(&err,serial,LastError);  
                                         asir_push_one((Obj)err);  
                                 }  
                                 break;  
                         }  
                         asir_do_cmd(cmd,serial);  
                         break;  
                 case OX_DATA:  
                 case OX_LOCAL_OBJECT_ASIR:  
                         if ( ox_flushing )  
                                 break;  
                         if ( do_message )  
                                 fprintf(stderr," -> data pushed");  
                         asir_push_one(obj);  
                         break;  
                 case OX_SYNC_BALL:  
                                 asir_end_flush();  
                         break;  
                 default:  
                         break;  
         }  
         if ( do_message )  
                 fprintf(stderr,"\n");  
 }  
   
 static void asir_do_cmd(unsigned int cmd,unsigned int serial)  
 {  
         MATHCAP client_mathcap;  
         LIST list;  
         int i;  
         Q q;  
   
         switch ( cmd ) {  
                 case SM_dupErrors:  
                         list = asir_GetErrorList();  
                         asir_push_one((Obj)list);  
                         break;  
                 case SM_getsp:  
                         i = plot_OperandStackPtr+1;  
                         STOQ(i,q);  
                         asir_push_one((Obj)q);  
                         break;  
                 case SM_popSerializedLocalObject:  
                         asir_popSerializedLocalObject();  
                         break;  
                 case SM_popCMO:  
                         asir_popCMO(serial);  
                         break;  
                 case SM_popString:  
                         asir_popString();  
                         break;  
                 case SM_setName:  
                         asir_setName(serial);  
                         break;  
                 case SM_evalName:  
                         asir_evalName(serial);  
                         break;  
                 case SM_executeStringByLocalParser:  
                         asir_executeString();  
                         break;  
                 case SM_executeFunction:  
                         asir_executeFunction();  
                         break;  
                 case SM_shutdown:  
                         asir_terminate(2);  
                         break;  
                 case SM_pops:  
                         asir_pops();  
                         break;  
                 case SM_mathcap:  
                         asir_push_one((Obj)my_mathcap);  
                         break;  
                 case SM_setMathcap:  
                         client_mathcap = (MATHCAP)asir_pop_one();  
                         store_remote_mathcap(0,client_mathcap);  
                         break;  
                 default:  
                         break;  
         }  
 }  
   
 static char *name_of_id(int id)  
 {  
         switch ( id ) {  
                 case OX_COMMAND:  
                         return "OX_COMMAND";  
                         break;  
                 case OX_DATA:  
                         return "OX_DATA";  
                         break;  
                 case OX_LOCAL_OBJECT_ASIR:  
                         return "OX_LOCAL_OBJECT_ASIR";  
                         break;  
                 case OX_SYNC_BALL:  
                         return "OX_SYNC_BALL";  
                         break;  
                 default:  
                         return "Unknown id";  
                         break;  
         }  
 }  
   
 static char *name_of_cmd(unsigned cmd)  
 {  
         switch ( cmd ) {  
                 case SM_popSerializedLocalObject:  
                         return "SM_popSerializedLocalObject";  
                         break;  
                 case SM_popCMO:  
                         return "SM_popCMO";  
                         break;  
                 case SM_popString:  
                         return "SM_popString";  
                         break;  
                 case SM_pops:  
                         return "SM_pops";  
                         break;  
                 case SM_setName:  
                         return "SM_setName";  
                         break;  
                 case SM_evalName:  
                         return "SM_evalName";  
                         break;  
                 case SM_executeStringByLocalParser:  
                         return "SM_executeString";  
                         break;  
                 case SM_executeFunction:  
                         return "SM_executeFunction";  
                         break;  
                 case SM_shutdown:  
                         return "SM_shutdown";  
                         break;  
                 case SM_beginBlock:  
                         return "SM_beginBlock";  
                         break;  
                 case SM_endBlock:  
                         return "SM_endBlock";  
                         break;  
                 case SM_mathcap:  
                         return "SM_mathcap";  
                         break;  
                 case SM_setMathcap:  
                         return "SM_setMathcap";  
                         break;  
                 default:  
                         return "Unknown cmd";  
                         break;  
         }  
 }  
   
 static void asir_popSerializedLocalObject()  
 {  
         Obj obj;  
         VL t,vl;  
   
         obj = asir_pop_one();  
         get_vars(obj,&vl);  
         for ( t = vl; t; t = NEXT(t) )  
                 if ( t->v->attr == (pointer)V_UC || t->v->attr == (pointer)V_PF )  
                         error("bsave : not implemented");  
         ox_send_cmd(0,SM_beginBlock);  
         ox_send_local_ring(0,vl);  
         ox_send_local_data(0,obj);  
         ox_send_cmd(0,SM_endBlock);  
 }  
   
 static void asir_popCMO(unsigned int serial)  
 {  
         Obj obj;  
         ERR err;  
   
         obj = asir_pop_one();  
         if ( valid_as_cmo(obj) )  
                 ox_send_data(0,obj);  
         else {  
                 create_error(&err,serial,"cannot convert to CMO object");  
                 ox_send_data(0,err);  
                 asir_push_one(obj);  
         }  
 }  
   
 static void asir_popString()  
 {  
         Obj val;  
         char *buf,*obuf;  
         int l;  
         STRING str;  
   
         val = asir_pop_one();  
         if ( !val )  
                 obuf = 0;  
         else {  
                 l = estimate_length(CO,val);  
                 buf = (char *)ALLOCA(l+1);  
                 soutput_init(buf);  
                 sprintexpr(CO,val);  
                 l = strlen(buf);  
                 obuf = (char *)MALLOC(l+1);  
                 strcpy(obuf,buf);  
         }  
         MKSTR(str,obuf);  
         ox_send_data(0,str);  
 }  
   
 static void asir_pops()  
 {  
         int n;  
   
         n = (int)(((USINT)asir_pop_one())->body);  
         plot_OperandStackPtr = MAX(plot_OperandStackPtr-n,-1);  
 }  
   
 static void asir_setName(unsigned int serial)  
 {  
         char *name;  
         int l,n;  
         char *dummy = "=0;";  
         SNODE snode;  
         ERR err;  
   
         name = ((STRING)asir_pop_one())->body;  
         l = strlen(name);  
         n = l+strlen(dummy)+1;  
         parse_strp = (char *)ALLOCA(n);  
         sprintf(parse_strp,"%s%s",name,dummy);  
         if ( mainparse(&snode) ) {  
                 create_error(&err,serial,"cannot set to variable");  
                 asir_push_one((Obj)err);  
         } else {  
                 FA1((FNODE)FA0(snode)) = (pointer)mkfnode(1,I_FORMULA,asir_pop_one());  
                 evalstat(snode);  
         }  
 }  
   
 static void asir_evalName(unsigned int serial)  
 {  
         char *name;  
         int l,n;  
         SNODE snode;  
         ERR err;  
         pointer val;  
   
         name = ((STRING)asir_pop_one())->body;  
         l = strlen(name);  
         n = l+2;  
         parse_strp = (char *)ALLOCA(n);  
         sprintf(parse_strp,"%s;",name);  
         if ( mainparse(&snode) ) {  
                 create_error(&err,serial,"no such variable");  
                 val = (pointer)err;  
         } else  
                 val = evalstat(snode);  
         asir_push_one(val);  
 }  
   
 static int asir_executeString()  
 {  
         SNODE snode;  
         pointer val;  
         char *cmd;  
 #if PARI  
         recover(0);  
         if ( setjmp(environnement) ) {  
                 avma = top; recover(1);  
                 resetenv("");  
         }  
 #endif  #endif
         cmd = ((STRING)asir_pop_one())->body;    if(do_message)fprintf(stderr,"I'm an ox_plot, Version %d.\n",ASIR_VERSION);
         parse_strp = cmd;    if(SETJMP(ox_env)){
         if ( mainparse(&snode) ) {      while(NEXT(asir_infile))closecurrentinput();
                 return -1;      reset_current_computation();
         }      ox_send_sync(0);
         val = evalstat(snode);    }
         if ( NEXT(asir_infile) ) {    while (1){
                 while ( NEXT(asir_infile) ) {  #if defined(VISUAL) || defined(__MINGW32__)
                         if ( mainparse(&snode) ) {      process_ox();
                                 asir_push_one(val);  #else
                                 return -1;      if(ox_data_is_available(0)) process_ox();
                         }      else if(use_x){
                         nextbp = 0;        FD_ZERO(&r);
                         val = evalstat(snode);        FD_SET(3,&r); FD_SET(ds,&r);
                 }        select(FD_SETSIZE,&r,NULL,NULL,NULL);
         }        if(FD_ISSET(3,&r)) process_ox();
         asir_push_one(val);        else if(FD_ISSET(ds,&r)) process_xevent();
         return 0;      }
 }    }
   
 static void asir_executeFunction()  
 {  
         char *func;  
         int argc;  
         int id;  
         FUNC f;  
         Q ret;  
         VL vl;  
         NODE n,n1;  
   
         func = ((STRING)asir_pop_one())->body;  
         argc = (int)(((USINT)asir_pop_one())->body);  
   
         for ( n = 0; argc; argc-- ) {  
                 NEXTNODE(n,n1);  
                 BDY(n1) = (pointer)asir_pop_one();  
         }  
         if ( n )  
                 NEXT(n1) = 0;  
         id = -1;  
         if ( !strcmp(func,"plot") )  
                 id = plot(n);  
         else if ( !strcmp(func,"arrayplot") )  
                 id = arrayplot(n);  
         else if ( !strcmp(func,"plotover") )  
                 id = plotover(n);  
         else if ( !strcmp(func,"drawcircle") )  
                 id = drawcircle(n);  
         STOQ(id,ret);  
 #if 0  
         asir_push_one((Obj)ret);  
 #endif  #endif
 }  }
   
 static void asir_end_flush()  static void process_ox(){
 {    int id;
         ox_flushing = 0;    unsigned int cmd;
 }    Obj obj;
     ERR err;
     unsigned int serial;
     int ret;
   
 static void asir_push_one(Obj obj)    serial=ox_recv(0,&id,&obj);
 {    if(do_message) fprintf(stderr,"#%d Got %s",serial,name_of_id(id));
         if ( !obj || OID(obj) != O_VOID ) {    switch (id){
                 plot_OperandStackPtr++;      case OX_COMMAND:
                 if ( plot_OperandStackPtr >= plot_OperandStackSize ) {        cmd=((USINT)obj)->body;
                         plot_OperandStackSize += BUFSIZ;        if(ox_flushing) break;
                         plot_OperandStack        if(do_message) fprintf(stderr," %s\n",name_of_cmd(cmd));
                                 = (Obj *)REALLOC(plot_OperandStack,        ret=SETJMP(main_env);
                                         plot_OperandStackSize*sizeof(Obj));        if(ret){
                 }          if(ret==1){
                 plot_OperandStack[plot_OperandStackPtr] = obj;            create_error(&err,serial,LastError,0);
         }            asir_push_one((Obj)err);
           }
           break;
         }
         asir_do_cmd(cmd,serial);
         break;
       case OX_DATA:
       case OX_LOCAL_OBJECT_ASIR:
         if(ox_flushing)break;
         if(do_message)fprintf(stderr," -> data pushed");
         asir_push_one(obj);
         break;
       case OX_SYNC_BALL:
         asir_end_flush();
         break;
       default:
         break;
     }
     if(do_message)fprintf(stderr,"\n");
 }  }
   
 static LIST asir_GetErrorList()  static void asir_do_cmd(unsigned int cmd,unsigned int serial){
 {    MATHCAP client_mathcap;
         int i;    LIST list;
         NODE n,n0;    int i;
         LIST err;    Q q;
         Obj obj;  
   
         for ( i = 0, n0 = 0; i <= plot_OperandStackPtr; i++ )    switch (cmd){
                 if ( (obj = plot_OperandStack[i]) && (OID(obj) == O_ERR) ) {      case SM_dupErrors:
                         NEXTNODE(n0,n); BDY(n) = (pointer)obj;        list=asir_GetErrorList();
                 }        asir_push_one((Obj)list);
         if ( n0 )        break;
                 NEXT(n) = 0;      case SM_getsp:
         MKLIST(err,n0);        i=asir_OperandStackPtr+1;
         return err;        STOQ(i,q);
         asir_push_one((Obj)q);
         break;
       case SM_popSerializedLocalObject:
         asir_popSerializedLocalObject();
         break;
       case SM_popCMO:
         asir_popCMO(serial);
         break;
       case SM_popString:
         asir_popString();
         break;
       case SM_setName:
         asir_setName(serial);
         break;
       case SM_evalName:
         asir_evalName(serial);
         break;
       case SM_executeStringByLocalParser:
         asir_executeString();
         break;
       case SM_executeFunction:
         asir_executeFunction(serial);
         break;
       case SM_shutdown:
         asir_terminate(2);
         break;
       case SM_pops:
         asir_pops();
         break;
       case SM_mathcap:
         asir_push_one((Obj)my_mathcap);
         break;
       case SM_setMathcap:
         client_mathcap=(MATHCAP)asir_pop_one();
         store_remote_mathcap(0,client_mathcap);
         break;
       case SM_nop:
       default:
         break;
     }
 }  }
   
 static Obj asir_pop_one() {  static void asir_executeFunction(int serial){
         if ( plot_OperandStackPtr < 0 ) {    char *fn;
                 if ( do_message )    int argc,id,fno;
                         fprintf(stderr,"OperandStack underflow");    FUNC f;
                 return 0;    Q ret;
         } else {    VL vl;
                 if ( do_message )    ERR err;
                         fprintf(stderr,"pop at %d\n",plot_OperandStackPtr);    NODE n,n1;
                 return plot_OperandStack[plot_OperandStackPtr--];    LIST bytes;
         }  
 }  
   
 static void ox_asir_init(int argc,char **argv)    fn=((STRING)asir_pop_one())->body;
 {    argc=(int)(((USINT)asir_pop_one())->body);
         int tmp;    for(n=0;argc;argc--){
         char ifname[BUFSIZ];      NEXTNODE(n,n1);
         extern int GC_dont_gc;      BDY(n1)=(pointer)asir_pop_one();
         extern int read_exec_file;    }
         extern int do_asirrc;    if(n)NEXT(n1)=0;
         extern int do_server_in_X11;    id=-1;
         char *getenv();    fno=modeNO(fn);
         static ox_asir_initialized = 0;    switch (fno){
         FILE *ifp;    case 0://IFPLOT
       id=plot(n,fno);
         do_server_in_X11 = 1; /* XXX */      STOQ(id,ret);
         asir_save_handler();      asir_push_one((Obj)ret);
 #if PARI      break;
         risa_pari_init();    case 1://CONPLOT
       id=plot(n,fno);
       STOQ(id,ret);
       asir_push_one((Obj)ret);
       break;
     case 2://PLOT
       id=plot(n,fno);
       STOQ(id,ret);
       asir_push_one((Obj)ret);
       break;
     case 4://POLARPLOT
       id=plot(n,fno);
       STOQ(id,ret);
       asir_push_one((Obj)ret);
       break;
     case 30://MEMORY_PLOT
       memory_plot(n,&bytes);
       asir_push_one((Obj)bytes);
       break;
     case 31://ARRAYPLOT
       id=arrayplot(n);
       STOQ(id,ret);
       asir_push_one((Obj)ret);
       break;
     case 32://OPEN_CANVAS
       id=open_canvas(n);
       STOQ(id,ret);
       asir_push_one((Obj)ret);
       break;
     case 5://PLOTOVER
       plotover(n);
       break;
     case 33://DRAWCIRCLE
       drawcircle(n);
       break;
     case 34://DRAW_OBJ
       if(draw_obj(n) < 0 ){
         create_error(&err,serial,LastError,0);
         asir_push_one((Obj)err);
       }
       break;
     case 35://DRAW_STRING
       if(draw_string(n)<0){
         create_error(&err,serial,LastError,0);
         asir_push_one((Obj)err);
       }
       break;
     case 37://CLEAR_CANVAS
       clear_canvas(n);
       break;
   // ifplotNG
     case 36://OBJ_CP
       id=objcp(n);
       STOQ(id,ret);
       asir_push_one((Obj)ret);
       break;
     case 6://IFPLOTD
     case 7://IFPLOTQ
     case 8://IFPLOTB
     case 9://INEQND
     case 10://INEQNQ
     case 11://INEQNB
     case 21://CONPLOTD
     case 22://CONPLOTQ
     case 23://CONPLOTB
   #if defined(INTERVAL)
     case 24://ITVIFPLOT
 #endif  #endif
         srandom((int)get_current_time());      id=ifplotNG(n,fno);
       STOQ(id,ret);
 #if defined(THINK_C)      asir_push_one((Obj)ret);
         param_init();      break;
 #endif    case 12://INEQNDAND
         StackBottom = &tmp + 1; /* XXX */    case 13://INEQNQAND
         rtime_init();    case 14://INEQNBAND
         env_init();    case 15://INEQNDOR
         endian_init();    case 16://INEQNQOR
 #if !defined(VISUAL) && !defined(THINK_C)    case 17://INEQNBOR
 /*      check_key(); */    case 18://INEQNDXOR
 #endif    case 19://INEQNQXOR
         GC_init();    case 20://INEQNBXOR
         process_args(--argc,++argv);    case 25://PLOTOVERD
 #if 0    case 26://PLOTOVERQ
         copyright();    case 27://PLOTOVERB
 #endif      id=ifplotOP(n,fno);
         output_init();      STOQ(id,ret);
         arf_init();      asir_push_one((Obj)ret);
         nglob_init();      break;
         glob_init();    case 38://POLARPLOTD
         sig_init();      id=polarplotNG(n);
         tty_init();      STOQ(id,ret);
         debug_init();      asir_push_one((Obj)ret);
         pf_init();      break;
         sysf_init();    }
         parif_init();  
 #if defined(VISUAL)  
         init_socket();  
 #endif  
 #if defined(UINIT)  
         reg_sysf();  
 #endif  
 #if defined(THINK_C)  
         sprintf(ifname,"asirrc");  
 #else  
         sprintf(ifname,"%s/.asirrc",getenv("HOME"));  
 #endif  
         if ( do_asirrc && (ifp = fopen(ifname,"r")) ) {  
                 input_init(ifp,ifname);  
                 if ( !setjmp(env) ) {  
                         read_exec_file = 1;  
                         read_eval_loop();  
                         read_exec_file = 0;  
                 }  
                 fclose(ifp);  
         }  
         input_init(0,"string");  
         ox_io_init();  
         create_my_mathcap("ox_plot");  
 }  
   
 static void ox_io_init() {  
         unsigned char c,rc;  
         extern int little_endian;  
   
         endian_init();  
         iofp[0].in = fdopen(3,"r");  
         iofp[0].out = fdopen(4,"w");  
         setbuffer(iofp[0].in,(char *)malloc(LBUFSIZ),LBUFSIZ);  
         setbuffer(iofp[0].out,(char *)malloc(LBUFSIZ),LBUFSIZ);  
         plot_OperandStackSize = BUFSIZ;  
         plot_OperandStack = (Obj *)CALLOC(plot_OperandStackSize,sizeof(Obj));  
         plot_OperandStackPtr = -1;  
         signal(SIGUSR1,ox_usr1_handler);  
         if ( little_endian )  
                 c = 1;  
         else  
                 c = 0xff;  
         write_char(iofp[0].out,&c); ox_flush_stream(0);  
         read_char(iofp[0].in,&rc);  
         iofp[0].conv = c == rc ? 0 : 1;  
 }  }
Legend:
Removed from v.1.6  
changed lines
  Added in v.1.32
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>