Oakland CPM Archive/oakcpm.iso/cpm/cpm68k/utils.lbr/INDENT.CQ/INDENT.C

C/C++ Source or Header | 1986-05-22 | 32.9 KB | 1,215 lines

/* -*-c,save-*-

              Copyright (C) 1976
                by the
              Board of Trustees
                of the
            University of Illinois

             All rights reserved


NAME:
    indent main program

FUNCTION:
    This is the main program of the indent program.  Indent will take a C
    program source and reformat it into a semi-reasonable form.

ALGORITHM:
    The routine lexi scans tokens and passes them back one at a time to the
    main routine.  The subroutine parse takes care of much of the work of
    figuring indentation level.

    1) Call lexi
    2) Enter a monster switch statement on the code returned by lexi.  If
       the indentation level for the line yet to be printed should be
       changed, set the variable ind_level.  If the indentation level for
       the following line should be changed, set the variable i_l_follow.

PARAMETERS:
    None

RETURNS:
    Nothing

GLOBALS:
    be_save =
    break_comma
    bp_save =
    btype_2 =
    code_lines
    com_ind =
    com_lines
    dec_nest =
    decl_com_ind =
    decl_on_line =
    i_l_follow =
    in_decl =
    ind_level =
    ind_size =
    ind_stmt =
    last_u_d =
    leave_comma =
    line_no =
    ljust_decl =
    max_col =
    out_coms
    out_lines
    p_l_follow =
    paren_level =
    pcase =
    sc_end =
    unindent_displace =
    use_ff =
    verbose =

CALLS:
    atoi (lib)
    cmp
    creat (lib)
    unlink (lib)
    dump_line
    eqin
    fill_buffer
    lexi
    open (lib)
    parse
    pr_comment
    printf (lib)
    seek (lib)
    time (lib)

CALLED BY:
    No one (main routine)

HISTORY:
    November 1976    D A Willcox of CAC    Initial coding
    12/9/76        D A Willcox of CAC    Fixed defaults for decl_com_ind
                        to be 8 less than com_ind if
                        left justifying declarations
    12/9/76        D A Willcox of CAC    Fixed processing of nested
                        <c>?<s>:<s> constructs
    1/7/77        D A Willcox of CAC    Added check for overwrite of
                        input file
                        Added code to handle -br and -bl
                        parameters
    10/30/83    William H. Nugent    Change unlink to delete for
                        VAX/VMS and commented out
                        checking for input & output
                        filename checking to protect
                        from overwrite (not a worry in
                        VMS land.  And changed the
                        indent.pro to handle VMS (i.e.
                        SYS$LOGIN:INDENT.PRO).  Backup
                        modified to take advantage of
                        VAX/VMS version numbers.

    8/17/85        Robert Heller        Change delete back to unlink
                        for CP/M-68k and changed the
                        indent.pro to be compatable
                        with CP/M-68k.  also added
                        calls to perror to give
                        usefull error messages on
                        system I/O errors.  Also
                        re-enabled filename checking
                        to prevent overwrite (CP/M-68K
                        does not have version numbers).

*/
#include "indntglo.h";
#include "indntcod.h";

/* #define dolog 1    /* if this define is removed, then the code to
               produce a log file will be removed */

struct templ {               /* this is a template for the list of
                      command line args */
    char   *str;           /* pointer to string which is a valid
                      command line arg */
    int     code;           /* code to be used in switch for processing
                      this arg */
};


struct templ    options[] =
{                   /* warning - because of the way that this
                      table is scanned, if one entry is an
                      initial substring of another, then the
                      longer entry should occur first */
    "-cd", 4,
    "-c", 2,
    "-l", 1,
    "-i", 3,
    "-v", 5,
    "-nv", 6,
    "-dj", 7,
    "-d", 13,               /* unindented comment placement */
    "-ndj", 8,
    "-bc", 10,               /* break after command in decl */
    "-nbc", 9,               /* don't break after comma */
    "-br", 14,               /* put brace on right of stmt */
    "-bl", 15,               /* put brace on left by itself */
    "-st", 16,               /* use the standard input and output
                  files */
    0, 0
};


char   *in_name = "Standard Input";
                   /* will always point to name of input file
                   */
char   *out_name = "Standard Output";
                   /* will always point to name of output file
                      */
char    bakfile[32] = "";

main (argc, argv)
int     argc;
char  **argv;
{

    int     dec_ind;           /* current indentation for declarations */
    int     di_stack[20];      /* a stack of structure indentation levels
                   */
    int     flushed_nl;           /* used when buffering up comments to
                      remember that a newline was passed over
                   */
    int     force_nl;           /* when true, code must be broken */
    int     hd_type;           /* used to store type of stmt for if (...),
                      for (...), etc */
    register int    i;           /* local loop counter */
    int     in_or_st;           /* Will be true iff there has been a
                      declarator (e.g. int or char) and no
                      left paren since the last semicolon.
                      When true, a { is starting a structure
                      definition or an initialization list */
    register int    j;           /* local loop counter */
    int     scase;           /* set to true when we see a case, so we
                      will know what to do with the following
                      colon */
    int     sp_sw;           /* when true, we are in the expressin of
                      if(...), while(...), etc. */
    int     squest;           /* when this is positive, we have seen a ?
                      without the matching : in a <c>?<s>:<s>
                      construct */
    register char  *t_ptr;     /* used for copying tokens */
    int     type_code;           /* the type of token, returned by lexi */
    int     want_blank;           /* set to true when the following token
                      should be prefixed by a blank. (Said
                      prefixing is ignored in some cases.) */

#ifdef dolog               /* include declarations needed for log */
    int     log_fid;           /* fid of log file */

    struct logtmpl {           /* structure of a log entry */
    int     tvec[2];       /* time of execution */
    char    inp;           /* input fid */
    char    outp;           /* output fid */
    int     nout;           /* # output lines */
    int     ncom;           /* # comments */
    int     wcom;           /* # lines w/ comments */
    int     wcode;           /* # lines w/code */
    char    mc;           /* max line size */
    char    ci;           /* comment indentation */
    char    inds;           /* indent size */
    char    dci;           /* decl comment indentation */
    char    verb;           /* verbose */
    char    ljus;           /* left just */
    char    lvcom;           /* leave commas */
    char    unin;           /* unindented comment indentation */
    char    uid;           /* the user id */
    char    bropt;           /* btype_2 */
    int     reserved[2];
    };

    struct logtmpl  logent;
#endif

/*-----------------------------------------------*\
|    INITIALIZATION
\*-----------------------------------------------*/


    combuf[0] = codebuf[0] = labbuf[0] = ' ';
 /* set up code, label, and comment buffers */
    combuf[1] = codebuf[1] = labbuf[1] = '\0';
    s_lab = e_lab = labbuf + 1;
    s_code = e_code = codebuf + 1;
    s_com = e_com = combuf + 1;

    buf_ptr = buf_end = in_buffer;
    line_no = 1;
    had_eof = in_decl = decl_on_line = break_comma = false;
    sp_sw = force_nl = false;
    in_or_st = false;
    bl_line = true;
    dec_ind = 0;
    di_stack[dec_nest = 0] = 0;
    want_blank = in_stmt = ind_stmt = false;


    scase = pcase = false;
    squest = 0;
    sc_end = 0;
    bp_save = 0;
    be_save = 0;

    input = -1;
    output = -1;
    ljust_decl = d_ljust;



/*--------------------------------------------------*\
|   COMMAND LINE SCAN
\*--------------------------------------------------*/

    max_col = d_max_col;       /* set up some default values */
    com_ind = d_com_ind;
    ind_size = d_ind_size;
    verbose = d_verbose;
    decl_com_ind = 0;           /* if this is not set to some positive
                      value by an arg, we will set this equal
                      to com_ind */
    btype_2 = d_btype_2;
    unindent_displace = d_unindent;
    leave_comma = d_leave_comma;

    set_profile ();

    for (i = 1; i < argc; ++i) {
    /* look thru args (if any) for changes to defaults */
    if (argv[i][0] != '-') {/* no flag on parameter */
        if (input < 0) {   /* we must have the input file */
        in_name = argv[i];    /* remember name of input
                       file */
        input = open (in_name, 0);
        if (input < 0) {    /* check for open error */
            perror("indent");
            printf ("Can't open %s\n", argv[i]);
            exit ();
        }
        continue;
        }
        else
        if (output < 0) {    /* we have the output file */
            out_name = argv[i];    /* remember name of output file */
            if (cmp (in_name, out_name) == 0) {      /* attempt to
                       overwright the file */
            printf ("Input and output files must be different\n");
            exit ();
            }

            output = creat (out_name, 0644);
            if (output < 0) {   /* check for create error */
            perror("indent");
            printf ("Can't create %s\n", argv[i]);
            exit ();
            }
            continue;
        }

        printf ("Unknown parameter: %s\n", argv[i]);
        exit ();
    }
    else
        set_option (argv[i]);

    }                   /* end of for */

    if (input < 0) {
    printf ("Usage: indent file [ outfile ] [ options ]\n");
    exit ();
    }
    if (output < 0) {
    out_name = in_name;
    bakcopy ();
    }

    if (com_ind <= 1)
    com_ind = 2;           /* don't put normal comments before column
                      2 */

    if (decl_com_ind <= 0)     /* if not specified by user, set this */
    decl_com_ind = ljust_decl ? (com_ind <= 10 ? 2 : com_ind - 8) : com_ind;

    fill_buffer ();           /* get first batch of stuff into input
                      buffer */

    parse (semicolon);
/*-----------------------------------------------------
|   START OF MAIN LOOP
\*----------------------------------------------------*/

    while (1) {               /* this is the main loop.  it will go until
                      we reach eof */
    type_code = lexi ();   /* lexi reads one token.  The actual
                      characters read are stored in "token".
                      lexi returns a code indicating the type
                      of token */

    /*
     * The following code moves everything following an if (), while (),
     * else, etc. up to the start of the following stmt to a buffer.  This
     * allows proper handling of both kinds of brace placement.
     */

    flushed_nl = false;
    while (search_brace) { /* if we scanned an if(), while(), etc., we
                      might need to copy stuff into a buffer
    *//* we must loop, copying stuff into save_com, until we find the
       start of the stmt which follows the if, or whatever */
        switch (type_code) {
        case newline:
            ++line_no;
            flushed_nl = true;
        case form_feed:
            break;     /* form feeds and newlines found here will
                      be ignored */

        case lbrace:   /* this is a brace that starts the compound
                      stmt */
            if (sc_end == 0) {
            /* ignore buffering if a comment wasn't stored up */
            search_brace = false;
            goto check_type;
            }

            if (btype_2) {
            save_com[0] = '{';
            /* we either want to put the brace right after the if
            */
            goto sw_buffer;
            /* go to common code to get out of this loop */
            }

        default:       /* it is the start of a normal statment */
            if (flushed_nl)
                   /* if we flushed a newline, make sure it is
                      put back */
            force_nl = true;

            if (sc_end == 0) {
            /* ignore buffering if comment wasn't saved up */
            search_brace = false;
            goto check_type;
            }

            if (force_nl) {
            /* if we should insert a nl here, put it into the
               buffer */
            force_nl = false;
            --line_no;
            /* this will be re-increased when the nl is read from
               the buffer */
            *sc_end++ = '\n';
            *sc_end++ = ' ';
            if (verbose && !flushed_nl)
                   /* print error msg if the line was not
                      already broken */
                printf ("%d: Line broken\n", line_no);
            flushed_nl = false;
            }

            for (t_ptr = token; *t_ptr; ++t_ptr)
            *sc_end++ = *t_ptr;
        /* copy token into temp buffer */

        sw_buffer:
            search_brace = false;
        /* stop looking for start of stmt */
            bp_save = buf_ptr;
        /* save current input buffer */
            be_save = buf_end;
            buf_ptr = save_com;
        /* fix so that subsequent calls to lexi will take tokens
           out of save_com */
            *sc_end++ = ' ';
        /* add trailing blank, just in case */
            buf_end = sc_end;
            sc_end = 0;
            break;

        case comment:  /* we have a comment, so we must copy it
                      into the buffer */
            if (sc_end == 0) {
            /* if this is the first comment, we must set up the
               buffer */
            save_com[0] = save_com[1] = ' ';
            sc_end = &(save_com[2]);
            }
            else {
            *sc_end++ = '\n';
            /* add newline between comments */
            *sc_end++ = ' ';
            --line_no;
            }

            *sc_end++ = '/';
        /* copy in start of comment */
            *sc_end++ = '*';

            for (;;) { /* loop until we get to the end of the
                      comment */
            *sc_end = *buf_ptr++;
            if (buf_ptr >= buf_end)
                fill_buffer ();

            if (*sc_end++ == '*' && *buf_ptr == '/')
                break;
            /* we are at end of comment */

            if (sc_end >= &(save_com[sc_size])) {
            /* check for temp buffer overflow */
                printf ("%d: Internal buffer overflow.\n",
                    line_no);
                printf ("Move big comment from right after if,\
 while, or whatever.\n");
                exit ();
            }
            }

            *sc_end++ = '/';
        /* add ending slash */
            if (++buf_ptr >= buf_end)/* get past / in buffer */
            fill_buffer ();
            break;
        }               /* end of switch */

        if (type_code != 0)/* we must make this check, just in case
                      there was an unexpected EOF */
        type_code = lexi ();
    /* read another token */
    }               /* end of while (serach_brace) */
check_type:

    if (type_code == 0) {  /* we got eof */
        if (s_lab != e_lab || s_code != e_code
            || s_com != e_com)/* must dump end of line */
        dump_line ();
        if (i_l_follow != 0)/* check for balanced braces */
        printf ("%d too few }'s\n", i_l_follow);

#ifdef dolog               /* only include this stuff if we want to
                      keep a log */
        log_fid = open ("/mnt/net/willcox/indent/indent_log", 1);
    /* open the log file */
        if (log_fid >= 0) {
        seek (log_fid, 0, 2);
        /* point to end of log */
        time (logent.tvec);
        /* get current time */
        logent.inp = input;
        /* set up the log entry */
        logent.outp = output;
        logent.nout = out_lines;
        logent.ncom = out_coms;
        logent.wcom = com_lines;
        logent.wcode = code_lines;
        logent.mc = max_col;
        logent.ci = com_ind;
        logent.inds = ind_size;
        logent.dci = decl_com_ind;
        logent.verb = verbose;
        logent.ljus = ljust_decl;
        logent.lvcom = leave_comma;
        logent.unin = unindent_displace;
        logent.uid = getuid ();
        logent.bropt = btype_2;
        write (log_fid, &logent, sizeof logent);
        }
#endif
        if (verbose) {
        printf ("There were %d output lines and %d comments\n",
            out_lines, out_coms);
        printf ("(Lines with comments)/(Lines with code): %6.3f\n",
            (1.0 * com_lines) / code_lines);
        }

        exit ();
    }

    if (
        (type_code != comment) &&
        (type_code != newline) &&
        (type_code != preesc) &&
        (type_code != form_feed)) {
        if (
            force_nl
            &&
            (type_code != semicolon) &&
            (
            type_code != lbrace
            ||
            !btype_2
            )) {       /* we should force a broken line here */
        if (verbose && !flushed_nl)
            printf ("%d: Line broken\n", line_no);
        flushed_nl = false;
        dump_line ();
        want_blank = false;
        /* don't insert blank at line start */
        force_nl = false;
        }

        in_stmt = true;    /* turn on flag which causes an extra level
                      of indentation. this is turned off by a
                      ; or } */
        if (s_com != e_com) {
        /* the turkey has embedded a comment in a line. fix it */
        *e_code++ = ' ';
        for (t_ptr = s_com; *t_ptr; ++t_ptr)
            *e_code++ = *t_ptr;
        *e_code++ = ' ';
        *e_code = '\0';/* null terminate code sect */
        want_blank = false;
        e_com = s_com;
        }
    }
    else
        if (type_code != comment)
                   /* preserve force_nl thru a comment */
        force_nl = false;
    /* cancel forced newline after newline, form feed, etc */



    /*----------------------------------------------------*\
    |   do switch on type of token scanned
    \*----------------------------------------------------*/
    switch (type_code) {   /* now, decide what to do with the token */

        case form_feed:    /* found a form feed in line */
        use_ff = true; /* a form feed is treated much like a
                      newline */
        dump_line ();
        want_blank = false;
        break;

        case newline:
        dump_line ();
        ++line_no;     /* keep track of input line number */
        want_blank = false;
        break;

        case lparen:       /* got a ( or [ */
        ++p_l_follow;  /* count parens to make Healy happy */
        if (want_blank && *token != '[')
                   /* don't put space in front of square
                      bracket */
            *e_code++ = ' ';

        if (in_decl)
            while ((e_code - s_code) < dec_ind)
            *e_code++ = ' ';

        *e_code++ = token[0];
        want_blank = false;
        if (in_or_st && *token == '(') {
        /* this is a kluge to make sure that declarations will be
           aaigned right if proc decl has an explicit type on it,
           i.e. "int a(x) {..." */
            parse (semicolon);
        /* I said this was a kluge... */
            in_or_st = false;
        /* turn off flag for structure decl or initialization */
        }

        break;

        case rparen:       /* got a ) or ] */
        if (--p_l_follow < 0) {
            p_l_follow = 0;
            printf ("%d: Extra %c\n", line_no, *token);
        }

        if (e_code == s_code)/* if the paren starts the line */
            paren_level = p_l_follow;
        /*    then indent it */

        *e_code++ = token[0];
        want_blank = true;

        if (sp_sw && (p_l_follow == 0)) {
        /* check for end of if (...), or some such */
            sp_sw = false;
            force_nl = true;
        /* must force newline after if */
            last_u_d = true;
        /* inform lexi that a following operator is unary */
            in_stmt = false;
        /* don't use stmt continuation indentation */

            parse (hd_type);
        /* let parser worry about if, or whatever */
        }

        search_brace = btype_2;
        /* this should insure that constructs such as main(){... and
           int[]{... have their braces put in the right place */
        break;

        case unary_op:     /* this could be any unary operation */
        if (want_blank)
            *e_code++ = ' ';

        if (in_decl) { /* if this is a unary op in a *//*
                      declaration, we should indent this token
                      */
            for (i = 0; token[i]; ++i);
        /* find length of token */
            while ((e_code - s_code) < (dec_ind - i))
            *e_code++ = ' ';
        /* pad it */
        }

        for (t_ptr = token; *t_ptr; ++t_ptr)
            *e_code++ = *t_ptr;
        /* move the token to buffer */
        want_blank = false;
        break;

        case binary_op:    /* any binary operation */
    do_binary:
        if (want_blank)
            *e_code++ = ' ';
        for (t_ptr = token; *t_ptr; ++t_ptr)
            *e_code++ = *t_ptr;
        /* move the operator */
        want_blank = true;
        break;

        case postop:       /* got a trailing ++ or -- */
        *e_code++ = token[0];
        *e_code++ = token[1];
        want_blank = true;
        break;

        case question:     /* got a ? */
        squest++;      /* this will be used when a later colon
                      appears so we can distinguish the
                      <c>?<n>:<n> construct */
        if (want_blank)
            *e_code++ = ' ';
        *e_code++ = '?';
        want_blank = true;
        break;

        case casestmt:     /* got word 'case' or 'default' */
        scase = true;  /* so we can process the later colon
                      properly */
        if (want_blank)
            *e_code++ = ' ';
        for (t_ptr = token; *t_ptr; ++t_ptr)
            *e_code++ = *t_ptr;
        want_blank = true;
        break;

        case colon:        /* got a ':' */
        if (squest > 0) {
        /* it is part of the <c>?<n>: <n> construct */
            --squest;
            if (want_blank)
            *e_code++ = ' ';
            *e_code++ = ':';
            want_blank = true;
            break;
        }

        in_stmt = false;
        /* seeing a label does not imply we are in a stmt */
        for (t_ptr = s_code; *t_ptr; ++t_ptr)
            *e_lab++ = *t_ptr;
        /* turn everything so far into a label */
        e_code = s_code;
        *e_lab++ = ':';
        *e_lab++ = ' ';
        *e_lab = '\0';

        force_nl = pcase = scase;
        /* pcase will be used by dump_line to decide how to indent the
           label. force_nl will force a case n: to be on a line by
           itself */
        scase = false;
        want_blank = false;
        break;

        case semicolon:    /* got a ';' */
        in_or_st = false;
        /* we are not in an initialization or structure declaration */
        scase = false; /* these will only need resetting in a
                      error */
        squest = 0;

        if (in_decl && s_code == e_code)
                   /* align this in a declaration */
            while ((e_code - s_code) < (dec_ind - 1))
            *e_code++ = ' ';

        in_decl = (dec_nest > 0);
        /* if we were in a first level structure declaration, we
           aren't any more */

        if ((!sp_sw || hd_type != forstmt) && p_l_follow > 0) {
        /* This should be true iff there were unbalanced parens in
           the stmt.  It is a bit complicated, because the
           semicolon might be in a for stmt */
            printf ("%d: Unbalanced parens\n", line_no);
            p_l_follow = 0;
            if (sp_sw) {
            /* this is a check for a if, while, etc. with
               unbalanced parens */
            sp_sw = false;
            parse (hd_type);
            /* don't lose the if, or whatever */
            }
        }

        *e_code++ = ';';
        want_blank = true;
        in_stmt = (p_l_follow > 0);
        /* we are no longer in the middle of a stmt */

        if (!sp_sw) {  /* if not if for (;;) */
            parse (semicolon);
        /* let parser know about end of stmt */
            force_nl = true;
        /* force newline after a end of stmt */
        }

        break;

        case lbrace:       /* got a { */
        in_stmt = false;
        /* don't indent the { */
        force_nl = true;
        /* force other stuff on same line as { onto new line */

        if (s_code != e_code && !btype_2) {
        /* bracket is not alone on line */
            if (verbose)
            printf ("%d: Line broken\n", line_no);
            dump_line ();
            want_blank = false;
        }

        if (p_l_follow > 0) {
        /* check for preceeding unbalanced parens */
            printf ("%d: Unbalanced parens\n", line_no);
            p_l_follow = 0;
            if (sp_sw) {
            /* check for unclosed if, for, etc. */
            sp_sw = false;
            parse (hd_type);
            ind_level = i_l_follow;
            }
        }

        if (s_code == e_code)
            ind_stmt = false;
        /* don't put extra indentation on line with '{' */
        if (in_decl && in_or_st) {
        /* this is either a structure declaration or an init */
            di_stack[dec_nest++] = dec_ind;
            dec_ind = 0;
        }
        else
            decl_on_line = false;
        /* we can't be in the middle of a declaration, so don't do
           special indentation of comments */

        parse (lbrace);/* let parser know about this */
        if (want_blank)/* put a blank before { if { is not at
                      start of line */
            *e_code++ = ' ';
        want_blank = false;
        *e_code++ = '{';
        break;

        case rbrace:       /* got a } */
        if (p_l_follow) {
        /* check for unclosed if, for, else. */
            printf ("%d: Unbalanced parens\n", line_no);
            p_l_follow = 0;
            sp_sw = false;
        }

        if (s_code != e_code) {
        /* } must be first on line */
            if (verbose)
            printf ("%d: Line broken\n", line_no);
            dump_line ();
        }

        *e_code++ = '}';
        want_blank = true;
        in_stmt = ind_stmt = false;

        if (dec_nest > 0) {
        /* we are in multi-level structure declaration */
            dec_ind = di_stack[--dec_nest];
            in_decl = true;
        }

        parse (rbrace);/*   let parser know about this */
        break;

        case swstmt:       /* got keyword "switch" */
        sp_sw = true;
        hd_type = swstmt;
        /* keep this for when we have seen the expression */
        goto copy_id;  /* go move the token into buffer */

        case sp_paren:     /* token is if, while, for */
        sp_sw = true;  /* the interesting stuff is done after the
                      expression is scanned */
        hd_type = (*token == 'i' ? ifstmt :
            (*token == 'w' ? whilestmt : forstmt));
        /* remember the type of header for later use by parser */
        goto copy_id;  /* copy the token into line */

        case sp_nparen:    /* got else, do */
        in_stmt = false;
        if (e_code != s_code) {
        /* make sure this starts a line */
            if (verbose)
            printf ("%d: Line broken\n", line_no);
            dump_line ();
            want_blank = false;
        }

        force_nl = true;
        /* also, following stuff must go onto new line */
        parse (*token == 'e' ? elselit : dolit);
        /* pass token on to parser */
        goto copy_id;  /* move the token into line */

        case decl:            /* we have a declaration type (int,
                      register, etc.) */
        parse (decl);  /* let parser worry about indentation */
        in_or_st = true;
        /* this might be a structure or initialization declaration */
        in_decl = decl_on_line = true;
        for (i = 0; token[i++];);
        /* get length of token */

        if (i <= 3)
            i = 4;

        dec_ind = ((e_code - s_code + i) / ind_size + 1) * ind_size;
        /* this will tell us how far to indent subsequent identifiers
        */
        goto copy_id;

        case ident:        /* got an identifier or constant */
        if (in_decl) { /* if we are in a declaration, we must
                      indent identifier */
            if (want_blank)
            *e_code++ = ' ';
            want_blank = false;

            while ((e_code - s_code) < dec_ind)
            *e_code++ = ' ';
        }
        else
            if (sp_sw && p_l_follow == 0) {
            /* check for if expr w/o parens *//* this will make
               JRM's obsurd "for ever" statements work */
            sp_sw = false;
            force_nl = true;
            last_u_d = true;
            in_stmt = false;
            parse (hd_type);
            }

    copy_id:
        if (want_blank)
            *e_code++ = ' ';
        for (t_ptr = token; *t_ptr; ++t_ptr)
            *e_code++ = *t_ptr;
        want_blank = true;
        break;

        case period:       /* treat a period kind of like a binary
                      operation */
        *e_code++ = '.';
        /* move the period into line */
        want_blank = false;
        /* don't put a blank after a period */
        break;

        case comma:
        want_blank = (s_code != e_code);
        /* only put blank after comma if comma does not start the line
           */
        if (in_decl)   /* align these in a declaration */
            while ((e_code - s_code) < (dec_ind - 1))
            *e_code++ = ' ';

        *e_code++ = ',';

        if (break_comma && p_l_follow == 0 && !leave_comma)
            force_nl = true;

        break;

        case preesc:       /* got the character '#' */
        if (
            (s_com != e_com) ||
            (s_lab != e_lab) ||
            (s_code != e_code)) {
        /* true iff the '#' was not at start of the line */
            printf ("%d: What is this # doing here?\n", line_no);
            goto do_binary;
        /* treat it as a binary operator */
        }

        *e_lab++ = '#';/* move whole line to 'label' buffer */
        while (*buf_ptr != '\n') {
            *e_lab = *buf_ptr++;
            if (buf_ptr >= buf_end)
            fill_buffer ();

            if (*e_lab++ == '/' && *buf_ptr == '*') {
            /* check for comment on preprocessor line */
            e_lab -= 2;
            /* skip back over slash */
            while (*e_lab == '\t' || *e_lab == ' ')
                --e_lab;
            /* strip off trailing blanks and tabs */
            *(++e_lab) = '\0';
            /* null terminate the line */
            if (++buf_ptr >= buf_end)
                   /* space past start of comment */
                fill_buffer ();
            col_1 = false;
            /* don't let pr_comment think that this comment starts
               in column 1 */
            decl_on_line = true;
            /* treat this as a declaration for comment placement
               purposes */
            goto proc_comment;
            /* go process the comment */
            }
        }

        *e_lab = '\0'; /* null terminate line */
        pcase = false;
        break;           /* subsequent processing of the newline
                      character will cause the line to be
                      printed */

        case comment:      /* we have gotten a /*  this is a biggie */
    proc_comment:
        pr_comment ();
        break;
    }               /* end of big switch stmt */

    *e_code = '\0';           /* make sure code section is null
                      terminated */

    }                   /* end of main while (1) loop */
};

/*
 * copy input file to backup file
 * if in_name is /blah/blah/blah/file, then backup file
 * will be ".Bfile"
 * then make the backup file the input and original
 * input file the output
 */
bakcopy () {
    int     n,
            bakchn;
    char    buff[512];
    register char  *p;

 /* construct file name .Bfile */
 /* RPH - fix backup file name - .Bfile is not legal for CP/M.  will
    instead create a name.BAK file like ED. */
    strcpy(bakfile,in_name);    /* copy whole thing over first */
    /* skip to end of name or of string */
    for (p = bakfile; *p != '\0' && *p != '.' ; p++);
    if (*p == '\0') *p = '.';    /* add dot to typeless file name */
    p++;    /* skip over dot */
    strcpy(p,"BAK");    /* create file name */

 /* copy in_name to backup file */
    bakchn = creat (bakfile, 0600);
    if (bakchn < 0) {
    perror("indent");
    printf ("can't create backup file \"%s\"\n", bakfile);
    exit ();
    }
    while (n = read (input, buff, 512))
    write (bakchn, buff, n);
    close (bakchn);
    close (input);

 /* re-open backup file as the input file */
    input = open (bakfile, 0);
    if (input < 0) {
    perror("indent");
    printf ("can't re-open backup file\n");
    exit ();
    }

 /* now the original input file will be the output */
    output = creat (in_name, 0644);
    if (output < 0) {
    perror("indent");
    printf ("can't create %s\n", in_name);
    unlink (bakfile);
    exit ();
    }
}


set_option (arg)
char   *arg;
{
    register    j;
    for (j = 0; options[j].str != 0; ++j) {
                   /* look thru list of possible options */
    if (eqin (options[j].str, arg)) {
        set_var (j, arg);
        break;           /* get out of for loop */
    }
    }

    if (options[j].str == 0) { /* illegal arg given */
    printf ("Unknown parameter: %s\n", arg);
    exit ();
    }
}


set_var (j, arg)
char   *arg;
{
    switch (options[j].code) {
    case 1:            /* have -lnnn */
        max_col = atoi (&arg[2]);
        break;
    case 2:            /* have -cnnn */
        com_ind = atoi (&arg[2]);
        break;
    case 3:            /* have -innn */
        ind_size = atoi (&arg[2]);
        break;
    case 4:            /* have -cdnnn */
        decl_com_ind = atoi (&arg[3]);
        break;
    case 5:            /* have -v */
        verbose = true;
        break;
    case 6:            /* have -nv */
        verbose = false;
        break;
    case 7:            /* have -dj */
        ljust_decl = true;
        break;
    case 8:            /* have -ndj */
        ljust_decl = false;
        break;
    case 9:            /* -nbc */
        leave_comma = true;
        break;
    case 10:            /* -bc */
        leave_comma = false;
        break;
    case 13:            /* -dnnn */
        unindent_displace = atoi (&arg[2]);
        break;
    case 14:            /* -br */
        btype_2 = true;
        break;
    case 15:            /* -bl */
        btype_2 = false;
        break;
    case 16:
        if(input<0) input = 0;
        if(output<0) output = 1;
        break;
    }
}


/*
 * GETPRO - get profile file
 * profile file is max 127 characters
 */
getpro (name, buf)
char   *name,               /* profile file name, as in '.indent.pro'
                   */
       *buf;               /* will receive contents of .pro file */
{
    register    chn,
                n;
    char    file[64];

    file[0] = 0;
/*  WHN 10/30/83  VAX/VMS file name time (CP/M-68k too - RPH)
    strcat (file, getenv ("HOME"));
    strcat (file, "/");
*/
    strcat (file, name);
    chn = open (file, 0);
    if (chn < 0)
    return (-1);
    n = read (chn, buf, 127);
    if (n < 0)
    return (-1);
    buf[n--] = 0;           /* null terminate line */
    if (buf[n] == '\n')
    buf[n] = 0;
    close (chn);
    return (0);
}


/*
 * strip off arguments in a string:
 * p is address of a character pointer
 * nextchr returns pointer to front of first arg
 * arg is null terminated.
 * p is reset to after arg for subsequent calls
 */
char   *nxtarg (p)
char  **p;
{
    register char  *f,
                   *b;
    f = b = *p;
    while (*f && (*f == ' ' || *f == '\t'))
    f++;
    while (*b && (*b != ' ' && *b != '\t'))
    b++;
    if (*b != 0)
    *b++ = 0;
    *p = b;
    return (f);
}


set_profile () {
    char    line[128],
           *b;
    register char  *f;
    extern char *nxtarg ();
/*  WHN 10/30/83 VAX/VMS filename
    if (getpro (".indent.pro", line) < 0)
    return;
*/
/*  RPH 8/17/85 CP/M-68K filename */
/*  if (getpro ("SYS$LOGIN:INDENT.PRO", line) <0)*/  /* WHN 10/30/83 VAX/VMS */
/*    return;*/
    if (getpro("INDENT.PRO", line) < 0) return;    /* RPH 8/17/85 CP/M-68K */

    b = line;
    if(verbose) printf ("profile: %s\n", b);
    while (*(f = nxtarg (&b)))
    set_option (f);
}