src/common/calprnt.c

#ifndef lint
static const char       RCSid[] = "$Id$";
#endif
/*
 *  calprint.c - routines for printing calcomp expressions.
 */

#include "copyright.h"

#include  <stdio.h>

#include  "calcomp.h"


void
eprint(ep, fp)                  /* print a parse tree */
register EPNODE  *ep;
FILE  *fp;
{
    static EPNODE  *curdef = NULL;
    register EPNODE  *ep1;

    switch (ep->type) {

        case VAR:
            fputs(ep->v.ln->name, fp);
            break;

        case SYM:
            fputs(ep->v.name, fp);
            break;

        case FUNC:
            eprint(ep->v.kid, fp);
            fputc('(', fp);
            ep1 = ep->v.kid->sibling;
            while (ep1 != NULL) {
                eprint(ep1, fp);
                if ((ep1 = ep1->sibling) != NULL)
                    fputs(", ", fp);
            }
            fputc(')', fp);
            break;

        case ARG:
            if (curdef == NULL || curdef->v.kid->type != FUNC ||
                        (ep1 = ekid(curdef->v.kid, ep->v.chan)) == NULL) {
                eputs("Bad argument!\n");
                quit(1);
            }
            eprint(ep1, fp);
            break;

        case NUM:
            fprintf(fp, "%.9g", ep->v.num);
            break;

        case UMINUS:
            fputc('-', fp);
            eprint(ep->v.kid, fp);
            break;

        case CHAN:
            fprintf(fp, "$%d", ep->v.chan);
            break;
        
        case '=':
        case ':':
            ep1 = curdef;
            curdef = ep;
            eprint(ep->v.kid, fp);
            fputc(' ', fp);
            fputc(ep->type, fp);
            fputc(' ', fp);
            eprint(ep->v.kid->sibling, fp);
            curdef = ep1;
            break;
            
        case '+':
        case '-':
        case '*':
        case '/':
        case '^':
            fputc('(', fp);
            eprint(ep->v.kid, fp);
            fputc(' ', fp);
            fputc(ep->type, fp);
            fputc(' ', fp);
            eprint(ep->v.kid->sibling, fp);
            fputc(')', fp);
            break;

        default:
            eputs("Bad expression!\n");
            quit(1);

    }

}


void
dprint(name, fp)                /* print a definition (all if no name) */
char  *name;
FILE  *fp;
{
    register EPNODE  *ep;
    
    if (name == NULL)
        for (ep = dfirst(); ep != NULL; ep = dnext()) {
            eprint(ep, fp);
            fputs(";\n", fp);
        }
    else if ((ep = dlookup(name)) != NULL) {
        eprint(ep, fp);
        fputs(";\n", fp);
    } else {
        wputs(name);
        wputs(": undefined\n");
    }
}
Revision:	2.3
Committed:	Tue Feb 25 02:47:21 2003 UTC (21 years, 2 months ago) by greg
Content type:	text/plain
Branch:	MAIN
CVS Tags:	rad3R5
Changes since 2.2:	+1 -56 lines
Log Message:	Replaced inline copyright notice with #include "copyright.h"
#	User	Rev	Content
1	greg	1.1	#ifndef lint
2	greg	2.2	static const char RCSid[] = "$Id$";
3	greg	1.1	#endif
4			/*
5			* calprint.c - routines for printing calcomp expressions.
6	greg	2.2	*/
7
8	greg	2.3	#include "copyright.h"
9	greg	1.1
10			#include <stdio.h>
11
12			#include "calcomp.h"
13
14
15	greg	2.2	void
16	greg	1.1	eprint(ep, fp) /* print a parse tree */
17			register EPNODE *ep;
18			FILE *fp;
19			{
20			static EPNODE *curdef = NULL;
21			register EPNODE *ep1;
22
23			switch (ep->type) {
24
25			case VAR:
26			fputs(ep->v.ln->name, fp);
27			break;
28
29			case SYM:
30			fputs(ep->v.name, fp);
31			break;
32
33			case FUNC:
34			eprint(ep->v.kid, fp);
35	greg	2.2	fputc('(', fp);
36	greg	1.1	ep1 = ep->v.kid->sibling;
37			while (ep1 != NULL) {
38			eprint(ep1, fp);
39			if ((ep1 = ep1->sibling) != NULL)
40			fputs(", ", fp);
41			}
42	greg	2.2	fputc(')', fp);
43	greg	1.1	break;
44
45			case ARG:
46			if (curdef == NULL \|\| curdef->v.kid->type != FUNC \|\|
47			(ep1 = ekid(curdef->v.kid, ep->v.chan)) == NULL) {
48			eputs("Bad argument!\n");
49			quit(1);
50			}
51			eprint(ep1, fp);
52			break;
53
54			case NUM:
55			fprintf(fp, "%.9g", ep->v.num);
56			break;
57
58			case UMINUS:
59	greg	2.2	fputc('-', fp);
60	greg	1.2	eprint(ep->v.kid, fp);
61	greg	1.1	break;
62
63			case CHAN:
64			fprintf(fp, "$%d", ep->v.chan);
65			break;
66
67			case '=':
68			case ':':
69			ep1 = curdef;
70			curdef = ep;
71			eprint(ep->v.kid, fp);
72	greg	2.2	fputc(' ', fp);
73			fputc(ep->type, fp);
74			fputc(' ', fp);
75	greg	1.1	eprint(ep->v.kid->sibling, fp);
76			curdef = ep1;
77			break;
78
79			case '+':
80			case '-':
81			case '*':
82			case '/':
83			case '^':
84	greg	2.2	fputc('(', fp);
85	greg	1.1	eprint(ep->v.kid, fp);
86	greg	2.2	fputc(' ', fp);
87			fputc(ep->type, fp);
88			fputc(' ', fp);
89	greg	1.1	eprint(ep->v.kid->sibling, fp);
90	greg	2.2	fputc(')', fp);
91	greg	1.1	break;
92
93			default:
94			eputs("Bad expression!\n");
95			quit(1);
96
97			}
98
99			}
100
101
102	greg	2.2	void
103	greg	1.1	dprint(name, fp) /* print a definition (all if no name) */
104			char *name;
105			FILE *fp;
106			{
107			register EPNODE *ep;
108
109			if (name == NULL)
110			for (ep = dfirst(); ep != NULL; ep = dnext()) {
111			eprint(ep, fp);
112			fputs(";\n", fp);
113			}
114			else if ((ep = dlookup(name)) != NULL) {
115			eprint(ep, fp);
116			fputs(";\n", fp);
117			} else {
118			wputs(name);
119			wputs(": undefined\n");
120			}
121			}