diagnostic.cpp

Go to the documentation of this file.

 
#include "diagnostic.h"
#include "scanner.h"          // for Scanner::token_t
#include "loc_exception.h"
 
#include <cstdarg>            // for va_list, ...
#include <cstdio>             // for puts(), fprintf(), ...
#include <set>                // for set
 
 
// set of disabled warnings
static std::set<int> disabled;
 
static bool warn = true;    // warnings (on by default)
static bool info = false;   // info messages (off by default)
 
 
// write a warning or error message to standard output.  If it is a warning
// that is issued and that warning has not been disabled then return true.
bool issue_diag (int type, bool, const Scanner::token_t *token,
                 const char *fmt, ...) 
{
    bool enabled = false;
 
    if (0 == fmt) {
 
        // special treatment when format string is 0: a request
        // to enable or disable this type of diagnostic, e.g.,
        // in response to a command line option
 
        if (W_DISABLE == type) {
            // disable all warnings
            enabled = warn;
            warn    = false;
        }
        else if (I_ENABLE == type) {
            // enable all informational messages
            enabled = info;
            info    = true;
        }
        else {
            // disable a specific warning and return its previous
            // setting (i.e., enabled or disabled)
            enabled = disabled.find (type) == disabled.end ();
            disabled.insert (type);
        }
 
        return enabled;
    }
 
    const bool is_info  = I_FIRST <= type && type <= I_LAST;
    const bool is_warn  = !is_info && W_FIRST <= type && type <= W_LAST;
    const bool is_error = !is_info && !is_warn;
 
    if (is_warn && (!warn || disabled.end () != disabled.find (type))) {
        // warning disabled
        return enabled;
    }
 
    if (is_info && !info) {
        // info disabled
        return enabled;
    }
 
    // all errors and those warnings that are not disabled
    // must be issued
    enabled = true;
 
    if (token && token->file)
        std::fprintf (stderr, "%s:%d: ",  token->file, token->line);
 
    if (is_error)
        std::fprintf (stderr, "Error %-3d: ", type);
    else if (is_warn)
        std::fprintf (stderr, "Warning %-3d: ", type);
    else
        std::fprintf (stderr, "Note %-3d: ", type);
        
    // get the variable sized argument and pass it to vfprintf
    // to be printed
    std::va_list va;
    va_start (va, fmt);
    std::vfprintf (stderr, fmt, va);
    va_end (va);
 
    // if the token pointer is non-zero, find the file and line
    // the token appears on and print it out, followed by a line
    // underscoring the token that caused the diagnostic with
    // a string of carets ('^')
 
    std::FILE* const ftok = token ? std::fopen (token->file, "r") : 0;
 
    if (ftok) {
        int i;
        char line [1024];   // FIXME: handle longer lines
 
        // advance to the specified line in the file
        for (i = 0; i < token->line; ++i) {
            if (0 == std::fgets (line, 1024, ftok)) {
                *line = '\0';
                break;
            }
        }
 
        if (i == token->line && '\0' != *line) {
            std::fputs ("\t\t", stderr);
            std::fputs (line, stderr);
            std::fputs ("\t\t", stderr);
            
            // tok->col is the column number where the first character
            // in the token begins.  Go through the line saving tabs
            // so that the '^' will line up with the token
 
            for (i = 0; i < token->column; ++i)
                std::fputc (line [i] == '\t' ? '\t' : ' ', stderr);
 
            for (unsigned j = 0; j < token->name.size (); ++j)
                std::fputc ('^', stderr);
 
            std::fputc ('\n', stderr);
        }
 
        std::fclose (ftok);
    }
 
    if (is_error) {
        // throw an exception if the diagnostic is a hard error
        throw loc_exception ();
    }
 
    // return otherwise (i.e., the diagnostic is not an error)
    return enabled;
}