![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to debug.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib2 / asir2000 / parse|
Return to debug.c CVS log | Up to [local] / OpenXM_contrib2 / asir2000 / parse |
1.2 ! noro 1: /* $OpenXM: OpenXM_contrib2/asir2000/parse/debug.c,v 1.1.1.1 1999/12/03 07:39:12 noro Exp $ */
1.1 noro 2: #include "ca.h"
3: #include "parse.h"
4: #include <ctype.h>
1.2 ! noro 5: #if PARI
1.1 noro 6: #include "genpari.h"
1.2 ! noro 7: #endif
1.1 noro 8:
9: void show_stack(VS);
10: void change_stack(int,NODE *);
11: void showpos(void);
12: void printvars(char *,VS);
13: void println(int,char **,int);
14: void bp(SNODE);
15: void searchsn(SNODE *,int,SNODE **);
16: void showbp(int);
17: void showbps(void);
18: void delbp(int,char **);
19: int searchbp(void);
20: void clearbp(FUNC);
21: void settp(char *);
22: void setbp(char *);
23: void setf(int,char **);
24: void show_alias(char *);
25: void add_alias(char *,char *);
26:
27: extern do_server_in_X11,do_file;
28:
29: typedef enum {
30: D_NEXT, D_STEP, D_FINISH, D_CONT, D_QUIT,
31: D_UP, D_DOWN, D_FRAME,
32: D_LIST, D_PRINT,
33: D_SETF, D_SETBP, D_SETTP, D_DELBP,
34: D_SHOWBP, D_WHERE, D_ALIAS, D_UNKNOWN
35: } did;
36:
37: struct oDEBCOM {
38: NODE names;
39: did id;
40: };
41:
42: int nextbp,nextbplevel;
43: FUNC cur_binf;
44:
45: static FUNC targetf;
46: static int curline = 1;
47:
48: extern NODE PVSS;
49: extern unsigned int evalstatline;
50: extern int debug_mode;
51: extern jmp_buf debug_env;
52:
53: char *debcom[] = {
54: "next",
55: "step",
56: "finish",
57: "cont",
58: "quit",
59: "up",
60: "down",
61: "frame",
62: "list",
63: "print",
64: "func",
65: "stop",
66: "trace",
67: "delete",
68: "status",
69: "where",
70: "alias",
71: };
72:
73: struct oDEBCOM dckwd[] = {
74: {0, D_NEXT},
75: {0, D_STEP},
76: {0, D_FINISH},
77: {0, D_CONT},
78: {0, D_QUIT},
79: {0, D_UP},
80: {0, D_DOWN},
81: {0, D_FRAME},
82: {0, D_LIST},
83: {0, D_PRINT},
84: {0, D_SETF},
85: {0, D_SETBP},
86: {0, D_SETTP},
87: {0, D_DELBP},
88: {0, D_SHOWBP},
89: {0, D_WHERE},
90: {0, D_ALIAS},
91: {0, D_UNKNOWN}
92: };
93:
94: void debug_init() {
95: int i,n,ac;
96: char *home;
97: char buf[BUFSIZ+1];
98: #if defined(__MWERKS__)
99: char *av[64];
100: #else
101: char *av[BUFSIZ];
102: #endif
103: FILE *fp;
104:
105: for ( n = 0; dckwd[n].id != D_UNKNOWN; n++ );
106: for ( i = 0; i < n; i++ )
107: MKNODE(dckwd[i].names,debcom[i],0);
108: #if defined(THINK_C)
109: strcpy(buf,"dbxinit");
110: #else
111: home = (char *)getenv("HOME");
112: if ( home )
113: strcpy(buf,home);
114: else
115: buf[0] = 0;
116: strcat(buf,"/.dbxinit");
117: #endif
118: if ( (fp = fopen(".dbxinit","r")) || (fp = fopen(buf,"r")) ) {
119: while ( fgets(buf,BUFSIZ,fp) ) {
120: stoarg(buf,&ac,av);
121: if ((ac == 3) && !strcmp(av[0],"alias"))
122: add_alias(av[2],av[1]);
123: }
124: fclose(fp);
125: }
126: #if !defined(VISUAL)
127: if ( do_server_in_X11 )
128: init_cmdwin();
129: #endif
130: }
131:
132: void add_alias(com,alias)
133: char *com,*alias;
134: {
135: int i;
136: NODE tn;
137: char *s;
138:
139: for ( i = 0; dckwd[i].names; i++ )
140: if (!strcmp(com,debcom[i])) {
141: for ( tn = dckwd[i].names; NEXT(tn); tn = NEXT(tn) );
142: s = (char *)MALLOC(strlen(alias)+1); strcpy(s,alias);
143: MKNODE(NEXT(tn),s,0);
144: return;
145: }
146: }
147:
148: void show_alias(alias)
149: char *alias;
150: {
151: int i;
152: NODE tn;
153:
154: if ( !alias )
155: for ( i = 0; dckwd[i].names; i++ ) {
156: if ( tn = NEXT(dckwd[i].names) )
157: fprintf(stderr,"%s\t",debcom[i]);
158: for ( ; tn; tn = NEXT(tn) ) {
159: fputs(BDY(tn),stderr);
160: if ( NEXT(tn) )
161: fputc(' ',stderr);
162: else
163: fputc('\n',stderr);
164: }
165: }
166: else
167: for ( i = 0; dckwd[i].names; i++ )
168: for ( tn = dckwd[i].names; tn; tn = NEXT(tn) )
169: if ( !strcmp(alias,BDY(tn)) ) {
170: fprintf(stderr,"%s->%s\n",alias,debcom[i]); return;
171: }
172: }
173:
174: void debug(f)
175: SNODE f;
176: {
177: int ac,i,n;
178: did id;
179: #if defined(__MWERKS__)
180: char *av[64];
181: #else
182: char *av[BUFSIZ];
183: #endif
184: char buf[BUFSIZ];
185: char prompt[BUFSIZ];
186: char *p,*pe;
187: NODE tn;
188: extern int kernelmode,do_fep;
189: NODE pvss;
190:
191: #if !defined(VISUAL)
192: if ( !isatty(fileno(stdin)) && !do_server_in_X11 )
193: if ( do_file )
194: ExitAsir();
195: else
196: return;
197: #endif
198: #if defined(VISUAL) || defined(THINK_C)
199: suspend_timer();
200: #endif
201: pvss = PVSS; debug_mode = 1;
202: #if !defined(VISUAL)
203: if ( do_server_in_X11 )
204: #endif
205: show_debug_window(1);
206: sprintf(prompt,"(debug)%c",kernelmode?0xfe:' ');
207: if ( kernelmode )
208: fputc('\0',stderr);
209: setjmp(debug_env);
210: while ( 1 ) {
211: if ( !do_server_in_X11 )
212: fputs(prompt,stderr);
213: bzero(buf,BUFSIZ);
214: while ( 1 ) {
215: {
216: int len;
217:
218: #if !defined(VISUAL)
219: if ( do_server_in_X11 )
220: get_line(buf);
221: else
222: #endif
223: if ( !fgets(buf,BUFSIZ,stdin) )
224: goto LAST;
225: len = strlen(buf);
226: if ( buf[len-1] == '\n' )
227: buf[len-1] = 0;
228: }
229: for ( p = buf; *p && isspace(*p); p++ );
230: if ( *p )
231: break;
232: }
233: for ( pe = p; *pe && !isspace(*pe); pe++ );
234: *pe = 0;
235: for ( i = 0; dckwd[i].names; i++ ) {
236: for ( tn = dckwd[i].names; tn; tn = NEXT(tn) )
237: if ( !strcmp(BDY(tn),p) )
238: break;
239: if ( tn )
240: break;
241: }
242: id = dckwd[i].id; p = pe+1;
243: switch ( id ) {
244: case D_NEXT:
245: if ( f ) { nextbp = 1; nextbplevel = 0; }
246: goto LAST; break;
247: case D_STEP:
248: if ( f ) { nextbp = 1; nextbplevel = -1; }
249: goto LAST; break;
250: case D_FINISH:
251: if ( f ) { nextbp = 1; nextbplevel = 1; }
252: goto LAST; break;
253: case D_CONT: case D_QUIT:
254: goto LAST; break;
255: case D_UP:
256: if ( f ) {
257: stoarg(p,&ac,av); n = ac ? atoi(av[0]) : 1;
258: change_stack(n,&pvss);
259: }
260: break;
261: case D_DOWN:
262: if ( f ) {
263: stoarg(p,&ac,av); n = ac ? atoi(av[0]) : 1;
264: change_stack(-n,&pvss);
265: }
266: break;
267: case D_FRAME:
268: if ( f ) {
269: stoarg(p,&ac,av);
270: if ( !ac )
271: show_stack((VS)BDY(pvss));
272: else {
273: n = atoi(av[0]);
274: change_stack(((VS)BDY(pvss))->level-((VS)BDY(PVSS))->level+n,&pvss);
275: }
276: }
277: break;
278: case D_PRINT:
279: printvars(p,pvss?(VS)BDY(pvss):GPVS); break;
280: case D_LIST:
281: stoarg(p,&ac,av); println(ac,av,10); break;
282: case D_SETF:
283: stoarg(p,&ac,av); setf(ac,av); break;
284: case D_SETBP:
285: setbp(p); break;
286: case D_SETTP:
287: settp(p); break;
288: case D_DELBP:
289: stoarg(p,&ac,av); delbp(ac,av); break;
290: case D_SHOWBP:
291: showbps(); break;
292: case D_WHERE:
293: showpos(); break;
294: case D_ALIAS:
295: stoarg(p,&ac,av);
296: switch ( ac ) {
297: case 0:
298: show_alias(0); break;
299: case 1:
300: show_alias(av[0]); break;
301: case 2: default:
302: add_alias(av[1],av[0]); break;
303: }
304: break;
305: default:
306: break;
307: }
308: }
309: LAST:
310: if ( kernelmode )
311: fputc('\0',stderr);
312: debug_mode = 0;
313: #if defined(THINK_C)
314: show_debug_window(0);
315: resume_timer();
316: #elif !defined(VISUAL)
317: if ( do_server_in_X11 )
318: #endif
319: show_debug_window(0);
320: }
321:
322: void setf(ac,av)
323: int ac;
324: char **av;
325: {
326: FUNC r;
327:
328: if ( !ac )
329: return;
330: searchf(usrf,av[0],&r);
331: if ( r ) {
332: targetf = r;
333: curline = targetf->f.usrf->startl;
334: }
335: }
336:
337: #define MAXBP 64
338:
339: static struct {
340: int at;
341: FUNC f;
342: SNODE *snp;
343: char *texpr;
344: char *cond;
345: } bpt[MAXBP];
346:
347: static int bpindex = 0;
348:
349: void setbp(p)
350: char *p;
351: {
352: int ac;
353: char *av[BUFSIZ];
354: char *buf,*savp;
355: char *fname;
356: FUNC r;
357: USRF t;
358: SNODE *snp = 0;
359: FNODE cond;
360: NODE tn;
361: int n,at,ln,bpi;
362:
363: buf = (char *)ALLOCA(strlen(p)+1); strcpy(buf,p); stoarg(buf,&ac,av);
364: if ( ac < 2 )
365: return;
366: if ( !strcmp(av[0],"at") ) {
367: if ( !targetf )
368: return;
369: n = atoi(av[1]); fname = targetf->f.usrf->fname;
370: for ( tn = usrf; tn; tn = NEXT(tn) ) {
371: r = (FUNC)BDY(tn); t = r->f.usrf;
372: if ( t && t->fname && !strcmp(t->fname,fname)
373: && ( t->startl <= n ) && ( n <= t->endl ) )
374: break;
375: }
376: if ( !r ) {
377: fprintf(stderr,"no such line in %s\n",fname);
378: return;
379: } else {
380: targetf = r; curline = n;
381: }
382: at = 1; searchsn(&BDY(t),n,&snp);
383: } else if ( !strcmp(av[0],"in") ) {
384: searchf(usrf,av[1],&r);
385: if ( !r ) {
386: fprintf(stderr,"%s() : no such function\n",av[1]);
387: return;
388: } else if ( r->id == A_UNDEF ) {
389: fprintf(stderr,"%s : undefined\n",av[1]);
390: return;
391: }
392: for ( tn = (NODE)FA0(BDY(r->f.usrf)); tn && !BDY(tn); tn = NEXT(tn) );
393: if ( tn ) {
394: snp = (SNODE *)&(BDY(tn)); at = 0; targetf = r; curline = (*snp)->ln;
395: }
396: } else
397: return;
398: if ( snp ) {
399: cond = 0;
400: if ( ac >= 3 && !strncmp(av[2],"if",2) ) {
401: savp = p+(av[2]-buf)+2;
402: exprparse(targetf,savp,&cond);
403: }
404: bpi = searchbp();
405: if ( bpi < 0 )
406: fprintf(stderr,"too many breakpoints\n");
407: else if ( ID(*snp) == S_BP )
408: return;
409: else {
410: switch ( ID(*snp) ) {
411: case S_IFELSE: case S_FOR: case S_DO:
412: ln = (int)FA0(*snp); break;
413: default:
414: ln = (*snp)->ln; break;
415: }
416: *snp = (SNODE)mksnode(3,S_BP,*snp,cond,0);
417: (*snp)->ln = ln;
418: if ( cond ) {
419: bpt[bpi].cond = (char *)MALLOC(strlen(savp)+1);
420: strcpy(bpt[bpi].cond,savp);
421: } else
422: bpt[bpi].cond = 0;
423: bpt[bpi].at = at;
424: bpt[bpi].f = targetf;
425: bpt[bpi].snp = snp;
426: bpt[bpi].texpr = 0;
427: showbp(bpi);
428: }
429: }
430: }
431:
432: void settp(p)
433: char *p;
434: {
435: int ac;
436: char *_av[BUFSIZ];
437: char **av;
438: char *buf,*savp;
439: char *fname;
440: char *texprname;
441: FUNC r;
442: USRF t;
443: SNODE *snp = 0;
444: FNODE cond,texpr;
445: NODE tn;
446: int n,at,ln,bpi;
447:
448: av = _av;
449: buf = (char *)ALLOCA(strlen(p)+1); strcpy(buf,p); stoarg(buf,&ac,av);
450: if ( ac < 3 )
451: return;
452: texprname = av[0]; ac--; av++;
453: if ( !strcmp(av[0],"at") ) {
454: if ( !targetf )
455: return;
456: n = atoi(av[1]); fname = targetf->f.usrf->fname;
457: for ( tn = usrf; tn; tn = NEXT(tn) ) {
458: r = (FUNC)BDY(tn); t = r->f.usrf;
459: if ( t && t->fname && !strcmp(t->fname,fname)
460: && ( t->startl <= n ) && ( n <= t->endl ) )
461: break;
462: }
463: if ( !r ) {
464: fprintf(stderr,"no such line in %s\n",fname);
465: return;
466: } else {
467: targetf = r; curline = n;
468: }
469: at = 1; searchsn(&BDY(t),n,&snp);
470: } else if ( !strcmp(av[0],"in") ) {
471: searchf(usrf,av[1],&r);
472: if ( !r ) {
473: fprintf(stderr,"%s() : no such function\n",av[1]);
474: return;
475: }
476: for ( tn = (NODE)FA0(BDY(r->f.usrf)); tn && !BDY(tn); tn = NEXT(tn) );
477: if ( tn ) {
478: snp = (SNODE *)&(BDY(tn)); at = 0; targetf = r; curline = (*snp)->ln;
479: }
480: } else
481: return;
482: if ( snp ) {
483: cond = 0;
484: exprparse(targetf,texprname,&texpr);
485: if ( ac >= 3 && !strncmp(av[2],"if",2) ) {
486: savp = p+(av[2]-buf)+2;
487: exprparse(targetf,savp,&cond);
488: }
489: bpi = searchbp();
490: if ( bpi < 0 )
491: fprintf(stderr,"too many breakpoints\n");
492: else if ( ID(*snp) == S_BP )
493: return;
494: else {
495: switch ( ID(*snp) ) {
496: case S_IFELSE: case S_FOR: case S_DO:
497: ln = (int)FA0(*snp); break;
498: default:
499: ln = (*snp)->ln; break;
500: }
501: *snp = (SNODE)mksnode(3,S_BP,*snp,cond,texpr);
502: (*snp)->ln = ln;
503: if ( cond ) {
504: bpt[bpi].cond = (char *)MALLOC(strlen(savp)+1);
505: strcpy(bpt[bpi].cond,savp);
506: } else
507: bpt[bpi].cond = 0;
508: bpt[bpi].at = at;
509: bpt[bpi].f = targetf;
510: bpt[bpi].snp = snp;
511: bpt[bpi].texpr = (char *)MALLOC(strlen(texprname)+1);
512: strcpy(bpt[bpi].texpr,texprname);
513: showbp(bpi);
514: }
515: }
516: }
517:
518: void clearbp(f)
519: FUNC f;
520: {
521: int i;
522:
523: if ( !f )
524: return;
525: for ( i = 0; i < bpindex; i++ )
526: if ( bpt[i].snp && !strcmp(f->name,bpt[i].f->name) ) {
527: bpt[i].at = 0; bpt[i].f = 0; bpt[i].snp = 0;
528: }
529: }
530:
531: int searchbp()
532: {
533: int i;
534:
535: for ( i = 0; i < bpindex; i++ )
536: if ( !bpt[i].snp )
537: return i;
538: if ( bpindex == MAXBP )
539: return -1;
540: else
541: return bpindex++;
542: }
543:
544: void delbp(ac,av)
545: int ac;
546: char **av;
547: {
548: int n;
549:
550: if ( !ac )
551: return;
552: if ( (n = atoi(av[0])) >= bpindex )
553: return;
554: if ( bpt[n].snp ) {
555: *bpt[n].snp = (SNODE)FA0(*bpt[n].snp);
556: bpt[n].snp = 0;
557: }
558: }
559:
560: void showbps() {
561: int i;
562:
563: for ( i = 0; i < bpindex; i++ )
564: showbp(i);
565: }
566:
567: void showbp(n)
568: int n;
569: {
570: if ( bpt[n].snp )
571: if ( bpt[n].texpr )
572: if ( bpt[n].at ) {
573: if ( bpt[n].cond )
574: fprintf(stderr,"(%d) trace %s at \"%s\":%d if %s\n",
575: n,bpt[n].texpr,bpt[n].f->f.usrf->fname,(*bpt[n].snp)->ln,bpt[n].cond);
576: else
577: fprintf(stderr,"(%d) trace %s at \"%s\":%d\n",
578: n,bpt[n].texpr,bpt[n].f->f.usrf->fname,(*bpt[n].snp)->ln);
579: } else {
580: if ( bpt[n].cond )
581: fprintf(stderr,"(%d) trace %s in %s if %s\n",
582: n,bpt[n].texpr,bpt[n].f->name,bpt[n].cond);
583: else
584: fprintf(stderr,"(%d) trace %s in %s\n",n,bpt[n].texpr,bpt[n].f->name);
585: }
586: else
587: if ( bpt[n].at ) {
588: if ( bpt[n].cond )
589: fprintf(stderr,"(%d) stop at \"%s\":%d if %s\n",
590: n,bpt[n].f->f.usrf->fname,(*bpt[n].snp)->ln,bpt[n].cond);
591: else
592: fprintf(stderr,"(%d) stop at \"%s\":%d\n",
593: n,bpt[n].f->f.usrf->fname,(*bpt[n].snp)->ln);
594: } else {
595: if ( bpt[n].cond )
596: fprintf(stderr,"(%d) stop in %s if %s\n",
597: n,bpt[n].f->name,bpt[n].cond);
598: else
599: fprintf(stderr,"(%d) stop in %s\n",n,bpt[n].f->name);
600: }
601: }
602:
603: void searchsn(fp,n,fpp)
604: SNODE *fp;
605: int n;
606: SNODE **fpp;
607: {
608: NODE tn;
609: SNODE sn;
610: SNODE *snp;
611:
612: *fpp = 0;
613: switch (ID(*fp)) {
614: case S_CPLX:
615: for ( tn = (NODE)FA0(*fp); tn; tn = NEXT(tn) )
616: if ( sn = (SNODE)BDY(tn) ) {
617: snp = (SNODE *)(ID(sn) == S_BP ? &FA0(sn) : &BDY(tn));
618: if ( (*snp)->ln >= n ) {
619: searchsn(snp,n,fpp); break;
620: }
621: }
622: break;
623: case S_IFELSE:
624: if ( n <= (int)FA0(*fp) )
625: *fpp = fp;
626: else if ( n <= ((SNODE)FA2(*fp))->ln )
627: searchsn((SNODE *)&FA2(*fp),n,fpp);
628: else if ( FA3(*fp) )
629: searchsn((SNODE *)&FA3(*fp),n,fpp);
630: if ( !(*fpp) )
631: *fpp = fp;
632: break;
633: case S_FOR:
634: if ( n <= (int)FA0(*fp) )
635: *fpp = fp;
636: else
637: searchsn((SNODE *)&FA4(*fp),n,fpp);
638: if ( !(*fpp) )
639: *fpp = fp;
640: break;
641: case S_DO:
642: if ( n <= (int)FA0(*fp) )
643: *fpp = fp;
644: else
645: searchsn((SNODE *)&FA1(*fp),n,fpp);
646: if ( !(*fpp) )
647: *fpp = fp;
648: break;
649: case S_BP:
650: switch ( ID((SNODE)FA0(*fp)) ) {
651: case S_SINGLE:
652: *fpp = fp; break;
653: default:
654: searchsn((SNODE *)&FA0(*fp),n,fpp); break;
655: }
656: break;
657: case S_SINGLE: default:
658: *fpp = fp;
659: break;
660: }
661: }
662:
663: void bp(f)
664: SNODE f;
665: {
666: int ln;
667:
668: if ( !f || (CPVS == GPVS) )
669: return;
670:
671: switch ( ID(f) ) {
672: case S_IFELSE: case S_FOR:
673: ln = (int)FA0(f); break;
674: default:
675: ln = f->ln; break;
676: }
677: #if !defined(VISUAL)
678: if ( do_server_in_X11 )
679: #endif
680: show_debug_window(1);
681: fprintf(stderr,"stopped in %s at line %d in file \"%s\"\n",
682: CPVS->usrf->name,ln,CPVS->usrf->f.usrf->fname);
683: targetf = CPVS->usrf; curline = ln;
684: println(0,0,1);
685: #if !defined(VISUAL)
686: if ( do_server_in_X11 || isatty(0) )
687: #endif
688: debug(f);
689: }
690:
691: void println(ac,av,l)
692: int ac;
693: char **av;
694: int l;
695: {
696: FILE *fp;
697: char buf[BUFSIZ+1];
698: int i;
699: int ln;
700: FUNC r;
701: #if defined(THINK_C)
702: void setDir(short);
703: #endif
704:
705: if ( !ac )
706: ln = curline;
707: else if ( isdigit(av[0][0]) )
708: ln = atoi(av[0]);
709: else {
710: searchf(usrf,av[0],&r);
711: if ( r && r->id != A_UNDEF ) {
712: targetf = r;
713: ln = r->f.usrf->startl;
714: } else {
715: fprintf(stderr,"%s undefined\n",av[0]);
716: ln = curline;
717: }
718: }
719: if ( !targetf )
720: return;
721: #if defined(THINK_C)
722: setDir(targetf->f.usrf->vol);
723: #endif
724: fp = fopen(targetf->f.usrf->fname,"r");
725: #if defined(THINK_C)
726: resetDir();
727: #endif
728: if ( !fp ) {
729: fprintf(stderr,"\"%s\" not found\n",targetf->name);
730: return;
731: }
732: for ( i = 1; i < ln; i++ )
733: if ( !fgets(buf,BUFSIZ,fp) )
734: return;
735: for ( i = 0; i < l; i++ ) {
736: if ( !fgets(buf,BUFSIZ,fp) )
737: break;
738: fprintf(stderr,"%d %s",ln+i,buf);
739: }
740: curline = ln + i;
741: fclose(fp);
742: }
743:
744: void printvars(s,vs)
745: char *s;
746: VS vs;
747: {
748: FNODE expr;
749: char *p;
750: pointer val = 0;
751: int err;
752: VS cpvs;
753:
754: for ( p = s; *p; p++ )
755: if ( *p == '\n' ) {
756: *p = 0; break;
757: }
758: if ( exprparse(vs==GPVS?0:vs->usrf,s,&expr) ) {
759: cpvs = CPVS; CPVS = vs;
760: if ( !(err = setjmp(debug_env)) )
761: val = eval(expr);
762: CPVS = cpvs;
763: if ( !err ) {
764: #if PARI
765: #if PARI1
766: outfile = stderr;
767: #else
768: pari_outfile = stderr;
769: #endif
770: #endif
771: asir_out = stderr;
772: for ( p = s; isspace(*p); p++ );
773: fprintf(asir_out,"%s = ",p);
774: if ( val && ID((R)val) == O_MAT )
775: putc('\n',asir_out);
776: #if defined(VISUAL_LIB)
777: w_noflush_stderr(1);
778: #endif
779: printexpr(CO,val); putc('\n',asir_out); fflush(asir_out);
780: #if defined(VISUAL_LIB)
781: w_noflush_stderr(0);
782: #endif
783: #if PARI
784: #if PARI1
785: outfile = stdout;
786: #else
787: pari_outfile = stdout;
788: #endif
789: #endif
790: asir_out = stdout;
791: }
792: }
793: }
794:
795: void showpos()
796: {
797: NODE n;
798: VS vs;
799: int level;
800:
801: if ( PVSS ) {
802: if ( cur_binf )
803: fprintf(stderr,"%s() (builtin)\n",cur_binf->name);
804: ((VS)BDY(PVSS))->at = evalstatline;
805: level = ((VS)BDY(PVSS))->level;
806: for ( n = PVSS; n; n = NEXT(n) ) {
807: vs = (VS)BDY(n);
808: fprintf(stderr,"#%d %s(), line %d in \"%s\"\n",
809: level-vs->level,vs->usrf->name,vs->at,vs->usrf->f.usrf->fname);
810: }
811: }
812: }
813:
814: void showpos_to_string(buf)
815: char *buf;
816: {
817: NODE n;
818: VS vs;
819: int level;
820:
821: buf[0] = 0;
822: if ( PVSS ) {
823: if ( cur_binf )
824: sprintf(buf,"%s() (builtin)\n",cur_binf->name);
825: buf += strlen(buf);
826: ((VS)BDY(PVSS))->at = evalstatline;
827: level = ((VS)BDY(PVSS))->level;
828: for ( n = PVSS; n; n = NEXT(n) ) {
829: vs = (VS)BDY(n);
830: sprintf(buf,"#%d %s(), line %d in \"%s\"\n",
831: level-vs->level,vs->usrf->name,vs->at,vs->usrf->f.usrf->fname);
832: buf += strlen(buf);
833: }
834: }
835: }
836:
837: void change_stack(level,pvss)
838: int level;
839: NODE *pvss;
840: {
841: extern NODE PVSS;
842: NODE n;
843: int i;
844: VS vs;
845:
846: if ( !level || !PVSS )
847: return;
848: if ( level < 0 ) {
849: for ( n = PVSS, i = 0; n && n != *pvss; n = NEXT(n), i++ );
850: for ( n = PVSS, i = MAX(i+level,0); n && i; n = NEXT(n), i-- );
851: } else
852: for ( n = *pvss, i = level; NEXT(n) && i; n = NEXT(n), i-- );
853: *pvss = n; vs = (VS)BDY(n);
854: ((VS)BDY(PVSS))->at = evalstatline;
855: show_stack(vs);
856: targetf = vs->usrf; curline = vs->at;
857: }
858:
859: void show_stack(vs)
860: VS vs;
861: {
862: fprintf(stderr,"#%d %s(), line %d in \"%s\"\n",
863: ((VS)BDY(PVSS))->level-vs->level,vs->usrf->name,vs->at,vs->usrf->f.usrf->fname);
864: }