]> Git Repo - binutils.git/blob - gdb/gdbsupport/common-utils.h
Update copyright year range in all GDB files.
[binutils.git] / gdb / gdbsupport / common-utils.h
1 /* Shared general utility routines for GDB, the GNU debugger.
2
3    Copyright (C) 1986-2020 Free Software Foundation, Inc.
4
5    This file is part of GDB.
6
7    This program is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 3 of the License, or
10    (at your option) any later version.
11
12    This program is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16
17    You should have received a copy of the GNU General Public License
18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
19
20 #ifndef COMMON_COMMON_UTILS_H
21 #define COMMON_COMMON_UTILS_H
22
23 #include <string>
24 #include <vector>
25
26 #include "poison.h"
27
28 /* If possible, define FUNCTION_NAME, a macro containing the name of
29    the function being defined.  Since this macro may not always be
30    defined, all uses must be protected by appropriate macro definition
31    checks (Eg: "#ifdef FUNCTION_NAME").
32
33    Version 2.4 and later of GCC define a magical variable `__PRETTY_FUNCTION__'
34    which contains the name of the function currently being defined.
35    This is broken in G++ before version 2.6.
36    C9x has a similar variable called __func__, but prefer the GCC one since
37    it demangles C++ function names.  */
38 #if (GCC_VERSION >= 2004)
39 #define FUNCTION_NAME           __PRETTY_FUNCTION__
40 #else
41 #if defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L
42 #define FUNCTION_NAME           __func__  /* ARI: func */
43 #endif
44 #endif
45
46 #include "gdb_string_view.h"
47
48 /* xmalloc(), xrealloc() and xcalloc() have already been declared in
49    "libiberty.h". */
50
51 /* Like xmalloc, but zero the memory.  */
52 void *xzalloc (size_t);
53
54 template <typename T>
55 static void
56 xfree (T *ptr)
57 {
58   static_assert (IsFreeable<T>::value, "Trying to use xfree with a non-POD \
59 data type.  Use operator delete instead.");
60
61   if (ptr != NULL)
62     free (ptr);         /* ARI: free */
63 }
64
65
66 /* Like asprintf and vasprintf, but return the string, throw an error
67    if no memory.  */
68 char *xstrprintf (const char *format, ...) ATTRIBUTE_PRINTF (1, 2);
69 char *xstrvprintf (const char *format, va_list ap)
70      ATTRIBUTE_PRINTF (1, 0);
71
72 /* Like snprintf, but throw an error if the output buffer is too small.  */
73 int xsnprintf (char *str, size_t size, const char *format, ...)
74      ATTRIBUTE_PRINTF (3, 4);
75
76 /* Returns a std::string built from a printf-style format string.  */
77 std::string string_printf (const char* fmt, ...)
78   ATTRIBUTE_PRINTF (1, 2);
79
80 /* Like string_printf, but takes a va_list.  */
81 std::string string_vprintf (const char* fmt, va_list args)
82   ATTRIBUTE_PRINTF (1, 0);
83
84 /* Like string_printf, but appends to DEST instead of returning a new
85    std::string.  */
86 void string_appendf (std::string &dest, const char* fmt, ...)
87   ATTRIBUTE_PRINTF (2, 3);
88
89 /* Like string_appendf, but takes a va_list.  */
90 void string_vappendf (std::string &dest, const char* fmt, va_list args)
91   ATTRIBUTE_PRINTF (2, 0);
92
93 /* Make a copy of the string at PTR with LEN characters
94    (and add a null character at the end in the copy).
95    Uses malloc to get the space.  Returns the address of the copy.  */
96
97 char *savestring (const char *ptr, size_t len);
98
99 /* Extract the next word from ARG.  The next word is defined as either,
100    everything up to the next space, or, if the next word starts with either
101    a single or double quote, then everything up to the closing quote.  The
102    enclosing quotes are not returned in the result string.  The pointer in
103    ARG is updated to point to the first character after the end of the
104    word, or, for quoted words, the first character after the closing
105    quote.  */
106
107 std::string extract_string_maybe_quoted (const char **arg);
108
109 /* The strerror() function can return NULL for errno values that are
110    out of range.  Provide a "safe" version that always returns a
111    printable string.  This version is also thread-safe.  */
112
113 extern const char *safe_strerror (int);
114
115 /* Return true if the start of STRING matches PATTERN, false otherwise.  */
116
117 static inline bool
118 startswith (const char *string, const char *pattern)
119 {
120   return strncmp (string, pattern, strlen (pattern)) == 0;
121 }
122
123 /* Version of startswith that takes string_view arguments.  See comment
124    above.  */
125
126 static inline bool
127 startswith (gdb::string_view string, gdb::string_view pattern)
128 {
129   return (string.length () >= pattern.length ()
130           && strncmp (string.data (), pattern.data (), pattern.length ()) == 0);
131 }
132
133 ULONGEST strtoulst (const char *num, const char **trailer, int base);
134
135 /* Skip leading whitespace characters in INP, returning an updated
136    pointer.  If INP is NULL, return NULL.  */
137
138 extern char *skip_spaces (char *inp);
139
140 /* A const-correct version of the above.  */
141
142 extern const char *skip_spaces (const char *inp);
143
144 /* Skip leading non-whitespace characters in INP, returning an updated
145    pointer.  If INP is NULL, return NULL.  */
146
147 extern char *skip_to_space (char *inp);
148
149 /* A const-correct version of the above.  */
150
151 extern const char *skip_to_space (const char *inp);
152
153 /* Assumes that V is an argv for a program, and iterates through
154    freeing all the elements.  */
155 extern void free_vector_argv (std::vector<char *> &v);
156
157 /* Given a vector of arguments ARGV, return a string equivalent to
158    joining all the arguments with a whitespace separating them.  */
159 extern std::string stringify_argv (const std::vector<char *> &argv);
160
161 /* Return true if VALUE is in [LOW, HIGH].  */
162
163 template <typename T>
164 static bool
165 in_inclusive_range (T value, T low, T high)
166 {
167   return value >= low && value <= high;
168 }
169
170 /* Ensure that V is aligned to an N byte boundary (B's assumed to be a
171    power of 2).  Round up/down when necessary.  Examples of correct
172    use include:
173
174     addr = align_up (addr, 8); -- VALUE needs 8 byte alignment
175     write_memory (addr, value, len);
176     addr += len;
177
178    and:
179
180     sp = align_down (sp - len, 16); -- Keep SP 16 byte aligned
181     write_memory (sp, value, len);
182
183    Note that uses such as:
184
185     write_memory (addr, value, len);
186     addr += align_up (len, 8);
187
188    and:
189
190     sp -= align_up (len, 8);
191     write_memory (sp, value, len);
192
193    are typically not correct as they don't ensure that the address (SP
194    or ADDR) is correctly aligned (relying on previous alignment to
195    keep things right).  This is also why the methods are called
196    "align_..." instead of "round_..." as the latter reads better with
197    this incorrect coding style.  */
198
199 extern ULONGEST align_up (ULONGEST v, int n);
200 extern ULONGEST align_down (ULONGEST v, int n);
201
202 #endif /* COMMON_COMMON_UTILS_H */
This page took 0.035327 seconds and 4 git commands to generate.