![[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] / 42BSD / ucb / indent|
Return to io.c CVS log | Up to [CSRG BSD Unix] / 42BSD / ucb / indent |
1.1 root 1: static char sccsid[] = "@(#)io.c 4.1 (Berkeley) 10/21/82";
2:
3: /*
4:
5: Copyright (C) 1976
6: by the
7: Board of Trustees
8: of the
9: University of Illinois
10:
11: All rights reserved
12:
13:
14: FILE NAME:
15: io.c
16:
17: PURPOSE:
18: Contains routines to handle i/o related stuff for indent.
19:
20: GLOBALS:
21: None
22:
23: FUNCTIONS:
24: dump_line
25: fill_buffer
26: pad_output
27: count_spaces
28: eqin
29: cmp
30:
31: */
32: /*
33:
34: Copyright (C) 1976
35: by the
36: Board of Trustees
37: of the
38: University of Illinois
39:
40: All rights reserved
41:
42:
43: NAME:
44: dump_line
45:
46: FUNCTION:
47: Does the actual printing of the stored up line
48:
49: ALGORITHM:
50: For each of the label, code, and comment sections which are used on
51: this line:
52:
53: 1) Use pad_output to get the section aligned properly.
54: 2) write the section
55:
56: The indentation level used for the code is set by ind_level. After
57: printing, ind_level is set to i_l_follow.
58:
59: An extra level of indentation is added if ind_stmt is 1. After
60: printing, ind_stmt is set to 1 iff the line just printed has an
61: unterminated, non-declaration statement.
62:
63: PARAMETERS:
64: None
65:
66: RETURNS:
67: Nothing
68:
69: GLOBALS:
70: labbuf
71: s_lab
72: e_lab = Reset to s_lab
73:
74: codebuf
75: s_code
76: e_code = Reset to s_code
77:
78: combuf
79: s_com
80: e_com = Reset to s_com
81:
82: bl_line = Set to true iff the line was blank
83: case_ind
84: code_lines = Count lines with code
85: com_col
86: com_lines = Keep track of lines with comments
87: decl_on_line = Set to in_decl after line is printed
88: i_l_follow
89: in_decl
90: in_stmt
91: ind_level = Set to i_l_follow at completion
92: ind_size
93: ind_stmt = Set to in_stmt at completion if not in declaration
94: out_lines = Count output lines
95: p_l_follow
96: paren_level = Set to p_l_follow at completion
97: pcase
98: use_ff = Reset to false
99:
100: CALLS:
101: pad_output
102: printf (lib)
103: write (lib)
104:
105: CALLED BY:
106: main
107: pr_comment
108:
109: HISTORY:
110: initial coding November 1976 D A Willcox of CAC
111:
112: */
113: #include "indent_globs.h";
114:
115:
116:
117: int ff = 014; /* used to write a form feed */
118:
119:
120: dump_line () { /* dump_line is the routine that actually
121: effects the printing of the new source.
122: It prints the label section, followed by
123: the code section with the appropriate
124: nesting level, followed by any comments
125: */
126: register int cur_col,
127: temp_col,
128: target_col;
129:
130: bl_line = true; /* if we don't find otherwise, assume a
131: blank line */
132:
133: if (ind_level == 0)
134: ind_stmt = 0; /* this is a class A kludge. don't do
135: additional statement indentation if we
136: are at bracket level 0 */
137:
138: if (e_lab != s_lab || e_code != s_code)
139: ++code_lines; /* keep count of lines with code */
140:
141: if (e_lab != s_lab) { /* print lab, if any */
142: if (pcase) /* if the label is really a case, we must
143: indent */
144: cur_col = pad_output (1, case_ind * ind_size + 1);
145: else {
146: if (*s_lab == '#') /* check for #define, etc */
147: cur_col = 1;
148: else
149: cur_col = pad_output (1, ind_size * (ind_level - label_offset) + 1);
150: }
151:
152: write (output, s_lab, e_lab - s_lab);
153: cur_col = count_spaces (cur_col, s_lab);
154: /* count_spaces gives number of characters, considering tabs */
155: bl_line = false; /* line not blank after all */
156: }
157: else
158: cur_col = 1; /* there is no label section */
159:
160: pcase = false;
161:
162: if (s_code != e_code) { /* print code section, if any */
163: target_col = ind_size * (ind_level + paren_level + ind_stmt) + 1;
164:
165: cur_col = pad_output (cur_col, target_col);
166: /* pad_output writes enough tabs and spaces to get the current char
167: position up to target_col */
168: write (output, s_code, e_code - s_code);
169: cur_col = count_spaces (cur_col, s_code);
170: bl_line = false; /* line not blank */
171: }
172:
173: if ((cur_col - 1) > max_col && output!=1)/* check for line too long */
174: printf ("%d: Code has %d chars, max is %d\n", line_no, (cur_col - 1), max_col);
175:
176: if (s_com != e_com) { /* print comment, if any */
177: if (cur_col > com_col && count_spaces (cur_col, s_com) >= max_col) {
178: /* if comment can't fit on this line, put it on next line */
179: write (output, "\n", 1);
180: cur_col = 1;
181: ++out_lines;
182: }
183: cur_col = pad_output (cur_col, com_col);
184: write (output, s_com, e_com - s_com);
185:
186: cur_col = count_spaces (cur_col, s_com);
187: if ((cur_col - 1) > max_col && output!=1)/* check for too long comment */
188: printf ("%d: Comment goes to column %d. Max is %d\n",
189: line_no, (cur_col - 1), max_col);
190:
191: bl_line = false;
192: ++com_lines; /* count lines with comments */
193: }
194:
195: if (use_ff)
196: write (output, &ff, 1);/* end the output with a ff */
197: else
198: write (output, "\n", 1); /* or a newline */
199: use_ff = false;
200: *(e_lab = s_lab) = '\0'; /* reset buffers */
201: *(e_code = s_code) = '\0';
202: *(e_com = s_com) = '\0';
203:
204: ind_level = i_l_follow;
205: paren_level = p_l_follow;
206: ++out_lines;
207: decl_on_line = in_decl; /* if we are in the middle of a
208: declaration, remember that fact for
209: proper comment indentation */
210: ind_stmt = in_stmt & ~in_decl;
211: /* next line should be indented if we have not completed this stmt and if
212: we are not in the middle of a declaration */
213:
214: return;
215: };
216: /*
217:
218: Copyright (C) 1976
219: by the
220: Board of Trustees
221: of the
222: University of Illinois
223:
224: All rights reserved
225:
226:
227: NAME:
228: fill_buffer
229:
230: FUNCTION:
231: Reads one block of input into input_buffer
232:
233: ALGORITHM:
234: Trivial
235:
236: PARAMETERS:
237: None
238:
239: RETURNS:
240: Nothing
241:
242: GLOBALS:
243: in_buffer =
244: buf_end = Set to 1 past last character read in
245: buf_ptr = Set to start of buffer
246: be_save = Set to zero if it was non-zero
247: bp_save = Set to zero
248:
249: CALLS:
250: read (lib)
251:
252: CALLED BY:
253: lexi
254: main
255: pr_comment
256:
257: HISTORY:
258: initial coding November 1976 D A Willcox of CAC
259: 1/7/77 D A Willcox of CAC Added check for switch back to
260: partly full input buffer from
261: temporary buffer
262:
263: */
264: int fill_buffer () { /* this routine reads stuff from the input */
265: int count;
266: register int i;
267:
268: if (bp_save != 0) { /* there is a partly filled input buffer
269: left */
270: buf_ptr = bp_save; /* don't read anything, just switch buffers
271: */
272: buf_end = be_save;
273: bp_save = be_save = 0;
274: if (buf_ptr < buf_end)
275: return; /* only return if there is really something
276: in this buffer */
277: }
278:
279: count = read (input, in_buffer, inp_bufs);
280:
281: buf_end = in_buffer + count;
282: buf_ptr = in_buffer;
283:
284: if (count == 0) { /* count of zero means eof */
285: had_eof = true;
286: *buf_end++ = ' ';
287: *buf_end++ = '\n'; /* insert extra newline. it will
288: eventually get indent to stop */
289: }
290:
291: return;
292: };
293: /*
294:
295: Copyright (C) 1976
296: by the
297: Board of Trustees
298: of the
299: University of Illinois
300:
301: All rights reserved
302:
303:
304: NAME:
305: pad_output
306:
307: FUNCTION:
308: Writes tabs and spaces to move the current column up to the
309: desired position.
310:
311: ALGORITHM:
312: Put tabs and/or blanks into pobuf, then write pobuf.
313:
314: PARAMETERS:
315: current integer The current column
316: target integer The desired column
317:
318: RETURNS:
319: Integer value of the new column. (If current >= target,
320: no action is taken, and current is returned.
321:
322: GLOBALS:
323: None
324:
325: CALLS:
326: write (sys)
327:
328: CALLED BY:
329: dump_line
330:
331: HISTORY:
332: initial coding November 1976 D A Willcox of CAC
333:
334: */
335: int pad_output (current, target)/* writes tabs and blanks (if necessary) to
336: get the current output position up to
337: the target column */
338: int current; /* the current column value */
339: int target; /* position we want it at */
340: {
341: register int curr; /* internal column pointer */
342: register char *p; /* pointer into buffer of characters to be written */
343: char pobuf[256]; /* pad characters are stored here before writing */
344: register int tcur;
345:
346: if (current >= target)
347: return (current); /* line is already long enough */
348:
349: curr = current;
350: p = pobuf;
351: while (curr < target) {
352: if ((tcur = ((curr - 1) & tabmask) + tabsize + 1) <= target){
353: *p++ = '\t'; /* put a tab into buffer */
354: curr = tcur;
355: }
356: else {
357: while (curr++ < target)
358: *p++ = ' '; /* pad with final blanks */
359: }
360: }
361:
362: write (output, pobuf, p - pobuf); /* write the characters we saved */
363: return (target);
364: };
365: /*
366:
367: Copyright (C) 1976
368: by the
369: Board of Trustees
370: of the
371: University of Illinois
372:
373: All rights reserved
374:
375:
376: NAME:
377: count_spaces
378:
379: FUNCTION:
380: Find out where printing of a given string will leave the current
381: character position on output.
382:
383: ALGORITHM:
384: Run thru input string and add appropriate values to current position.
385:
386: PARAMETERS:
387: current integer The current line character position
388: buffer ptr to character Pointer to input string
389:
390: RETURNS:
391: Integer value of position after printing "buffer" starting in
392: column "current".
393:
394: GLOBALS:
395: None
396:
397: CALLS:
398: None
399:
400: CALLED BY:
401: pr_comment
402:
403: HISTORY:
404: initial coding November 1976 D A Willcox of CAC
405:
406: */
407: int count_spaces (current, buffer)
408: /* this routine figures out where the
409: character position will be after
410: printing the text in buffer starting at
411: column "current" */
412: int current;
413: char *buffer;
414: {
415: register char *buf; /* used to look thru buffer */
416: register int cur; /* current character counter */
417:
418: cur = current;
419:
420: for (buf = buffer; *buf != '\0'; ++buf) {
421: switch (*buf) {
422:
423: case '\n':
424: case 014: /* form feed */
425: cur = 1;
426: break;
427:
428: case '\t':
429: cur = ((cur - 1) & tabmask) + tabsize + 1;
430: break;
431:
432: case '': /* this is a backspace */
433: --cur;
434: break;
435:
436: default:
437: ++cur;
438: break;
439: } /* end of switch */
440: } /* end of for loop */
441:
442: return (cur);
443: };
444: /*
445:
446: Copyright (C) 1976
447: by the
448: Board of Trustees
449: of the
450: University of Illinois
451:
452: All rights reserved
453:
454:
455: NAME:
456: eqin
457:
458: FUNCTION:
459: Returns true if the first arg matches the beginning of the second arg.
460:
461: ALGORITHM:
462: Trivial
463:
464: PARAMETERS:
465: str1 pointer to character
466: str2 pointer to character
467:
468: RETURNS:
469: 1 if first string matches start of second string
470: 0 otherwise
471:
472: GLOBALS:
473: None
474:
475: CALLS:
476: None
477:
478: CALLED BY:
479: lexi
480: main
481:
482: HISTORY:
483: initial coding November 1976 by D A Willcox of CAC
484:
485: */
486: eqin (str1, str2)
487: char *str1;
488: char *str2;
489: {
490: register char *s1; /* local pointer into first string */
491: register char *s2; /* local pointer into second string */
492:
493: s1 = str1;
494: s2 = str2;
495: while (*s1) { /* compare no further than end of first
496: string */
497: if (*s2 == 0) /* check that second string isn't too short
498: */
499: return (false);
500: if (*s1++ != *s2++)
501: return (false);
502: }
503:
504: return (true);
505: }
506: /*
507: Copyright (C) 1976
508: by the
509: Board of Trustees
510: of the
511: University of Illinois
512:
513: All rights reserved
514:
515: NAME:
516: cmp
517:
518: FUNCTION:
519: Compares two strings
520:
521: ALGORITHM:
522: Trivial
523:
524: PARAMETERS:
525: a Pointer to char First string to compare
526: b Pointer to char Second string to compare
527:
528: RETURNS:
529: -1 if a < b
530: 0 if a = b
531: 1 if a > b
532:
533: GLOBALS:
534: None
535:
536: CALLS:
537: None
538:
539: CALLED BY:
540: main
541:
542: HISTORY:
543: 1/7/77 D A Willcox of CAC Initial Coding
544: */
545: int cmp (a, b)
546: char *a;
547: char *b;
548: {
549: register char *ta,
550: *tb;
551:
552: ta = a;
553: tb = b;
554:
555: while (*ta) {
556: if (*ta > *tb)
557: return (1);
558: if (*ta < *tb)
559: return (-1);
560: ++ta;
561: ++tb;
562: }
563: if (*tb)
564: return (1);
565: else
566: return (0);
567: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.