1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
|
//===-- BreakpointID.cpp ----------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// C Includes
#include <stdio.h>
// C++ Includes
// Other libraries and framework includes
// Project includes
#include "lldb/Breakpoint/BreakpointID.h"
#include "lldb/Breakpoint/Breakpoint.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/Error.h"
using namespace lldb;
using namespace lldb_private;
BreakpointID::BreakpointID (break_id_t bp_id, break_id_t loc_id) :
m_break_id (bp_id),
m_location_id (loc_id)
{
}
BreakpointID::~BreakpointID ()
{
}
const char *BreakpointID::g_range_specifiers[] = { "-", "to", "To", "TO", NULL };
// Tells whether or not STR is valid to use between two strings representing breakpoint IDs, to
// indicate a range of breakpoint IDs. This is broken out into a separate function so that we can
// easily change or add to the format for specifying ID ranges at a later date.
bool
BreakpointID::IsRangeIdentifier (const char *str)
{
int specifier_count = 0;
for (int i = 0; g_range_specifiers[i] != NULL; ++i)
++specifier_count;
for (int i = 0; i < specifier_count; ++i)
{
if (strcmp (g_range_specifiers[i], str) == 0)
return true;
}
return false;
}
bool
BreakpointID::IsValidIDExpression (const char *str)
{
break_id_t bp_id;
break_id_t loc_id;
BreakpointID::ParseCanonicalReference (str, &bp_id, &loc_id);
if (bp_id == LLDB_INVALID_BREAK_ID)
return false;
else
return true;
}
void
BreakpointID::GetDescription (Stream *s, lldb::DescriptionLevel level)
{
if (level == eDescriptionLevelVerbose)
s->Printf("%p BreakpointID:", static_cast<void*>(this));
if (m_break_id == LLDB_INVALID_BREAK_ID)
s->PutCString ("<invalid>");
else if (m_location_id == LLDB_INVALID_BREAK_ID)
s->Printf("%i", m_break_id);
else
s->Printf("%i.%i", m_break_id, m_location_id);
}
void
BreakpointID::GetCanonicalReference (Stream *s, break_id_t bp_id, break_id_t loc_id)
{
if (bp_id == LLDB_INVALID_BREAK_ID)
s->PutCString ("<invalid>");
else if (loc_id == LLDB_INVALID_BREAK_ID)
s->Printf("%i", bp_id);
else
s->Printf("%i.%i", bp_id, loc_id);
}
bool
BreakpointID::ParseCanonicalReference (const char *input, break_id_t *break_id_ptr, break_id_t *break_loc_id_ptr)
{
*break_id_ptr = LLDB_INVALID_BREAK_ID;
*break_loc_id_ptr = LLDB_INVALID_BREAK_ID;
if (input == NULL || *input == '\0')
return false;
const char *format = "%i%n.%i%n";
int chars_consumed_1 = 0;
int chars_consumed_2 = 0;
int n_items_parsed = ::sscanf (input,
format,
break_id_ptr, // %i parse the breakpoint ID
&chars_consumed_1, // %n gets the number of characters parsed so far
break_loc_id_ptr, // %i parse the breakpoint location ID
&chars_consumed_2); // %n gets the number of characters parsed so far
if ((n_items_parsed == 1 && input[chars_consumed_1] == '\0') ||
(n_items_parsed == 2 && input[chars_consumed_2] == '\0'))
return true;
// Badly formatted canonical reference.
*break_id_ptr = LLDB_INVALID_BREAK_ID;
*break_loc_id_ptr = LLDB_INVALID_BREAK_ID;
return false;
}
bool
BreakpointID::StringIsBreakpointName(const char *name, Error &error)
{
error.Clear();
if (name && (name[0] >= 'A' && name[0] <= 'z'))
{
if (strcspn(name, ".- ") != strlen(name))
{
error.SetErrorStringWithFormat("invalid breakpoint name: \"%s\"", name);
}
return true;
}
else
return false;
}
|
