src/common/calprnt.c

#ifndef lint
static const char       RCSid[] = "$Id: calprnt.c,v 2.7 2021/07/30 00:22:32 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 binary operation lower precedence than parent? */
static int
lower_precedent_binop(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_binop(ep->type, ep->v.kid)) {
                fputc('(', fp);
                eprint(ep->v.kid, fp);
                fputc(')', fp);
            } else
                eprint(ep->v.kid, fp);
            if (ep->type != '^') {
                fputc(' ', fp);
                fputc(ep->type, fp);
                fputc(' ', fp);
            } else
                fputc(ep->type, fp);
            if (lower_precedent_binop(ep->type, ep->v.kid->sibling)) {
                fputc('(', fp);
                eprint(ep->v.kid->sibling, fp);
                fputc(')', fp);
            } else
                eprint(ep->v.kid->sibling, 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.8
Committed:	Fri Feb 23 03:47:57 2024 UTC (14 months, 1 week ago) by greg
Content type:	text/plain
Branch:	MAIN
Changes since 2.7:	+7 -7 lines
Log Message:	perf: Added array index optimization to calcomp routines
#	User	Rev	Content
1	greg	1.1	#ifndef lint
2	greg	2.8	static const char RCSid[] = "$Id: calprnt.c,v 2.7 2021/07/30 00:22:32 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.7	/* is child binary operation lower precedence than parent? */
18			static int
19	greg	2.8	lower_precedent_binop(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			case '-':
110			case '*':
111			case '/':
112			case '^':
113	greg	2.7	if (lower_precedent_binop(ep->type, ep->v.kid)) {
114			fputc('(', fp);
115			eprint(ep->v.kid, fp);
116			fputc(')', fp);
117			} else
118			eprint(ep->v.kid, fp);
119			if (ep->type != '^') {
120			fputc(' ', fp);
121			fputc(ep->type, fp);
122			fputc(' ', fp);
123			} else
124			fputc(ep->type, fp);
125			if (lower_precedent_binop(ep->type, ep->v.kid->sibling)) {
126			fputc('(', fp);
127			eprint(ep->v.kid->sibling, fp);
128			fputc(')', fp);
129			} else
130			eprint(ep->v.kid->sibling, fp);
131	greg	1.1	break;
132
133			default:
134			eputs("Bad expression!\n");
135			quit(1);
136
137			}
138			}
139
140
141	greg	2.2	void
142	greg	2.6	dprint( /* print a definition (all if no name) */
143			char *name,
144			FILE *fp
145			)
146	greg	1.1	{
147	greg	2.6	EPNODE *ep;
148	greg	1.1
149			if (name == NULL)
150			for (ep = dfirst(); ep != NULL; ep = dnext()) {
151			eprint(ep, fp);
152			fputs(";\n", fp);
153			}
154			else if ((ep = dlookup(name)) != NULL) {
155			eprint(ep, fp);
156			fputs(";\n", fp);
157			} else {
158			wputs(name);
159			wputs(": undefined\n");
160			}
161			}