/**
 * \file libyasm/errwarn.h
 * \brief YASM error and warning reporting interface.
 *
 * \license
 *  Copyright (C) 2001-2007  Peter Johnson
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *  - Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  - Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND OTHER CONTRIBUTORS ``AS IS''
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR OTHER CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 * \endlicense
 */
#ifndef YASM_ERRWARN_H
#define YASM_ERRWARN_H

#ifndef YASM_LIB_DECL
#define YASM_LIB_DECL
#endif

/** Warning classes (that may be enabled/disabled). */
typedef enum yasm_warn_class {
    YASM_WARN_NONE = 0,     /**< No warning */
    YASM_WARN_GENERAL,      /**< Non-specific warnings */
    YASM_WARN_UNREC_CHAR,   /**< Unrecognized characters (while tokenizing) */
    YASM_WARN_PREPROC,      /**< Preprocessor warnings */
    YASM_WARN_ORPHAN_LABEL, /**< Label alone on a line without a colon */
    YASM_WARN_UNINIT_CONTENTS, /**< Uninitialized space in code/data section */
    YASM_WARN_SIZE_OVERRIDE,/**< Double size override */
    YASM_WARN_IMPLICIT_SIZE_OVERRIDE /**< Implicit size override */
} yasm_warn_class;

/** Error classes.  Bitmask-based to support limited subclassing. */
typedef enum yasm_error_class {
    YASM_ERROR_NONE             = 0x0000, /**< No error */
    YASM_ERROR_GENERAL          = 0xFFFF, /**< Non-specific */
    YASM_ERROR_ARITHMETIC       = 0x0001, /**< Arithmetic error (general) */
    YASM_ERROR_OVERFLOW         = 0x8001, /**< Arithmetic overflow */
    YASM_ERROR_FLOATING_POINT   = 0x4001, /**< Floating point error */
    YASM_ERROR_ZERO_DIVISION    = 0x2001, /**< Divide-by-zero */
    YASM_ERROR_ASSERTION        = 0x0002, /**< Assertion error */
    YASM_ERROR_VALUE            = 0x0004, /**< Value inappropriate
                                           *   (e.g. not in range) */
    YASM_ERROR_NOT_ABSOLUTE     = 0x8004, /**< Absolute expression required */
    YASM_ERROR_TOO_COMPLEX      = 0x4004, /**< Expression too complex */
    YASM_ERROR_NOT_CONSTANT     = 0x2004, /**< Constant expression required */
    YASM_ERROR_IO               = 0x0008, /**< I/O error */
    YASM_ERROR_NOT_IMPLEMENTED  = 0x0010, /**< Not implemented error */
    YASM_ERROR_TYPE             = 0x0020, /**< Type error */
    YASM_ERROR_SYNTAX           = 0x0040, /**< Syntax error */
    YASM_ERROR_PARSE            = 0x8040  /**< Parser error */
} yasm_error_class;

/** Initialize any internal data structures. */
YASM_LIB_DECL
void yasm_errwarn_initialize(void);

/** Clean up any memory allocated by yasm_errwarn_initialize() or other
 * functions.
 */
YASM_LIB_DECL
void yasm_errwarn_cleanup(void);

/** Reporting point of internal errors.  These are usually due to sanity
 * check failures in the code.
 * \warning This function must NOT return to calling code; exit or longjmp
 *          instead.
 * \param file      source file (ala __FILE__)
 * \param line      source line (ala __LINE__)
 * \param message   internal error message
 */
YASM_LIB_DECL
extern /*@exits@*/ void (*yasm_internal_error_)
    (const char *file, unsigned int line, const char *message);

/** Easily-callable version of yasm_internal_error_().  Automatically uses
 * __FILE__ and __LINE__ as the file and line.
 * \param message   internal error message
 */
#define yasm_internal_error(message) \
    yasm_internal_error_(__FILE__, __LINE__, message)

/** Reporting point of fatal errors.
 * \warning This function must NOT return to calling code; exit or longjmp
 *          instead.
 * \param message   fatal error message
 * \param va        va_list argument list for message
 */
YASM_LIB_DECL
extern /*@exits@*/ void (*yasm_fatal) (const char *message, va_list va);

/** Reporting point of fatal errors, with variable arguments (internal only).
 * \warning This function calls #yasm_fatal, and thus does not return to the
 *          calling code.
 * \param message   fatal error message
 * \param ...       argument list for message
 */
YASM_LIB_DECL
/*@exits@*/ void yasm__fatal(const char *message, ...);

YASM_LIB_DECL
/*@exits@*/ void yasm__fatal_missing_input_file(const char *message, const char *filename);

/** Unconditionally clear the error indicator, freeing any associated data.
 * Has no effect if the error indicator is not set.
 */
YASM_LIB_DECL
void yasm_error_clear(void);

/** Get the error indicator.  YASM_ERROR_NONE is returned if no error has
 * been set.  Note that as YASM_ERROR_NONE is 0, the return value can also
 * be treated as a boolean value.
 * \return Current error indicator.
 */
yasm_error_class yasm_error_occurred(void);

/** Check the error indicator against an error class.  To check if any error
 * has been set, check against the YASM_ERROR_GENERAL class.  This function
 * properly checks error subclasses.
 * \param eclass    base error class to check against
 * \return Nonzero if error indicator is set and a subclass of eclass, 0
 *         otherwise.
 */
YASM_LIB_DECL
int yasm_error_matches(yasm_error_class eclass);

#ifndef YASM_DOXYGEN
YASM_LIB_DECL
extern yasm_error_class yasm_eclass;
#define yasm_error_occurred()       yasm_eclass
#endif

/** Set the error indicator (va_list version).  Has no effect if the error
 * indicator is already set.
 * \param eclass    error class
 * \param format    printf format string
 * \param va        argument list for format
 */
YASM_LIB_DECL
void yasm_error_set_va(yasm_error_class eclass, const char *format, va_list va);

/** Set the error indicator.  Has no effect if the error indicator is already
 * set.
 * \param eclass    error class
 * \param format    printf format string
 * \param ...       argument list for format
 */
YASM_LIB_DECL
void yasm_error_set(yasm_error_class eclass, const char *format, ...)
    /*@printflike@*/;

/** Set a cross-reference for a new error (va_list version).  Has no effect
 * if the error indicator is already set (e.g. with yasm_error_set()).  This
 * function must be called prior to its corresponding yasm_error_set() call.
 * \param xrefline  virtual line to cross-reference to (should not be 0)
 * \param format    printf format string
 * \param va        argument list for format
 */
YASM_LIB_DECL
void yasm_error_set_xref_va(unsigned long xrefline, const char *format,
                            va_list va);

/** Set a cross-reference for a new error.  Has no effect if the error
 * indicator is already set (e.g. with yasm_error_set()).  This function
 * must be called prior to its corresponding yasm_error_set() call.
 * \param xrefline  virtual line to cross-reference to (should not be 0)
 * \param format    printf format string
 * \param ...       argument list for format
 */
YASM_LIB_DECL
void yasm_error_set_xref(unsigned long xrefline, const char *format, ...)
    /*@printflike@*/;

/** Fetch the error indicator and all associated data.  If the error
 * indicator is set, the output pointers are set to the current error
 * indicator values, and the error indicator is cleared.
 * The code using this function is then responsible for yasm_xfree()'ing
 * str and xrefstr (if non-NULL).  If the error indicator is not set,
 * all output values are set to 0 (including eclass, which is set to
 * YASM_ERROR_NONE).
 * \param eclass    error class (output)
 * \param str       error message
 * \param xrefline  virtual line used for cross-referencing (0 if no xref)
 * \param xrefstr   cross-reference error message (NULL if no xref)
 */
YASM_LIB_DECL
void yasm_error_fetch(/*@out@*/ yasm_error_class *eclass,
                      /*@out@*/ /*@only@*/ /*@null@*/ char **str,
                      /*@out@*/ unsigned long *xrefline,
                      /*@out@*/ /*@only@*/ /*@null@*/ char **xrefstr);

/** Unconditionally clear all warning indicators, freeing any associated data.
 * Has no effect if no warning indicators have been set.
 */
YASM_LIB_DECL
void yasm_warn_clear(void);

/** Get the first warning indicator.  YASM_WARN_NONE is returned if no warning
 * has been set.  Note that as YASM_WARN_NONE is 0, the return value can also
 * be treated as a boolean value.
 * \return First warning indicator.
 */
YASM_LIB_DECL
yasm_warn_class yasm_warn_occurred(void);

/** Add a warning indicator (va_list version).
 * \param wclass    warning class
 * \param format    printf format string
 * \param va        argument list for format
 */
YASM_LIB_DECL
void yasm_warn_set_va(yasm_warn_class wclass, const char *format, va_list va);

/** Add a warning indicator.
 * \param wclass    warning class
 * \param format    printf format string
 * \param ...       argument list for format
 */
YASM_LIB_DECL
void yasm_warn_set(yasm_warn_class wclass, const char *format, ...)
    /*@printflike@*/;

/** Fetch the first warning indicator and all associated data.  If there
 * is at least one warning indicator, the output pointers are set to the
 * first warning indicator values, and first warning indicator is removed.
 * The code using this function is then responsible for yasm_xfree()'ing
 * str and xrefstr (if non-NULL).  If there is no warning indicator set,
 * all output values are set to 0 (including wclass, which is set to
 * YASM_WARN_NONE).
 * \param wclass    warning class (output)
 * \param str       warning message
 */
YASM_LIB_DECL
void yasm_warn_fetch(/*@out@*/ yasm_warn_class *wclass,
                     /*@out@*/ /*@only@*/ char **str);

/** Enable a class of warnings.
 * \param wclass    warning class
 */
YASM_LIB_DECL
void yasm_warn_enable(yasm_warn_class wclass);

/** Disable a class of warnings.
 * \param wclass    warning class
 */
YASM_LIB_DECL
void yasm_warn_disable(yasm_warn_class wclass);

/** Disable all classes of warnings. */
YASM_LIB_DECL
void yasm_warn_disable_all(void);

/** Create an error/warning set for collection of multiple error/warnings.
 * \return Newly allocated set.
 */
YASM_LIB_DECL
/*@only@*/ yasm_errwarns *yasm_errwarns_create(void);

/** Destroy an error/warning set.
 * \param errwarns  error/warning set
 */
YASM_LIB_DECL
void yasm_errwarns_destroy(/*@only@*/ yasm_errwarns *errwarns);

/** Propagate error indicator and warning indicator(s) to an error/warning set.
 * Has no effect if the error indicator and warning indicator are not set.
 * Does not print immediately; yasm_errwarn_output_all() outputs
 * accumulated errors and warnings.
 * Generally multiple errors on the same line will be reported, but errors
 * of class YASM_ERROR_PARSE will get overwritten by any other class on the
 * same line.
 * \param errwarns  error/warning set
 * \param line      virtual line
 */
YASM_LIB_DECL
void yasm_errwarn_propagate(yasm_errwarns *errwarns, unsigned long line);

/** Get total number of errors logged.
 * \param errwarns          error/warning set
 * \param warning_as_error  if nonzero, warnings are treated as errors.
 * \return Number of errors.
 */
YASM_LIB_DECL
unsigned int yasm_errwarns_num_errors(yasm_errwarns *errwarns,
                                      int warning_as_error);

/** Print out an error.
 * \param fn            filename of source file
 * \param line          line number
 * \param msg           error message
 * \param xref_fn       cross-referenced source filename
 * \param xref_line     cross-referenced line number
 * \param xref_msg      cross-referenced error message
 */
typedef void (*yasm_print_error_func)
    (const char *fn, unsigned long line, const char *msg,
     /*@null@*/ const char *xref_fn, unsigned long xref_line,
     /*@null@*/ const char *xref_msg);

/** Print out a warning.
 * \param fn    filename of source file
 * \param line  line number
 * \param msg   warning message
 */
typedef void (*yasm_print_warning_func)
    (const char *fn, unsigned long line, const char *msg);

/** Outputs error/warning set in sorted order (sorted by virtual line number).
 * \param errwarns          error/warning set
 * \param lm    line map (to convert virtual lines into filename/line pairs)
 * \param warning_as_error  if nonzero, treat warnings as errors.
 * \param print_error       function called to print out errors
 * \param print_warning     function called to print out warnings
 */
YASM_LIB_DECL
void yasm_errwarns_output_all
    (yasm_errwarns *errwarns, yasm_linemap *lm, int warning_as_error,
     yasm_print_error_func print_error, yasm_print_warning_func print_warning);

/** Convert a possibly unprintable character into a printable string.
 * \internal
 * \param ch    possibly unprintable character
 * \return Printable string representation (static buffer).
 */
YASM_LIB_DECL
char *yasm__conv_unprint(int ch);

/** Hook for library users to map to gettext() if GNU gettext is being used.
 * \param msgid     message catalog identifier
 * \return Translated message.
 */
YASM_LIB_DECL
extern const char * (*yasm_gettext_hook) (const char *msgid);

#endif