src/common/calprnt.c

#ifndef lint
static const char       RCSid[] = "$Id: calprnt.c,v 2.3 2003/02/25 02:47:21 greg Exp $";
#endif
/*
 *  calprint.c - routines for printing calcomp expressions.
 */

#include "copyright.h"

#include  <stdio.h>

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