[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.23 and 1.24

version 1.23, 2012/10/04 04:56:39 version 1.24, 2013/12/19 05:48:25
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.22 2011/08/10 04:51:58 saito Exp $   * $OpenXM: OpenXM_contrib2/asir2000/plot/plotf.c,v 1.23 2012/10/04 04:56:39 saito Exp $
 */  */
 #include "ca.h"  #include "ca.h"
 #include "parse.h"  #include "parse.h"
 #include "ox.h"  #include "ox.h"
 #include "ifplot.h"  #include "ifplot.h"
   
 void Pifplot(NODE, Obj *), Pconplot(NODE, Obj *), Pplotover(NODE, Q *);  void ListCheck(char *,LIST);
 void Pplot(NODE, Obj *), Parrayplot(NODE, Q *), Pdrawcircle(NODE, Q *);  void Pplot(NODE, Obj *);
 #if defined(INTERVAL)  void Ppolarplot(NODE, Obj *);
 void Pitvplot1(NODE, Obj *), itvplot_main1(NODE, Obj *); //NORMAL  void Pobj_cp(NODE, Obj *),Parrayplot(NODE,Obj*),Pdrawcircle(NODE,Obj*);
 void Pitvplot2(NODE, Obj *), itvplot_main2(NODE, Obj *); //TRANSFER  void Pifplot(NODE,Obj *),Pconplot(NODE,Obj *),Pplotover(NODE,Obj *);
 void Pitvplot3(NODE, Obj *), itvplot_main3(NODE, Obj *); //RECURSION  void Pmemory_ifplot(NODE, Obj *),Pmemory_conplot(NODE, Obj *);
 void Pitvplot4(NODE, Obj *), itvplot_main4(NODE, Obj *); //RECURSION+TRANSFER  
 void Pitvplot(NODE, Obj *), itvplot_main(NODE, Obj *); //NEWTYPE  
 void Pobj_cp(NODE, Obj *);  
 void Pineqn(NODE, Obj *), Pineqnor(NODE, Obj *), Pineqnand(NODE, Obj *);  
 void Pineqnxor(NODE, Obj *), Pmemory_ineqn(NODE, Obj *);  
 void ineqn_main(NODE, int, Obj *);  
 void ineqn_main_op(NODE, int, int, Obj *);  
 #endif  
 void Ppolarplot(NODE, Q *);  
 void Pmemory_ifplot(NODE, Obj *), Pmemory_conplot(NODE, Obj *);  
 void Pmemory_plot(NODE, Obj *);  void Pmemory_plot(NODE, Obj *);
 void Popen_canvas(NODE, Q *), Pclear_canvas(NODE, Q *), Pdraw_obj(NODE, Q *);  void ifplot_main(NODE, int, int, Obj *);
 void Pdraw_string(NODE, Q *);  void plot_main(NODE, int, int, Obj *);
 void Pox_rpc(), Pox_cmo_rpc();  
 void ifplot_main(NODE, int, Obj *);  
 void conplot_main(NODE, int, Obj *);  void conplot_main(NODE, int, Obj *);
 void plot_main(NODE, int, Obj *);  
   
 struct ftab plot_tab[] = {  void Popen_canvas(NODE,Obj *),Pclear_canvas(NODE,Obj *),Pdraw_obj(NODE,Obj *);
         {"ifplot",Pifplot,-7},  void Pdraw_string(NODE,Obj *);
         {"memory_ifplot",Pmemory_ifplot,-6},  void Pox_rpc(), Pox_cmo_rpc();
   
   //NG
 #if defined(INTERVAL)  #if defined(INTERVAL)
         {"itvplot1",Pitvplot1,-7},  void Pitvifplot(NODE, Obj *);
         {"itvplot2",Pitvplot2,-7},  
         {"itvplot3",Pitvplot3,-7},  
         {"itvplot4",Pitvplot4,-7},  
         {"itvplot",Pitvplot,-7},  
         {"ineqn",Pineqn,-8},  
         {"ineqnor",Pineqnor,-7},  
         {"ineqnand",Pineqnand,-7},  
         {"ineqnxor",Pineqnxor,-7},  
         {"memory_ineqn",Pmemory_ineqn,-6},  
         {"obj_cp",Pobj_cp,4},  
 #endif  #endif
   void PifplotD(NODE,Obj *),PifplotQ(NODE,Obj *),PifplotB(NODE,Obj *);
   void PineqnD(NODE,Obj *), PineqnQ(NODE,Obj *), PineqnB(NODE,Obj *);
   void PineqnandD(NODE,Obj *), PineqnandQ(NODE,Obj *), PineqnandB(NODE,Obj *);
   void PineqnorD(NODE,Obj *), PineqnorQ(NODE,Obj *), PineqnorB(NODE,Obj *);
   void PineqnxorD(NODE,Obj *), PineqnxorQ(NODE,Obj *), PineqnxorB(NODE,Obj *);
   void PconplotD(NODE,Obj *),PconplotQ(NODE,Obj *),PconplotB(NODE,Obj *);
   void PplotoverD(NODE,Obj *),PplotoverQ(NODE,Obj *),PplotoverB(NODE,Obj *);
   void ifplot_mainNG(NODE,int,Obj *);
   void ifplot_mainOP(NODE,int,Obj *);
   void conplot_mainNG(NODE,int,Obj *);
   void plotover_mainNG(NODE,int,Obj *);
   //void PplotD(NODE, Obj *);
   
   char *pfunc[]={
           "ifplot","conplot","plot","interactive","polarplot","plotover",
           "ifplotD","ifplotQ","ifplotB","ineqnD","ineqnQ","ineqnB",
           "ineqnandD","ineqnandQ","ineqnandB","ineqnorD","ineqnorQ","ineqnorB",
           "ineqnxorD","ineqnxorQ","ineqnxorB",
           "conplotD","conplotQ","conplotB","itvifplot",
           "plotoverD","plotoverQ","plotoverB"};
   // end NG
   
   struct ftab plot_tab[]={
           {"plot",Pplot,-6},
   #if defined(INTERVAL)
           {"itvifplot",Pitvifplot,-8},
   #endif
           {"polarplot",Ppolarplot,-7},
           {"obj_cp",Pobj_cp,4},
           {"ifplot",Pifplot,-7},
           {"ifplotD",PifplotD,-8},
           {"ifplotQ",PifplotQ,-8},
           {"ifplotB",PifplotB,-8},
           {"ineqn",PineqnD,-8},
           {"ineqnD",PineqnD,-8},
           {"ineqnQ",PineqnQ,-8},
           {"ineqnB",PineqnB,-8},
           {"ineqnand",PineqnandD,4},//ifplot_mainOP :argc is const
           {"ineqnandD",PineqnandD,4},
           {"ineqnandQ",PineqnandQ,4},
           {"ineqnandB",PineqnandB,4},
           {"ineqnor",PineqnorD,4},
           {"ineqnorD",PineqnorD,4},
           {"ineqnorQ",PineqnorQ,4},
           {"ineqnorB",PineqnorB,4},
           {"ineqnxor",PineqnxorD,4},
           {"ineqnxorD",PineqnxorD,4},
           {"ineqnxorQ",PineqnxorQ,4},
           {"ineqnxorB",PineqnxorB,4},
         {"conplot",Pconplot,-8},          {"conplot",Pconplot,-8},
           {"conplotD",PconplotD,-9},
           {"conplotB",PconplotB,-9},
           {"conplotQ",PconplotQ,-9},
           {"plotover",Pplotover,-5},
           {"plotoverD",PplotoverD,-5},
           {"plotoverQ",PplotoverQ,-5},
           {"plotoverB",PplotoverB,-5},
           {"memory_ifplot",Pmemory_ifplot,-6},
         {"memory_conplot",Pmemory_conplot,-7},          {"memory_conplot",Pmemory_conplot,-7},
         {"plot",Pplot,-6},  
         {"memory_plot",Pmemory_plot,-5},          {"memory_plot",Pmemory_plot,-5},
         {"polarplot",Ppolarplot,-6},  
         {"plotover",Pplotover,-4},  
         {"drawcircle",Pdrawcircle,6},          {"drawcircle",Pdrawcircle,6},
         {"open_canvas",Popen_canvas,-3},          {"open_canvas",Popen_canvas,-3},
         {"clear_canvas",Pclear_canvas,2},          {"clear_canvas",Pclear_canvas,2},
Line 106  struct ftab plot_tab[] = {
Line 139  struct ftab plot_tab[] = {
         {0,0,0},          {0,0,0},
 };  };
   
 void Popen_canvas(NODE arg,Q *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) )                  if(!BDY(arg)) stream=0;
                         stream = 0;                  else switch (OID(BDY(arg))){
                 else                          case O_LIST:
                 switch ( OID(BDY(arg)) ) {                                  geom=(LIST)BDY(arg);
                 case O_LIST:                                  break;
                         geom = (LIST)BDY(arg);                          case O_N:
                         break;                                  stream=QTOS((Q)BDY(arg));
                 case O_N:                                  break;
                         stream = QTOS((Q)BDY(arg)); break;                          case O_STR:
                 case O_STR:                                  wname=(STRING)BDY(arg);
                         wname = (STRING)BDY(arg); break;                                  break;
                 default:                          default:
                         error("open_canvas : invalid argument"); break;                                  error("open_canvas : invalid argument");
                                   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(n,w300,n0); MKLIST(geom,n);                  MKNODE(n0,w300,0);
                   MKNODE(n,w300,n0);
                   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 = s_id;          *rp=(Obj)s_id;
 }  }
   
 void Pifplot(NODE arg,Obj *rp)  void Pifplot(NODE arg,Obj *rp){ifplot_main(arg,0,MODE_IFPLOT,rp);}
 {  void Pmemory_ifplot(NODE arg,Obj *rp){ifplot_main(arg,1,MODE_IFPLOT,rp);}
         ifplot_main(arg,0,rp);  
 }  
   
 void Pmemory_ifplot(NODE arg,Obj *rp)  void ifplot_main(NODE arg,int is_memory,int fn,Obj *rp){
 {  
         ifplot_main(arg,1,rp);  
 }  
   
 void ifplot_main(NODE arg,int is_memory, Obj *rp)  
 {  
         Q m2,p2,w300,s_id;          Q m2,p2,w300,s_id;
         NODE defrange;          NODE defrange;
         LIST xrange,yrange,range[2],list,geom;          LIST xrange,yrange,range[2],list,geom;
         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;          P poly,var;
         P var;  
         NODE n,n0;          NODE n,n0;
         STRING fname,wname;          STRING fname,wname;
         Obj t;          Obj t;
   
         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;
         poly = 0; vl = 0; geom = 0; wname = 0; stream = -1; ri = 0;          v[0]=v[1]=0;
         v[0] = v[1] = 0;          for(;arg;arg=NEXT(arg))
         for ( ; arg; arg = NEXT(arg) )                  if(!BDY(arg))stream=0;
                 if ( !BDY(arg) ) stream = 0;  
                 else                  else
                 switch ( OID(BDY(arg)) ) {                  switch(OID(BDY(arg))){
                 case O_P:                  case O_P:
                         poly = (P)BDY(arg);                          poly=(P)BDY(arg);
                         get_vars_recursive((Obj)poly,&vl);                          get_vars_recursive((Obj)poly,&vl);
                         for ( vl0 = vl, i = 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 ( i >= 2 ) error("ifplot : invalid argument");                                          if(i>=2)error("ifplot : invalid argument");
                                         else v[i++] = vl0->v;                                          else v[i++]=vl0->v;
                         break;                          break;
                 case O_LIST:                  case O_LIST:
                         list = (LIST)BDY(arg);                          list=(LIST)BDY(arg);
                         if ( OID(BDY(BDY(list))) == O_P )                          if(OID(BDY(BDY(list)))==O_P)
                                 if ( ri > 1 ) error("ifplot : invalid argument");                                  if(ri>1) error("ifplot : invalid argument");
                                 else range[ri++] = list;                                  else range[ri++]=list;
                         else geom = list;                          else geom=list;
                         break;                          break;
                 case O_N:                  case O_N:
                         stream = QTOS((Q)BDY(arg)); break;                          stream=QTOS((Q)BDY(arg));break;
                 case O_STR:                  case O_STR:
                         wname = (STRING)BDY(arg); break;                          wname=(STRING)BDY(arg);break;
                 default:                  default:
                         error("ifplot : invalid argument"); break;                          error("ifplot : invalid argument");break;
                 }                  }
         if ( !poly ) error("ifplot : invalid argument");          if(!poly) error("ifplot : invalid argument");
         switch ( ri ) {          switch(ri){
         case 0:          case 0:
                 if ( !v[1] ) error("ifplot : please specify all variables");                  if(!v[1]) error("ifplot : please specify all variables");
                 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);                  MKV(v[1],var);MKNODE(n,var,defrange);MKLIST(yrange,n);
                 break;                  break;
         case 1:          case 1:
                 if ( !v[1] ) error("ifplot : please specify all variables");                  if(!v[1]) error("ifplot : please specify all variables");
                 av[0] = VR((P)BDY(BDY(range[0])));                  av[0]=VR((P)BDY(BDY(range[0])));
                 if ( v[0] == av[0] ) {                  if(v[0]==av[0]){
                         xrange = range[0];                          xrange=range[0];
                         MKV(v[1],var); MKNODE(n,var,defrange); MKLIST(yrange,n);                          MKV(v[1],var);MKNODE(n,var,defrange);MKLIST(yrange,n);
                 } else if ( v[1] == av[0] ) {                  } 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);
                         yrange = range[0];                          yrange=range[0];
                 } else error("ifplot : invalid argument");                  } else error("ifplot : invalid argument");
                 break;                  break;
         case 2:          case 2:
                 av[0] = VR((P)BDY(BDY(range[0])));                  av[0]=VR((P)BDY(BDY(range[0])));
                 av[1] = VR((P)BDY(BDY(range[1])));                  av[1]=VR((P)BDY(BDY(range[1])));
                 if ( ((v[0] == av[0]) && (!v[1] || v[1] == av[1])) ||                  if(((v[0]==av[0])&&(!v[1]||v[1]==av[1]))||
                         ((v[0] == av[1]) && (!v[1] || v[1] == av[0])) ) {                          ((v[0]==av[1])&&(!v[1]||v[1]==av[0]))){
                         xrange = range[0]; yrange = range[1];                          xrange=range[0];yrange=range[1];
                 } else error("ifplot : invalid argument");                  } else error("ifplot : invalid argument");
                 break;                  break;
         default:          default:
                 error("ifplot : cannot happen"); break;                  error("ifplot : cannot happen");break;
         }          }
         /* ifplot in ox_plot requires          /* ifplot in ox_plot requires
                 [s_id (Q),                  [s_id (Q),
Line 234  void ifplot_main(NODE arg,int is_memory, Obj *rp)
Line 259  void ifplot_main(NODE arg,int is_memory, Obj *rp)
                 geom=[xsize,ysize] (LIST),                  geom=[xsize,ysize] (LIST),
                 wname=name (STRING)]                  wname=name (STRING)]
         */          */
           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(n,w300,n0);MKLIST(geom,n);
                 MKNODE(n0,w300,0); MKNODE(n,w300,n0); MKLIST(geom,n);  
         }          }
         if ( is_memory ) {          if(is_memory){
                 MKSTR(fname,"memory_plot");                  MKSTR(fname,"memory_plot");
                 arg = mknode(8,s_id,fname,poly,xrange,yrange,0,geom);                  arg=mknode(8,s_id,fname,poly,xrange,yrange,0,geom);
                 Pox_rpc(arg,&t);                  Pox_rpc(arg,&t);
                 arg = mknode(1,s_id);                  arg=mknode(1,s_id);
                 Pox_pop_cmo(arg,rp);                  Pox_pop_cmo(arg,rp);
         } else {          } else {
                 MKSTR(fname,"plot");                  MKSTR(fname,pfunc[fn]);
                 arg = mknode(8,s_id,fname,poly,xrange,yrange,0,geom,wname);                  arg=mknode(8,s_id,fname,poly,xrange,yrange,0,geom,wname);
                 Pox_rpc(arg,&t);                  Pox_rpc(arg,&t);
                 *rp = (Obj)s_id;                  *rp=(Obj)s_id;
         }          }
 }  }
   
 #if defined(INTERVAL)  void Pobj_cp(NODE arg,Obj *rp){
 void Pitvplot(NODE arg, Obj *rp)          //copy canvas
 {          //1:and,3:copy,6:xor,7:or
         itvplot_main(arg, rp);          Q sysid,index_A,index_B,op_code;
 }          STRING fname;
   
 void itvplot_main(NODE arg, Obj *rp)  
 {  
         Q m2,p2,w300,s_id, itvsize;  
         NODE defrange;  
         LIST xrange,yrange,range[2],list,geom;  
         VL vl,vl0;  
         V v[2],av[2];  
         int stream,ri,i,sign;  
         P poly;  
         P var;  
         NODE n,n0;  
         STRING fname,wname;  
         Obj t;          Obj t;
           sysid=(Q)ARG0(arg);
         STOQ(-2,m2); STOQ(2,p2);          index_A=(Q)ARG1(arg);
         MKNODE(n,p2,0); MKNODE(defrange,m2,n);          index_B=(Q)ARG2(arg);
         poly = 0; vl = 0; geom = 0; wname = 0; stream = -1; ri = 0;          op_code=(Q)ARG3(arg);
         v[0] = v[1] = 0;          MKSTR(fname,"objcp");
         for ( ; arg; arg = NEXT(arg) )          arg=mknode(5,sysid,fname,index_A,index_B,op_code);
                 if ( !BDY(arg) ) stream = 0;  
                 else  
                 switch ( OID(BDY(arg)) ) {  
                 case O_P:  
                         poly = (P)BDY(arg);  
                         get_vars_recursive((Obj)poly,&vl);  
                         for ( vl0 = vl, i = 0; vl0; vl0 = NEXT(vl0) )  
                                 if ( vl0->v->attr == (pointer)V_IND )  
                                         if ( i >= 2 ) error("itvplot : invalid argument");  
                                         else v[i++] = vl0->v;  
                         break;  
                 case O_LIST:  
                         list = (LIST)BDY(arg);  
                         if ( OID(BDY(BDY(list))) == O_P )  
                                 if ( ri > 1 ) error("itvplot : invalid argument");  
                                 else range[ri++] = list;  
                         else geom = list;  
                         break;  
                 case O_N:  
                         stream = QTOS((Q)BDY(arg)); break;  
                 case O_STR:  
                         wname = (STRING)BDY(arg); break;  
                 default:  
                         error("itvplot : invalid argument"); break;  
         }  
         if ( !poly ) error("itvplot : invalid argument");  
         switch ( ri ) {  
         case 0:  
                 if ( !v[1] ) error("itvplot : please specify all variables");  
                 MKV(v[0],var); MKNODE(n,var,defrange); MKLIST(xrange,n);  
                 MKV(v[1],var); MKNODE(n,var,defrange); MKLIST(yrange,n);  
                 break;  
         case 1:  
                 if ( !v[1] ) error("itvplot : please specify all variables");  
                 av[0] = VR((P)BDY(BDY(range[0])));  
                 if ( v[0] == av[0] ) {  
                         xrange = range[0];  
                         MKV(v[1],var); MKNODE(n,var,defrange); MKLIST(yrange,n);  
                 } else if ( v[1] == av[0] ) {  
                         MKV(v[0],var); MKNODE(n,var,defrange); MKLIST(xrange,n);  
                         yrange = range[0];  
                 } else error("itvplot : invalid argument");  
                 break;  
         case 2:  
                 av[0] = VR((P)BDY(BDY(range[0])));  
                 av[1] = VR((P)BDY(BDY(range[1])));  
                 if ( ((v[0] == av[0]) && (!v[1] || v[1] == av[1])) ||  
                         ((v[0] == av[1]) && (!v[1] || v[1] == av[0])) ) {  
                         xrange = range[0]; yrange = range[1];  
                 } else error("itvplot : invalid argument");  
                 break;  
         default:  
                 error("itvplot : cannot happen"); break;  
         }  
         /* itvplot in ox_plot requires  
            [s_id (Q),  
                 formula (Obj),  
                 xrange=[x,xmin,xmax] (LIST),  
                 yrange=[y,ymin,ymax] (LIST),  
                 zrange=0,  
                 geom=[xsize,ysize] (LIST),  
                 wname=name (STRING)]  
         */  
         stream = validate_ox_plot_stream(stream);  
         STOQ(stream,s_id);  
         if ( !geom ) {  
                 STOQ(300,w300);  
                 MKNODE(n0,w300,0); MKNODE(n,w300,n0); MKLIST(geom,n);  
         }  
         MKSTR(fname,"itvifplot");  
         STOQ(Itvplot, itvsize);  
         arg = mknode(9,s_id,fname,poly,xrange,yrange,0,geom,wname,itvsize);  
         Pox_rpc(arg,&t);          Pox_rpc(arg,&t);
         *rp = (Obj)s_id;          *rp=(Obj)sysid;
 }  }
   
 void Pitvplot1(NODE arg, Obj *rp)  void Pconplot(NODE arg,Obj *rp){conplot_main(arg, 0, rp);}
 {  void Pmemory_conplot(NODE arg,Obj *rp){conplot_main(arg,1,rp);}
         itvplot_main1(arg, rp);  
 }  
   
 void Pitvplot2(NODE arg, Obj *rp)  void conplot_main(NODE arg,int is_memory,Obj *rp){
 {          int stream,ri,i;
         itvplot_main2(arg, rp);          Q m2,p2,w300,s_id,mxgc;
 }          NODE defrange,n,n0,n1,n2,n3;
           LIST xrange,yrange,zrange,range[3],list,geom;
 void Pitvplot3(NODE arg, Obj *rp)  
 {  
         itvplot_main3(arg, rp);  
 }  
   
 void Pitvplot4(NODE arg, Obj *rp)  
 {  
         itvplot_main4(arg, rp);  
 }  
   
 // NORMAL type  
 void itvplot_main1(NODE arg, Obj *rp)  
 {  
         Q m2,p2,w300,s_id;  
         NODE defrange;  
         LIST xrange,yrange,range[2],list,geom;  
         VL vl,vl0;          VL vl,vl0;
         V v[2],av[2];          V v[2],av[2];
         int stream,ri,i,sign;          P poly,var;
         P poly;  
         P var;  
         NODE n,n0;  
         STRING fname,wname;          STRING fname,wname;
         Obj t;          Obj t;
   
         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;v[0]=v[1]=0;
         poly = 0; vl = 0; geom = 0; wname = 0; stream = -1; ri = 0;          for(;arg;arg=NEXT(arg))
         v[0] = v[1] = 0;                  if(!BDY(arg)) stream=0;
         for ( ; arg; arg = NEXT(arg) )                  else switch (OID(BDY(arg))){
                 if ( !BDY(arg) ) stream = 0;  
                 else  
                 switch ( OID(BDY(arg)) ) {  
                 case O_P:  
                         poly = (P)BDY(arg);  
                         get_vars_recursive((Obj)poly,&vl);  
                         for ( vl0 = vl, i = 0; vl0; vl0 = NEXT(vl0) )  
                                 if ( vl0->v->attr == (pointer)V_IND )  
                                         if ( i >= 2 ) error("itvplot : invalid argument");  
                                         else v[i++] = vl0->v;  
                         break;  
                 case O_LIST:  
                         list = (LIST)BDY(arg);  
                         if ( OID(BDY(BDY(list))) == O_P )  
                                 if ( ri > 1 ) error("itvplot : invalid argument");  
                                 else range[ri++] = list;  
                         else geom = list;  
                         break;  
                 case O_N:  
                         stream = QTOS((Q)BDY(arg)); break;  
                 case O_STR:  
                         wname = (STRING)BDY(arg); break;  
                 default:  
                         error("itvplot : invalid argument"); break;  
                 }  
         if ( !poly ) error("itvplot : invalid argument");  
         switch ( ri ) {  
         case 0:  
                 if ( !v[1] ) error("itvplot : please specify all variables");  
                 MKV(v[0],var); MKNODE(n,var,defrange); MKLIST(xrange,n);  
                 MKV(v[1],var); MKNODE(n,var,defrange); MKLIST(yrange,n);  
                 break;  
         case 1:  
                 if ( !v[1] ) error("itvplot : please specify all variables");  
                 av[0] = VR((P)BDY(BDY(range[0])));  
                 if ( v[0] == av[0] ) {  
                         xrange = range[0];  
                         MKV(v[1],var); MKNODE(n,var,defrange); MKLIST(yrange,n);  
                 } else if ( v[1] == av[0] ) {  
                         MKV(v[0],var); MKNODE(n,var,defrange); MKLIST(xrange,n);  
                         yrange = range[0];  
                 } else error("itvplot : invalid argument");  
                 break;  
         case 2:  
                 av[0] = VR((P)BDY(BDY(range[0])));  
                 av[1] = VR((P)BDY(BDY(range[1])));  
                 if ( ((v[0] == av[0]) && (!v[1] || v[1] == av[1])) ||  
                         ((v[0] == av[1]) && (!v[1] || v[1] == av[0])) ) {  
                         xrange = range[0]; yrange = range[1];  
                 } else error("itvplot : invalid argument");  
                 break;  
         default:  
                 error("itvplot : cannot happen"); break;  
         }  
         stream = validate_ox_plot_stream(stream);  
         STOQ(stream,s_id);  
         if ( !geom ) {  
                 STOQ(300,w300);  
                 MKNODE(n0,w300,0); MKNODE(n,w300,n0); MKLIST(geom,n);  
         }  
         MKSTR(fname,"itvplot1");  
         arg = mknode(8,s_id,fname,poly,xrange,yrange,0,geom,wname);  
         Pox_rpc(arg,&t);  
         *rp = (Obj)s_id;  
 }  
   
 // TRANSFER TYPE  
 void itvplot_main2(NODE arg, Obj *rp)  
 {  
         Q m2,p2,w300,s_id;  
         NODE defrange;  
         LIST xrange,yrange,range[2],list,geom;  
         VL vl,vl0;  
         V v[2],av[2];  
         int stream,ri,i,sign;  
         P poly;  
         P var;  
         NODE n,n0;  
         STRING fname,wname;  
         Obj t;  
   
         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;  
         v[0] = v[1] = 0;  
         for ( ; arg; arg = NEXT(arg) )  
                 if ( !BDY(arg) )  
                         stream = 0;  
                 else  
                 switch ( OID(BDY(arg)) ) {  
                         case O_P:                          case O_P:
                                 poly = (P)BDY(arg);                                  poly=(P)BDY(arg);
                                 get_vars_recursive((Obj)poly,&vl);                                  get_vars_recursive((Obj)poly,&vl);
                                 for ( vl0 = vl, i = 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 ( i >= 2 )                                                  if(i>=2) error("conplot : invalid argument");
                                                         error("itvplot : invalid argument");                                                  else v[i++]=vl0->v;
                                                 else  
                                                         v[i++] = vl0->v;  
                                 break;                                  break;
                         case O_LIST:                          case O_LIST:
                                 list = (LIST)BDY(arg);                                  list=(LIST)BDY(arg);
                                 if ( OID(BDY(BDY(list))) == O_P )                                  if(OID(BDY(BDY(list)))==O_P)
                                         if ( ri > 1 )                                          if(ri>2) error("conplot : invalid argument");
                                                 error("itvplot : invalid argument");                                          else range[ri++]=list;
                                         else                                  else geom=list;
                                                 range[ri++] = list;  
                                 else  
                                         geom = list;  
                                 break;                                  break;
                         case O_N:                          case O_N:
                                 stream = QTOS((Q)BDY(arg)); break;                                  stream=QTOS((Q)BDY(arg));
                         case O_STR:  
                                 wname = (STRING)BDY(arg); break;  
                         default:  
                                 error("itvplot : invalid argument"); break;  
                 }  
         if ( !poly )  
                 error("itvplot : invalid argument");  
         switch ( ri ) {  
                 case 0:  
                         if ( !v[1] )  
                                 error("itvplot : please specify all variables");  
                         MKV(v[0],var); MKNODE(n,var,defrange); MKLIST(xrange,n);  
                         MKV(v[1],var); MKNODE(n,var,defrange); MKLIST(yrange,n);  
                         break;  
                 case 1:  
                         if ( !v[1] )  
                                 error("itvplot : please specify all variables");  
                         av[0] = VR((P)BDY(BDY(range[0])));  
                         if ( v[0] == av[0] ) {  
                                 xrange = range[0];  
                                 MKV(v[1],var); MKNODE(n,var,defrange); MKLIST(yrange,n);  
                         } else if ( v[1] == av[0] ) {  
                                 MKV(v[0],var); MKNODE(n,var,defrange); MKLIST(xrange,n);  
                                 yrange = range[0];  
                         } else  
                                 error("itvplot : invalid argument");  
                         break;  
                 case 2:  
                         av[0] = VR((P)BDY(BDY(range[0])));  
                         av[1] = VR((P)BDY(BDY(range[1])));  
                         if ( ((v[0] == av[0]) && (!v[1] || v[1] == av[1])) ||  
                                  ((v[0] == av[1]) && (!v[1] || v[1] == av[0])) ) {  
                                         xrange = range[0]; yrange = range[1];  
                         } else  
                                         error("itvplot : invalid argument");  
                         break;  
                 default:  
                         error("itvplot : cannot happen"); break;  
         }  
         stream = validate_ox_plot_stream(stream);  
         STOQ(stream,s_id);  
         if ( !geom ) {  
                 STOQ(300,w300);  
                 MKNODE(n0,w300,0); MKNODE(n,w300,n0); MKLIST(geom,n);  
         }  
         MKSTR(fname,"itvplot2");  
         arg = mknode(8,s_id,fname,poly,xrange,yrange,0,geom,wname);  
         Pox_rpc(arg,&t);  
         *rp = (Obj)s_id;  
 }  
 // RECURSION TYPE  
 void itvplot_main3(NODE arg, Obj *rp)  
 {  
         Q m2,p2,w300,s_id, itvsize;  
         NODE defrange;  
         LIST xrange,yrange,range[2],list,geom;  
         VL vl,vl0;  
         V v[2],av[2];  
         int stream,ri,i,sign;  
         P poly;  
         P var;  
         NODE n,n0;  
         STRING fname,wname;  
         Obj t;  
   
         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;  
         v[0] = v[1] = 0;  
         for ( ; arg; arg = NEXT(arg) )  
                 if ( !BDY(arg) )  
                         stream = 0;  
                 else  
                 switch ( OID(BDY(arg)) ) {  
                         case O_P:  
                                 poly = (P)BDY(arg);  
                                 get_vars_recursive((Obj)poly,&vl);  
                                 for ( vl0 = vl, i = 0; vl0; vl0 = NEXT(vl0) )  
                                         if ( vl0->v->attr == (pointer)V_IND )  
                                                 if ( i >= 2 )  
                                                         error("itvplot : invalid argument");  
                                                 else  
                                                         v[i++] = vl0->v;  
                                 break;                                  break;
                         case O_LIST:  
                                 list = (LIST)BDY(arg);  
                                 if ( OID(BDY(BDY(list))) == O_P )  
                                         if ( ri > 1 )  
                                                 error("itvplot : invalid argument");  
                                         else  
                                                 range[ri++] = list;  
                                 else  
                                         geom = list;  
                                 break;  
                         case O_N:  
                                 stream = QTOS((Q)BDY(arg)); break;  
                         case O_STR:                          case O_STR:
                                 wname = (STRING)BDY(arg); break;                                  wname=(STRING)BDY(arg);
                         default:  
                                 error("itvplot : invalid argument"); break;  
                 }  
         if ( !poly )  
                 error("itvplot : invalid argument");  
         switch ( ri ) {  
                 case 0:  
                         if ( !v[1] )  
                                 error("itvplot : please specify all variables");  
                         MKV(v[0],var); MKNODE(n,var,defrange); MKLIST(xrange,n);  
                         MKV(v[1],var); MKNODE(n,var,defrange); MKLIST(yrange,n);  
                         break;  
                 case 1:  
                         if ( !v[1] )  
                                 error("itvplot : please specify all variables");  
                         av[0] = VR((P)BDY(BDY(range[0])));  
                         if ( v[0] == av[0] ) {  
                                 xrange = range[0];  
                                 MKV(v[1],var); MKNODE(n,var,defrange); MKLIST(yrange,n);  
                         } else if ( v[1] == av[0] ) {  
                                 MKV(v[0],var); MKNODE(n,var,defrange); MKLIST(xrange,n);  
                                 yrange = range[0];  
                         } else  
                                 error("itvplot : invalid argument");  
                         break;  
                 case 2:  
                         av[0] = VR((P)BDY(BDY(range[0])));  
                         av[1] = VR((P)BDY(BDY(range[1])));  
                         if ( ((v[0] == av[0]) && (!v[1] || v[1] == av[1])) ||  
                                  ((v[0] == av[1]) && (!v[1] || v[1] == av[0])) ) {  
                                         xrange = range[0]; yrange = range[1];  
                         } else  
                                         error("itvplot : invalid argument");  
                         break;  
                 default:  
                         error("itvplot : cannot happen"); break;  
         }  
         stream = validate_ox_plot_stream(stream);  
         STOQ(stream,s_id);  
         if ( !geom ) {  
                 STOQ(300,w300);  
                 MKNODE(n0,w300,0); MKNODE(n,w300,n0); MKLIST(geom,n);  
         }  
         MKSTR(fname,"itvplot3");  
         STOQ(Itvplot, itvsize);  
         arg = mknode(9,s_id,fname,poly,xrange,yrange,0,geom,wname,itvsize);  
         Pox_rpc(arg,&t);  
         *rp = (Obj)s_id;  
 }  
 // RECURSION and TRANSFER TYPE  
 void itvplot_main4(NODE arg, Obj *rp)  
 {  
         Q m2,p2,w300,s_id,itvsize;  
         NODE defrange;  
         LIST xrange,yrange,range[2],list,geom;  
         VL vl,vl0;  
         V v[2],av[2];  
         int stream,ri,i,sign;  
         P poly;  
         P var;  
         NODE n,n0;  
         STRING fname,wname;  
         Obj t;  
   
         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;  
         v[0] = v[1] = 0;  
         for ( ; arg; arg = NEXT(arg) )  
                 if ( !BDY(arg) )  
                         stream = 0;  
                 else  
                 switch ( OID(BDY(arg)) ) {  
                         case O_P:  
                                 poly = (P)BDY(arg);  
                                 get_vars_recursive((Obj)poly,&vl);  
                                 for ( vl0 = vl, i = 0; vl0; vl0 = NEXT(vl0) )  
                                         if ( vl0->v->attr == (pointer)V_IND )  
                                                 if ( i >= 2 )  
                                                         error("itvplot : invalid argument");  
                                                 else  
                                                         v[i++] = vl0->v;  
                                 break;                                  break;
                         case O_LIST:  
                                 list = (LIST)BDY(arg);  
                                 if ( OID(BDY(BDY(list))) == O_P )  
                                         if ( ri > 1 )  
                                                 error("itvplot : invalid argument");  
                                         else  
                                                 range[ri++] = list;  
                                 else  
                                         geom = list;  
                                 break;  
                         case O_N:  
                                 stream = QTOS((Q)BDY(arg)); break;  
                         case O_STR:  
                                 wname = (STRING)BDY(arg); break;  
                         default:                          default:
                                 error("itvplot : invalid argument"); break;                                  error("conplot : invalid argument");
                 }  
         if ( !poly )  
                 error("itvplot : invalid argument");  
         switch ( ri ) {  
                 case 0:  
                         if ( !v[1] )  
                                 error("itvplot : please specify all variables");  
                         MKV(v[0],var); MKNODE(n,var,defrange); MKLIST(xrange,n);  
                         MKV(v[1],var); MKNODE(n,var,defrange); MKLIST(yrange,n);  
                         break;  
                 case 1:  
                         if ( !v[1] )  
                                 error("itvplot : please specify all variables");  
                         av[0] = VR((P)BDY(BDY(range[0])));  
                         if ( v[0] == av[0] ) {  
                                 xrange = range[0];  
                                 MKV(v[1],var); MKNODE(n,var,defrange); MKLIST(yrange,n);  
                         } else if ( v[1] == av[0] ) {  
                                 MKV(v[0],var); MKNODE(n,var,defrange); MKLIST(xrange,n);  
                                 yrange = range[0];  
                         } else  
                                 error("itvplot : invalid argument");  
                         break;  
                 case 2:  
                         av[0] = VR((P)BDY(BDY(range[0])));  
                         av[1] = VR((P)BDY(BDY(range[1])));  
                         if ( ((v[0] == av[0]) && (!v[1] || v[1] == av[1])) ||  
                                  ((v[0] == av[1]) && (!v[1] || v[1] == av[0])) ) {  
                                         xrange = range[0]; yrange = range[1];  
                         } else  
                                         error("itvplot : invalid argument");  
                         break;  
                 default:  
                         error("itvplot : cannot happen"); break;  
         }  
         /* itvplot in ox_plot requires  
            [s_id (Q),  
                 formula (Obj),  
                 xrange=[x,xmin,xmax] (LIST),  
                 yrange=[y,ymin,ymax] (LIST),  
                 zrange=0,  
                 geom=[xsize,ysize] (LIST),  
                 wname=name (STRING)]  
         */  
   
         stream = validate_ox_plot_stream(stream);  
         STOQ(stream,s_id);  
         if ( !geom ) {  
                 STOQ(300,w300);  
                 MKNODE(n0,w300,0); MKNODE(n,w300,n0); MKLIST(geom,n);  
         }  
         MKSTR(fname,"itvplot4");  
         STOQ(Itvplot, itvsize);  
         arg = mknode(9,s_id,fname,poly,xrange,yrange,0,geom,wname,itvsize);  
         Pox_rpc(arg,&t);  
         *rp = (Obj)s_id;  
 }  
   
 void Pineqn(NODE arg, Obj *rp)  
 {  
         ineqn_main(arg, 1, rp);  
 }  
   
 void ineqn_main(NODE arg,int is_memory, Obj *rp)  
 {  
         Q s_id, m2, p2, w300, color;  
         NODE defrange, n, n0;  
         P poly, var;  
         VL vl, vl0;  
         V v[2], av[2];  
         LIST xrange, yrange, range[2], list, geom;  
         int stream, ri, i,sign;  
         STRING fname,wname;  
   
         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;  
         v[0] = v[1] = 0;  
         /* get polynomial */  
         if ( !(OID(BDY(arg)) == O_P || (OID(BDY(arg)) ==O_R)) )  
                 error("ineqn : first argument must be a polynormial");  
         else {  
                 poly = (P)BDY(arg);  
                 /* get vars */  
                 get_vars_recursive((Obj)poly,&vl);  
                 for ( vl0 = vl, i = 0; vl0; vl0 = NEXT(vl0) )  
                 if ( vl0->v->attr == (pointer)V_IND )  
                 if ( i >= 2 )  
                         error(  
                                 "ineqn : first argument must be a univariate or bivariate polynormial");  
                 else  
                         v[i++] = vl0->v;  
         }  
         /* get color */  
         arg = NEXT(arg);  
         if ( OID(BDY(arg)) != O_N )  
                 error("ineqn : second argument must be color code");  
         else  
                 color = (Q)BDY(arg);  
         /* other argument is optional */  
         arg = NEXT(arg);  
         for ( ; arg; arg = NEXT(arg) )  
                 if ( !BDY(arg) )  
                         stream = 0;  
                 else  
                 switch ( OID(BDY(arg)) ) {  
                 case O_LIST:  
                         list = (LIST)BDY(arg);  
                         if ( OID(BDY(BDY(list))) == O_P )  
                                 if ( ri > 1 )  
                                         error("ineqn : invalid list argument");  
                                 else  
                                         range[ri++] = list;  
                         else  
                         geom = list;  
                         break;  
                 case O_N:  
                         stream = QTOS((Q)BDY(arg)); break;  
                 case O_STR:  
                         wname = (STRING)BDY(arg); break;  
                 default:  
                         error("ineqn : invalid argument"); break;  
         }  
         switch ( ri ) {  
         case 0:  
                 if ( !v[1] ) error("ineqn : please specify all variables");  
                 MKV(v[0],var); MKNODE(n,var,defrange); MKLIST(xrange,n);  
                 MKV(v[1],var); MKNODE(n,var,defrange); MKLIST(yrange,n);  
                 break;  
         case 1:  
                 if ( !v[1] ) error("ineqn : please specify all variables");  
                 av[0] = VR((P)BDY(BDY(range[0])));  
                 if ( v[0] == av[0] ) {  
                         xrange = range[0];  
                         MKV(v[1],var); MKNODE(n,var,defrange); MKLIST(yrange,n);  
                 } else if ( v[1] == av[0] ) {  
                         MKV(v[0],var); MKNODE(n,var,defrange); MKLIST(xrange,n);  
                         yrange = range[0];  
                 } else error("ineqn : invalid argument");  
                 break;  
         case 2:  
                 av[0] = VR((P)BDY(BDY(range[0])));  
                 av[1] = VR((P)BDY(BDY(range[1])));  
                 if ( ((v[0] == av[0]) && (!v[1] || v[1] == av[1])) ||  
                                 ((v[0] == av[1]) && (!v[1] || v[1] == av[0])) ) {  
                         xrange = range[0]; yrange = range[1];  
                 } else error("ineqn : invalid argument");  
                 break;  
         default:  
                 error("ineqn : cannot happen"); break;  
         }  
   
         stream = validate_ox_plot_stream(stream);  
         STOQ(stream,s_id);  
         if ( !geom ) {  
                 STOQ(300,w300);  
                 MKNODE(n0,w300,0); MKNODE(n,w300,n0); MKLIST(geom,n);  
         }  
         MKSTR(fname, "ineqn");  
         arg = mknode(8, s_id, fname, poly, color, xrange, yrange, geom, wname);  
         Pox_cmo_rpc(arg,rp);  
         *rp = (Obj)s_id;  
 }  
   
 void Pineqnor(NODE arg, Obj *rp)  
 {  
         ineqn_main_op(arg, 7, 0, rp);  
 }  
   
 void Pineqnand(NODE arg, Obj *rp)  
 {  
         ineqn_main_op(arg, 1, 0, rp);  
 }  
   
 void Pineqnxor(NODE arg, Obj *rp)  
 {  
         ineqn_main_op(arg, 6, 0, rp);  
 }  
   
 void Pmemory_ineqn(NODE arg, Obj *rp)  
 {  
         ineqn_main(arg, 1, rp);  
 }  
   
 void ineqn_main_op(NODE arg, int op, int is_memory, Obj *rp)  
 {  
         Q s_id, index, color, op_code;  
         P poly;  
         STRING fname;  
         Obj t;  
   
         poly  = (P)ARG0(arg);  
         color = (Q)ARG1(arg);  
         s_id  = (Q)ARG2(arg);  
         index = (Q)ARG3(arg);  
         STOQ( op, op_code);  
         MKSTR(fname, "ineqnover");  
         arg = mknode(6, s_id, fname, index, poly, color, op_code);  
         Pox_rpc(arg, &t);  
         *rp = (Obj)s_id;  
 }  
   
 void Pobj_cp(NODE arg, Obj *rp)  
 {  
         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, "objcp");  
         arg = mknode(5, sysid, fname, index_A, index_B, op_code);  
         Pox_rpc(arg, &t);  
         *rp = (Obj)sysid;  
 }  
 #endif  
   
 void Pconplot(NODE arg,Obj *rp)  
 {  
         conplot_main(arg, 0, rp);  
 }  
   
 void Pmemory_conplot(NODE arg,Obj *rp)  
 {  
         conplot_main(arg,1,rp);  
 }  
   
 void conplot_main(NODE arg,int is_memory,Obj *rp)  
 {  
         Q m2,p2,w300,s_id;  
         NODE defrange;  
         LIST xrange,yrange,zrange,range[3],list,geom;  
         VL vl,vl0;  
         V v[2],av[2];  
         int stream,ri,i;  
         P poly;  
         P var;  
         NODE n,n0;  
         STRING fname,wname;  
         Obj t;  
   
         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;  
         v[0] = v[1] = 0;  
         for ( ; arg; arg = NEXT(arg) )  
                 if ( !BDY(arg) )  
                         stream = 0;  
                 else  
                 switch ( OID(BDY(arg)) ) {  
                         case O_P:  
                                 poly = (P)BDY(arg);  
                                 get_vars_recursive((Obj)poly,&vl);  
                                 for ( vl0 = vl, i = 0; vl0; vl0 = NEXT(vl0) )  
                                         if ( vl0->v->attr == (pointer)V_IND )  
                                                 if ( i >= 2 )  
                                                         error("ifplot : invalid argument");  
                                                 else  
                                                         v[i++] = vl0->v;  
                                 break;                                  break;
                         case O_LIST:  
                                 list = (LIST)BDY(arg);  
                                 if ( OID(BDY(BDY(list))) == O_P )  
                                         if ( ri > 2 )  
                                                 error("ifplot : invalid argument");  
                                         else  
                                                 range[ri++] = list;  
                                 else  
                                         geom = list;  
                                 break;  
                         case O_N:  
                                 stream = QTOS((Q)BDY(arg)); break;  
                         case O_STR:  
                                 wname = (STRING)BDY(arg); break;  
                         default:  
                                 error("ifplot : invalid argument"); break;  
                 }                  }
         if ( !poly )          if(!poly) error("conplot : invalid argument");
                 error("ifplot : invalid argument");          // list format var,num,num[,num]
         switch ( ri ) {          switch (ri){
                 case 0:                  case 0:
                         if ( !v[1] )                          if(!v[1]) error("conplot : please specify all variables");
                                 error("ifplot : please specify all variables");                          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);
                         MKV(v[1],var); MKNODE(n,var,defrange); MKLIST(yrange,n);                          STOQ(MAXGC,mxgc);MKNODE(n1,mxgc,0);MKNODE(n2,p2,n1);MKNODE(n3,p2,n2);
                         MKNODE(n,0,defrange); MKLIST(zrange,n);                          MKLIST(zrange,n3);
                         break;                          break;
                 case 1:                  case 1:
                         if ( !v[1] )                          if(!v[1]) error("conplot : please specify all variables");
                                 error("ifplot : please specify all variables");                          av[0]=VR((P)BDY(BDY(range[0])));
                         av[0] = VR((P)BDY(BDY(range[0])));                          if(v[0]==av[0]){
                         if ( v[0] == av[0] ) {                                  xrange=range[0];
                                 xrange = range[0];                                  MKV(v[1],var);MKNODE(n,var,defrange);MKLIST(yrange,n);
                                 MKV(v[1],var); MKNODE(n,var,defrange); MKLIST(yrange,n);                                  STOQ(MAXGC,mxgc);MKNODE(n1,mxgc,0);MKNODE(n2,p2,n1);MKNODE(n3,p2,n2);
                                 MKNODE(n,0,defrange); MKLIST(zrange,n);                                  MKLIST(zrange,n3);
                         } else if ( v[1] == av[0] ) {                          } 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);
                                 yrange = range[0];                                  yrange=range[0];
                                 MKNODE(n,0,defrange); MKLIST(zrange,n);                                  STOQ(MAXGC,mxgc);MKNODE(n1,mxgc,0);MKNODE(n2,p2,n1);MKNODE(n3,p2,n2);
                                   MKLIST(zrange,n3);
                         } else {                          } else {
                                 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);                                  MKV(v[1],var);MKNODE(n,var,defrange);MKLIST(yrange,n);
                                 zrange = range[0];                                  n=NEXT((NODE)BDY(range[0]));
                                   for(i=0,n1=n;n1;n1=NEXT(n1),i++);
                                   if(i==3)MKLIST(zrange,n);
                                   else if(i==2){
                                           n1=(NODE)BDY(n);
                                           n2=(NODE)(BDY(NEXT(n)));
                                           STOQ(MAXGC,mxgc);MKNODE(n,mxgc,0);
                                           MKNODE(n3,n1,n);
                                           MKNODE(n1,n2,n3);
                                           MKLIST(zrange,n1);
                                   } else error("conplot : zrange error");
                         }                          }
                         break;                          break;
                 case 2: case 3:                  case 2:
                         av[0] = VR((P)BDY(BDY(range[0])));                  case 3:
                         av[1] = VR((P)BDY(BDY(range[1])));                          av[0]=VR((P)BDY(BDY(range[0])));
                         if ( ((v[0] == av[0]) && (!v[1] || v[1] == av[1])) ||                          av[1]=VR((P)BDY(BDY(range[1])));
                                  ((v[0] == av[1]) && (!v[1] || v[1] == av[0])) ) {                          if(((v[0]==av[0])&&(!v[1]||v[1]==av[1]))||
                                 xrange = range[0]; yrange = range[1];                                  ((v[0]==av[1])&&(!v[1]||v[1]==av[0]))){
                                 if ( ri == 3 )                                  xrange=range[0];
                                         zrange = range[2];                                  yrange=range[1];
                                   if(ri==3) MKLIST(zrange,NEXT(BDY(range[2])));
                                 else {                                  else {
                                         MKNODE(n,0,defrange); MKLIST(zrange,n);                                          for(i=0,n=(NODE)BDY(range[0]);n;n=NEXT(n),i++);
                                           MKNODE(n,0,defrange);
                                           MKLIST(zrange,n);
                                 }                                  }
                         } else                          } else error("conplot : invalid argument");
                                 error("ifplot : invalid argument");  
                         break;                          break;
                 default:                  default:
                         error("ifplot : cannot happen"); break;                          error("conplot : cannot happen");
                           break;
         }          }
         /* conplot in ox_plot requires          /* conplot in ox_plot requires
            [s_id (Q),             [s_id (Q),
                 formula (Obj),                  formula (Obj),
                 xrange=[x,xmin,xmax] (LIST),                  xrange=[x,xmin,xmax] (LIST),
                 yrange=[y,ymin,ymax] (LIST),                  yrange=[y,ymin,ymax] (LIST),
                 zrange=[z,zmin,zmax] (LIST),                  zrange=[z,zmin,zmax,nstep] (LIST),z:dummy var
                 geom=[xsize,ysize] (LIST),                  geom=[xsize,ysize] (LIST),
                 wname=name (STRING)]                  wname=name (STRING)]
         */          */
           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(n,w300,n0); MKLIST(geom,n);                  MKNODE(n0,w300,0);
                   MKNODE(n,w300,n0);
                   MKLIST(geom,n);
         }          }
         if ( is_memory ) {          if(is_memory){
                 MKSTR(fname,"memory_plot");                  MKSTR(fname,"memory_plot");
                 arg = mknode(7,s_id,fname,poly,xrange,yrange,zrange,geom);                  arg=mknode(7,s_id,fname,poly,xrange,yrange,zrange,geom);
                 Pox_rpc(arg,&t);                  Pox_rpc(arg,&t);
                 arg = mknode(1,s_id);                  arg=mknode(1,s_id);
                 Pox_pop_cmo(arg,rp);                  Pox_pop_cmo(arg,rp);
         } else {          } else {
                 MKSTR(fname,"plot");                  //list check
                 arg = mknode(8,s_id,fname,poly,xrange,yrange,zrange,geom,wname);                  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,pfunc[MODE_CONPLOT]);
                   arg=mknode(8,s_id,fname,poly,xrange,yrange,zrange,geom,wname);
                 Pox_rpc(arg,&t);                  Pox_rpc(arg,&t);
                 *rp = (Obj)s_id;                  *rp=(Obj)s_id;
         }          }
 }  }
   
 void Pplot(NODE arg,Obj *rp)  void Pplot(NODE arg,Obj *rp){plot_main(arg,0,MODE_PLOT,rp);}
 {  void Pmemory_plot(NODE arg,Obj *rp){plot_main(arg,1,MODE_PLOT,rp);}
         plot_main(arg,0,rp);  
 }  
   
 void Pmemory_plot(NODE arg,Obj *rp)  void plot_main(NODE arg,int is_memory,int fn,Obj *rp){
 {  
         plot_main(arg,1,rp);  
 }  
   
 void plot_main(NODE arg,int is_memory,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;
Line 1083  void plot_main(NODE arg,int is_memory,Obj *rp)
Line 451  void plot_main(NODE arg,int is_memory,Obj *rp)
         STRING fname,wname;          STRING fname,wname;
         Obj t;          Obj t;
   
         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;          poly=0;vl=0;geom=0;wname=0;stream=-1;ri=0;
         v[0] = 0;          v[0]=0;
         for ( ; arg; arg = NEXT(arg) )          for(;arg;arg=NEXT(arg) )
                 if ( !BDY(arg) )                  if(!BDY(arg) )
                         stream = 0;                          stream=0;
                 else                  else
                 switch ( OID(BDY(arg)) ) {                  switch ( OID(BDY(arg)) ){
                         case O_P: case O_R:                          case O_P: case O_R:
                                 poly = (P)BDY(arg);                                  poly=(P)BDY(arg);
                                 get_vars_recursive((Obj)poly,&vl);                                  get_vars_recursive((Obj)poly,&vl);
                                 for ( vl0 = vl, i = 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 ( i >= 1 )                                                  if(i >= 1 )
                                                         error("ifplot : invalid argument");                                                          error("ifplot : invalid argument");
                                                 else                                                  else
                                                         v[i++] = vl0->v;                                                          v[i++]=vl0->v;
                                 if ( i != 1 )                                  if(i != 1 )
                                         error("ifplot : invalid argument");                                          error("ifplot : invalid argument");
                                 break;                                  break;
                         case O_LIST:                          case O_LIST:
                                 list = (LIST)BDY(arg);                                  list=(LIST)BDY(arg);
                                 if ( OID(BDY(BDY(list))) == O_P )                                  if(OID(BDY(BDY(list)))==O_P )
                                         if ( ri > 0 )                                          if(ri > 0 )
                                                 error("plot : invalid argument");                                                  error("plot : invalid argument");
                                         else                                          else
                                                 range[ri++] = list;                                                  range[ri++]=list;
                                 else                                  else
                                         geom = list;                                          geom=list;
                                 break;                                  break;
                         case O_N:                          case O_N:
                                 stream = QTOS((Q)BDY(arg)); break;                                  stream=QTOS((Q)BDY(arg));break;
                         case O_STR:                          case O_STR:
                                 wname = (STRING)BDY(arg); break;                                  wname=(STRING)BDY(arg);break;
                         default:                          default:
                                 error("plot : invalid argument"); break;                                  error("plot : invalid argument");break;
                 }                  }
         if ( !poly )          if(!poly )
                 error("plot : invalid argument");                  error("plot : invalid argument");
         switch ( ri ) {          switch ( ri ){
                 case 0:                  case 0:
                         MKV(v[0],var); MKNODE(n,var,defrange); MKLIST(xrange,n);                          MKV(v[0],var);MKNODE(n,var,defrange);MKLIST(xrange,n);
                         break;                          break;
                 case 1:                  case 1:
                         av[0] = VR((P)BDY(BDY(range[0])));                          av[0]=VR((P)BDY(BDY(range[0])));
                         if ( v[0] == av[0] )                          if(v[0]==av[0] )
                                 xrange = range[0];                                  xrange=range[0];
                         else                          else
                                 error("plot : invalid argument");                                  error("plot : invalid argument");
                         break;                          break;
                 default:                  default:
                         error("plot : cannot happen"); break;                          error("plot : cannot happen");break;
         }          }
         /* conplot in ox_plot requires          /* conplot in ox_plot requires
            [s_id (Q),             [s_id (Q),
Line 1146  void plot_main(NODE arg,int is_memory,Obj *rp)
Line 514  void plot_main(NODE arg,int is_memory,Obj *rp)
                 geom=[xsize,ysize] (LIST),                  geom=[xsize,ysize] (LIST),
                 wname=name (STRING)]                  wname=name (STRING)]
         */          */
         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(n,w300,n0); MKLIST(geom,n);                  MKNODE(n0,w300,0);MKNODE(n,w300,n0);MKLIST(geom,n);
         }          }
         if ( is_memory ) {          if(is_memory ){
                 MKSTR(fname,"memory_plot");                  MKSTR(fname,"memory_plot");
                 arg = mknode(7,s_id,fname,poly,xrange,NULLP,NULLP,geom);                  arg=mknode(7,s_id,fname,poly,xrange,NULLP,NULLP,geom);
                 Pox_rpc(arg,&t);                  Pox_rpc(arg,&t);
                 arg = mknode(1,s_id);                  arg=mknode(1,s_id);
                 Pox_pop_cmo(arg,rp);                  Pox_pop_cmo(arg,rp);
         } else {          } else {
                 MKSTR(fname,"plot");                  MKSTR(fname,pfunc[fn]);
                 arg = mknode(8,s_id,fname,poly,xrange,NULLP,NULLP,geom,wname);                  arg=mknode(8,s_id,fname,poly,xrange,NULLP,NULLP,geom,wname);
                 Pox_rpc(arg,&t);                  Pox_rpc(arg,&t);
                 *rp = (Obj)s_id;                  *rp=(Obj)s_id;
         }          }
 }  }
   
 #define Pi 3.14159265358979323846264  #define Pi 3.14159265358979323846264
   
 void Ppolarplot(NODE arg,Q *rp)  void Ppolarplot(NODE arg,Obj *rp){
 {  
         Q m2,p2,w300,s_id;          Q m2,p2,w300,s_id;
         NODE defrange;          NODE defrange;
         LIST zrange,range[1],list,geom;          LIST zrange,range[1],list,geom;
Line 1184  void Ppolarplot(NODE arg,Q *rp)
Line 551  void Ppolarplot(NODE arg,Q *rp)
         Obj t;          Obj t;
   
         MKReal(2*Pi,pi2);          MKReal(2*Pi,pi2);
         MKNODE(n,pi2,0); MKNODE(defrange,0,n);          MKNODE(n,pi2,0);MKNODE(defrange,0,n);
         poly = 0; vl = 0; geom = 0; wname = 0; stream = -1; ri = 0;          poly=0;vl=0;geom=0;wname=0;stream=-1;ri=0;
         v[0] = 0;          v[0]=0;
         for ( ; arg; arg = NEXT(arg) )          for(;arg;arg=NEXT(arg) )
                 if ( !BDY(arg) )                  if(!BDY(arg) )
                         stream = 0;                          stream=0;
                 else                  else
                 switch ( OID(BDY(arg)) ) {                  switch ( OID(BDY(arg)) ){
                         case O_P: case O_R:                          case O_P: case O_R:
                                 poly = (P)BDY(arg);                                  poly=(P)BDY(arg);
                                 get_vars_recursive((Obj)poly,&vl);                                  get_vars_recursive((Obj)poly,&vl);
                                 for ( vl0 = vl, i = 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 ( i >= 1 )                                                  if(i >= 1 )
                                                         error("polarplot : invalid argument");                                                          error("polarplot : invalid argument");
                                                 else                                                  else
                                                         v[i++] = vl0->v;                                                          v[i++]=vl0->v;
                                 if ( i != 1 )                                  if(i != 1 )
                                         error("polarplot : invalid argument");                                          error("polarplot : invalid argument");
                                 break;                                  break;
                         case O_LIST:                          case O_LIST:
                                 list = (LIST)BDY(arg);                                  list=(LIST)BDY(arg);
                                 if ( OID(BDY(BDY(list))) == O_P )                                  if(OID(BDY(BDY(list)))==O_P )
                                         if ( ri > 0 )                                          if(ri > 0 )
                                                 error("polarplot : invalid argument");                                                  error("polarplot : invalid argument");
                                         else                                          else
                                                 range[ri++] = list;                                                  range[ri++]=list;
                                 else                                  else
                                         geom = list;                                          geom=list;
                                 break;                                  break;
                         case O_N:                          case O_N:
                                 stream = QTOS((Q)BDY(arg)); break;                                  stream=QTOS((Q)BDY(arg));break;
                         case O_STR:                          case O_STR:
                                 wname = (STRING)BDY(arg); break;                                  wname=(STRING)BDY(arg);break;
                         default:                          default:
                                 error("polarplot : invalid argument"); break;                                  error("polarplot : invalid argument");break;
                 }                  }
         if ( !poly )          if(!poly )
                 error("polarplot : invalid argument");                  error("polarplot : invalid argument");
         switch ( ri ) {          switch ( ri ){
                 case 0:                  case 0:
                         MKV(v[0],var); MKNODE(n,var,defrange); MKLIST(zrange,n);                          MKV(v[0],var);MKNODE(n,var,defrange);MKLIST(zrange,n);
                         break;                          break;
                 case 1:                  case 1:
                         av[0] = VR((P)BDY(BDY(range[0])));                          av[0]=VR((P)BDY(BDY(range[0])));
                         if ( v[0] == av[0] )                          if(v[0]==av[0] )
                                 zrange = range[0];                                  zrange=range[0];
                         else                          else
                                 error("polarplot : invalid argument");                                  error("polarplot : invalid argument");
                         break;                          break;
                 default:                  default:
                         error("polarplot : cannot happen"); break;                          error("polarplot : cannot happen");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(n,w300,n0); MKLIST(geom,n);                  MKNODE(n0,w300,0);MKNODE(n,w300,n0);MKLIST(geom,n);
         }          }
         MKSTR(fname,"plot");          MKSTR(fname,pfunc[MODE_POLARPLOT]);
         arg = mknode(8,s_id,fname,poly,NULLP,NULLP,zrange,geom,wname);          arg=mknode(8,s_id,fname,poly,NULLP,NULLP,zrange,geom,wname);
         Pox_rpc(arg,&t);          Pox_rpc(arg,&t);
         *rp = s_id;          *rp=(Obj)s_id;
 }  }
   
 void Pplotover(NODE arg,Q *rp)  void Pplotover(NODE arg,Obj *rp){
 {          Q s_id,w_id,color;
         Q s_id,index;  
         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);
         index = (Q)ARG2(arg);          if(argc(arg)==4)color=(Q)ARG3(arg);
           else color=0;
         MKSTR(fname,"plotover");          MKSTR(fname,"plotover");
         if ( argc(arg) == 4 )          arg=mknode(5,s_id,fname,w_id,poly,color);
                 arg = mknode(5,s_id,fname,index,poly,(Q)ARG3(arg));  
         else  
                 arg = mknode(4,s_id,fname,index,poly);  
         Pox_rpc(arg,&t);          Pox_rpc(arg,&t);
         *rp = s_id;          *rp=(Obj)s_id;
 }  }
   
 /* arg = [x,y,r,s_id,index] */  void Pdrawcircle(NODE arg,Obj *rp){
   
 void Pdrawcircle(NODE arg,Q *rp)  
 {  
         Q s_id,index;          Q s_id,index;
         Obj x,y,r,c;          Obj x,y,r,c,t;
         STRING fname;          STRING fname;
         NODE n;          NODE n;
         LIST pos;          LIST pos;
         Obj t;  
   
         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); MKLIST(pos,n);          n=mknode(3,x,y,r,c);
         arg = mknode(5,s_id,fname,index,pos,c);          MKLIST(pos,n);
           arg=mknode(5,s_id,fname,index,pos,c);
         Pox_rpc(arg,&t);          Pox_rpc(arg,&t);
         *rp = s_id;          *rp=(Obj)s_id;
 }  }
   
 /* draw_obj(s_id,cindex,point|line); point = [x,y], line = [xa,ya,xb,yb] */  void Pdraw_obj(NODE arg,Obj *rp){
 void Pdraw_obj(NODE arg,Q *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 ) {          if(!fname)MKSTR(fname,"draw_obj");
                 MKSTR(fname,"draw_obj");          s_id=(Q)ARG0(arg);
         }          index=(Q)ARG1(arg);
         s_id = (Q)ARG0(arg);          obj=(LIST)ARG2(arg);
         index = (Q)ARG1(arg);          // ARG3(arg)=color
         obj = (LIST)ARG2(arg);          if(argc(arg)==4) arg=mknode(5,s_id,fname,index,obj,ARG3(arg));
         /* ARG3(arg) = color */          else arg=mknode(4,s_id,fname,index,obj);
         if ( argc(arg) == 4 )  
                 arg = mknode(5,s_id,fname,index,obj,ARG3(arg));  
         else  
                 arg = mknode(4,s_id,fname,index,obj);  
         Pox_cmo_rpc(arg,&t);          Pox_cmo_rpc(arg,&t);
         *rp = s_id;          *rp=(Obj)s_id;
 }  }
   
 /* draw_string(s_id,cindex,pos,string,[,color]); pos=[x,y] */  void Pdraw_string(NODE arg,Obj *rp){
 void Pdraw_string(NODE arg,Q *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 ) {          if(!fname)MKSTR(fname,"draw_string");
                 MKSTR(fname,"draw_string");          s_id=(Q)ARG0(arg);
         }          index=(Q)ARG1(arg);
         s_id = (Q)ARG0(arg);          pos=(LIST)ARG2(arg);
         index = (Q)ARG1(arg);          str=(STRING)ARG3(arg);
         pos = (LIST)ARG2(arg);          // ARG4(arg)=color
         str = (STRING)ARG3(arg);          if(argc(arg)==5) arg=mknode(6,s_id,fname,index,pos,str,ARG4(arg));
         /* ARG4(arg) = color */          else arg=mknode(5,s_id,fname,index,pos,str);
         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);  
         Pox_cmo_rpc(arg,&t);          Pox_cmo_rpc(arg,&t);
         *rp = s_id;          *rp=(Obj)s_id;
 }  }
   
 void Pclear_canvas(NODE arg,Q *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 ) {          if(!fname) MKSTR(fname,"clear_canvas");
                 MKSTR(fname,"clear_canvas");          s_id=(Q)ARG0(arg);
         }          index=(Q)ARG1(arg);
         s_id = (Q)ARG0(arg);          arg=mknode(3,s_id,fname,index);
         index = (Q)ARG1(arg);  
         arg = mknode(3,s_id,fname,index);  
         Pox_cmo_rpc(arg,&t);          Pox_cmo_rpc(arg,&t);
         *rp = s_id;          *rp=(Obj)s_id;
 }  }
   //****************************ifplotNG
   /*
    * name ifplot,ineqn,ineqnor,ineqnand,ineqnxor,conplot
    * type
    *  D:sign character using double
    *  Q:sign character use rational
    *  B:Boundary character use sturm theorem
    */
   void ListCheck(char * head,LIST list){
           int i;
           NODE n;
           printf("%s\n",head);
           if(!list){
                   printf("zero list\n");
                   return;
           }
           for(i=0,n=(NODE)BDY(list);n;i++,n=NEXT(n)){
                   if(!BDY(n))printf("%d 0\n",i);
                   else if(OID(BDY(n))==O_P) printf("%d poly\n",i);
                   else printf("%d %d\n",i,QTOS((Q)BDY(n)));
           }
   }
   
 #if 0  void PifplotD(NODE arg,Obj *rp){ifplot_mainNG(arg,MODE_IFPLOTD,rp);}
 void Parrayplot(NODE arg,Obj *rp)  void PifplotQ(NODE arg,Obj *rp){ifplot_mainNG(arg,MODE_IFPLOTQ,rp);}
 {  void PifplotB(NODE arg,Obj *rp){ifplot_mainNG(arg,MODE_IFPLOTB,rp);}
         int s;  
         int id;  
   
         if ( ID((Obj)ARG0(arg)) == O_VECT && ID((Obj)ARG1(arg)) == O_LIST ) {  void PconplotD(NODE arg,Obj *rp){ifplot_mainNG(arg,MODE_CONPLOTD,rp);}
                 s = current_s;  void PconplotQ(NODE arg,Obj *rp){ifplot_mainNG(arg,MODE_CONPLOTQ,rp);}
                 gensend(s,C_APLOT,0);  void PconplotB(NODE arg,Obj *rp){ifplot_mainNG(arg,MODE_CONPLOTB,rp);}
                 gensend(s,C_OBJ,ARG0(arg)); gensend(s,C_OBJ,ARG1(arg)); genflush(s);  
   void PineqnD(NODE arg,Obj *rp){ifplot_mainNG(arg,MODE_INEQND,rp);}
   void PineqnQ(NODE arg,Obj *rp){ifplot_mainNG(arg,MODE_INEQNQ,rp);}
   void PineqnB(NODE arg,Obj *rp){ifplot_mainNG(arg,MODE_INEQNB,rp);}
   
   #if defined(INTERVAL)
   void Pitvifplot(NODE arg,Obj *rp){ifplot_mainNG(arg,MODE_ITVIFPLOT,rp);}
   #endif
   
   void PineqnorD(NODE arg,Obj *rp){ifplot_mainOP(arg,MODE_INEQNORD,rp);}
   void PineqnorQ(NODE arg,Obj *rp){ifplot_mainOP(arg,MODE_INEQNORQ,rp);}
   void PineqnorB(NODE arg,Obj *rp){ifplot_mainOP(arg,MODE_INEQNORB,rp);}
   
   void PineqnandD(NODE arg,Obj *rp){ifplot_mainOP(arg,MODE_INEQNANDD,rp);}
   void PineqnandQ(NODE arg,Obj *rp){ifplot_mainOP(arg,MODE_INEQNANDQ,rp);}
   void PineqnandB(NODE arg,Obj *rp){ifplot_mainOP(arg,MODE_INEQNANDB,rp);}
   
   void PineqnxorD(NODE arg,Obj *rp){ifplot_mainOP(arg,MODE_INEQNXORD,rp);}
   void PineqnxorQ(NODE arg,Obj *rp){ifplot_mainOP(arg,MODE_INEQNXORQ,rp);}
   void PineqnxorB(NODE arg,Obj *rp){ifplot_mainOP(arg,MODE_INEQNXORB,rp);}
   
   void PplotoverD(NODE arg,Obj *rp){plotover_mainNG(arg,MODE_PLOTOVERD,rp);}
   void PplotoverQ(NODE arg,Obj *rp){plotover_mainNG(arg,MODE_PLOTOVERQ,rp);}
   void PplotoverB(NODE arg,Obj *rp){plotover_mainNG(arg,MODE_PLOTOVERB,rp);}
   
   void ifplot_mainNG(NODE arg,int fn,Obj *rp){
           Q m2,p2,w300,mxgc,s_id,color,idv;
           NODE defrange,n,n0,n1,n2;
           P poly,var;
           VL vl,vl0;
           V v[2],av;
           LIST xrange,yrange,zrange,geom,range[2],list[4];
           int stream,ri,i,j,sign,llen,len,iNo,lNo,vNo,sNo,pfine,findG;
           STRING fname,wname;
           Obj t,frst,sec,thr;
           char ebuf[BUFSIZ];
   
           iNo=lNo=sNo=findG=0;pfine=TRUE;
           poly=0;stream=-1;wname=0;color=0;idv=0;stream=0;
           STOQ(-2,m2);STOQ(2,p2);MKNODE(n,p2,0);MKNODE(defrange,m2,n);
           STOQ(MAXGC,mxgc);
           for(;arg;arg=NEXT(arg)){
                   if(!BDY(arg)) iNo++;
                   else switch(OID(BDY(arg))){
                   case O_P://formular
                           if(pfine){
                                   poly=(P)BDY(arg);
                                   pfine=FALSE;
                           } else {
                                   sprintf(ebuf,"%s : to many ploy arguments",pfunc[fn]);
                                   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;
                           case 2: //division arg
                                   if(fn==MODE_ITVIFPLOT){//itvifplot
                                           idv=(Q)BDY(arg);
                                           iNo++;
                                   } else {//others
                                           sprintf(ebuf,"%s : invalid number arguments",pfunc[fn]);
                                           error(ebuf);
                                   }
                                   break;
                           case 3:// error
                                   sprintf(ebuf,"%s : invalid number arguments",pfunc[fn]);
                                   error(ebuf);
                                   break;
                           }
                           break;
                   case O_LIST://xrange,yrange,zrange,geometry
                           if(lNo<4) list[lNo++]=(LIST)BDY(arg);
                           else {
                                   sprintf(ebuf,"%s : invalid list argument",pfunc[fn]);
                                   error(ebuf);
                           }
                           break;
                   case O_STR://wname
                           wname=(STRING)BDY(arg);
                           sNo++;
                           break;
                   default:
                           break;
                   }
         }          }
         genrecv(s,&id,rp);          // formular check
           if(!poly){
                   sprintf(ebuf,"%s : invalid ploy argument",pfunc[fn]);
                   error(ebuf);
           }
           // vars check
           get_vars_recursive((Obj)poly,&vl);
           for(vl0=vl,vNo=0;vl0;vl0=NEXT(vl0))
                   if(vl0->v->attr==(pointer)V_IND)
                           if(vNo>=2){
                                   sprintf(ebuf,"%s : invalid ploy argument",pfunc[fn]);
                                   error(ebuf);
                           } else v[vNo++]=vl0->v;
           //list check
           xrange=yrange=zrange=geom=0;frst=sec=thr=0;
           for(i=0;i<lNo;i++){
                   for(llen=0,n=(NODE)BDY(list[i]);n;llen++,n=NEXT(n));
                   if(llen>4){
                           sprintf(ebuf,"%s : invalid list length",pfunc[fn]);
                           error(ebuf);
                   }
                   if(OID(BDY(BDY(list[i])))!=O_P){
                           // First list value is number
                           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 thr=BDY(n);
                           }
                           switch(len){
                           case 2:
                                   if(!zrange){
                                           if(thr==0)thr=(Obj)mxgc;
                                           MKNODE(n,thr,0);MKNODE(n1,sec,n);MKNODE(n2,frst,n1);MKLIST(zrange,n2);
                                   } else geom=list[i];
                                   break;
                           case 3:
                                   zrange=list[i];
                                   break;
                           case 0:
                           case 1:
                           default:
                                   sprintf(ebuf,"%s : invalid list length",pfunc[fn]);
                                   error(ebuf);
                                   break;
                           }
                   } else {
                           //xrange,yrange
                           av=VR((P)BDY(BDY(list[i])));
                           if(v[0]==av)xrange=list[i];
                           else if(v[1]==av)yrange=list[i];
                           else {
                                   MKLIST(zrange,NEXT(BDY(list[i])));
                           }
                   }
           }
           //set default
           if(!xrange){
                   MKV(v[0],var);MKNODE(n,var,defrange);MKLIST(xrange,n);
           }
           if(!yrange){
                   MKV(v[1],var);MKNODE(n,var,defrange);MKLIST(yrange,n);
           }
           if(!geom){
                   STOQ(300,w300);MKNODE(n0,w300,0);MKNODE(n,w300,n0);MKLIST(geom,n);
           }
           if(fn==MODE_CONPLOTD||fn==MODE_CONPLOTQ||fn==MODE_CONPLOTB) if(!zrange){
                   MKNODE(n,mxgc,0);MKNODE(n1,m2,n);MKNODE(n2,m2,n1);MKLIST(zrange,n2);
           }
           /*new ifplot in ox_plot requires
                   [s_id (Q),
                   formula (Obj),
                   color (Q),
                   geom=[xsize,ysize] (LIST optional),
                   xrange=[x,xmin,xmax] (LIST optional),
                   yrange=[y,ymin,ymax] (LIST optional),
                   zrange=[zmin,zmax,zstep] (LIST optional),
                   wname=name (STRING optional)],
                   itvstep (Q) if MODE_ITVIFPLOT */
           stream=validate_ox_plot_stream(stream);
           STOQ(stream,s_id);
           MKSTR(fname,pfunc[fn]);
   /*
   printf("%s\n",pfunc[fn]);
   ListCheck("xrange",xrange);
   ListCheck("yrange",yrange);
   ListCheck("zrange",zrange);
   ListCheck("geom",geom);
   */
           if(fn==MODE_ITVIFPLOT)
                   arg=mknode(10,s_id,fname,poly,color,xrange,yrange,zrange,geom,wname,idv);
           else arg=mknode(9,s_id,fname,poly,color,xrange,yrange,zrange,geom,wname);
           Pox_rpc(arg,&t);
           *rp=(Obj)s_id;
 }  }
 #endif  
   void ifplot_mainOP(NODE arg,int fn,Obj *rp){
           /*
                   new ineqnXX in ox_plot requires
                   [s_id (Q),
                   w_id (Q),
                   formula (Obj),
                   color (Q)]
           */
           Q s_id,w_id,color;
           P poly;
           STRING fname;
           Obj t;
           int iNo,pfine,sfine;
           char ebuf[BUFSIZ];
   
           pfine=sfine=TRUE;
           iNo=0;poly=0;color=s_id=w_id=0;
           for(;arg;arg=NEXT(arg)){
                   if(!BDY(arg)) iNo++;
                   else switch(OID(BDY(arg))){
                   case O_P://formular
                           if(pfine){
                                   poly=(P)BDY(arg);
                                   pfine=FALSE;
                           } else {
                                   sprintf(ebuf,"%s : to many ploy arguments",pfunc[fn]);
                                   error(ebuf);
                           }
                           break;
                   case O_N://color,s_id,w_id
                           switch(iNo){
                           case 0://color arg
                                   color=(Q)BDY(arg);
                                   iNo++;
                                   break;
                           case 1://stream arg
                                   s_id=(Q)BDY(arg);
                                   iNo++;
                                   break;
                           case 2://window arg
                                   w_id=(Q)BDY(arg);
                                   iNo++;
                                   break;
                           default://error
                                   sprintf(ebuf,"%s : to many numbers",pfunc[fn]);
                                   error(ebuf);
                                   break;
                           }
                           break;
                   default:
                           sprintf(ebuf,"%s : arguments type miss match",pfunc[fn]);
                           error(ebuf);
                   }
           }
           MKSTR(fname,pfunc[fn]);
   /*
   printf("fname %s\n",BDY(fname));
   printf("s_id %d\n",QTOS((Q)s_id));
   printf("w_id %d\n",QTOS((Q)w_id));
   printf("color %d\n",QTOS((Q)color));
   */
           arg=mknode(5,s_id,fname,w_id,poly,color);
           Pox_rpc(arg,&t);
           *rp=(Obj)s_id;
   }
   
   void plotover_mainNG(NODE arg,int fn,Obj *rp){
           /*
                   [s_id (Q),
                   w_id (Q),
                   formula (Obj),
                   color (Q)]
           */
           Q s_id,w_id,color;
           P poly;
           STRING fname;
           Obj t;
           int iNo,pfine,sfine;
           char ebuf[BUFSIZ];
   
           pfine=sfine=TRUE;
           iNo=0;poly=0;color=s_id=w_id=0;
           for(;arg;arg=NEXT(arg)){
                   if(!BDY(arg)) iNo++;
                   else switch(OID(BDY(arg))){
                   case O_P://formular
                           if(pfine){
                                   poly=(P)BDY(arg);
                                   pfine=FALSE;
                           } else {
                                   sprintf(ebuf,"%s : to many ploy arguments",pfunc[fn]);
                                   error(ebuf);
                           }
                           break;
                   case O_N://color,s_id,w_id
                           switch(iNo){
                           case 0://color arg
                                   color=(Q)BDY(arg);
                                   iNo++;
                                   break;
                           case 1://stream arg
                                   s_id=(Q)BDY(arg);
                                   iNo++;
                                   break;
                           case 2://window arg
                                   w_id=(Q)BDY(arg);
                                   iNo++;
                                   break;
                           default://error
                                   sprintf(ebuf,"%s : to many numbers",pfunc[fn]);
                                   error(ebuf);
                                   break;
                           }
                           break;
                   default:
                           sprintf(ebuf,"%s : arguments type miss match",pfunc[fn]);
                           error(ebuf);
                   }
           }
           MKSTR(fname,pfunc[fn]);
   /*
   printf("fname %s\n",BDY(fname));
   printf("s_id %d\n",QTOS((Q)s_id));
   printf("w_id %d\n",QTOS((Q)w_id));
   printf("color %d\n",QTOS((Q)color));
   */
           arg=mknode(5,s_id,fname,w_id,poly,color);
           Pox_rpc(arg,&t);
           *rp=(Obj)s_id;
   }
Legend:
Removed from v.1.23  
changed lines
  Added in v.1.24
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>