Return to io.c CVS log

Up to [CSRG BSD Unix] / 43BSD / ucb / indent

Annotation of 43BSD/ucb/indent/io.c, revision 1.1

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

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.