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

Diff for /OpenXM_contrib2/asir2000/plot/ox_plot.c between version 1.3 and 1.31

version 1.3, 2000/04/13 06:51:09 version 1.31, 2018/03/29 01:32:55
Line 1 
Line 1 
 /* $OpenXM: OpenXM_contrib2/asir2000/plot/ox_plot.c,v 1.2 2000/02/08 04:47:13 noro Exp $ */  /*
    * Copyright (c) 1994-2000 FUJITSU LABORATORIES LIMITED
    * All rights reserved.
    *
    * FUJITSU LABORATORIES LIMITED ("FLL") hereby grants you a limited,
    * non-exclusive and royalty-free license to use, copy, modify and
    * redistribute, solely for non-commercial and non-profit purposes, the
    * computer program, "Risa/Asir" ("SOFTWARE"), subject to the terms and
    * conditions of this Agreement. For the avoidance of doubt, you acquire
    * only a limited right to use the SOFTWARE hereunder, and FLL or any
    * third party developer retains all rights, including but not limited to
    * copyrights, in and to the SOFTWARE.
    *
    * (1) FLL does not grant you a license in any way for commercial
    * purposes. You may use the SOFTWARE only for non-commercial and
    * non-profit purposes only, such as academic, research and internal
    * business use.
    * (2) The SOFTWARE is protected by the Copyright Law of Japan and
    * international copyright treaties. If you make copies of the SOFTWARE,
    * with or without modification, as permitted hereunder, you shall affix
    * to all such copies of the SOFTWARE the above copyright notice.
    * (3) An explicit reference to this SOFTWARE and its copyright owner
    * shall be made on your publication or presentation in any form of the
    * results obtained by use of the SOFTWARE.
    * (4) In the event that you modify the SOFTWARE, you shall notify FLL by
    * e-mail at risa-admin@sec.flab.fujitsu.co.jp of the detailed specification
    * for such modification or the source code of the modified part of the
    * SOFTWARE.
    *
    * THE SOFTWARE IS PROVIDED AS IS WITHOUT ANY WARRANTY OF ANY KIND. FLL
    * MAKES ABSOLUTELY NO WARRANTIES, EXPRESSED, IMPLIED OR STATUTORY, AND
    * EXPRESSLY DISCLAIMS ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS
    * FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT OF THIRD PARTIES'
    * RIGHTS. NO FLL DEALER, AGENT, EMPLOYEES IS AUTHORIZED TO MAKE ANY
    * MODIFICATIONS, EXTENSIONS, OR ADDITIONS TO THIS WARRANTY.
    * UNDER NO CIRCUMSTANCES AND UNDER NO LEGAL THEORY, TORT, CONTRACT,
    * OR OTHERWISE, SHALL FLL BE LIABLE TO YOU OR ANY OTHER PERSON FOR ANY
    * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, PUNITIVE OR CONSEQUENTIAL
    * DAMAGES OF ANY CHARACTER, INCLUDING, WITHOUT LIMITATION, DAMAGES
    * ARISING OUT OF OR RELATING TO THE SOFTWARE OR THIS AGREEMENT, DAMAGES
    * FOR LOSS OF GOODWILL, WORK STOPPAGE, OR LOSS OF DATA, OR FOR ANY
    * DAMAGES, EVEN IF FLL SHALL HAVE BEEN INFORMED OF THE POSSIBILITY OF
    * SUCH DAMAGES, OR FOR ANY CLAIM BY ANY OTHER PARTY. EVEN IF A PART
    * OF THE SOFTWARE HAS BEEN DEVELOPED BY A THIRD PARTY, THE THIRD PARTY
    * DEVELOPER SHALL HAVE NO LIABILITY IN CONNECTION WITH THE USE,
    * PERFORMANCE OR NON-PERFORMANCE OF THE SOFTWARE.
    *
    * $OpenXM: OpenXM_contrib2/asir2000/plot/ox_plot.c,v 1.30 2017/08/30 09:40:30 ohara 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"
 #include "version.h"  #include "version.h"
 #include <signal.h>  #include <signal.h>
 #if PARI  #if defined(PARI)
 #include "genpari.h"  #include "genpari.h"
 #endif  #endif
   
 void ox_usr1_handler();  extern int asir_OperandStackSize;
   extern Obj *asir_OperandStack;
   extern int asir_OperandStackPtr;
   
   // environement is defined in libpari.a
   #if !(PARI_VERSION_CODE > 131588)
 extern jmp_buf environnement;  extern jmp_buf environnement;
   #endif
   
 extern int do_message;  extern int do_message;
 extern int ox_flushing;  extern int ox_flushing;
 extern jmp_buf ox_env;  extern JMP_BUF ox_env;
 extern MATHCAP my_mathcap;  extern MATHCAP my_mathcap;
   extern char LastError[];
   
 static int plot_OperandStackSize;  void create_error(ERR *,unsigned int ,char *,LIST );
 static Obj *plot_OperandStack;  
 static int plot_OperandStackPtr = -1;  
   
 static void create_error(ERR *,unsigned int ,char *);  void ox_io_init();
   void ox_asir_init(int,char **,char *);
   Obj asir_pop_one();
   void asir_push_one(Obj);
   void asir_end_flush();
   int asir_executeString();
   void asir_evalName(unsigned int);
   void asir_setName(unsigned int);
   void asir_pops();
   void asir_popString();
   void asir_popCMO(unsigned int);
   void asir_popSerializedLocalObject();
   char *name_of_cmd(unsigned int);
   char *name_of_id(int);
   LIST asir_GetErrorList();
   
   static void asir_do_cmd(unsigned int,unsigned int);
 static void process_ox();  static void process_ox();
 static void ox_io_init();  
 static void ox_asir_init(int,char **);  
 static Obj asir_pop_one();  
 static void asir_push_one(Obj);  
 static void asir_end_flush();  
 static void asir_executeFunction();  static void asir_executeFunction();
 static int asir_executeString();  
 static void asir_evalName(unsigned int);  
 static void asir_setName(unsigned int);  
 static void asir_pops();  
 static void asir_popString();  
 static void asir_popCMO(unsigned int);  
 static void asir_popSerializedLocalObject();  
 static char *name_of_cmd(unsigned int);  
 static char *name_of_id(int);  
 static void asir_do_cmd(unsigned int,unsigned int);  
   
 static void create_error(ERR *err,unsigned int serial,char *msg)  #if defined(VISUAL) || defined(__MINGW32__)
   void ox_plot_main()
   #else
   void ox_plot_main(int argc,char **argv)
   #endif
 {  {
         USINT ui;    int ds;
         NODE n,n1;    fd_set r;
         LIST list;    int n;
         STRING errmsg;    int use_x;
   
         MKUSINT(ui,serial);  #if !defined(VISUAL) && !defined(__MINGW32__)
         MKSTR(errmsg,msg);    ox_asir_init(argc,argv,"ox_plot");
         MKNODE(n1,errmsg,0); MKNODE(n,ui,n1); MKLIST(list,n);    use_x=init_plot_display(argc,argv);
         MKERR(*err,list);    if(use_x) ds=ConnectionNumber(display);
 }    else fprintf(stderr,"Entering no X mode\n");
   
 void ox_plot_main(int argc,char **argv) {  
         int ds;  
         fd_set r;  
         int n;  
   
         ox_asir_init(argc,argv);  
         init_plot_display(argc,argv);  
         ds = ConnectionNumber(display);  
         if ( do_message )  
                 fprintf(stderr,"I'm an ox_plot, Version %d.\n",ASIR_VERSION);  
   
         if ( setjmp(ox_env) ) {  
                 while ( NEXT(asir_infile) )  
                         closecurrentinput();  
                 reset_current_computation();  
                 ox_send_sync(0);  
         }  
         while ( 1 ) {  
                 if ( ox_data_is_available(0) )  
                         process_ox();  
                 else {  
                         FD_ZERO(&r);  
                         FD_SET(3,&r); FD_SET(ds,&r);  
                         select(FD_SETSIZE,&r,NULL,NULL,NULL);  
                         if ( FD_ISSET(3,&r) )  
                                 process_ox();  
                         else if ( FD_ISSET(ds,&r) )  
                                 process_xevent();  
                 }  
         }  
 }  
   
 static void process_ox()  
 {  
         int id;  
         unsigned int cmd;  
         Obj obj;  
         ERR err;  
         unsigned int serial;  
         int ret;  
         extern char LastError[];  
   
         serial = ox_recv(0,&id,&obj);  
         if ( do_message )  
                 fprintf(stderr,"#%d Got %s",serial,name_of_id(id));  
         switch ( id ) {  
                 case OX_COMMAND:  
                         cmd = ((USINT)obj)->body;  
                         if ( ox_flushing )  
                                 break;  
                         if ( do_message )  
                                 fprintf(stderr," %s\n",name_of_cmd(cmd));  
                         if ( ret = setjmp(env) ) {  
                                 if ( ret == 1 ) {  
                                         create_error(&err,serial,LastError);  
                                         asir_push_one((Obj)err);  
                                 }  
                                 break;  
                         }  
                         asir_do_cmd(cmd,serial);  
                         break;  
                 case OX_DATA:  
                 case OX_LOCAL_OBJECT_ASIR:  
                         if ( ox_flushing )  
                                 break;  
                         if ( do_message )  
                                 fprintf(stderr," -> data pushed");  
                         asir_push_one(obj);  
                         break;  
                 case OX_SYNC_BALL:  
                                 asir_end_flush();  
                         break;  
                 default:  
                         break;  
         }  
         if ( do_message )  
                 fprintf(stderr,"\n");  
 }  
   
 static void asir_do_cmd(unsigned int cmd,unsigned int serial)  
 {  
         MATHCAP client_mathcap;  
   
         switch ( cmd ) {  
                 case SM_popSerializedLocalObject:  
                         asir_popSerializedLocalObject();  
                         break;  
                 case SM_popCMO:  
                         asir_popCMO(serial);  
                         break;  
                 case SM_popString:  
                         asir_popString();  
                         break;  
                 case SM_setName:  
                         asir_setName(serial);  
                         break;  
                 case SM_evalName:  
                         asir_evalName(serial);  
                         break;  
                 case SM_executeStringByLocalParser:  
                         asir_executeString();  
                         break;  
                 case SM_executeFunction:  
                         asir_executeFunction();  
                         break;  
                 case SM_shutdown:  
                         asir_terminate(2);  
                         break;  
                 case SM_pops:  
                         asir_pops();  
                         break;  
                 case SM_mathcap:  
                         asir_push_one((Obj)my_mathcap);  
                         break;  
                 case SM_setMathcap:  
                         client_mathcap = (MATHCAP)asir_pop_one();  
                         store_remote_mathcap(0,client_mathcap);  
                         break;  
                 default:  
                         break;  
         }  
 }  
   
 static char *name_of_id(int id)  
 {  
         switch ( id ) {  
                 case OX_COMMAND:  
                         return "OX_COMMAND";  
                         break;  
                 case OX_DATA:  
                         return "OX_DATA";  
                         break;  
                 case OX_LOCAL_OBJECT_ASIR:  
                         return "OX_LOCAL_OBJECT_ASIR";  
                         break;  
                 case OX_SYNC_BALL:  
                         return "OX_SYNC_BALL";  
                         break;  
                 default:  
                         return "Unknown id";  
                         break;  
         }  
 }  
   
 static char *name_of_cmd(unsigned cmd)  
 {  
         switch ( cmd ) {  
                 case SM_popSerializedLocalObject:  
                         return "SM_popSerializedLocalObject";  
                         break;  
                 case SM_popCMO:  
                         return "SM_popCMO";  
                         break;  
                 case SM_popString:  
                         return "SM_popString";  
                         break;  
                 case SM_pops:  
                         return "SM_pops";  
                         break;  
                 case SM_setName:  
                         return "SM_setName";  
                         break;  
                 case SM_evalName:  
                         return "SM_evalName";  
                         break;  
                 case SM_executeStringByLocalParser:  
                         return "SM_executeString";  
                         break;  
                 case SM_executeFunction:  
                         return "SM_executeFunction";  
                         break;  
                 case SM_shutdown:  
                         return "SM_shutdown";  
                         break;  
                 case SM_beginBlock:  
                         return "SM_beginBlock";  
                         break;  
                 case SM_endBlock:  
                         return "SM_endBlock";  
                         break;  
                 case SM_mathcap:  
                         return "SM_mathcap";  
                         break;  
                 case SM_setMathcap:  
                         return "SM_setMathcap";  
                         break;  
                 default:  
                         return "Unknown cmd";  
                         break;  
         }  
 }  
   
 static void asir_popSerializedLocalObject()  
 {  
         Obj obj;  
         VL t,vl;  
   
         obj = asir_pop_one();  
         get_vars(obj,&vl);  
         for ( t = vl; t; t = NEXT(t) )  
                 if ( t->v->attr == (pointer)V_UC || t->v->attr == (pointer)V_PF )  
                         error("bsave : not implemented");  
         ox_send_cmd(0,SM_beginBlock);  
         ox_send_local_ring(0,vl);  
         ox_send_local_data(0,obj);  
         ox_send_cmd(0,SM_endBlock);  
 }  
   
 static void asir_popCMO(unsigned int serial)  
 {  
         Obj obj;  
         ERR err;  
   
         obj = asir_pop_one();  
         if ( valid_as_cmo(obj) )  
                 ox_send_data(0,obj);  
         else {  
                 create_error(&err,serial,"cannot convert to CMO object");  
                 ox_send_data(0,err);  
                 asir_push_one(obj);  
         }  
 }  
   
 static void asir_popString()  
 {  
         Obj val;  
         char *buf,*obuf;  
         int l;  
         STRING str;  
   
         val = asir_pop_one();  
         if ( !val )  
                 obuf = 0;  
         else {  
                 l = estimate_length(CO,val);  
                 buf = (char *)ALLOCA(l+1);  
                 soutput_init(buf);  
                 sprintexpr(CO,val);  
                 l = strlen(buf);  
                 obuf = (char *)MALLOC(l+1);  
                 strcpy(obuf,buf);  
         }  
         MKSTR(str,obuf);  
         ox_send_data(0,str);  
 }  
   
 static void asir_pops()  
 {  
         int n;  
   
         n = (int)(((USINT)asir_pop_one())->body);  
         plot_OperandStackPtr = MAX(plot_OperandStackPtr-n,-1);  
 }  
   
 static void asir_setName(unsigned int serial)  
 {  
         char *name;  
         int l,n;  
         char *dummy = "=0;";  
         SNODE snode;  
         ERR err;  
   
         name = ((STRING)asir_pop_one())->body;  
         l = strlen(name);  
         n = l+strlen(dummy)+1;  
         parse_strp = (char *)ALLOCA(n);  
         sprintf(parse_strp,"%s%s",name,dummy);  
         if ( mainparse(&snode) ) {  
                 create_error(&err,serial,"cannot set to variable");  
                 asir_push_one((Obj)err);  
         } else {  
                 FA1((FNODE)FA0(snode)) = (pointer)mkfnode(1,I_FORMULA,asir_pop_one());  
                 evalstat(snode);  
         }  
 }  
   
 static void asir_evalName(unsigned int serial)  
 {  
         char *name;  
         int l,n;  
         SNODE snode;  
         ERR err;  
         pointer val;  
   
         name = ((STRING)asir_pop_one())->body;  
         l = strlen(name);  
         n = l+2;  
         parse_strp = (char *)ALLOCA(n);  
         sprintf(parse_strp,"%s;",name);  
         if ( mainparse(&snode) ) {  
                 create_error(&err,serial,"no such variable");  
                 val = (pointer)err;  
         } else  
                 val = evalstat(snode);  
         asir_push_one(val);  
 }  
   
 static int asir_executeString()  
 {  
         SNODE snode;  
         pointer val;  
         char *cmd;  
 #if PARI  
         recover(0);  
         if ( setjmp(environnement) ) {  
                 avma = top; recover(1);  
                 resetenv("");  
         }  
 #endif  #endif
         cmd = ((STRING)asir_pop_one())->body;    if(do_message)fprintf(stderr,"I'm an ox_plot, Version %d.\n",ASIR_VERSION);
         parse_strp = cmd;    if(SETJMP(ox_env)){
         if ( mainparse(&snode) ) {      while(NEXT(asir_infile))closecurrentinput();
                 return -1;      reset_current_computation();
         }      ox_send_sync(0);
         val = evalstat(snode);    }
         if ( NEXT(asir_infile) ) {    while (1){
                 while ( NEXT(asir_infile) ) {  #if defined(VISUAL) || defined(__MINGW32__)
                         if ( mainparse(&snode) ) {      process_ox();
                                 asir_push_one(val);  #else
                                 return -1;      if(ox_data_is_available(0)) process_ox();
                         }      else if(use_x){
                         nextbp = 0;        FD_ZERO(&r);
                         val = evalstat(snode);        FD_SET(3,&r); FD_SET(ds,&r);
                 }        select(FD_SETSIZE,&r,NULL,NULL,NULL);
         }        if(FD_ISSET(3,&r)) process_ox();
         asir_push_one(val);        else if(FD_ISSET(ds,&r)) process_xevent();
         return 0;      }
 }    }
   
 static void asir_executeFunction()  
 {  
         char *func;  
         int argc;  
         int id;  
         FUNC f;  
         Q ret;  
         VL vl;  
         NODE n,n1;  
   
         func = ((STRING)asir_pop_one())->body;  
         argc = (int)(((USINT)asir_pop_one())->body);  
   
         for ( n = 0; argc; argc-- ) {  
                 NEXTNODE(n,n1);  
                 BDY(n1) = (pointer)asir_pop_one();  
         }  
         if ( n )  
                 NEXT(n1) = 0;  
         id = -1;  
         if ( !strcmp(func,"plot") )  
                 id = plot(n);  
         else if ( !strcmp(func,"arrayplot") )  
                 id = arrayplot(n);  
         else if ( !strcmp(func,"plotover") )  
                 id = plotover(n);  
         else if ( !strcmp(func,"drawcircle") )  
                 id = drawcircle(n);  
         STOQ(id,ret);  
 #if 0  
         asir_push_one((Obj)ret);  
 #endif  #endif
 }  }
   
 static void asir_end_flush()  static void process_ox(){
 {    int id;
         ox_flushing = 0;    unsigned int cmd;
 }    Obj obj;
     ERR err;
     unsigned int serial;
     int ret;
   
 static void asir_push_one(Obj obj)    serial=ox_recv(0,&id,&obj);
 {    if(do_message) fprintf(stderr,"#%d Got %s",serial,name_of_id(id));
         if ( !obj || OID(obj) != O_VOID ) {    switch (id){
                 plot_OperandStackPtr++;      case OX_COMMAND:
                 if ( plot_OperandStackPtr >= plot_OperandStackSize ) {        cmd=((USINT)obj)->body;
                         plot_OperandStackSize += BUFSIZ;        if(ox_flushing) break;
                         plot_OperandStack        if(do_message) fprintf(stderr," %s\n",name_of_cmd(cmd));
                                 = (Obj *)REALLOC(plot_OperandStack,        ret=SETJMP(main_env);
                                         plot_OperandStackSize*sizeof(Obj));        if(ret){
                 }          if(ret==1){
                 plot_OperandStack[plot_OperandStackPtr] = obj;            create_error(&err,serial,LastError,0);
         }            asir_push_one((Obj)err);
           }
           break;
         }
         asir_do_cmd(cmd,serial);
         break;
       case OX_DATA:
       case OX_LOCAL_OBJECT_ASIR:
         if(ox_flushing)break;
         if(do_message)fprintf(stderr," -> data pushed");
         asir_push_one(obj);
         break;
       case OX_SYNC_BALL:
         asir_end_flush();
         break;
       default:
         break;
     }
     if(do_message)fprintf(stderr,"\n");
 }  }
   
 static Obj asir_pop_one() {  static void asir_do_cmd(unsigned int cmd,unsigned int serial){
         if ( plot_OperandStackPtr < 0 ) {    MATHCAP client_mathcap;
                 if ( do_message )    LIST list;
                         fprintf(stderr,"OperandStack underflow");    int i;
                 return 0;    Q q;
         } else {  
                 if ( do_message )  
                         fprintf(stderr,"pop at %d\n",plot_OperandStackPtr);  
                 return plot_OperandStack[plot_OperandStackPtr--];  
         }  
 }  
   
 static void ox_asir_init(int argc,char **argv)    switch (cmd){
 {      case SM_dupErrors:
         int tmp;        list=asir_GetErrorList();
         char ifname[BUFSIZ];        asir_push_one((Obj)list);
         extern int GC_dont_gc;        break;
         extern int read_exec_file;      case SM_getsp:
         extern int do_asirrc;        i=asir_OperandStackPtr+1;
         extern int do_server_in_X11;        STOQ(i,q);
         char *getenv();        asir_push_one((Obj)q);
         static ox_asir_initialized = 0;        break;
         FILE *ifp;      case SM_popSerializedLocalObject:
         asir_popSerializedLocalObject();
         do_server_in_X11 = 1; /* XXX */        break;
         asir_save_handler();      case SM_popCMO:
 #if PARI        asir_popCMO(serial);
         risa_pari_init();        break;
 #endif      case SM_popString:
         srandom((int)get_current_time());        asir_popString();
         break;
 #if defined(THINK_C)      case SM_setName:
         param_init();        asir_setName(serial);
 #endif        break;
         StackBottom = &tmp + 1; /* XXX */      case SM_evalName:
         rtime_init();        asir_evalName(serial);
         env_init();        break;
         endian_init();      case SM_executeStringByLocalParser:
 #if !defined(VISUAL) && !defined(THINK_C)        asir_executeString();
 /*      check_key(); */        break;
 #endif      case SM_executeFunction:
         GC_init();        asir_executeFunction(serial);
         process_args(--argc,++argv);        break;
 #if 0      case SM_shutdown:
         copyright();        asir_terminate(2);
 #endif        break;
         output_init();      case SM_pops:
         arf_init();        asir_pops();
         nglob_init();        break;
         glob_init();      case SM_mathcap:
         sig_init();        asir_push_one((Obj)my_mathcap);
         tty_init();        break;
         debug_init();      case SM_setMathcap:
         pf_init();        client_mathcap=(MATHCAP)asir_pop_one();
         sysf_init();        store_remote_mathcap(0,client_mathcap);
         parif_init();        break;
 #if defined(VISUAL)      case SM_nop:
         init_socket();      default:
 #endif        break;
 #if defined(UINIT)    }
         reg_sysf();  
 #endif  
 #if defined(THINK_C)  
         sprintf(ifname,"asirrc");  
 #else  
         sprintf(ifname,"%s/.asirrc",getenv("HOME"));  
 #endif  
         if ( do_asirrc && (ifp = fopen(ifname,"r")) ) {  
                 input_init(ifp,ifname);  
                 if ( !setjmp(env) ) {  
                         read_exec_file = 1;  
                         read_eval_loop();  
                         read_exec_file = 0;  
                 }  
                 fclose(ifp);  
         }  
         input_init(0,"string");  
         ox_io_init();  
         create_my_mathcap("ox_plot");  
 }  }
   
 static void ox_io_init() {  static void asir_executeFunction(int serial){
         unsigned char c,rc;    char *fn;
         extern int little_endian;    int argc,id,fno;
     FUNC f;
     Q ret;
     VL vl;
     ERR err;
     NODE n,n1;
     LIST bytes;
   
         endian_init();    fn=((STRING)asir_pop_one())->body;
         iofp[0].in = fdopen(3,"r");    argc=(int)(((USINT)asir_pop_one())->body);
         iofp[0].out = fdopen(4,"w");    for(n=0;argc;argc--){
         setbuffer(iofp[0].in,(char *)malloc(LBUFSIZ),LBUFSIZ);      NEXTNODE(n,n1);
         setbuffer(iofp[0].out,(char *)malloc(LBUFSIZ),LBUFSIZ);      BDY(n1)=(pointer)asir_pop_one();
         plot_OperandStackSize = BUFSIZ;    }
         plot_OperandStack = (Obj *)CALLOC(plot_OperandStackSize,sizeof(Obj));    if(n)NEXT(n1)=0;
         plot_OperandStackPtr = -1;    id=-1;
         signal(SIGUSR1,ox_usr1_handler);    fno=modeNO(fn);
         if ( little_endian )    switch (fno){
                 c = 1;    case 0://IFPLOT
         else      id=plot(n,fno);
                 c = 0xff;      STOQ(id,ret);
         write_char(iofp[0].out,&c); ox_flush_stream(0);      asir_push_one((Obj)ret);
         read_char(iofp[0].in,&rc);      break;
         iofp[0].conv = c == rc ? 0 : 1;    case 1://CONPLOT
       id=plot(n,fno);
       STOQ(id,ret);
       asir_push_one((Obj)ret);
       break;
     case 2://PLOT
       id=plot(n,fno);
       STOQ(id,ret);
       asir_push_one((Obj)ret);
       break;
     case 4://POLARPLOT
       id=plot(n,fno);
       STOQ(id,ret);
       asir_push_one((Obj)ret);
       break;
     case 30://MEMORY_PLOT
       memory_plot(n,&bytes);
       asir_push_one((Obj)bytes);
       break;
     case 31://ARRAYPLOT
       id=arrayplot(n);
       STOQ(id,ret);
       asir_push_one((Obj)ret);
       break;
     case 32://OPEN_CANVAS
       id=open_canvas(n);
       STOQ(id,ret);
       asir_push_one((Obj)ret);
       break;
     case 5://PLOTOVER
       plotover(n);
       break;
     case 33://DRAWCIRCLE
       drawcircle(n);
       break;
     case 34://DRAW_OBJ
       if(draw_obj(n) < 0 ){
         create_error(&err,serial,LastError,0);
         asir_push_one((Obj)err);
       }
       break;
     case 35://DRAW_STRING
       if(draw_string(n)<0){
         create_error(&err,serial,LastError,0);
         asir_push_one((Obj)err);
       }
       break;
     case 37://CLEAR_CANVAS
       clear_canvas(n);
       break;
   // ifplotNG
     case 36://OBJ_CP
       id=objcp(n);
       STOQ(id,ret);
       asir_push_one((Obj)ret);
       break;
     case 6://IFPLOTD
     case 7://IFPLOTQ
     case 8://IFPLOTB
     case 9://INEQND
     case 10://INEQNQ
     case 11://INEQNB
     case 21://CONPLOTD
     case 22://CONPLOTQ
     case 23://CONPLOTB
   #if defined(INTERVAL)
     case 24://ITVIFPLOT
   #endif
       id=ifplotNG(n,fno);
       STOQ(id,ret);
       asir_push_one((Obj)ret);
       break;
     case 12://INEQNDAND
     case 13://INEQNQAND
     case 14://INEQNBAND
     case 15://INEQNDOR
     case 16://INEQNQOR
     case 17://INEQNBOR
     case 18://INEQNDXOR
     case 19://INEQNQXOR
     case 20://INEQNBXOR
     case 25://PLOTOVERD
     case 26://PLOTOVERQ
     case 27://PLOTOVERB
       id=ifplotOP(n,fno);
       STOQ(id,ret);
       asir_push_one((Obj)ret);
       break;
     case 38://POLARPLOTD
       id=polarplotNG(n);
       STOQ(id,ret);
       asir_push_one((Obj)ret);
       break;
     }
 }  }
Legend:
Removed from v.1.3  
changed lines
  Added in v.1.31
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>