include/comma/basic/Diagnostic.h

Go to the documentation of this file.

//===-- basic/Diagnostic.h ------------------------------------ -*- C++ -*-===//
//
// This file is distributed under the MIT license.  See LICENSE.txt for details.
//
// Copyright (C) 2008-2009, Stephen Wilson
//
//===----------------------------------------------------------------------===//

#ifndef COMMA_BASIC_DIAGNOSTIC_HDR_GUARD
#define COMMA_BASIC_DIAGNOSTIC_HDR_GUARD

#include "comma/basic/IdentifierInfo.h"
#include "comma/basic/Location.h"
#include "comma/basic/ParameterModes.h"

#include "llvm/Support/raw_ostream.h"

namespace comma {

namespace diag {

enum Kind {
#define DIAGNOSTIC(ENUM, KIND, FORMAT) ENUM,
#include "comma/basic/Diagnostic.def"
#undef DIAGNOSTIC

    LAST_UNUSED_DIAGNOSTIC_KIND
};

enum Type {
    ERROR,             
    WARNING,           
    NOTE               
};

} // End diag namespace.

class DiagnosticComponent {

public:
    virtual ~DiagnosticComponent() { }

    virtual void print(llvm::raw_ostream &stream) const = 0;
};

class DiagnosticStream {

public:
    DiagnosticStream(llvm::raw_ostream &stream);

    ~DiagnosticStream();

    DiagnosticStream &initialize(const SourceLocation &sloc, const char *format,
                                 diag::Type type);

    DiagnosticStream &operator<<(const std::string &string);

    DiagnosticStream &operator<<(const char *string);

    DiagnosticStream &operator<<(int n);

    DiagnosticStream &operator<<(char c);

    DiagnosticStream &operator<<(const SourceLocation &sloc);

    DiagnosticStream &operator<<(const IdentifierInfo *idInfo);

    DiagnosticStream &operator<<(PM::ParameterMode mode);

    DiagnosticStream &operator<<(const DiagnosticComponent &component);

private:
    void emitFormatComponent();

    void emitSourceLocation(const SourceLocation &sloc);

    void emitDiagnosticType(diag::Type type);

    llvm::raw_ostream &stream;
    unsigned position;
    std::string buffer;
    llvm::raw_string_ostream message;
    SourceLocation sourceLoc;
    const char *format;
    diag::Type type;
};

class Diagnostic {

public:
    Diagnostic() :
        diagstream(llvm::errs()),
        errorCount(0), warningCount(0), noteCount(0) { }

    Diagnostic(llvm::raw_ostream &stream) : diagstream(stream) { }

    DiagnosticStream &report(const SourceLocation &loc, diag::Kind kind);

    const char *getFormat(diag::Kind kind);

    diag::Type getType(diag::Kind kind);

    bool reportsGenerated() { return numReports() != 0; }

    unsigned numReports() const {
        return errorCount + warningCount + noteCount;
    }

    unsigned numErrors() const { return errorCount; }

    unsigned numWarnings() const { return warningCount; }

    unsigned numNotes() const { return noteCount; }

private:
    DiagnosticStream diagstream;

    unsigned errorCount;
    unsigned warningCount;
    unsigned noteCount;

    static void initializeMessages();

    struct DiagInfo {
        const char *format;
        diag::Type type;
    };

    static const DiagInfo diagnostics[diag::LAST_UNUSED_DIAGNOSTIC_KIND];
};

} // End comma namespace.

#endif

---