src/common/calprnt.c

#ifndef lint
static const char       RCSid[] = "$Id: calprnt.c,v 2.8 2024/02/23 03:47:57 greg Exp $";
#endif
/*
 *  calprint.c - routines for printing calcomp expressions.
 */

#include "copyright.h"

#include  <stdio.h>
#include  <string.h>

#include  "rterror.h"
#include  "calcomp.h"


/* is child operation lower precedence than parent? */
static int
lower_precedent_op(int typ, EPNODE *ek)
{
    if (ek == NULL)
        return(0);
    switch (typ) {
        case '+':
                return(0);
        case '-':
                return(ek->type == '+');
        case '*':
                return(strchr("+-", ek->type) != NULL);
        case '/':
                return(strchr("+-*", ek->type) != NULL);
        case '^':
                return(strchr("+-*/^", ek->type) != NULL);
        }
    return(0);                  /* child not binary op */
}

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

    switch (ep==NULL ? -1 : 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 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 UMINUS:
            fputc('-', fp);
            if (ep->v.kid != NULL && strchr("+-*/^", ep->v.kid->type)) {
                fputc('(', fp);
                eprint(ep->v.kid, fp);
                fputc(')', fp);
            } else
                eprint(ep->v.kid, fp);
            break;

        case '+':
        case '*':
        case '-':
        case '/':
        case '^':
            if (lower_precedent_op(ep->type, ep->v.kid)) {
                fputc('(', fp);
                eprint(ep->v.kid, fp);
                fputc(')', fp);
            } else
                eprint(ep->v.kid, fp);
            for (ep1 = ep->v.kid->sibling; ep1 != NULL; ep1 = ep1->sibling) {
                if (ep->type != '^') {
                    fputc(' ', fp);
                    fputc(ep->type, fp);
                    fputc(' ', fp);
                } else
                    fputc(ep->type, fp);
                if (lower_precedent_op(ep->type, ep1)) {
                    fputc('(', fp);
                    eprint(ep1, fp);
                    fputc(')', fp);
                } else
                    eprint(ep1, fp);
            }
            break;

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

    }
}


void
dprint(                 /* print a definition (all if no name) */
        char  *name,
        FILE  *fp
)
{
    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.9
Committed:	Sat Feb 24 19:00:23 2024 UTC (20 months, 1 week ago) by greg
Content type:	text/plain
Branch:	MAIN
CVS Tags:	rad6R0, HEAD
Changes since 2.8:	+19 -17 lines
Log Message:	perf: Flatten hierarchies for commutative & associative operators, '+' and '*'
#	User	Rev	Content
1	greg	1.1	#ifndef lint
2	greg	2.9	static const char RCSid[] = "$Id: calprnt.c,v 2.8 2024/02/23 03:47:57 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	greg	2.7	#include <string.h>
12	greg	1.1
13	schorsch	2.4	#include "rterror.h"
14	greg	1.1	#include "calcomp.h"
15
16
17	greg	2.9	/* is child operation lower precedence than parent? */
18	greg	2.7	static int
19	greg	2.9	lower_precedent_op(int typ, EPNODE *ek)
20	greg	2.7	{
21	greg	2.8	if (ek == NULL)
22	greg	2.7	return(0);
23			switch (typ) {
24			case '+':
25			return(0);
26			case '-':
27	greg	2.8	return(ek->type == '+');
28	greg	2.7	case '*':
29	greg	2.8	return(strchr("+-", ek->type) != NULL);
30	greg	2.7	case '/':
31	greg	2.8	return(strchr("+-*", ek->type) != NULL);
32	greg	2.7	case '^':
33	greg	2.8	return(strchr("+-*/^", ek->type) != NULL);
34	greg	2.7	}
35			return(0); /* child not binary op */
36			}
37
38	greg	2.2	void
39	greg	2.6	eprint( /* print a parse tree */
40			EPNODE *ep,
41			FILE *fp
42			)
43	greg	1.1	{
44			static EPNODE *curdef = NULL;
45	greg	2.6	EPNODE *ep1 = NULL;
46	greg	1.1
47	greg	2.7	switch (ep==NULL ? -1 : ep->type) {
48	greg	1.1
49			case VAR:
50			fputs(ep->v.ln->name, fp);
51			break;
52
53			case SYM:
54			fputs(ep->v.name, fp);
55			break;
56
57			case FUNC:
58			eprint(ep->v.kid, fp);
59	greg	2.2	fputc('(', fp);
60	greg	1.1	ep1 = ep->v.kid->sibling;
61			while (ep1 != NULL) {
62			eprint(ep1, fp);
63			if ((ep1 = ep1->sibling) != NULL)
64			fputs(", ", fp);
65			}
66	greg	2.2	fputc(')', fp);
67	greg	1.1	break;
68
69			case ARG:
70			if (curdef == NULL \|\| curdef->v.kid->type != FUNC \|\|
71			(ep1 = ekid(curdef->v.kid, ep->v.chan)) == NULL) {
72			eputs("Bad argument!\n");
73			quit(1);
74			}
75			eprint(ep1, fp);
76			break;
77
78			case NUM:
79			fprintf(fp, "%.9g", ep->v.num);
80			break;
81
82			case CHAN:
83			fprintf(fp, "$%d", ep->v.chan);
84			break;
85
86			case '=':
87			case ':':
88			ep1 = curdef;
89			curdef = ep;
90			eprint(ep->v.kid, fp);
91	greg	2.2	fputc(' ', fp);
92			fputc(ep->type, fp);
93			fputc(' ', fp);
94	greg	1.1	eprint(ep->v.kid->sibling, fp);
95			curdef = ep1;
96			break;
97	greg	2.7
98			case UMINUS:
99			fputc('-', fp);
100			if (ep->v.kid != NULL && strchr("+-*/^", ep->v.kid->type)) {
101			fputc('(', fp);
102			eprint(ep->v.kid, fp);
103			fputc(')', fp);
104			} else
105			eprint(ep->v.kid, fp);
106			break;
107
108	greg	1.1	case '+':
109	greg	2.9	case '*':
110	greg	1.1	case '-':
111			case '/':
112			case '^':
113	greg	2.9	if (lower_precedent_op(ep->type, ep->v.kid)) {
114	greg	2.7	fputc('(', fp);
115			eprint(ep->v.kid, fp);
116			fputc(')', fp);
117			} else
118			eprint(ep->v.kid, fp);
119	greg	2.9	for (ep1 = ep->v.kid->sibling; ep1 != NULL; ep1 = ep1->sibling) {
120			if (ep->type != '^') {
121			fputc(' ', fp);
122			fputc(ep->type, fp);
123			fputc(' ', fp);
124			} else
125			fputc(ep->type, fp);
126			if (lower_precedent_op(ep->type, ep1)) {
127			fputc('(', fp);
128			eprint(ep1, fp);
129			fputc(')', fp);
130			} else
131			eprint(ep1, fp);
132			}
133	greg	1.1	break;
134
135			default:
136			eputs("Bad expression!\n");
137			quit(1);
138
139			}
140			}
141
142
143	greg	2.2	void
144	greg	2.6	dprint( /* print a definition (all if no name) */
145			char *name,
146			FILE *fp
147			)
148	greg	1.1	{
149	greg	2.6	EPNODE *ep;
150	greg	1.1
151			if (name == NULL)
152			for (ep = dfirst(); ep != NULL; ep = dnext()) {
153			eprint(ep, fp);
154			fputs(";\n", fp);
155			}
156			else if ((ep = dlookup(name)) != NULL) {
157			eprint(ep, fp);
158			fputs(";\n", fp);
159			} else {
160			wputs(name);
161			wputs(": undefined\n");
162			}
163			}