![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to makenode.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 42BSD / ingres / source / decomp|
Return to makenode.c CVS log | Up to [CSRG BSD Unix] / 42BSD / ingres / source / decomp |
1.1 root 1: # include <ingres.h>
2: # include <aux.h>
3: # include <tree.h>
4: # include <symbol.h>
5: # include "globs.h"
6: # include <sccs.h>
7:
8: SCCSID(@(#)makenode.c 7.1 2/5/81)
9:
10:
11:
12:
13: /*
14: ** Make a copy of a tree.
15: */
16:
17: QTREE *
18: copytree(r, buf)
19: register QTREE *r;
20: char *buf;
21: {
22: register QTREE *q;
23: register int length;
24: extern char *need();
25:
26: if (r == NULL)
27: return (0);
28:
29: length = r->sym.len & I1MASK;
30: q = (QTREE *) need(buf, length + QT_HDR_SIZ);
31: bmove((char *)&r->sym, (char *)&q->sym, length + SYM_HDR_SIZ);
32:
33: q->left = copytree(r->left, buf);
34: q->right = copytree(r->right, buf);
35:
36: return (q);
37: }
38: /*
39: ** Make a new copy of the root by making
40: ** new AND nodes and connecting them to the
41: ** same branches.
42: **
43: ** Trace Flags:
44: ** 64
45: */
46:
47: QTREE *
48: copy_ands(root, buf)
49: QTREE *root;
50: char *buf;
51: {
52: register QTREE *q;
53: register QTREE *x, *y;
54: QTREE *newroot;
55: extern char *need();
56: register int len;
57:
58: # ifdef xDTR1
59: if (tTf(64, -1))
60: printf("COPY_ANDS");
61: # endif
62: newroot = (QTREE *) need(buf, 0);
63: y = 0;
64:
65: for (q=root; q->sym.type != QLEND; q=q->right)
66: {
67: len = q->sym.len & I1MASK;
68: x = (QTREE *) need(buf, len + QT_HDR_SIZ);
69: x->left = q->left;
70: bmove((char *)&q->sym, (char *)&x->sym, len + SYM_HDR_SIZ);
71: if (y)
72: y->right = x;
73: y = x;
74: }
75: y->right = q;
76:
77: # ifdef xDTR1
78: if (tTf(64, 0))
79: {
80: printf("New tree\n");
81: treepr(newroot);
82: }
83: # endif
84: return(newroot);
85: }
86:
87:
88:
89: QTREE *
90: makroot(buf)
91: char *buf;
92: {
93: register QTREE *s;
94: extern char *need();
95:
96: s = (QTREE *) need(buf, QT_HDR_SIZ + sizeof (struct rootnode));
97: s->right = De.de_qle;
98: s->left = De.de_tr;
99: s->sym.value.sym_root.rootuser = FALSE;
100: s->sym.value.sym_root.lvarm = 0;
101: s->sym.value.sym_root.rvarm = 0;
102: s->sym.value.sym_root.tvarc = 0;
103: s->sym.value.sym_root.lvarc = 0;
104: s->sym.type = ROOT;
105: s->sym.len = sizeof (struct rootnode);
106: return (s);
107: }
108:
109:
110: QTREE *
111: makresdom(buf, node)
112: char *buf;
113: QTREE *node;
114: {
115: register QTREE *res, *n;
116: extern char *need();
117:
118: n = node;
119: res = (QTREE *) need(buf, QT_HDR_SIZ + sizeof(struct resdomnode));
120: res->sym.type = RESDOM;
121: res->sym.len = sizeof(struct resdomnode);
122: if (n->sym.type == AOP)
123: {
124: res->sym.value.sym_resdom.resfrmt = n->sym.value.sym_op.agfrmt;
125: res->sym.value.sym_resdom.resfrml = n->sym.value.sym_op.agfrml;
126: }
127: else
128: {
129: res->sym.value.sym_resdom.resfrmt = n->sym.value.sym_var.varfrmt;
130: res->sym.value.sym_resdom.resfrml = n->sym.value.sym_var.varfrml;
131: }
132: return (res);
133: }
134:
135: QTREE *
136: makavar(node, varnum, attnum)
137: QTREE *node;
138: int varnum, attnum;
139: {
140: register QTREE *avar, *n;
141: extern char *need();
142:
143: n = node;
144:
145: avar = (QTREE *) need(De.de_qbuf, QT_HDR_SIZ + sizeof(struct varnode));
146: avar->left = avar->right = NULL;
147: avar->sym.value.sym_var.valptr = NULL;
148: avar->sym.type = VAR;
149: avar->sym.len = sizeof(struct varnode);
150: avar->sym.value.sym_var.varfrmt = n->sym.value.sym_var.varfrmt;
151: avar->sym.value.sym_var.varfrml = n->sym.value.sym_var.varfrml;
152: avar->sym.value.sym_var.varno = varnum;
153: avar->sym.value.sym_var.attno = attnum;
154: # ifdef xDTR1
155: if (tTf(64, 3))
156: {
157: printf("makavar: node=%x ", n);
158: nodepr(avar);
159: }
160: # endif
161: return(avar);
162: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.