/* 

 *   Copyright (c) 1999, 2002 Michael J. Roberts.  All Rights Reserved.

 *   

 *   Please see the accompanying license file, LICENSE.TXT, for information

 *   on using and copying this software.  

 */

/*

Name

  tcmain.h - TADS 3 Compiler - main compiler driver

Function

Notes

Modified

  04/22/99 MJRoberts  - Creation

*/

#ifndef TCMAIN_H

#define TCMAIN_H

#include <stdarg.h>

#include "t3std.h"

#include "tcerr.h"

/* 

 *   error display option flags

 */

#define TCMAIN_ERR_VERBOSE  0x00000001              /* use verbose messages */

#define TCMAIN_ERR_NUMBERS  0x00000002       /* include numeric error codes */

#define TCMAIN_ERR_WARNINGS 0x00000004                     /* show warnings */

#define TCMAIN_ERR_PEDANTIC 0x00000008           /* show pendantic warnings */

#define TCMAIN_ERR_TESTMODE 0x00000010                      /* testing mode */

#define TCMAIN_ERR_FNAME_QU 0x00000020                   /* quote filenames */

/* 

 *   main compiler driver class 

 */

class CTcMain

{

public:

    /* Initialize the compiler.  Creates all global objects. */

    static void init(class CTcHostIfc *hostifc,

                     class CResLoader *res_loader,

                     const char *default_charset);

    /* Terminate the compiler.  Deletes all global objects. */

    static void terminate();

    /* initialize/terminate the error subsystem */

    static void tc_err_init(size_t param_stack_size,

                            class CResLoader *res_loader);

    static void tc_err_term();

    /* log an error - varargs arguments - static routine */

    static void S_log_error(class CTcTokFileDesc *linedesc, long linenum,

                            int *err_counter, int *warn_counter,

                            unsigned long options,

                            const int *suppress_list, size_t suppress_cnt,

                            tc_severity_t severity, int err, ...)

    {

        va_list args;

        /* pass through to our va_list-style handler */

        va_start(args, err);

        S_v_log_error(linedesc, linenum, err_counter, warn_counter, 0, 0,

                      options, suppress_list, suppress_cnt,

                      severity, err, args);

        va_end(args);

    }

    /* log an error - arguments from a CVmException object */

    static void S_log_error(class CTcTokFileDesc *linedesc, long linenum,

                            int *err_counter, int *warn_counter,

                            unsigned long options,

                            const int *suppress_list, size_t suppress_cnt,

                            tc_severity_t severity,

                            struct CVmException *exc);

    /* show or don't show numeric error codes */

    void set_show_err_numbers(int show)

    {

        if (show)

            err_options_ |= TCMAIN_ERR_NUMBERS;

        else

            err_options_ &= ~TCMAIN_ERR_NUMBERS;

    }

    /* set verbosity for error messages */

    void set_verbosity(int verbose)

    {

        if (verbose)

            err_options_ |= TCMAIN_ERR_VERBOSE;

        else

            err_options_ &= ~TCMAIN_ERR_VERBOSE;

    }

    /* turn all warnings on or off */

    void set_warnings(int show)

    {

        if (show)

            err_options_ |= TCMAIN_ERR_WARNINGS;

        else

            err_options_ &= ~TCMAIN_ERR_WARNINGS;

    }

    /* turn pedantic warnings on or off */

    void set_pedantic(int show)

    {

        if (show)

            err_options_ |= TCMAIN_ERR_PEDANTIC;

        else

            err_options_ &= ~TCMAIN_ERR_PEDANTIC;

    }

    /* 

     *   Get/set regression test reporting mode.  In test mode, we'll only

     *   show the root name of each file in our status reports and error

     *   messages.  This is useful when running regression tests, because it

     *   allows us to diff the compiler output against a reference log

     *   without worrying about the local directory structure.  

     */

    int get_test_report_mode() const

        { return (err_options_ & TCMAIN_ERR_TESTMODE) != 0; }

    void set_test_report_mode(int flag)

    {

        if (flag)

            err_options_ |= TCMAIN_ERR_TESTMODE;

        else

            err_options_ &= ~TCMAIN_ERR_TESTMODE;

    }

    /* 

     *   Set the quoted filenames option.  If this option is set, we'll quote

     *   the filenames we report in our error messages; this makes it easier

     *   for automated tools to parse the error messages, because it ensures

     *   that the contents of a filename won't be mistaken for part of the

     *   error message format.  

     */

    void set_quote_filenames(int flag)

    {

        if (flag)

            err_options_ |= TCMAIN_ERR_FNAME_QU;

        else

            err_options_ &= ~TCMAIN_ERR_FNAME_QU;

    }

    /*

     *   Set an array of warning codes to suppress.  We will suppress any

     *   warnings and pedantic warnings whose error numbers appear in this

     *   array; errors of greater severity will be shown even when they

     *   appear here.

     *   

     *   The memory of this list is managed by the caller.  We merely keep a

     *   reference to the caller's array.  The caller is responsible for

     *   ensuring that the memory remains valid for as long as we're around.

     */

    void set_suppress_list(const int *lst, size_t cnt)

    {

        /* remember the list and its size */

        suppress_list_ = lst;

        suppress_cnt_ = cnt;

    }

    /* log an error - va_list-style arguments - static routine */

    static void S_v_log_error(class CTcTokFileDesc *linedesc, long linenum,

                              int *err_counter, int *warn_counter,

                              int *first_error, int *first_warning,

                              unsigned long options,

                              const int *suppress_list, size_t suppress_cnt,

                              tc_severity_t severity, int err, va_list args);

    /* log an error - varargs */

    void log_error(class CTcTokFileDesc *linedesc, long linenum,

                   tc_severity_t severity, int err, ...)

    {

        va_list args;

        /* pass through to our va_list-style handler */

        va_start(args, err);

        v_log_error(linedesc, linenum, severity, err, args);

        va_end(args);

    }

    void v_log_error(class CTcTokFileDesc *linedesc, long linenum,

                     tc_severity_t severity, int err, va_list args)

    {

        /* call our static routine */

        S_v_log_error(linedesc, linenum, &error_count_, &warning_count_,

                      &first_error_, &first_warning_, err_options_,

                      suppress_list_, suppress_cnt_,

                      severity, err, args);

        /* if we've exceeded the maximum error limit, throw a fatal error */

        check_error_limit();

    }

    /* get the error/warning count */

    int get_error_count() const { return error_count_; }

    int get_warning_count() const { return warning_count_; }

    /* reset the error and warning counters */

    void reset_error_counts()

    {

        /* clear the counters */

        error_count_ = 0;

        warning_count_ = 0;

        /* clear the error/warning memories */

        first_error_ = 0;

        first_warning_ = 0;

    }

    /* 

     *   get the first compilation error/warning code - we keep track of

     *   these for times when we have limited error reporting capabilities

     *   and can only report a single error, such as when we're compiling

     *   an expression in the debugger 

     */

    int get_first_error() const { return first_error_; }

    int get_first_warning() const { return first_warning_; }

    /* 

     *   check the error count against the error limit, and throw a fatal

     *   error if we've exceeded it 

     */

    void check_error_limit();

    /* get the console output character mapper */

    static class CCharmapToLocal *get_console_mapper()

        { return console_mapper_; }

private:

    CTcMain(class CResLoader *res_loader, const char *default_charset);

    ~CTcMain();

    /* error and warning count */

    int error_count_;

    int warning_count_;

    /* first error/warning code we've encountered */

    int first_error_;

    int first_warning_;

    /*

     *   Maximum error limit - if we encounter more than this many errors

     *   in a single compilation unit, we'll abort the compilation with a

     *   fatal error.  This at least limits the amount of garbage we'll

     *   display if we run into a really bad cascading parsing error

     *   situation where we just can't resynchronize.  

     */

    int max_error_count_;

    /* error options - this is a combination of TCMAIN_ERR_xxx flags */

    unsigned long err_options_;

    /*

     *   An array of warning messages to suppress.  We'll only use this to

     *   suppress warnings and pedantic warnings; errors of greater severity

     *   will be displayed even if they appear in this list.  The memory used

     *   for this list is managed by our client; we just keep a reference to

     *   the client's list.  

     */

    const int *suppress_list_;

    size_t suppress_cnt_;

    /* resource loader */

    class CResLoader *res_loader_;

    /* default character set name */

    char *default_charset_;

    /* 

     *   flag: we have tried loading an external compiler error message

     *   file and failed; if we fail once during a session, we won't try

     *   again, to avoid repeated searches for a message file during

     *   compilations of multiple files 

     */

    static int err_no_extern_messages_;

    /* count of references to the error subsystem */

    static int err_refs_;

    /* 

     *   The console character mapper.  We use this to map error messages

     *   to the console character set.  This is a static so that we can

     *   access it from the static error message printer routines.  

     */

    static class CCharmapToLocal *console_mapper_;

};

#endif /* TCMAIN_H */