![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to ox_plot.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib2 / asir2000 / plot|
Return to ox_plot.c CVS log | Up to [local] / OpenXM_contrib2 / asir2000 / plot |
1.3 ! noro 1: /* $OpenXM: OpenXM_contrib2/asir2000/plot/ox_plot.c,v 1.2 2000/02/08 04:47:13 noro Exp $ */
1.1 noro 2: #include "ca.h"
3: #include "parse.h"
4: #include "ox.h"
5: #include "ifplot.h"
6: #include "version.h"
1.3 ! noro 7: #include <signal.h>
1.2 noro 8: #if PARI
9: #include "genpari.h"
10: #endif
1.1 noro 11:
12: void ox_usr1_handler();
13:
14: extern jmp_buf environnement;
15:
16: extern int do_message;
17: extern int ox_flushing;
18: extern jmp_buf ox_env;
19: extern MATHCAP my_mathcap;
20:
21: static int plot_OperandStackSize;
22: static Obj *plot_OperandStack;
23: static int plot_OperandStackPtr = -1;
24:
25: static void create_error(ERR *,unsigned int ,char *);
26: static void process_ox();
27: static void ox_io_init();
28: static void ox_asir_init(int,char **);
29: static Obj asir_pop_one();
30: static void asir_push_one(Obj);
31: static void asir_end_flush();
32: static void asir_executeFunction();
33: static int asir_executeString();
34: static void asir_evalName(unsigned int);
35: static void asir_setName(unsigned int);
36: static void asir_pops();
37: static void asir_popString();
38: static void asir_popCMO(unsigned int);
39: static void asir_popSerializedLocalObject();
40: static char *name_of_cmd(unsigned int);
41: static char *name_of_id(int);
42: static void asir_do_cmd(unsigned int,unsigned int);
43:
44: static void create_error(ERR *err,unsigned int serial,char *msg)
45: {
46: USINT ui;
47: NODE n,n1;
48: LIST list;
49: STRING errmsg;
50:
51: MKUSINT(ui,serial);
52: MKSTR(errmsg,msg);
53: MKNODE(n1,errmsg,0); MKNODE(n,ui,n1); MKLIST(list,n);
54: MKERR(*err,list);
55: }
56:
57: void ox_plot_main(int argc,char **argv) {
58: int ds;
59: fd_set r;
60: int n;
61:
62: ox_asir_init(argc,argv);
63: init_plot_display(argc,argv);
64: ds = ConnectionNumber(display);
65: if ( do_message )
66: fprintf(stderr,"I'm an ox_plot, Version %d.\n",ASIR_VERSION);
67:
68: if ( setjmp(ox_env) ) {
69: while ( NEXT(asir_infile) )
70: closecurrentinput();
71: reset_current_computation();
72: ox_send_sync(0);
73: }
74: while ( 1 ) {
75: if ( ox_data_is_available(0) )
76: process_ox();
77: else {
78: FD_ZERO(&r);
79: FD_SET(3,&r); FD_SET(ds,&r);
80: select(FD_SETSIZE,&r,NULL,NULL,NULL);
81: if ( FD_ISSET(3,&r) )
82: process_ox();
83: else if ( FD_ISSET(ds,&r) )
84: process_xevent();
85: }
86: }
87: }
88:
89: static void process_ox()
90: {
91: int id;
92: unsigned int cmd;
93: Obj obj;
94: ERR err;
95: unsigned int serial;
96: int ret;
97: extern char LastError[];
98:
99: serial = ox_recv(0,&id,&obj);
100: if ( do_message )
101: fprintf(stderr,"#%d Got %s",serial,name_of_id(id));
102: switch ( id ) {
103: case OX_COMMAND:
104: cmd = ((USINT)obj)->body;
105: if ( ox_flushing )
106: break;
107: if ( do_message )
108: fprintf(stderr," %s\n",name_of_cmd(cmd));
109: if ( ret = setjmp(env) ) {
110: if ( ret == 1 ) {
111: create_error(&err,serial,LastError);
112: asir_push_one((Obj)err);
113: }
114: break;
115: }
116: asir_do_cmd(cmd,serial);
117: break;
118: case OX_DATA:
119: case OX_LOCAL_OBJECT_ASIR:
120: if ( ox_flushing )
121: break;
122: if ( do_message )
123: fprintf(stderr," -> data pushed");
124: asir_push_one(obj);
125: break;
126: case OX_SYNC_BALL:
127: asir_end_flush();
128: break;
129: default:
130: break;
131: }
132: if ( do_message )
133: fprintf(stderr,"\n");
134: }
135:
136: static void asir_do_cmd(unsigned int cmd,unsigned int serial)
137: {
138: MATHCAP client_mathcap;
139:
140: switch ( cmd ) {
141: case SM_popSerializedLocalObject:
142: asir_popSerializedLocalObject();
143: break;
144: case SM_popCMO:
145: asir_popCMO(serial);
146: break;
147: case SM_popString:
148: asir_popString();
149: break;
150: case SM_setName:
151: asir_setName(serial);
152: break;
153: case SM_evalName:
154: asir_evalName(serial);
155: break;
156: case SM_executeStringByLocalParser:
157: asir_executeString();
158: break;
159: case SM_executeFunction:
160: asir_executeFunction();
161: break;
162: case SM_shutdown:
163: asir_terminate(2);
164: break;
165: case SM_pops:
166: asir_pops();
167: break;
168: case SM_mathcap:
169: asir_push_one((Obj)my_mathcap);
170: break;
171: case SM_setMathcap:
172: client_mathcap = (MATHCAP)asir_pop_one();
173: store_remote_mathcap(0,client_mathcap);
174: break;
175: default:
176: break;
177: }
178: }
179:
180: static char *name_of_id(int id)
181: {
182: switch ( id ) {
183: case OX_COMMAND:
184: return "OX_COMMAND";
185: break;
186: case OX_DATA:
187: return "OX_DATA";
188: break;
189: case OX_LOCAL_OBJECT_ASIR:
190: return "OX_LOCAL_OBJECT_ASIR";
191: break;
192: case OX_SYNC_BALL:
193: return "OX_SYNC_BALL";
194: break;
195: default:
196: return "Unknown id";
197: break;
198: }
199: }
200:
201: static char *name_of_cmd(unsigned cmd)
202: {
203: switch ( cmd ) {
204: case SM_popSerializedLocalObject:
205: return "SM_popSerializedLocalObject";
206: break;
207: case SM_popCMO:
208: return "SM_popCMO";
209: break;
210: case SM_popString:
211: return "SM_popString";
212: break;
213: case SM_pops:
214: return "SM_pops";
215: break;
216: case SM_setName:
217: return "SM_setName";
218: break;
219: case SM_evalName:
220: return "SM_evalName";
221: break;
222: case SM_executeStringByLocalParser:
223: return "SM_executeString";
224: break;
225: case SM_executeFunction:
226: return "SM_executeFunction";
227: break;
228: case SM_shutdown:
229: return "SM_shutdown";
230: break;
231: case SM_beginBlock:
232: return "SM_beginBlock";
233: break;
234: case SM_endBlock:
235: return "SM_endBlock";
236: break;
237: case SM_mathcap:
238: return "SM_mathcap";
239: break;
240: case SM_setMathcap:
241: return "SM_setMathcap";
242: break;
243: default:
244: return "Unknown cmd";
245: break;
246: }
247: }
248:
249: static void asir_popSerializedLocalObject()
250: {
251: Obj obj;
252: VL t,vl;
253:
254: obj = asir_pop_one();
255: get_vars(obj,&vl);
256: for ( t = vl; t; t = NEXT(t) )
257: if ( t->v->attr == (pointer)V_UC || t->v->attr == (pointer)V_PF )
258: error("bsave : not implemented");
259: ox_send_cmd(0,SM_beginBlock);
260: ox_send_local_ring(0,vl);
261: ox_send_local_data(0,obj);
262: ox_send_cmd(0,SM_endBlock);
263: }
264:
265: static void asir_popCMO(unsigned int serial)
266: {
267: Obj obj;
268: ERR err;
269:
270: obj = asir_pop_one();
271: if ( valid_as_cmo(obj) )
272: ox_send_data(0,obj);
273: else {
274: create_error(&err,serial,"cannot convert to CMO object");
275: ox_send_data(0,err);
276: asir_push_one(obj);
277: }
278: }
279:
280: static void asir_popString()
281: {
282: Obj val;
283: char *buf,*obuf;
284: int l;
285: STRING str;
286:
287: val = asir_pop_one();
288: if ( !val )
289: obuf = 0;
290: else {
291: l = estimate_length(CO,val);
292: buf = (char *)ALLOCA(l+1);
293: soutput_init(buf);
294: sprintexpr(CO,val);
295: l = strlen(buf);
296: obuf = (char *)MALLOC(l+1);
297: strcpy(obuf,buf);
298: }
299: MKSTR(str,obuf);
300: ox_send_data(0,str);
301: }
302:
303: static void asir_pops()
304: {
305: int n;
306:
307: n = (int)(((USINT)asir_pop_one())->body);
308: plot_OperandStackPtr = MAX(plot_OperandStackPtr-n,-1);
309: }
310:
311: static void asir_setName(unsigned int serial)
312: {
313: char *name;
314: int l,n;
315: char *dummy = "=0;";
316: SNODE snode;
317: ERR err;
318:
319: name = ((STRING)asir_pop_one())->body;
320: l = strlen(name);
321: n = l+strlen(dummy)+1;
322: parse_strp = (char *)ALLOCA(n);
323: sprintf(parse_strp,"%s%s",name,dummy);
324: if ( mainparse(&snode) ) {
325: create_error(&err,serial,"cannot set to variable");
326: asir_push_one((Obj)err);
327: } else {
328: FA1((FNODE)FA0(snode)) = (pointer)mkfnode(1,I_FORMULA,asir_pop_one());
329: evalstat(snode);
330: }
331: }
332:
333: static void asir_evalName(unsigned int serial)
334: {
335: char *name;
336: int l,n;
337: SNODE snode;
338: ERR err;
339: pointer val;
340:
341: name = ((STRING)asir_pop_one())->body;
342: l = strlen(name);
343: n = l+2;
344: parse_strp = (char *)ALLOCA(n);
345: sprintf(parse_strp,"%s;",name);
346: if ( mainparse(&snode) ) {
347: create_error(&err,serial,"no such variable");
348: val = (pointer)err;
349: } else
350: val = evalstat(snode);
351: asir_push_one(val);
352: }
353:
354: static int asir_executeString()
355: {
356: SNODE snode;
357: pointer val;
358: char *cmd;
359: #if PARI
360: recover(0);
361: if ( setjmp(environnement) ) {
362: avma = top; recover(1);
363: resetenv("");
364: }
365: #endif
366: cmd = ((STRING)asir_pop_one())->body;
367: parse_strp = cmd;
368: if ( mainparse(&snode) ) {
369: return -1;
370: }
371: val = evalstat(snode);
372: if ( NEXT(asir_infile) ) {
373: while ( NEXT(asir_infile) ) {
374: if ( mainparse(&snode) ) {
375: asir_push_one(val);
376: return -1;
377: }
378: nextbp = 0;
379: val = evalstat(snode);
380: }
381: }
382: asir_push_one(val);
383: return 0;
384: }
385:
386: static void asir_executeFunction()
387: {
388: char *func;
389: int argc;
390: int id;
391: FUNC f;
392: Q ret;
393: VL vl;
394: NODE n,n1;
395:
396: func = ((STRING)asir_pop_one())->body;
397: argc = (int)(((USINT)asir_pop_one())->body);
398:
399: for ( n = 0; argc; argc-- ) {
400: NEXTNODE(n,n1);
401: BDY(n1) = (pointer)asir_pop_one();
402: }
403: if ( n )
404: NEXT(n1) = 0;
405: id = -1;
406: if ( !strcmp(func,"plot") )
407: id = plot(n);
408: else if ( !strcmp(func,"arrayplot") )
409: id = arrayplot(n);
410: else if ( !strcmp(func,"plotover") )
411: id = plotover(n);
412: else if ( !strcmp(func,"drawcircle") )
413: id = drawcircle(n);
414: STOQ(id,ret);
415: #if 0
416: asir_push_one((Obj)ret);
417: #endif
418: }
419:
420: static void asir_end_flush()
421: {
422: ox_flushing = 0;
423: }
424:
425: static void asir_push_one(Obj obj)
426: {
427: if ( !obj || OID(obj) != O_VOID ) {
428: plot_OperandStackPtr++;
429: if ( plot_OperandStackPtr >= plot_OperandStackSize ) {
430: plot_OperandStackSize += BUFSIZ;
431: plot_OperandStack
432: = (Obj *)REALLOC(plot_OperandStack,
433: plot_OperandStackSize*sizeof(Obj));
434: }
435: plot_OperandStack[plot_OperandStackPtr] = obj;
436: }
437: }
438:
439: static Obj asir_pop_one() {
440: if ( plot_OperandStackPtr < 0 ) {
441: if ( do_message )
442: fprintf(stderr,"OperandStack underflow");
443: return 0;
444: } else {
445: if ( do_message )
446: fprintf(stderr,"pop at %d\n",plot_OperandStackPtr);
447: return plot_OperandStack[plot_OperandStackPtr--];
448: }
449: }
450:
451: static void ox_asir_init(int argc,char **argv)
452: {
453: int tmp;
454: char ifname[BUFSIZ];
455: extern int GC_dont_gc;
456: extern int read_exec_file;
457: extern int do_asirrc;
458: extern int do_server_in_X11;
459: char *getenv();
460: static ox_asir_initialized = 0;
461: FILE *ifp;
462:
463: do_server_in_X11 = 1; /* XXX */
464: asir_save_handler();
465: #if PARI
466: risa_pari_init();
467: #endif
468: srandom((int)get_current_time());
469:
470: #if defined(THINK_C)
471: param_init();
472: #endif
473: StackBottom = &tmp + 1; /* XXX */
474: rtime_init();
475: env_init();
476: endian_init();
477: #if !defined(VISUAL) && !defined(THINK_C)
478: /* check_key(); */
479: #endif
480: GC_init();
481: process_args(--argc,++argv);
482: #if 0
483: copyright();
484: #endif
485: output_init();
486: arf_init();
487: nglob_init();
488: glob_init();
489: sig_init();
490: tty_init();
491: debug_init();
492: pf_init();
493: sysf_init();
494: parif_init();
495: #if defined(VISUAL)
496: init_socket();
497: #endif
498: #if defined(UINIT)
499: reg_sysf();
500: #endif
501: #if defined(THINK_C)
502: sprintf(ifname,"asirrc");
503: #else
504: sprintf(ifname,"%s/.asirrc",getenv("HOME"));
505: #endif
506: if ( do_asirrc && (ifp = fopen(ifname,"r")) ) {
507: input_init(ifp,ifname);
508: if ( !setjmp(env) ) {
509: read_exec_file = 1;
510: read_eval_loop();
511: read_exec_file = 0;
512: }
513: fclose(ifp);
514: }
515: input_init(0,"string");
516: ox_io_init();
517: create_my_mathcap("ox_plot");
518: }
519:
520: static void ox_io_init() {
521: unsigned char c,rc;
522: extern int little_endian;
523:
524: endian_init();
525: iofp[0].in = fdopen(3,"r");
526: iofp[0].out = fdopen(4,"w");
527: setbuffer(iofp[0].in,(char *)malloc(LBUFSIZ),LBUFSIZ);
528: setbuffer(iofp[0].out,(char *)malloc(LBUFSIZ),LBUFSIZ);
529: plot_OperandStackSize = BUFSIZ;
530: plot_OperandStack = (Obj *)CALLOC(plot_OperandStackSize,sizeof(Obj));
531: plot_OperandStackPtr = -1;
532: signal(SIGUSR1,ox_usr1_handler);
533: if ( little_endian )
534: c = 1;
535: else
536: c = 0xff;
537: write_char(iofp[0].out,&c); ox_flush_stream(0);
538: read_char(iofp[0].in,&rc);
539: iofp[0].conv = c == rc ? 0 : 1;
540: }