wserror.c File Reference

#include "wsint.h"

Go to the source code of this file.

Functions
void	ws_info (WsCompilerPtr compiler, char *message,...)
void	ws_fatal (char *fmt,...)
void	ws_error_memory (WsCompilerPtr compiler)
void	ws_error_syntax (WsCompilerPtr compiler, WsUInt32 line)
void	ws_src_error (WsCompilerPtr compiler, WsUInt32 line, char *message,...)
void	ws_src_warning (WsCompilerPtr compiler, WsUInt32 line, char *message,...)
void	ws_fprintf (WsIOProc io, void *context, const char *fmt,...)
void	ws_vfprintf (WsIOProc io, void *context, const char *fmt, va_list ap)
void	ws_puts (WsIOProc io, void *context, const char *str)
void	ws_fputc (int ch, WsIOProc io, void *context)

Function Documentation

ws_error_memory()

void ws_error_memory

(

WsCompilerPtr

compiler

)

Definition at line 107 of file wserror.c.

References COMPILER_MAGIC, WsCompilerRec::errors, gw_assert(), WsCompilerRec::magic, WS_ERROR_B_MEMORY, WS_LINE_TERMINATOR, ws_puts(), and WS_STDERR.

Referenced by asm_alloc(), buffer_to_int(), expr_alloc(), read_float_from_exp(), read_float_from_point(), stmt_alloc(), ws_asm_linearize(), ws_expr_assign(), ws_expr_call(), ws_expr_const_string(), ws_expr_linearize(), ws_expr_postfix_var(), ws_expr_symbol(), ws_expr_unary_var(), ws_formal_parameter(), ws_function(), ws_function_hash(), ws_list_append(), ws_list_new(), ws_pragma_meta_body(), ws_pragma_use(), ws_stmt_linearize(), ws_variable_declaration(), ws_variable_define(), ws_yy_lex(), and yyparse().

{
    gw_assert(compiler->magic == COMPILER_MAGIC);

    if (compiler->errors & WS_ERROR_B_MEMORY)
        /* We have already reported this error. */
        return;

    compiler->errors |= WS_ERROR_B_MEMORY;
    ws_puts(WS_STDERR, "wsc: error: out of memory" WS_LINE_TERMINATOR);
}

ws_error_syntax()

void ws_error_syntax	(	WsCompilerPtr	compiler,
		WsUInt32	line
	)

Definition at line 120 of file wserror.c.

References COMPILER_MAGIC, WsCompilerRec::errors, gw_assert(), WsCompilerRec::input_name, WsCompilerRec::last_syntax_error_line, WsCompilerRec::linenum, WsCompilerRec::magic, WS_ERROR_B_MEMORY, WS_ERROR_B_SYNTAX, ws_fprintf(), WS_LINE_TERMINATOR, and WS_STDERR.

Referenced by yyparse().

{
    gw_assert(compiler->magic == COMPILER_MAGIC);

    if (compiler->errors & WS_ERROR_B_MEMORY)
        /* It makes no sense to report syntax errors when we have run out
           of memory.  This information is not too valid. */ 
        return;

    if (line == 0)
        line = compiler->linenum;

    if (compiler->last_syntax_error_line == line)
        /* It makes no sense to report multiple syntax errors from the
           same line. */ 
        return;

    compiler->last_syntax_error_line = line;
    compiler->errors |= WS_ERROR_B_SYNTAX;

    ws_fprintf(WS_STDERR, "%s:%u: syntax error" WS_LINE_TERMINATOR,
               compiler->input_name, line);
}

ws_fatal()

void ws_fatal	(	char *	fmt,
			...
	)

Definition at line 91 of file wserror.c.

Referenced by ws_asm_linearize(), ws_asm_print(), ws_bc_decode(), ws_bc_encode(), ws_decode_buffer(), ws_encode_buffer(), ws_expr_linearize(), ws_lexer_free_block(), ws_utf8_append_char(), ws_utf8_to_latin1(), and ws_vfprintf().

{
    va_list ap;

    fprintf(stderr, "wsc: fatal: ");

    va_start(ap, fmt);
    vfprintf(stderr, fmt, ap);
    va_end(ap);

    fprintf(stderr, "\n");

    abort();
}

ws_fprintf()

void ws_fprintf	(	WsIOProc	io,
		void *	context,
		const char *	fmt,
			...
	)

Definition at line 190 of file wserror.c.

References ws_vfprintf().

Referenced by ws_asm_dasm(), ws_asm_print(), ws_error_syntax(), ws_src_error(), and ws_src_warning().

{
    va_list ap;

    va_start(ap, fmt);
    ws_vfprintf(io, context, fmt, ap);
    va_end(ap);
}

ws_fputc()

void ws_fputc	(	int	ch,
		WsIOProc	io,
		void *	context
	)

Definition at line 324 of file wserror.c.

Referenced by ws_vfprintf().

{
    char c = (char) ch;

    (*io)(&c, 1, context);
}

ws_info()

void ws_info	(	WsCompilerPtr	compiler,
		char *	message,
			...
	)

Definition at line 74 of file wserror.c.

References WsCompilerRec::params, WsCompilerParamsRec::verbose, WS_LINE_TERMINATOR, ws_puts(), WS_STDOUT, and ws_vfprintf().

Referenced by compile_stream(), opt_conv(), opt_dead_code(), opt_jumps_to_jumps(), opt_jumps_to_next_instruction(), and opt_peephole().

{
    va_list ap;

    if (!compiler->params.verbose)
        return;

    ws_puts(WS_STDOUT, "wsc: ");

    va_start(ap, message);
    ws_vfprintf(WS_STDOUT, message, ap);
    va_end(ap);

    ws_puts(WS_STDOUT, WS_LINE_TERMINATOR);
}

ws_puts()

void ws_puts	(	WsIOProc	io,
		void *	context,
		const char *	str
	)

Definition at line 318 of file wserror.c.

Referenced by ws_error_memory(), ws_info(), ws_src_error(), and ws_src_warning().

{
    (*io)(str, strlen(str), context);
}

ws_src_error()

void ws_src_error	(	WsCompilerPtr	compiler,
		WsUInt32	line,
		char *	message,
			...
	)

Definition at line 145 of file wserror.c.

References COMPILER_MAGIC, WsCompilerRec::errors, gw_assert(), WsCompilerRec::input_name, WsCompilerRec::linenum, WsCompilerRec::magic, WsCompilerRec::num_errors, WS_ERROR_B_SEMANTIC, ws_fprintf(), WS_LINE_TERMINATOR, ws_puts(), WS_STDERR, and ws_vfprintf().

Referenced by buffer_to_int(), read_float_from_exp(), ws_expr_linearize(), ws_function(), ws_pragma_use(), ws_stmt_linearize(), ws_variable_define(), and ws_yy_lex().

{
    va_list ap;

    gw_assert(compiler->magic == COMPILER_MAGIC);

    if (line == 0)
        line = compiler->linenum;

    compiler->errors |= WS_ERROR_B_SEMANTIC;

    ws_fprintf(WS_STDERR, "%s:%u: ", compiler->input_name, line);

    va_start(ap, message);
    ws_vfprintf(WS_STDERR, message, ap);
    va_end(ap);

    ws_puts(WS_STDERR, WS_LINE_TERMINATOR);

    compiler->num_errors++;
}

ws_src_warning()

void ws_src_warning	(	WsCompilerPtr	compiler,
		WsUInt32	line,
		char *	message,
			...
	)

Definition at line 168 of file wserror.c.

References COMPILER_MAGIC, gw_assert(), WsCompilerRec::input_name, WsCompilerRec::linenum, WsCompilerRec::magic, WsCompilerRec::num_errors, ws_fprintf(), WS_LINE_TERMINATOR, ws_puts(), WS_STDERR, and ws_vfprintf().

{
    va_list ap;

    gw_assert(compiler->magic == COMPILER_MAGIC);

    if (line == 0)
        line = compiler->linenum;

    ws_fprintf(WS_STDERR, "%s:%u: warning: ", compiler->input_name, line);

    va_start(ap, message);
    ws_vfprintf(WS_STDERR, message, ap);
    va_end(ap);

    ws_puts(WS_STDERR, WS_LINE_TERMINATOR);

    compiler->num_errors++;
}

ws_vfprintf()

void ws_vfprintf	(	WsIOProc	io,
		void *	context,
		const char *	fmt,
		va_list	ap
	)

Definition at line 200 of file wserror.c.

References start, ws_fatal(), and ws_fputc().

Referenced by ws_fprintf(), ws_info(), ws_src_error(), and ws_src_warning().

{
    int start, i;

    for (start = 0, i = 0; fmt[i]; i++)
        if (fmt[i] == '%' && fmt[i + 1]) {
            char buf[256];
            char *cp;
            int ival;
            unsigned int uival;
            int padder = ' ';
            int left = 0;
            unsigned int width = 0;

            if (fmt[i + 1] == '%') {
                /* An escaped `%'.  Print leading data including the `%'
                          character. */
                i++;
                (*io)(fmt + start, i - start, context);
                start = i + 1;
                continue;
            }

            /* An escape sequence. */

            /* Print leading data if any. */
            if (i > start)
                (*io)(fmt + start, i - start, context);

            /* We support a minor sub-set of the printf()'s formatting
                      capabilities.  Let's see what we got. */
            i++;

            /* Alignment? */
            if (fmt[i] == '-') {
                left = 1;
                i++;
            }

            /* Padding? */
            if (fmt[i] == '0') {
                padder = '0';
                i++;
            }

            /* Width? */
            while ('0' <= fmt[i] && fmt[i] <= '9') {
                width *= 10;
                width += fmt[i++] - '0';
            }

            /* Check the format. */
            cp = buf;
            switch (fmt[i]) {
            case 'c':       /* character */
                ival = (int) va_arg(ap, int);

                snprintf(buf, sizeof(buf), "%c", (char) ival);
                cp = buf;
                break;

            case 's':       /* string */
                cp = va_arg(ap, char *);
                break;

            case 'd':       /* integer */
                ival = va_arg(ap, int);

                snprintf(buf, sizeof(buf), "%d", ival);
                cp = buf;
                break;

            case 'u':       /* unsigned integer */
                uival = va_arg(ap, unsigned int);

                snprintf(buf, sizeof(buf), "%u", uival);
                cp = buf;
                break;

            case 'x':       /* unsigned integer in hexadecimal format */
                uival = va_arg(ap, unsigned int);

                snprintf(buf, sizeof(buf), "%x", uival);
                cp = buf;
                break;

            default:
                ws_fatal("ws_vfprintf(): format %%%c not implemented", fmt[i]);
                break;
            }

            if (left)
                /* Output the value left-justified. */
                (*io)(cp, strlen(cp), context);

            /* Need padding? */
            if (width > strlen(cp)) {
                /* Yes we need. */
                int amount = width - strlen(cp);

                while (amount-- > 0)
                    ws_fputc(padder, io, context);
            }

            if (!left)
                /* Output the value right-justified. */
                (*io)(cp, strlen(cp), context);

            /* Process more. */
            start = i + 1;
        }

    /* Print trailing data if any. */
    if (i > start)
        (*io)(fmt + start, i - start, context);
}