![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to niceprintf.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / f2c|
Return to niceprintf.c CVS log | Up to [Research Unix] / researchv10no / cmd / f2c |
1.1 root 1: /****************************************************************
2: Copyright 1990, 1991, 1993 by AT&T Bell Laboratories and Bellcore.
3:
4: Permission to use, copy, modify, and distribute this software
5: and its documentation for any purpose and without fee is hereby
6: granted, provided that the above copyright notice appear in all
7: copies and that both that the copyright notice and this
8: permission notice and warranty disclaimer appear in supporting
9: documentation, and that the names of AT&T Bell Laboratories or
10: Bellcore or any of their entities not be used in advertising or
11: publicity pertaining to distribution of the software without
12: specific, written prior permission.
13:
14: AT&T and Bellcore disclaim all warranties with regard to this
15: software, including all implied warranties of merchantability
16: and fitness. In no event shall AT&T or Bellcore be liable for
17: any special, indirect or consequential damages or any damages
18: whatsoever resulting from loss of use, data or profits, whether
19: in an action of contract, negligence or other tortious action,
20: arising out of or in connection with the use or performance of
21: this software.
22: ****************************************************************/
23:
24: #include "defs.h"
25: #include "names.h"
26: #include "output.h"
27:
28: #define TOO_LONG_INDENT (2 * tab_size)
29: #define MAX_INDENT 44
30: #define MIN_INDENT 22
31: static int last_was_newline = 0;
32: int indent = 0;
33: int in_comment = 0;
34: int in_define = 0;
35: extern int gflag1;
36: extern char *file_name;
37:
38: static int
39: write_indent(fp, use_indent, extra_indent, start, end)
40: FILE *fp;
41: int use_indent, extra_indent;
42: char *start, *end;
43: {
44: int ind, tab;
45:
46: if (gflag1 && last_was_newline)
47: fprintf(fp, "#line %ld \"%s\"\n", lineno, file_name);
48: if (in_define == 1) {
49: in_define = 2;
50: use_indent = 0;
51: }
52: if (last_was_newline && use_indent) {
53: if (*start == '\n') do {
54: putc('\n', fp);
55: if (++start > end)
56: return;
57: }
58: while(*start == '\n');
59:
60: ind = indent <= MAX_INDENT
61: ? indent
62: : MIN_INDENT + indent % (MAX_INDENT - MIN_INDENT);
63:
64: tab = ind + extra_indent;
65:
66: while (tab > 7) {
67: putc ('\t', fp);
68: tab -= 8;
69: } /* while */
70:
71: while (tab-- > 0)
72: putc (' ', fp);
73: } /* if last_was_newline */
74:
75: while (start <= end)
76: putc (*start++, fp);
77: } /* write_indent */
78:
79:
80: /*VARARGS2*/
81: int margin_printf (fp, a, b, c, d, e, f, g)
82: FILE *fp;
83: char *a;
84: long b, c, d, e, f, g;
85: {
86: ind_printf (0, fp, a, b, c, d, e, f, g);
87: } /* margin_printf */
88:
89: /*VARARGS2*/
90: int nice_printf (fp, a, b, c, d, e, f, g)
91: FILE *fp;
92: char *a;
93: long b, c, d, e, f, g;
94: {
95: ind_printf (1, fp, a, b, c, d, e, f, g);
96: } /* nice_printf */
97:
98:
99: #define max_line_len c_output_line_length
100: /* 74Number of characters allowed on an output
101: line. This assumes newlines are handled
102: nicely, i.e. a newline after a full text
103: line on a terminal is ignored */
104:
105: /* output_buf holds the text of the next line to be printed. It gets
106: flushed when a newline is printed. next_slot points to the next
107: available location in the output buffer, i.e. where the next call to
108: nice_printf will have its output stored */
109:
110: static char *output_buf;
111: static char *next_slot;
112: static char *string_start;
113:
114: static char *word_start = NULL;
115: static int cursor_pos = 0;
116: static int In_string = 0;
117:
118: void
119: np_init()
120: {
121: next_slot = output_buf = Alloc(MAX_OUTPUT_SIZE);
122: memset(output_buf, 0, MAX_OUTPUT_SIZE);
123: }
124:
125: static char *
126: adjust_pointer_in_string(pointer)
127: register char *pointer;
128: {
129: register char *s, *s1, *se, *s0;
130:
131: /* arrange not to break \002 */
132: s1 = string_start ? string_start : output_buf;
133: for(s = s1; s < pointer; s++) {
134: s0 = s1;
135: s1 = s;
136: if (*s == '\\') {
137: se = s++ + 4;
138: if (se > pointer)
139: break;
140: if (*s < '0' || *s > '7')
141: continue;
142: while(++s < se)
143: if (*s < '0' || *s > '7')
144: break;
145: --s;
146: }
147: }
148: return s0 - 1;
149: }
150:
151: /* ANSI says strcpy's behavior is undefined for overlapping args,
152: * so we roll our own fwd_strcpy: */
153:
154: static void
155: fwd_strcpy(t, s)
156: register char *t, *s;
157: { while(*t++ = *s++); }
158:
159: /* isident -- true iff character could belong to a unit. C allows
160: letters, numbers and underscores in identifiers. This also doubles as
161: a check for numeric constants, since we include the decimal point and
162: minus sign. The minus has to be here, since the constant "10e-2"
163: cannot be broken up. The '.' also prevents structure references from
164: being broken, which is a quite acceptable side effect */
165:
166: #define isident(x) (Tr[x] & 1)
167: #define isntident(x) (!Tr[x])
168:
169: int ind_printf (use_indent, fp, a, b, c, d, e, f, g)
170: int use_indent;
171: FILE *fp;
172: char *a;
173: long b, c, d, e, f, g;
174: {
175: extern int max_line_len;
176: extern FILEP c_file;
177: extern char tr_tab[]; /* in output.c */
178: register char *Tr = tr_tab;
179: int ch, inc, ind;
180: static int extra_indent, last_indent, set_cursor = 1;
181:
182: cursor_pos += indent - last_indent;
183: last_indent = indent;
184: sprintf (next_slot, a, b, c, d, e, f, g);
185:
186: if (fp != c_file) {
187: fprintf (fp,"%s", next_slot);
188: return 1;
189: } /* if fp != c_file */
190:
191: do {
192: char *pointer;
193:
194: /* The for loop will parse one output line */
195:
196: if (set_cursor) {
197: ind = indent <= MAX_INDENT
198: ? indent
199: : MIN_INDENT + indent % (MAX_INDENT - MIN_INDENT);
200: cursor_pos = ind + extra_indent;
201: set_cursor = 0;
202: }
203: if (in_comment)
204: for (pointer = next_slot; *pointer && *pointer != '\n' &&
205: cursor_pos <= max_line_len; pointer++)
206: cursor_pos++;
207: else
208: for (pointer = next_slot; *pointer && *pointer != '\n' &&
209: cursor_pos <= max_line_len; pointer++) {
210:
211: /* Update state variables here */
212:
213: if (In_string) {
214: switch(*pointer) {
215: case '\\':
216: if (++cursor_pos > max_line_len) {
217: cursor_pos -= 2;
218: --pointer;
219: goto overflow;
220: }
221: ++pointer;
222: break;
223: case '"':
224: In_string = 0;
225: word_start = 0;
226: }
227: }
228: else switch (*pointer) {
229: case '"':
230: if (cursor_pos + 5 > max_line_len) {
231: word_start = 0;
232: --pointer;
233: goto overflow;
234: }
235: In_string = 1;
236: string_start = word_start = pointer;
237: break;
238: case '\'':
239: if (pointer[1] == '\\')
240: if ((ch = pointer[2]) >= '0' && ch <= '7')
241: for(inc = 3; pointer[inc] != '\''
242: && ++inc < 5;);
243: else
244: inc = 3;
245: else
246: inc = 2;
247: /*debug*/ if (pointer[inc] != '\'')
248: /*debug*/ fatalstr("Bad character constant %.10s",
249: pointer);
250: if ((cursor_pos += inc) > max_line_len) {
251: cursor_pos -= inc;
252: word_start = 0;
253: --pointer;
254: goto overflow;
255: }
256: word_start = pointer;
257: pointer += inc;
258: break;
259: case '\t':
260: cursor_pos = 8 * ((cursor_pos + 8) / 8) - 1;
261: break;
262: default: {
263:
264: /* HACK Assumes that all characters in an atomic C token will be written
265: at the same time. Must check for tokens first, since '-' is considered
266: part of an identifier; checking isident first would mean breaking up "->" */
267:
268: if (word_start) {
269: if (isntident(*(unsigned char *)pointer))
270: word_start = NULL;
271: }
272: else if (isident(*(unsigned char *)pointer))
273: word_start = pointer;
274: break;
275: } /* default */
276: } /* switch */
277: cursor_pos++;
278: } /* for pointer = next_slot */
279: overflow:
280: if (*pointer == '\0') {
281:
282: /* The output line is not complete, so break out and don't output
283: anything. The current line fragment will be stored in the buffer */
284:
285: next_slot = pointer;
286: break;
287: } else {
288: char last_char;
289: int in_string0 = In_string;
290:
291: /* If the line was too long, move pointer back to the character before
292: the current word. This allows line breaking on word boundaries. Make
293: sure that 80 character comment lines get broken up somehow. We assume
294: that any non-string 80 character identifier must be in a comment.
295: */
296:
297: if (*pointer == '\n')
298: in_define = 0;
299: else if (word_start && word_start > output_buf)
300: if (In_string)
301: if (string_start && pointer - string_start < 5)
302: pointer = string_start - 1;
303: else {
304: pointer = adjust_pointer_in_string(pointer);
305: string_start = 0;
306: }
307: else if (word_start == string_start
308: && pointer - string_start >= 5) {
309: pointer = adjust_pointer_in_string(next_slot);
310: In_string = 1;
311: string_start = 0;
312: }
313: else
314: pointer = word_start - 1;
315: else if (cursor_pos > max_line_len) {
316: #ifndef ANSI_Libraries
317: extern char *strchr();
318: #endif
319: if (In_string) {
320: pointer = adjust_pointer_in_string(pointer);
321: if (string_start && pointer > string_start)
322: string_start = 0;
323: }
324: else if (strchr("&*+-/<=>|", *pointer)
325: && strchr("!%&*+-/<=>^|", pointer[-1])) {
326: pointer -= 2;
327: if (strchr("<>", *pointer)) /* <<=, >>= */
328: pointer--;
329: }
330: else {
331: if (word_start)
332: while(isident(*(unsigned char *)pointer))
333: pointer++;
334: pointer--;
335: }
336: }
337: last_char = *pointer;
338: write_indent(fp, use_indent, extra_indent, output_buf, pointer);
339: next_slot = output_buf;
340: if (In_string && !string_start && Ansi == 1 && last_char != '\n')
341: *next_slot++ = '"';
342: fwd_strcpy(next_slot, pointer + 1);
343:
344: /* insert a line break */
345:
346: if (last_char == '\n') {
347: if (In_string)
348: last_was_newline = 0;
349: else {
350: last_was_newline = 1;
351: extra_indent = 0;
352: }
353: }
354: else {
355: extra_indent = TOO_LONG_INDENT;
356: if (In_string && !string_start) {
357: if (Ansi == 1) {
358: fprintf(fp, "\"\n");
359: use_indent = 1;
360: last_was_newline = 1;
361: }
362: else {
363: fprintf(fp, "\\\n");
364: last_was_newline = 0;
365: }
366: In_string = in_string0;
367: }
368: else {
369: if (in_define)
370: putc('\\', fp);
371: putc ('\n', fp);
372: last_was_newline = 1;
373: }
374: } /* if *pointer != '\n' */
375:
376: if (In_string && Ansi != 1 && !string_start)
377: cursor_pos = 0;
378: else
379: set_cursor = 1;
380:
381: string_start = word_start = NULL;
382:
383: } /* else */
384:
385: } while (*next_slot);
386:
387: return 0;
388: } /* ind_printf */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.