![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to readinput.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / ingres / source / ctlmod|
Return to readinput.c CVS log | Up to [CSRG BSD Unix] / 43BSD / ingres / source / ctlmod |
1.1 root 1: # include "ctlmod.h"
2: # include "pipes.h"
3: # include <resp.h>
4: # include <ingres.h>
5: # include <aux.h>
6: # include <tree.h>
7: # include <sccs.h>
8:
9: SCCSID(@(#)readinput.c 8.1 12/31/84)
10:
11: /*
12: ** READINPUT -- read the input pipe and determine next function
13: **
14: ** The input pipe is read (using pb_get). Parameters are
15: ** collected and set up in the global Ctx.ctx_pv. *ppb
16: ** is set to the new function, block type, etc.
17: **
18: ** If an error block is read, the error routine processing
19: ** is invoked.
20: **
21: ** Parameters:
22: ** ppb -- a pointer to the pipe block to read into;
23: ** also becomes part of the return value.
24: **
25: ** Returns:
26: ** nothing directly.
27: **
28: ** Side Effects:
29: ** Sets Ctx.ctx_pv, Ctx.ctx_pc to the new parmv &
30: ** parmc read from the pipe.
31: ** Sets the *ppb struct to indicate state, etc.
32: **
33: ** Trace Flags:
34: ** 10.0 - 10.5
35: */
36:
37: readinput(ppb)
38: register pb_t *ppb;
39: {
40: register int i;
41:
42: /*
43: ** Top Loop.
44: ** Executed once for each complete block read. Normally
45: ** only executed once, but can be more if an error
46: ** block is read.
47: **
48: ** We mark Qbuf first, so we can free any parameters
49: ** when they are no longer needed (such as when they
50: ** are passed to another process).
51: */
52:
53: Ctx.ctx_pmark = markbuf(Qbuf);
54: # ifdef xCTR1
55: if (tTf(10, 0))
56: lprintf("readinput: mark %d, errfn %x, ppb %x\n", Ctx.ctx_pmark, Ctx.ctx_errfn, ppb);
57: # endif
58:
59: for (;;)
60: {
61: /* prime the input (reads first block) */
62: pb_prime(ppb, PB_NOTYPE);
63: # ifdef xCTR2
64: if (tTf(10, 1))
65: lprintf("readinput: type %d\n", ppb->pb_type);
66: # endif
67:
68: /* if this is a response block, return immediately */
69: if (ppb->pb_type == PB_RESP)
70: {
71: i = pb_get(ppb, (char *) &Resp, sizeof Resp);
72: if (i != sizeof Resp)
73: syserr("readinput: Resp sz %d", i);
74: /*
75: read_arg(ppb, &Resp.resp_rval);
76: */
77: break;
78: }
79:
80: /*
81: ** Parameter Loop.
82: ** Wander through and start reading parameters.
83: */
84:
85: for (Ctx.ctx_pc = 0; Ctx.ctx_pc < PV_MAXPC; Ctx.ctx_pc++)
86: {
87: if (read_arg(ppb, &Ctx.ctx_pv[Ctx.ctx_pc]) == PV_EOF)
88: break;
89: }
90:
91: /* out of loop, check for vector overflow */
92: if (Ctx.ctx_pc >= PV_MAXPC)
93: syserr("readinput: overflow");
94:
95: /* check for error blocks */
96: if (ppb->pb_type == PB_ERR)
97: {
98: proc_err(ppb, Ctx.ctx_pc, Ctx.ctx_pv);
99: syserr("readinput: proc_err");
100: }
101:
102:
103: /* non-error block */
104: # ifdef xCM_DEBUG
105: if (ppb->pb_type != PB_REG)
106: syserr("readinput: pb_type %d", ppb->pb_type);
107: # endif
108: Ctx.ctx_resp = ppb->pb_resp;
109: break;
110: }
111: # ifdef xCTR1
112: if (tTf(10, 4))
113: {
114: lprintf("readinput: ");
115: pb_dump(ppb, FALSE);
116: }
117: # endif
118: }
119: /*
120: ** READ_ARG -- Read a single argument from pipe
121: **
122: ** An argument can be as simple as an integer, or as complex
123: ** as a query tree.
124: **
125: ** Parameters:
126: ** ppb -- the pipe block to read from.
127: ** pparm -- the parameter descripter to put the
128: ** argument in.
129: **
130: ** Returns:
131: ** none.
132: **
133: ** Side Effects:
134: ** May allocate space from Qbuf for trees, etc.
135: **
136: ** Called By:
137: ** readinput
138: **
139: ** Trace Flags:
140: ** 10.6 - 10.7
141: */
142:
143: read_arg(ppb, pparm)
144: register pb_t *ppb;
145: register PARM *pparm;
146: {
147: auto char ptype;
148: auto short plen;
149: register int i;
150: register char *p;
151: QTREE *q;
152: extern char *need();
153: extern QTREE *readqry();
154:
155: /* get the parameter type */
156: i = pb_get(ppb, &ptype, 1);
157: if (i == 0)
158: {
159: pparm->pv_type = PV_EOF;
160: pparm->pv_val.pv_str = NULL;
161: return (PV_EOF);
162: }
163: i = pb_get(ppb, (char *) &plen, 2);
164: if (i < 2)
165: syserr("readarg: pb_get %d", i);
166:
167: /* figure out the type */
168: switch (ptype)
169: {
170: case PV_INT:
171: # ifdef xCM_DEBUG
172: if (plen != sizeof pparm->pv_val.pv_int)
173: syserr("readinput: PV_INT %d", plen);
174: # endif
175: pb_get(ppb, (char *) &pparm->pv_val.pv_int, plen);
176: break;
177:
178: case PV_STR:
179: case PV_TUPLE:
180: p = need(Qbuf, plen);
181: pb_get(ppb, p, plen);
182: pparm->pv_val.pv_str = p;
183: break;
184:
185: case PV_QTREE:
186: q = readqry(pb_get, (int) ppb, TRUE);
187: pparm->pv_val.pv_qtree = q;
188: break;
189:
190: case PV_EOF:
191: /* this case is allowed for the mon-par interface */
192: break;
193:
194: default:
195: syserr("readinput: type %d len %d", ptype, plen);
196: }
197:
198: /* save the type & length */
199: pparm->pv_type = ptype;
200: pparm->pv_len = plen;
201:
202: return (ptype);
203: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.