PostgreSQL Source Code  git master
indent.c File Reference
#include "c.h"
#include <sys/param.h>
#include <err.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include "indent_globs.h"
#include "indent_codes.h"
#include "indent.h"
Include dependency graph for indent.c:

Go to the source code of this file.

Macros

#define DECLARE_INDENT_GLOBALS   1
 

Functions

static void bakcopy (void)
 
static void indent_declaration (int, int)
 
int main (int argc, char **argv)
 

Variables

const char * in_name = "Standard Input"
 
const char * out_name = "Standard Output"
 
char bakfile [MAXPGPATH] = ""
 

Macro Definition Documentation

◆ DECLARE_INDENT_GLOBALS

#define DECLARE_INDENT_GLOBALS   1

Definition at line 50 of file indent.c.

Function Documentation

◆ bakcopy()

static void bakcopy ( void  )
static

Definition at line 1203 of file indent.c.

1204 {
1205  int n,
1206  bakchn;
1207  char buff[8 * 1024];
1208  const char *p;
1209 
1210  /* construct file name .Bfile */
1211  for (p = in_name; *p; p++); /* skip to end of string */
1212  while (p > in_name && *p != '/') /* find last '/' */
1213  p--;
1214  if (*p == '/')
1215  p++;
1216  sprintf(bakfile, "%s.BAK", p);
1217 
1218  /* copy in_name to backup file */
1219  bakchn = creat(bakfile, 0600);
1220  if (bakchn < 0)
1221  err(1, "%s", bakfile);
1222  while ((n = read(fileno(input), buff, sizeof(buff))) > 0)
1223  if (write(bakchn, buff, n) != n)
1224  err(1, "%s", bakfile);
1225  if (n < 0)
1226  err(1, "%s", in_name);
1227  close(bakchn);
1228  fclose(input);
1229 
1230  /* re-open backup file as the input file */
1231  input = fopen(bakfile, "r");
1232  if (input == NULL)
1233  err(1, "%s", bakfile);
1234  /* now the original input file will be the output */
1235  output = fopen(in_name, "wb");
1236  if (output == NULL) {
1237  unlink(bakfile);
1238  err(1, "%s", in_name);
1239  }
1240 }
void err(int eval, const char *fmt,...)
Definition: err.c:43
const char * in_name
Definition: indent.c:59
char bakfile[MAXPGPATH]
Definition: indent.c:63
FILE * input
FILE * output
#define close(a)
Definition: win32.h:12
#define write(a, b, c)
Definition: win32.h:14
#define read(a, b, c)
Definition: win32.h:13
#define sprintf
Definition: port.h:240

References bakfile, close, err(), in_name, input, output, read, sprintf, and write.

Referenced by main().

◆ indent_declaration()

static void indent_declaration ( int  cur_dec_ind,
int  tabs_to_var 
)
static

Definition at line 1243 of file indent.c.

1244 {
1245  int pos = e_code - s_code;
1246  char *startpos = e_code;
1247 
1248  /*
1249  * get the tab math right for indentations that are not multiples of tabsize
1250  */
1251  if ((ps.ind_level * ps.ind_size) % tabsize != 0) {
1252  pos += (ps.ind_level * ps.ind_size) % tabsize;
1253  cur_dec_ind += (ps.ind_level * ps.ind_size) % tabsize;
1254  }
1255  if (tabs_to_var) {
1256  int tpos;
1257 
1258  CHECK_SIZE_CODE(cur_dec_ind / tabsize);
1259  while ((tpos = tabsize * (1 + pos / tabsize)) <= cur_dec_ind) {
1260  *e_code++ = (!postgres_tab_rules ||
1261  tpos != pos + 1 ||
1262  cur_dec_ind >= tpos + tabsize) ? '\t' : ' ';
1263  pos = tpos;
1264  }
1265  }
1266  CHECK_SIZE_CODE(cur_dec_ind - pos + 1);
1267  while (pos < cur_dec_ind) {
1268  *e_code++ = ' ';
1269  pos++;
1270  }
1271  if (e_code == startpos && ps.want_blank) {
1272  *e_code++ = ' ';
1273  ps.want_blank = false;
1274  }
1275 }
int tabsize
int postgres_tab_rules
#define CHECK_SIZE_CODE(desired_size)
Definition: indent_globs.h:59
char * e_code
struct parser_state ps
char * s_code
static XLogRecPtr startpos

References CHECK_SIZE_CODE, e_code, parser_state::ind_level, parser_state::ind_size, postgres_tab_rules, ps, s_code, startpos, tabsize, and parser_state::want_blank.

Referenced by main().

◆ main()

int main ( int  argc,
char **  argv 
)

Definition at line 66 of file indent.c.

67 {
68  int dec_ind; /* current indentation for declarations */
69  int di_stack[20]; /* a stack of structure indentation levels */
70  int force_nl; /* when true, code must be broken */
71  int hd_type = 0; /* used to store type of stmt for if (...),
72  * for (...), etc */
73  int i; /* local loop counter */
74  int scase; /* set to true when we see a case, so we will
75  * know what to do with the following colon */
76  int sp_sw; /* when true, we are in the expression of
77  * if(...), while(...), etc. */
78  int squest; /* when this is positive, we have seen a ?
79  * without the matching : in a <c>?<s>:<s>
80  * construct */
81  const char *t_ptr; /* used for copying tokens */
82  int tabs_to_var; /* true if using tabs to indent to var name */
83  int type_code; /* the type of token, returned by lexi */
84 
85  int last_else = 0; /* true iff last keyword was an else */
86  const char *profile_name = NULL;
87  struct parser_state transient_state; /* a copy for lookup */
88 
89 
90  /*-----------------------------------------------*\
91  | INITIALIZATION |
92  \*-----------------------------------------------*/
93 
94  found_err = 0;
95 
96  ps.p_stack[0] = stmt; /* this is the parser's stack */
97  ps.last_nl = true; /* this is true if the last thing scanned was
98  * a newline */
100  combuf = (char *) malloc(bufsize);
101  if (combuf == NULL)
102  err(1, NULL);
103  labbuf = (char *) malloc(bufsize);
104  if (labbuf == NULL)
105  err(1, NULL);
106  codebuf = (char *) malloc(bufsize);
107  if (codebuf == NULL)
108  err(1, NULL);
109  tokenbuf = (char *) malloc(bufsize);
110  if (tokenbuf == NULL)
111  err(1, NULL);
112  alloc_typenames();
113  l_com = combuf + bufsize - 5;
114  l_lab = labbuf + bufsize - 5;
115  l_code = codebuf + bufsize - 5;
116  l_token = tokenbuf + bufsize - 5;
117  combuf[0] = codebuf[0] = labbuf[0] = ' '; /* set up code, label, and
118  * comment buffers */
119  combuf[1] = codebuf[1] = labbuf[1] = '\0';
120  ps.else_if = 1; /* Default else-if special processing to on */
121  s_lab = e_lab = labbuf + 1;
122  s_code = e_code = codebuf + 1;
123  s_com = e_com = combuf + 1;
124  s_token = e_token = tokenbuf + 1;
125 
126  in_buffer = (char *) malloc(10);
127  if (in_buffer == NULL)
128  err(1, NULL);
131  line_no = 1;
133  sp_sw = force_nl = false;
134  ps.in_or_st = false;
135  ps.bl_line = true;
136  dec_ind = 0;
137  di_stack[ps.dec_nest = 0] = 0;
138  ps.want_blank = ps.in_stmt = ps.ind_stmt = false;
139 
140  scase = ps.pcase = false;
141  squest = 0;
142  sc_end = NULL;
143  bp_save = NULL;
144  be_save = NULL;
145 
146  output = NULL;
147  tabs_to_var = 0;
148 
149  /*--------------------------------------------------*\
150  | COMMAND LINE SCAN |
151  \*--------------------------------------------------*/
152 
153 #ifdef undef
154  max_col = 78; /* -l78 */
155  lineup_to_parens = 1; /* -lp */
156  lineup_to_parens_always = 0; /* -nlpl */
157  ps.ljust_decl = 0; /* -ndj */
158  ps.com_ind = 33; /* -c33 */
159  star_comment_cont = 1; /* -sc */
160  ps.ind_size = 8; /* -i8 */
161  verbose = 0;
162  ps.decl_indent = 16; /* -di16 */
163  ps.local_decl_indent = -1; /* if this is not set to some nonnegative value
164  * by an arg, we will set this equal to
165  * ps.decl_ind */
166  ps.indent_parameters = 1; /* -ip */
167  ps.decl_com_ind = 0; /* if this is not set to some positive value
168  * by an arg, we will set this equal to
169  * ps.com_ind */
170  btype_2 = 1; /* -br */
171  cuddle_else = 1; /* -ce */
172  ps.unindent_displace = 0; /* -d0 */
173  ps.case_indent = 0; /* -cli0 */
174  format_block_comments = 1; /* -fcb */
175  format_col1_comments = 1; /* -fc1 */
176  procnames_start_line = 1; /* -psl */
177  proc_calls_space = 0; /* -npcs */
178  comment_delimiter_on_blankline = 1; /* -cdb */
179  ps.leave_comma = 1; /* -nbc */
180 #endif
181 
182  for (i = 1; i < argc; ++i)
183  if (strcmp(argv[i], "-npro") == 0)
184  break;
185  else if (argv[i][0] == '-' && argv[i][1] == 'P' && argv[i][2] != '\0')
186  profile_name = argv[i]; /* non-empty -P (set profile) */
187  set_defaults();
188  if (i >= argc)
189  set_profile(profile_name);
190 
191  for (i = 1; i < argc; ++i) {
192 
193  /*
194  * look thru args (if any) for changes to defaults
195  */
196  if (argv[i][0] != '-') {/* no flag on parameter */
197  if (input == NULL) { /* we must have the input file */
198  in_name = argv[i]; /* remember name of input file */
199  input = fopen(in_name, "r");
200  if (input == NULL) /* check for open error */
201  err(1, "%s", in_name);
202  continue;
203  }
204  else if (output == NULL) { /* we have the output file */
205  out_name = argv[i]; /* remember name of output file */
206  if (strcmp(in_name, out_name) == 0) { /* attempt to overwrite
207  * the file */
208  errx(1, "input and output files must be different");
209  }
210  output = fopen(out_name, "wb");
211  if (output == NULL) /* check for create error */
212  err(1, "%s", out_name);
213  continue;
214  }
215  errx(1, "unknown parameter: %s", argv[i]);
216  }
217  else
218  set_option(argv[i]);
219  } /* end of for */
220  if (input == NULL)
221  input = stdin;
222  if (output == NULL) {
223  if (input == stdin)
224  output = stdout;
225  else {
226  out_name = in_name;
227  bakcopy();
228  }
229  }
230 
231  if (ps.com_ind <= 1)
232  ps.com_ind = 2; /* dont put normal comments before column 2 */
233  if (block_comment_max_col <= 0)
235  if (ps.local_decl_indent < 0) /* if not specified by user, set this */
237  if (ps.decl_com_ind <= 0) /* if not specified by user, set this */
238  ps.decl_com_ind = ps.ljust_decl ? (ps.com_ind <= 10 ? 2 : ps.com_ind - 8) : ps.com_ind;
239  if (continuation_indent == 0)
241  fill_buffer(); /* get first batch of stuff into input buffer */
242 
243  parse(semicolon);
244  {
245  char *p = buf_ptr;
246  int col = 1;
247 
248  while (1) {
249  if (*p == ' ')
250  col++;
251  else if (*p == '\t')
252  col = tabsize * (1 + (col - 1) / tabsize) + 1;
253  else
254  break;
255  p++;
256  }
257  if (col > ps.ind_size)
258  ps.ind_level = ps.i_l_follow = col / ps.ind_size;
259  }
260 
261  /*
262  * START OF MAIN LOOP
263  */
264 
265  while (1) { /* this is the main loop. it will go until we
266  * reach eof */
267  int comment_buffered = false;
268 
269  type_code = lexi(&ps); /* lexi reads one token. The actual
270  * characters read are stored in "token". lexi
271  * returns a code indicating the type of token */
272 
273  /*
274  * The following code moves newlines and comments following an if (),
275  * while (), else, etc. up to the start of the following stmt to
276  * a buffer. This allows proper handling of both kinds of brace
277  * placement (-br, -bl) and cuddling "else" (-ce).
278  */
279 
280  while (ps.search_brace) {
281  switch (type_code) {
282  case newline:
283  if (sc_end == NULL) {
284  save_com = sc_buf;
285  save_com[0] = save_com[1] = ' ';
286  sc_end = &save_com[2];
287  }
288  *sc_end++ = '\n';
289  /*
290  * We may have inherited a force_nl == true from the previous
291  * token (like a semicolon). But once we know that a newline
292  * has been scanned in this loop, force_nl should be false.
293  *
294  * However, the force_nl == true must be preserved if newline
295  * is never scanned in this loop, so this assignment cannot be
296  * done earlier.
297  */
298  force_nl = false;
299  case form_feed:
300  break;
301  case comment:
302  if (sc_end == NULL) {
303  /*
304  * Copy everything from the start of the line, because
305  * pr_comment() will use that to calculate original
306  * indentation of a boxed comment.
307  */
308  memcpy(sc_buf, in_buffer, buf_ptr - in_buffer - 4);
309  save_com = sc_buf + (buf_ptr - in_buffer - 4);
310  save_com[0] = save_com[1] = ' ';
311  sc_end = &save_com[2];
312  }
313  comment_buffered = true;
314  *sc_end++ = '/'; /* copy in start of comment */
315  *sc_end++ = '*';
316  for (;;) { /* loop until we get to the end of the comment */
317  *sc_end = *buf_ptr++;
318  if (buf_ptr >= buf_end)
319  fill_buffer();
320  if (*sc_end++ == '*' && *buf_ptr == '/')
321  break; /* we are at end of comment */
322  if (sc_end >= &save_com[sc_size]) { /* check for temp buffer
323  * overflow */
324  diag2(1, "Internal buffer overflow - Move big comment from right after if, while, or whatever");
325  fflush(output);
326  exit(1);
327  }
328  }
329  *sc_end++ = '/'; /* add ending slash */
330  if (++buf_ptr >= buf_end) /* get past / in buffer */
331  fill_buffer();
332  break;
333  case lbrace:
334  /*
335  * Put KNF-style lbraces before the buffered up tokens and
336  * jump out of this loop in order to avoid copying the token
337  * again under the default case of the switch below.
338  */
339  if (sc_end != NULL && btype_2) {
340  save_com[0] = '{';
341  /*
342  * Originally the lbrace may have been alone on its own
343  * line, but it will be moved into "the else's line", so
344  * if there was a newline resulting from the "{" before,
345  * it must be scanned now and ignored.
346  */
347  while (isspace((unsigned char)*buf_ptr)) {
348  if (++buf_ptr >= buf_end)
349  fill_buffer();
350  if (*buf_ptr == '\n')
351  break;
352  }
353  goto sw_buffer;
354  }
355  /* FALLTHROUGH */
356  default: /* it is the start of a normal statement */
357  {
358  int remove_newlines;
359 
360  remove_newlines =
361  /* "} else" */
362  (type_code == sp_nparen && *token == 'e' &&
363  e_code != s_code && e_code[-1] == '}')
364  /* "else if" */
365  || (type_code == sp_paren && *token == 'i' &&
366  last_else && ps.else_if);
367  if (remove_newlines)
368  force_nl = false;
369  if (sc_end == NULL) { /* ignore buffering if
370  * comment wasn't saved up */
371  ps.search_brace = false;
372  goto check_type;
373  }
374  while (sc_end > save_com && isblank((unsigned char)sc_end[-1])) {
375  sc_end--;
376  }
378  (!comment_buffered && remove_newlines)) {
379  force_nl = !remove_newlines;
380  while (sc_end > save_com && sc_end[-1] == '\n') {
381  sc_end--;
382  }
383  }
384  if (force_nl) { /* if we should insert a nl here, put
385  * it into the buffer */
386  force_nl = false;
387  --line_no; /* this will be re-increased when the
388  * newline is read from the buffer */
389  *sc_end++ = '\n';
390  *sc_end++ = ' ';
391  if (verbose) /* print error msg if the line was
392  * not already broken */
393  diag2(0, "Line broken");
394  }
395  for (t_ptr = token; *t_ptr; ++t_ptr)
396  *sc_end++ = *t_ptr;
397 
398  sw_buffer:
399  ps.search_brace = false; /* stop looking for start of
400  * stmt */
401  bp_save = buf_ptr; /* save current input buffer */
402  be_save = buf_end;
403  buf_ptr = save_com; /* fix so that subsequent calls to
404  * lexi will take tokens out of
405  * save_com */
406  *sc_end++ = ' ';/* add trailing blank, just in case */
407  buf_end = sc_end;
408  sc_end = NULL;
409  break;
410  }
411  } /* end of switch */
412  /*
413  * We must make this check, just in case there was an unexpected
414  * EOF.
415  */
416  if (type_code != 0) {
417  /*
418  * The only intended purpose of calling lexi() below is to
419  * categorize the next token in order to decide whether to
420  * continue buffering forthcoming tokens. Once the buffering
421  * is over, lexi() will be called again elsewhere on all of
422  * the tokens - this time for normal processing.
423  *
424  * Calling it for this purpose is a bug, because lexi() also
425  * changes the parser state and discards leading whitespace,
426  * which is needed mostly for comment-related considerations.
427  *
428  * Work around the former problem by giving lexi() a copy of
429  * the current parser state and discard it if the call turned
430  * out to be just a look ahead.
431  *
432  * Work around the latter problem by copying all whitespace
433  * characters into the buffer so that the later lexi() call
434  * will read them.
435  */
436  if (sc_end != NULL) {
437  while (*buf_ptr == ' ' || *buf_ptr == '\t') {
438  *sc_end++ = *buf_ptr++;
439  if (sc_end >= &save_com[sc_size]) {
440  errx(1, "input too long");
441  }
442  }
443  if (buf_ptr >= buf_end) {
444  fill_buffer();
445  }
446  }
447  transient_state = ps;
448  type_code = lexi(&transient_state); /* read another token */
449  if (type_code != newline && type_code != form_feed &&
450  type_code != comment && !transient_state.search_brace) {
451  ps = transient_state;
452  }
453  }
454  } /* end of while (search_brace) */
455  last_else = 0;
456 check_type:
457  if (type_code == 0) { /* we got eof */
458  if (s_lab != e_lab || s_code != e_code
459  || s_com != e_com) /* must dump end of line */
460  dump_line();
461  if (ps.tos > 1) /* check for balanced braces */
462  diag2(1, "Stuff missing from end of file");
463 
464  if (verbose) {
465  printf("There were %d output lines and %d comments\n",
467  printf("(Lines with comments)/(Lines with code): %6.3f\n",
468  (1.0 * ps.com_lines) / code_lines);
469  }
470  fflush(output);
471  exit(found_err);
472  }
473  if (
474  (type_code != comment) &&
475  (type_code != newline) &&
476  (type_code != preesc) &&
477  (type_code != form_feed)) {
478  if (force_nl &&
479  (type_code != semicolon) &&
480  (type_code != lbrace || !btype_2)) {
481  /* we should force a broken line here */
482  if (verbose)
483  diag2(0, "Line broken");
484  dump_line();
485  ps.want_blank = false; /* dont insert blank at line start */
486  force_nl = false;
487  }
488  ps.in_stmt = true; /* turn on flag which causes an extra level of
489  * indentation. this is turned off by a ; or
490  * '}' */
491  if (s_com != e_com) { /* the turkey has embedded a comment
492  * in a line. fix it */
493  int len = e_com - s_com;
494 
495  CHECK_SIZE_CODE(len + 3);
496  *e_code++ = ' ';
497  memcpy(e_code, s_com, len);
498  e_code += len;
499  *e_code++ = ' ';
500  *e_code = '\0'; /* null terminate code sect */
501  ps.want_blank = false;
502  e_com = s_com;
503  }
504  }
505  else if (type_code != comment) /* preserve force_nl thru a comment */
506  force_nl = false; /* cancel forced newline after newline, form
507  * feed, etc */
508 
509 
510 
511  /*-----------------------------------------------------*\
512  | do switch on type of token scanned |
513  \*-----------------------------------------------------*/
514  CHECK_SIZE_CODE(3); /* maximum number of increments of e_code
515  * before the next CHECK_SIZE_CODE or
516  * dump_line() is 2. After that there's the
517  * final increment for the null character. */
518  switch (type_code) { /* now, decide what to do with the token */
519 
520  case form_feed: /* found a form feed in line */
521  ps.use_ff = true; /* a form feed is treated much like a newline */
522  dump_line();
523  ps.want_blank = false;
524  break;
525 
526  case newline:
527  if (ps.last_token != comma || ps.p_l_follow > 0
528  || !ps.leave_comma || ps.block_init || !break_comma || s_com != e_com) {
529  dump_line();
530  ps.want_blank = false;
531  }
532  ++line_no; /* keep track of input line number */
533  break;
534 
535  case lparen: /* got a '(' or '[' */
536  /* count parens to make Healy happy */
537  if (++ps.p_l_follow == nitems(ps.paren_indents)) {
538  diag3(0, "Reached internal limit of %d unclosed parens",
540  ps.p_l_follow--;
541  }
542  if (*token == '[')
543  /* not a function pointer declaration or a function call */;
544  else if (ps.in_decl && !ps.block_init && !ps.dumped_decl_indent &&
545  ps.procname[0] == '\0' && ps.paren_level == 0) {
546  /* function pointer declarations */
547  indent_declaration(dec_ind, tabs_to_var);
548  ps.dumped_decl_indent = true;
549  }
550  else if (ps.want_blank &&
551  ((ps.last_token != ident && ps.last_token != funcname) ||
552  /* offsetof (1) is never allowed a space; sizeof (2) gets
553  * one iff -bs; all other keywords (>2) always get a space
554  * before lparen */
555  ps.keyword + Bill_Shannon > 2))
556  *e_code++ = ' ';
557  ps.want_blank = false;
558  *e_code++ = token[0];
560  if (sp_sw && ps.p_l_follow == 1 && extra_expression_indent
561  && ps.paren_indents[0] < 2 * ps.ind_size)
562  ps.paren_indents[0] = 2 * ps.ind_size;
563  if (ps.in_or_st && *token == '(' && ps.tos <= 2) {
564  /*
565  * this is a kluge to make sure that declarations will be
566  * aligned right if proc decl has an explicit type on it, i.e.
567  * "int a(x) {..."
568  */
569  parse(semicolon); /* I said this was a kluge... */
570  ps.in_or_st = false; /* turn off flag for structure decl or
571  * initialization */
572  }
573  /*
574  * parenthesized type following sizeof or offsetof is not a cast,
575  * and we assume the same for any other non-keyword identifier,
576  * to support macros that take types
577  */
578  if (ps.last_token == ident &&
579  (ps.keyword == 0 || ps.keyword == 1 || ps.keyword == 2))
580  ps.not_cast_mask |= 1 << ps.p_l_follow;
581  break;
582 
583  case rparen: /* got a ')' or ']' */
584  if (ps.cast_mask & (1 << ps.p_l_follow) & ~ps.not_cast_mask) {
585  ps.last_u_d = true;
586  ps.cast_mask &= (1 << ps.p_l_follow) - 1;
588  } else
589  ps.want_blank = true;
590  ps.not_cast_mask &= (1 << ps.p_l_follow) - 1;
591  if (--ps.p_l_follow < 0) {
592  ps.p_l_follow = 0;
593  diag3(0, "Extra %c", *token);
594  }
595  if (e_code == s_code) /* if the paren starts the line */
596  ps.paren_level = ps.p_l_follow; /* then indent it */
597 
598  *e_code++ = token[0];
599 
600  if (sp_sw && (ps.p_l_follow == 0)) { /* check for end of if
601  * (...), or some such */
602  sp_sw = false;
603  force_nl = true;/* must force newline after if */
604  ps.last_u_d = true; /* inform lexi that a following
605  * operator is unary */
606  ps.in_stmt = false; /* dont use stmt continuation
607  * indentation */
608 
609  parse(hd_type); /* let parser worry about if, or whatever */
610  }
611  ps.search_brace = btype_2; /* this should ensure that constructs
612  * such as main(){...} and int[]{...}
613  * have their braces put in the right
614  * place */
615  break;
616 
617  case unary_op: /* this could be any unary operation */
619  ps.procname[0] == '\0' && ps.paren_level == 0) {
620  /* pointer declarations */
621 
622  /*
623  * if this is a unary op in a declaration, we should indent
624  * this token
625  */
626  for (i = 0; token[i]; ++i)
627  /* find length of token */;
628  indent_declaration(dec_ind - i, tabs_to_var);
629  ps.dumped_decl_indent = true;
630  }
631  else if (ps.want_blank)
632  *e_code++ = ' ';
633 
634  {
635  int len = e_token - s_token;
636 
638  memcpy(e_code, token, len);
639  e_code += len;
640  }
641  ps.want_blank = false;
642  break;
643 
644  case binary_op: /* any binary operation */
645  {
646  int len = e_token - s_token;
647 
648  CHECK_SIZE_CODE(len + 1);
649  if (ps.want_blank)
650  *e_code++ = ' ';
651  memcpy(e_code, token, len);
652  e_code += len;
653  }
654  ps.want_blank = true;
655  break;
656 
657  case postop: /* got a trailing ++ or -- */
658  *e_code++ = token[0];
659  *e_code++ = token[1];
660  ps.want_blank = true;
661  break;
662 
663  case question: /* got a ? */
664  squest++; /* this will be used when a later colon
665  * appears so we can distinguish the
666  * <c>?<n>:<n> construct */
667  if (ps.want_blank)
668  *e_code++ = ' ';
669  *e_code++ = '?';
670  ps.want_blank = true;
671  break;
672 
673  case casestmt: /* got word 'case' or 'default' */
674  scase = true; /* so we can process the later colon properly */
675  goto copy_id;
676 
677  case colon: /* got a ':' */
678  if (squest > 0) { /* it is part of the <c>?<n>: <n> construct */
679  --squest;
680  if (ps.want_blank)
681  *e_code++ = ' ';
682  *e_code++ = ':';
683  ps.want_blank = true;
684  break;
685  }
686  if (ps.in_or_st) {
687  *e_code++ = ':';
688  ps.want_blank = false;
689  break;
690  }
691  ps.in_stmt = false; /* seeing a label does not imply we are in a
692  * stmt */
693  /*
694  * turn everything so far into a label
695  */
696  {
697  int len = e_code - s_code;
698 
699  CHECK_SIZE_LAB(len + 3);
700  memcpy(e_lab, s_code, len);
701  e_lab += len;
702  *e_lab++ = ':';
703  *e_lab = '\0';
704  e_code = s_code;
705  }
706  force_nl = ps.pcase = scase; /* ps.pcase will be used by
707  * dump_line to decide how to
708  * indent the label. force_nl
709  * will force a case n: to be
710  * on a line by itself */
711  scase = false;
712  ps.want_blank = false;
713  break;
714 
715  case semicolon: /* got a ';' */
716  if (ps.dec_nest == 0)
717  ps.in_or_st = false;/* we are not in an initialization or
718  * structure declaration */
719  scase = false; /* these will only need resetting in an error */
720  squest = 0;
721  if (ps.last_token == rparen)
723  ps.cast_mask = 0;
724  ps.not_cast_mask = 0;
725  ps.block_init = 0;
726  ps.block_init_level = 0;
727  ps.just_saw_decl--;
728 
729  if (ps.in_decl && s_code == e_code && !ps.block_init &&
730  !ps.dumped_decl_indent && ps.paren_level == 0) {
731  /* indent stray semicolons in declarations */
732  indent_declaration(dec_ind - 1, tabs_to_var);
733  ps.dumped_decl_indent = true;
734  }
735 
736  ps.in_decl = (ps.dec_nest > 0); /* if we were in a first level
737  * structure declaration, we
738  * arent any more */
739 
740  if ((!sp_sw || hd_type != forstmt) && ps.p_l_follow > 0) {
741 
742  /*
743  * This should be true iff there were unbalanced parens in the
744  * stmt. It is a bit complicated, because the semicolon might
745  * be in a for stmt
746  */
747  diag2(1, "Unbalanced parens");
748  ps.p_l_follow = 0;
749  if (sp_sw) { /* this is a check for an if, while, etc. with
750  * unbalanced parens */
751  sp_sw = false;
752  parse(hd_type); /* dont lose the if, or whatever */
753  }
754  }
755  *e_code++ = ';';
756  ps.want_blank = true;
757  ps.in_stmt = (ps.p_l_follow > 0); /* we are no longer in the
758  * middle of a stmt */
759 
760  if (!sp_sw) { /* if not if for (;;) */
761  parse(semicolon); /* let parser know about end of stmt */
762  force_nl = true;/* force newline after an end of stmt */
763  }
764  break;
765 
766  case lbrace: /* got a '{' */
767  ps.in_stmt = false; /* dont indent the {} */
768  if (!ps.block_init)
769  force_nl = true;/* force other stuff on same line as '{' onto
770  * new line */
771  else if (ps.block_init_level <= 0)
772  ps.block_init_level = 1;
773  else
775 
776  if (s_code != e_code && !ps.block_init) {
777  if (!btype_2) {
778  dump_line();
779  ps.want_blank = false;
780  }
781  else if (ps.in_parameter_declaration && !ps.in_or_st) {
782  ps.i_l_follow = 0;
783  if (function_brace_split) { /* dump the line prior to the
784  * brace ... */
785  dump_line();
786  ps.want_blank = false;
787  } else /* add a space between the decl and brace */
788  ps.want_blank = true;
789  }
790  }
793 
794  if (ps.p_l_follow > 0) { /* check for preceding unbalanced
795  * parens */
796  diag2(1, "Unbalanced parens");
797  ps.p_l_follow = 0;
798  if (sp_sw) { /* check for unclosed if, for, etc. */
799  sp_sw = false;
800  parse(hd_type);
802  }
803  }
804  if (s_code == e_code)
805  ps.ind_stmt = false; /* dont put extra indentation on line
806  * with '{' */
807  if (ps.in_decl && ps.in_or_st) { /* this is either a structure
808  * declaration or an init */
809  di_stack[ps.dec_nest] = dec_ind;
810  if (++ps.dec_nest == nitems(di_stack)) {
811  diag3(0, "Reached internal limit of %d struct levels",
812  nitems(di_stack));
813  ps.dec_nest--;
814  }
815  /* ? dec_ind = 0; */
816  }
817  else {
818  ps.decl_on_line = false; /* we can't be in the middle of
819  * a declaration, so don't do
820  * special indentation of
821  * comments */
826  ps.in_decl = false;
827  }
828  dec_ind = 0;
829  parse(lbrace); /* let parser know about this */
830  if (ps.want_blank) /* put a blank before '{' if '{' is not at
831  * start of line */
832  *e_code++ = ' ';
833  ps.want_blank = false;
834  *e_code++ = '{';
835  ps.just_saw_decl = 0;
836  break;
837 
838  case rbrace: /* got a '}' */
839  if (ps.p_stack[ps.tos] == decl && !ps.block_init) /* semicolons can be
840  * omitted in
841  * declarations */
842  parse(semicolon);
843  if (ps.p_l_follow) {/* check for unclosed if, for, else. */
844  diag2(1, "Unbalanced parens");
845  ps.p_l_follow = 0;
846  sp_sw = false;
847  }
848  ps.just_saw_decl = 0;
850  if (s_code != e_code && !ps.block_init) { /* '}' must be first on
851  * line */
852  if (verbose)
853  diag2(0, "Line broken");
854  dump_line();
855  }
856  *e_code++ = '}';
857  ps.want_blank = true;
858  ps.in_stmt = ps.ind_stmt = false;
859  if (ps.dec_nest > 0) { /* we are in multi-level structure
860  * declaration */
861  dec_ind = di_stack[--ps.dec_nest];
862  if (ps.dec_nest == 0 && !ps.in_parameter_declaration)
863  ps.just_saw_decl = 2;
864  ps.in_decl = true;
865  }
867  parse(rbrace); /* let parser know about this */
869  && ps.il[ps.tos] >= ps.ind_level;
870  if (ps.tos <= 1 && blanklines_after_procs && ps.dec_nest <= 0)
872  break;
873 
874  case swstmt: /* got keyword "switch" */
875  sp_sw = true;
876  hd_type = swstmt; /* keep this for when we have seen the
877  * expression */
878  goto copy_id; /* go move the token into buffer */
879 
880  case sp_paren: /* token is if, while, for */
881  sp_sw = true; /* the interesting stuff is done after the
882  * expression is scanned */
883  hd_type = (*token == 'i' ? ifstmt :
884  (*token == 'w' ? whilestmt : forstmt));
885 
886  /*
887  * remember the type of header for later use by parser
888  */
889  goto copy_id; /* copy the token into line */
890 
891  case sp_nparen: /* got else, do */
892  ps.in_stmt = false;
893  if (*token == 'e') {
894  if (e_code != s_code && (!cuddle_else || e_code[-1] != '}')) {
895  if (verbose)
896  diag2(0, "Line broken");
897  dump_line();/* make sure this starts a line */
898  ps.want_blank = false;
899  }
900  force_nl = true;/* also, following stuff must go onto new line */
901  last_else = 1;
902  parse(elselit);
903  }
904  else {
905  if (e_code != s_code) { /* make sure this starts a line */
906  if (verbose)
907  diag2(0, "Line broken");
908  dump_line();
909  ps.want_blank = false;
910  }
911  force_nl = true;/* also, following stuff must go onto new line */
912  last_else = 0;
913  parse(dolit);
914  }
915  goto copy_id; /* move the token into line */
916 
917  case type_def:
918  case storage:
920  goto copy_id;
921 
922  case structure:
923  if (ps.p_l_follow > 0)
924  goto copy_id;
925  /* FALLTHROUGH */
926  case decl: /* we have a declaration type (int, etc.) */
927  parse(decl); /* let parser worry about indentation */
928  if (ps.last_token == rparen && ps.tos <= 1) {
929  if (s_code != e_code) {
930  dump_line();
931  ps.want_blank = 0;
932  }
933  }
935  ps.ind_level = ps.i_l_follow = 1;
936  ps.ind_stmt = 0;
937  }
938  ps.in_or_st = true; /* this might be a structure or initialization
939  * declaration */
940  ps.in_decl = ps.decl_on_line = true;
941  if ( /* !ps.in_or_st && */ ps.dec_nest <= 0)
942  ps.just_saw_decl = 2;
944  for (i = 0; token[i++];); /* get length of token */
945 
946  if (ps.ind_level == 0 || ps.dec_nest > 0) {
947  /* global variable or struct member in local variable */
948  dec_ind = ps.decl_indent > 0 ? ps.decl_indent : i;
949  tabs_to_var = (use_tabs ? ps.decl_indent > 0 : 0);
950  } else {
951  /* local variable */
952  dec_ind = ps.local_decl_indent > 0 ? ps.local_decl_indent : i;
953  tabs_to_var = (use_tabs ? ps.local_decl_indent > 0 : 0);
954  }
955  goto copy_id;
956 
957  case funcname:
958  case ident: /* got an identifier or constant */
959  if (ps.in_decl) {
960  if (type_code == funcname) {
961  ps.in_decl = false;
962  if (procnames_start_line && s_code != e_code) {
963  *e_code = '\0';
964  dump_line();
965  }
966  else if (ps.want_blank) {
967  *e_code++ = ' ';
968  }
969  ps.want_blank = false;
970  }
971  else if (!ps.block_init && !ps.dumped_decl_indent &&
972  ps.paren_level == 0) { /* if we are in a declaration, we
973  * must indent identifier */
974  indent_declaration(dec_ind, tabs_to_var);
975  ps.dumped_decl_indent = true;
976  ps.want_blank = false;
977  }
978  }
979  else if (sp_sw && ps.p_l_follow == 0) {
980  sp_sw = false;
981  force_nl = true;
982  ps.last_u_d = true;
983  ps.in_stmt = false;
984  parse(hd_type);
985  }
986  copy_id:
987  {
988  int len = e_token - s_token;
989 
990  CHECK_SIZE_CODE(len + 1);
991  if (ps.want_blank)
992  *e_code++ = ' ';
993  memcpy(e_code, s_token, len);
994  e_code += len;
995  }
996  if (type_code != funcname)
997  ps.want_blank = true;
998  break;
999 
1000  case strpfx:
1001  {
1002  int len = e_token - s_token;
1003 
1004  CHECK_SIZE_CODE(len + 1);
1005  if (ps.want_blank)
1006  *e_code++ = ' ';
1007  memcpy(e_code, token, len);
1008  e_code += len;
1009  }
1010  ps.want_blank = false;
1011  break;
1012 
1013  case period: /* treat a period kind of like a binary
1014  * operation */
1015  *e_code++ = '.'; /* move the period into line */
1016  ps.want_blank = false; /* dont put a blank after a period */
1017  break;
1018 
1019  case comma:
1020  ps.want_blank = (s_code != e_code); /* only put blank after comma
1021  * if comma does not start the
1022  * line */
1023  if (ps.in_decl && ps.procname[0] == '\0' && !ps.block_init &&
1024  !ps.dumped_decl_indent && ps.paren_level == 0) {
1025  /* indent leading commas and not the actual identifiers */
1026  indent_declaration(dec_ind - 1, tabs_to_var);
1027  ps.dumped_decl_indent = true;
1028  }
1029  *e_code++ = ',';
1030  if (ps.p_l_follow == 0) {
1031  if (ps.block_init_level <= 0)
1032  ps.block_init = 0;
1033  if (break_comma && (!ps.leave_comma ||
1035  max_col - tabsize))
1036  force_nl = true;
1037  }
1038  break;
1039 
1040  case preesc: /* got the character '#' */
1041  if ((s_com != e_com) ||
1042  (s_lab != e_lab) ||
1043  (s_code != e_code))
1044  dump_line();
1045  CHECK_SIZE_LAB(1);
1046  *e_lab++ = '#'; /* move whole line to 'label' buffer */
1047  {
1048  int in_comment = 0;
1049  int com_start = 0;
1050  char quote = 0;
1051  int com_end = 0;
1052 
1053  while (*buf_ptr == ' ' || *buf_ptr == '\t') {
1054  buf_ptr++;
1055  if (buf_ptr >= buf_end)
1056  fill_buffer();
1057  }
1058  while (*buf_ptr != '\n' || (in_comment && !had_eof)) {
1059  CHECK_SIZE_LAB(2);
1060  *e_lab = *buf_ptr++;
1061  if (buf_ptr >= buf_end)
1062  fill_buffer();
1063  switch (*e_lab++) {
1064  case BACKSLASH:
1065  if (!in_comment) {
1066  *e_lab++ = *buf_ptr++;
1067  if (buf_ptr >= buf_end)
1068  fill_buffer();
1069  }
1070  break;
1071  case '/':
1072  if (*buf_ptr == '*' && !in_comment && !quote) {
1073  in_comment = 1;
1074  *e_lab++ = *buf_ptr++;
1075  com_start = e_lab - s_lab - 2;
1076  }
1077  break;
1078  case '"':
1079  if (quote == '"')
1080  quote = 0;
1081  break;
1082  case '\'':
1083  if (quote == '\'')
1084  quote = 0;
1085  break;
1086  case '*':
1087  if (*buf_ptr == '/' && in_comment) {
1088  in_comment = 0;
1089  *e_lab++ = *buf_ptr++;
1090  com_end = e_lab - s_lab;
1091  }
1092  break;
1093  }
1094  }
1095 
1096  while (e_lab > s_lab && (e_lab[-1] == ' ' || e_lab[-1] == '\t'))
1097  e_lab--;
1098  if (e_lab - s_lab == com_end && bp_save == NULL) {
1099  /* comment on preprocessor line */
1100  if (sc_end == NULL) { /* if this is the first comment,
1101  * we must set up the buffer */
1102  save_com = sc_buf;
1103  sc_end = &save_com[0];
1104  }
1105  else {
1106  *sc_end++ = '\n'; /* add newline between
1107  * comments */
1108  *sc_end++ = ' ';
1109  --line_no;
1110  }
1111  if (sc_end - save_com + com_end - com_start > sc_size)
1112  errx(1, "input too long");
1113  memmove(sc_end, s_lab + com_start, com_end - com_start);
1114  sc_end += com_end - com_start;
1115  e_lab = s_lab + com_start;
1116  while (e_lab > s_lab && (e_lab[-1] == ' ' || e_lab[-1] == '\t'))
1117  e_lab--;
1118  bp_save = buf_ptr; /* save current input buffer */
1119  be_save = buf_end;
1120  buf_ptr = save_com; /* fix so that subsequent calls to
1121  * lexi will take tokens out of
1122  * save_com */
1123  *sc_end++ = ' '; /* add trailing blank, just in case */
1124  buf_end = sc_end;
1125  sc_end = NULL;
1126  }
1127  CHECK_SIZE_LAB(1);
1128  *e_lab = '\0'; /* null terminate line */
1129  ps.pcase = false;
1130  }
1131 
1132  if (strncmp(s_lab, "#if", 3) == 0) { /* also ifdef, ifndef */
1133  if ((size_t)ifdef_level < nitems(state_stack)) {
1134  match_state[ifdef_level].tos = -1;
1135  state_stack[ifdef_level++] = ps;
1136  }
1137  else
1138  diag2(1, "#if stack overflow");
1139  }
1140  else if (strncmp(s_lab, "#el", 3) == 0) { /* else, elif */
1141  if (ifdef_level <= 0)
1142  diag2(1, s_lab[3] == 'i' ? "Unmatched #elif" : "Unmatched #else");
1143  else {
1144  match_state[ifdef_level - 1] = ps;
1145  ps = state_stack[ifdef_level - 1];
1146  }
1147  }
1148  else if (strncmp(s_lab, "#endif", 6) == 0) {
1149  if (ifdef_level <= 0)
1150  diag2(1, "Unmatched #endif");
1151  else
1152  ifdef_level--;
1153  } else {
1154  struct directives {
1155  int size;
1156  const char *string;
1157  }
1158  recognized[] = {
1159  {7, "include"},
1160  {6, "define"},
1161  {5, "undef"},
1162  {4, "line"},
1163  {5, "error"},
1164  {6, "pragma"}
1165  };
1166  int d = nitems(recognized);
1167  while (--d >= 0)
1168  if (strncmp(s_lab + 1, recognized[d].string, recognized[d].size) == 0)
1169  break;
1170  if (d < 0) {
1171  diag2(1, "Unrecognized cpp directive");
1172  break;
1173  }
1174  }
1177  n_real_blanklines = 0;
1178  }
1179  else {
1182  }
1183  break; /* subsequent processing of the newline
1184  * character will cause the line to be printed */
1185 
1186  case comment: /* we have gotten a / followed by * this is a biggie */
1187  pr_comment();
1188  break;
1189  } /* end of big switch stmt */
1190 
1191  *e_code = '\0'; /* make sure code section is null terminated */
1192  if (type_code != comment && type_code != newline && type_code != preesc)
1193  ps.last_token = type_code;
1194  } /* end of main while (1) loop */
1195 }
void set_profile(const char *profile_name)
Definition: args.c:176
void set_defaults(void)
Definition: args.c:246
void errx(int eval, const char *fmt,...)
Definition: err.c:58
#define malloc(a)
Definition: header.h:50
static void bakcopy(void)
Definition: indent.c:1203
const char * out_name
Definition: indent.c:61
static void indent_declaration(int, int)
Definition: indent.c:1243
int compute_code_target(void)
Definition: io.c:223
int lexi(struct parser_state *)
Definition: lexi.c:216
void diag2(int, const char *)
Definition: io.c:590
void diag3(int, const char *, int)
Definition: io.c:573
int count_spaces_until(int, char *, char *)
Definition: io.c:517
void pr_comment(void)
Definition: pr_comment.c:79
void alloc_typenames(void)
Definition: lexi.c:677
void fill_buffer(void)
Definition: io.c:346
void dump_line(void)
Definition: io.c:61
#define nitems(x)
Definition: indent.h:31
#define comma
Definition: indent_codes.h:48
#define form_feed
Definition: indent_codes.h:52
#define stmt
Definition: indent_codes.h:59
#define lparen
Definition: indent_codes.h:36
#define whilestmt
Definition: indent_codes.h:57
#define swstmt
Definition: indent_codes.h:50
#define sp_nparen
Definition: indent_codes.h:55
#define ifhead
Definition: indent_codes.h:64
#define rbrace
Definition: indent_codes.h:46
#define colon
Definition: indent_codes.h:43
#define postop
Definition: indent_codes.h:40
#define ifstmt
Definition: indent_codes.h:56
#define period
Definition: indent_codes.h:66
#define comment
Definition: indent_codes.h:49
#define question
Definition: indent_codes.h:41
#define lbrace
Definition: indent_codes.h:45
#define semicolon
Definition: indent_codes.h:44
#define ident
Definition: indent_codes.h:47
#define type_def
Definition: indent_codes.h:70
#define preesc
Definition: indent_codes.h:51
#define structure
Definition: indent_codes.h:71
#define forstmt
Definition: indent_codes.h:58
#define funcname
Definition: indent_codes.h:69
#define dolit
Definition: indent_codes.h:62
#define binary_op
Definition: indent_codes.h:39
#define elselit
Definition: indent_codes.h:61
#define casestmt
Definition: indent_codes.h:42
#define storage
Definition: indent_codes.h:68
#define newline
Definition: indent_codes.h:35
#define sp_paren
Definition: indent_codes.h:54
#define decl
Definition: indent_codes.h:53
#define unary_op
Definition: indent_codes.h:38
#define strpfx
Definition: indent_codes.h:67
#define rparen
Definition: indent_codes.h:37
char * l_token
int star_comment_cont
char * e_com
int verbose
char * tokenbuf
char * codebuf
int procnames_start_line
int block_comment_max_col
#define sc_size
Definition: indent_globs.h:37
int use_tabs
#define token
Definition: indent_globs.h:126
int blanklines_after_procs
int format_col1_comments
char * in_buffer
int space_after_cast
char * l_com
int had_eof
int btype_2
int lineup_to_parens
char * s_com
int postfix_blankline_requested
char * l_lab
struct parser_state state_stack[5]
char sc_buf[sc_size]
int proc_calls_space
char * buf_ptr
int prefix_blankline_requested
char * in_buffer_limit
char * save_com
char * e_token
int line_no
#define bufsize
Definition: indent_globs.h:36
int found_err
int Bill_Shannon
int extra_expression_indent
char * l_code
char * e_lab
char * labbuf
int function_brace_split
char * buf_end
char * s_lab
char * combuf
int max_col
int format_block_comments
int comment_delimiter_on_blankline
#define CHECK_SIZE_LAB(desired_size)
Definition: indent_globs.h:88
struct parser_state match_state[5]
int n_real_blanklines
char * s_token
int blanklines_around_conditional_compilation
char * sc_end
int break_comma
char * be_save
int swallow_optional_blanklines
int cuddle_else
#define BACKSLASH
Definition: indent_globs.h:35
int continuation_indent
int code_lines
char * bp_save
int ifdef_level
int lineup_to_parens_always
int blanklines_after_declarations_at_proctop
int i
Definition: isn.c:73
if(TABLE==NULL||TABLE_index==NULL)
Definition: isn.c:77
static void const char fflush(stdout)
exit(1)
bool set_option
const void size_t len
#define printf(...)
Definition: port.h:244
char string[11]
Definition: preproc-type.c:52
static struct subre * parse(struct vars *v, int stopper, int type, struct state *init, struct state *final)
Definition: regcomp.c:715
int unindent_displace
Definition: indent_globs.h:307
char procname[100]
Definition: indent_globs.h:327
int indent_parameters
Definition: indent_globs.h:325
int block_init_level
Definition: indent_globs.h:252
int dumped_decl_indent
Definition: indent_globs.h:321
float case_indent
Definition: indent_globs.h:322
int p_stack[256]
Definition: indent_globs.h:235
int local_decl_indent
Definition: indent_globs.h:319
int in_parameter_declaration
Definition: indent_globs.h:324
short paren_indents[20]
Definition: indent_globs.h:300

References alloc_typenames(), BACKSLASH, bakcopy(), be_save, Bill_Shannon, binary_op, parser_state::bl_line, blanklines_after_declarations_at_proctop, blanklines_after_procs, blanklines_around_conditional_compilation, block_comment_max_col, parser_state::block_init, parser_state::block_init_level, bp_save, break_comma, btype_2, buf_end, buf_ptr, bufsize, parser_state::case_indent, casestmt, parser_state::cast_mask, CHECK_SIZE_CODE, CHECK_SIZE_LAB, code_lines, codebuf, colon, parser_state::com_ind, parser_state::com_lines, combuf, comma, comment, comment_delimiter_on_blankline, compute_code_target(), continuation_indent, count_spaces_until(), cuddle_else, parser_state::dec_nest, decl, parser_state::decl_com_ind, parser_state::decl_indent, parser_state::decl_on_line, diag2(), diag3(), dolit, dump_line(), parser_state::dumped_decl_indent, e_code, e_com, e_lab, e_token, parser_state::else_if, elselit, err(), errx(), exit(), extra_expression_indent, fflush(), fill_buffer(), form_feed, format_block_comments, format_col1_comments, forstmt, found_err, funcname, function_brace_split, had_eof, i, parser_state::i_l_follow, ident, if(), ifdef_level, ifhead, ifstmt, parser_state::il, in_buffer, in_buffer_limit, parser_state::in_decl, in_name, parser_state::in_or_st, parser_state::in_parameter_declaration, parser_state::in_stmt, parser_state::ind_level, parser_state::ind_size, parser_state::ind_stmt, indent_declaration(), parser_state::indent_parameters, input, parser_state::just_saw_decl, parser_state::keyword, l_code, l_com, l_lab, l_token, labbuf, parser_state::last_nl, parser_state::last_token, parser_state::last_u_d, lbrace, parser_state::leave_comma, len, lexi(), line_no, lineup_to_parens, lineup_to_parens_always, parser_state::ljust_decl, parser_state::local_decl_indent, lparen, malloc, match_state, max_col, n_real_blanklines, newline, nitems, parser_state::not_cast_mask, parser_state::out_coms, parser_state::out_lines, out_name, output, parser_state::p_l_follow, parser_state::p_stack, parser_state::paren_indents, parser_state::paren_level, parse(), parser_state::pcase, period, postfix_blankline_requested, postop, pr_comment(), preesc, prefix_blankline_requested, printf, proc_calls_space, parser_state::procname, procnames_start_line, ps, question, rbrace, rparen, s_code, s_com, s_lab, s_token, save_com, sc_buf, sc_end, sc_size, parser_state::search_brace, semicolon, set_defaults(), set_option, set_profile(), sp_nparen, sp_paren, space_after_cast, star_comment_cont, state_stack, generate_unaccent_rules::stdout, stmt, storage, strpfx, structure, swallow_optional_blanklines, swstmt, tabsize, token, tokenbuf, parser_state::tos, type_def, unary_op, parser_state::unindent_displace, parser_state::use_ff, use_tabs, verbose, parser_state::want_blank, and whilestmt.

Variable Documentation

◆ bakfile

char bakfile[MAXPGPATH] = ""

Definition at line 63 of file indent.c.

Referenced by bakcopy().

◆ in_name

const char* in_name = "Standard Input"

Definition at line 59 of file indent.c.

Referenced by bakcopy(), and main().

◆ out_name

const char* out_name = "Standard Output"

Definition at line 61 of file indent.c.

Referenced by main().