static char sccsid[] = "@(#)io.c 4.1 (Berkeley) 10/21/82"; /* Copyright (C) 1976 by the Board of Trustees of the University of Illinois All rights reserved FILE NAME: io.c PURPOSE: Contains routines to handle i/o related stuff for indent. GLOBALS: None FUNCTIONS: dump_line fill_buffer pad_output count_spaces eqin cmp */ /* Copyright (C) 1976 by the Board of Trustees of the University of Illinois All rights reserved NAME: dump_line FUNCTION: Does the actual printing of the stored up line ALGORITHM: For each of the label, code, and comment sections which are used on this line: 1) Use pad_output to get the section aligned properly. 2) write the section The indentation level used for the code is set by ind_level. After printing, ind_level is set to i_l_follow. An extra level of indentation is added if ind_stmt is 1. After printing, ind_stmt is set to 1 iff the line just printed has an unterminated, non-declaration statement. PARAMETERS: None RETURNS: Nothing GLOBALS: labbuf s_lab e_lab = Reset to s_lab codebuf s_code e_code = Reset to s_code combuf s_com e_com = Reset to s_com bl_line = Set to true iff the line was blank case_ind code_lines = Count lines with code com_col com_lines = Keep track of lines with comments decl_on_line = Set to in_decl after line is printed i_l_follow in_decl in_stmt ind_level = Set to i_l_follow at completion ind_size ind_stmt = Set to in_stmt at completion if not in declaration out_lines = Count output lines p_l_follow paren_level = Set to p_l_follow at completion pcase use_ff = Reset to false CALLS: pad_output printf (lib) write (lib) CALLED BY: main pr_comment HISTORY: initial coding November 1976 D A Willcox of CAC */ #include "indent_globs.h"; int ff = 014; /* used to write a form feed */ dump_line () { /* dump_line is the routine that actually effects the printing of the new source. It prints the label section, followed by the code section with the appropriate nesting level, followed by any comments */ register int cur_col, temp_col, target_col; bl_line = true; /* if we don't find otherwise, assume a blank line */ if (ind_level == 0) ind_stmt = 0; /* this is a class A kludge. don't do additional statement indentation if we are at bracket level 0 */ if (e_lab != s_lab || e_code != s_code) ++code_lines; /* keep count of lines with code */ if (e_lab != s_lab) { /* print lab, if any */ if (pcase) /* if the label is really a case, we must indent */ cur_col = pad_output (1, case_ind * ind_size + 1); else { if (*s_lab == '#') /* check for #define, etc */ cur_col = 1; else cur_col = pad_output (1, ind_size * (ind_level - label_offset) + 1); } write (output, s_lab, e_lab - s_lab); cur_col = count_spaces (cur_col, s_lab); /* count_spaces gives number of characters, considering tabs */ bl_line = false; /* line not blank after all */ } else cur_col = 1; /* there is no label section */ pcase = false; if (s_code != e_code) { /* print code section, if any */ target_col = ind_size * (ind_level + paren_level + ind_stmt) + 1; cur_col = pad_output (cur_col, target_col); /* pad_output writes enough tabs and spaces to get the current char position up to target_col */ write (output, s_code, e_code - s_code); cur_col = count_spaces (cur_col, s_code); bl_line = false; /* line not blank */ } if ((cur_col - 1) > max_col && output!=1)/* check for line too long */ printf ("%d: Code has %d chars, max is %d\n", line_no, (cur_col - 1), max_col); if (s_com != e_com) { /* print comment, if any */ if (cur_col > com_col && count_spaces (cur_col, s_com) >= max_col) { /* if comment can't fit on this line, put it on next line */ write (output, "\n", 1); cur_col = 1; ++out_lines; } cur_col = pad_output (cur_col, com_col); write (output, s_com, e_com - s_com); cur_col = count_spaces (cur_col, s_com); if ((cur_col - 1) > max_col && output!=1)/* check for too long comment */ printf ("%d: Comment goes to column %d. Max is %d\n", line_no, (cur_col - 1), max_col); bl_line = false; ++com_lines; /* count lines with comments */ } if (use_ff) write (output, &ff, 1);/* end the output with a ff */ else write (output, "\n", 1); /* or a newline */ use_ff = false; *(e_lab = s_lab) = '\0'; /* reset buffers */ *(e_code = s_code) = '\0'; *(e_com = s_com) = '\0'; ind_level = i_l_follow; paren_level = p_l_follow; ++out_lines; decl_on_line = in_decl; /* if we are in the middle of a declaration, remember that fact for proper comment indentation */ ind_stmt = in_stmt & ~in_decl; /* next line should be indented if we have not completed this stmt and if we are not in the middle of a declaration */ return; }; /* Copyright (C) 1976 by the Board of Trustees of the University of Illinois All rights reserved NAME: fill_buffer FUNCTION: Reads one block of input into input_buffer ALGORITHM: Trivial PARAMETERS: None RETURNS: Nothing GLOBALS: in_buffer = buf_end = Set to 1 past last character read in buf_ptr = Set to start of buffer be_save = Set to zero if it was non-zero bp_save = Set to zero CALLS: read (lib) CALLED BY: lexi main pr_comment HISTORY: initial coding November 1976 D A Willcox of CAC 1/7/77 D A Willcox of CAC Added check for switch back to partly full input buffer from temporary buffer */ int fill_buffer () { /* this routine reads stuff from the input */ int count; register int i; if (bp_save != 0) { /* there is a partly filled input buffer left */ buf_ptr = bp_save; /* don't read anything, just switch buffers */ buf_end = be_save; bp_save = be_save = 0; if (buf_ptr < buf_end) return; /* only return if there is really something in this buffer */ } count = read (input, in_buffer, inp_bufs); buf_end = in_buffer + count; buf_ptr = in_buffer; if (count == 0) { /* count of zero means eof */ had_eof = true; *buf_end++ = ' '; *buf_end++ = '\n'; /* insert extra newline. it will eventually get indent to stop */ } return; }; /* Copyright (C) 1976 by the Board of Trustees of the University of Illinois All rights reserved NAME: pad_output FUNCTION: Writes tabs and spaces to move the current column up to the desired position. ALGORITHM: Put tabs and/or blanks into pobuf, then write pobuf. PARAMETERS: current integer The current column target integer The desired column RETURNS: Integer value of the new column. (If current >= target, no action is taken, and current is returned. GLOBALS: None CALLS: write (sys) CALLED BY: dump_line HISTORY: initial coding November 1976 D A Willcox of CAC */ int pad_output (current, target)/* writes tabs and blanks (if necessary) to get the current output position up to the target column */ int current; /* the current column value */ int target; /* position we want it at */ { register int curr; /* internal column pointer */ register char *p; /* pointer into buffer of characters to be written */ char pobuf[256]; /* pad characters are stored here before writing */ register int tcur; if (current >= target) return (current); /* line is already long enough */ curr = current; p = pobuf; while (curr < target) { if ((tcur = ((curr - 1) & tabmask) + tabsize + 1) <= target){ *p++ = '\t'; /* put a tab into buffer */ curr = tcur; } else { while (curr++ < target) *p++ = ' '; /* pad with final blanks */ } } write (output, pobuf, p - pobuf); /* write the characters we saved */ return (target); }; /* Copyright (C) 1976 by the Board of Trustees of the University of Illinois All rights reserved NAME: count_spaces FUNCTION: Find out where printing of a given string will leave the current character position on output. ALGORITHM: Run thru input string and add appropriate values to current position. PARAMETERS: current integer The current line character position buffer ptr to character Pointer to input string RETURNS: Integer value of position after printing "buffer" starting in column "current". GLOBALS: None CALLS: None CALLED BY: pr_comment HISTORY: initial coding November 1976 D A Willcox of CAC */ int count_spaces (current, buffer) /* this routine figures out where the character position will be after printing the text in buffer starting at column "current" */ int current; char *buffer; { register char *buf; /* used to look thru buffer */ register int cur; /* current character counter */ cur = current; for (buf = buffer; *buf != '\0'; ++buf) { switch (*buf) { case '\n': case 014: /* form feed */ cur = 1; break; case '\t': cur = ((cur - 1) & tabmask) + tabsize + 1; break; case '': /* this is a backspace */ --cur; break; default: ++cur; break; } /* end of switch */ } /* end of for loop */ return (cur); }; /* Copyright (C) 1976 by the Board of Trustees of the University of Illinois All rights reserved NAME: eqin FUNCTION: Returns true if the first arg matches the beginning of the second arg. ALGORITHM: Trivial PARAMETERS: str1 pointer to character str2 pointer to character RETURNS: 1 if first string matches start of second string 0 otherwise GLOBALS: None CALLS: None CALLED BY: lexi main HISTORY: initial coding November 1976 by D A Willcox of CAC */ eqin (str1, str2) char *str1; char *str2; { register char *s1; /* local pointer into first string */ register char *s2; /* local pointer into second string */ s1 = str1; s2 = str2; while (*s1) { /* compare no further than end of first string */ if (*s2 == 0) /* check that second string isn't too short */ return (false); if (*s1++ != *s2++) return (false); } return (true); } /* Copyright (C) 1976 by the Board of Trustees of the University of Illinois All rights reserved NAME: cmp FUNCTION: Compares two strings ALGORITHM: Trivial PARAMETERS: a Pointer to char First string to compare b Pointer to char Second string to compare RETURNS: -1 if a < b 0 if a = b 1 if a > b GLOBALS: None CALLS: None CALLED BY: main HISTORY: 1/7/77 D A Willcox of CAC Initial Coding */ int cmp (a, b) char *a; char *b; { register char *ta, *tb; ta = a; tb = b; while (*ta) { if (*ta > *tb) return (1); if (*ta < *tb) return (-1); ++ta; ++tb; } if (*tb) return (1); else return (0); }