indent: group global variables for token buffer
No functional change.
This commit is contained in:
rillig
parent
f93323fd6d
commit
6c6f9b4b1c
|
|
@ -1,4 +1,4 @@
|
|||
/* $NetBSD: indent.c,v 1.66 2021/09/25 07:59:52 rillig Exp $ */
|
||||
/* $NetBSD: indent.c,v 1.67 2021/09/25 08:04:13 rillig Exp $ */
|
||||
|
||||
/*-
|
||||
* SPDX-License-Identifier: BSD-4-Clause
|
||||
|
|
@ -46,7 +46,7 @@ static char sccsid[] = "@(#)indent.c 5.17 (Berkeley) 6/7/93";
|
|||
#include <sys/cdefs.h>
|
||||
#ifndef lint
|
||||
#if defined(__NetBSD__)
|
||||
__RCSID("$NetBSD: indent.c,v 1.66 2021/09/25 07:59:52 rillig Exp $");
|
||||
__RCSID("$NetBSD: indent.c,v 1.67 2021/09/25 08:04:13 rillig Exp $");
|
||||
#elif defined(__FreeBSD__)
|
||||
__FBSDID("$FreeBSD: head/usr.bin/indent/indent.c 340138 2018-11-04 19:24:49Z oshogbo $");
|
||||
#endif
|
||||
|
|
@ -74,11 +74,7 @@ struct parser_state ps;
|
|||
struct buffer lab;
|
||||
struct buffer code;
|
||||
struct buffer com;
|
||||
|
||||
char *tokenbuf;
|
||||
char *s_token;
|
||||
char *e_token;
|
||||
char *l_token;
|
||||
struct buffer token;
|
||||
|
||||
char *in_buffer;
|
||||
char *in_buffer_limit;
|
||||
|
|
@ -259,11 +255,11 @@ search_brace(token_type *inout_ttype, int *inout_force_nl,
|
|||
|
||||
remove_newlines =
|
||||
/* "} else" */
|
||||
(*inout_ttype == keyword_do_else && *s_token == 'e' &&
|
||||
(*inout_ttype == keyword_do_else && *token.s == 'e' &&
|
||||
code.e != code.s && code.e[-1] == '}')
|
||||
/* "else if" */
|
||||
|| (*inout_ttype == keyword_for_if_while &&
|
||||
*s_token == 'i' && *inout_last_else && opt.else_if);
|
||||
*token.s == 'i' && *inout_last_else && opt.else_if);
|
||||
if (remove_newlines)
|
||||
*inout_force_nl = false;
|
||||
if (sc_end == NULL) { /* ignore buffering if
|
||||
|
|
@ -292,7 +288,7 @@ search_brace(token_type *inout_ttype, int *inout_force_nl,
|
|||
* not already broken */
|
||||
diag(0, "Line broken");
|
||||
}
|
||||
for (const char *t_ptr = s_token; *t_ptr; ++t_ptr)
|
||||
for (const char *t_ptr = token.s; *t_ptr; ++t_ptr)
|
||||
*sc_end++ = *t_ptr;
|
||||
|
||||
sw_buffer:
|
||||
|
|
@ -375,23 +371,23 @@ main_init_globals(void)
|
|||
code.buf = malloc(bufsize);
|
||||
if (code.buf == NULL)
|
||||
err(1, NULL);
|
||||
tokenbuf = malloc(bufsize);
|
||||
if (tokenbuf == NULL)
|
||||
token.buf = malloc(bufsize);
|
||||
if (token.buf == NULL)
|
||||
err(1, NULL);
|
||||
alloc_typenames();
|
||||
init_constant_tt();
|
||||
com.l = com.buf + bufsize - 5;
|
||||
lab.l = lab.buf + bufsize - 5;
|
||||
code.l = code.buf + bufsize - 5;
|
||||
l_token = tokenbuf + bufsize - 5;
|
||||
token.l = token.buf + bufsize - 5;
|
||||
com.buf[0] = code.buf[0] = lab.buf[0] = ' '; /* set up code, label, and
|
||||
* comment buffers */
|
||||
com.buf[1] = code.buf[1] = lab.buf[1] = tokenbuf[1] = '\0';
|
||||
com.buf[1] = code.buf[1] = lab.buf[1] = token.buf[1] = '\0';
|
||||
opt.else_if = 1; /* Default else-if special processing to on */
|
||||
lab.s = lab.e = lab.buf + 1;
|
||||
code.s = code.e = code.buf + 1;
|
||||
com.s = com.e = com.buf + 1;
|
||||
s_token = e_token = tokenbuf + 1;
|
||||
token.s = token.e = token.buf + 1;
|
||||
|
||||
in_buffer = malloc(10);
|
||||
if (in_buffer == NULL)
|
||||
|
|
@ -616,7 +612,7 @@ process_lparen_or_lbracket(int dec_ind, int tabs_to_var, int sp_sw)
|
|||
nitems(ps.paren_indents));
|
||||
ps.p_l_follow--;
|
||||
}
|
||||
if (*s_token == '[')
|
||||
if (*token.s == '[')
|
||||
/* not a function pointer declaration or a function call */;
|
||||
else if (ps.in_decl && !ps.block_init && !ps.dumped_decl_indent &&
|
||||
ps.procname[0] == '\0' && ps.paren_level == 0) {
|
||||
|
|
@ -630,7 +626,7 @@ process_lparen_or_lbracket(int dec_ind, int tabs_to_var, int sp_sw)
|
|||
ps.keyword != rw_0 && ps.keyword != rw_offsetof)))
|
||||
*code.e++ = ' ';
|
||||
ps.want_blank = false;
|
||||
*code.e++ = s_token[0];
|
||||
*code.e++ = token.s[0];
|
||||
|
||||
ps.paren_indents[ps.p_l_follow - 1] =
|
||||
indentation_after_range(0, code.s, code.e);
|
||||
|
|
@ -642,7 +638,7 @@ process_lparen_or_lbracket(int dec_ind, int tabs_to_var, int sp_sw)
|
|||
ps.paren_indents[0] = 2 * opt.indent_size;
|
||||
debug_println("paren_indent[0] is now %d", ps.paren_indents[0]);
|
||||
}
|
||||
if (ps.in_or_st && *s_token == '(' && ps.tos <= 2) {
|
||||
if (ps.in_or_st && *token.s == '(' && ps.tos <= 2) {
|
||||
/*
|
||||
* this is a kluge to make sure that declarations will be
|
||||
* aligned right if proc decl has an explicit type on it, i.e.
|
||||
|
|
@ -671,13 +667,13 @@ process_rparen_or_rbracket(int *inout_sp_sw, int *inout_force_nl,
|
|||
|
||||
if (--ps.p_l_follow < 0) {
|
||||
ps.p_l_follow = 0;
|
||||
diag(0, "Extra %c", *s_token);
|
||||
diag(0, "Extra %c", *token.s);
|
||||
}
|
||||
|
||||
if (code.e == code.s) /* if the paren starts the line */
|
||||
ps.paren_level = ps.p_l_follow; /* then indent it */
|
||||
|
||||
*code.e++ = s_token[0];
|
||||
*code.e++ = token.s[0];
|
||||
|
||||
if (*inout_sp_sw && (ps.p_l_follow == 0)) { /* check for end of if
|
||||
* (...), or some such */
|
||||
|
|
@ -706,7 +702,7 @@ process_unary_op(int dec_ind, int tabs_to_var)
|
|||
* this token
|
||||
*/
|
||||
int i;
|
||||
for (i = 0; s_token[i]; ++i)
|
||||
for (i = 0; token.s[i]; ++i)
|
||||
/* find length of token */;
|
||||
indent_declaration(dec_ind - i, tabs_to_var);
|
||||
ps.dumped_decl_indent = true;
|
||||
|
|
@ -714,10 +710,10 @@ process_unary_op(int dec_ind, int tabs_to_var)
|
|||
*code.e++ = ' ';
|
||||
|
||||
{
|
||||
size_t len = e_token - s_token;
|
||||
size_t len = token.e - token.s;
|
||||
|
||||
check_size_code(len);
|
||||
memcpy(code.e, s_token, len);
|
||||
memcpy(code.e, token.s, len);
|
||||
code.e += len;
|
||||
}
|
||||
ps.want_blank = false;
|
||||
|
|
@ -726,12 +722,12 @@ process_unary_op(int dec_ind, int tabs_to_var)
|
|||
static void
|
||||
process_binary_op(void)
|
||||
{
|
||||
size_t len = e_token - s_token;
|
||||
size_t len = token.e - token.s;
|
||||
|
||||
check_size_code(len + 1);
|
||||
if (ps.want_blank)
|
||||
*code.e++ = ' ';
|
||||
memcpy(code.e, s_token, len);
|
||||
memcpy(code.e, token.s, len);
|
||||
code.e += len;
|
||||
|
||||
ps.want_blank = true;
|
||||
|
|
@ -740,8 +736,8 @@ process_binary_op(void)
|
|||
static void
|
||||
process_postfix_op(void)
|
||||
{
|
||||
*code.e++ = s_token[0];
|
||||
*code.e++ = s_token[1];
|
||||
*code.e++ = token.s[0];
|
||||
*code.e++ = token.s[1];
|
||||
ps.want_blank = true;
|
||||
}
|
||||
|
||||
|
|
@ -966,7 +962,7 @@ static void
|
|||
process_keyword_do_else(int *inout_force_nl, int *inout_last_else)
|
||||
{
|
||||
ps.in_stmt = false;
|
||||
if (*s_token == 'e') {
|
||||
if (*token.s == 'e') {
|
||||
if (code.e != code.s && (!opt.cuddle_else || code.e[-1] != '}')) {
|
||||
if (opt.verbose)
|
||||
diag(0, "Line broken");
|
||||
|
|
@ -1010,7 +1006,7 @@ process_decl(int *out_dec_ind, int *out_tabs_to_var)
|
|||
ps.just_saw_decl = 2;
|
||||
prefix_blankline_requested = 0;
|
||||
int i;
|
||||
for (i = 0; s_token[i++];); /* get length of token */
|
||||
for (i = 0; token.s[i++];); /* get length of token */
|
||||
|
||||
if (ps.ind_level == 0 || ps.dec_nest > 0) {
|
||||
/* global variable or struct member in local variable */
|
||||
|
|
@ -1056,24 +1052,24 @@ process_ident(token_type ttype, int dec_ind, int tabs_to_var,
|
|||
static void
|
||||
copy_id(void)
|
||||
{
|
||||
size_t len = e_token - s_token;
|
||||
size_t len = token.e - token.s;
|
||||
|
||||
check_size_code(len + 1);
|
||||
if (ps.want_blank)
|
||||
*code.e++ = ' ';
|
||||
memcpy(code.e, s_token, len);
|
||||
memcpy(code.e, token.s, len);
|
||||
code.e += len;
|
||||
}
|
||||
|
||||
static void
|
||||
process_string_prefix(void)
|
||||
{
|
||||
size_t len = e_token - s_token;
|
||||
size_t len = token.e - token.s;
|
||||
|
||||
check_size_code(len + 1);
|
||||
if (ps.want_blank)
|
||||
*code.e++ = ' ';
|
||||
memcpy(code.e, s_token, len);
|
||||
memcpy(code.e, token.s, len);
|
||||
code.e += len;
|
||||
|
||||
ps.want_blank = false;
|
||||
|
|
@ -1379,8 +1375,8 @@ main_loop(void)
|
|||
case keyword_for_if_while:
|
||||
sp_sw = true; /* the interesting stuff is done after the
|
||||
* expression is scanned */
|
||||
hd_type = (*s_token == 'i' ? if_expr :
|
||||
(*s_token == 'w' ? while_expr : for_exprs));
|
||||
hd_type = (*token.s == 'i' ? if_expr :
|
||||
(*token.s == 'w' ? while_expr : for_exprs));
|
||||
|
||||
/* remember the type of header for later use by parser */
|
||||
goto copy_id; /* copy the token into line */
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* $NetBSD: indent_globs.h,v 1.25 2021/09/25 07:59:52 rillig Exp $ */
|
||||
/* $NetBSD: indent_globs.h,v 1.26 2021/09/25 08:04:13 rillig Exp $ */
|
||||
|
||||
/*-
|
||||
* SPDX-License-Identifier: BSD-4-Clause
|
||||
|
|
@ -62,11 +62,7 @@ extern FILE *output; /* the output file */
|
|||
extern struct buffer lab; /* label or preprocessor directive */
|
||||
extern struct buffer code; /* code */
|
||||
extern struct buffer com; /* comment */
|
||||
|
||||
extern char *tokenbuf; /* the last token scanned */
|
||||
extern char *s_token;
|
||||
extern char *e_token;
|
||||
extern char *l_token;
|
||||
extern struct buffer token; /* the last token scanned */
|
||||
|
||||
extern char *in_buffer; /* input buffer */
|
||||
extern char *in_buffer_limit; /* the end of the input buffer */
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* $NetBSD: io.c,v 1.55 2021/09/25 07:55:24 rillig Exp $ */
|
||||
/* $NetBSD: io.c,v 1.56 2021/09/25 08:04:13 rillig Exp $ */
|
||||
|
||||
/*-
|
||||
* SPDX-License-Identifier: BSD-4-Clause
|
||||
|
|
@ -46,7 +46,7 @@ static char sccsid[] = "@(#)io.c 8.1 (Berkeley) 6/6/93";
|
|||
#include <sys/cdefs.h>
|
||||
#ifndef lint
|
||||
#if defined(__NetBSD__)
|
||||
__RCSID("$NetBSD: io.c,v 1.55 2021/09/25 07:55:24 rillig Exp $");
|
||||
__RCSID("$NetBSD: io.c,v 1.56 2021/09/25 08:04:13 rillig Exp $");
|
||||
#elif defined(__FreeBSD__)
|
||||
__FBSDID("$FreeBSD: head/usr.bin/indent/io.c 334927 2018-06-10 16:44:18Z pstef $");
|
||||
#endif
|
||||
|
|
@ -261,8 +261,8 @@ dump_line(void)
|
|||
|
||||
/* keep blank lines after '//' comments */
|
||||
if (com.e - com.s > 1 && com.s[1] == '/'
|
||||
&& s_token < e_token && isspace((unsigned char)s_token[0]))
|
||||
output_range(s_token, e_token);
|
||||
&& token.s < token.e && isspace((unsigned char)token.s[0]))
|
||||
output_range(token.s, token.e);
|
||||
|
||||
ps.decl_on_line = ps.in_decl; /* if we are in the middle of a declaration,
|
||||
* remember that fact for proper comment
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* $NetBSD: lexi.c,v 1.49 2021/09/25 07:59:52 rillig Exp $ */
|
||||
/* $NetBSD: lexi.c,v 1.50 2021/09/25 08:04:13 rillig Exp $ */
|
||||
|
||||
/*-
|
||||
* SPDX-License-Identifier: BSD-4-Clause
|
||||
|
|
@ -46,7 +46,7 @@ static char sccsid[] = "@(#)lexi.c 8.1 (Berkeley) 6/6/93";
|
|||
#include <sys/cdefs.h>
|
||||
#ifndef lint
|
||||
#if defined(__NetBSD__)
|
||||
__RCSID("$NetBSD: lexi.c,v 1.49 2021/09/25 07:59:52 rillig Exp $");
|
||||
__RCSID("$NetBSD: lexi.c,v 1.50 2021/09/25 08:04:13 rillig Exp $");
|
||||
#elif defined(__FreeBSD__)
|
||||
__FBSDID("$FreeBSD: head/usr.bin/indent/lexi.c 337862 2018-08-15 18:19:45Z pstef $");
|
||||
#endif
|
||||
|
|
@ -206,17 +206,17 @@ inbuf_next(void)
|
|||
static void
|
||||
check_size_token(size_t desired_size)
|
||||
{
|
||||
if (e_token + (desired_size) < l_token)
|
||||
if (token.e + (desired_size) < token.l)
|
||||
return;
|
||||
|
||||
size_t nsize = l_token - s_token + 400 + desired_size;
|
||||
size_t token_len = e_token - s_token;
|
||||
tokenbuf = realloc(tokenbuf, nsize);
|
||||
if (tokenbuf == NULL)
|
||||
size_t nsize = token.l - token.s + 400 + desired_size;
|
||||
size_t token_len = token.e - token.s;
|
||||
token.buf = realloc(token.buf, nsize);
|
||||
if (token.buf == NULL)
|
||||
err(1, NULL);
|
||||
e_token = tokenbuf + token_len + 1;
|
||||
l_token = tokenbuf + nsize - 5;
|
||||
s_token = tokenbuf + 1;
|
||||
token.e = token.buf + token_len + 1;
|
||||
token.l = token.buf + nsize - 5;
|
||||
token.s = token.buf + 1;
|
||||
}
|
||||
|
||||
static int
|
||||
|
|
@ -266,7 +266,7 @@ lexi_end(token_type ttype)
|
|||
{
|
||||
debug_printf("in line %d, lexi returns '%s'",
|
||||
line_no, token_type_name(ttype));
|
||||
print_buf("token", s_token, e_token);
|
||||
print_buf("token", token.s, token.e);
|
||||
print_buf("label", lab.s, lab.e);
|
||||
print_buf("code", code.s, code.e);
|
||||
print_buf("comment", com.s, com.e);
|
||||
|
|
@ -293,7 +293,7 @@ lex_number(void)
|
|||
}
|
||||
s = table[i][s - 'A'];
|
||||
check_size_token(1);
|
||||
*e_token++ = inbuf_next();
|
||||
*token.e++ = inbuf_next();
|
||||
}
|
||||
/* s now indicates the type: f(loating), i(integer), u(nknown) */
|
||||
}
|
||||
|
|
@ -314,7 +314,7 @@ lex_word(void)
|
|||
break;
|
||||
}
|
||||
check_size_token(1);
|
||||
*e_token++ = inbuf_next();
|
||||
*token.e++ = inbuf_next();
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -323,7 +323,7 @@ lex_char_or_string(void)
|
|||
{
|
||||
char delim;
|
||||
|
||||
delim = *s_token;
|
||||
delim = *token.s;
|
||||
do { /* copy the string */
|
||||
for (;;) { /* move one character or [/<char>]<char> */
|
||||
if (*buf_ptr == '\n') {
|
||||
|
|
@ -331,17 +331,17 @@ lex_char_or_string(void)
|
|||
return;
|
||||
}
|
||||
check_size_token(2);
|
||||
*e_token = inbuf_next();
|
||||
if (*e_token == '\\') { /* if escape, copy extra char */
|
||||
*token.e = inbuf_next();
|
||||
if (*token.e == '\\') { /* if escape, copy extra char */
|
||||
if (*buf_ptr == '\n') /* check for escaped newline */
|
||||
++line_no;
|
||||
*++e_token = inbuf_next();
|
||||
++e_token; /* we must increment this again because we
|
||||
*++token.e = inbuf_next();
|
||||
++token.e; /* we must increment this again because we
|
||||
* copied two chars */
|
||||
} else
|
||||
break; /* we copied one character */
|
||||
} /* end of while (1) */
|
||||
} while (*e_token++ != delim);
|
||||
} while (*token.e++ != delim);
|
||||
}
|
||||
|
||||
/* Reads the next token, placing it in the global variable "token". */
|
||||
|
|
@ -352,7 +352,7 @@ lexi(struct parser_state *state)
|
|||
* forces a following operator to be unary */
|
||||
token_type ttype;
|
||||
|
||||
e_token = s_token; /* point to start of place to save token */
|
||||
token.e = token.s; /* 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
|
||||
|
|
@ -380,9 +380,9 @@ lexi(struct parser_state *state)
|
|||
} else {
|
||||
lex_word();
|
||||
}
|
||||
*e_token = '\0';
|
||||
*token.e = '\0';
|
||||
|
||||
if (s_token[0] == 'L' && s_token[1] == '\0' &&
|
||||
if (token.s[0] == 'L' && token.s[1] == '\0' &&
|
||||
(*buf_ptr == '"' || *buf_ptr == '\''))
|
||||
return lexi_end(string_prefix);
|
||||
|
||||
|
|
@ -401,15 +401,15 @@ lexi(struct parser_state *state)
|
|||
*/
|
||||
state->last_u_d = (state->last_token == keyword_struct_union_enum);
|
||||
|
||||
p = bsearch(s_token, specials, sizeof specials / sizeof specials[0],
|
||||
p = bsearch(token.s, specials, sizeof specials / sizeof specials[0],
|
||||
sizeof specials[0], compare_templ_array);
|
||||
if (p == NULL) { /* not a special keyword... */
|
||||
char *u;
|
||||
|
||||
/* ... so maybe a type_t or a typedef */
|
||||
if ((opt.auto_typedefs && ((u = strrchr(s_token, '_')) != NULL) &&
|
||||
if ((opt.auto_typedefs && ((u = strrchr(token.s, '_')) != NULL) &&
|
||||
strcmp(u, "_t") == 0) || (typename_top >= 0 &&
|
||||
bsearch(s_token, typenames, (size_t)typename_top + 1,
|
||||
bsearch(token.s, typenames, (size_t)typename_top + 1,
|
||||
sizeof typenames[0], compare_string_array))) {
|
||||
state->keyword = rw_type;
|
||||
state->last_u_d = true;
|
||||
|
|
@ -463,7 +463,7 @@ lexi(struct parser_state *state)
|
|||
while (tp < buf_end)
|
||||
if (*tp++ == ')' && (*tp == ';' || *tp == ','))
|
||||
goto not_proc;
|
||||
strncpy(state->procname, s_token, sizeof state->procname - 1);
|
||||
strncpy(state->procname, token.s, sizeof state->procname - 1);
|
||||
if (state->in_decl)
|
||||
state->in_parameter_declaration = 1;
|
||||
return lexi_end(funcname);
|
||||
|
|
@ -493,11 +493,11 @@ lexi(struct parser_state *state)
|
|||
/* Scan a non-alphanumeric token */
|
||||
|
||||
check_size_token(3); /* things like "<<=" */
|
||||
*e_token++ = inbuf_next(); /* if it is only a one-character token, it is
|
||||
*token.e++ = inbuf_next(); /* if it is only a one-character token, it is
|
||||
* moved here */
|
||||
*e_token = '\0';
|
||||
*token.e = '\0';
|
||||
|
||||
switch (*s_token) {
|
||||
switch (*token.s) {
|
||||
case '\n':
|
||||
unary_delim = state->last_u_d;
|
||||
state->last_nl = true; /* remember that we just had a newline */
|
||||
|
|
@ -574,9 +574,9 @@ lexi(struct parser_state *state)
|
|||
ttype = state->last_u_d ? unary_op : binary_op;
|
||||
unary_delim = true;
|
||||
|
||||
if (*buf_ptr == s_token[0]) {
|
||||
if (*buf_ptr == token.s[0]) {
|
||||
/* check for doubled character */
|
||||
*e_token++ = *buf_ptr++;
|
||||
*token.e++ = *buf_ptr++;
|
||||
/* buffer overflow will be checked at end of loop */
|
||||
if (state->last_token == ident || state->last_token == rparen) {
|
||||
ttype = state->last_u_d ? unary_op : postfix_op;
|
||||
|
|
@ -585,10 +585,10 @@ lexi(struct parser_state *state)
|
|||
}
|
||||
} else if (*buf_ptr == '=')
|
||||
/* check for operator += */
|
||||
*e_token++ = *buf_ptr++;
|
||||
*token.e++ = *buf_ptr++;
|
||||
else if (*buf_ptr == '>') {
|
||||
/* check for operator -> */
|
||||
*e_token++ = *buf_ptr++;
|
||||
*token.e++ = *buf_ptr++;
|
||||
unary_delim = false;
|
||||
ttype = unary_op;
|
||||
state->want_blank = false;
|
||||
|
|
@ -600,9 +600,9 @@ lexi(struct parser_state *state)
|
|||
if (state->in_or_st)
|
||||
state->block_init = 1;
|
||||
if (*buf_ptr == '=') { /* == */
|
||||
*e_token++ = '='; /* Flip =+ to += */
|
||||
*token.e++ = '='; /* Flip =+ to += */
|
||||
buf_ptr++;
|
||||
*e_token = 0;
|
||||
*token.e = 0;
|
||||
}
|
||||
ttype = binary_op;
|
||||
unary_delim = true;
|
||||
|
|
@ -613,9 +613,9 @@ lexi(struct parser_state *state)
|
|||
case '<':
|
||||
case '!': /* ops like <, <<, <=, !=, etc */
|
||||
if (*buf_ptr == '>' || *buf_ptr == '<' || *buf_ptr == '=')
|
||||
*e_token++ = inbuf_next();
|
||||
*token.e++ = inbuf_next();
|
||||
if (*buf_ptr == '=')
|
||||
*e_token++ = *buf_ptr++;
|
||||
*token.e++ = *buf_ptr++;
|
||||
ttype = state->last_u_d ? unary_op : binary_op;
|
||||
unary_delim = true;
|
||||
break;
|
||||
|
|
@ -624,14 +624,14 @@ lexi(struct parser_state *state)
|
|||
unary_delim = true;
|
||||
if (!state->last_u_d) {
|
||||
if (*buf_ptr == '=')
|
||||
*e_token++ = *buf_ptr++;
|
||||
*token.e++ = *buf_ptr++;
|
||||
ttype = binary_op;
|
||||
break;
|
||||
}
|
||||
while (*buf_ptr == '*' || isspace((unsigned char)*buf_ptr)) {
|
||||
if (*buf_ptr == '*') {
|
||||
check_size_token(1);
|
||||
*e_token++ = *buf_ptr;
|
||||
*token.e++ = *buf_ptr;
|
||||
}
|
||||
inbuf_skip();
|
||||
}
|
||||
|
|
@ -650,20 +650,20 @@ lexi(struct parser_state *state)
|
|||
break;
|
||||
|
||||
default:
|
||||
if (s_token[0] == '/' && (*buf_ptr == '*' || *buf_ptr == '/')) {
|
||||
if (token.s[0] == '/' && (*buf_ptr == '*' || *buf_ptr == '/')) {
|
||||
/* it is start of comment */
|
||||
*e_token++ = inbuf_next();
|
||||
*token.e++ = inbuf_next();
|
||||
|
||||
ttype = comment;
|
||||
unary_delim = state->last_u_d;
|
||||
break;
|
||||
}
|
||||
while (e_token[-1] == *buf_ptr || *buf_ptr == '=') {
|
||||
while (token.e[-1] == *buf_ptr || *buf_ptr == '=') {
|
||||
/*
|
||||
* handle ||, &&, etc, and also things as in int *****i
|
||||
*/
|
||||
check_size_token(1);
|
||||
*e_token++ = inbuf_next();
|
||||
*token.e++ = inbuf_next();
|
||||
}
|
||||
ttype = state->last_u_d ? unary_op : binary_op;
|
||||
unary_delim = true;
|
||||
|
|
@ -673,7 +673,7 @@ lexi(struct parser_state *state)
|
|||
fill_buffer();
|
||||
state->last_u_d = unary_delim;
|
||||
check_size_token(1);
|
||||
*e_token = '\0';
|
||||
*token.e = '\0';
|
||||
return lexi_end(ttype);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* $NetBSD: parse.c,v 1.21 2021/09/25 07:59:52 rillig Exp $ */
|
||||
/* $NetBSD: parse.c,v 1.22 2021/09/25 08:04:13 rillig Exp $ */
|
||||
|
||||
/*-
|
||||
* SPDX-License-Identifier: BSD-4-Clause
|
||||
|
|
@ -65,7 +65,7 @@ parse(token_type ttype)
|
|||
int i;
|
||||
|
||||
#ifdef debug
|
||||
printf("parse token: '%s' \"%s\"\n", token_type_name(ttype), s_token);
|
||||
printf("parse token: '%s' \"%s\"\n", token_type_name(ttype), token.s);
|
||||
#endif
|
||||
|
||||
while (ps.p_stack[ps.tos] == if_expr_stmt && ttype != keyword_else) {
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* $NetBSD: pr_comment.c,v 1.38 2021/09/25 07:55:24 rillig Exp $ */
|
||||
/* $NetBSD: pr_comment.c,v 1.39 2021/09/25 08:04:13 rillig Exp $ */
|
||||
|
||||
/*-
|
||||
* SPDX-License-Identifier: BSD-4-Clause
|
||||
|
|
@ -46,7 +46,7 @@ static char sccsid[] = "@(#)pr_comment.c 8.1 (Berkeley) 6/6/93";
|
|||
#include <sys/cdefs.h>
|
||||
#ifndef lint
|
||||
#if defined(__NetBSD__)
|
||||
__RCSID("$NetBSD: pr_comment.c,v 1.38 2021/09/25 07:55:24 rillig Exp $");
|
||||
__RCSID("$NetBSD: pr_comment.c,v 1.39 2021/09/25 08:04:13 rillig Exp $");
|
||||
#elif defined(__FreeBSD__)
|
||||
__FBSDID("$FreeBSD: head/usr.bin/indent/pr_comment.c 334927 2018-06-10 16:44:18Z pstef $");
|
||||
#endif
|
||||
|
|
@ -119,7 +119,7 @@ process_comment(void)
|
|||
break_delim = false;
|
||||
ps.com_col = 1;
|
||||
} else {
|
||||
if (*buf_ptr == '-' || *buf_ptr == '*' || e_token[-1] == '/' ||
|
||||
if (*buf_ptr == '-' || *buf_ptr == '*' || token.e[-1] == '/' ||
|
||||
(*buf_ptr == '\n' && !opt.format_block_comments)) {
|
||||
ps.box_com = true; /* A comment with a '-' or '*' immediately
|
||||
* after the /+* is assumed to be a boxed
|
||||
|
|
@ -185,7 +185,7 @@ process_comment(void)
|
|||
}
|
||||
ps.comment_delta = 0;
|
||||
*com.e++ = '/';
|
||||
*com.e++ = e_token[-1];
|
||||
*com.e++ = token.e[-1];
|
||||
if (*buf_ptr != ' ' && !ps.box_com)
|
||||
*com.e++ = ' ';
|
||||
|
||||
|
|
@ -246,7 +246,7 @@ process_comment(void)
|
|||
break;
|
||||
|
||||
case '\n':
|
||||
if (e_token[-1] == '/') {
|
||||
if (token.e[-1] == '/') {
|
||||
++line_no;
|
||||
goto end_of_comment;
|
||||
}
|
||||
|
|
@ -311,7 +311,7 @@ process_comment(void)
|
|||
}
|
||||
if (com.e[-1] != ' ' && com.e[-1] != '\t' && !ps.box_com)
|
||||
*com.e++ = ' '; /* ensure blank before end */
|
||||
if (e_token[-1] == '/')
|
||||
if (token.e[-1] == '/')
|
||||
*com.e++ = '\n', *com.e = '\0';
|
||||
else
|
||||
*com.e++ = '*', *com.e++ = '/', *com.e = '\0';
|
||||
|
|
|
|||
Loading…
Reference in New Issue