![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to printup.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 / iutil|
Return to printup.c CVS log | Up to [CSRG BSD Unix] / 43BSD / ingres / source / iutil |
1.1 root 1: # include <stdio.h>
2: # include <ingres.h>
3: # include <aux.h>
4: # include <access.h>
5: # include <symbol.h>
6: # include <sccs.h>
7:
8: SCCSID(@(#)printup.c 8.3 2/8/85)
9:
10: /*
11: ** PRINTUP -- print tuple
12: **
13: ** Parameters:
14: ** d -- a descriptor describing the tuple.
15: ** tuple -- the tuple to print.
16: **
17: ** Returns:
18: ** ??
19: **
20: ** Side Effects:
21: ** None.
22: */
23:
24: # define PAGELGTH 56
25:
26: int Printlgth;
27: extern struct out_arg Out_arg;
28: int Hdr = 0;
29: HDRINFO *Fieldwidth, *Hdrptr;
30:
31: printup(d, tuple)
32: DESC *d;
33: char *tuple;
34: {
35: register char *ftype, *flen;
36: register short *foff;
37: static double dbl;
38: auto long lng;
39: int i, type;
40: extern HDRINFO *Hdrptr;
41: extern HDRINFO *Fieldwidth;
42:
43: ftype = &d->relfrmt[1];
44: flen = &d->relfrml[1];
45: foff = &d->reloff[1];
46: i = d->reldum.relatts;
47:
48: /* If relation is S_BINARY then print char fields escaped */
49: if (d->reldum.relstat & S_BINARY)
50: {
51: while (i--)
52: printatt((type = *ftype++) == CHAR ? BINARY : type, *flen++, &tuple[*foff++]);
53: }
54: else
55: {
56: while (i--)
57: {
58: switch ( *ftype )
59: {
60: case FLOAT:
61: bmove(&tuple[*foff++],&dbl,*flen);
62: printatt(*ftype++, *flen++, (ANYTYPE *)&dbl);
63: break;
64:
65: case CHAR:
66: printatt(*ftype++, *flen++, (ANYTYPE *)&tuple[*foff++]);
67: break;
68:
69: case INT:
70: if ( *flen != 4 )
71: printatt(*ftype++, *flen++, (ANYTYPE *)&tuple[*foff++]);
72: else
73: {
74: bmove(&tuple[*foff++],&lng,4);
75: printatt(*ftype++, *flen++, (ANYTYPE *)&lng);
76: }
77: break;
78: }
79: }
80: }
81: printeol();
82: }
83:
84: printatt(type, length, value)
85: char type;
86: register int length;
87: register ANYTYPE *value;
88: {
89: char buf[MAXFIELD];
90: ANYTYPE valbuf;
91: double dbl;
92: float flt;
93: extern char *iocv();
94: extern char *locv();
95: extern HDRINFO *Hdrptr;
96: extern HDRINFO *Fieldwidth;
97: extern int Hdr;
98: register char *p;
99:
100: putc(Out_arg.coldelim, stdout);
101: switch (type)
102: {
103: case INT:
104: switch (length)
105: {
106: case 1:
107: printfatt(Out_arg.i1width, iocv(value->i1type));
108: break;
109:
110: case 2:
111: printfatt(Out_arg.i2width, iocv(value->i2type));
112: break;
113:
114: case 4:
115: printfatt(Out_arg.i4width, locv(value->i4type));
116: break;
117:
118: default:
119: syserr("printatt: i%d", length);
120: }
121: return (0);
122:
123: case FLOAT:
124: switch (length)
125: {
126: case 4:
127: ftoa(value->f4type, buf, Out_arg.f4width, Out_arg.f4prec, Out_arg.f4style);
128: printfatt(Out_arg.f4width, buf);
129: break;
130:
131: case 8:
132: dbl = value->f8type;
133:
134: ftoa(dbl, (char *)buf, (int)Out_arg.f8width,(int) Out_arg.f8prec, (char)Out_arg.f8style);
135: printfatt(Out_arg.f8width, buf);
136: break;
137:
138: default:
139: syserr("printatt: f%d", length);
140: }
141: return (0);
142:
143: case CHAR:
144: length &= I1MASK;
145: if (Hdr)
146: {
147: if (length > Fieldwidth->len)
148: length = Fieldwidth->len;
149: }
150: fwrite(value, 1, length, stdout);
151: if (Hdr)
152: {
153: if ((length = Fieldwidth->len - length) > 0)
154: while (length--)
155: putc(' ', stdout);
156: if ((length = Out_arg.c0width - Fieldwidth->len) > 0)
157: while (length--)
158: putc(' ', stdout);
159: Fieldwidth = Fieldwidth->next;
160: if (Fieldwidth == NULL)
161: Fieldwidth = Hdrptr;
162: }
163: else
164: {
165: if ((length = Out_arg.c0width - length) > 0)
166: while (length--)
167: putc(' ', stdout);
168: }
169: return (0);
170:
171: case BINARY:
172: length &= I1MASK;
173: p = (char *) value;
174: while (length--)
175: xputchar(*p++);
176: return (0);
177:
178: default:
179: syserr("printatt type %d", type);
180: }
181: }
182: /*
183: ** FORMATTED ATTRIBUTE PRINT
184: **
185: ** Attribute 'value' is printed. It is type 'type' and has a
186: ** field width of 'width'.
187: */
188:
189: printfatt(width, value)
190: int width;
191: char *value;
192: {
193: register char *p;
194: register int w;
195: register int v;
196:
197: w = width;
198: p = value;
199: v = length(p);
200:
201: if (v > w)
202: {
203: /* field overflow */
204: while (w--)
205: putc('*', stdout);
206: return;
207: }
208:
209: /* output the field */
210: for (w -= v; w > 0; w--)
211: putc(' ', stdout);
212: fwrite(p, 1, v, stdout);
213: }
214:
215:
216: printeol()
217: {
218: putc(Out_arg.coldelim, stdout);
219: putc('\n', stdout);
220: }
221:
222: printeh()
223: {
224: register int i;
225:
226: putc(Out_arg.coldelim, stdout);
227: for (i = 1; i < Printlgth; i++)
228: putc('-', stdout);
229: printeol();
230: }
231:
232: printhdr(type, length, value)
233: char type;
234: register int length;
235: register char *value;
236: {
237: register int i;
238: char c;
239:
240: switch (type)
241: {
242: case INT:
243: switch (length)
244: {
245: case 1:
246: length = Out_arg.i1width;
247: break;
248:
249: case 2:
250: length = Out_arg.i2width;
251: break;
252:
253: case 4:
254: length = Out_arg.i4width;
255: break;
256:
257: default:
258: syserr("printhdr: i%d", length);
259: }
260: break;
261:
262: case FLOAT:
263: switch (length)
264: {
265: case 4:
266: length = Out_arg.f4width;
267: break;
268:
269: case 8:
270: length = Out_arg.f8width;
271: break;
272:
273: default:
274: syserr("printhdr: f%d", length);
275: }
276: break;
277:
278: case CHAR:
279: length &= I1MASK;
280: if (length < Out_arg.c0width)
281: length = Out_arg.c0width;
282: break;
283:
284: default:
285: syserr("printhdr: type 0%o", type);
286: }
287:
288: putc(Out_arg.coldelim, stdout);
289: for (i = 0; i < length && i < MAXNAME; i++)
290: if (c = *value++)
291: putc(c, stdout);
292: else
293: break;
294:
295: for ( ; i < length; i++)
296: putc(' ', stdout);
297:
298: Printlgth += length + 1;
299: }
300:
301: beginhdr()
302: {
303: Printlgth = 0;
304: putchar('\n');
305: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.