int compute_code_target(void) { 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 { 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; }
int code_target() { register target_col = ps.ind_size * ps.ind_level + 1; if (ps.paren_level) if (!lineup_to_parens) target_col += continuation_indent * ps.paren_level; else { register w; register 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; }
/* Figure out where we should put the code in codebuf. Return the column number in spaces. */ int compute_code_target() { #ifdef MSDOS register int target_col = parser_state_tos->ind_level + 1; #else register target_col = parser_state_tos->ind_level + 1; #endif /* MSDOS */ if (parser_state_tos->paren_level) if (!lineup_to_parens) target_col += continuation_indent * parser_state_tos->paren_level; else { #ifdef MSDOS register int w; register int t = paren_target; #else register w; register t = paren_target; #endif /* MSDOS */ 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 (parser_state_tos->ind_stmt) target_col += continuation_indent; return target_col; }
int extract_opcode(char **line) { char **parts; int i; int nb_spaces; char *op_name; char *tmp; if (is_comment_or_empty(*line)) return (0); tmp = *line; nb_spaces = count_spaces(*line); parts = ft_split_whitespaces(*line); op_name = ft_strdup(parts[0]); i = 0; while (parts[i]) free(parts[i++]); free(parts); if (op_name != NULL) { return (get_code_value(op_name, line, tmp, nb_spaces)); } else throw_error(1); return (0); }
int main(void){ char inputStr[N + 1] = ""; printf("Enter a string with less than %d characters: ", N); gets(inputStr); printf("There a %d space characters\n", count_spaces(inputStr)); return 0; }
int main(int argc, char *argv[]) { if (argc != 2) { fprintf(stderr, "Usage: %s <string>\n", argv[0]); return 1; } printf("Spaces: %d\n", count_spaces(argv[1])); return 0; }
t_info how_many_spaces(t_flist *f_list, t_info max) { max.nlink = count_spaces(f_list->st.st_nlink, max.nlink); if (S_ISCHR(f_list->st.st_mode) || S_ISBLK(f_list->st.st_mode)) { max.dev = count_spaces(major(f_list->st.st_rdev), max.dev); max.size = count_spaces(minor(f_list->st.st_rdev), max.size); } else max.size = count_spaces(f_list->st.st_size, max.size); if (getgrgid(f_list->st.st_gid)) { if (ft_strlen(getgrgid(f_list->st.st_gid)->gr_name) > max.gid) max.gid = ft_strlen(getgrgid(f_list->st.st_gid)->gr_name); } else max.gid = count_spaces(f_list->st.st_gid, max.gid); if (getpwuid(f_list->st.st_uid)) { if (ft_strlen(getpwuid(f_list->st.st_uid)->pw_name) > max.uid) max.uid = ft_strlen(getpwuid(f_list->st.st_uid)->pw_name); } else max.uid = count_spaces(f_list->st.st_uid, max.uid); max.total += f_list->st.st_blocks; return (max); }
void parse_args(char *buf, t_data *data) { int n; int k; if ((buf = my_epur_str(buf)) == NULL) exit(1); data->n_max = count_spaces(buf) + 1; init_all_cmd(data, buf, data->n_max); n = 0; k = 0; word_tab(data, buf, n, k); free(buf); }
int main(int argc, char *argv[]) { int count = 0; const char *sentence = "this is a test"; count = count_spaces(sentence); printf("The sentence was: %s\n", sentence); printf("There were %d spaces in the sentence.", count); getchar(); getchar(); return 0; }
char *camelize(const char *s) { char *res = malloc((strlen(s) - count_spaces(s) + 1) * sizeof(char)); char *start = res; while (*s) { if (*s == ' ') *res++ = *++s - ('a' - 'A'); else *res++ = *s; s++; } *res = '\0'; return start; }
char *ft_strtrim(char const *s) { size_t len; size_t start; if (s) { len = count_spaces_return(s, ft_strlen(s)); start = count_spaces(s); if (!len && !start) return (ft_strdup(s)); else if (start == ft_strlen(s)) return (ft_strsub(s, 0, 0)); else return (ft_strsub(s, start, len - start + 1)); } return (NULL); }
char *ft_strtrim(char const *s) { int spaces; char *new_string; unsigned int i; unsigned int j; if (!s) return (NULL); spaces = count_spaces(s); i = 0; j = 0; new_string = (char*)malloc(sizeof(new_string) * (ft_strlen(s) - spaces)); if (new_string == NULL) return (NULL); if (spaces == 0) new_string = ft_strcpy(new_string, s); while (s[i] == ' ' || s[i] == '\t' || s[i] == '\n') i++; while (j < (ft_strlen(s) - spaces)) new_string[j++] = s[i++]; new_string[j] = '\0'; return (new_string); }
void pr_comment(void) { 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 unix_comment; /* tri-state variable used to decide if it is * a unix-style comment. 0 means only blanks * since /+*, 1 means regular style comment, 2 * means unix style comment */ int break_delim = comment_delimiter_on_blankline; int l_just_saw_decl = ps.just_saw_decl; /* * int ps.last_nl = 0; true iff the last significant thing * weve seen is a newline */ int one_liner = 1; /* true iff this comment is a one-liner */ adj_max_col = max_col; ps.just_saw_decl = 0; last_bl = 0; /* 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 */ unix_comment = 1; /* set flag to let us figure out if there is a * unix-style comment ** DISABLED: use 0 to * reenable this hack! */ /* 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; 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 = 0; } 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 = 0; 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); } 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 = ((target_col + 7) & ~7) + 1; if (ps.com_col + 24 > adj_max_col) adj_max_col = ps.com_col + 24; } } if (ps.box_com) { buf_ptr[-2] = 0; ps.n_comment_delta = 1 - count_spaces(1, in_buffer); 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++ = ' '; *e_com = '\0'; if (troff) { now_col = 1; adj_max_col = 80; } else now_col = count_spaces(ps.com_col, s_com); /* figure what column we * would be in if we * printed the comment * now */ /* Start to copy the comment */ while (1) { /* this loop will go until the comment is * copied */ if (*buf_ptr > 040 && *buf_ptr != '*') ps.last_nl = 0; CHECK_SIZE_COM; switch (*buf_ptr) { /* this checks for various spcl cases */ case 014: /* check for a form feed */ 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 = 0; *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"); *e_com = '\0'; dump_line(); return; } one_liner = 0; 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++ = ' '; *e_com++ = ' '; } *e_com = '\0'; if (!ps.box_com && e_com - s_com > 3) { if (break_delim == 1 && s_com[0] == '/' && s_com[1] == '*' && s_com[2] == ' ') { char *t = e_com; break_delim = 2; e_com = s_com + 2; *e_com = 0; if (blanklines_before_blockcomments) prefix_blankline_requested = 1; dump_line(); e_com = t; s_com[0] = s_com[1] = s_com[2] = ' '; } dump_line(); CHECK_SIZE_COM; *e_com++ = ' '; *e_com++ = ' '; } dump_line(); now_col = ps.com_col; } else { ps.last_nl = 1; if (unix_comment != 1) { /* we not are in unix_style * comment */ if (unix_comment == 0 && s_code == e_code) { /* * if it is a UNIX-style comment, ignore the * requirement that previous line be blank for * unindention */ ps.com_col = (ps.ind_level - ps.unindent_displace) * ps.ind_size + 1; if (ps.com_col <= 1) ps.com_col = 2; } unix_comment = 2; /* permanently remember that we are in * this type of comment */ dump_line(); ++line_no; now_col = ps.com_col; *e_com++ = ' '; /* * fix so that the star at the start of the line will line * up */ do /* flush leading white space */ if (++buf_ptr >= buf_end) fill_buffer(); while (*buf_ptr == ' ' || *buf_ptr == '\t'); break; } 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; CHECK_SIZE_COM; *e_com++ = ' '; ++now_col; } } ++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(); if (unix_comment == 0) /* set flag to show we are not in * unix-style comment */ unix_comment = 1; if (*buf_ptr == '/') { /* it is the end!!! */ end_of_comment: if (++buf_ptr >= buf_end) fill_buffer(); if (*(e_com - 1) != ' ' && !ps.box_com) { /* insure blank before * end */ *e_com++ = ' '; ++now_col; } if (break_delim == 1 && !one_liner && s_com[0] == '/' && s_com[1] == '*' && s_com[2] == ' ') { char *t = e_com; break_delim = 2; e_com = s_com + 2; *e_com = 0; if (blanklines_before_blockcomments) prefix_blankline_requested = 1; dump_line(); e_com = t; s_com[0] = s_com[1] = s_com[2] = ' '; } if (break_delim == 2 && e_com > s_com + 3 /* now_col > adj_max_col - 2 && !ps.box_com */ ) { *e_com = '\0'; dump_line(); now_col = ps.com_col; } CHECK_SIZE_COM; *e_com++ = '*'; *e_com++ = '/'; *e_com = '\0'; ps.just_saw_decl = l_just_saw_decl; return; } else { /* handle isolated '*' */ *e_com++ = '*'; ++now_col; } break; default: /* we have a random char */ if (unix_comment == 0 && *buf_ptr != ' ' && *buf_ptr != '\t') unix_comment = 1; /* we are not in unix-style comment */ *e_com = *buf_ptr++; if (buf_ptr >= buf_end) fill_buffer(); if (*e_com == '\t') /* keep track of column */ now_col = ((now_col - 1) & tabmask) + tabsize + 1; else if (*e_com == '\b') /* this is a backspace */ --now_col; else ++now_col; if (*e_com == ' ' || *e_com == '\t') last_bl = e_com; /* remember we saw a blank */ ++e_com; if (now_col > adj_max_col && !ps.box_com && unix_comment == 1 && e_com[-1] > ' ') { /* * the comment is too long, it must be broken up */ if (break_delim == 1 && s_com[0] == '/' && s_com[1] == '*' && s_com[2] == ' ') { char *t = e_com; break_delim = 2; e_com = s_com + 2; *e_com = 0; if (blanklines_before_blockcomments) prefix_blankline_requested = 1; dump_line(); e_com = t; s_com[0] = s_com[1] = s_com[2] = ' '; } if (last_bl == 0) { /* we have seen no blanks */ last_bl = e_com; /* fake it */ *e_com++ = ' '; } *e_com = '\0'; /* print what we have */ *last_bl = '\0'; while (last_bl > s_com && last_bl[-1] < 040) *--last_bl = 0; e_com = last_bl; dump_line(); *e_com++ = ' '; /* add blanks for continuation */ *e_com++ = ' '; *e_com++ = ' '; t_ptr = last_bl + 1; last_bl = 0; if (t_ptr >= e_com) { while (*t_ptr == ' ' || *t_ptr == '\t') t_ptr++; while (*t_ptr != '\0') { /* move unprinted part of * comment down in buffer */ if (*t_ptr == ' ' || *t_ptr == '\t') last_bl = e_com; *e_com++ = *t_ptr++; } } *e_com = '\0'; now_col = count_spaces(ps.com_col, s_com); /* recompute current * position */ } break; } } }
void dump_line() { /* 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 */ register int cur_col, target_col; static not_first_line; if (ps.procname[0]) { if (troff) { if (comment_open) { comment_open = 0; fprintf(output, ".*/\n"); } fprintf(output, ".Pr \"%s\"\n", ps.procname); } 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_opt_bl) { 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--; cur_col = pad_output(1, label_target()); 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 */ register char *p; if (comment_open) { comment_open = 0; fprintf(output, ".*/\n"); } target_col = code_target(); { register 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) if (troff) { int all_here = 0; register char *p; if (e_com[-1] == '/' && e_com[-2] == '*') e_com -= 2, all_here++; while (e_com > s_com && e_com[-1] == ' ') e_com--; *e_com = 0; p = s_com; while (*p == ' ') p++; if (p[0] == '/' && p[1] == '*') p += 2, all_here++; else if (p[0] == '*') p += p[1] == '/' ? 2 : 1; while (*p == ' ') p++; if (*p == 0) goto inhibit_newline; if (comment_open < 2 && ps.box_com) { comment_open = 0; fprintf(output, ".*/\n"); } if (comment_open == 0) { if ('a' <= *p && *p <= 'z') *p = *p + 'A' - 'a'; if (e_com - p < 50 && all_here == 2) { register char *follow = p; fprintf(output, "\n.nr C! \\w\1"); while (follow < e_com) { switch (*follow) { case '\n': putc(' ', output); case 1: break; case '\\': putc('\\', output); default: putc(*follow, output); } follow++; } putc(1, output); } fprintf(output, "\n./* %dp %d %dp\n", ps.com_col * 7, (s_code != e_code || s_lab != e_lab) - ps.box_com, target_col * 7); } comment_open = 1 + ps.box_com; while (*p) { if (*p == BACKSLASH) putc(BACKSLASH, output); putc(*p++, output); } } else { /* print comment, if any */ register target = ps.com_col; register char *com_st = s_com; target += ps.comment_delta; while (*com_st == '\t') com_st++, target += 8; /* ? */ while (target <= 0) if (*com_st == ' ') target++, com_st++; else if (*com_st == '\t') target = ((target - 1) & ~7) + 9, com_st++; else target = 1; if (cur_col > target) { /* if comment cant fit on this line, put it on next line */ putc('\n', output); cur_col = 1; ++ps.out_lines; } while (e_com > com_st && isspace(e_com[-1])) e_com--; cur_col = pad_output(cur_col, target); if (!ps.box_com) { if (star_comment_cont && (com_st[1] != '*' || e_com <= com_st + 1)) if (com_st[1] == ' ' && com_st[0] == ' ' && e_com > com_st + 1) com_st[1] = '*'; else fwrite(" * ", com_st[0] == '\t' ? 2 : com_st[0] == '*' ? 1 : 3, 1, output); } fwrite(com_st, (int)(e_com - com_st), 1, output); ps.comment_delta = ps.n_comment_delta; cur_col = count_spaces(cur_col, com_st); ++ps.com_lines; /* count lines with comments */ } if (ps.use_ff) putc('\014', output); else putc('\n', output); inhibit_newline: ++ps.out_lines; if (ps.just_saw_decl == 1 && bl_aft_decl) { 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 */ ps.ind_stmt = ps.in_stmt & ~ps.in_decl; /* next line should be indented if we have not completed this stmt and if we are not in the middle of a declaration */ 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) = '\0'; ps.ind_level = ps.i_l_follow; ps.paren_level = ps.p_l_follow; paren_target = -ps.paren_indents[ps.paren_level - 1]; not_first_line = 1; return; }
/* Parse a line like: "active raid1 sdb1[0] sdc1[1](F)" */ static guestfs_int_mdstat_list * parse_md_stat_line (char *line) { guestfs_int_mdstat_list *ret; guestfs_int_mdstat *t; size_t spaces, n, i, len; char *next; char *p, *q; ret = malloc (sizeof *ret); if (!ret) { reply_with_perror ("malloc"); return NULL; } /* We don't know exactly how many entries we will need yet, but we * can estimate it, and this will always be an over-estimate. */ spaces = count_spaces (line); ret->guestfs_int_mdstat_list_val = calloc (spaces+1, sizeof (struct guestfs_int_mdstat)); if (ret->guestfs_int_mdstat_list_val == NULL) { reply_with_perror ("calloc"); free (ret); return NULL; } for (n = 0; *line; line = next) { len = strcspn (line, " "); if (line[len] == '\0') next = &line[len]; else { line[len] = '\0'; next = &line[len+1]; } if (verbose) printf ("mdstat: %s\n", line); /* Looking for entries that contain "[..]", skip ones which don't. */ p = strchr (line, '['); if (p == NULL) continue; q = strchr (line, ']'); if (q == NULL) continue; if (p > q) continue; ret->guestfs_int_mdstat_list_len = n+1; t = &ret->guestfs_int_mdstat_list_val[n]; /* Device name is everything before the '[' character, but we * need to prefix with /dev/. */ if (p == line) { reply_with_error ("device entry is too short: %s", line); goto error; } *p = '\0'; if (asprintf (&t->mdstat_device, "/dev/%s", line) == -1) { reply_with_perror ("asprintf"); goto error; } /* Device index is the number after '['. */ line = p+1; *q = '\0'; if (sscanf (line, "%" SCNi32, &t->mdstat_index) != 1) { reply_with_error ("not a device number: %s", line); goto error; } /* Looking for flags "(F)(S)...". */ line = q+1; len = strlen (line); t->mdstat_flags = malloc (len+1); if (!t->mdstat_flags) { reply_with_error ("malloc"); goto error; } for (i = 0; *line; line++) { if (c_isalpha (*line)) t->mdstat_flags[i++] = *line; } t->mdstat_flags[i] = '\0'; n++; } return ret; error: for (i = 0; i < spaces+1; ++i) { free (ret->guestfs_int_mdstat_list_val[i].mdstat_device); free (ret->guestfs_int_mdstat_list_val[i].mdstat_flags); } free (ret->guestfs_int_mdstat_list_val); free (ret); return NULL; }
void dump_line(void) { /* 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 */ ps.ind_stmt = ps.in_stmt & ~ps.in_decl; /* next line should be * indented if we have not * completed this stmt and if * we are not in the middle of * a declaration */ 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; }
int main(int argc, char** argv) { std::string s = "There are 4 spaces here."; int i = count_spaces( s, std::locale()); return 0; }
dump_line () { /* 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 */ register int cur_col, temp_col, target_col; bl_line = true; /* if we don't find otherwise, assume a blank line */ if (ind_level == 0) ind_stmt = 0; /* this is a class A kludge. don't 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 (pcase) /* if the label is really a case, we must indent */ cur_col = pad_output (1, case_ind * ind_size + 1); else { if (*s_lab == '#') /* check for #define, etc */ cur_col = 1; else cur_col = pad_output (1, ind_size * (ind_level - label_offset) + 1); } write (output, s_lab, e_lab - s_lab); cur_col = count_spaces (cur_col, s_lab); /* count_spaces gives number of characters, considering tabs */ bl_line = false; /* line not blank after all */ } else cur_col = 1; /* there is no label section */ pcase = false; if (s_code != e_code) { /* print code section, if any */ target_col = ind_size * (ind_level + paren_level + ind_stmt) + 1; cur_col = pad_output (cur_col, target_col); /* pad_output writes enough tabs and spaces to get the current char position up to target_col */ write (output, s_code, e_code - s_code); cur_col = count_spaces (cur_col, s_code); bl_line = false; /* line not blank */ } if ((cur_col - 1) > max_col && output!=1)/* check for line too long */ printf ("%d: Code has %d chars, max is %d\n", line_no, (cur_col - 1), max_col); if (s_com != e_com) { /* print comment, if any */ if (cur_col > com_col && count_spaces (cur_col, s_com) >= max_col) { /* if comment can't fit on this line, put it on next line */ write (output, "\n", 1); cur_col = 1; ++out_lines; } cur_col = pad_output (cur_col, com_col); write (output, s_com, e_com - s_com); cur_col = count_spaces (cur_col, s_com); if ((cur_col - 1) > max_col && output!=1)/* check for too long comment */ printf ("%d: Comment goes to column %d. Max is %d\n", line_no, (cur_col - 1), max_col); bl_line = false; ++com_lines; /* count lines with comments */ } if (use_ff) write (output, &ff, 1);/* end the output with a ff */ else write (output, "\n", 1); /* or a newline */ use_ff = false; *(e_lab = s_lab) = '\0'; /* reset buffers */ *(e_code = s_code) = '\0'; *(e_com = s_com) = '\0'; ind_level = i_l_follow; paren_level = p_l_follow; ++out_lines; decl_on_line = in_decl; /* if we are in the middle of a declaration, remember that fact for proper comment indentation */ ind_stmt = in_stmt & ~in_decl; /* next line should be indented if we have not completed this stmt and if we are not in the middle of a declaration */ return; };
void dump_line() { /* 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 */ register int cur_col, target_col; static not_first_line; if (parser_state_tos->procname[0]) { if (troff) { if (comment_open) { comment_open = 0; fprintf(output, ".*/\n"); } fprintf(output, ".Pr \"%.*s\"\n", parser_state_tos->procname_end - parser_state_tos->procname, parser_state_tos->procname); } parser_state_tos->ind_level = 0; parser_state_tos->procname = "\0"; } if (s_code == e_code && s_lab == e_lab && s_com == e_com) { /* If we have a formfeed on a blank line, we should just output it, rather than treat it as a normal blank line. */ if (parser_state_tos->use_ff) { putc('\014',output); parser_state_tos->use_ff = false; } else { if (suppress_blanklines > 0) suppress_blanklines--; else { parser_state_tos->bl_line = true; n_real_blanklines++; } } } else if (!inhibit_formatting) { suppress_blanklines = 0; parser_state_tos->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 (parser_state_tos->ind_level == 0) parser_state_tos->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--; cur_col = pad_output(1, compute_label_target()); if (s_lab[0] == '#' && (strncmp(s_lab, "#else", 5) == 0 || strncmp(s_lab, "#endif", 6) == 0)) { /* Treat #else and #endif as a special case because any text after #else or #endif should be converted to a comment. */ register 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 */", e_lab - s, s); } else fprintf(output, "%.*s", e_lab - s_lab, s_lab); cur_col = count_spaces(cur_col, s_lab); } else cur_col = 1; /* there is no label section */ parser_state_tos->pcase = false; if (s_code != e_code) { /* print code section, if any */ register char *p; if (comment_open) { comment_open = 0; fprintf(output, ".*/\n"); } target_col = compute_code_target(); /* If a line ends in an lparen character, the following line should not line up with the parenthesis, but should be indented by the usual amount. */ if (parser_state_tos->last_token == lparen) { parser_state_tos->paren_indents[parser_state_tos->p_l_follow-1] += ind_size - 1; } { register i; for (i = 0; i < parser_state_tos->p_l_follow; i++) if (parser_state_tos->paren_indents[i] >= 0) parser_state_tos->paren_indents[i] = -(parser_state_tos->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) { if (troff) { int all_here = 0; register char *p; if (e_com[-1] == '/' && e_com[-2] == '*') e_com -= 2, all_here++; while (e_com > s_com && e_com[-1] == ' ') e_com--; *e_com = 0; p = s_com; while (*p == ' ') p++; if (p[0] == '/' && p[1] == '*') p += 2, all_here++; else if (p[0] == '*') p += p[1] == '/' ? 2 : 1; while (*p == ' ') p++; if (*p == 0) goto inhibit_newline; if (comment_open < 2 && parser_state_tos->box_com) { comment_open = 0; fprintf(output, ".*/\n"); } if (comment_open == 0) { if ('a' <= *p && *p <= 'z') *p = *p + 'A' - 'a'; if (e_com - p < 50 && all_here == 2) { register char *follow = p; fprintf(output, "\n.nr C! \\w\1"); while (follow < e_com) { switch (*follow) { case '\n': putc(' ', output); case 1: break; case '\\': putc('\\', output); default: putc(*follow, output); } follow++; } putc(1, output); } fprintf(output, "\n./* %dp %d %dp\n", parser_state_tos->com_col * 7, (s_code != e_code || s_lab != e_lab) - parser_state_tos->box_com, target_col * 7); } comment_open = 1 + parser_state_tos->box_com; while (*p) { if (*p == BACKSLASH) putc(BACKSLASH, output); putc(*p++, output); } } else { /* print comment, if any */ #ifdef MSDOS register int target = parser_state_tos->com_col; #else register target = parser_state_tos->com_col; #endif register char *com_st = s_com; target += parser_state_tos->comment_delta; while (*com_st == '\t') com_st++, target += 8; /* ? */ while (target <= 0) if (*com_st == ' ') target++, com_st++; else if (*com_st == '\t') target = ((target - 1) & ~7) + 9, com_st++; else target = 1; if (cur_col > target) { /* if comment cant fit on this line, * put it on next line */ putc('\n', output); cur_col = 1; ++parser_state_tos->out_lines; } while (e_com > com_st && isspace(e_com[-1])) e_com--; cur_col = pad_output(cur_col, target); if (!parser_state_tos->box_com) { if (star_comment_cont && (com_st[1] != '*' || e_com <= com_st + 1)) if (com_st[1] == ' ' && com_st[0] == ' ' && e_com > com_st + 1) com_st[1] = '*'; else fwrite(" * ", com_st[0] == '\t' ? 2 : com_st[0] == '*' ? 1 : 3, 1, output); } fwrite(com_st, e_com - com_st, 1, output); parser_state_tos->comment_delta = parser_state_tos->n_comment_delta; cur_col = count_spaces(cur_col, com_st); ++parser_state_tos->com_lines; /* count lines with comments */ } } if (parser_state_tos->use_ff) { putc('\014', output); parser_state_tos->use_ff = false; } else putc('\n', output); inhibit_newline: ++parser_state_tos->out_lines; if (parser_state_tos->just_saw_decl == 1 && blanklines_after_declarations) { prefix_blankline_requested = 1; parser_state_tos->just_saw_decl = 0; } else prefix_blankline_requested = postfix_blankline_requested; postfix_blankline_requested = 0; } parser_state_tos->decl_on_line = parser_state_tos->in_decl; /* if we are in the middle of a * declaration, remember that fact for * proper comment indentation */ parser_state_tos->ind_stmt = parser_state_tos->in_stmt & ~parser_state_tos->in_decl; /* next line should be * indented if we have not * completed this stmt and if * we are not in the middle of * a declaration */ parser_state_tos->dumped_decl_indent = 0; *(e_lab = s_lab) = '\0'; /* reset buffers */ *(e_code = s_code) = '\0'; *(e_com = s_com) = '\0'; parser_state_tos->ind_level = parser_state_tos->i_l_follow; parser_state_tos->paren_level = parser_state_tos->p_l_follow; paren_target = -parser_state_tos->paren_indents[parser_state_tos->paren_level - 1]; not_first_line = 1; return; }
pr_comment () { 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 unix_comment; /* tri-state variable used to decide if it is a unix-style comment. 0 means only blanks since /*, 1 means regular style comment, 2 means unix style comment */ int break_delim = comment_delimiter_on_blankline; int l_just_saw_decl = parser_state_tos->just_saw_decl; /* int parser_state_tos->last_nl = 0; /* true iff the last significant thing weve seen is a newline */ int one_liner = 1; /* true iff this comment is a one-liner */ adj_max_col = max_col; parser_state_tos->just_saw_decl = 0; last_bl = 0; /* no blanks found so far */ parser_state_tos->box_com = false; /* at first, assume that we are not in a boxed comment or some other comment that should not be touched */ ++out_coms; /* keep track of number of comments */ unix_comment = 1; /* set flag to let us figure out if there is a unix-style comment ** DISABLED: use 0 to reenable this hack! */ /* Figure where to align and how to treat the comment */ if (parser_state_tos->col_1 && !format_col1_comments) { /* if comment starts in column 1 it should not be touched */ parser_state_tos->box_com = true; parser_state_tos->com_col = 1; } else { if (*buf_ptr == '-' || *buf_ptr == '*' || !format_comments) { parser_state_tos->box_com = true; /* a comment with a '-' or '*' immediately after the /* is assumed to be a boxed comment */ break_delim = 0; } /* Used to also check that parser_state_tos->bl_line != 0 */ if ((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 */ parser_state_tos->com_col = (parser_state_tos->ind_level - unindent_displace) + 1; adj_max_col = block_comment_max_col; if (parser_state_tos->com_col <= 1) parser_state_tos->com_col = 1 + !format_col1_comments; /* If we have a comment in an old-style (pre-ANSI) parameter declaration, indent it like we would the parameter declaration. For example: int destroy (what) / * N things to destroy. * / int what; */ if (parser_state_tos->in_parameter_declaration && indent_parameters != 0 && parser_state_tos->dec_nest == 0) { parser_state_tos->com_col = indent_parameters + 1; parser_state_tos->ind_stmt = 0; } } else { register target_col; break_delim = 0; 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); } parser_state_tos->com_col = parser_state_tos->decl_on_line || parser_state_tos->ind_level == 0 ? decl_com_ind : com_ind; /* If we are already past the position for the comment, put it at the next tab stop. */ if (parser_state_tos->com_col < target_col) parser_state_tos->com_col = ((target_col + (tabsize - 1)) & ~(tabsize - 1)) + 1; if (else_or_endif) { parser_state_tos->com_col = else_endif_col; else_or_endif = false; /* We want the comment to appear one space after the #else or #endif. */ if (parser_state_tos->com_col < target_col) parser_state_tos->com_col = target_col + 1; } if (parser_state_tos->com_col + 24 > adj_max_col) adj_max_col = parser_state_tos->com_col + 24; } } if (parser_state_tos->box_com) { parser_state_tos->n_comment_delta = 1 - parser_state_tos->com_col; #if 0 buf_ptr[-2] = 0; parser_state_tos->n_comment_delta = 1 - count_spaces (1, cur_line); buf_ptr[-2] = '/'; #endif } else { parser_state_tos->n_comment_delta = 0; while (*buf_ptr == ' ' || *buf_ptr == '\t') buf_ptr++; } parser_state_tos->comment_delta = 0; *e_com++ = '/'; /* put '/*' into buffer */ *e_com++ = '*'; if (*buf_ptr != ' ' && !parser_state_tos->box_com) *e_com++ = ' '; *e_com = '\0'; if (troff) { now_col = 1; adj_max_col = 80; } else /* figure what column we would be in if we printed the comment now */ now_col = count_spaces (parser_state_tos->com_col, s_com); /* Start to copy the comment */ while (1) { /* this loop will go until the comment is copied */ if (*buf_ptr > 040 && *buf_ptr != '*') parser_state_tos->last_nl = 0; check_com_size; switch (*buf_ptr) { /* this checks for various spcl cases */ case 014: /* check for a form feed */ if (!parser_state_tos->box_com) { /* in a text comment, break the line here */ parser_state_tos->use_ff = true; /* fix so dump_line uses a form feed */ dump_line (); last_bl = 0; *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"); *e_com = '\0'; dump_line (); return; } one_liner = 0; if (parser_state_tos->box_com || parser_state_tos->last_nl) { /* if this is a boxed comment, we dont ignore the newline */ if (s_com == e_com) { *e_com++ = ' '; *e_com++ = ' '; } *e_com = '\0'; if (!parser_state_tos->box_com && e_com - s_com > 3) { if (break_delim == 1 && s_com[0] == '/' && s_com[1] == '*' && s_com[2] == ' ') { char *t = e_com; break_delim = 2; e_com = s_com + 2; *e_com = 0; if (blanklines_before_blockcomments) prefix_blankline_requested = 1; dump_line (); e_com = t; s_com[0] = s_com[1] = s_com[2] = ' '; } dump_line (); check_com_size; *e_com++ = ' '; *e_com++ = ' '; } dump_line (); now_col = parser_state_tos->com_col; } else { parser_state_tos->last_nl = 1; if (unix_comment != 1) { /* we not are in unix_style comment */ if (unix_comment == 0 && s_code == e_code) { /* if it is a UNIX-style comment, ignore the requirement that previous line be blank for unindention */ parser_state_tos->com_col = ((parser_state_tos->ind_level - unindent_displace) + ind_size); if (parser_state_tos->com_col <= 1) parser_state_tos->com_col = 2; } unix_comment = 2; /* permanently remember that we are in this type of comment */ dump_line (); ++line_no; now_col = parser_state_tos->com_col; *e_com++ = ' '; /* fix so that the star at the start of the line will line up */ do /* flush leading white space */ if (++buf_ptr >= buf_end) fill_buffer (); while (*buf_ptr == ' ' || *buf_ptr == '\t'); break; } 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; check_com_size; *e_com++ = ' '; ++now_col; } } ++line_no; /* keep track of input line number */ if (!parser_state_tos->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 (); if (unix_comment == 0) /* set flag to show we are not in unix-style comment */ unix_comment = 1; if (*buf_ptr == '/') { /* it is the end!!! */ end_of_comment: if (++buf_ptr >= buf_end) fill_buffer (); if (*(e_com - 1) != ' ' && !parser_state_tos->box_com) { /* insure blank before end */ *e_com++ = ' '; ++now_col; } if (break_delim == 1 && !one_liner && s_com[0] == '/' && s_com[1] == '*' && s_com[2] == ' ') { char *t = e_com; break_delim = 2; e_com = s_com + 2; *e_com = 0; if (blanklines_before_blockcomments) prefix_blankline_requested = 1; dump_line (); e_com = t; s_com[0] = s_com[1] = s_com[2] = ' '; } if (break_delim == 2 && e_com > s_com + 3 /* now_col > adj_max_col - 2 && !parser_state_tos->box_com */ ) { *e_com = '\0'; dump_line (); now_col = parser_state_tos->com_col; } check_com_size; *e_com++ = '*'; *e_com++ = '/'; *e_com = '\0'; parser_state_tos->just_saw_decl = l_just_saw_decl; return; } else { /* handle isolated '*' */ *e_com++ = '*'; ++now_col; } break; default: /* we have a random char */ if (unix_comment == 0 && *buf_ptr != ' ' && *buf_ptr != '\t') unix_comment = 1; /* we are not in unix-style comment */ *e_com = *buf_ptr++; if (buf_ptr >= buf_end) fill_buffer (); if (*e_com == '\t') /* keep track of column */ now_col = now_col + tabsize - (now_col - 1) % tabsize; else if (*e_com == '\b') /* this is a backspace */ --now_col; else ++now_col; if (*e_com == ' ' || *e_com == '\t') last_bl = e_com; /* remember we saw a blank */ ++e_com; if (now_col > adj_max_col && !parser_state_tos->box_com && unix_comment == 1 && e_com[-1] > ' ') { /* the comment is too long, it must be broken up */ if (break_delim == 1 && s_com[0] == '/' && s_com[1] == '*' && s_com[2] == ' ') { char *t = e_com; break_delim = 2; e_com = s_com + 2; *e_com = 0; if (blanklines_before_blockcomments) prefix_blankline_requested = 1; dump_line (); e_com = t; s_com[0] = s_com[1] = s_com[2] = ' '; } if (last_bl == 0) { /* we have seen no blanks */ last_bl = e_com; /* fake it */ *e_com++ = ' '; } *e_com = '\0'; /* print what we have */ *last_bl = '\0'; while (last_bl > s_com && last_bl[-1] < 040) *--last_bl = 0; e_com = last_bl; dump_line (); *e_com++ = ' '; /* add blanks for continuation */ *e_com++ = ' '; *e_com++ = ' '; t_ptr = last_bl + 1; last_bl = 0; if (t_ptr >= e_com) { while (*t_ptr == ' ' || *t_ptr == '\t') t_ptr++; while (*t_ptr != '\0') { /* move unprinted part of comment down in buffer */ if (*t_ptr == ' ' || *t_ptr == '\t') last_bl = e_com; *e_com++ = *t_ptr++; } } *e_com = '\0'; /* recompute current position */ now_col = count_spaces (parser_state_tos->com_col, s_com); } break; } } }
dump_line() { /* 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 */ register int cur_col, temp_col, target_col; if (ps.procname[0]) { if (troff) fprintf(output, ".Pr \"%s\"\n", ps.procname); 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) 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--; cur_col = pad_output(1, compute_label_target()); fprintf(output, "%.*s", 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 */ register char *p; if (comment_open) { comment_open = 0; fprintf(output, ".*/\n"); } target_col = compute_code_target(); { register 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 == 0200) fprintf(output, "%d", target_col * 7); else putc(*p, output); cur_col = count_spaces(cur_col, s_code); } if (s_com != e_com) if (troff) { register char *p; if (e_com[-1] == '/' && e_com[-2] == '*') e_com -= 2; while (e_com > s_com && e_com[-1] == ' ') e_com--; *e_com = 0; p = s_com; while (*p == ' ') p++; if (p[0] == '/' && p[1] == '*') p += 2; else if (p[0] == '*') p += p[1] == '/' ? 2 : 1; while (*p == ' ') p++; if (*p == 0) goto inhibit_newline; if (!comment_open) { if ('a' <= *p && *p <= 'z') *p = *p + 'A' - 'a'; if (s_code != e_code || s_lab != e_lab) { fprintf(output, "\\c\n./* %dp 1 %dp\n", ps.com_col * 7, target_col * 7); } else fprintf(output, "./* %dp 0 %dp\n", ps.com_col * 7, target_col * 7); } comment_open = 1; while (*p) { if (*p == BACKSLASH) putc(BACKSLASH, output); putc(*p++, output); } } else { /* print comment, if any */ register target = ps.com_col; register char *com_st = s_com; target += ps.comment_delta; while (target <= 0) if (*s_com == ' ') target++, s_com++; else if (*s_com == '\t') target = ((target - 1) & ~7) + 9, s_com++; else target = 1; if (cur_col > target) { /* if comment cant fit on this * line, put it on next line */ putc('\n', output); cur_col = 1; ++ps.out_lines; } cur_col = pad_output(cur_col, target); if (!ps.box_com) { if (star_comment_cont && com_st[1] != '*') if (com_st[1] == ' ' && com_st[0] == ' ') com_st[1] = '*'; else fwrite(" * ", com_st[0] == '\t' ? 2 : com_st[0] == '*' ? 1 : 3, 1, output); } fwrite(com_st, e_com - com_st, 1, output); ps.comment_delta = ps.n_comment_delta; cur_col = count_spaces(cur_col, com_st); ++ps.com_lines; /* count lines with comments */ } if (ps.use_ff) putc('\014', output); else putc('\n', output); inhibit_newline: ++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 */ ps.ind_stmt = ps.in_stmt & ~ps.in_decl; /* next line should be * indented if we have not * completed this stmt and * if we are not in the * middle of a declaration */ 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) = '\0'; ps.ind_level = ps.i_l_follow; ps.paren_level = ps.p_l_follow; paren_target = -ps.paren_indents[ps.paren_level - 1]; return; };