Diagnostic.h revision 37b74a387bb3993387029859c2d9d051c41c724e 
1//===- Diagnostic.h -------------------------------------------------------===//
2//
3//                     The MCLinker Project
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9#ifndef MCLD_LD_DIAGNOSTIC_H_
10#define MCLD_LD_DIAGNOSTIC_H_
11
12#include "mcld/LD/DiagnosticEngine.h"
13
14#include <cassert>
15#include <string>
16
17namespace mcld {
18
19/** \class Diagnostic
20 *  \brief Diagnostic provides current status to DiagnosticPrinters.
21 */
22class Diagnostic {
23 public:
24  explicit Diagnostic(DiagnosticEngine& pEngine);
25
26  ~Diagnostic();
27
28  unsigned int getID() const { return m_Engine.state().ID; }
29
30  unsigned int getNumArgs() const { return m_Engine.state().numArgs; }
31
32  DiagnosticEngine::ArgumentKind getArgKind(unsigned int pIdx) const {
33    assert(pIdx < getNumArgs() && "Argument index is out of range!");
34    return (DiagnosticEngine::ArgumentKind)m_Engine.state().ArgumentKinds[pIdx];
35  }
36
37  const std::string& getArgStdStr(unsigned int pIdx) const {
38    assert(getArgKind(pIdx) == DiagnosticEngine::ak_std_string &&
39           "Invalid argument accessor!");
40    return m_Engine.state().ArgumentStrs[pIdx];
41  }
42
43  const char* getArgCStr(unsigned int pIdx) const {
44    assert(getArgKind(pIdx) == DiagnosticEngine::ak_c_string &&
45           "Invalid argument accessor!");
46    return reinterpret_cast<const char*>(m_Engine.state().ArgumentVals[pIdx]);
47  }
48
49  int getArgSInt(unsigned int pIdx) const {
50    assert(getArgKind(pIdx) == DiagnosticEngine::ak_sint &&
51           "Invalid argument accessor!");
52    return static_cast<int>(m_Engine.state().ArgumentVals[pIdx]);
53  }
54
55  unsigned int getArgUInt(unsigned int pIdx) const {
56    assert(getArgKind(pIdx) == DiagnosticEngine::ak_uint &&
57           "Invalid argument accessor!");
58    return (unsigned int)m_Engine.state().ArgumentVals[pIdx];
59  }
60
61  unsigned long long getArgULongLong(unsigned pIdx) const {
62    assert(getArgKind(pIdx) == DiagnosticEngine::ak_ulonglong &&
63           "Invalid argument accessor!");
64    return (unsigned long long)m_Engine.state().ArgumentVals[pIdx];
65  }
66
67  bool getArgBool(unsigned int pIdx) const {
68    assert(getArgKind(pIdx) == DiagnosticEngine::ak_bool &&
69           "Invalid argument accessor!");
70    return static_cast<bool>(m_Engine.state().ArgumentVals[pIdx]);
71  }
72
73  intptr_t getRawVals(unsigned int pIdx) const {
74    assert(getArgKind(pIdx) != DiagnosticEngine::ak_std_string &&
75           "Invalid argument accessor!");
76    return m_Engine.state().ArgumentVals[pIdx];
77  }
78
79  // format - format this diagnostic into string, subsituting the formal
80  // arguments. The result is appended at on the pOutStr.
81  void format(std::string& pOutStr) const;
82
83  // format - format the given formal string, subsituting the formal
84  // arguments. The result is appended at on the pOutStr.
85  void format(const char* pBegin, const char* pEnd, std::string& pOutStr) const;
86
87 private:
88  const char* findMatch(char pVal, const char* pBegin, const char* pEnd) const;
89
90 private:
91  DiagnosticEngine& m_Engine;
92};
93
94}  // namespace mcld
95
96#endif  // MCLD_LD_DIAGNOSTIC_H_
97