![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to input.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / b / STREAMS / conf / bin / src|
Return to input.c CVS log | Up to [MW Coherent from dump] / coherent / b / STREAMS / conf / bin / src |
1.1 root 1: /*
2: * Input stream abstraction.
3: */
4:
5: /*
6: *-IMPORTS:
7: * <sys/compat.h>
8: * CONST
9: * USE_PROTO
10: * ARGS ()
11: * LOCAL
12: * <stddef.h>
13: * NULL
14: * offsetof ()
15: * <stdio.h>
16: * EOF
17: * FILE
18: * stderr
19: * fprintf ()
20: * fputs ()
21: * getc ()
22: * putc ()
23: * <stdlib.h>
24: * free ()
25: * malloc ()
26: * <string.h>
27: * memcpy ()
28: * strlen ()
29: */
30:
31: #include <common/tricks.h>
32: #include <sys/compat.h>
33: #include <stddef.h>
34: #include <stdio.h>
35: #include <stdlib.h>
36: #include <string.h>
37: #include <stdarg.h>
38:
39: #include "devadm.h"
40:
41: #include "lex.h"
42:
43: #include "input.h"
44: #include "mkinput.h"
45:
46:
47: /*
48: * Structures for dealing with input from a file.
49: *
50: * A new feature added to this for the 'devadm' utility is support for an
51: * output file attached to the input file that can be used to support input
52: * filtering effectively. Comments in the input source are copied to the
53: * output by the lower layer, while higher-level software can perform semantic
54: * processing and then copy the resulting changes out, retaining the relative
55: * ordering of the components. This may cause some reordering (moving comments
56: * at the end of a line to the beginning of a line), but will in general be
57: * benign.
58: */
59:
60: typedef struct fileinput filein_t;
61:
62: struct fileinput {
63: input_t fi_input;
64:
65: char * fi_name;
66: FILE * fi_infile; /* input stream */
67: int fi_inclose; /* close when stream is closed? */
68: FILE * fi_outfile; /* output stream */
69: int fi_outclose; /* close when stream is closed? */
70: int fi_lineno; /* line number in file */
71: int fi_colno; /* current column number */
72: int fi_prevline;
73: int fi_prevcol;
74: int fi_comment; /* comment character (maybe none) */
75: int fi_prevchar; /* previous character */
76: int fi_outcol; /* output column number */
77:
78: char fi_line [64]; /* line buffer for errors */
79: };
80:
81: #define ARRAY_LEN(a) (sizeof (a) / sizeof (* a))
82:
83:
84: /*
85: * Structure for processing input from a string.
86: */
87:
88: typedef struct strinput strin_t;
89:
90: struct strinput {
91: input_t si_input;
92:
93: CONST unsigned char
94: * si_data; /* data being read */
95: size_t si_pos; /* position in input stream */
96: size_t si_len; /* length of input stream */
97: };
98:
99:
100: /*
101: * Send a single character to the filter output.
102: */
103:
104: #if USE_PROTO
105: LOCAL int _fi_putc (int ch, filein_t * fi)
106: #else
107: LOCAL int
108: _fi_putc (ch, fi)
109: int ch;
110: filein_t * fi;
111: #endif
112: {
113: FILE * file;
114:
115: if ((file = fi->fi_outfile) == NULL) {
116: #if TRACE
117: if (do_debug == 0)
118: return 0;
119: file = stderr;
120: #else
121: return 0;
122: #endif
123: }
124:
125: if (fputc (ch, file) < 0)
126: return -1;
127:
128: switch (ch) {
129: case '\n':
130: fi->fi_outcol = 0;
131: break;
132:
133: case '\t':
134: fi->fi_outcol = ROUND_UP_TO_MULTIPLE (fi->fi_outcol + 1, 8);
135: break;
136:
137: default:
138: fi->fi_outcol ++;
139: break;
140: }
141:
142: return 0;
143: }
144:
145:
146: /*
147: * Read a character from a file.
148: */
149:
150: #if USE_PROTO
151: LOCAL int fi_read (input_t * input)
152: #else
153: LOCAL int
154: fi_read (input)
155: input_t * input;
156: #endif
157: {
158: filein_t * fi = (filein_t *) input;
159: int ch;
160:
161: /*
162: * Get a character from the input file, recording the data for the
163: * purpose of error reporting.
164: */
165:
166: fi->fi_prevcol = fi->fi_colno;
167: fi->fi_prevline = fi->fi_lineno;
168:
169: another_line:
170: if ((ch = getc (fi->fi_infile)) == EOF)
171: return IN_EOF;
172:
173: fi->fi_line [fi->fi_colno ++ % ARRAY_LEN (fi->fi_line)] = ch;
174:
175: if (ch == fi->fi_comment) {
176: /*
177: * Consume data to EOL, then return EOL.
178: */
179:
180: do {
181: _fi_putc (ch, fi);
182:
183: if ((ch = getc (fi->fi_infile)) == EOF)
184: return IN_EOF;
185: } while (ch != '\n');
186:
187: if (fi->fi_colno > 1)
188: _fi_putc (ch, fi);
189: }
190:
191:
192: if (ch == '\n') {
193:
194: fi->fi_lineno ++;
195:
196: if (fi->fi_colno == 1) {
197:
198: _fi_putc (ch, fi);
199: goto another_line;
200: };
201:
202: fi->fi_colno = 0;
203: }
204:
205: fi->fi_prevchar = ch;
206: return ch;
207: }
208:
209:
210: /*
211: * Return the last read character to the input stream.
212: */
213:
214: #if USE_PROTO
215: LOCAL void fi_unread (input_t * input)
216: #else
217: LOCAL void
218: fi_unread (input)
219: input_t * input;
220: #endif
221: {
222: filein_t * fi = (filein_t *) input;
223:
224: if (fi->fi_prevchar != IN_EOF) {
225:
226: ungetc (fi->fi_prevchar, fi->fi_infile);
227:
228: fi->fi_prevchar = IN_EOF;
229: fi->fi_colno = fi->fi_prevcol;
230: fi->fi_lineno = fi->fi_prevline;
231: }
232: }
233:
234:
235: /*
236: * Close the input file.
237: */
238:
239: #if USE_PROTO
240: LOCAL void fi_close (input_t * input)
241: #else
242: LOCAL void
243: fi_close (input)
244: input_t * input;
245: #endif
246: {
247: filein_t * fi = (filein_t *) input;
248:
249: if (fi->fi_infile != NULL && fi->fi_inclose)
250: (void) fclose (fi->fi_infile);
251: if (fi->fi_outfile != NULL && fi->fi_outclose)
252: (void) fclose (fi->fi_outfile);
253: free (fi);
254: }
255:
256:
257: /*
258: * Produce an error report for this input source.
259: */
260:
261: #if USE_PROTO
262: LOCAL void fi_error (input_t * input)
263: #else
264: LOCAL void
265: fi_error (input)
266: input_t * input;
267: #endif
268: {
269: filein_t * fi = (filein_t *) input;
270: int col;
271: int ch;
272: int end;
273:
274: (void) fprintf (stderr, "Error vicinity : file \"%s\", line %d, column %d\n",
275: fi->fi_name, fi->fi_prevline, fi->fi_prevcol);
276:
277: col = fi->fi_prevcol < 40 ? 0 : fi->fi_prevcol - 40;
278:
279: if (fi->fi_colno > (end = fi->fi_prevcol))
280: end ++;
281:
282: while (col < end) {
283: /*
284: * Should think about escaping controls.
285: */
286:
287: ch = fi->fi_line [col ++ % ARRAY_LEN (fi->fi_line)];
288: (void) putc (ch, stderr);
289: }
290:
291:
292: fputs (" <---\n", stderr);
293: }
294:
295:
296: /*
297: * Perform columnar formatted output.
298: */
299:
300: #if USE_PROTO
301: LOCAL int fi_filter (input_t * input, CONST char * format, ...)
302: #else
303: LOCAL int
304: fi_filter (input, format)
305: input_t * input;
306: CONST char * format;
307: #endif
308: {
309: filein_t * fi = (filein_t *) input;
310: va_list args;
311: FILE * file;
312:
313: if ((file = fi->fi_outfile) == NULL) {
314: #if TRACE
315: if (do_debug == 0)
316: return 0;
317: file = stderr;
318: #else
319: return 0;
320: #endif
321: }
322:
323: va_start (args, format);
324:
325: while (* format) {
326: char ch;
327: int cols;
328: char * tmp;
329: static char digits [] = "0123456789";
330: int long_datum;
331:
332: /*
333: * We accept either a '%' or '<' sign to introduce a format
334: * so that we don't clutter things up with too many '%'-signs.
335: */
336:
337: if (((ch = * format ++) != '%' && ch != '<') ||
338: * format == ch) {
339: _fi_putc (ch, fi);
340: continue;
341: }
342:
343: if ((ch = * format ++) == 0)
344: return -1;
345:
346: /*
347: * After a percent-sign, look for a number of tab-columns to
348: * align the output to.
349: */
350:
351: cols = 0;
352: while ((tmp = strchr (digits, ch)) != NULL) {
353:
354: cols = (cols * 10) + (tmp - digits);
355: if ((ch = * format ++) == 0)
356: break;
357: }
358:
359: /*
360: * Dispatch on the format character and record the number of
361: * characters written (which will be negative on error).
362: */
363:
364: if ((long_datum = ch == 'l') != 0)
365: ch = * format ++;
366:
367: switch (ch) {
368: case 'c':
369: ch = fprintf (file, "%*c", cols,
370: va_arg (args, int));
371: break;
372:
373: case 's':
374: ch = fprintf (file, "%*s", cols,
375: va_arg (args, char *));
376: break;
377:
378: case 'd':
379: ch = fprintf (file, "%*ld", cols,
380: long_datum ? va_arg (args, long) :
381: (long) va_arg (args, int));
382: break;
383:
384: case 'x':
385: ch = fprintf (file, "%*lx", cols,
386: long_datum ? va_arg (args, long) :
387: (long) va_arg (args, int));
388: break;
389:
390: case '>':
391: /*
392: * Here is what we add: <{digits}> indicates a column
393: * number to seek forward to.
394: */
395:
396: cols = cols * 8 - fi->fi_outcol;
397:
398: if (cols <= 0)
399: _fi_putc (' ', fi);
400:
401: while (cols > 0) {
402: _fi_putc ('\t', fi);
403: cols -= 8;
404: }
405:
406: ch = 0;
407: break;
408:
409: default:
410: return -1;
411: }
412:
413: if (ch < 0)
414: return -1;
415:
416: fi->fi_outcol += ch;
417: }
418:
419: va_end (args);
420: return 0;
421: }
422:
423:
424: /*
425: * Create a source of input from a file. The 'comment' parameter gives the
426: * code of a character which can be used to indicate input sections that are
427: * to be ignored. The 'filter' parameter points to an optional FILE where the
428: * input is going to be copied.
429: */
430:
431: #if USE_PROTO
432: input_t * (make_filter) (FILE * infile, CONST char * inname, int inclose,
433: int comment, FILE * outfile, int outclose)
434: #else
435: input_t *
436: make_filter ARGS ((infile, inname, inclose, comment, outfile, outclose))
437: FILE * infile;
438: CONST char * inname;
439: int inclose;
440: int comment;
441: FILE * outfile;
442: int outclose;
443: #endif
444: {
445: filein_t * fi;
446: size_t namelen;
447:
448: /* ASSERT that fi_input is the first member of the structure */
449:
450: if (offsetof (filein_t, fi_input) != 0)
451: return NULL;
452:
453: if (inname == NULL)
454: inname = "no name";
455:
456: namelen = strlen (inname) + 1;
457:
458: if ((fi = (filein_t *) malloc (sizeof (* fi) + namelen)) == NULL)
459: return NULL;
460:
461: fi->fi_lineno = 1;
462: fi->fi_colno = 0;
463: fi->fi_infile = infile;
464: fi->fi_inclose = inclose;
465: fi->fi_outfile = outfile;
466: fi->fi_outclose = outclose;
467: fi->fi_name = (char *) (fi + 1);
468:
469: fi->fi_comment = comment;
470: fi->fi_prevchar = IN_EOF;
471:
472: if (namelen > 0)
473: memcpy (fi->fi_name, inname, namelen);
474:
475: fi->fi_input.in_read = fi_read;
476: fi->fi_input.in_unread = fi_unread;
477: fi->fi_input.in_readtok = NULL;
478: fi->fi_input.in_close = fi_close;
479: fi->fi_input.in_error = fi_error;
480: fi->fi_input.in_filter = fi_filter;
481:
482: return & fi->fi_input;
483: }
484:
485:
486: /*
487: * Return a character from an input string, or EOF when the end-of-string is
488: * reached.
489: */
490:
491: #if USE_PROTO
492: LOCAL int si_read (input_t * input)
493: #else
494: LOCAL int
495: si_read (input)
496: input_t * input;
497: #endif
498: {
499: strin_t * si = (strin_t *) input;
500:
501: if (si->si_pos >= si->si_len)
502: return IN_EOF;
503:
504: return si->si_data [si->si_pos ++];
505: }
506:
507:
508: /*
509: * Return a character to the input stream to be read again.
510: */
511:
512: #if USE_PROTO
513: LOCAL void si_unread (input_t * input)
514: #else
515: LOCAL void
516: si_unread (input)
517: input_t * input;
518: #endif
519: {
520: strin_t * si = (strin_t *) input;
521:
522: if (si->si_pos > 0)
523: si->si_pos --;
524: }
525:
526:
527: /*
528: * Reading a token, specialized to string input streams.
529: */
530:
531: #if USE_PROTO
532: LOCAL CONST unsigned char * si_readtok (input_t * input, lex_t * lexp,
533: size_t * lengthp)
534: #else
535: LOCAL CONST unsigned char *
536: si_readtok (input, lexp, lengthp)
537: input_t * input;
538: lex_t * lexp;
539: size_t * lengthp;
540: #endif
541: {
542: strin_t * si = (strin_t *) input;
543: int start = -1;
544: int ch;
545:
546: for (;;) {
547: if ((ch = si_read (input)) == IN_EOF)
548: break;
549:
550: switch (classify (lexp, ch, start == -1)) {
551:
552: case CLASS_FLUSH:
553: continue;
554:
555: case CLASS_SEP:
556: si_unread (input);
557: goto separator;
558:
559: default:
560: break;
561: }
562:
563: if (start == -1)
564: start = si->si_pos - 1;
565: }
566:
567: separator:
568: * lengthp = start == -1 ? 0 : si->si_pos - start;
569: return start == -1 ? NULL : & si->si_data [start];
570: }
571:
572:
573: /*
574: * Finish with a string input stream.
575: */
576:
577: #if USE_PROTO
578: LOCAL void si_close (input_t * input)
579: #else
580: LOCAL void
581: si_close (input)
582: input_t * input;
583: #endif
584: {
585: free (input);
586: }
587:
588:
589: /*
590: * Display an error locus in a string input stream.
591: */
592:
593: #if USE_PROTO
594: LOCAL void si_error (input_t * input)
595: #else
596: LOCAL void
597: si_error (input)
598: input_t * input;
599: #endif
600: {
601: strin_t * si = (strin_t *) input;
602: int col;
603:
604: col = si->si_pos < 40 ? 0 : si->si_pos - 40;
605:
606: (void) fprintf (stderr, "Error vicinity in input string : %.*s <---\n",
607: (int) si->si_pos - col, & si->si_data [col]);
608: }
609:
610:
611: /*
612: * The filtering concept does not really apply to strings yet.
613: */
614:
615: #if USE_PROTO
616: LOCAL int si_filter (input_t * NOTUSED (input), CONST char * NOTUSED (format),
617: ...)
618: #else
619: LOCAL int
620: si_filter (input, format)
621: input_t * input;
622: CONST char * format;
623: #endif
624: {
625: return -1;
626: }
627:
628:
629: /*
630: * Create a source of input from a string. Depending on the "action" code,
631: * the string may or may not be copied or left alone. If the user wants some
632: * clean processing to be done at close time, then another version of this
633: * code should be set in place which allows registration of a close-time
634: * callback (which is messy, so it hasn't been done).
635: */
636:
637: #if USE_PROTO
638: input_t * (make_string_input) (CONST unsigned char * str, int copy)
639: #else
640: input_t *
641: make_string_input ARGS ((str, copy))
642: CONST unsigned char
643: * str;
644: int copy;
645: #endif
646: {
647: strin_t * si;
648: size_t len;
649:
650: /* ASSERT that si_input is the first member of the structure */
651:
652: if (offsetof (strin_t, si_input) != 0)
653: return NULL;
654:
655: len = strlen ((char *) str);
656:
657: if ((si = (strin_t *) malloc (sizeof (* si) +
658: (copy ? len : 0))) == NULL)
659: return NULL;
660:
661: si->si_pos = 0;
662: si->si_len = len;
663:
664: if (copy) {
665:
666: si->si_data = (CONST unsigned char *) (si + 1);
667: memcpy (si + 1, str, len);
668: } else
669: si->si_data = str;
670:
671: si->si_input.in_read = si_read;
672: si->si_input.in_unread = si_unread;
673: si->si_input.in_readtok = si_readtok;
674: si->si_input.in_close = si_close;
675: si->si_input.in_error = si_error;
676: si->si_input.in_filter = si_filter;
677:
678: return & si->si_input;
679: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.