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

Diff for /OpenXM_contrib2/asir2000/plot/plotf.c between version 1.26 and 1.35

version 1.26, 2014/05/12 16:54:41 version 1.35, 2018/06/12 07:03:36
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/plotf.c,v 1.25 2014/01/07 06:22:08 saito Exp $   * $OpenXM: OpenXM_contrib2/asir2000/plot/plotf.c,v 1.34 2018/03/29 01:32:55 noro Exp $
 */  */
 #include "ca.h"  #include "ca.h"
 #include "parse.h"  #include "parse.h"
Line 78  void PineqnandD(NODE,Obj *), PineqnandQ(NODE,Obj *), P
Line 78  void PineqnandD(NODE,Obj *), PineqnandQ(NODE,Obj *), P
 void PineqnorD(NODE,Obj *), PineqnorQ(NODE,Obj *), PineqnorB(NODE,Obj *);  void PineqnorD(NODE,Obj *), PineqnorQ(NODE,Obj *), PineqnorB(NODE,Obj *);
 void PineqnxorD(NODE,Obj *), PineqnxorQ(NODE,Obj *), PineqnxorB(NODE,Obj *);  void PineqnxorD(NODE,Obj *), PineqnxorQ(NODE,Obj *), PineqnxorB(NODE,Obj *);
 void PconplotD(NODE,Obj *),PconplotQ(NODE,Obj *),PconplotB(NODE,Obj *);  void PconplotD(NODE,Obj *),PconplotQ(NODE,Obj *),PconplotB(NODE,Obj *);
   void PpolarplotD(NODE,Obj *);
 void PplotoverD(NODE,Obj *),PplotoverQ(NODE,Obj *),PplotoverB(NODE,Obj *);  void PplotoverD(NODE,Obj *),PplotoverQ(NODE,Obj *),PplotoverB(NODE,Obj *);
 void ifplot_mainNG(NODE,char *,Obj *);  void ifplot_mainNG(NODE,char *,Obj *);
 void conplot_mainNG(NODE,char *,Obj *);  void conplot_mainNG(NODE,char *,Obj *);
 void plotover_mainNG(NODE,char *,Obj *);  void plotover_mainNG(NODE,char *,Obj *);
   
 struct ftab plot_tab[]={  struct ftab plot_tab[]={
         {PLOT,Pplot,-7},    {PLOT,Pplot,-7},
 #if defined(INTERVAL)  #if defined(INTERVAL)
         {ITVIFPLOT,Pitvifplot,-8},    {ITVIFPLOT,Pitvifplot,-8},
 #endif  #endif
         {POLARPLOT,Ppolarplot,-6},    {OBJ_CP,Pobj_cp,4},
         {OBJ_CP,Pobj_cp,4},    {POLARPLOT,Ppolarplot,-6},
         {IFPLOT,Pifplot,-7},    {POLARPLOTD,PpolarplotD,-7},
         {IFPLOTD,PifplotD,-8},    {IFPLOT,Pifplot,-7},
         {IFPLOTQ,PifplotQ,-8},    {IFPLOTD,PifplotD,-8},
         {IFPLOTB,PifplotB,-8},    {IFPLOTQ,PifplotQ,-8},
         {INEQN,PineqnD,-8},    {IFPLOTB,PifplotB,-8},
         {INEQND,PineqnD,-8},    {INEQN,PineqnD,-8},
         {INEQNQ,PineqnQ,-8},    {INEQND,PineqnD,-8},
         {INEQNB,PineqnB,-8},    {INEQNQ,PineqnQ,-8},
         {INEQNAND,PineqnandD,-4},    {INEQNB,PineqnB,-8},
         {INEQNDAND,PineqnandD,-4},    {INEQNAND,PineqnandD,-4},
         {INEQNQAND,PineqnandQ,-4},    {INEQNDAND,PineqnandD,-4},
         {INEQNBAND,PineqnandB,-4},    {INEQNQAND,PineqnandQ,-4},
         {INEQNOR,PineqnorD,-4},    {INEQNBAND,PineqnandB,-4},
         {INEQNDOR,PineqnorD,-4},    {INEQNOR,PineqnorD,-4},
         {INEQNQOR,PineqnorQ,-4},    {INEQNDOR,PineqnorD,-4},
         {INEQNBOR,PineqnorB,-4},    {INEQNQOR,PineqnorQ,-4},
         {INEQNXOR,PineqnxorD,-4},    {INEQNBOR,PineqnorB,-4},
         {INEQNDXOR,PineqnxorD,-4},    {INEQNXOR,PineqnxorD,-4},
         {INEQNQXOR,PineqnxorQ,-4},    {INEQNDXOR,PineqnxorD,-4},
         {INEQNBXOR,PineqnxorB,-4},    {INEQNQXOR,PineqnxorQ,-4},
         {CONPLOT,Pconplot,-7},    {INEQNBXOR,PineqnxorB,-4},
         {CONPLOTD,PconplotD,-8},    {CONPLOT,Pconplot,-7},
         {CONPLOTB,PconplotB,-8},    {CONPLOTD,PconplotD,-8},
         {CONPLOTQ,PconplotQ,-8},    {CONPLOTB,PconplotB,-8},
         {PLOTOVER,Pplotover,-4},    {CONPLOTQ,PconplotQ,-8},
         {PLOTOVERD,PplotoverD,-4},    {PLOTOVER,Pplotover,-4},
         {PLOTOVERQ,PplotoverQ,-4},    {PLOTOVERD,PplotoverD,-4},
         {PLOTOVERB,PplotoverB,-4},    {PLOTOVERQ,PplotoverQ,-4},
         {MEMORY_IFPLOT,Pmemory_ifplot,-7},    {PLOTOVERB,PplotoverB,-4},
         {MEMORY_CONPLOT,Pmemory_conplot,-7},    {MEMORY_IFPLOT,Pmemory_ifplot,-7},
         {MEMORY_PLOT,Pmemory_plot,-7},    {MEMORY_CONPLOT,Pmemory_conplot,-7},
         {DRAWCIRCLE,Pdrawcircle,4},    {MEMORY_PLOT,Pmemory_plot,-7},
         {OPEN_CANVAS,Popen_canvas,-3},    {DRAWCIRCLE,Pdrawcircle,6},
         {CLEAR_CANVAS,Pclear_canvas,2},    {OPEN_CANVAS,Popen_canvas,-3},
         {DRAW_OBJ,Pdraw_obj,-3},    {CLEAR_CANVAS,Pclear_canvas,2},
         {DRAW_STRING,Pdraw_string,-4},    {DRAW_OBJ,Pdraw_obj,-4},
         {0,0,0},    {DRAW_STRING,Pdraw_string,-5},
     {0,0,0},
 };  };
 char *pfn[]={  char *pfn[]={
         IFPLOT,CONPLOT,PLOT,INTERACTIVE,POLARPLOT,PLOTOVER,    IFPLOT,CONPLOT,PLOT,INTERACTIVE,POLARPLOT,PLOTOVER,
         IFPLOTD,IFPLOTQ,IFPLOTB,INEQND,INEQNQ,INEQNB,    IFPLOTD,IFPLOTQ,IFPLOTB,INEQND,INEQNQ,INEQNB,
         INEQNDAND,INEQNQAND,INEQNBAND,    INEQNDAND,INEQNQAND,INEQNBAND,
         INEQNDOR,INEQNQOR,INEQNBOR,    INEQNDOR,INEQNQOR,INEQNBOR,
         INEQNDXOR,INEQNQXOR,INEQNBXOR,    INEQNDXOR,INEQNQXOR,INEQNBXOR,
         CONPLOTD,CONPLOTQ,CONPLOTB,ITVIFPLOT,    CONPLOTD,CONPLOTQ,CONPLOTB,ITVIFPLOT,
         PLOTOVERD,PLOTOVERQ,PLOTOVERB,    PLOTOVERD,PLOTOVERQ,PLOTOVERB,
         MEMORY_IFPLOT,MEMORY_CONPLOT,MEMORY_PLOT,ARRAYPLOT,OPEN_CANVAS,    MEMORY_IFPLOT,MEMORY_CONPLOT,MEMORY_PLOT,ARRAYPLOT,OPEN_CANVAS,
         DRAWCIRCLE,DRAW_OBJ,DRAW_STRING,OBJ_CP,CLEAR_CANVAS};    DRAWCIRCLE,DRAW_OBJ,DRAW_STRING,OBJ_CP,CLEAR_CANVAS,POLARPLOTD};
 /*  /*
         IFPLOT:0,CONPLOT:1,PLOT:2,INTERACTIVE:3,POLARPLOT:4,PLOTOVER:5,    IFPLOT:0,CONPLOT:1,PLOT:2,INTERACTIVE:3,POLARPLOT:4,PLOTOVER:5,
         IFPLOTD:6,IFPLOTQ:7,IFPLOTB:8,INEQND:9,INEQNQ:10,INEQNB:11,    IFPLOTD:6,IFPLOTQ:7,IFPLOTB:8,INEQND:9,INEQNQ:10,INEQNB:11,
         INEQNDAND:12,INEQNQAND:13,INEQNBAND:14,    INEQNDAND:12,INEQNQAND:13,INEQNBAND:14,
         INEQNDOR:15,INEQNQOR:16,INEQNBOR:17,    INEQNDOR:15,INEQNQOR:16,INEQNBOR:17,
         INEQNDXOR:18,INEQNQXOR:19,INEQNBXOR:20,    INEQNDXOR:18,INEQNQXOR:19,INEQNBXOR:20,
         CONPLOTD:21,CONPLOTQ:22,CONPLOTB:23,ITVIFPLOT:24,    CONPLOTD:21,CONPLOTQ:22,CONPLOTB:23,ITVIFPLOT:24,
         PLOTOVERD:25,PLOTOVERQ:26,PLOTOVERB:27,    PLOTOVERD:25,PLOTOVERQ:26,PLOTOVERB:27,
         MEMORY_IFPLOT:28,MEMORY_CONPLOT:29,MEMORY_PLOT:30,ARRAYPLOT:31,    MEMORY_IFPLOT:28,MEMORY_CONPLOT:29,MEMORY_PLOT:30,ARRAYPLOT:31,
         OPEN_CANVAS:32,DRAWCIRCLE:33,DRAW_OBJ:34,DRAW_STRING:35,OBJ_CP:36,    OPEN_CANVAS:32,DRAWCIRCLE:33,DRAW_OBJ:34,DRAW_STRING:35,OBJ_CP:36,
         CLEAR_CANVAS:37    CLEAR_CANVAS:37,POLARPLOTD:38
 */  */
 int modeNO(char *fn){  int modeNO(char *fn){
         int i;    int i;
         char **z;    char **z;
         for(i=0,z=pfn;*z!=NULL;z++,i++)if(!strcmp(fn,*z))return i;    for(i=0,z=pfn;*z!=NULL;z++,i++)if(!strcmp(fn,*z))return i;
         return -1;    return -1;
 }  }
   
 void Popen_canvas(NODE arg,Obj *rp){  void Popen_canvas(NODE arg,Obj *rp){
         Q w300,s_id;    Q w300,s_id;
         LIST geom;    LIST geom;
         int stream;    int stream;
         NODE n,n0;    NODE n,n0;
         STRING fname,wname;    STRING fname,wname;
   
         geom=0;wname=0;stream=-1;    geom=0;wname=0;stream=-1;
         for(;arg;arg=NEXT(arg))    for(;arg;arg=NEXT(arg))
                 if(!BDY(arg)) stream=0;      if(!BDY(arg)) stream=0;
                 else switch (OID(BDY(arg))){      else switch (OID(BDY(arg))){
                         case O_LIST:        case O_LIST:
                                 geom=(LIST)BDY(arg);          geom=(LIST)BDY(arg);
                                 break;          break;
                         case O_N:        case O_N:
                                 stream=QTOS((Q)BDY(arg));          stream=QTOS((Q)BDY(arg));
                                 break;          break;
                         case O_STR:        case O_STR:
                                 wname=(STRING)BDY(arg);          wname=(STRING)BDY(arg);
                                 break;          break;
                         default:        default:
                                 error("open_canvas : invalid argument");          error("open_canvas : invalid argument");
                                 break;          break;
                 }      }
         stream=validate_ox_plot_stream(stream);    stream=validate_ox_plot_stream(stream);
         STOQ(stream,s_id);    STOQ(stream,s_id);
         if(!geom){    if(!geom){
                 STOQ(300,w300);      STOQ(300,w300);
                 MKNODE(n0,w300,0);      MKNODE(n0,w300,0);
                 MKNODE(n,w300,n0);      MKNODE(n,w300,n0);
                 MKLIST(geom,n);      MKLIST(geom,n);
         }    }
         MKSTR(fname,OPEN_CANVAS);    MKSTR(fname,OPEN_CANVAS);
         arg=mknode(4,s_id,fname,geom,wname);    arg=mknode(4,s_id,fname,geom,wname);
         Pox_cmo_rpc(arg,rp);    Pox_cmo_rpc(arg,rp);
         *rp=(Obj)s_id;    *rp=(Obj)s_id;
 }  }
   
 void Pifplot(NODE arg,Obj *rp){ifplot_main(arg,0,IFPLOT,rp);}  void Pifplot(NODE arg,Obj *rp){ifplot_main(arg,0,IFPLOT,rp);}
 void Pmemory_ifplot(NODE arg,Obj *rp){ifplot_main(arg,1,IFPLOT,rp);}  void Pmemory_ifplot(NODE arg,Obj *rp){ifplot_main(arg,1,IFPLOT,rp);}
   
 void ifplot_main(NODE arg,int is_memory,char *fn,Obj *rp){  void ifplot_main(NODE arg,int is_memory,char *fn,Obj *rp){
         Q m2,p2,w300,s_id;    Q m2,p2,w300,s_id;
         NODE defrange;    NODE defrange;
         LIST xrange,yrange,zrange,range[2],list,geom;    LIST xrange,yrange,zrange,range[2],list,geom=0;
         VL vl,vl0;    VL vl,vl0;
         V v[2],av[2];    V v[2],av[2];
         int stream,ri,i,sign;    int stream,ri,i,sign;
         P poly,var;    Obj poly;
         NODE n,n0;    P var;
         STRING fname,wname;    NODE n,n0;
         Obj t;    STRING fname,wname;
     Obj t;
     int found_f;
   
         STOQ(-2,m2);STOQ(2,p2);MKNODE(n,p2,0);MKNODE(defrange,m2,n);    STOQ(-2,m2);STOQ(2,p2);MKNODE(n,p2,0);MKNODE(defrange,m2,n);
         poly=0;vl=0;geom=0;wname=0;stream=-1;ri=0;xrange=0;yrange=0;zrange=0;    poly=0;vl=0;geom=0;wname=0;stream=-1;ri=0;xrange=0;yrange=0;zrange=0;
         v[0]=v[1]=0;    v[0]=v[1]=0;
         for(;arg;arg=NEXT(arg))    found_f = 0;
                 if(!BDY(arg))stream=0;    for(;arg;arg=NEXT(arg))
                 else      if(!BDY(arg)){
                 switch(OID(BDY(arg))){        if ( !found_f ) {
                 case O_P:          poly = 0;
                         poly=(P)BDY(arg);          found_f = 1;
                         get_vars_recursive((Obj)poly,&vl);        } else stream=0;
                         for(vl0=vl,i=0;vl0;vl0=NEXT(vl0)){      } else
                                 if(vl0->v->attr==(pointer)V_IND){      switch(OID(BDY(arg))){
                                         if(i>=2)error("ifplot : invalid argument");      case O_P:
                                         else v[i++]=vl0->v;        poly=(Obj)BDY(arg);
                                 }        get_vars_recursive((Obj)poly,&vl);
                         }        for(vl0=vl,i=0;vl0;vl0=NEXT(vl0)){
                         break;          if(vl0->v->attr==(pointer)V_IND){
                 case O_LIST:            if(i>=2)error("ifplot : invalid argument");
                         list=(LIST)BDY(arg);            else v[i++]=vl0->v;
                         if(OID(BDY(BDY(list)))==O_P)          }
                                 if(ri>1) error("ifplot : invalid argument");        }
                                 else range[ri++]=list;        found_f = 1;
                         else geom=list;        break;
                         break;      case O_LIST:
                 case O_N:        list=(LIST)BDY(arg);
                         stream=QTOS((Q)BDY(arg));break;        if(OID(BDY(BDY(list)))==O_P)
                 case O_STR:          if(ri>1) error("ifplot : invalid argument");
                         wname=(STRING)BDY(arg);break;          else range[ri++]=list;
                 default:        else if ( geom )
                         error("ifplot : invalid argument");break;          error("ifplot : Two geometries are specified. Probably a variable is missing.");
                 }        else
         if(!poly) error("ifplot : invalid argument");          geom=list;
         switch(ri){        break;
         case 0:      case O_N:
                 if(!v[1]) error("ifplot : please specify all variables");        if ( !found_f ) {
                 MKV(v[0],var);MKNODE(n,var,defrange);MKLIST(xrange,n);          poly = (Obj)BDY(arg);
                 MKV(v[1],var);MKNODE(n,var,defrange);MKLIST(yrange,n);          found_f = 1;
                 break;        } else stream=QTOS((Q)BDY(arg));
         case 1:        break;
                 if(!v[1]) error("ifplot : please specify all variables");      case O_STR:
                 av[0]=VR((P)BDY(BDY(range[0])));        wname=(STRING)BDY(arg);break;
                 if(v[0]==av[0]){      default:
                         xrange=range[0];        error("ifplot : invalid argument");break;
                         MKV(v[1],var);MKNODE(n,var,defrange);MKLIST(yrange,n);      }
                 } else if(v[1]==av[0]){    if(!found_f) error("ifplot : invalid argument");
                         MKV(v[0],var);MKNODE(n,var,defrange);MKLIST(xrange,n);    switch(ri){
                         yrange=range[0];    case 0:
                 } else error("ifplot : invalid argument");      if(!v[1]) error("ifplot : please specify all variables");
                 break;      MKV(v[0],var);MKNODE(n,var,defrange);MKLIST(xrange,n);
         case 2:      MKV(v[1],var);MKNODE(n,var,defrange);MKLIST(yrange,n);
                 av[0]=VR((P)BDY(BDY(range[0])));      break;
                 av[1]=VR((P)BDY(BDY(range[1])));    case 1:
                 if(((v[0]==av[0])&&(!v[1]||v[1]==av[1]))||      if(!v[1]) error("ifplot : please specify all variables");
                         ((v[0]==av[1])&&(!v[1]||v[1]==av[0]))){      av[0]=VR((P)BDY(BDY(range[0])));
                         xrange=range[0];yrange=range[1];      if(!poly || NUM(poly) || v[0]==av[0]){
                 } else error("ifplot : invalid argument");        xrange=range[0];
                 break;        MKV(v[1],var);MKNODE(n,var,defrange);MKLIST(yrange,n);
         default:      } else if(v[1]==av[0]){
                 error("ifplot : cannot happen");break;        MKV(v[0],var);MKNODE(n,var,defrange);MKLIST(xrange,n);
         }        yrange=range[0];
         /* ifplot in ox_plot requires      } else error("ifplot : invalid argument");
                 [s_id (Q),      break;
                 formula (Obj),    case 2:
                 xrange=[x,xmin,xmax] (LIST),      av[0]=VR((P)BDY(BDY(range[0])));
                 yrange=[y,ymin,ymax] (LIST),      av[1]=VR((P)BDY(BDY(range[1])));
                 zrange=0,      if(!poly || NUM(poly) || (((v[0]==av[0])&&(!v[1]||v[1]==av[1]))||
                 geom=[xsize,ysize] (LIST),        ((v[0]==av[1])&&(!v[1]||v[1]==av[0])))){
                 wname=name (STRING)]        xrange=range[0];yrange=range[1];
         */      } else error("ifplot : invalid argument");
         stream=validate_ox_plot_stream(stream);      break;
         STOQ(stream,s_id);    default:
         if(!geom){      error("ifplot : cannot happen");break;
                 STOQ(300,w300);MKNODE(n0,w300,0);MKNODE(n,w300,n0);MKLIST(geom,n);    }
         }    /* ifplot in ox_plot requires
         if(is_memory){      [s_id (Q),
                 MKSTR(fname,MEMORY_PLOT);      formula (Obj),
                 arg=mknode(8,s_id,fname,poly,xrange,yrange,zrange,geom);      xrange=[x,xmin,xmax] (LIST),
                 Pox_rpc(arg,&t);      yrange=[y,ymin,ymax] (LIST),
                 arg=mknode(1,s_id);      zrange=0,
                 Pox_pop_cmo(arg,rp);      geom=[xsize,ysize] (LIST),
         } else {      wname=name (STRING)]
                 MKSTR(fname,fn);    */
 /*    stream=validate_ox_plot_stream(stream);
 printf("%s\n",fn);    STOQ(stream,s_id);
 ListCheck("xrange",xrange);    if(!geom){
 ListCheck("yrange",yrange);      STOQ(300,w300);MKNODE(n0,w300,0);MKNODE(n,w300,n0);MKLIST(geom,n);
 ListCheck("geom",geom);    }
 */    if(is_memory){
                 arg=mknode(8,s_id,fname,poly,xrange,yrange,zrange,geom,wname);      MKSTR(fname,MEMORY_PLOT);
                 Pox_rpc(arg,&t);      arg=mknode(8,s_id,fname,poly,xrange,yrange,zrange,geom);
                 *rp=(Obj)s_id;      Pox_rpc(arg,&t);
         }      arg=mknode(1,s_id);
       Pox_pop_cmo(arg,rp);
     } else {
       MKSTR(fname,fn);
       arg=mknode(8,s_id,fname,poly,xrange,yrange,zrange,geom,wname);
       Pox_rpc(arg,&t);
       *rp=(Obj)s_id;
     }
 }  }
   
 void Pobj_cp(NODE arg,Obj *rp){  
         //copy canvas  
         //1:and,3:copy,6:xor,7:or  
         Q sysid,index_A,index_B,op_code;  
         STRING fname;  
         Obj t;  
         sysid=(Q)ARG0(arg);  
         index_A=(Q)ARG1(arg);  
         index_B=(Q)ARG2(arg);  
         op_code=(Q)ARG3(arg);  
         MKSTR(fname,OBJ_CP);  
         arg=mknode(5,sysid,fname,index_A,index_B,op_code);  
         Pox_rpc(arg,&t);  
         *rp=(Obj)sysid;  
 }  
   
 void Pconplot(NODE arg,Obj *rp){conplot_main(arg, 0, rp);}  void Pconplot(NODE arg,Obj *rp){conplot_main(arg, 0, rp);}
 void Pmemory_conplot(NODE arg,Obj *rp){conplot_main(arg,1,rp);}  void Pmemory_conplot(NODE arg,Obj *rp){conplot_main(arg,1,rp);}
   
 void conplot_main(NODE arg,int is_memory,Obj *rp){  void conplot_main(NODE arg,int is_memory,Obj *rp){
         int stream,ri,i;    Q m2,p2,w300,s_id;
         Q m2,p2,w300,s_id,mxgc;    NODE defrange;
         NODE defrange,n,n0,n1,n2,n3;    LIST xrange,yrange,zrange,range[3],list,geom;
         LIST xrange,yrange,zrange,range[3],list,geom;    VL vl,vl0;
         VL vl,vl0;    V v[2],av[2];
         V v[2],av[2];    int stream,ri,i;
         P poly,var;    P poly;
         STRING fname,wname;    P var;
         Obj t;    NODE n,n0;
     STRING fname,wname;
     Obj t;
   
         STOQ(-2,m2);STOQ(2,p2);MKNODE(n,p2,0);MKNODE(defrange,m2,n);    STOQ(-2,m2); STOQ(2,p2);
         poly=0;vl=0;geom=0;wname=0;stream=-1;ri=0;v[0]=v[1]=0;    MKNODE(n,p2,0); MKNODE(defrange,m2,n);
         for(;arg;arg=NEXT(arg))    poly = 0; vl = 0; geom = 0; wname = 0; stream = -1; ri = 0;
                 if(!BDY(arg)) stream=0;    v[0] = v[1] = 0;
                 else switch (OID(BDY(arg))){    for ( ; arg; arg = NEXT(arg) )
                         case O_P:      if ( !BDY(arg) )
                                 poly=(P)BDY(arg);        stream = 0;
                                 get_vars_recursive((Obj)poly,&vl);      else
                                 for(vl0=vl,i=0;vl0;vl0=NEXT(vl0)){      switch ( OID(BDY(arg)) ) {
                                         if(vl0->v->attr==(pointer)V_IND){        case O_P:
                                                 if(i>=2){          poly = (P)BDY(arg);
                                                         error("conplot : invalid argument");          get_vars_recursive((Obj)poly,&vl);
                                                 } else v[i++]=vl0->v;          for ( vl0 = vl, i = 0; vl0; vl0 = NEXT(vl0) )
                                         }            if ( vl0->v->attr == (pointer)V_IND )
                                 }              if ( i >= 2 )
                                 break;                error("ifplot : invalid argument");
                         case O_LIST:              else
                                 list=(LIST)BDY(arg);                v[i++] = vl0->v;
                                 if(OID(BDY(BDY(list)))==O_P)          break;
                                         if(ri>2) error("conplot : invalid argument");        case O_LIST:
                                         else range[ri++]=list;          list = (LIST)BDY(arg);
                                 else geom=list;          if ( OID(BDY(BDY(list))) == O_P ) {
                                 break;            if ( ri > 2 )
                         case O_N:              error("ifplot : invalid argument");
                                 stream=QTOS((Q)BDY(arg));            else
                                 break;              range[ri++] = list;
                         case O_STR:          } else if ( geom )
                                 wname=(STRING)BDY(arg);            error("conplot : Two geometries are specified. Probably a variable is missing.");
                                 break;          else
                         default:            geom = list;
                                 error("conplot : invalid argument");          break;
                                 break;        case O_N:
                 }          stream = QTOS((Q)BDY(arg)); break;
         if(!poly) error("conplot : invalid argument");        case O_STR:
         // list format var,num,num[,num]          wname = (STRING)BDY(arg); break;
         switch (ri){        default:
                 case 0:          error("ifplot : invalid argument"); break;
                         if(!v[1]) error("conplot : please specify all variables");      }
                         MKV(v[0],var);MKNODE(n,var,defrange);MKLIST(xrange,n);    if ( !poly )
                         MKV(v[1],var);MKNODE(n,var,defrange);MKLIST(yrange,n);      error("ifplot : invalid argument");
                         STOQ(MAXGC,mxgc);MKNODE(n1,mxgc,0);MKNODE(n2,p2,n1);MKNODE(n3,p2,n2);    switch ( ri ) {
                         MKLIST(zrange,n3);      case 0:
                         break;        if ( !v[1] )
                 case 1:          error("ifplot : please specify all variables");
                         if(!v[1]) error("conplot : please specify all variables");        MKV(v[0],var); MKNODE(n,var,defrange); MKLIST(xrange,n);
                         av[0]=VR((P)BDY(BDY(range[0])));        MKV(v[1],var); MKNODE(n,var,defrange); MKLIST(yrange,n);
                         if(v[0]==av[0]){        MKNODE(n,0,defrange); MKLIST(zrange,n);
                                 xrange=range[0];        break;
                                 MKV(v[1],var);MKNODE(n,var,defrange);MKLIST(yrange,n);      case 1:
                                 STOQ(MAXGC,mxgc);MKNODE(n1,mxgc,0);MKNODE(n2,p2,n1);MKNODE(n3,p2,n2);        if ( !v[1] )
                                 MKLIST(zrange,n3);          error("ifplot : please specify all variables");
                         } else if(v[1]==av[0]){        av[0] = VR((P)BDY(BDY(range[0])));
                                 MKV(v[0],var);MKNODE(n,var,defrange);MKLIST(xrange,n);        if ( v[0] == av[0] ) {
                                 yrange=range[0];          xrange = range[0];
                                 STOQ(MAXGC,mxgc);MKNODE(n1,mxgc,0);MKNODE(n2,p2,n1);MKNODE(n3,p2,n2);          MKV(v[1],var); MKNODE(n,var,defrange); MKLIST(yrange,n);
                                 MKLIST(zrange,n3);          MKNODE(n,0,defrange); MKLIST(zrange,n);
                         } else {        } else if ( v[1] == av[0] ) {
                                 MKV(v[0],var);MKNODE(n,var,defrange);MKLIST(xrange,n);          MKV(v[0],var); MKNODE(n,var,defrange); MKLIST(xrange,n);
                                 MKV(v[1],var);MKNODE(n,var,defrange);MKLIST(yrange,n);          yrange = range[0];
                                 n=NEXT((NODE)BDY(range[0]));          MKNODE(n,0,defrange); MKLIST(zrange,n);
                                 for(i=0,n1=n;n1;n1=NEXT(n1),i++);        } else {
                                 if(i==3)MKLIST(zrange,n);          MKV(v[0],var); MKNODE(n,var,defrange); MKLIST(xrange,n);
                                 else if(i==2){          MKV(v[1],var); MKNODE(n,var,defrange); MKLIST(yrange,n);
                                         n1=(NODE)BDY(n);          zrange = range[0];
                                         n2=(NODE)(BDY(NEXT(n)));        }
                                         STOQ(MAXGC,mxgc);MKNODE(n,mxgc,0);        break;
                                         MKNODE(n3,n1,n);      case 2: case 3:
                                         MKNODE(n1,n2,n3);        av[0] = VR((P)BDY(BDY(range[0])));
                                         MKLIST(zrange,n1);        av[1] = VR((P)BDY(BDY(range[1])));
                                 } else error("conplot : zrange error");        if ( ((v[0] == av[0]) && (!v[1] || v[1] == av[1])) ||
                         }           ((v[0] == av[1]) && (!v[1] || v[1] == av[0])) ) {
                         break;          xrange = range[0]; yrange = range[1];
                 case 2:          if ( ri == 3 )
                 case 3:            zrange = range[2];
                         av[0]=VR((P)BDY(BDY(range[0])));          else {
                         av[1]=VR((P)BDY(BDY(range[1])));            MKNODE(n,0,defrange); MKLIST(zrange,n);
                         if(((v[0]==av[0])&&(!v[1]||v[1]==av[1]))||          }
                                 ((v[0]==av[1])&&(!v[1]||v[1]==av[0]))){        } else
                                 xrange=range[0];          error("ifplot : invalid argument");
                                 yrange=range[1];        break;
                                 if(ri==3) MKLIST(zrange,NEXT(BDY(range[2])));      default:
                                 else {        error("ifplot : cannot happen"); break;
                                         for(i=0,n=(NODE)BDY(range[0]);n;n=NEXT(n),i++);    }
                                         MKNODE(n,0,defrange);    /* conplot in ox_plot requires
                                         MKLIST(zrange,n);       [s_id (Q),
                                 }         formula (Obj),
                         } else error("conplot : invalid argument");         xrange=[x,xmin,xmax] (LIST),
                         break;         yrange=[y,ymin,ymax] (LIST),
                 default:         zrange=[z,zmin,zmax] (LIST),
                         error("conplot : cannot happen");         geom=[xsize,ysize] (LIST),
                         break;         wname=name (STRING)]
         }    */
         /* conplot in ox_plot requires  
            [s_id (Q),    stream = validate_ox_plot_stream(stream);
                 formula (Obj),    STOQ(stream,s_id);
                 xrange=[x,xmin,xmax] (LIST),    if ( !geom ) {
                 yrange=[y,ymin,ymax] (LIST),      STOQ(300,w300);
                 zrange=[z,zmin,zmax,nstep] (LIST),z:dummy var      MKNODE(n0,w300,0); MKNODE(n,w300,n0); MKLIST(geom,n);
                 geom=[xsize,ysize] (LIST),    }
                 wname=name (STRING)]    if ( is_memory ) {
         */      MKSTR(fname,"memory_plot");
         stream=validate_ox_plot_stream(stream);      arg = mknode(7,s_id,fname,poly,xrange,yrange,zrange,geom);
         STOQ(stream,s_id);      Pox_rpc(arg,&t);
         if(!geom){      arg = mknode(1,s_id);
                 STOQ(300,w300);      Pox_pop_cmo(arg,rp);
                 MKNODE(n0,w300,0);    } else {
                 MKNODE(n,w300,n0);      MKSTR(fname,CONPLOT);
                 MKLIST(geom,n);      arg = mknode(8,s_id,fname,poly,xrange,yrange,zrange,geom,wname);
         }      Pox_rpc(arg,&t);
         if(is_memory){      *rp = (Obj)s_id;
                 MKSTR(fname,MEMORY_PLOT);    }
                 arg=mknode(7,s_id,fname,poly,xrange,yrange,zrange,geom);  
                 Pox_rpc(arg,&t);  
                 arg=mknode(1,s_id);  
                 Pox_pop_cmo(arg,rp);  
         } else {  
                 //list check  
                 for(i=0,n=(NODE)BDY(xrange);n;i++,n=NEXT(n));  
                 if(i!=3)error("conplot : xrange error");  
                 for(i=0,n=(NODE)BDY(yrange);n;i++,n=NEXT(n));  
                 if(i!=3)error("conplot : yrange error");  
                 for(i=0,n=(NODE)BDY(zrange);n;i++,n=NEXT(n));  
                 if(i!=3)error("conplot : xrange error");  
                 MKSTR(fname,CONPLOT);  
                 arg=mknode(8,s_id,fname,poly,xrange,yrange,zrange,geom,wname);  
                 Pox_rpc(arg,&t);  
                 *rp=(Obj)s_id;  
         }  
 }  }
   
 void Pplot(NODE arg,Obj *rp){plot_main(arg,0,PLOT,rp);}  void Pplot(NODE arg,Obj *rp){plot_main(arg,0,PLOT,rp);}
 void Pmemory_plot(NODE arg,Obj *rp){plot_main(arg,1,PLOT,rp);}  void Pmemory_plot(NODE arg,Obj *rp){plot_main(arg,1,PLOT,rp);}
   
   int plot_by_bigfloat;
   
 void plot_main(NODE arg,int is_memory,char *fn,Obj *rp){  void plot_main(NODE arg,int is_memory,char *fn,Obj *rp){
         Q m2,p2,w300,s_id;    Q m2,p2,w300,s_id;
         NODE defrange;    NODE defrange;
         LIST xrange,range[1],list,geom;    LIST xrange,range[1],list,geom;
         VL vl,vl0;    VL vl,vl0;
         V v[1],av[1];    V v[1],av[1];
         int stream,ri,i;    int stream,ri,i,found_f;
         P poly;    Obj func;
         P var;    P var;
         NODE n,n0;    NODE n,n0;
         STRING fname,wname;    STRING fname,wname;
         Obj t;    Obj t;
     Q prec;
   
         STOQ(-2,m2);STOQ(2,p2);    STOQ(-2,m2);STOQ(2,p2);
         MKNODE(n,p2,0);MKNODE(defrange,m2,n);    MKNODE(n,p2,0);MKNODE(defrange,m2,n);
         poly=0;vl=0;geom=0;wname=0;stream=-1;ri=0;    func=0;vl=0;geom=0;wname=0;stream=-1;ri=0;
         v[0]=0;    v[0]=0;
         for(;arg;arg=NEXT(arg) )    found_f = 0;
                 if(!BDY(arg) )    for(;arg;arg=NEXT(arg) ) {
                         stream=0;      if(!BDY(arg) )
                 else        if ( !found_f ) {
                 switch ( OID(BDY(arg)) ){          makevar("x",&var);
                         case O_P: case O_R:          v[0] = VR(var);
                                 poly=(P)BDY(arg);          found_f = 1;
                                 get_vars_recursive((Obj)poly,&vl);        } else
                                 for(vl0=vl, i=0;vl0;vl0=NEXT(vl0) ){          stream=0;
                                         if(vl0->v->attr==(pointer)V_IND ){      else
                                                 if(i >= 1 ) error("ifplot : invalid argument");      switch ( OID(BDY(arg)) ){
                                                 else v[i++]=vl0->v;        case O_P: case O_R:
                                         }          func = (Obj)BDY(arg);
                                 }          get_vars_recursive(func,&vl);
                                 if(i != 1 ) error("ifplot : invalid argument");          for(vl0=vl, i=0;vl0;vl0=NEXT(vl0) ){
                                 break;            if(vl0->v->attr==(pointer)V_IND ){
                         case O_LIST:              if(i >= 1 ) error("plot : function must be univariate");
                                 list=(LIST)BDY(arg);              else v[i++]=vl0->v;
                                 if(OID(BDY(BDY(list)))==O_P ){            }
                                         if(ri > 0 ) error("plot : invalid argument");          }
                                         else range[ri++]=list;          found_f = 1;
                                 } else geom=list;          break;
                                 break;        case O_LIST:
                         case O_N:          list=(LIST)BDY(arg);
                                 stream=QTOS((Q)BDY(arg));break;          if(OID(BDY(BDY(list)))==O_P ){
                         case O_STR:            if(ri > 0 ) error("plot : too many intervals");
                                 wname=(STRING)BDY(arg);break;            else range[ri++]=list;
                         default:          } else geom=list;
                                 error("plot : invalid argument");break;          break;
                 }        case O_N:
         if(!poly )          if ( !found_f ) {
                 error("plot : invalid argument");            func = (Obj)BDY(arg);
         switch ( ri ){            makevar("x",&var);
                 case 0:            v[0] = VR(var);
                         MKV(v[0],var);MKNODE(n,var,defrange);MKLIST(xrange,n);            found_f = 1;
                         break;          } else
                 case 1:            stream=QTOS((Q)BDY(arg));
                         av[0]=VR((P)BDY(BDY(range[0])));          break;
                         if(v[0]==av[0] )        case O_STR:
                                 xrange=range[0];          wname=(STRING)BDY(arg);break;
                         else        default:
                                 error("plot : invalid argument");          error("plot : invalid argument");break;
                         break;      }
                 default:    }
                         error("plot : cannot happen");break;    if(!found_f )
         }      error("plot : invalid argument");
         /* conplot in ox_plot requires    switch ( ri ){
            [s_id (Q),      case 0:
                 formula (Obj),        MKV(v[0],var);MKNODE(n,var,defrange);MKLIST(xrange,n);
                 xrange=[x,xmin,xmax] (LIST),        break;
                 yrange=0,      case 1:
                 zrange=0,        av[0]=VR((P)BDY(BDY(range[0])));
                 geom=[xsize,ysize] (LIST),        if(!func || NUM(func) || v[0]==av[0] )
                 wname=name (STRING)]          xrange=range[0];
         */        else
         stream=validate_ox_plot_stream(stream);          error("plot : invalid argument");
         STOQ(stream,s_id);        break;
         if(!geom ){      default:
                 STOQ(300,w300);        error("plot : cannot happen");break;
                 MKNODE(n0,w300,0);MKNODE(n,w300,n0);MKLIST(geom,n);    }
         }    /* conplot in ox_plot requires
         if(is_memory ){       [s_id (Q),
                 MKSTR(fname,MEMORY_PLOT);         formula (Obj),
                 arg=mknode(7,s_id,fname,poly,xrange,NULLP,NULLP,geom);         xrange=[x,xmin,xmax] (LIST),
                 Pox_rpc(arg,&t);         yrange=0,
                 arg=mknode(1,s_id);         zrange=0,
                 Pox_pop_cmo(arg,rp);         geom=[xsize,ysize] (LIST),
         } else {         wname=name (STRING)]
                 MKSTR(fname,fn);    */
                 arg=mknode(8,s_id,fname,poly,xrange,NULLP,NULLP,geom,wname);    stream=validate_ox_plot_stream(stream);
                 Pox_rpc(arg,&t);    STOQ(stream,s_id);
                 *rp=(Obj)s_id;    if(!geom ){
         }      STOQ(300,w300);
       MKNODE(n0,w300,0);MKNODE(n,w300,n0);MKLIST(geom,n);
     }
     if(plot_by_bigfloat)
       STOQ(plot_by_bigfloat,prec);
     else
       prec = 0;
     if(is_memory ){
       MKSTR(fname,MEMORY_PLOT);
       arg=mknode(8,s_id,fname,func,xrange,NULLP,NULLP,geom,prec);
       Pox_rpc(arg,&t);
       arg=mknode(1,s_id);
       Pox_pop_cmo(arg,rp);
     } else {
       MKSTR(fname,fn);
       arg=mknode(9,s_id,fname,func,xrange,NULLP,NULLP,geom,wname,prec);
       Pox_rpc(arg,&t);
       *rp=(Obj)s_id;
     }
 }  }
   
 #define Pi 3.14159265358979323846264  #define Pi 3.14159265358979323846264
   
 void Ppolarplot(NODE arg,Obj *rp){  void Ppolarplot(NODE arg,Obj *rp){
         Q m2,p2,w300,defstep,s_id,color;    Q m2,p2,w300,s_id;
         NODE defrange,n,n0,n1,n2;    NODE defrange,n,n0;
         LIST range,geom,list[2];    LIST zrange,range[1],geom,list;
         VL vl,vl0;    VL vl,vl0;
         V v[1],av;    V v[1],av[1];
         int stream,ri,i,len,iNo,lNo,vNo,sNo,pfine,findG;    int stream,ri,i;
         P poly,var;    P poly,var;
         STRING fname,wname;    STRING fname,wname;
         Real pi2;    Real pi2;
         Obj t,frst,sec,thr;;    Obj t;
         char ebuf[BUFSIZ];  
   
         iNo=lNo=sNo=findG=0;pfine=TRUE;    MKReal(2*Pi,pi2);MKNODE(n,pi2,0); MKNODE(defrange,0,n);
         poly=0;vl=0;geom=0;wname=0;color=0;stream=-1;ri=0;v[0]=0;    poly=0;vl=0;geom=0;wname=0;stream=-1;ri=0;v[0]=0;
         for(;arg;arg=NEXT(arg)){    for(;arg;arg=NEXT(arg)){
                 if(!BDY(arg)) iNo++;      if(!BDY(arg)) stream=0;
                 else switch(OID(BDY(arg))){      else switch(OID(BDY(arg))){
                 case O_P: case O_R://formular      case O_P: case O_R://formula
                         poly=(P)BDY(arg);        poly=(P)BDY(arg);
                         get_vars_recursive((Obj)poly,&vl);        get_vars_recursive((Obj)poly,&vl);
                         for(vl0=vl,vNo=0;vl0;vl0=NEXT(vl0)){        for(vl0=vl,i=0;vl0;vl0=NEXT(vl0))
                                 if(vl0->v->attr==(pointer)V_IND){          if(vl0->v->attr==(pointer)V_IND)
                                         if(vNo>=1){            if(i>=1)error("polarplot : invalid argument");
                                                 sprintf(ebuf,"%s : invalaid argument",POLARPLOT);          else v[i++]=vl0->v;
                                                 error(ebuf);        if(i!=1)error("polarplot : invalid argument");
                                         } else v[vNo++]=vl0->v;        break;
                                 }      case O_LIST://range,geomerty
                         }        list=(LIST)BDY(arg);
                         if(vNo!=1){        if(OID(BDY(BDY(list)))==O_P)
                                 sprintf(ebuf,"%s : only uni-variate formular",POLARPLOT);          if(ri>0)error("polarplot : invalid argument");
                                 error(ebuf);          else range[ri++]=list;
                         }        else geom=list;
                         break;        break;
                 case O_N://color,id,idx,division      case O_N:
                         switch (iNo){        stream=QTOS((Q)BDY(arg));
                         case 0://color arg        break;
                                 color=(Q)BDY(arg);      case O_STR://wname
                                 iNo++;        wname=(STRING)BDY(arg);
                                 break;        break;
                         case 1://stream arg      default:
                                 stream=QTOS((Q)BDY(arg));        error("polarplot : invalid argument");
                                 iNo++;        break;
                                 break;      }
                         default://error    }
                                 sprintf(ebuf,"%s : invalid number arguments",POLARPLOT);    //formular check
                                 error(ebuf);    if(!poly)error("polarplot : invalid argument");
                                 break;    switch (ri){
                         }    case 0:
                         break;      MKV(v[0],var); MKNODE(n,var,defrange); MKLIST(zrange,n);
                 case O_LIST://range,geomerty      break;
                         if(lNo<2)list[lNo++]=(LIST)BDY(arg);    case 1:
                         else {      av[0]=VR((P)BDY(BDY(range[0])));
                                 sprintf(ebuf,"%s : invalid list argument",POLARPLOT);      if(v[0]==av[0]) zrange = range[0];
                                 error(ebuf);      else error("polarplot : invalid argument");
                         }      break;
                         break;    default:
                 case O_STR://wname      error("polarplot : cannot happen");
                         wname=(STRING)BDY(arg);      break;
                         sNo++;    }
                         break;    stream=validate_ox_plot_stream(stream);
                 default:    STOQ(stream,s_id);
                         break;    if(!geom){
                 }      STOQ(300,w300);
         }      MKNODE(n0,w300,0); MKNODE(n,w300,n0); MKLIST(geom,n);
         //formular check    }
         if(!poly){    MKSTR(fname,POLARPLOT);
                 sprintf(ebuf,"%s : invalid ploy argument",POLARPLOT);    arg=mknode(8,s_id,fname,poly,NULLP,NULLP,zrange,geom,wname);
                 error(ebuf);    Pox_rpc(arg,&t);
         }    *rp=s_id;
         //vars check  
         get_vars_recursive((Obj)poly,&vl);  
         for(vl0=vl,vNo=0;vl0;vNo++,vl0=NEXT(vl0)){  
                 if(vl0->v->attr==(pointer)V_IND){  
                         if(vNo>=2){  
                                 sprintf(ebuf,"%s : invalid ploy argument",POLARPLOT);  
                                 error(ebuf);  
                         } else v[vNo]=vl0->v;  
                 }  
         }  
         //list check  
         for(i=0;i<lNo;i++){  
                 if(OID(BDY(BDY(list[i])))!=O_P){  
                         // list first value is number (geometry)  
                         for(len=0,n=(NODE)BDY(list[i]);n;len++,n=NEXT(n)){  
                                 if(len==0) frst=BDY(n);  
                                 else if(len==1) sec=BDY(n);  
                                 else {  
                                         sprintf(ebuf,"%s : geometry list too long",POLARPLOT);  
                                         error(ebuf);  
                                 }  
                         }  
                         if(len!=2){  
                                 sprintf(ebuf,"%s : geometry requierd 2 numbers", POLARPLOT);  
                                 error(ebuf);  
                         } else geom=list[i];  
                 } else {  
                         //list first value is var (range)  
                         av=VR((P)BDY(BDY(list[i])));  
                         if(v[0]==av)range=list[i];  
                         else {  
                                 sprintf(ebuf,"%s : invalid list length",POLARPLOT);  
                                 error(ebuf);  
                         }  
                 }  
         }  
         // set default  
         if(!range){  
                 STOQ(DEFAULTPOLARSTEP,defstep);MKReal(2*Pi,pi2);MKV(v[0],var);  
                 MKNODE(n,defstep,0);MKNODE(n1,pi2,n);MKNODE(n2,0,n1);  
                 MKNODE(defrange,var,n2);MKLIST(range,defrange);  
         }  
         if(!geom){  
                 STOQ(300,w300);MKNODE(n0,w300,0);MKNODE(n,w300,n0);MKLIST(geom,n);  
         }  
         stream=validate_ox_plot_stream(stream);  
         STOQ(stream,s_id);  
         MKSTR(fname,POLARPLOT);  
         arg=mknode(7,s_id,fname,poly,color,range,geom,wname);  
         Pox_rpc(arg,&t);  
         *rp=(Obj)s_id;  
 }  }
   
 void Pplotover(NODE arg,Obj *rp){  void Pplotover(NODE arg,Obj *rp){
         Q s_id,w_id,color;    Q s_id,w_id,color;
         P poly;    P poly;
         STRING fname;    STRING fname;
         Obj t;    Obj t;
         poly=(P)ARG0(arg);    poly=(P)ARG0(arg);
         s_id=(Q)ARG1(arg);    s_id=(Q)ARG1(arg);
         w_id=(Q)ARG2(arg);    w_id=(Q)ARG2(arg);
         if(argc(arg)==4)color=(Q)ARG3(arg);    if(argc(arg)==4)color=(Q)ARG3(arg);
         else color=0;    else color=0;
         MKSTR(fname,PLOTOVER);    MKSTR(fname,PLOTOVER);
         arg=mknode(5,s_id,fname,w_id,poly,color);    arg=mknode(5,s_id,fname,w_id,poly,color);
         Pox_rpc(arg,&t);    Pox_rpc(arg,&t);
         *rp=(Obj)s_id;    *rp=(Obj)s_id;
 }  }
   
 void Pdrawcircle(NODE arg,Obj *rp){  void Pdrawcircle(NODE arg,Obj *rp){
         Q s_id,index;    Q s_id,index;
         Obj x,y,r,c,t;    Obj x,y,r,c,t;
         STRING fname;    STRING fname;
         NODE n;    NODE n;
         LIST pos;    LIST pos;
   
         x=(Obj)ARG0(arg);    x=(Obj)ARG0(arg);
         y=(Obj)ARG1(arg);    y=(Obj)ARG1(arg);
         r=(Obj)ARG2(arg);    r=(Obj)ARG2(arg);
         c=(Obj)ARG3(arg);    c=(Obj)ARG3(arg);
         s_id=(Q)ARG4(arg);    s_id=(Q)ARG4(arg);
         index=(Q)ARG5(arg);    index=(Q)ARG5(arg);
         MKSTR(fname,DRAWCIRCLE);    MKSTR(fname,DRAWCIRCLE);
         n=mknode(3,x,y,r,c);    n=mknode(3,x,y,r,c);
         MKLIST(pos,n);    MKLIST(pos,n);
         arg=mknode(5,s_id,fname,index,pos,c);    arg=mknode(5,s_id,fname,index,pos,c);
         Pox_rpc(arg,&t);    Pox_rpc(arg,&t);
         *rp=(Obj)s_id;    *rp=(Obj)s_id;
 }  }
   
 void Pdraw_obj(NODE arg,Obj *rp){  void Pdraw_obj(NODE arg,Obj *rp){
         static STRING fname;    static STRING fname;
         Q s_id,index;    Q s_id,index;
         LIST obj;    LIST obj;
         Obj t;    Obj t;
   
         if(!fname)MKSTR(fname,DRAW_OBJ);    if(!fname)MKSTR(fname,DRAW_OBJ);
         s_id=(Q)ARG0(arg);    s_id=(Q)ARG0(arg);
         index=(Q)ARG1(arg);    index=(Q)ARG1(arg);
         obj=(LIST)ARG2(arg);    obj=(LIST)ARG2(arg);
         // ARG3(arg)=color    // ARG3(arg)=color
         if(argc(arg)==4) arg=mknode(5,s_id,fname,index,obj,ARG3(arg));    if(argc(arg)==4) arg=mknode(5,s_id,fname,index,obj,ARG3(arg));
         else arg=mknode(4,s_id,fname,index,obj);    else arg=mknode(4,s_id,fname,index,obj);
         Pox_cmo_rpc(arg,&t);    Pox_cmo_rpc(arg,&t);
         *rp=(Obj)s_id;    *rp=(Obj)s_id;
 }  }
   
 void Pdraw_string(NODE arg,Obj *rp){  void Pdraw_string(NODE arg,Obj *rp){
         static STRING fname;    static STRING fname;
         STRING str;    STRING str;
         Q s_id,index;    Q s_id,index;
         LIST pos;    LIST pos;
         Obj t;    Obj t;
   
         if(!fname)MKSTR(fname,DRAW_STRING);    if(!fname)MKSTR(fname,DRAW_STRING);
         s_id=(Q)ARG0(arg);    s_id=(Q)ARG0(arg);
         index=(Q)ARG1(arg);    index=(Q)ARG1(arg);
         pos=(LIST)ARG2(arg);    pos=(LIST)ARG2(arg);
         str=(STRING)ARG3(arg);    str=(STRING)ARG3(arg);
         // ARG4(arg)=color    // ARG4(arg)=color
         if(argc(arg)==5) arg=mknode(6,s_id,fname,index,pos,str,ARG4(arg));    if(argc(arg)==5) arg=mknode(6,s_id,fname,index,pos,str,ARG4(arg));
         else arg=mknode(5,s_id,fname,index,pos,str);    else arg=mknode(5,s_id,fname,index,pos,str);
         Pox_cmo_rpc(arg,&t);    Pox_cmo_rpc(arg,&t);
         *rp=(Obj)s_id;    *rp=(Obj)s_id;
 }  }
   
 void Pclear_canvas(NODE arg,Obj *rp){  void Pclear_canvas(NODE arg,Obj *rp){
         static STRING fname;    static STRING fname;
         Q s_id,index;    Q s_id,index;
         Obj t;    Obj t;
   
         if(!fname) MKSTR(fname,CLEAR_CANVAS);    if(!fname) MKSTR(fname,CLEAR_CANVAS);
         s_id=(Q)ARG0(arg);    s_id=(Q)ARG0(arg);
         index=(Q)ARG1(arg);    index=(Q)ARG1(arg);
         arg=mknode(3,s_id,fname,index);    arg=mknode(3,s_id,fname,index);
         Pox_cmo_rpc(arg,&t);    Pox_cmo_rpc(arg,&t);
         *rp=(Obj)s_id;    *rp=(Obj)s_id;
 }  }
 //****************************ifplotNG  //****************************ifplotNG
 /*  /*
Line 778  void Pclear_canvas(NODE arg,Obj *rp){
Line 727  void Pclear_canvas(NODE arg,Obj *rp){
  *  B:Boundary character use sturm theorem   *  B:Boundary character use sturm theorem
  */   */
 void ListCheck(char * head,LIST list){  void ListCheck(char * head,LIST list){
         int i;    int i;
         NODE n;    NODE n;
         if(!list){    if(!list){
                 printf("%s zero \n",head);      printf("%s zero \n",head);
                 return;      return;
         }    }
         for(i=0,n=(NODE)BDY(list);n;i++,n=NEXT(n));    for(i=0,n=(NODE)BDY(list);n;i++,n=NEXT(n));
         printf("%s length %d\n",head,i);    printf("%s length %d\n",head,i);
         for(i=0,n=(NODE)BDY(list);n;i++,n=NEXT(n)){    for(i=0,n=(NODE)BDY(list);n;i++,n=NEXT(n)){
                 if(!BDY(n))printf("%d 0\n",i);      if(!BDY(n))printf("%d 0\n",i);
                 else if(OID(BDY(n))==O_P) printf("%d poly\n",i);      else if(OID(BDY(n))==O_P) printf("%d poly\n",i);
                 else if(OID(BDY(n))==O_R) printf("%d real\n",i);      else if(OID(BDY(n))==O_R) printf("%d real\n",i);
                 else if(OID(BDY(n))==O_N) printf("%d %d\n",i,QTOS((Q)BDY(n)));      else if(OID(BDY(n))==O_N) printf("%d %d\n",i,QTOS((Q)BDY(n)));
         }    }
 }  }
   
 void PifplotD(NODE arg,Obj *rp){ifplot_mainNG(arg,IFPLOTD,rp);}  void PifplotD(NODE arg,Obj *rp){ifplot_mainNG(arg,IFPLOTD,rp);}
Line 826  void PplotoverD(NODE arg,Obj *rp){plotover_mainNG(arg,
Line 775  void PplotoverD(NODE arg,Obj *rp){plotover_mainNG(arg,
 void PplotoverQ(NODE arg,Obj *rp){plotover_mainNG(arg,PLOTOVERQ,rp);}  void PplotoverQ(NODE arg,Obj *rp){plotover_mainNG(arg,PLOTOVERQ,rp);}
 void PplotoverB(NODE arg,Obj *rp){plotover_mainNG(arg,PLOTOVERB,rp);}  void PplotoverB(NODE arg,Obj *rp){plotover_mainNG(arg,PLOTOVERB,rp);}
   
   void Pobj_cp(NODE arg,Obj *rp){
     //copy canvas
     //1:and,3:copy,6:xor,7:or
     Q sysid,index_A,index_B,op_code;
     STRING fname;
     Obj t;
     sysid=(Q)ARG0(arg);
     index_A=(Q)ARG1(arg);
     index_B=(Q)ARG2(arg);
     op_code=(Q)ARG3(arg);
     MKSTR(fname,OBJ_CP);
     arg=mknode(5,sysid,fname,index_A,index_B,op_code);
     Pox_rpc(arg,&t);
     *rp=(Obj)sysid;
   }
   
   void PpolarplotD(NODE arg,Obj *rp){
     Q m2,p2,w300,defstep,s_id,color;
     NODE defrange,n,n0,n1,n2;
     LIST range,geom,list[2];
     VL vl,vl0;
     V v[1],av;
     int stream,ri,i,len,iNo,lNo,vNo,sNo,pfine,findG;
     P poly,var;
     STRING fname,wname;
     Real pi2;
     Obj t,frst,sec,thr;
     char ebuf[BUFSIZ];
   
     iNo=lNo=sNo=findG=0;pfine=TRUE;
     poly=0;vl=0;geom=0;wname=0;color=0;stream=-1;ri=0;v[0]=0;
     for(;arg;arg=NEXT(arg)){
       if(!BDY(arg)) iNo++;
       else switch(OID(BDY(arg))){
       case O_P: case O_R://formular
         poly=(P)BDY(arg);
         get_vars_recursive((Obj)poly,&vl);
         for(vl0=vl,vNo=0;vl0;vl0=NEXT(vl0)){
           if(vl0->v->attr==(pointer)V_IND){
             if(vNo>=1){
               sprintf(ebuf,"%s : invalaid argument",POLARPLOT);
               error(ebuf);
             } else v[vNo++]=vl0->v;
           }
         }
         if(vNo!=1){
           sprintf(ebuf,"%s : only uni-variate formular",POLARPLOT);
           error(ebuf);
         }
         break;
       case O_N://color,id,idx,division
         switch (iNo){
         case 0://color arg
           color=(Q)BDY(arg);
           iNo++;
           break;
         case 1://stream arg
           stream=QTOS((Q)BDY(arg));
           iNo++;
           break;
         default://error
           sprintf(ebuf,"%s : invalid number arguments",POLARPLOT);
           error(ebuf);
           break;
         }
         break;
       case O_LIST://range,geomerty
         if(lNo<2)list[lNo++]=(LIST)BDY(arg);
         else {
           sprintf(ebuf,"%s : invalid list argument",POLARPLOT);
           error(ebuf);
         }
         break;
       case O_STR://wname
         wname=(STRING)BDY(arg);
         sNo++;
         break;
       default:
         break;
       }
     }
     //formular check
     if(!poly){
       sprintf(ebuf,"%s : invalid plot argument",POLARPLOT);
       error(ebuf);
     }
     //vars check
     get_vars_recursive((Obj)poly,&vl);
     for(vl0=vl,vNo=0;vl0;vNo++,vl0=NEXT(vl0)){
       if(vl0->v->attr==(pointer)V_IND){
         if(vNo>=2){
           sprintf(ebuf,"%s : invalid plot argument",POLARPLOT);
           error(ebuf);
         } else v[vNo]=vl0->v;
       }
     }
     //list check
     for(i=0;i<lNo;i++){
       if(OID(BDY(BDY(list[i])))!=O_P){
         // list first value is number (geometry)
         for(len=0,n=(NODE)BDY(list[i]);n;len++,n=NEXT(n)){
           if(len==0) frst=BDY(n);
           else if(len==1) sec=BDY(n);
           else {
             sprintf(ebuf,"%s : geometry list too long",POLARPLOT);
             error(ebuf);
           }
         }
         if(len!=2){
           sprintf(ebuf,"%s : geometry requierd 2 numbers", POLARPLOT);
           error(ebuf);
         } else geom=list[i];
       } else {
         //list first value is var (range)
         av=VR((P)BDY(BDY(list[i])));
         if(v[0]==av)range=list[i];
         else {
           sprintf(ebuf,"%s : invalid list length",POLARPLOT);
           error(ebuf);
         }
       }
     }
     // set default
     if(!range){
       STOQ(DEFAULTPOLARSTEP,defstep);MKReal(2*Pi,pi2);MKV(v[0],var);
       MKNODE(n,defstep,0);MKNODE(n1,pi2,n);MKNODE(n2,0,n1);
       MKNODE(defrange,var,n2);MKLIST(range,defrange);
     }
     if(!geom){
       STOQ(300,w300);MKNODE(n0,w300,0);MKNODE(n,w300,n0);MKLIST(geom,n);
     }
     stream=validate_ox_plot_stream(stream);
     STOQ(stream,s_id);
     MKSTR(fname,POLARPLOTD);
     arg=mknode(7,s_id,fname,poly,color,range,geom,wname);
     Pox_rpc(arg,&t);
     *rp=(Obj)s_id;
   }
   
 void ifplot_mainNG(NODE arg,char *fn,Obj *rp){  void ifplot_mainNG(NODE arg,char *fn,Obj *rp){
         Q m2,p2,w300,mxgc,s_id,color;    Q m2,p2,w300,mxgc,s_id,color;
         NODE defrange,n,n0,n1,n2;    NODE defrange,n,n0,n1,n2;
         P poly,var;    P poly,var;
         VL vl,vl0;    VL vl,vl0;
         V v[2],av;    V v[2],av;
         LIST xrange,yrange,zrange,geom,range[2],list[4];    LIST xrange,yrange,zrange,geom,range[2],list[4];
         int stream,ri,i,j,sign,llen,len,iNo,lNo,vNo,sNo,pfine,findG;    int stream,ri,i,j,sign,llen,len,iNo,lNo,vNo,sNo,pfine,findG;
         STRING fname,wname;    STRING fname,wname;
         Obj t,frst,sec,thr;    Obj t,frst,sec,thr;
         char ebuf[BUFSIZ];    char ebuf[BUFSIZ];
   
         iNo=lNo=sNo=findG=0;pfine=TRUE;    iNo=lNo=sNo=findG=0;pfine=TRUE;
         poly=0;stream=-1;wname=0;color=0;stream=0;    poly=0;stream=-1;wname=0;color=0;stream=0;
         STOQ(-2,m2);STOQ(2,p2);MKNODE(n,p2,0);MKNODE(defrange,m2,n);    STOQ(-2,m2);STOQ(2,p2);MKNODE(n,p2,0);MKNODE(defrange,m2,n);
         STOQ(MAXGC,mxgc);    STOQ(MAXGC,mxgc);
         for(;arg;arg=NEXT(arg)){    for(;arg;arg=NEXT(arg)){
                 if(!BDY(arg)) iNo++;      if(!BDY(arg)) iNo++;
                 else switch(OID(BDY(arg))){      else switch(OID(BDY(arg))){
                 case O_P://formular      case O_P://formular
                         if(pfine){        if(pfine){
                                 poly=(P)BDY(arg);          poly=(P)BDY(arg);
                                 pfine=FALSE;          pfine=FALSE;
                         } else {        } else {
                                 sprintf(ebuf,"%s : to many ploy arguments",fn);          sprintf(ebuf,"%s : to many plot arguments",fn);
                                 error(ebuf);          error(ebuf);
                         }        }
                         break;        break;
                 case O_N://color,id,idx,division      case O_N://color,id,idx,division
                         switch (iNo){        switch (iNo){
                         case 0: //color arg        case 0: //color arg
                                 color=(Q)BDY(arg);          color=(Q)BDY(arg);
                                 iNo++;          iNo++;
                                 break;          break;
                         case 1: //stream arg        case 1: //stream arg
                                 stream=QTOS((Q)BDY(arg));          stream=QTOS((Q)BDY(arg));
                                 iNo++;          iNo++;
                                 break;          break;
                         default:        default:
                                 sprintf(ebuf,"%s : invalid number arguments",fn);          sprintf(ebuf,"%s : invalid number arguments",fn);
                                 error(ebuf);          error(ebuf);
                                 break;          break;
                         }        }
                         break;        break;
                 case O_LIST://xrange,yrange,zrange,geometry      case O_LIST://xrange,yrange,zrange,geometry
                         if(lNo<4) list[lNo++]=(LIST)BDY(arg);        if(lNo<4) list[lNo++]=(LIST)BDY(arg);
                         else {        else {
                                 sprintf(ebuf,"%s : invalid list argument",fn);          sprintf(ebuf,"%s : invalid list argument",fn);
                                 error(ebuf);          error(ebuf);
                         }        }
                         break;        break;
                 case O_STR://wname      case O_STR://wname
                         wname=(STRING)BDY(arg);        wname=(STRING)BDY(arg);
                         sNo++;        sNo++;
                         break;        break;
                 default:      default:
                         break;        break;
                 }      }
         }    }
         // formular check    // formular check
         if(!poly){    if(!poly){
                 sprintf(ebuf,"%s : invalid ploy argument",fn);      sprintf(ebuf,"%s : invalid plot argument",fn);
                 error(ebuf);      error(ebuf);
         }    }
         // vars check    // vars check
         get_vars_recursive((Obj)poly,&vl);    get_vars_recursive((Obj)poly,&vl);
         for(vl0=vl,vNo=0;vl0;vl0=NEXT(vl0)){    for(vl0=vl,vNo=0;vl0;vl0=NEXT(vl0)){
                 if(vl0->v->attr==(pointer)V_IND){      if(vl0->v->attr==(pointer)V_IND){
                         if(vNo>=2){        if(vNo>=2){
                                 sprintf(ebuf,"%s : invalid ploy argument",fn);          sprintf(ebuf,"%s : invalid plot argument",fn);
                                 error(ebuf);          error(ebuf);
                         } else v[vNo++]=vl0->v;        } else v[vNo++]=vl0->v;
                 }      }
         }    }
         //list check    //list check
         xrange=yrange=zrange=geom=0;frst=sec=thr=0;    xrange=yrange=zrange=geom=0;frst=sec=thr=0;
         for(i=0;i<lNo;i++){    for(i=0;i<lNo;i++){
                 for(llen=0,n=(NODE)BDY(list[i]);n;llen++,n=NEXT(n));      for(llen=0,n=(NODE)BDY(list[i]);n;llen++,n=NEXT(n));
                 if(llen>4){      if(llen>4){
                         sprintf(ebuf,"%s : invalid list length",fn);        sprintf(ebuf,"%s : invalid list length",fn);
                         error(ebuf);        error(ebuf);
                 }      }
                 if(OID(BDY(BDY(list[i])))!=O_P){      if(OID(BDY(BDY(list[i])))!=O_P){
                         // First list value is number        // First list value is number
                         for(len=0,n=(NODE)BDY(list[i]);n;len++,n=NEXT(n)){        for(len=0,n=(NODE)BDY(list[i]);n;len++,n=NEXT(n)){
                                 if(len==0)frst=BDY(n);          if(len==0)frst=BDY(n);
                                 else if(len==1)sec=BDY(n);          else if(len==1)sec=BDY(n);
                                 else thr=BDY(n);          else thr=BDY(n);
                         }        }
                         switch(len){        switch(len){
                         case 2:        case 2:
                                 if(!strcmp(fn,CONPLOT)){          if(!strcmp(fn,CONPLOT)){
                                         if(thr==0)thr=(Obj)mxgc;            if(thr==0)thr=(Obj)mxgc;
                                         MKNODE(n,thr,0);MKNODE(n1,sec,n);MKNODE(n2,frst,n1);MKLIST(zrange,n2);            MKNODE(n,thr,0);MKNODE(n1,sec,n);MKNODE(n2,frst,n1);MKLIST(zrange,n2);
                                 } else geom=list[i];          } else geom=list[i];
                                 break;          break;
                         case 3:        case 3:
                                 zrange=list[i];          zrange=list[i];
                                 break;          break;
                         case 0:        case 0:
                         case 1:        case 1:
                         default:        default:
                                 sprintf(ebuf,"%s : invalid list length",fn);          sprintf(ebuf,"%s : invalid list length",fn);
                                 error(ebuf);          error(ebuf);
                                 break;          break;
                         }        }
                 } else {      } else {
                         //xrange,yrange        //xrange,yrange
                         av=VR((P)BDY(BDY(list[i])));        av=VR((P)BDY(BDY(list[i])));
                         if(v[0]==av)xrange=list[i];        if(v[0]==av)xrange=list[i];
                         else if(v[1]==av)yrange=list[i];        else if(v[1]==av)yrange=list[i];
                         else {        else {
                                 MKLIST(zrange,NEXT(BDY(list[i])));          MKLIST(zrange,NEXT(BDY(list[i])));
                         }        }
                 }      }
         }    }
         //set default    //set default
         if(!xrange){    if(!xrange){
                 MKV(v[0],var);MKNODE(n,var,defrange);MKLIST(xrange,n);      MKV(v[0],var);MKNODE(n,var,defrange);MKLIST(xrange,n);
         }    }
         if(!yrange){    if(!yrange){
                 MKV(v[1],var);MKNODE(n,var,defrange);MKLIST(yrange,n);      MKV(v[1],var);MKNODE(n,var,defrange);MKLIST(yrange,n);
         }    }
         if(!geom){    if(!geom){
                 STOQ(300,w300);MKNODE(n0,w300,0);MKNODE(n,w300,n0);MKLIST(geom,n);      STOQ(300,w300);MKNODE(n0,w300,0);MKNODE(n,w300,n0);MKLIST(geom,n);
         }    }
         if(!(strcmp(fn,CONPLOTD)&strcmp(fn,CONPLOTQ)&strcmp(fn,CONPLOTB))&!zrange){    if(!(strcmp(fn,CONPLOTD)&strcmp(fn,CONPLOTQ)&strcmp(fn,CONPLOTB))&!zrange){
                 MKNODE(n,mxgc,0);MKNODE(n1,m2,n);MKNODE(n2,m2,n1);MKLIST(zrange,n2);      MKNODE(n,mxgc,0);MKNODE(n1,m2,n);MKNODE(n2,m2,n1);MKLIST(zrange,n2);
         }    }
         /*new ifplot in ox_plot requires    /*new ifplot in ox_plot requires
                 [s_id (Q),      [s_id (Q),
                 formula (Obj),      formula (Obj),
                 color (Q),      color (Q),
                 geom=[xsize,ysize] (LIST optional),      geom=[xsize,ysize] (LIST optional),
                 xrange=[x,xmin,xmax] (LIST optional),      xrange=[x,xmin,xmax] (LIST optional),
                 yrange=[y,ymin,ymax] (LIST optional),      yrange=[y,ymin,ymax] (LIST optional),
                 zrange=[zmin,zmax,zstep] (LIST optional),      zrange=[zmin,zmax,zstep] (LIST optional),
                 wname=name (STRING optional)],      wname=name (STRING optional)],
                 itvstep (Q) if ITVIFPLOT */      itvstep (Q) if ITVIFPLOT */
         stream=validate_ox_plot_stream(stream);    stream=validate_ox_plot_stream(stream);
         STOQ(stream,s_id);    STOQ(stream,s_id);
         MKSTR(fname,fn);    MKSTR(fname,fn);
 /*    arg=mknode(9,s_id,fname,poly,color,xrange,yrange,zrange,geom,wname);
 printf("%s\n",fn);    Pox_rpc(arg,&t);
 ListCheck("xrange",xrange);    *rp=(Obj)s_id;
 ListCheck("yrange",yrange);  
 ListCheck("zrange",zrange);  
 ListCheck("geom",geom);  
 printf("idv %d\n",idv);  
 */  
         arg=mknode(9,s_id,fname,poly,color,xrange,yrange,zrange,geom,wname);  
         Pox_rpc(arg,&t);  
         *rp=(Obj)s_id;  
 }  }
   
 void plotover_mainNG(NODE arg,char *fn,Obj *rp){  void plotover_mainNG(NODE arg,char *fn,Obj *rp){
         //[s_id (Q), w_id (Q), formula (Obj), color (Q)]    Q s_id,w_id,color;
         Q s_id,w_id,color;    P poly;
         P poly;    STRING fname;
         STRING fname;    Obj t;
         Obj t;    int iNo,pfine,sfine;
         int iNo,pfine,sfine;    char ebuf[BUFSIZ];
         char ebuf[BUFSIZ];  
   
         pfine=sfine=TRUE;    pfine=sfine=TRUE;
         iNo=0;poly=0;color=s_id=w_id=0;    iNo=0;poly=0;color=s_id=w_id=0;
         for(;arg;arg=NEXT(arg)){    for(;arg;arg=NEXT(arg)){
                 if(!BDY(arg)) iNo++;      if(!BDY(arg)) iNo++;
                 else switch(OID(BDY(arg))){      else switch(OID(BDY(arg))){
                 case O_P://formular      case O_P://formular
                         if(pfine){        if(pfine){
                                 poly=(P)BDY(arg);          poly=(P)BDY(arg);
                                 pfine=FALSE;          pfine=FALSE;
                         } else {        } else {
                                 sprintf(ebuf,"%s : to many ploy arguments",fn);          sprintf(ebuf,"%s : to many plot arguments",fn);
                                 error(ebuf);          error(ebuf);
                         }        }
                         break;        break;
                 case O_N://color,s_id,w_id      case O_N://color,s_id,w_id
                         switch(iNo){        switch(iNo){
                         case 0://color arg        case 0://color arg
                                 color=(Q)BDY(arg);          color=(Q)BDY(arg);
                                 iNo++;          iNo++;
                                 break;          break;
                         case 1://stream arg        case 1://stream arg
                                 s_id=(Q)BDY(arg);          s_id=(Q)BDY(arg);
                                 iNo++;          iNo++;
                                 break;          break;
                         case 2://window arg        case 2://window arg
                                 w_id=(Q)BDY(arg);          w_id=(Q)BDY(arg);
                                 iNo++;          iNo++;
                                 break;          break;
                         default://error        default://error
                                 sprintf(ebuf,"%s : to many numbers",fn);          sprintf(ebuf,"%s : to many numbers",fn);
                                 error(ebuf);          error(ebuf);
                                 break;          break;
                         }        }
                         break;        break;
                 default:      default:
                         sprintf(ebuf,"%s : arguments type miss match",fn);        sprintf(ebuf,"%s : arguments type miss match",fn);
                         error(ebuf);        error(ebuf);
                 }      }
         }    }
         MKSTR(fname,fn);    MKSTR(fname,fn);
         arg=mknode(5,s_id,fname,w_id,poly,color);    //[s_id (Q), w_id (Q), formula (Obj), color (Q)]
 //printf("fn:%s s_id:%d w_id:%d color:%d\n",BDY(fname),QTOS(s_id),QTOS(w_id),QTOS(color));    arg=mknode(5,s_id,fname,w_id,poly,color);
         Pox_rpc(arg,&t);    Pox_rpc(arg,&t);
         *rp=(Obj)s_id;    *rp=(Obj)s_id;
 }  }
Legend:
Removed from v.1.26  
changed lines
  Added in v.1.35
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>