home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Usenet 1994 January
/
usenetsourcesnewsgroupsinfomagicjanuary1994.iso
/
sources
/
unix
/
volume18
/
indent
/
part02
< prev
next >
Wrap
Text File
|
1989-03-20
|
44KB
|
1,595 lines
Subject: v18i050: Indent, C reformatting program, Part02/03
Newsgroups: comp.sources.unix
Sender: sources
Approved: rsalz@uunet.UU.NET
Submitted-by: Ozan Yigit <oz@nexus.yorku.ca>
Posting-number: Volume 18, Issue 50
Archive-name: indent/part02
#! /bin/sh
# This is a shell archive. Remove anything before this line, then unpack
# it by saving it into a file and typing "sh file". To overwrite existing
# files, type "sh file -c". You can also feed this as standard input via
# unshar, or by typing "sh <file", e.g.. If this archive is complete, you
# will see the following message at the end:
# "End of archive 2 (of 3)."
# Contents: indent/io.c indent/lexi.c indent/pr_comment.c
# Wrapped by oz@yunexus on Thu Mar 9 18:11:05 1989
PATH=/bin:/usr/bin:/usr/ucb ; export PATH
if test -f 'indent/io.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'indent/io.c'\"
else
echo shar: Extracting \"'indent/io.c'\" \(14572 characters\)
sed "s/^X//" >'indent/io.c' <<'END_OF_FILE'
X/*
X * Copyright (c) 1985 Sun Microsystems, Inc.
X * Copyright (c) 1980 The Regents of the University of California.
X * Copyright (c) 1976 Board of Trustees of the University of Illinois.
X * All rights reserved.
X *
X * Redistribution and use in source and binary forms are permitted
X * provided that the above copyright notice and this paragraph are
X * duplicated in all such forms and that any documentation,
X * advertising materials, and other materials related to such
X * distribution and use acknowledge that the software was developed
X * by the University of California, Berkeley, the University of Illinois,
X * Urbana, and Sun Microsystems, Inc. The name of either University
X * or Sun Microsystems may not be used to endorse or promote products
X * derived from this software without specific prior written permission.
X * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
X * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
X * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
X */
X
X#ifndef lint
Xstatic char sccsid[] = "@(#)io.c 5.10 (Berkeley) 9/15/88";
X#endif /* not lint */
X
X#include "indent_globs.h"
X#include <ctype.h>
X
X
Xint comment_open;
Xstatic paren_target;
X
Xdump_line()
X{ /* dump_line is the routine that actually
X * effects the printing of the new source. It
X * prints the label section, followed by the
X * code section with the appropriate nesting
X * level, followed by any comments */
X register int cur_col,
X target_col;
X static not_first_line;
X
X if (ps.procname[0]) {
X if (troff) {
X if (comment_open) {
X comment_open = 0;
X fprintf(output, ".*/\n");
X }
X fprintf(output, ".Pr \"%s\"\n", ps.procname);
X }
X ps.ind_level = 0;
X ps.procname[0] = 0;
X }
X if (s_code == e_code && s_lab == e_lab && s_com == e_com) {
X if (suppress_blanklines > 0)
X suppress_blanklines--;
X else {
X ps.bl_line = true;
X n_real_blanklines++;
X }
X }
X else if (!inhibit_formatting) {
X suppress_blanklines = 0;
X ps.bl_line = false;
X if (prefix_blankline_requested && not_first_line)
X if (swallow_optional_blanklines) {
X if (n_real_blanklines == 1)
X n_real_blanklines = 0;
X }
X else {
X if (n_real_blanklines == 0)
X n_real_blanklines = 1;
X }
X while (--n_real_blanklines >= 0)
X putc('\n', output);
X n_real_blanklines = 0;
X if (ps.ind_level == 0)
X ps.ind_stmt = 0; /* this is a class A kludge. dont do
X * additional statement indentation if we are
X * at bracket level 0 */
X
X if (e_lab != s_lab || e_code != s_code)
X ++code_lines; /* keep count of lines with code */
X
X
X if (e_lab != s_lab) { /* print lab, if any */
X if (comment_open) {
X comment_open = 0;
X fprintf(output, ".*/\n");
X }
X while (e_lab > s_lab && (e_lab[-1] == ' ' || e_lab[-1] == '\t'))
X e_lab--;
X cur_col = pad_output(1, compute_label_target());
X fprintf(output, "%.*s", e_lab - s_lab, s_lab);
X cur_col = count_spaces(cur_col, s_lab);
X }
X else
X cur_col = 1; /* there is no label section */
X
X ps.pcase = false;
X
X if (s_code != e_code) { /* print code section, if any */
X register char *p;
X
X if (comment_open) {
X comment_open = 0;
X fprintf(output, ".*/\n");
X }
X target_col = compute_code_target();
X {
X register i;
X
X for (i = 0; i < ps.p_l_follow; i++)
X if (ps.paren_indents[i] >= 0)
X ps.paren_indents[i] = -(ps.paren_indents[i] + target_col);
X }
X cur_col = pad_output(cur_col, target_col);
X for (p = s_code; p < e_code; p++)
X if (*p == (char) 0200)
X fprintf(output, "%d", target_col * 7);
X else
X putc(*p, output);
X cur_col = count_spaces(cur_col, s_code);
X }
X if (s_com != e_com)
X if (troff) {
X int all_here = 0;
X register char *p;
X
X if (e_com[-1] == '/' && e_com[-2] == '*')
X e_com -= 2, all_here++;
X while (e_com > s_com && e_com[-1] == ' ')
X e_com--;
X *e_com = 0;
X p = s_com;
X while (*p == ' ')
X p++;
X if (p[0] == '/' && p[1] == '*')
X p += 2, all_here++;
X else if (p[0] == '*')
X p += p[1] == '/' ? 2 : 1;
X while (*p == ' ')
X p++;
X if (*p == 0)
X goto inhibit_newline;
X if (comment_open < 2 && ps.box_com) {
X comment_open = 0;
X fprintf(output, ".*/\n");
X }
X if (comment_open == 0) {
X if ('a' <= *p && *p <= 'z')
X *p = *p + 'A' - 'a';
X if (e_com - p < 50 && all_here == 2) {
X register char *follow = p;
X fprintf(output, "\n.nr C! \\w\1");
X while (follow < e_com) {
X switch (*follow) {
X case '\n':
X putc(' ', output);
X case 1:
X break;
X case '\\':
X putc('\\', output);
X default:
X putc(*follow, output);
X }
X follow++;
X }
X putc(1, output);
X }
X fprintf(output, "\n./* %dp %d %dp\n",
X ps.com_col * 7,
X (s_code != e_code || s_lab != e_lab) - ps.box_com,
X target_col * 7);
X }
X comment_open = 1 + ps.box_com;
X while (*p) {
X if (*p == BACKSLASH)
X putc(BACKSLASH, output);
X putc(*p++, output);
X }
X }
X else { /* print comment, if any */
X register target = ps.com_col;
X register char *com_st = s_com;
X
X target += ps.comment_delta;
X while (*com_st == '\t')
X com_st++, target += 8; /* ? */
X while (target <= 0)
X if (*com_st == ' ')
X target++, com_st++;
X else if (*com_st == '\t')
X target = ((target - 1) & ~7) + 9, com_st++;
X else
X target = 1;
X if (cur_col > target) { /* if comment cant fit on this line,
X * put it on next line */
X putc('\n', output);
X cur_col = 1;
X ++ps.out_lines;
X }
X while (e_com > com_st && isspace(e_com[-1]))
X e_com--;
X cur_col = pad_output(cur_col, target);
X if (!ps.box_com) {
X if (star_comment_cont && (com_st[1] != '*' || e_com <= com_st + 1))
X if (com_st[1] == ' ' && com_st[0] == ' ' && e_com > com_st + 1)
X com_st[1] = '*';
X else
X fwrite(" * ", com_st[0] == '\t' ? 2 : com_st[0] == '*' ? 1 : 3, 1, output);
X }
X fwrite(com_st, e_com - com_st, 1, output);
X ps.comment_delta = ps.n_comment_delta;
X cur_col = count_spaces(cur_col, com_st);
X ++ps.com_lines; /* count lines with comments */
X }
X if (ps.use_ff)
X putc('\014', output);
X else
X putc('\n', output);
Xinhibit_newline:
X ++ps.out_lines;
X if (ps.just_saw_decl == 1 && blanklines_after_declarations) {
X prefix_blankline_requested = 1;
X ps.just_saw_decl = 0;
X }
X else
X prefix_blankline_requested = postfix_blankline_requested;
X postfix_blankline_requested = 0;
X }
X ps.decl_on_line = ps.in_decl; /* if we are in the middle of a
X * declaration, remember that fact for
X * proper comment indentation */
X ps.ind_stmt = ps.in_stmt & ~ps.in_decl; /* next line should be
X * indented if we have not
X * completed this stmt and if
X * we are not in the middle of
X * a declaration */
X ps.use_ff = false;
X ps.dumped_decl_indent = 0;
X *(e_lab = s_lab) = '\0'; /* reset buffers */
X *(e_code = s_code) = '\0';
X *(e_com = s_com) = '\0';
X ps.ind_level = ps.i_l_follow;
X ps.paren_level = ps.p_l_follow;
X paren_target = -ps.paren_indents[ps.paren_level - 1];
X not_first_line = 1;
X return;
X};
X
Xcompute_code_target()
X{
X register target_col = ps.ind_size * ps.ind_level + 1;
X
X if (ps.paren_level)
X if (!lineup_to_parens)
X target_col += continuation_indent * ps.paren_level;
X else {
X register w;
X register t = paren_target;
X
X if ((w = count_spaces(t, s_code) - max_col) > 0
X && count_spaces(target_col, s_code) <= max_col) {
X t -= w + 1;
X if (t > target_col)
X target_col = t;
X }
X else
X target_col = t;
X }
X else if (ps.ind_stmt)
X target_col += continuation_indent;
X return target_col;
X}
X
Xcompute_label_target()
X{
X return
X ps.pcase ? (int) (case_ind * ps.ind_size) + 1
X : *s_lab == '#' ? 1
X : ps.ind_size * (ps.ind_level - label_offset) + 1;
X}
X
X
X/*
X * Copyright (C) 1976 by the Board of Trustees of the University of Illinois
X *
X * All rights reserved
X *
X *
X * NAME: fill_buffer
X *
X * FUNCTION: Reads one block of input into input_buffer
X *
X * HISTORY: initial coding November 1976 D A Willcox of CAC 1/7/77 A
X * Willcox of CAC Added check for switch back to partly full input
X * buffer from temporary buffer
X *
X */
Xint
Xfill_buffer()
X{ /* this routine reads stuff from the input */
X register char *p;
X register int i;
X register FILE *f = input;
X
X if (bp_save != 0) { /* there is a partly filled input buffer left */
X buf_ptr = bp_save; /* dont read anything, just switch buffers */
X buf_end = be_save;
X bp_save = be_save = 0;
X if (buf_ptr < buf_end)
X return; /* only return if there is really something in
X * this buffer */
X }
X for (p = buf_ptr = in_buffer;;) {
X if ((i = getc(f)) == EOF) {
X *p++ = ' ';
X *p++ = '\n';
X had_eof = true;
X break;
X }
X *p++ = i;
X if (i == '\n')
X break;
X }
X buf_end = p;
X if (p[-2] == '/' && p[-3] == '*') {
X if (in_buffer[3] == 'I' && strncmp(in_buffer, "/**INDENT**", 11) == 0)
X fill_buffer(); /* flush indent error message */
X else {
X int com = 0;
X
X p = in_buffer;
X while (*p == ' ' || *p == '\t')
X p++;
X if (*p == '/' && p[1] == '*') {
X p += 2;
X while (*p == ' ' || *p == '\t')
X p++;
X if (p[0] == 'I' && p[1] == 'N' && p[2] == 'D' && p[3] == 'E'
X && p[4] == 'N' && p[5] == 'T') {
X p += 6;
X while (*p == ' ' || *p == '\t')
X p++;
X if (*p == '*')
X com = 1;
X else if (*p == 'O')
X if (*++p == 'N')
X p++, com = 1;
X else if (*p == 'F' && *++p == 'F')
X p++, com = 2;
X while (*p == ' ' || *p == '\t')
X p++;
X if (p[0] == '*' && p[1] == '/' && p[2] == '\n' && com) {
X if (s_com != e_com || s_lab != e_lab || s_code != e_code)
X dump_line();
X if (!(inhibit_formatting = com - 1)) {
X n_real_blanklines = 0;
X postfix_blankline_requested = 0;
X prefix_blankline_requested = 0;
X suppress_blanklines = 1;
X }
X }
X }
X }
X }
X }
X if (inhibit_formatting) {
X p = in_buffer;
X do
X putc(*p, output);
X while (*p++ != '\n');
X }
X return;
X};
X
X/*
X * Copyright (C) 1976 by the Board of Trustees of the University of Illinois
X *
X * All rights reserved
X *
X *
X * NAME: pad_output
X *
X * FUNCTION: Writes tabs and spaces to move the current column up to the desired
X * position.
X *
X * ALGORITHM: Put tabs and/or blanks into pobuf, then write pobuf.
X *
X * PARAMETERS: current integer The current column target
X * nteger The desired column
X *
X * RETURNS: Integer value of the new column. (If current >= target, no action is
X * taken, and current is returned.
X *
X * GLOBALS: None
X *
X * CALLS: write (sys)
X *
X * CALLED BY: dump_line
X *
X * HISTORY: initial coding November 1976 D A Willcox of CAC
X *
X */
Xpad_output(current, target) /* writes tabs and blanks (if necessary) to
X * get the current output position up to the
X * target column */
X int current; /* the current column value */
X int target; /* position we want it at */
X{
X register int curr; /* internal column pointer */
X register int tcur;
X
X if (troff)
X fprintf(output, "\\h'|%dp'", (target - 1) * 7);
X else {
X if (current >= target)
X return (current); /* line is already long enough */
X curr = current;
X while ((tcur = ((curr - 1) & tabmask) + tabsize + 1) <= target) {
X putc('\t', output);
X curr = tcur;
X }
X while (curr++ < target)
X putc(' ', output); /* pad with final blanks */
X }
X return (target);
X};
X
X/*
X * Copyright (C) 1976 by the Board of Trustees of the University of Illinois
X *
X * All rights reserved
X *
X *
X * NAME: count_spaces
X *
X * FUNCTION: Find out where printing of a given string will leave the current
X * character position on output.
X *
X * ALGORITHM: Run thru input string and add appropriate values to current
X * position.
X *
X * RETURNS: Integer value of position after printing "buffer" starting in column
X * "current".
X *
X * HISTORY: initial coding November 1976 D A Willcox of CAC
X *
X */
Xint
Xcount_spaces(current, buffer)
X/*
X * this routine figures out where the character position will be after
X * printing the text in buffer starting at column "current"
X */
X int current;
X char *buffer;
X{
X register char *buf; /* used to look thru buffer */
X register int cur; /* current character counter */
X
X cur = current;
X
X for (buf = buffer; *buf != '\0'; ++buf) {
X switch (*buf) {
X
X case '\n':
X case 014: /* form feed */
X cur = 1;
X break;
X
X case '\t':
X cur = ((cur - 1) & tabmask) + tabsize + 1;
X break;
X
X case '': /* this is a backspace */
X --cur;
X break;
X
X default:
X ++cur;
X break;
X } /* end of switch */
X } /* end of for loop */
X return (cur);
X};
X
Xint found_err;
Xdiag(level, msg, a, b)
X{
X if (level)
X found_err = 1;
X if (output == stdout) {
X fprintf(stdout, "/**INDENT** %s@%d: ", level == 0 ? "Warning" : "Error", line_no);
X fprintf(stdout, msg, a, b);
X fprintf(stdout, " */\n");
X }
X else {
X fprintf(stderr, "%s@%d: ", level == 0 ? "Warning" : "Error", line_no);
X fprintf(stderr, msg, a, b);
X fprintf(stderr, "\n");
X }
X}
X
Xwritefdef(f, nm)
X register struct fstate *f;
X{
X fprintf(output, ".ds f%c %s\n.nr s%c %d\n",
X nm, f->font, nm, f->size);
X}
X
Xchar *
Xchfont(of, nf, s)
X register struct fstate *of,
X *nf;
X char *s;
X{
X if (of->font[0] != nf->font[0]
X || of->font[1] != nf->font[1]) {
X *s++ = '\\';
X *s++ = 'f';
X if (nf->font[1]) {
X *s++ = '(';
X *s++ = nf->font[0];
X *s++ = nf->font[1];
X }
X else
X *s++ = nf->font[0];
X }
X if (nf->size != of->size) {
X *s++ = '\\';
X *s++ = 's';
X if (nf->size < of->size) {
X *s++ = '-';
X *s++ = '0' + of->size - nf->size;
X }
X else {
X *s++ = '+';
X *s++ = '0' + nf->size - of->size;
X }
X }
X return s;
X}
X
X
Xparsefont(f, s0)
X register struct fstate *f;
X char *s0;
X{
X register char *s = s0;
X int sizedelta = 0;
X bzero(f, sizeof *f);
X while (*s) {
X if (isdigit(*s))
X f->size = f->size * 10 + *s - '0';
X else if (isupper(*s))
X if (f->font[0])
X f->font[1] = *s;
X else
X f->font[0] = *s;
X else if (*s == 'c')
X f->allcaps = 1;
X else if (*s == '+')
X sizedelta++;
X else if (*s == '-')
X sizedelta--;
X else {
X fprintf(stderr, "indent: bad font specification: %s\n", s0);
X exit(1);
X }
X s++;
X }
X if (f->font[0] == 0)
X f->font[0] = 'R';
X if (bodyf.size == 0)
X bodyf.size = 11;
X if (f->size == 0)
X f->size = bodyf.size + sizedelta;
X else if (sizedelta > 0)
X f->size += bodyf.size;
X else
X f->size = bodyf.size - f->size;
X}
END_OF_FILE
echo shar: 1 control character may be missing from \"'indent/io.c'\"
if test 14572 -ne `wc -c <'indent/io.c'`; then
echo shar: \"'indent/io.c'\" unpacked with wrong size!
fi
# end of 'indent/io.c'
fi
if test -f 'indent/lexi.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'indent/lexi.c'\"
else
echo shar: Extracting \"'indent/lexi.c'\" \(13568 characters\)
sed "s/^X//" >'indent/lexi.c' <<'END_OF_FILE'
X/*
X * Copyright (c) 1985 Sun Microsystems, Inc.
X * Copyright (c) 1980 The Regents of the University of California.
X * Copyright (c) 1976 Board of Trustees of the University of Illinois.
X * All rights reserved.
X *
X * Redistribution and use in source and binary forms are permitted
X * provided that the above copyright notice and this paragraph are
X * duplicated in all such forms and that any documentation,
X * advertising materials, and other materials related to such
X * distribution and use acknowledge that the software was developed
X * by the University of California, Berkeley, the University of Illinois,
X * Urbana, and Sun Microsystems, Inc. The name of either University
X * or Sun Microsystems may not be used to endorse or promote products
X * derived from this software without specific prior written permission.
X * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
X * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
X * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
X */
X
X#ifndef lint
Xstatic char sccsid[] = "@(#)lexi.c 5.11 (Berkeley) 9/15/88";
X#endif /* not lint */
X
X/*
X * Here we have the token scanner for indent. It scans off one token and puts
X * it in the global variable "token". It returns a code, indicating the type
X * of token scanned.
X */
X
X#include "indent_globs.h"
X#include "indent_codes.h"
X#include "ctype.h"
X
X#define alphanum 1
X#define opchar 3
X
Xstruct templ {
X char *rwd;
X int rwcode;
X};
X
Xstruct templ specials[100] =
X{
X "switch", 1,
X "case", 2,
X "break", 0,
X "struct", 3,
X "union", 3,
X "enum", 3,
X "default", 2,
X "int", 4,
X "char", 4,
X "float", 4,
X "double", 4,
X "long", 4,
X "short", 4,
X "typdef", 4,
X "unsigned", 4,
X "register", 4,
X "static", 4,
X "global", 4,
X "extern", 4,
X "void", 4,
X "goto", 0,
X "return", 0,
X "if", 5,
X "while", 5,
X "for", 5,
X "else", 6,
X "do", 6,
X "sizeof", 7,
X 0, 0
X};
X
Xchar chartype[128] =
X{ /* this is used to facilitate the decision of
X * what type (alphanumeric, operator) each
X * character is */
X 0, 0, 0, 0, 0, 0, 0, 0,
X 0, 0, 0, 0, 0, 0, 0, 0,
X 0, 0, 0, 0, 0, 0, 0, 0,
X 0, 0, 0, 0, 0, 0, 0, 0,
X 0, 3, 0, 0, 1, 3, 3, 0,
X 0, 0, 3, 3, 0, 3, 0, 3,
X 1, 1, 1, 1, 1, 1, 1, 1,
X 1, 1, 0, 0, 3, 3, 3, 3,
X 0, 1, 1, 1, 1, 1, 1, 1,
X 1, 1, 1, 1, 1, 1, 1, 1,
X 1, 1, 1, 1, 1, 1, 1, 1,
X 1, 1, 1, 0, 0, 0, 3, 1,
X 0, 1, 1, 1, 1, 1, 1, 1,
X 1, 1, 1, 1, 1, 1, 1, 1,
X 1, 1, 1, 1, 1, 1, 1, 1,
X 1, 1, 1, 0, 3, 0, 3, 0
X};
X
X
X
X
Xint
Xlexi()
X{
X register char *tok; /* local pointer to next char in token */
X int unary_delim; /* this is set to 1 if the current token
X *
X * forces a following operator to be unary */
X static int last_code; /* the last token type returned */
X static int l_struct; /* set to 1 if the last token was 'struct' */
X int code; /* internal code to be returned */
X char qchar; /* the delimiter character for a string */
X
X tok = token; /* point to start of place to save token */
X unary_delim = false;
X ps.col_1 = ps.last_nl; /* tell world that this token started in
X * column 1 iff the last thing scanned was nl */
X ps.last_nl = false;
X
X while (*buf_ptr == ' ' || *buf_ptr == '\t') { /* get rid of blanks */
X ps.col_1 = false; /* leading blanks imply token is not in column
X * 1 */
X if (++buf_ptr >= buf_end)
X fill_buffer();
X }
X
X /* Scan an alphanumeric token */
X if (chartype[*buf_ptr] == alphanum || buf_ptr[0] == '.' && isdigit(buf_ptr[1])) {
X /*
X * we have a character or number
X */
X register char *j; /* used for searching thru list of
X *
X * reserved words */
X register struct templ *p;
X
X if (isdigit(*buf_ptr) || buf_ptr[0] == '.' && isdigit(buf_ptr[1])) {
X int seendot = 0,
X seenexp = 0;
X if (*buf_ptr == '0' &&
X (buf_ptr[1] == 'x' || buf_ptr[1] == 'X')) {
X *tok++ = *buf_ptr++;
X *tok++ = *buf_ptr++;
X while (isxdigit(*buf_ptr))
X *tok++ = *buf_ptr++;
X }
X else
X while (1) {
X if (*buf_ptr == '.')
X if (seendot)
X break;
X else
X seendot++;
X *tok++ = *buf_ptr++;
X if (!isdigit(*buf_ptr) && *buf_ptr != '.')
X if ((*buf_ptr != 'E' && *buf_ptr != 'e') || seenexp)
X break;
X else {
X seenexp++;
X seendot++;
X *tok++ = *buf_ptr++;
X if (*buf_ptr == '+' || *buf_ptr == '-')
X *tok++ = *buf_ptr++;
X }
X }
X if (*buf_ptr == 'L' || *buf_ptr == 'l')
X *tok++ = *buf_ptr++;
X }
X else
X while (chartype[*buf_ptr] == alphanum) { /* copy it over */
X *tok++ = *buf_ptr++;
X if (buf_ptr >= buf_end)
X fill_buffer();
X }
X *tok++ = '\0';
X while (*buf_ptr == ' ' || *buf_ptr == '\t') { /* get rid of blanks */
X if (++buf_ptr >= buf_end)
X fill_buffer();
X }
X ps.its_a_keyword = false;
X ps.sizeof_keyword = false;
X if (l_struct) { /* if last token was 'struct', then this token
X * should be treated as a declaration */
X l_struct = false;
X last_code = ident;
X ps.last_u_d = true;
X return (decl);
X }
X ps.last_u_d = false; /* Operator after indentifier is binary */
X last_code = ident; /* Remember that this is the code we will
X * return */
X
X /*
X * This loop will check if the token is a keyword.
X */
X for (p = specials; (j = p->rwd) != 0; p++) {
X tok = token; /* point at scanned token */
X if (*j++ != *tok++ || *j++ != *tok++)
X continue; /* This test depends on the fact that
X * identifiers are always at least 1 character
X * long (ie. the first two bytes of the
X * identifier are always meaningful) */
X if (tok[-1] == 0)
X break; /* If its a one-character identifier */
X while (*tok++ == *j)
X if (*j++ == 0)
X goto found_keyword; /* I wish that C had a multi-level
X * break... */
X }
X if (p->rwd) { /* we have a keyword */
X found_keyword:
X ps.its_a_keyword = true;
X ps.last_u_d = true;
X switch (p->rwcode) {
X case 1: /* it is a switch */
X return (swstmt);
X case 2: /* a case or default */
X return (casestmt);
X
X case 3: /* a "struct" */
X if (ps.p_l_follow)
X break; /* inside parens: cast */
X l_struct = true;
X
X /*
X * Next time around, we will want to know that we have had a
X * 'struct'
X */
X case 4: /* one of the declaration keywords */
X if (ps.p_l_follow) {
X ps.cast_mask |= 1 << ps.p_l_follow;
X break; /* inside parens: cast */
X }
X last_code = decl;
X return (decl);
X
X case 5: /* if, while, for */
X return (sp_paren);
X
X case 6: /* do, else */
X return (sp_nparen);
X
X case 7:
X ps.sizeof_keyword = true;
X default: /* all others are treated like any other
X * identifier */
X return (ident);
X } /* end of switch */
X } /* end of if (found_it) */
X if (*buf_ptr == '(' && ps.tos <= 1 && ps.ind_level == 0) {
X register char *tp = buf_ptr;
X while (tp < buf_end)
X if (*tp++ == ')' && *tp == ';')
X goto not_proc;
X strncpy(ps.procname, token, sizeof ps.procname - 1);
X ps.in_parameter_declaration = 1;
X not_proc:;
X }
X /*
X * The following hack attempts to guess whether or not the current
X * token is in fact a declaration keyword -- one that has been
X * typedefd
X */
X if (((*buf_ptr == '*' && buf_ptr[1] != '=') || isalpha(*buf_ptr) || *buf_ptr == '_')
X && !ps.p_l_follow
X && !ps.block_init
X && (ps.last_token == rparen || ps.last_token == semicolon ||
X ps.last_token == decl ||
X ps.last_token == lbrace || ps.last_token == rbrace)) {
X ps.its_a_keyword = true;
X ps.last_u_d = true;
X last_code = decl;
X return decl;
X }
X if (last_code == decl) /* if this is a declared variable, then
X * following sign is unary */
X ps.last_u_d = true; /* will make "int a -1" work */
X last_code = ident;
X return (ident); /* the ident is not in the list */
X } /* end of procesing for alpanum character */
X /* l l l Scan a non-alphanumeric token */
X
X *tok++ = *buf_ptr; /* if it is only a one-character token, it is
X * moved here */
X *tok = '\0';
X if (++buf_ptr >= buf_end)
X fill_buffer();
X
X switch (*token) {
X case '\n':
X unary_delim = ps.last_u_d;
X ps.last_nl = true; /* remember that we just had a newline */
X code = (had_eof ? 0 : newline);
X
X /*
X * if data has been exausted, the newline is a dummy, and we should
X * return code to stop
X */
X break;
X
X case '\'': /* start of quoted character */
X case '"': /* start of string */
X qchar = *token;
X if (troff) {
X tok[-1] = '`';
X if (qchar == '"')
X *tok++ = '`';
X tok = chfont(&bodyf, &stringf, tok);
X }
X do { /* copy the string */
X while (1) { /* move one character or [/<char>]<char> */
X if (*buf_ptr == '\n') {
X printf("%d: Unterminated literal\n", line_no);
X goto stop_lit;
X }
X *tok = *buf_ptr++;
X if (buf_ptr >= buf_end)
X fill_buffer();
X if (had_eof || ((tok - token) > (bufsize - 2))) {
X printf("Unterminated literal\n");
X ++tok;
X goto stop_lit;
X /* get outof literal copying loop */
X }
X if (*tok == BACKSLASH) { /* if escape, copy extra char */
X if (*buf_ptr == '\n') /* check for escaped newline */
X ++line_no;
X if (troff) {
X *++tok = BACKSLASH;
X if (*buf_ptr == BACKSLASH)
X *++tok = BACKSLASH;
X }
X *++tok = *buf_ptr++;
X ++tok; /* we must increment this again because we
X * copied two chars */
X if (buf_ptr >= buf_end)
X fill_buffer();
X }
X else
X break; /* we copied one character */
X } /* end of while (1) */
X } while (*tok++ != qchar);
X if (troff) {
X tok = chfont(&stringf, &bodyf, tok - 1);
X if (qchar == '"')
X *tok++ = '\'';
X }
Xstop_lit:
X code = ident;
X break;
X
X case ('('):
X case ('['):
X unary_delim = true;
X code = lparen;
X break;
X
X case (')'):
X case (']'):
X code = rparen;
X break;
X
X case '#':
X unary_delim = ps.last_u_d;
X code = preesc;
X break;
X
X case '?':
X unary_delim = true;
X code = question;
X break;
X
X case (':'):
X code = colon;
X unary_delim = true;
X break;
X
X case (';'):
X unary_delim = true;
X code = semicolon;
X break;
X
X case ('{'):
X unary_delim = true;
X
X /*
X * if (ps.in_or_st) ps.block_init = 1;
X */
X /* ? code = ps.block_init ? lparen : lbrace; */
X code = lbrace;
X break;
X
X case ('}'):
X unary_delim = true;
X /* ? code = ps.block_init ? rparen : rbrace; */
X code = rbrace;
X break;
X
X case 014: /* a form feed */
X unary_delim = ps.last_u_d;
X ps.last_nl = true; /* remember this so we can set 'ps.col_1'
X * right */
X code = form_feed;
X break;
X
X case (','):
X unary_delim = true;
X code = comma;
X break;
X
X case '.':
X unary_delim = false;
X code = period;
X break;
X
X case '-':
X case '+': /* check for -, +, --, ++ */
X code = (ps.last_u_d ? unary_op : binary_op);
X unary_delim = true;
X
X if (*buf_ptr == token[0]) {
X /* check for doubled character */
X *tok++ = *buf_ptr++;
X /* buffer overflow will be checked at end of loop */
X if (last_code == ident || last_code == rparen) {
X code = (ps.last_u_d ? unary_op : postop);
X /* check for following ++ or -- */
X unary_delim = false;
X }
X }
X else if (*buf_ptr == '=')
X /* check for operator += */
X *tok++ = *buf_ptr++;
X else if (*buf_ptr == '>') {
X /* check for operator -> */
X *tok++ = *buf_ptr++;
X if (!pointer_as_binop) {
X unary_delim = false;
X code = unary_op;
X ps.want_blank = false;
X }
X }
X break; /* buffer overflow will be checked at end of
X * switch */
X
X case '=':
X if (ps.in_or_st)
X ps.block_init = 1;
X#ifdef undef
X if (chartype[*buf_ptr] == opchar) { /* we have two char assignment */
X tok[-1] = *buf_ptr++;
X if ((tok[-1] == '<' || tok[-1] == '>') && tok[-1] == *buf_ptr)
X *tok++ = *buf_ptr++;
X *tok++ = '='; /* Flip =+ to += */
X *tok = 0;
X }
X#else
X if (*buf_ptr == '=') {/* == */
X *tok++ = '='; /* Flip =+ to += */
X buf_ptr++;
X *tok = 0;
X }
X#endif
X code = binary_op;
X unary_delim = true;
X break;
X /* can drop thru!!! */
X
X case '>':
X case '<':
X case '!': /* ops like <, <<, <=, !=, etc */
X if (*buf_ptr == '>' || *buf_ptr == '<' || *buf_ptr == '=') {
X *tok++ = *buf_ptr;
X if (++buf_ptr >= buf_end)
X fill_buffer();
X }
X if (*buf_ptr == '=')
X *tok++ = *buf_ptr++;
X code = (ps.last_u_d ? unary_op : binary_op);
X unary_delim = true;
X break;
X
X default:
X if (token[0] == '/' && *buf_ptr == '*') {
X /* it is start of comment */
X *tok++ = '*';
X
X if (++buf_ptr >= buf_end)
X fill_buffer();
X
X code = comment;
X unary_delim = ps.last_u_d;
X break;
X }
X while (*(tok - 1) == *buf_ptr || *buf_ptr == '=') {
X /*
X * handle ||, &&, etc, and also things as in int *****i
X */
X *tok++ = *buf_ptr;
X if (++buf_ptr >= buf_end)
X fill_buffer();
X }
X code = (ps.last_u_d ? unary_op : binary_op);
X unary_delim = true;
X
X
X } /* end of switch */
X if (code != newline) {
X l_struct = false;
X last_code = code;
X }
X if (buf_ptr >= buf_end) /* check for input buffer empty */
X fill_buffer();
X ps.last_u_d = unary_delim;
X *tok = '\0'; /* null terminate the token */
X return (code);
X};
X
X/*
X * Add the given keyword to the keyword table, using val as the keyword type
X */
Xaddkey(key, val)
X char *key;
X{
X register struct templ *p = specials;
X while (p->rwd)
X if (p->rwd[0] == key[0] && strcmp(p->rwd, key) == 0)
X return;
X else
X p++;
X if (p >= specials + sizeof specials / sizeof specials[0])
X return; /* For now, table overflows are silently
X * ignored */
X p->rwd = key;
X p->rwcode = val;
X p[1].rwd = 0;
X p[1].rwcode = 0;
X return;
X}
END_OF_FILE
if test 13568 -ne `wc -c <'indent/lexi.c'`; then
echo shar: \"'indent/lexi.c'\" unpacked with wrong size!
fi
# end of 'indent/lexi.c'
fi
if test -f 'indent/pr_comment.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'indent/pr_comment.c'\"
else
echo shar: Extracting \"'indent/pr_comment.c'\" \(11737 characters\)
sed "s/^X//" >'indent/pr_comment.c' <<'END_OF_FILE'
X/*
X * Copyright (c) 1985 Sun Microsystems, Inc.
X * Copyright (c) 1980 The Regents of the University of California.
X * Copyright (c) 1976 Board of Trustees of the University of Illinois.
X * All rights reserved.
X *
X * Redistribution and use in source and binary forms are permitted
X * provided that the above copyright notice and this paragraph are
X * duplicated in all such forms and that any documentation,
X * advertising materials, and other materials related to such
X * distribution and use acknowledge that the software was developed
X * by the University of California, Berkeley, the University of Illinois,
X * Urbana, and Sun Microsystems, Inc. The name of either University
X * or Sun Microsystems may not be used to endorse or promote products
X * derived from this software without specific prior written permission.
X * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
X * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
X * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
X */
X
X#ifndef lint
Xstatic char sccsid[] = "@(#)pr_comment.c 5.9 (Berkeley) 9/15/88";
X#endif /* not lint */
X
X/*
X * NAME:
X * pr_comment
X *
X * FUNCTION:
X * This routine takes care of scanning and printing comments.
X *
X * ALGORITHM:
X * 1) Decide where the comment should be aligned, and if lines should
X * be broken.
X * 2) If lines should not be broken and filled, just copy up to end of
X * comment.
X * 3) If lines should be filled, then scan thru input_buffer copying
X * characters to com_buf. Remember where the last blank, tab, or
X * newline was. When line is filled, print up to last blank and
X * continue copying.
X *
X * HISTORY:
X * November 1976 D A Willcox of CAC Initial coding
X * 12/6/76 D A Willcox of CAC Modification to handle
X * UNIX-style comments
X *
X */
X
X/*
X * this routine processes comments. It makes an attempt to keep comments from
X * going over the max line length. If a line is too long, it moves everything
X * from the last blank to the next comment line. Blanks and tabs from the
X * beginning of the input line are removed
X */
X
X
X#include "indent_globs.h"
X
X
Xpr_comment()
X{
X int now_col; /* column we are in now */
X int adj_max_col; /* Adjusted max_col for when we decide to
X * spill comments over the right margin */
X char *last_bl; /* points to the last blank in the output
X * buffer */
X char *t_ptr; /* used for moving string */
X int unix_comment; /* tri-state variable used to decide if it is
X * a unix-style comment. 0 means only blanks
X * since /*, 1 means regular style comment, 2
X * means unix style comment */
X int break_delim = comment_delimiter_on_blankline;
X int l_just_saw_decl = ps.just_saw_decl;
X /*
X * int ps.last_nl = 0; /* true iff the last significant thing
X * weve seen is a newline
X */
X int one_liner = 1; /* true iff this comment is a one-liner */
X adj_max_col = max_col;
X ps.just_saw_decl = 0;
X last_bl = 0; /* no blanks found so far */
X ps.box_com = false; /* at first, assume that we are not in
X * a boxed comment or some other
X * comment that should not be touched */
X ++ps.out_coms; /* keep track of number of comments */
X unix_comment = 1; /* set flag to let us figure out if there is a
X * unix-style comment ** DISABLED: use 0 to
X * reenable this hack! */
X
X /* Figure where to align and how to treat the comment */
X
X if (ps.col_1 && !format_col1_comments) { /* if comment starts in column
X * 1 it should not be touched */
X ps.box_com = true;
X ps.com_col = 1;
X }
X else {
X if (*buf_ptr == '-' || *buf_ptr == '*') {
X ps.box_com = true; /* a comment with a '-' or '*' immediately
X * after the /* is assumed to be a boxed
X * comment */
X break_delim = 0;
X }
X if ( /* ps.bl_line && */ (s_lab == e_lab) && (s_code == e_code)) {
X /* klg: check only if this line is blank */
X /*
X * If this (*and previous lines are*) blank, dont put comment way
X * out at left
X */
X ps.com_col = (ps.ind_level - ps.unindent_displace) * ps.ind_size + 1;
X adj_max_col = block_comment_max_col;
X if (ps.com_col <= 1)
X ps.com_col = 1 + !format_col1_comments;
X }
X else {
X register target_col;
X break_delim = 0;
X if (s_code != e_code)
X target_col = count_spaces(compute_code_target(), s_code);
X else {
X target_col = 1;
X if (s_lab != e_lab)
X target_col = count_spaces(compute_label_target(), s_lab);
X }
X ps.com_col = ps.decl_on_line || ps.ind_level == 0 ? ps.decl_com_ind : ps.com_ind;
X if (ps.com_col < target_col)
X ps.com_col = ((target_col + 7) & ~7) + 1;
X if (ps.com_col + 24 > adj_max_col)
X adj_max_col = ps.com_col + 24;
X }
X }
X if (ps.box_com) {
X buf_ptr[-2] = 0;
X ps.n_comment_delta = 1 - count_spaces(1, in_buffer);
X buf_ptr[-2] = '/';
X }
X else {
X ps.n_comment_delta = 0;
X while (*buf_ptr == ' ' || *buf_ptr == '\t')
X buf_ptr++;
X }
X ps.comment_delta = 0;
X *e_com++ = '/'; /* put '/*' into buffer */
X *e_com++ = '*';
X if (*buf_ptr != ' ' && !ps.box_com)
X *e_com++ = ' ';
X
X *e_com = '\0';
X if (troff) {
X now_col = 1;
X adj_max_col = 80;
X }
X else
X now_col = count_spaces(ps.com_col, s_com); /* figure what column we
X * would be in if we
X * printed the comment
X * now */
X
X /* Start to copy the comment */
X
X while (1) { /* this loop will go until the comment is
X * copied */
X if (*buf_ptr > 040 && *buf_ptr != '*')
X ps.last_nl = 0;
X check_size(com);
X switch (*buf_ptr) { /* this checks for various spcl cases */
X case 014: /* check for a form feed */
X if (!ps.box_com) { /* in a text comment, break the line here */
X ps.use_ff = true;
X /* fix so dump_line uses a form feed */
X dump_line();
X last_bl = 0;
X *e_com++ = ' ';
X *e_com++ = '*';
X *e_com++ = ' ';
X while (*++buf_ptr == ' ' || *buf_ptr == '\t');
X }
X else {
X if (++buf_ptr >= buf_end)
X fill_buffer();
X *e_com++ = 014;
X }
X break;
X
X case '\n':
X if (had_eof) { /* check for unexpected eof */
X printf("Unterminated comment\n");
X *e_com = '\0';
X dump_line();
X return;
X }
X one_liner = 0;
X if (ps.box_com || ps.last_nl) { /* if this is a boxed comment,
X * we dont ignore the newline */
X if (s_com == e_com) {
X *e_com++ = ' ';
X *e_com++ = ' ';
X }
X *e_com = '\0';
X if (!ps.box_com && e_com - s_com > 3) {
X if (break_delim == 1 && s_com[0] == '/'
X && s_com[1] == '*' && s_com[2] == ' ') {
X char *t = e_com;
X break_delim = 2;
X e_com = s_com + 2;
X *e_com = 0;
X if (blanklines_before_blockcomments)
X prefix_blankline_requested = 1;
X dump_line();
X e_com = t;
X s_com[0] = s_com[1] = s_com[2] = ' ';
X }
X dump_line();
X check_size(com);
X *e_com++ = ' ';
X *e_com++ = ' ';
X }
X dump_line();
X now_col = ps.com_col;
X }
X else {
X ps.last_nl = 1;
X if (unix_comment != 1) { /* we not are in unix_style
X * comment */
X if (unix_comment == 0 && s_code == e_code) {
X /*
X * if it is a UNIX-style comment, ignore the
X * requirement that previous line be blank for
X * unindention
X */
X ps.com_col = (ps.ind_level - ps.unindent_displace) * ps.ind_size + 1;
X if (ps.com_col <= 1)
X ps.com_col = 2;
X }
X unix_comment = 2; /* permanently remember that we are in
X * this type of comment */
X dump_line();
X ++line_no;
X now_col = ps.com_col;
X *e_com++ = ' ';
X /*
X * fix so that the star at the start of the line will line
X * up
X */
X do /* flush leading white space */
X if (++buf_ptr >= buf_end)
X fill_buffer();
X while (*buf_ptr == ' ' || *buf_ptr == '\t');
X break;
X }
X if (*(e_com - 1) == ' ' || *(e_com - 1) == '\t')
X last_bl = e_com - 1;
X /*
X * if there was a space at the end of the last line, remember
X * where it was
X */
X else { /* otherwise, insert one */
X last_bl = e_com;
X check_size(com);
X *e_com++ = ' ';
X ++now_col;
X }
X }
X ++line_no; /* keep track of input line number */
X if (!ps.box_com) {
X int nstar = 1;
X do { /* flush any blanks and/or tabs at start of
X * next line */
X if (++buf_ptr >= buf_end)
X fill_buffer();
X if (*buf_ptr == '*' && --nstar >= 0) {
X if (++buf_ptr >= buf_end)
X fill_buffer();
X if (*buf_ptr == '/')
X goto end_of_comment;
X }
X } while (*buf_ptr == ' ' || *buf_ptr == '\t');
X }
X else if (++buf_ptr >= buf_end)
X fill_buffer();
X break; /* end of case for newline */
X
X case '*': /* must check for possibility of being at end
X * of comment */
X if (++buf_ptr >= buf_end) /* get to next char after * */
X fill_buffer();
X
X if (unix_comment == 0) /* set flag to show we are not in
X * unix-style comment */
X unix_comment = 1;
X
X if (*buf_ptr == '/') { /* it is the end!!! */
X end_of_comment:
X if (++buf_ptr >= buf_end)
X fill_buffer();
X
X if (*(e_com - 1) != ' ' && !ps.box_com) { /* insure blank before
X * end */
X *e_com++ = ' ';
X ++now_col;
X }
X if (break_delim == 1 && !one_liner && s_com[0] == '/'
X && s_com[1] == '*' && s_com[2] == ' ') {
X char *t = e_com;
X break_delim = 2;
X e_com = s_com + 2;
X *e_com = 0;
X if (blanklines_before_blockcomments)
X prefix_blankline_requested = 1;
X dump_line();
X e_com = t;
X s_com[0] = s_com[1] = s_com[2] = ' ';
X }
X if (break_delim == 2 && e_com > s_com + 3
X /* now_col > adj_max_col - 2 && !ps.box_com */ ) {
X *e_com = '\0';
X dump_line();
X now_col = ps.com_col;
X }
X check_size(com);
X *e_com++ = '*';
X *e_com++ = '/';
X *e_com = '\0';
X ps.just_saw_decl = l_just_saw_decl;
X return;
X }
X else { /* handle isolated '*' */
X *e_com++ = '*';
X ++now_col;
X }
X break;
X default: /* we have a random char */
X if (unix_comment == 0 && *buf_ptr != ' ' && *buf_ptr != '\t')
X unix_comment = 1; /* we are not in unix-style comment */
X
X *e_com = *buf_ptr++;
X if (buf_ptr >= buf_end)
X fill_buffer();
X
X if (*e_com == '\t') /* keep track of column */
X now_col = ((now_col - 1) & tabmask) + tabsize + 1;
X else if (*e_com == '\b') /* this is a backspace */
X --now_col;
X else
X ++now_col;
X
X if (*e_com == ' ' || *e_com == '\t')
X last_bl = e_com;
X /* remember we saw a blank */
X
X ++e_com;
X if (now_col > adj_max_col && !ps.box_com && unix_comment == 1 && e_com[-1] > ' ') {
X /*
X * the comment is too long, it must be broken up
X */
X if (break_delim == 1 && s_com[0] == '/'
X && s_com[1] == '*' && s_com[2] == ' ') {
X char *t = e_com;
X break_delim = 2;
X e_com = s_com + 2;
X *e_com = 0;
X if (blanklines_before_blockcomments)
X prefix_blankline_requested = 1;
X dump_line();
X e_com = t;
X s_com[0] = s_com[1] = s_com[2] = ' ';
X }
X if (last_bl == 0) { /* we have seen no blanks */
X last_bl = e_com; /* fake it */
X *e_com++ = ' ';
X }
X *e_com = '\0'; /* print what we have */
X *last_bl = '\0';
X while (last_bl > s_com && last_bl[-1] < 040)
X *--last_bl = 0;
X e_com = last_bl;
X dump_line();
X
X *e_com++ = ' '; /* add blanks for continuation */
X *e_com++ = ' ';
X *e_com++ = ' ';
X
X t_ptr = last_bl + 1;
X last_bl = 0;
X if (t_ptr >= e_com) {
X while (*t_ptr == ' ' || *t_ptr == '\t')
X t_ptr++;
X while (*t_ptr != '\0') { /* move unprinted part of
X * comment down in buffer */
X if (*t_ptr == ' ' || *t_ptr == '\t')
X last_bl = e_com;
X *e_com++ = *t_ptr++;
X }
X }
X *e_com = '\0';
X now_col = count_spaces(ps.com_col, s_com); /* recompute current
X * position */
X }
X break;
X }
X }
X}
END_OF_FILE
if test 11737 -ne `wc -c <'indent/pr_comment.c'`; then
echo shar: \"'indent/pr_comment.c'\" unpacked with wrong size!
fi
# end of 'indent/pr_comment.c'
fi
echo shar: End of archive 2 \(of 3\).
cp /dev/null ark2isdone
MISSING=""
for I in 1 2 3 ; do
if test ! -f ark${I}isdone ; then
MISSING="${MISSING} ${I}"
fi
done
if test "${MISSING}" = "" ; then
echo You have unpacked all 3 archives.
rm -f ark[1-9]isdone
else
echo You still need to unpack the following archives:
echo " " ${MISSING}
fi
## End of shell archive.
exit 0
