indent.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	nitems(x)   (sizeof((x)) / sizeof((x)[0]))

Functions
void	add_typename (const char *)
void	alloc_typenames (void)
int	compute_code_target (void)
int	compute_label_target (void)
int	count_spaces (int, char *)
int	count_spaces_until (int, char *, char *)
int	lexi (struct parser_state *)
void	diag2 (int, const char *)
void	diag3 (int, const char *, int)
void	diag4 (int, const char *, int, int)
void	dump_line (void)
int	lookahead (void)
void	lookahead_reset (void)
void	fill_buffer (void)
void	parse (int)
void	pr_comment (void)
void	set_defaults (void)
void	set_option (char *)
void	set_profile (const char *)

Macro Definition Documentation

nitems

#define nitems

(

x

)

(sizeof((x)) / sizeof((x)[0]))

Definition at line 31 of file indent.h.

Function Documentation

add_typename()

void add_typename

(

const char *

key

)

Definition at line 687 of file lexi.c.

{
    int comparison;
    const char *copy;
 
    if (typename_top + 1 >= typename_count) {
    typenames = realloc((void *)typenames,
        sizeof(typenames[0]) * (typename_count *= 2));
    if (typenames == NULL)
        err(1, NULL);
    }
    if (typename_top == -1)
    typenames[++typename_top] = copy = strdup(key);
    else if ((comparison = strcmp(key, typenames[typename_top])) >= 0) {
    /* take advantage of sorted input */
    if (comparison == 0)    /* remove duplicates */
        return;
    typenames[++typename_top] = copy = strdup(key);
    }
    else {
    int p;
 
    for (p = 0; (comparison = strcmp(key, typenames[p])) > 0; p++)
        /* find place for the new key */;
    if (comparison == 0)    /* remove duplicates */
        return;
    memmove(&typenames[p + 1], &typenames[p],
        sizeof(typenames[0]) * (++typename_top - p));
    typenames[p] = copy = strdup(key);
    }
 
    if (copy == NULL)
    err(1, NULL);
}

References err(), sort-test::key, realloc, typename_count, typename_top, and typenames.

Referenced by add_typedefs_from_file(), and set_option().

alloc_typenames()

void alloc_typenames

(

void

)

Definition at line 677 of file lexi.c.

{
 
    typenames = (const char **)malloc(sizeof(typenames[0]) *
        (typename_count = 16));
    if (typenames == NULL)
    err(1, NULL);
}

References err(), malloc, typename_count, and typenames.

Referenced by main().

compute_code_target()

int compute_code_target

(

void

)

Definition at line 223 of file io.c.

{
    int target_col = ps.ind_size * ps.ind_level + 1;
 
    if (ps.paren_level)
    if (!lineup_to_parens)
        target_col += continuation_indent
        * (2 * continuation_indent == ps.ind_size ? 1 : ps.paren_level);
    else if (lineup_to_parens_always)
        target_col = paren_target;
    else {
        int w;
        int t = paren_target;
 
        if ((w = count_spaces(t, s_code) - max_col) > 0
            && count_spaces(target_col, s_code) <= max_col) {
        t -= w + 1;
        if (t > target_col)
            target_col = t;
        }
        else
        target_col = t;
    }
    else if (ps.ind_stmt)
    target_col += continuation_indent;
    return target_col;
}

References continuation_indent, count_spaces(), parser_state::ind_level, parser_state::ind_size, parser_state::ind_stmt, lineup_to_parens, lineup_to_parens_always, max_col, parser_state::paren_level, paren_target, ps, and s_code.

Referenced by dump_line(), main(), and pr_comment().

compute_label_target()

int compute_label_target

(

void

)

Definition at line 252 of file io.c.

{
    return
    ps.pcase ? (int) (case_ind * ps.ind_size) + 1
    : *s_lab == '#' ? 1
    : ps.ind_size * (ps.ind_level - label_offset) + 1;
}

References case_ind, parser_state::ind_level, parser_state::ind_size, label_offset, parser_state::pcase, ps, and s_lab.

Referenced by dump_line(), and pr_comment().

count_spaces()

int count_spaces	(	int	cur,
		char *	buffer
	)

Definition at line 550 of file io.c.

{
    return (count_spaces_until(cur, buffer, NULL));
}

References count_spaces_until(), and cur.

Referenced by compute_code_target(), dump_line(), and pr_comment().

count_spaces_until()

int count_spaces_until	(	int	cur,
		char *	buffer,
		char *	end
	)

Definition at line 517 of file io.c.

{
    char *buf;      /* used to look thru buffer */
 
    for (buf = buffer; *buf != '\0' && buf != end; ++buf) {
    switch (*buf) {
 
    case '\n':
    case 014:       /* form feed */
        cur = 1;
        break;
 
    case '\t':
        cur = tabsize * (1 + (cur - 1) / tabsize) + 1;
        break;
 
    case 010:       /* backspace */
        --cur;
        break;
 
    default:
        ++cur;
        break;
    }           /* end of switch */
    }               /* end of for loop */
    return (cur);
}

References buf, cur, and tabsize.

Referenced by count_spaces(), main(), and pr_comment().

diag2()

void diag2	(	int	level,
		const char *	msg
	)

Definition at line 590 of file io.c.

{
    if (level)
    found_err = 1;
    if (output == stdout) {
    fprintf(stdout, "/**INDENT** %s@%d: ", level == 0 ? "Warning" : "Error", line_no);
    fprintf(stdout, "%s", msg);
    fprintf(stdout, " */\n");
    }
    else {
    fprintf(stderr, "%s@%d: ", level == 0 ? "Warning" : "Error", line_no);
    fprintf(stderr, "%s", msg);
    fprintf(stderr, "\n");
    }
}

References found_err, fprintf, line_no, output, and generate_unaccent_rules::stdout.

Referenced by lexi(), main(), and parse().

diag3()

void diag3	(	int	level,
		const char *	msg,
		int	a
	)

Definition at line 573 of file io.c.

{
    if (level)
    found_err = 1;
    if (output == stdout) {
    fprintf(stdout, "/**INDENT** %s@%d: ", level == 0 ? "Warning" : "Error", line_no);
    fprintf(stdout, msg, a);
    fprintf(stdout, " */\n");
    }
    else {
    fprintf(stderr, "%s@%d: ", level == 0 ? "Warning" : "Error", line_no);
    fprintf(stderr, msg, a);
    fprintf(stderr, "\n");
    }
}

References a, found_err, fprintf, line_no, output, and generate_unaccent_rules::stdout.

Referenced by main().

diag4()

void diag4	(	int	level,
		const char *	msg,
		int	a,
		int	b
	)

Definition at line 556 of file io.c.

{
    if (level)
    found_err = 1;
    if (output == stdout) {
    fprintf(stdout, "/**INDENT** %s@%d: ", level == 0 ? "Warning" : "Error", line_no);
    fprintf(stdout, msg, a, b);
    fprintf(stdout, " */\n");
    }
    else {
    fprintf(stderr, "%s@%d: ", level == 0 ? "Warning" : "Error", line_no);
    fprintf(stderr, msg, a, b);
    fprintf(stderr, "\n");
    }
}

References a, b, found_err, fprintf, line_no, output, and generate_unaccent_rules::stdout.

dump_line()

void dump_line

(

void

)

Definition at line 61 of file io.c.

{               /* dump_line is the routine that actually
                 * effects the printing of the new source. It
                 * prints the label section, followed by the
                 * code section with the appropriate nesting
                 * level, followed by any comments */
    int cur_col,
                target_col = 1;
    static int  not_first_line;
 
    if (ps.procname[0]) {
    ps.ind_level = 0;
    ps.procname[0] = 0;
    }
    if (s_code == e_code && s_lab == e_lab && s_com == e_com) {
    if (suppress_blanklines > 0)
        suppress_blanklines--;
    else {
        ps.bl_line = true;
        n_real_blanklines++;
    }
    }
    else if (!inhibit_formatting) {
    suppress_blanklines = 0;
    ps.bl_line = false;
    if (prefix_blankline_requested && not_first_line) {
        if (swallow_optional_blanklines) {
        if (n_real_blanklines == 1)
            n_real_blanklines = 0;
        }
        else {
        if (n_real_blanklines == 0)
            n_real_blanklines = 1;
        }
    }
    while (--n_real_blanklines >= 0)
        putc('\n', output);
    n_real_blanklines = 0;
    if (ps.ind_level == 0)
        ps.ind_stmt = 0;    /* this is a class A kludge. dont do
                 * additional statement indentation if we are
                 * at bracket level 0 */
 
    if (e_lab != s_lab || e_code != s_code)
        ++code_lines;   /* keep count of lines with code */
 
 
    if (e_lab != s_lab) {   /* print lab, if any */
        if (comment_open) {
        comment_open = 0;
        fprintf(output, ".*/\n");
        }
        while (e_lab > s_lab && (e_lab[-1] == ' ' || e_lab[-1] == '\t'))
        e_lab--;
        *e_lab = '\0';
        cur_col = pad_output(1, compute_label_target());
        if (s_lab[0] == '#' && (strncmp(s_lab, "#else", 5) == 0
                    || strncmp(s_lab, "#endif", 6) == 0)) {
        char *s = s_lab;
        if (e_lab[-1] == '\n') e_lab--;
        do putc(*s++, output);
        while (s < e_lab && 'a' <= *s && *s<='z');
        while ((*s == ' ' || *s == '\t') && s < e_lab)
            s++;
        if (s < e_lab)
            fprintf(output, s[0]=='/' && s[1]=='*' ? "\t%.*s" : "\t/* %.*s */",
                (int)(e_lab - s), s);
        }
        else fprintf(output, "%.*s", (int)(e_lab - s_lab), s_lab);
        cur_col = count_spaces(cur_col, s_lab);
    }
    else
        cur_col = 1;    /* there is no label section */
 
    ps.pcase = false;
 
    if (s_code != e_code) { /* print code section, if any */
        char *p;
 
        if (comment_open) {
        comment_open = 0;
        fprintf(output, ".*/\n");
        }
        target_col = compute_code_target();
        {
        int i;
 
        for (i = 0; i < ps.p_l_follow; i++)
            if (ps.paren_indents[i] >= 0)
            ps.paren_indents[i] = -(ps.paren_indents[i] + target_col);
        }
        cur_col = pad_output(cur_col, target_col);
        for (p = s_code; p < e_code; p++)
        if (*p == (char) 0200)
            fprintf(output, "%d", target_col * 7);
        else
            putc(*p, output);
        cur_col = count_spaces(cur_col, s_code);
    }
    if (s_com != e_com) {       /* print comment, if any */
        int target = ps.com_col;
        char *com_st = s_com;
 
        target += ps.comment_delta;
        while (*com_st == '\t') /* consider original indentation in
                     * case this is a box comment */
        com_st++, target += tabsize;
        while (target <= 0)
        if (*com_st == ' ')
            target++, com_st++;
        else if (*com_st == '\t')
            target = tabsize * (1 + (target - 1) / tabsize) + 1, com_st++;
        else
            target = 1;
        if (cur_col > target) { /* if comment can't fit on this line,
                     * put it on next line */
        putc('\n', output);
        cur_col = 1;
        ++ps.out_lines;
        }
        while (e_com > com_st && isspace((unsigned char)e_com[-1]))
        e_com--;
        (void)pad_output(cur_col, target);
        fwrite(com_st, e_com - com_st, 1, output);
        ps.comment_delta = ps.n_comment_delta;
        ++ps.com_lines; /* count lines with comments */
    }
    if (ps.use_ff)
        putc('\014', output);
    else
        putc('\n', output);
    ++ps.out_lines;
    if (ps.just_saw_decl == 1 && blanklines_after_declarations) {
        prefix_blankline_requested = 1;
        ps.just_saw_decl = 0;
    }
    else
        prefix_blankline_requested = postfix_blankline_requested;
    postfix_blankline_requested = 0;
    }
    ps.decl_on_line = ps.in_decl;   /* if we are in the middle of a
                     * declaration, remember that fact for
                     * proper comment indentation */
    /* next line should be indented if we have not completed this stmt, and
     * either we are not in a declaration or we are in an initialization
     * assignment; but not if we're within braces in an initialization,
     * because that scenario is handled by other rules. */
    ps.ind_stmt = ps.in_stmt &&
    (!ps.in_decl || (ps.block_init && ps.block_init_level <= 0));
    ps.use_ff = false;
    ps.dumped_decl_indent = 0;
    *(e_lab = s_lab) = '\0';    /* reset buffers */
    *(e_code = s_code) = '\0';
    *(e_com = s_com = combuf + 1) = '\0';
    ps.ind_level = ps.i_l_follow;
    ps.paren_level = ps.p_l_follow;
    if (ps.paren_level > 0)
    paren_target = -ps.paren_indents[ps.paren_level - 1];
    not_first_line = 1;
}

References parser_state::bl_line, blanklines_after_declarations, parser_state::block_init, parser_state::block_init_level, code_lines, parser_state::com_col, parser_state::com_lines, combuf, parser_state::comment_delta, comment_open, compute_code_target(), compute_label_target(), count_spaces(), parser_state::decl_on_line, parser_state::dumped_decl_indent, e_code, e_com, e_lab, fprintf, i, parser_state::i_l_follow, parser_state::in_decl, parser_state::in_stmt, parser_state::ind_level, parser_state::ind_stmt, inhibit_formatting, parser_state::just_saw_decl, parser_state::n_comment_delta, n_real_blanklines, parser_state::out_lines, output, parser_state::p_l_follow, pad_output(), parser_state::paren_indents, parser_state::paren_level, paren_target, parser_state::pcase, postfix_blankline_requested, prefix_blankline_requested, parser_state::procname, ps, s_code, s_com, s_lab, suppress_blanklines, swallow_optional_blanklines, tabsize, and parser_state::use_ff.

Referenced by fill_buffer(), main(), and pr_comment().

fill_buffer()

void fill_buffer

(

void

)

Definition at line 346 of file io.c.

{               /* this routine reads stuff from the input */
    char *p;
    int i;
    FILE *f = input;
 
    if (bp_save != NULL) {  /* there is a partly filled input buffer left */
    buf_ptr = bp_save;  /* do not read anything, just switch buffers */
    buf_end = be_save;
    bp_save = be_save = NULL;
    lookahead_bp_save = NULL;
    if (buf_ptr < buf_end)
        return;     /* only return if there is really something in
                 * this buffer */
    }
    for (p = in_buffer;;) {
    if (p >= in_buffer_limit) {
        int size = (in_buffer_limit - in_buffer) * 2 + 10;
        int offset = p - in_buffer;
        in_buffer = realloc(in_buffer, size);
        if (in_buffer == NULL)
        errx(1, "input line too long");
        p = in_buffer + offset;
        in_buffer_limit = in_buffer + size - 2;
    }
    if (lookahead_start < lookahead_end) {
        i = (unsigned char) *lookahead_start++;
    } else {
        lookahead_start = lookahead_ptr = lookahead_end = lookahead_buf;
        if ((i = getc(f)) == EOF) {
        *p++ = ' ';
        *p++ = '\n';
        had_eof = true;
        break;
        }
    }
    if (i != '\0')
        *p++ = i;
    if (i == '\n')
        break;
    }
    buf_ptr = in_buffer;
    buf_end = p;
    if (p - in_buffer > 2 && p[-2] == '/' && p[-3] == '*') {
    if (in_buffer[3] == 'I' && strncmp(in_buffer, "/**INDENT**", 11) == 0)
        fill_buffer();  /* flush indent error message */
    else {
        int         com = 0;
 
        p = in_buffer;
        while (*p == ' ' || *p == '\t')
        p++;
        if (*p == '/' && p[1] == '*') {
        p += 2;
        while (*p == ' ' || *p == '\t')
            p++;
        if (p[0] == 'I' && p[1] == 'N' && p[2] == 'D' && p[3] == 'E'
            && p[4] == 'N' && p[5] == 'T') {
            p += 6;
            while (*p == ' ' || *p == '\t')
            p++;
            if (*p == '*')
            com = 1;
            else if (*p == 'O') {
            if (*++p == 'N')
                p++, com = 1;
            else if (*p == 'F' && *++p == 'F')
                p++, com = 2;
            }
            while (*p == ' ' || *p == '\t')
            p++;
            if (p[0] == '*' && p[1] == '/' && p[2] == '\n' && com) {
            if (s_com != e_com || s_lab != e_lab || s_code != e_code)
                dump_line();
            if (!(inhibit_formatting = com - 1)) {
                n_real_blanklines = 0;
                postfix_blankline_requested = 0;
                prefix_blankline_requested = 0;
                suppress_blanklines = 1;
            }
            }
        }
        }
    }
    }
    if (inhibit_formatting) {
    p = in_buffer;
    do
        putc(*p, output);
    while (*p++ != '\n');
    }
}

References be_save, bp_save, buf_end, buf_ptr, dump_line(), e_code, e_com, e_lab, errx(), fill_buffer(), had_eof, i, in_buffer, in_buffer_limit, inhibit_formatting, input, lookahead_bp_save, lookahead_buf, lookahead_end, lookahead_ptr, lookahead_start, n_real_blanklines, output, postfix_blankline_requested, prefix_blankline_requested, realloc, s_code, s_com, s_lab, size, and suppress_blanklines.

Referenced by fill_buffer(), lexi(), main(), and pr_comment().

lexi()

int lexi

(

struct parser_state *

state

)

Definition at line 216 of file lexi.c.

{
    int         unary_delim;    /* this is set to 1 if the current token
                 * forces a following operator to be unary */
    int         code;       /* internal code to be returned */
    char        qchar;      /* the delimiter character for a string */
 
    e_token = s_token;      /* point to start of place to save token */
    unary_delim = false;
    state->col_1 = state->last_nl;  /* tell world that this token started
                     * in column 1 iff the last thing
                     * scanned was a newline */
    state->last_nl = false;
 
    while (*buf_ptr == ' ' || *buf_ptr == '\t') {   /* get rid of blanks */
    state->col_1 = false;   /* leading blanks imply token is not in column
                 * 1 */
    if (++buf_ptr >= buf_end)
        fill_buffer();
    }
 
    /* Scan an alphanumeric token */
    if (chartype[*buf_ptr & 127] == alphanum ||
    (buf_ptr[0] == '.' && isdigit((unsigned char)buf_ptr[1]))) {
    /*
     * we have a character or number
     */
    struct templ *p;
 
    if (isdigit((unsigned char)*buf_ptr) ||
        (buf_ptr[0] == '.' && isdigit((unsigned char)buf_ptr[1]))) {
        int         seendot = 0,
                    seenexp = 0,
            seensfx = 0;
 
        /*
         * base 2, base 8, base 16:
         */
        if (buf_ptr[0] == '0' && buf_ptr[1] != '.') {
        int len;
 
        if (buf_ptr[1] == 'b' || buf_ptr[1] == 'B')
            len = strspn(buf_ptr + 2, "01") + 2;
        else if (buf_ptr[1] == 'x' || buf_ptr[1] == 'X')
            len = strspn(buf_ptr + 2, "0123456789ABCDEFabcdef") + 2;
        else
            len = strspn(buf_ptr + 1, "012345678") + 1;
        if (len > 0) {
            CHECK_SIZE_TOKEN(len);
            memcpy(e_token, buf_ptr, len);
            e_token += len;
            buf_ptr += len;
        }
        else
            diag2(1, "Unterminated literal");
        }
        else        /* base 10: */
        while (1) {
            if (*buf_ptr == '.') {
            if (seendot)
                break;
            else
                seendot++;
            }
            CHECK_SIZE_TOKEN(3);
            *e_token++ = *buf_ptr++;
            if (!isdigit((unsigned char)*buf_ptr) && *buf_ptr != '.') {
            if ((*buf_ptr != 'E' && *buf_ptr != 'e') || seenexp)
                break;
            else {
                seenexp++;
                seendot++;
                *e_token++ = *buf_ptr++;
                if (*buf_ptr == '+' || *buf_ptr == '-')
                *e_token++ = *buf_ptr++;
            }
            }
        }
 
        while (1) {
        CHECK_SIZE_TOKEN(2);
        if (!(seensfx & 1) && (*buf_ptr == 'U' || *buf_ptr == 'u')) {
            *e_token++ = *buf_ptr++;
            seensfx |= 1;
            continue;
        }
        if (!(seensfx & 2) && (strchr("fFlL", *buf_ptr) != NULL)) {
            if (buf_ptr[1] == buf_ptr[0])
                *e_token++ = *buf_ptr++;
            *e_token++ = *buf_ptr++;
            seensfx |= 2;
            continue;
        }
        break;
        }
    }
    else
        while (chartype[*buf_ptr & 127] == alphanum || *buf_ptr == BACKSLASH) {
        /* fill_buffer() terminates buffer with newline */
        if (*buf_ptr == BACKSLASH) {
            if (*(buf_ptr + 1) == '\n') {
            buf_ptr += 2;
            if (buf_ptr >= buf_end)
                fill_buffer();
            } else
                break;
        }
        CHECK_SIZE_TOKEN(1);
        /* copy it over */
        *e_token++ = *buf_ptr++;
        if (buf_ptr >= buf_end)
            fill_buffer();
        }
    *e_token = '\0';
 
    if (s_token[0] == 'L' && s_token[1] == '\0' &&
          (*buf_ptr == '"' || *buf_ptr == '\''))
        return (strpfx);
 
    while (*buf_ptr == ' ' || *buf_ptr == '\t') {   /* get rid of blanks */
        if (++buf_ptr >= buf_end)
        fill_buffer();
    }
    state->keyword = 0;
    if (state->last_token == structure && !state->p_l_follow) {
                /* if last token was 'struct' and we're not
                 * in parentheses, then this token
                 * should be treated as a declaration */
        state->last_u_d = true;
        return (decl);
    }
    /*
     * Operator after identifier is binary unless last token was 'struct'
     */
    state->last_u_d = (state->last_token == structure);
 
    p = bsearch(s_token,
        specials,
        sizeof(specials) / sizeof(specials[0]),
        sizeof(specials[0]),
        strcmp_type);
    if (p == NULL) {    /* not a special keyword... */
        char *u;
 
        /* ... so maybe a type_t or a typedef */
        if ((auto_typedefs && ((u = strrchr(s_token, '_')) != NULL) &&
            strcmp(u, "_t") == 0) || (typename_top >= 0 &&
          bsearch(s_token, typenames, typename_top + 1,
            sizeof(typenames[0]), strcmp_type))) {
        state->keyword = 4; /* a type name */
        state->last_u_d = true;
            goto found_typename;
        }
    } else {            /* we have a keyword */
        state->keyword = p->rwcode;
        state->last_u_d = true;
        switch (p->rwcode) {
        case 7:     /* it is a switch */
        return (swstmt);
        case 8:     /* a case or default */
        return (casestmt);
 
        case 3:     /* a "struct" */
        /* FALLTHROUGH */
        case 4:     /* one of the declaration keywords */
        found_typename:
        if (state->p_l_follow) {
            /* inside parens: cast, param list, offsetof or sizeof */
            state->cast_mask |= (1 << state->p_l_follow) & ~state->not_cast_mask;
        }
        if (state->last_token == period || state->last_token == unary_op) {
            state->keyword = 0;
            break;
        }
        if (p != NULL && p->rwcode == 3)
            return (structure);
        if (state->p_l_follow)
            break;
        return (decl);
 
        case 5:     /* if, while, for */
        return (sp_paren);
 
        case 6:     /* do, else */
        return (sp_nparen);
 
        case 10:        /* storage class specifier */
        return (storage);
 
        case 11:        /* typedef */
        return (type_def);
 
        default:        /* all others are treated like any other
                 * identifier */
        return (ident);
        }           /* end of switch */
    }           /* end of if (found_it) */
    if (*buf_ptr == '(' && state->tos <= 1 && state->ind_level == 0 &&
        state->in_parameter_declaration == 0 && state->block_init == 0) {
        if (is_func_definition(buf_ptr)) {
        strncpy(state->procname, token, sizeof state->procname - 1);
        if (state->in_decl)
            state->in_parameter_declaration = 1;
        return (funcname);
        }
    }
    /*
     * The following hack attempts to guess whether or not the current
     * token is in fact a declaration keyword -- one that has been
     * typedefd
     */
    else if (!state->p_l_follow && !state->block_init &&
        !state->in_stmt &&
        ((*buf_ptr == '*' && buf_ptr[1] != '=') ||
        isalpha((unsigned char)*buf_ptr)) &&
        (state->last_token == semicolon || state->last_token == lbrace ||
        state->last_token == rbrace)) {
        state->keyword = 4; /* a type name */
        state->last_u_d = true;
        return decl;
    }
    if (state->last_token == decl)  /* if this is a declared variable,
                     * then following sign is unary */
        state->last_u_d = true; /* will make "int a -1" work */
    return (ident);     /* the ident is not in the list */
    }               /* end of processing for alphanum character */
 
    /* Scan a non-alphanumeric token */
 
    CHECK_SIZE_TOKEN(3);        /* things like "<<=" */
    *e_token++ = *buf_ptr;      /* if it is only a one-character token, it is
                 * moved here */
    *e_token = '\0';
    if (++buf_ptr >= buf_end)
    fill_buffer();
 
    switch (*token) {
    case '\n':
    unary_delim = state->last_u_d;
    state->last_nl = true;  /* remember that we just had a newline */
    code = (had_eof ? 0 : newline);
 
    /*
     * if data has been exhausted, the newline is a dummy, and we should
     * return code to stop
     */
    break;
 
    case '\'':          /* start of quoted character */
    case '"':           /* start of string */
    qchar = *token;
    do {            /* copy the string */
        while (1) {     /* move one character or [/<char>]<char> */
        if (*buf_ptr == '\n') {
            diag2(1, "Unterminated literal");
            goto stop_lit;
        }
        CHECK_SIZE_TOKEN(2);
        *e_token = *buf_ptr++;
        if (buf_ptr >= buf_end)
            fill_buffer();
        if (*e_token == BACKSLASH) {    /* if escape, copy extra char */
            if (*buf_ptr == '\n')   /* check for escaped newline */
            ++line_no;
            *++e_token = *buf_ptr++;
            ++e_token;  /* we must increment this again because we
                 * copied two chars */
            if (buf_ptr >= buf_end)
            fill_buffer();
        }
        else
            break;  /* we copied one character */
        }           /* end of while (1) */
    } while (*e_token++ != qchar);
stop_lit:
    code = ident;
    break;
 
    case ('('):
    case ('['):
    unary_delim = true;
    code = lparen;
    break;
 
    case (')'):
    case (']'):
    code = rparen;
    break;
 
    case '#':
    unary_delim = state->last_u_d;
    code = preesc;
    break;
 
    case '?':
    unary_delim = true;
    code = question;
    break;
 
    case (':'):
    code = colon;
    unary_delim = true;
    break;
 
    case (';'):
    unary_delim = true;
    code = semicolon;
    break;
 
    case ('{'):
    unary_delim = true;
 
    /*
     * if (state->in_or_st) state->block_init = 1;
     */
    /* ?    code = state->block_init ? lparen : lbrace; */
    code = lbrace;
    break;
 
    case ('}'):
    unary_delim = true;
    /* ?    code = state->block_init ? rparen : rbrace; */
    code = rbrace;
    break;
 
    case 014:           /* a form feed */
    unary_delim = state->last_u_d;
    state->last_nl = true;  /* remember this so we can set 'state->col_1'
                 * right */
    code = form_feed;
    break;
 
    case (','):
    unary_delim = true;
    code = comma;
    break;
 
    case '.':
    unary_delim = false;
    code = period;
    break;
 
    case '-':
    case '+':           /* check for -, +, --, ++ */
    code = (state->last_u_d ? unary_op : binary_op);
    unary_delim = true;
 
    if (*buf_ptr == token[0]) {
        /* check for doubled character */
        *e_token++ = *buf_ptr++;
        /* buffer overflow will be checked at end of loop */
        if (state->last_token == ident || state->last_token == rparen) {
        code = (state->last_u_d ? unary_op : postop);
        /* check for following ++ or -- */
        unary_delim = false;
        }
    }
    else if (*buf_ptr == '=')
        /* check for operator += */
        *e_token++ = *buf_ptr++;
    else if (*buf_ptr == '>') {
        /* check for operator -> */
        *e_token++ = *buf_ptr++;
        unary_delim = false;
        code = unary_op;
        state->want_blank = false;
    }
    break;          /* buffer overflow will be checked at end of
                 * switch */
 
    case '=':
    if (state->in_or_st)
        state->block_init = 1;
#ifdef undef
    if (chartype[*buf_ptr & 127] == opchar) {   /* we have two char assignment */
        e_token[-1] = *buf_ptr++;
        if ((e_token[-1] == '<' || e_token[-1] == '>') && e_token[-1] == *buf_ptr)
        *e_token++ = *buf_ptr++;
        *e_token++ = '=';   /* Flip =+ to += */
        *e_token = 0;
    }
#else
    if (*buf_ptr == '=') {/* == */
        *e_token++ = '=';   /* Flip =+ to += */
        buf_ptr++;
        *e_token = 0;
    }
#endif
    code = binary_op;
    unary_delim = true;
    break;
    /* can drop thru!!! */
 
    case '>':
    case '<':
    case '!':           /* ops like <, <<, <=, !=, etc */
    if (*buf_ptr == '>' || *buf_ptr == '<' || *buf_ptr == '=') {
        *e_token++ = *buf_ptr;
        if (++buf_ptr >= buf_end)
        fill_buffer();
    }
    if (*buf_ptr == '=')
        *e_token++ = *buf_ptr++;
    code = (state->last_u_d ? unary_op : binary_op);
    unary_delim = true;
    break;
 
    case '*':
    unary_delim = true;
    if (!state->last_u_d) {
        if (*buf_ptr == '=')
        *e_token++ = *buf_ptr++;
        code = binary_op;
        break;
    }
    while (*buf_ptr == '*' || isspace((unsigned char)*buf_ptr)) {
        if (*buf_ptr == '*') {
        CHECK_SIZE_TOKEN(1);
        *e_token++ = *buf_ptr;
        }
        if (++buf_ptr >= buf_end)
        fill_buffer();
    }
    code = unary_op;
    break;
 
    default:
    if (token[0] == '/' && *buf_ptr == '*') {
        /* it is start of comment */
        *e_token++ = '*';
 
        if (++buf_ptr >= buf_end)
        fill_buffer();
 
        code = comment;
        unary_delim = state->last_u_d;
        break;
    }
    while (*(e_token - 1) == *buf_ptr || *buf_ptr == '=') {
        /*
         * handle ||, &&, etc, and also things as in int *****i
         */
        CHECK_SIZE_TOKEN(1);
        *e_token++ = *buf_ptr;
        if (++buf_ptr >= buf_end)
        fill_buffer();
    }
    code = (state->last_u_d ? unary_op : binary_op);
    unary_delim = true;
 
 
    }               /* end of switch */
    if (buf_ptr >= buf_end) /* check for input buffer empty */
    fill_buffer();
    state->last_u_d = unary_delim;
    CHECK_SIZE_TOKEN(1);
    *e_token = '\0';        /* null terminate the token */
    return (code);
}

References alphanum, auto_typedefs, BACKSLASH, binary_op, buf_end, buf_ptr, casestmt, chartype, CHECK_SIZE_TOKEN, colon, comma, comment, decl, diag2(), e_token, fill_buffer(), form_feed, funcname, had_eof, ident, is_func_definition(), lbrace, len, line_no, lparen, newline, period, postop, preesc, question, rbrace, rparen, templ::rwcode, s_token, semicolon, sp_nparen, sp_paren, specials, storage, strcmp_type(), strpfx, structure, swstmt, token, type_def, typename_top, typenames, and unary_op.

Referenced by main().

lookahead()

int lookahead

(

void

)

Definition at line 275 of file io.c.

{
    /* First read whatever's in bp_save area */
    if (lookahead_bp_save != NULL && lookahead_bp_save < be_save)
    return (unsigned char) *lookahead_bp_save++;
    /* Else, we have to examine and probably fill the main lookahead buffer */
    while (lookahead_ptr >= lookahead_end) {
    int     i = getc(input);
 
    if (i == EOF)
        return i;
    if (i == '\0')
        continue;       /* fill_buffer drops nulls, and so do we */
 
    if (lookahead_end >= lookahead_buf_end) {
        /* Need to allocate or enlarge lookahead_buf */
        char       *new_buf;
        size_t  req;
 
        if (lookahead_buf == NULL) {
        req = 64;
        new_buf = malloc(req);
        } else {
        req = (lookahead_buf_end - lookahead_buf) * 2;
        new_buf = realloc(lookahead_buf, req);
        }
        if (new_buf == NULL)
        errx(1, "too much lookahead required");
        lookahead_start = new_buf + (lookahead_start - lookahead_buf);
        lookahead_ptr = new_buf + (lookahead_ptr - lookahead_buf);
        lookahead_end = new_buf + (lookahead_end - lookahead_buf);
        lookahead_buf = new_buf;
        lookahead_buf_end = new_buf + req;
    }
 
    *lookahead_end++ = i;
    }
    return (unsigned char) *lookahead_ptr++;
}

References be_save, errx(), i, input, lookahead_bp_save, lookahead_buf, lookahead_buf_end, lookahead_end, lookahead_ptr, lookahead_start, malloc, and realloc.

Referenced by is_func_definition().

lookahead_reset()

void lookahead_reset

(

void

)

Definition at line 320 of file io.c.

{
    /* Reset the main lookahead buffer */
    lookahead_ptr = lookahead_start;
    /* If bp_save isn't NULL, we need to scan that first */
    lookahead_bp_save = bp_save;
}

References bp_save, lookahead_bp_save, lookahead_ptr, and lookahead_start.

Referenced by is_func_definition().

parse()

void parse

(

int

tk

)

Definition at line 49 of file parse.c.

{
    int         i;
 
#ifdef debug
    printf("%2d - %s\n", tk, token);
#endif
 
    while (ps.p_stack[ps.tos] == ifhead && tk != elselit) {
    /* true if we have an if without an else */
    ps.p_stack[ps.tos] = stmt;  /* apply the if(..) stmt ::= stmt
                     * reduction */
    reduce();       /* see if this allows any reduction */
    }
 
 
    switch (tk) {       /* go on and figure out what to do with the
                 * input */
 
    case decl:          /* scanned a declaration word */
    ps.search_brace = btype_2;
    /* indicate that following brace should be on same line */
    if (ps.p_stack[ps.tos] != decl) {   /* only put one declaration
                         * onto stack */
        break_comma = true; /* while in declaration, newline should be
                 * forced after comma */
        ps.p_stack[++ps.tos] = decl;
        ps.il[ps.tos] = ps.i_l_follow;
 
        if (ps.ljust_decl) {/* only do if we want left justified
                 * declarations */
        ps.ind_level = 0;
        for (i = ps.tos - 1; i > 0; --i)
            if (ps.p_stack[i] == decl)
            ++ps.ind_level; /* indentation is number of
                     * declaration levels deep we are */
        ps.i_l_follow = ps.ind_level;
        }
    }
    break;
 
    case ifstmt:        /* scanned if (...) */
    if (ps.p_stack[ps.tos] == elsehead && ps.else_if)   /* "else if ..." */
        /*
         * Note that the stack pointer here is decremented, effectively
         * reducing "else if" to "if". This saves a lot of stack space
         * in case of a long "if-else-if ... else-if" sequence.
         */
        ps.i_l_follow = ps.il[ps.tos--];
    /* the rest is the same as for dolit and forstmt */
    /* FALLTHROUGH */
    case dolit:     /* 'do' */
    case forstmt:       /* for (...) */
    ps.p_stack[++ps.tos] = tk;
    ps.il[ps.tos] = ps.ind_level = ps.i_l_follow;
    ++ps.i_l_follow;    /* subsequent statements should be indented 1 */
    ps.search_brace = btype_2;
    break;
 
    case lbrace:        /* scanned { */
    break_comma = false;    /* don't break comma in an initial list */
    if (ps.p_stack[ps.tos] == stmt || ps.p_stack[ps.tos] == decl
        || ps.p_stack[ps.tos] == stmtl)
        ++ps.i_l_follow;    /* it is a random, isolated stmt group or a
                 * declaration */
    else {
        if (s_code == e_code) {
        /*
         * only do this if there is nothing on the line
         */
        --ps.ind_level;
        /*
         * it is a group as part of a while, for, etc.
         */
        if (ps.p_stack[ps.tos] == swstmt && ps.case_indent >= 1)
            --ps.ind_level;
        /*
         * for a switch, brace should be two levels out from the code
         */
        }
    }
 
    ps.p_stack[++ps.tos] = lbrace;
    ps.il[ps.tos] = ps.ind_level;
    ps.p_stack[++ps.tos] = stmt;
    /* allow null stmt between braces */
    ps.il[ps.tos] = ps.i_l_follow;
    break;
 
    case whilestmt:     /* scanned while (...) */
    if (ps.p_stack[ps.tos] == dohead) {
        /* it is matched with do stmt */
        ps.ind_level = ps.i_l_follow = ps.il[ps.tos];
        ps.p_stack[++ps.tos] = whilestmt;
        ps.il[ps.tos] = ps.ind_level = ps.i_l_follow;
    }
    else {          /* it is a while loop */
        ps.p_stack[++ps.tos] = whilestmt;
        ps.il[ps.tos] = ps.i_l_follow;
        ++ps.i_l_follow;
        ps.search_brace = btype_2;
    }
 
    break;
 
    case elselit:       /* scanned an else */
 
    if (ps.p_stack[ps.tos] != ifhead)
        diag2(1, "Unmatched 'else'");
    else {
        ps.ind_level = ps.il[ps.tos];   /* indentation for else should
                         * be same as for if */
        ps.i_l_follow = ps.ind_level + 1;   /* everything following should
                         * be in 1 level */
        ps.p_stack[ps.tos] = elsehead;
        /* remember if with else */
        ps.search_brace = btype_2 | ps.else_if;
    }
    break;
 
    case rbrace:        /* scanned a } */
    /* stack should have <lbrace> <stmt> or <lbrace> <stmtl> */
    if (ps.tos > 0 && ps.p_stack[ps.tos - 1] == lbrace) {
        ps.ind_level = ps.i_l_follow = ps.il[--ps.tos];
        ps.p_stack[ps.tos] = stmt;
    }
    else
        diag2(1, "Statement nesting error");
    break;
 
    case swstmt:        /* had switch (...) */
    ps.p_stack[++ps.tos] = swstmt;
    ps.cstk[ps.tos] = case_ind;
    /* save current case indent level */
    ps.il[ps.tos] = ps.i_l_follow;
    case_ind = ps.i_l_follow + ps.case_indent;  /* cases should be one
                             * level down from
                             * switch */
    ps.i_l_follow += ps.case_indent + 1;    /* statements should be two
                         * levels in */
    ps.search_brace = btype_2;
    break;
 
    case semicolon:     /* this indicates a simple stmt */
    break_comma = false;    /* turn off flag to break after commas in a
                 * declaration */
    ps.p_stack[++ps.tos] = stmt;
    ps.il[ps.tos] = ps.ind_level;
    break;
 
    default:            /* this is an error */
    diag2(1, "Unknown code to parser");
    return;
 
 
    }               /* end of switch */
 
    if (ps.tos >= nitems(ps.p_stack) - 1)
    errx(1, "Parser stack overflow");
 
    reduce();           /* see if any reduction can be done */
 
#ifdef debug
    for (i = 1; i <= ps.tos; ++i)
    printf("(%d %d)", ps.p_stack[i], ps.il[i]);
    printf("\n");
#endif
 
    return;
}

References break_comma, btype_2, case_ind, parser_state::case_indent, parser_state::cstk, decl, diag2(), dohead, dolit, e_code, parser_state::else_if, elsehead, elselit, errx(), forstmt, i, parser_state::i_l_follow, ifhead, ifstmt, parser_state::il, parser_state::ind_level, lbrace, parser_state::ljust_decl, nitems, parser_state::p_stack, printf, ps, rbrace, reduce(), s_code, parser_state::search_brace, semicolon, stmt, stmtl, swstmt, token, parser_state::tos, and whilestmt.

pr_comment()

void pr_comment

(

void

)

Definition at line 79 of file pr_comment.c.

{
    int         now_col;    /* column we are in now */
    int         adj_max_col;    /* Adjusted max_col for when we decide to
                 * spill comments over the right margin */
    char       *last_bl;    /* points to the last blank in the output
                 * buffer */
    char       *t_ptr;      /* used for moving string */
    int         break_delim = comment_delimiter_on_blankline;
    int         l_just_saw_decl = ps.just_saw_decl;
    adj_max_col = max_col;
    ps.just_saw_decl = 0;
    last_bl = NULL;     /* no blanks found so far */
    ps.box_com = false;     /* at first, assume that we are not in
                     * a boxed comment or some other
                     * comment that should not be touched */
    ++ps.out_coms;      /* keep track of number of comments */
 
    /* Figure where to align and how to treat the comment */
 
    if (ps.col_1 && !format_col1_comments) {    /* if comment starts in column
                         * 1 it should not be touched */
    ps.box_com = true;
    break_delim = false;
    ps.com_col = 1;
    }
    else {
    if (*buf_ptr == '-' || *buf_ptr == '*' ||
        (*buf_ptr == '\n' && !format_block_comments)) {
        ps.box_com = true;  /* A comment with a '-' or '*' immediately
                 * after the /+* is assumed to be a boxed
                 * comment. A comment with a newline
                 * immediately after the /+* is assumed to
                 * be a block comment and is treated as a
                 * box comment unless format_block_comments
                 * is nonzero (the default). */
        break_delim = false;
    }
    if ( /* ps.bl_line && */ (s_lab == e_lab) && (s_code == e_code)) {
        /* klg: check only if this line is blank */
        /*
         * If this (*and previous lines are*) blank, dont put comment way
         * out at left
         */
        ps.com_col = (ps.ind_level - ps.unindent_displace) * ps.ind_size + 1;
        adj_max_col = block_comment_max_col;
        if (ps.com_col <= 1)
        ps.com_col = 1 + !format_col1_comments;
    }
    else {
        int target_col;
        break_delim = false;
        if (s_code != e_code)
        target_col = count_spaces(compute_code_target(), s_code);
        else {
        target_col = 1;
        if (s_lab != e_lab)
            target_col = count_spaces(compute_label_target(), s_lab);
        }
        if (s_lab != e_lab && s_lab[1] == 'e' &&
        (strncmp(s_lab, "#endif", 6) == 0 ||
        strncmp(s_lab, "#else", 5) == 0))
        ps.com_col = else_endif_com_ind <= target_col
            ? target_col + 1 : else_endif_com_ind;
        else
        ps.com_col = ps.decl_on_line || ps.ind_level == 0
            ? ps.decl_com_ind : ps.com_ind;
        if (ps.com_col <= target_col)
        ps.com_col = tabsize * (1 + (target_col - 1) / tabsize) + 1;
        if (ps.com_col + 24 > adj_max_col)
        adj_max_col = ps.com_col + 24;
    }
    }
    if (ps.box_com) {
    /*
     * Find out how much indentation there was originally, because that
     * much will have to be ignored by pad_output() in dump_line(). This
     * is a box comment, so nothing changes -- not even indentation.
     *
     * The comment we're about to read usually comes from in_buffer,
     * unless it has been copied into save_com.
     */
    char *start;
 
    start = buf_ptr >= save_com && buf_ptr < save_com + sc_size ?
        sc_buf : in_buffer;
    ps.n_comment_delta = 1 - count_spaces_until(1, start, buf_ptr - 2);
    }
    else {
    ps.n_comment_delta = 0;
    while (*buf_ptr == ' ' || *buf_ptr == '\t')
        buf_ptr++;
    }
    ps.comment_delta = 0;
    *e_com++ = '/';     /* put '/' followed by '*' into buffer */
    *e_com++ = '*';
    if (*buf_ptr != ' ' && !ps.box_com)
    *e_com++ = ' ';
 
    /*
     * Don't put a break delimiter if this is a one-liner that won't wrap.
     */
    if (break_delim)
    for (t_ptr = buf_ptr; *t_ptr != '\0' && *t_ptr != '\n'; t_ptr++) {
        if (t_ptr >= buf_end)
        fill_buffer();
        if (t_ptr[0] == '*' && t_ptr[1] == '/') {
        if (adj_max_col >= count_spaces_until(ps.com_col, buf_ptr, t_ptr + 2))
            break_delim = false;
        break;
        }
    }
 
    if (break_delim) {
    char       *t = e_com;
    e_com = s_com + 2;
    *e_com = 0;
    if (blanklines_before_blockcomments && ps.last_token != lbrace)
        prefix_blankline_requested = 1;
    dump_line();
    e_com = s_com = t;
    if (!ps.box_com && star_comment_cont)
        *e_com++ = ' ', *e_com++ = '*', *e_com++ = ' ';
    }
 
    /* Start to copy the comment */
 
    while (1) {         /* this loop will go until the comment is
                 * copied */
    switch (*buf_ptr) { /* this checks for various spcl cases */
    case 014:       /* check for a form feed */
        CHECK_SIZE_COM(3);
        if (!ps.box_com) {  /* in a text comment, break the line here */
        ps.use_ff = true;
        /* fix so dump_line uses a form feed */
        dump_line();
        last_bl = NULL;
        if (!ps.box_com && star_comment_cont)
            *e_com++ = ' ', *e_com++ = '*', *e_com++ = ' ';
        while (*++buf_ptr == ' ' || *buf_ptr == '\t')
            ;
        }
        else {
        if (++buf_ptr >= buf_end)
            fill_buffer();
        *e_com++ = 014;
        }
        break;
 
    case '\n':
        if (had_eof) {  /* check for unexpected eof */
        printf("Unterminated comment\n");
        dump_line();
        return;
        }
        last_bl = NULL;
        CHECK_SIZE_COM(4);
        if (ps.box_com || ps.last_nl) { /* if this is a boxed comment,
                         * we dont ignore the newline */
        if (s_com == e_com)
            *e_com++ = ' ';
        if (!ps.box_com && e_com - s_com > 3) {
            dump_line();
            if (star_comment_cont)
            *e_com++ = ' ', *e_com++ = '*', *e_com++ = ' ';
        }
        dump_line();
        if (!ps.box_com && star_comment_cont)
            *e_com++ = ' ', *e_com++ = '*', *e_com++ = ' ';
        }
        else {
        ps.last_nl = 1;
        if (*(e_com - 1) == ' ' || *(e_com - 1) == '\t')
            last_bl = e_com - 1;
        /*
         * if there was a space at the end of the last line, remember
         * where it was
         */
        else {      /* otherwise, insert one */
            last_bl = e_com;
            *e_com++ = ' ';
        }
        }
        ++line_no;      /* keep track of input line number */
        if (!ps.box_com) {
        int         nstar = 1;
        do {        /* flush any blanks and/or tabs at start of
                 * next line */
            if (++buf_ptr >= buf_end)
            fill_buffer();
            if (*buf_ptr == '*' && --nstar >= 0) {
            if (++buf_ptr >= buf_end)
                fill_buffer();
            if (*buf_ptr == '/')
                goto end_of_comment;
            }
        } while (*buf_ptr == ' ' || *buf_ptr == '\t');
        }
        else if (++buf_ptr >= buf_end)
        fill_buffer();
        break;      /* end of case for newline */
 
    case '*':       /* must check for possibility of being at end
                 * of comment */
        if (++buf_ptr >= buf_end)   /* get to next char after * */
        fill_buffer();
        CHECK_SIZE_COM(4);
        if (*buf_ptr == '/') {  /* it is the end!!! */
    end_of_comment:
        if (++buf_ptr >= buf_end)
            fill_buffer();
        if (break_delim) {
            if (e_com > s_com + 3) {
            dump_line();
            }
            else
            s_com = e_com;
            *e_com++ = ' ';
        }
        if (e_com[-1] != ' ' && e_com[-1] != '\t' && !ps.box_com)
            *e_com++ = ' '; /* ensure blank before end */
        *e_com++ = '*', *e_com++ = '/', *e_com = '\0';
        ps.just_saw_decl = l_just_saw_decl;
        return;
        }
        else        /* handle isolated '*' */
        *e_com++ = '*';
        break;
    default:        /* we have a random char */
        now_col = count_spaces_until(ps.com_col, s_com, e_com);
        do {
        CHECK_SIZE_COM(1);
        *e_com = *buf_ptr++;
        if (buf_ptr >= buf_end)
            fill_buffer();
        if (*e_com == ' ' || *e_com == '\t')
            last_bl = e_com;    /* remember we saw a blank */
        ++e_com;
        now_col++;
        } while (!memchr("*\n\r\b\t", *buf_ptr, 6) &&
        (now_col <= adj_max_col || !last_bl));
        ps.last_nl = false;
        if (now_col > adj_max_col && !ps.box_com && e_com[-1] > ' ') {
        /*
         * the comment is too long, it must be broken up
         */
        if (last_bl == NULL) {
            dump_line();
            if (!ps.box_com && star_comment_cont)
            *e_com++ = ' ', *e_com++ = '*', *e_com++ = ' ';
            break;
        }
        *e_com = '\0';
        e_com = last_bl;
        dump_line();
        if (!ps.box_com && star_comment_cont)
            *e_com++ = ' ', *e_com++ = '*', *e_com++ = ' ';
        for (t_ptr = last_bl + 1; *t_ptr == ' ' || *t_ptr == '\t';
            t_ptr++)
            ;
        last_bl = NULL;
        /*
         * t_ptr will be somewhere between e_com (dump_line() reset)
         * and l_com. So it's safe to copy byte by byte from t_ptr
         * to e_com without any CHECK_SIZE_COM().
         */
        while (*t_ptr != '\0') {
            if (*t_ptr == ' ' || *t_ptr == '\t')
            last_bl = e_com;
            *e_com++ = *t_ptr++;
        }
        }
        break;
    }
    }
}

References blanklines_before_blockcomments, block_comment_max_col, parser_state::box_com, buf_end, buf_ptr, CHECK_SIZE_COM, parser_state::col_1, parser_state::com_col, parser_state::com_ind, comment_delimiter_on_blankline, parser_state::comment_delta, compute_code_target(), compute_label_target(), count_spaces(), count_spaces_until(), parser_state::decl_com_ind, parser_state::decl_on_line, dump_line(), e_code, e_com, e_lab, else_endif_com_ind, fill_buffer(), format_block_comments, format_col1_comments, had_eof, if(), in_buffer, parser_state::ind_level, parser_state::ind_size, parser_state::just_saw_decl, parser_state::last_nl, parser_state::last_token, lbrace, line_no, max_col, parser_state::n_comment_delta, parser_state::out_coms, prefix_blankline_requested, printf, ps, s_code, s_com, s_lab, save_com, sc_buf, sc_size, star_comment_cont, start, tabsize, parser_state::unindent_displace, and parser_state::use_ff.

Referenced by main().

set_defaults()

void set_defaults

(

void

)

Definition at line 246 of file args.c.

{
    struct pro *p;
 
    /*
     * Because ps.case_indent is a float, we can't initialize it from the
     * table:
     */
    ps.case_indent = 0.0;   /* -cli0.0 */
    for (p = pro; p->p_name; p++)
    if (p->p_type != PRO_SPECIAL)
        *p->p_obj = p->p_default;
}

References parser_state::case_indent, pro::p_default, pro::p_name, pro::p_obj, pro::p_type, PRO_SPECIAL, and ps.

Referenced by main().

set_option()

void set_option

(

char *

arg

)

Definition at line 261 of file args.c.

{
    struct  pro *p;
    const char  *param_start;
 
    arg++;          /* ignore leading "-" */
    for (p = pro; p->p_name; p++)
    if (*p->p_name == *arg && (param_start = eqin(p->p_name, arg)) != NULL)
        goto found;
    errx(1, "%s: unknown parameter \"%s\"", option_source, arg - 1);
found:
    switch (p->p_type) {
 
    case PRO_SPECIAL:
    switch (p->p_special) {
 
    case IGN:
        break;
 
    case CLI:
        if (*param_start == 0)
        goto need_param;
        ps.case_indent = atof(param_start);
        break;
 
    case STDIN:
        if (input == NULL)
        input = stdin;
        if (output == NULL)
        output = stdout;
        break;
 
    case KEY:
        if (*param_start == 0)
        goto need_param;
        add_typename(param_start);
        break;
 
    case KEY_FILE:
        if (*param_start == 0)
        goto need_param;
        add_typedefs_from_file(param_start);
        break;
 
    case VERSION:
        printf("pg_bsd_indent %s (based on FreeBSD indent)\n", INDENT_VERSION);
        exit(0);
 
    default:
        errx(1, "set_option: internal error: p_special %d", p->p_special);
    }
    break;
 
    case PRO_BOOL:
    if (p->p_special == OFF)
        *p->p_obj = false;
    else
        *p->p_obj = true;
    break;
 
    case PRO_INT:
    if (!isdigit((unsigned char)*param_start)) {
    need_param:
        errx(1, "%s: ``%s'' requires a parameter", option_source, p->p_name);
    }
    *p->p_obj = atoi(param_start);
    break;
 
    default:
    errx(1, "set_option: internal error: p_type %d", p->p_type);
    }
}

References add_typedefs_from_file(), add_typename(), arg, parser_state::case_indent, CLI, eqin(), errx(), exit(), IGN, INDENT_VERSION, input, KEY, KEY_FILE, OFF, option_source, output, pro::p_name, pro::p_obj, pro::p_special, pro::p_type, printf, PRO_BOOL, PRO_INT, PRO_SPECIAL, ps, STDIN, generate_unaccent_rules::stdout, and VERSION.

Referenced by scan_profile().

set_profile()

void set_profile

(

const char *

profile_name

)

Definition at line 176 of file args.c.

{
    FILE *f;
    char fname[MAXPGPATH];
    static char prof[] = ".indent.pro";
 
    if (profile_name == NULL)
    snprintf(fname, sizeof(fname), "%s/%s", getenv("HOME"), prof);
    else
    snprintf(fname, sizeof(fname), "%s", profile_name + 2);
    if ((f = fopen(option_source = fname, "r")) != NULL) {
    scan_profile(f);
    (void) fclose(f);
    }
    if ((f = fopen(option_source = prof, "r")) != NULL) {
    scan_profile(f);
    (void) fclose(f);
    }
    option_source = "Command line";
}

References MAXPGPATH, option_source, scan_profile(), and snprintf.

Referenced by main().