FormatManager.cpp revision 54890a32efd3a6ffd2bfe38f7398c0a63b5913d5 
1//===-- FormatManager.cpp -------------------------------------------*- C++ -*-===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
10#include "lldb/Core/FormatManager.h"
11
12// C Includes
13// C++ Includes
14// Other libraries and framework includes
15// Project includes
16
17using namespace lldb;
18using namespace lldb_private;
19
20
21struct FormatInfo
22{
23    Format format;
24    const char format_char; // One or more format characters that can be used for this format.
25    const char *format_name;    // Long format name that can be used to specify the current format
26};
27
28static FormatInfo
29g_format_infos[] =
30{
31    { eFormatDefault        , '\0'  , "default"             },
32    { eFormatBoolean        , 'B'   , "boolean"             },
33    { eFormatBinary         , 'b'   , "binary"              },
34    { eFormatBytes          , 'y'   , "bytes"               },
35    { eFormatBytesWithASCII , 'Y'   , "bytes with ASCII"    },
36    { eFormatChar           , 'c'   , "character"           },
37    { eFormatCharPrintable  , 'C'   , "printable character" },
38    { eFormatComplexFloat   , 'F'   , "complex float"       },
39    { eFormatCString        , 's'   , "c-string"            },
40    { eFormatDecimal        , 'i'   , "signed decimal"      },
41    { eFormatEnum           , 'E'   , "enumeration"         },
42    { eFormatHex            , 'x'   , "hex"                 },
43    { eFormatFloat          , 'f'   , "float"               },
44    { eFormatOctal          , 'o'   , "octal"               },
45    { eFormatOSType         , 'O'   , "OSType"              },
46    { eFormatUnicode16      , 'U'   , "unicode16"           },
47    { eFormatUnicode32      , '\0'  , "unicode32"           },
48    { eFormatUnsigned       , 'u'   , "unsigned decimal"    },
49    { eFormatPointer        , 'p'   , "pointer"             },
50    { eFormatVectorOfChar   , '\0'  , "char[]"              },
51    { eFormatVectorOfSInt8  , '\0'  , "int8_t[]"            },
52    { eFormatVectorOfUInt8  , '\0'  , "uint8_t[]"           },
53    { eFormatVectorOfSInt16 , '\0'  , "int16_t[]"           },
54    { eFormatVectorOfUInt16 , '\0'  , "uint16_t[]"          },
55    { eFormatVectorOfSInt32 , '\0'  , "int32_t[]"           },
56    { eFormatVectorOfUInt32 , '\0'  , "uint32_t[]"          },
57    { eFormatVectorOfSInt64 , '\0'  , "int64_t[]"           },
58    { eFormatVectorOfUInt64 , '\0'  , "uint64_t[]"          },
59    { eFormatVectorOfFloat32, '\0'  , "float32[]"           },
60    { eFormatVectorOfFloat64, '\0'  , "float64[]"           },
61    { eFormatVectorOfUInt128, '\0'  , "uint128_t[]"         },
62    { eFormatComplexInteger , 'I'   , "complex integer"     },
63    { eFormatCharArray      , 'a'   , "character array"     }
64};
65
66static uint32_t
67g_num_format_infos = sizeof(g_format_infos)/sizeof(FormatInfo);
68
69static bool
70GetFormatFromFormatChar (char format_char, Format &format)
71{
72    for (uint32_t i=0; i<g_num_format_infos; ++i)
73    {
74        if (g_format_infos[i].format_char == format_char)
75        {
76            format = g_format_infos[i].format;
77            return true;
78        }
79    }
80    format = eFormatInvalid;
81    return false;
82}
83
84static bool
85GetFormatFromFormatName (const char *format_name, bool partial_match_ok, Format &format)
86{
87    uint32_t i;
88    for (i=0; i<g_num_format_infos; ++i)
89    {
90        if (strcasecmp (g_format_infos[i].format_name, format_name) == 0)
91        {
92            format = g_format_infos[i].format;
93            return true;
94        }
95    }
96
97    if (partial_match_ok)
98    {
99        for (i=0; i<g_num_format_infos; ++i)
100        {
101            if (strcasestr (g_format_infos[i].format_name, format_name) == g_format_infos[i].format_name)
102            {
103                format = g_format_infos[i].format;
104                return true;
105            }
106        }
107    }
108    format = eFormatInvalid;
109    return false;
110}
111
112bool
113FormatManager::GetFormatFromCString (const char *format_cstr,
114                                     bool partial_match_ok,
115                                     lldb::Format &format)
116{
117    bool success = false;
118    if (format_cstr && format_cstr[0])
119    {
120        if (format_cstr[1] == '\0')
121        {
122            success = GetFormatFromFormatChar (format_cstr[0], format);
123            if (success)
124                return true;
125        }
126
127        success = GetFormatFromFormatName (format_cstr, partial_match_ok, format);
128    }
129    if (!success)
130        format = eFormatInvalid;
131    return success;
132}
133
134char
135FormatManager::GetFormatAsFormatChar (lldb::Format format)
136{
137    for (uint32_t i=0; i<g_num_format_infos; ++i)
138    {
139        if (g_format_infos[i].format == format)
140            return g_format_infos[i].format_char;
141    }
142    return '\0';
143}
144
145
146
147const char *
148FormatManager::GetFormatAsCString (Format format)
149{
150    if (format >= eFormatDefault && format < kNumFormats)
151        return g_format_infos[format].format_name;
152    return NULL;
153}
154
155template<>
156bool
157FormatNavigator<std::map<lldb::RegularExpressionSP, SummaryFormat::SharedPointer>, SummaryFormat::RegexSummaryCallback>::Get(const char* key,
158                                                                                                                     SummaryFormat::SharedPointer& value)
159{
160    Mutex::Locker(m_map_mutex);
161    MapIterator pos, end = m_map.end();
162    for (pos = m_map.begin(); pos != end; pos++)
163    {
164        lldb::RegularExpressionSP regex = pos->first;
165        if (regex->Execute(key))
166        {
167            value = pos->second;
168            return true;
169        }
170    }
171    return false;
172}
173
174template<>
175bool
176FormatNavigator<std::map<lldb::RegularExpressionSP, SummaryFormat::SharedPointer>, SummaryFormat::RegexSummaryCallback>::Delete(const char* type)
177{
178    Mutex::Locker(m_map_mutex);
179    MapIterator pos, end = m_map.end();
180    for (pos = m_map.begin(); pos != end; pos++)
181    {
182        lldb::RegularExpressionSP regex = pos->first;
183        if ( ::strcmp(type,regex->GetText()) == 0)
184        {
185            m_map.erase(pos);
186            return true;
187        }
188    }
189    return false;
190}
191