![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to io.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / ucb / indent|
Return to io.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / ucb / indent |
1.1 root 1: /*
2: * Copyright (c) 1980 Regents of the University of California.
3: * Copyright (c) 1976 Board of Trustees of the University of Illinois.
4: * All rights reserved.
5: *
6: * Redistribution and use in source and binary forms are permitted
7: * provided that the above copyright notice and this paragraph are
8: * duplicated in all such forms and that any documentation,
9: * advertising materials, and other materials related to such
10: * distribution and use acknowledge that the software was developed
11: * by the University of California, Berkeley and the University
12: * of Illinois, Urbana. The name of either
13: * University may not be used to endorse or promote products derived
14: * from this software without specific prior written permission.
15: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
16: * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
17: * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
18: */
19:
20: #ifndef lint
21: static char sccsid[] = "@(#)io.c 5.7 (Berkeley) 6/29/88";
22: #endif /* not lint */
23:
24: /*
25: * FILE NAME:
26: * io.c
27: * PURPOSE:
28: * Contains routines to handle i/o related stuff for indent.
29: * GLOBALS:
30: * None
31: * FUNCTIONS:
32: * dump_line
33: * fill_buffer
34: * pad_output
35: * count_spaces
36: * eqin
37: * cmp
38: *
39: */
40: /*-
41: *
42: * Copyright (C) 1976
43: * by the
44: * Board of Trustees
45: * of the
46: * University of Illinois
47: *
48: * All rights reserved
49: *
50: *
51: * NAME:
52: * dump_line
53: *
54: * FUNCTION:
55: * Does the actual printing of the stored up line
56: *
57: * ALGORITHM:
58: * For each of the label, code, and comment sections which are used on
59: * this line:
60: *
61: * 1) Use pad_output to get the section aligned properly.
62: * 2) write the section
63: *
64: * The indentation level used for the code is set by ps.ind_level. After
65: * printing, ps.ind_level is set to ps.i_l_follow.
66: *
67: * An extra level of indentation is added if ps.ind_stmt is 1. After
68: * printing, ps.ind_stmt is set to 1 iff the line just printed has an
69: * unterminated, non-declaration statement.
70: *
71: * HISTORY:
72: * initial coding November 1976 D A Willcox of CAC
73: *
74: */
75: #include "indent_globs.h"
76:
77:
78:
79: int ff = 014; /* used to write a form feed */
80: int comment_open;
81: static paren_target;
82:
83: dump_line()
84: { /* dump_line is the routine that actually
85: * effects the printing of the new source.
86: * It prints the label section, followed
87: * by the code section with the
88: * appropriate nesting level, followed by
89: * any comments */
90: register int cur_col,
91: temp_col,
92: target_col;
93:
94: if (ps.procname[0]) {
95: if (troff)
96: fprintf(output, ".Pr \"%s\"\n", ps.procname);
97: ps.ind_level = 0;
98: ps.procname[0] = 0;
99: }
100: if (s_code == e_code && s_lab == e_lab && s_com == e_com) {
101: if (suppress_blanklines>0) suppress_blanklines--;
102: else {
103: ps.bl_line = true;
104: n_real_blanklines++;
105: }
106: }
107: else if (!inhibit_formatting) {
108: suppress_blanklines = 0;
109: ps.bl_line = false;
110: if (prefix_blankline_requested)
111: if (swallow_optional_blanklines) {
112: if (n_real_blanklines == 1)
113: n_real_blanklines = 0;
114: }
115: else {
116: if (n_real_blanklines == 0)
117: n_real_blanklines = 1;
118: }
119: while (--n_real_blanklines >= 0)
120: putc('\n', output);
121: n_real_blanklines = 0;
122: if (ps.ind_level == 0)
123: ps.ind_stmt = 0; /* this is a class A kludge. dont do
124: * additional statement indentation if we
125: * are at bracket level 0 */
126:
127: if (e_lab != s_lab || e_code != s_code)
128: ++code_lines; /* keep count of lines with code */
129:
130:
131: if (e_lab != s_lab) { /* print lab, if any */
132: if (comment_open) {
133: comment_open = 0;
134: fprintf(output, ".*/\n");
135: }
136: while (e_lab > s_lab && (e_lab[-1] == ' ' || e_lab[-1] == '\t'))
137: e_lab--;
138: cur_col = pad_output(1, compute_label_target());
139: fprintf(output, "%.*s", e_lab - s_lab, s_lab);
140: cur_col = count_spaces(cur_col, s_lab);
141: }
142: else
143: cur_col = 1; /* there is no label section */
144:
145: ps.pcase = false;
146:
147: if (s_code != e_code) { /* print code section, if any */
148: register char *p;
149:
150: if (comment_open) {
151: comment_open = 0;
152: fprintf(output, ".*/\n");
153: }
154: target_col = compute_code_target();
155: {
156: register i;
157:
158: for (i = 0; i < ps.p_l_follow; i++)
159: if (ps.paren_indents[i] >= 0)
160: ps.paren_indents[i] = -(ps.paren_indents[i] + target_col);
161: }
162: cur_col = pad_output(cur_col, target_col);
163: for (p = s_code; p < e_code; p++)
164: if (*p == (char)0200)
165: fprintf(output, "%d", target_col * 7);
166: else
167: putc(*p, output);
168: cur_col = count_spaces(cur_col, s_code);
169: }
170: if (s_com != e_com)
171: if (troff) {
172: register char *p;
173:
174: if (e_com[-1] == '/' && e_com[-2] == '*')
175: e_com -= 2;
176: while (e_com > s_com && e_com[-1] == ' ')
177: e_com--;
178: *e_com = 0;
179: p = s_com;
180: while (*p == ' ')
181: p++;
182: if (p[0] == '/' && p[1] == '*')
183: p += 2;
184: else if (p[0] == '*')
185: p += p[1] == '/' ? 2 : 1;
186: while (*p == ' ')
187: p++;
188: if (*p == 0)
189: goto inhibit_newline;
190: if (!comment_open) {
191: if ('a' <= *p && *p <= 'z')
192: *p = *p + 'A' - 'a';
193: if (s_code != e_code || s_lab != e_lab) {
194: fprintf(output, "\\c\n./* %dp 1 %dp\n",
195: ps.com_col * 7, target_col * 7);
196: }
197: else
198: fprintf(output, "./* %dp 0 %dp\n",
199: ps.com_col * 7, target_col * 7);
200: }
201: comment_open = 1;
202: while (*p) {
203: if (*p == BACKSLASH)
204: putc(BACKSLASH, output);
205: putc(*p++, output);
206: }
207: }
208: else { /* print comment, if any */
209: register target = ps.com_col;
210: register char *com_st = s_com;
211:
212: target += ps.comment_delta;
213: while (target <= 0)
214: if (*s_com == ' ')
215: target++, s_com++;
216: else if (*s_com == '\t')
217: target = ((target - 1) & ~7) + 9, s_com++;
218: else
219: target = 1;
220: if (cur_col > target) { /* if comment cant fit on this
221: * line, put it on next line */
222: putc('\n', output);
223: cur_col = 1;
224: ++ps.out_lines;
225: }
226: cur_col = pad_output(cur_col, target);
227: if (!ps.box_com) {
228: if (star_comment_cont && com_st[1] != '*')
229: if (com_st[1] == ' ' && com_st[0] == ' ')
230: com_st[1] = '*';
231: else
232: fwrite(" * ", com_st[0] == '\t' ? 2 : com_st[0] == '*' ? 1 : 3, 1, output);
233: }
234: fwrite(com_st, e_com - com_st, 1, output);
235: ps.comment_delta = ps.n_comment_delta;
236: cur_col = count_spaces(cur_col, com_st);
237: ++ps.com_lines; /* count lines with comments */
238: }
239: if (ps.use_ff)
240: putc('\014', output);
241: else
242: putc('\n', output);
243: inhibit_newline:
244: ++ps.out_lines;
245: if (ps.just_saw_decl == 1 && blanklines_after_declarations) {
246: prefix_blankline_requested = 1;
247: ps.just_saw_decl = 0;
248: }
249: else
250: prefix_blankline_requested = postfix_blankline_requested;
251: postfix_blankline_requested = 0;
252: }
253: ps.decl_on_line = ps.in_decl; /* if we are in the middle of a
254: * declaration, remember that fact
255: * for proper comment indentation */
256: ps.ind_stmt = ps.in_stmt & ~ps.in_decl; /* next line should be
257: * indented if we have not
258: * completed this stmt and
259: * if we are not in the
260: * middle of a declaration */
261: ps.use_ff = false;
262: ps.dumped_decl_indent = 0;
263: *(e_lab = s_lab) = '\0'; /* reset buffers */
264: *(e_code = s_code) = '\0';
265: *(e_com = s_com) = '\0';
266: ps.ind_level = ps.i_l_follow;
267: ps.paren_level = ps.p_l_follow;
268: paren_target = -ps.paren_indents[ps.paren_level - 1];
269: return;
270: };
271:
272: compute_code_target() {
273: register target_col = ps.ind_size * ps.ind_level + 1;
274:
275: if (ps.paren_level)
276: if (!lineup_to_parens)
277: target_col += continuation_indent * ps.paren_level;
278: else {
279: register w;
280: register t = paren_target;
281:
282: if ((w = count_spaces(t, s_code) - max_col) > 0
283: && count_spaces(target_col, s_code) <= max_col) {
284: t -= w + 1;
285: if (t > target_col)
286: target_col = t;
287: }
288: else
289: target_col = t;
290: }
291: else if (ps.ind_stmt)
292: target_col += continuation_indent;
293: return target_col;
294: }
295:
296: compute_label_target()
297: {
298: return
299: ps.pcase ? (int) (case_ind * ps.ind_size) +1
300: : *s_lab == '#' ? 1
301: : ps.ind_size * (ps.ind_level - label_offset) +1;
302: }
303:
304:
305: /*
306: * Copyright (C) 1976 by the Board of Trustees of the University of
307: * Illinois
308: *
309: * All rights reserved
310: *
311: *
312: * NAME: fill_buffer
313: *
314: * FUNCTION: Reads one block of input into input_buffer
315: *
316: * HISTORY: initial coding November 1976 D A Willcox of CAC 1/7/77
317: * A Willcox of CAC Added check for switch back to partly full input
318: * buffer from temporary buffer
319: *
320: */
321: int
322: fill_buffer()
323: { /* this routine reads stuff from the input */
324: int count;
325: register char *p;
326: register int i;
327: register FILE *f = input;
328:
329: if (bp_save != 0) { /* there is a partly filled input buffer
330: * left */
331: buf_ptr = bp_save; /* dont read anything, just switch buffers */
332: buf_end = be_save;
333: bp_save = be_save = 0;
334: if (buf_ptr < buf_end)
335: return; /* only return if there is really
336: * something in this buffer */
337: }
338: p = in_buffer;
339: buf_ptr = p;
340: while ((*p++ = i = getc(f)) != EOF && i != '\n');
341: if (i == EOF) {
342: p[-1] = ' ';
343: *p++ = '\n';
344: had_eof = true;
345: }
346: buf_end = p;
347: if (p[-2] == '/' && p[-3] == '*') {
348: if (in_buffer[3] == 'I' && strncmp(in_buffer, "/**INDENT**", 11) == 0)
349: fill_buffer(); /* flush indent error message */
350: else {
351: int com = 0;
352:
353: p = in_buffer;
354: while (*p == ' ' || *p == '\t')
355: p++;
356: if (*p == '/' && p[1] == '*') {
357: p += 2;
358: while (*p == ' ' || *p == '\t')
359: p++;
360: if (p[0] == 'I' && p[1] == 'N' && p[2] == 'D' && p[3] == 'E'
361: && p[4] == 'N' && p[5] == 'T') {
362: p += 6;
363: while (*p == ' ' || *p == '\t')
364: p++;
365: if (*p == '*')
366: com = 1;
367: else if (*p == 'O')
368: if (*++p == 'N')
369: p++, com = 1;
370: else if (*p == 'F' && *++p == 'F')
371: p++, com = 2;
372: while (*p == ' ' || *p == '\t')
373: p++;
374: if (p[0] == '*' && p[1] == '/' && p[2] == '\n' && com) {
375: if (s_com != e_com || s_lab != e_lab || s_code != e_code)
376: dump_line();
377: if (!(inhibit_formatting = com - 1)) {
378: n_real_blanklines = 0;
379: postfix_blankline_requested = 0;
380: prefix_blankline_requested = 0;
381: suppress_blanklines = 1;
382: }
383: }
384: }
385: }
386: }
387: }
388: if (inhibit_formatting) {
389: p = in_buffer;
390: do
391: putc(*p, output);
392: while (*p++ != '\n');
393: }
394: return;
395: };
396:
397: /*
398: * Copyright (C) 1976 by the Board of Trustees of the University of
399: * Illinois
400: *
401: * All rights reserved
402: *
403: *
404: * NAME: pad_output
405: *
406: * FUNCTION: Writes tabs and spaces to move the current column up to the
407: * desired position.
408: *
409: * ALGORITHM: Put tabs and/or blanks into pobuf, then write pobuf.
410: *
411: * PARAMETERS: current integer The current column target
412: * nteger The desired column
413: *
414: * RETURNS: Integer value of the new column. (If current >= target, no
415: * action is taken, and current is returned.
416: *
417: * GLOBALS: None
418: *
419: * CALLS: write (sys)
420: *
421: * CALLED BY: dump_line
422: *
423: * HISTORY: initial coding November 1976 D A Willcox of CAC
424: *
425: */
426: pad_output(current, target) /* writes tabs and blanks (if necessary)
427: * to get the current output position up
428: * to the target column */
429: int current; /* the current column value */
430: int target; /* position we want it at */
431: {
432: register int curr; /* internal column pointer */
433: register int tcur;
434:
435: if (troff)
436: fprintf(output, "\\h'|%dp'", (target - 1) * 7);
437: else {
438: if (current >= target)
439: return (current); /* line is already long enough */
440: curr = current;
441: while ((tcur = ((curr - 1) & tabmask) + tabsize + 1) <= target) {
442: putc('\t', output);
443: curr = tcur;
444: }
445: while (curr++ < target)
446: putc(' ', output); /* pad with final blanks */
447: }
448: return (target);
449: };
450:
451: /*
452: * Copyright (C) 1976 by the Board of Trustees of the University of
453: * Illinois
454: *
455: * All rights reserved
456: *
457: *
458: * NAME: count_spaces
459: *
460: * FUNCTION: Find out where printing of a given string will leave the current
461: * character position on output.
462: *
463: * ALGORITHM: Run thru input string and add appropriate values to current
464: * position.
465: *
466: * RETURNS: Integer value of position after printing "buffer" starting in
467: * column "current".
468: *
469: * HISTORY: initial coding November 1976 D A Willcox of CAC
470: *
471: */
472: int
473: count_spaces(current, buffer)
474:
475: /*
476: * this routine figures out where the character position will be after
477: * printing the text in buffer starting at column "current"
478: */
479: int current;
480: char *buffer;
481: {
482: register char *buf; /* used to look thru buffer */
483: register int cur; /* current character counter */
484:
485: cur = current;
486:
487: for (buf = buffer; *buf != '\0'; ++buf) {
488: switch (*buf) {
489:
490: case '\n':
491: case 014: /* form feed */
492: cur = 1;
493: break;
494:
495: case '\t':
496: cur = ((cur - 1) & tabmask) + tabsize + 1;
497: break;
498:
499: case '': /* this is a backspace */
500: --cur;
501: break;
502:
503: default:
504: ++cur;
505: break;
506: } /* end of switch */
507: } /* end of for loop */
508: return (cur);
509: };
510:
511: int found_err;
512: diag(level, msg, a, b)
513: {
514: if (level)
515: found_err = 1;
516: if (output == stdout) {
517: fprintf(stdout, "/**INDENT** %s@%d: ", level == 0 ? "Warning" : "Error", line_no);
518: fprintf(stdout, msg, a, b);
519: fprintf(stdout, " */\n");
520: }
521: else {
522: fprintf(stderr, "%s@%d: ", level == 0 ? "Warning" : "Error", line_no);
523: fprintf(stderr, msg, a, b);
524: fprintf(stderr, "\n");
525: }
526: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.