niceprintf.c File Reference

#include "defs.h"
#include "names.h"
#include "output.h"
#include "stdarg.h"

Include dependency graph for niceprintf.c:

Go to the source code of this file.

Defines
#define	TOO_LONG_INDENT   (2 * tab_size)
#define	MAX_INDENT   44
#define	MIN_INDENT   22
#define	SPRINTF(x, a, b, c, d, e, f, g)   vsprintf(x,a,ap)
#define	max_line_len   c_output_line_length
#define	isident(x)   (Tr[x] & 1)
#define	isntident(x)   (!Tr[x])
Functions
static void ind_printf	Argdcl ((int, FILE *, const char *, va_list))
static void	write_indent (FILE *fp, int use_indent, int extra_indent, char *start, char *end)
void	margin_printf (FILE *fp, const char *fmt,...)
void	nice_printf (FILE *fp, const char *fmt,...)
void	np_init (Void)
static char *	adjust_pointer_in_string (register char *pointer)
static void	fwd_strcpy (register char *t, register char *s)
static void	ind_printf (int use_indent, FILE *fp, const char *a, va_list ap)
Variables
static int	last_was_newline = 0
int	sharp_line = 0
int	indent = 0
int	in_comment = 0
int	in_define = 0
int	gflag1
char	filename []
static char *	output_buf
static char *	next_slot
static char *	string_start
static char *	word_start = NULL
static int	cursor_pos = 0
static int	In_string = 0

---

Define Documentation

#define isident

(

x

)

(Tr[x] & 1)

Definition at line 214 of file niceprintf.c.

Referenced by ind_printf().

#define isntident

(

x

)

(!Tr[x])

Definition at line 215 of file niceprintf.c.

Referenced by ind_printf().

#define MAX_INDENT   44

Definition at line 32 of file niceprintf.c.

Referenced by ind_printf(), and write_indent().

#define max_line_len   c_output_line_length

Definition at line 138 of file niceprintf.c.

Referenced by ind_printf().

#define MIN_INDENT   22

Definition at line 33 of file niceprintf.c.

Referenced by ind_printf(), and write_indent().

#define SPRINTF	(	x,
		a,
		b,
		c,
		d,
		e,
		f,
		g		)	vsprintf(x,a,ap)

Definition at line 117 of file niceprintf.c.

Referenced by ind_printf().

#define TOO_LONG_INDENT   (2 * tab_size)

Definition at line 31 of file niceprintf.c.

Referenced by ind_printf().

---

Function Documentation

static char* adjust_pointer_in_string

(

register char *

pointer

)

[static]

Definition at line 169 of file niceprintf.c.

References s, and s1.

Referenced by ind_printf().

{
        register char *s, *s1, *se, *s0;

        /* arrange not to break \002 */
        s1 = string_start ? string_start : output_buf;
        for(s = s1; s < pointer; s++) {
                s0 = s1;
                s1 = s;
                if (*s == '\\') {
                        se = s++ + 4;
                        if (se > pointer)
                                break;
                        if (*s < '0' || *s > '7')
                                continue;
                        while(++s < se)
                                if (*s < '0' || *s > '7')
                                        break;
                        --s;
                        }
                }
        return s0 - 1;
        }

Here is the caller graph for this function:

static void ind_printf Argdcl

(

(int, FILE *, const char *, va_list)

)

[static]

static void fwd_strcpy	(	register char *	t,
		register char *	s
	)			[static]

Definition at line 203 of file niceprintf.c.

Referenced by ind_printf().

{ while(*t++ = *s++); }

Here is the caller graph for this function:

static void ind_printf	(	int	use_indent,
		FILE *	fp,
		const char *	a,
		va_list	ap
	)			[static]

Definition at line 225 of file niceprintf.c.

References adjust_pointer_in_string(), Ansi, c_file, fatalstr(), fwd_strcpy(), gflag1, in_comment, in_define, ind, indent, isident, isntident, last_was_newline, MAX_INDENT, max_line_len, MIN_INDENT, NULL, sharp_line, SPRINTF, strchr(), TOO_LONG_INDENT, tr_tab, and write_indent().

Referenced by margin_printf(), and nice_printf().

{
    extern int max_line_len;
    extern FILEP c_file;
    extern char tr_tab[];       /* in output.c */
    register char *Tr = tr_tab;
    int ch, cmax, inc, ind;
    static int extra_indent, last_indent, set_cursor = 1;

    cursor_pos += indent - last_indent;
    last_indent = indent;
    SPRINTF (next_slot, a, b, c, d, e, f, g);

    if (fp != c_file) {
        fprintf (fp,"%s", next_slot);
        return;
    } /* if fp != c_file */

    do {
        char *pointer;

/* The   for   loop will parse one output line */

        if (set_cursor) {
                ind = indent <= MAX_INDENT
                        ? indent
                        : MIN_INDENT + indent % (MAX_INDENT - MIN_INDENT);
                cursor_pos = extra_indent;
                if (use_indent)
                        cursor_pos += ind;
                set_cursor = 0;
                }
        if (in_comment) {
                cmax = max_line_len + 32;       /* let comments be wider */
                for (pointer = next_slot; *pointer && *pointer != '\n' &&
                                cursor_pos <= cmax; pointer++)
                        cursor_pos++;
                }
        else
          for (pointer = next_slot; *pointer && *pointer != '\n' &&
                cursor_pos <= max_line_len; pointer++) {

            /* Update state variables here */

            if (In_string) {
                switch(*pointer) {
                        case '\\':
                                if (++cursor_pos > max_line_len) {
                                        cursor_pos -= 2;
                                        --pointer;
                                        goto overflow;
                                        }
                                ++pointer;
                                break;
                        case '"':
                                In_string = 0;
                                word_start = 0;
                        }
                }
            else switch (*pointer) {
                case '"':
                        if (cursor_pos + 5 > max_line_len) {
                                word_start = 0;
                                --pointer;
                                goto overflow;
                                }
                        In_string = 1;
                        string_start = word_start = pointer;
                        break;
                case '\'':
                        if (pointer[1] == '\\')
                                if ((ch = pointer[2]) >= '0' && ch <= '7')
                                        for(inc = 3; pointer[inc] != '\''
                                                && ++inc < 5;);
                                else
                                        inc = 3;
                        else
                                inc = 2;
                        /*debug*/ if (pointer[inc] != '\'')
                        /*debug*/  fatalstr("Bad character constant %.10s",
                                        pointer);
                        if ((cursor_pos += inc) > max_line_len) {
                                cursor_pos -= inc;
                                word_start = 0;
                                --pointer;
                                goto overflow;
                                }
                        word_start = pointer;
                        pointer += inc;
                        break;
                case '\t':
                    cursor_pos = 8 * ((cursor_pos + 8) / 8) - 1;
                    break;
                default: {

/* HACK  Assumes that all characters in an atomic C token will be written
   at the same time.  Must check for tokens first, since '-' is considered
   part of an identifier; checking isident first would mean breaking up "->" */

                    if (word_start) {
                        if (isntident(*(unsigned char *)pointer))
                                word_start = NULL;
                        }
                    else if (isident(*(unsigned char *)pointer))
                        word_start = pointer;
                    break;
                } /* default */
            } /* switch */
            cursor_pos++;
        } /* for pointer = next_slot */
 overflow:
        if (*pointer == '\0') {

/* The output line is not complete, so break out and don't output
   anything.  The current line fragment will be stored in the buffer */

            next_slot = pointer;
            break;
        } else {
            char last_char;
            int in_string0 = In_string;

/* If the line was too long, move   pointer   back to the character before
   the current word.  This allows line breaking on word boundaries.  Make
   sure that 80 character comment lines get broken up somehow.  We assume
   that any non-string 80 character identifier must be in a comment.
*/

            if (*pointer == '\n')
                in_define = 0;
            else if (word_start && word_start > output_buf)
                if (In_string)
                        if (string_start && pointer - string_start < 5)
                                pointer = string_start - 1;
                        else {
                                pointer = adjust_pointer_in_string(pointer);
                                string_start = 0;
                                }
                else if (word_start == string_start
                                && pointer - string_start >= 5) {
                        pointer = adjust_pointer_in_string(next_slot);
                        In_string = 1;
                        string_start = 0;
                        }
                else
                        pointer = word_start - 1;
            else if (cursor_pos > max_line_len) {
#ifndef ANSI_Libraries
                extern char *strchr();
#endif
                if (In_string) {
                        pointer = adjust_pointer_in_string(pointer);
                        if (string_start && pointer > string_start)
                                string_start = 0;
                        }
                else if (strchr("&*+-/<=>|", *pointer)
                        && strchr("!%&*+-/<=>^|", pointer[-1])) {
                        pointer -= 2;
                        if (strchr("<>", *pointer)) /* <<=, >>= */
                                pointer--;
                        }
                else {
                        if (word_start)
                                while(isident(*(unsigned char *)pointer))
                                        pointer++;
                        pointer--;
                        }
                }
            last_char = *pointer;
            write_indent(fp, use_indent, extra_indent, output_buf, pointer);
            next_slot = output_buf;
            if (In_string && !string_start && Ansi == 1 && last_char != '\n')
                *next_slot++ = '"';
            fwd_strcpy(next_slot, pointer + 1);

/* insert a line break */

            if (last_char == '\n') {
                if (In_string)
                        last_was_newline = 0;
                else {
                        last_was_newline = 1;
                        extra_indent = 0;
                        sharp_line = gflag1;
                        }
                }
            else {
                extra_indent = TOO_LONG_INDENT;
                if (In_string && !string_start) {
                        if (Ansi == 1) {
                                fprintf(fp, gflag1 ? "\"\\\n" : "\"\n");
                                use_indent = 1;
                                last_was_newline = 1;
                                }
                        else {
                                fprintf(fp, "\\\n");
                                last_was_newline = 0;
                                }
                        In_string = in_string0;
                        }
                else {
                        if (in_define/* | gflag1*/)
                                putc('\\', fp);
                        putc ('\n', fp);
                        last_was_newline = 1;
                        }
            } /* if *pointer != '\n' */

            if (In_string && Ansi != 1 && !string_start)
                cursor_pos = 0;
            else
                set_cursor = 1;

            string_start = word_start = NULL;

        } /* else */

    } while (*next_slot);

} /* ind_printf */

Here is the call graph for this function:

Here is the caller graph for this function:

void margin_printf	(	FILE *	fp,
		const char *	fmt,
			...
	)

Definition at line 120 of file niceprintf.c.

References ind_printf().

Referenced by do_p1_comment(), do_p1_label(), ref_defs(), wr_globals(), wr_one_init(), and write_char_init().

{
        va_list ap;
        va_start(ap,fmt);
        ind_printf(0, fp, fmt, ap);
        va_end(ap);
        }

Here is the call graph for this function:

Here is the caller graph for this function:

void nice_printf	(	FILE *	fp,
		const char *	fmt,
			...
	)

Definition at line 129 of file niceprintf.c.

References ind_printf().

Referenced by Ado_string(), commonprotos(), compgoto_out(), def_commons(), def_start(), do_init_data(), do_p1_1while(), do_p1_2while(), do_p1_elseifstart(), do_p1_goto(), do_p1_head(), do_p1_subr_ret(), do_string(), do_uninit_equivs(), entry_goto(), expr_out(), extern_out(), fill_dcl(), list_arg_types(), list_init_data(), listargs(), main(), opconv_fudge(), other_undefs(), out_addr(), out_and_free_statement(), out_args(), out_asgoto(), out_call(), out_const(), out_end_for(), out_for(), out_if(), out_name(), output_arg_list(), output_binary(), output_list(), output_literal(), output_prim(), output_rbrace(), output_unary(), prolog(), protowrite(), put_semi(), putentries(), ref_defs(), start_formatting(), wr_abbrevs(), wr_ardecls(), wr_array_init(), wr_char_len(), wr_common_decls(), wr_equiv_init(), wr_globals(), wr_nv_ident_help(), wr_one_init(), wr_struct(), write_assigned_fmts(), write_comment(), write_formats(), write_ioblocks(), write_namelists(), and write_typedefs().

{
        va_list ap;
        va_start(ap,fmt);
        ind_printf(1, fp, fmt, ap);
        va_end(ap);
        }

Here is the call graph for this function:

Here is the caller graph for this function:

void np_init

(

Void

)

Definition at line 158 of file niceprintf.c.

References Alloc(), MAX_OUTPUT_SIZE, and memset().

Referenced by fileinit().

{
        next_slot = output_buf = Alloc(MAX_OUTPUT_SIZE);
        memset(output_buf, 0, MAX_OUTPUT_SIZE);
        }

Here is the call graph for this function:

Here is the caller graph for this function:

static void write_indent	(	FILE *	fp,
		int	use_indent,
		int	extra_indent,
		char *	start,
		char *	end
	)			[static]

Definition at line 53 of file niceprintf.c.

References filename, in_define, ind, indent, last_was_newline, lineno, MAX_INDENT, MIN_INDENT, and sharp_line.

Referenced by ind_printf().

{
    int ind, tab;

    if (sharp_line) {
        fprintf(fp, "#line %ld \"%s\"\n", lineno, filename);
        sharp_line = 0;
        }
    if (in_define == 1) {
        in_define = 2;
        use_indent = 0;
        }
    if (last_was_newline && use_indent) {
        if (*start == '\n') do {
                putc('\n', fp);
                if (++start > end)
                        return;
                }
                while(*start == '\n');

        ind = indent <= MAX_INDENT
                ? indent
                : MIN_INDENT + indent % (MAX_INDENT - MIN_INDENT);

        tab = ind + extra_indent;

        while (tab > 7) {
            putc ('\t', fp);
            tab -= 8;
        } /* while */

        while (tab-- > 0)
            putc (' ', fp);
    } /* if last_was_newline */

    while (start <= end)
        putc (*start++, fp);
} /* write_indent */

Here is the caller graph for this function:

---

Variable Documentation

int cursor_pos = 0 [static]

Definition at line 154 of file niceprintf.c.

char filename[]

Definition at line 81 of file format.c.

Referenced by C2F(), DeleteDirectory(), getfilenamehistory(), Load(), PrintPs(), Save(), SavePs(), write_indent(), and XmuLocatePixmapFile().

int gflag1

Definition at line 84 of file format.c.

Referenced by ind_printf().

int in_comment = 0

Definition at line 37 of file niceprintf.c.

Referenced by do_p1_comment(), and ind_printf().

int in_define = 0

Definition at line 38 of file niceprintf.c.

Referenced by def_start(), ind_printf(), and write_indent().

int In_string = 0 [static]

Definition at line 155 of file niceprintf.c.

int indent = 0

Definition at line 36 of file niceprintf.c.

Referenced by Check(), CheckCOLUMN(), CheckOptDim(), CheckOptSquare(), CheckROW(), CheckSCALAR(), CheckSquare(), CheckVECTOR(), CreCommon(), CreDIMFOREXT(), CreIMATRIX(), CrePOINTER(), CreSPARSE(), CreSTRINGMAT(), Generate(), GetCOLUMN(), GetCom(), GetIMATRIX(), GetPOINTER(), GetPOLYNOM(), GetROW(), GetSCALAR(), GetSPARSE(), GetSTRINGMAT(), GetVECTOR(), ind_printf(), OptMATRIX(), OptOpointer(), OutCommon(), OutExtBMATRIX1(), OutExtCommon(), OutExtIMATRIX(), OutExtPOLYNOM(), OutExtSPARSE(), OutExtSTRING(), OutExtSTRINGMAT(), OutIMATRIX(), OutLISTarg(), OutPOLYNOM(), OutSPARSE(), OutSTRINGMAT(), write_indent(), WriteArgCheck(), WriteCallConvertion(), WriteCallRest(), WriteCallRestCheck(), WriteCrossCheck(), WriteDeclaration(), WriteExternalVariableOutput(), WriteFortranCall(), WriteFunctionCode(), WriteHeader(), WriteInitDeclarations(), WriteListAnalysis(), WriteMain(), WriteMainHeader(), WriteOptArg(), WriteOptArgPhase2(), WriteOutput(), WriteVariable(), and WriteVariableOutput().

int last_was_newline = 0 [static]

Definition at line 34 of file niceprintf.c.

Referenced by ind_printf(), and write_indent().

char* next_slot [static]

Definition at line 150 of file niceprintf.c.

char* output_buf [static]

Definition at line 149 of file niceprintf.c.

int sharp_line = 0

Definition at line 35 of file niceprintf.c.

Referenced by ind_printf(), and write_indent().

char* string_start [static]

Definition at line 151 of file niceprintf.c.

char* word_start = NULL [static]

Definition at line 153 of file niceprintf.c.

---