1 /* Shared general utility routines for GDB, the GNU debugger. 2 3 Copyright (C) 1986-2024 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 #include "common-utils.h" 21 #include "host-defs.h" 22 #include "gdbsupport/gdb-safe-ctype.h" 23 #include "gdbsupport/gdb-xfree.h" 24 25 void * 26 xzalloc (size_t size) 27 { 28 return xcalloc (1, size); 29 } 30 31 /* Like asprintf/vasprintf but get an internal_error if the call 32 fails. */ 33 34 gdb::unique_xmalloc_ptr<char> 35 xstrprintf (const char *format, ...) 36 { 37 va_list args; 38 39 va_start (args, format); 40 gdb::unique_xmalloc_ptr<char> ret = xstrvprintf (format, args); 41 va_end (args); 42 return ret; 43 } 44 45 gdb::unique_xmalloc_ptr<char> 46 xstrvprintf (const char *format, va_list ap) 47 { 48 char *ret = NULL; 49 int status = vasprintf (&ret, format, ap); 50 51 /* NULL is returned when there was a memory allocation problem, or 52 any other error (for instance, a bad format string). A negative 53 status (the printed length) with a non-NULL buffer should never 54 happen, but just to be sure. */ 55 if (ret == NULL || status < 0) 56 internal_error (_("vasprintf call failed")); 57 return gdb::unique_xmalloc_ptr<char> (ret); 58 } 59 60 int 61 xsnprintf (char *str, size_t size, const char *format, ...) 62 { 63 va_list args; 64 int ret; 65 66 va_start (args, format); 67 ret = vsnprintf (str, size, format, args); 68 gdb_assert (ret < size); 69 va_end (args); 70 71 return ret; 72 } 73 74 /* See documentation in common-utils.h. */ 75 76 std::string 77 string_printf (const char* fmt, ...) 78 { 79 va_list vp; 80 int size; 81 82 va_start (vp, fmt); 83 size = vsnprintf (NULL, 0, fmt, vp); 84 va_end (vp); 85 86 std::string str (size, '\0'); 87 88 /* C++11 and later guarantee std::string uses contiguous memory and 89 always includes the terminating '\0'. */ 90 va_start (vp, fmt); 91 vsprintf (&str[0], fmt, vp); /* ARI: vsprintf */ 92 va_end (vp); 93 94 return str; 95 } 96 97 /* See documentation in common-utils.h. */ 98 99 std::string 100 string_vprintf (const char* fmt, va_list args) 101 { 102 va_list vp; 103 size_t size; 104 105 va_copy (vp, args); 106 size = vsnprintf (NULL, 0, fmt, vp); 107 va_end (vp); 108 109 std::string str (size, '\0'); 110 111 /* C++11 and later guarantee std::string uses contiguous memory and 112 always includes the terminating '\0'. */ 113 vsprintf (&str[0], fmt, args); /* ARI: vsprintf */ 114 115 return str; 116 } 117 118 119 /* See documentation in common-utils.h. */ 120 121 std::string & 122 string_appendf (std::string &str, const char *fmt, ...) 123 { 124 va_list vp; 125 126 va_start (vp, fmt); 127 string_vappendf (str, fmt, vp); 128 va_end (vp); 129 130 return str; 131 } 132 133 134 /* See documentation in common-utils.h. */ 135 136 std::string & 137 string_vappendf (std::string &str, const char *fmt, va_list args) 138 { 139 va_list vp; 140 int grow_size; 141 142 va_copy (vp, args); 143 grow_size = vsnprintf (NULL, 0, fmt, vp); 144 va_end (vp); 145 146 size_t curr_size = str.size (); 147 str.resize (curr_size + grow_size); 148 149 /* C++11 and later guarantee std::string uses contiguous memory and 150 always includes the terminating '\0'. */ 151 vsprintf (&str[curr_size], fmt, args); /* ARI: vsprintf */ 152 153 return str; 154 } 155 156 char * 157 savestring (const char *ptr, size_t len) 158 { 159 char *p = (char *) xmalloc (len + 1); 160 161 memcpy (p, ptr, len); 162 p[len] = 0; 163 return p; 164 } 165 166 /* See documentation in common-utils.h. */ 167 168 std::string 169 extract_string_maybe_quoted (const char **arg) 170 { 171 bool squote = false; 172 bool dquote = false; 173 bool bsquote = false; 174 std::string result; 175 const char *p = *arg; 176 177 /* Find the start of the argument. */ 178 p = skip_spaces (p); 179 180 /* Parse p similarly to gdb_argv buildargv function. */ 181 while (*p != '\0') 182 { 183 if (ISSPACE (*p) && !squote && !dquote && !bsquote) 184 break; 185 else 186 { 187 if (bsquote) 188 { 189 bsquote = false; 190 result += *p; 191 } 192 else if (*p == '\\') 193 bsquote = true; 194 else if (squote) 195 { 196 if (*p == '\'') 197 squote = false; 198 else 199 result += *p; 200 } 201 else if (dquote) 202 { 203 if (*p == '"') 204 dquote = false; 205 else 206 result += *p; 207 } 208 else 209 { 210 if (*p == '\'') 211 squote = true; 212 else if (*p == '"') 213 dquote = true; 214 else 215 result += *p; 216 } 217 p++; 218 } 219 } 220 221 *arg = p; 222 return result; 223 } 224 225 /* The bit offset of the highest byte in a ULONGEST, for overflow 226 checking. */ 227 228 #define HIGH_BYTE_POSN ((sizeof (ULONGEST) - 1) * HOST_CHAR_BIT) 229 230 /* True (non-zero) iff DIGIT is a valid digit in radix BASE, 231 where 2 <= BASE <= 36. */ 232 233 static int 234 is_digit_in_base (unsigned char digit, int base) 235 { 236 if (!ISALNUM (digit)) 237 return 0; 238 if (base <= 10) 239 return (ISDIGIT (digit) && digit < base + '0'); 240 else 241 return (ISDIGIT (digit) || TOLOWER (digit) < base - 10 + 'a'); 242 } 243 244 static int 245 digit_to_int (unsigned char c) 246 { 247 if (ISDIGIT (c)) 248 return c - '0'; 249 else 250 return TOLOWER (c) - 'a' + 10; 251 } 252 253 /* As for strtoul, but for ULONGEST results. */ 254 255 ULONGEST 256 strtoulst (const char *num, const char **trailer, int base) 257 { 258 unsigned int high_part; 259 ULONGEST result; 260 int minus = 0; 261 int i = 0; 262 263 /* Skip leading whitespace. */ 264 while (ISSPACE (num[i])) 265 i++; 266 267 /* Handle prefixes. */ 268 if (num[i] == '+') 269 i++; 270 else if (num[i] == '-') 271 { 272 minus = 1; 273 i++; 274 } 275 276 if (base == 0 || base == 16) 277 { 278 if (num[i] == '0' && (num[i + 1] == 'x' || num[i + 1] == 'X')) 279 { 280 i += 2; 281 if (base == 0) 282 base = 16; 283 } 284 } 285 286 if (base == 0 && num[i] == '0') 287 base = 8; 288 289 if (base == 0) 290 base = 10; 291 292 if (base < 2 || base > 36) 293 { 294 errno = EINVAL; 295 return 0; 296 } 297 298 result = high_part = 0; 299 for (; is_digit_in_base (num[i], base); i += 1) 300 { 301 result = result * base + digit_to_int (num[i]); 302 high_part = high_part * base + (unsigned int) (result >> HIGH_BYTE_POSN); 303 result &= ((ULONGEST) 1 << HIGH_BYTE_POSN) - 1; 304 if (high_part > 0xff) 305 { 306 errno = ERANGE; 307 result = ~ (ULONGEST) 0; 308 high_part = 0; 309 minus = 0; 310 break; 311 } 312 } 313 314 if (trailer != NULL) 315 *trailer = &num[i]; 316 317 result = result + ((ULONGEST) high_part << HIGH_BYTE_POSN); 318 if (minus) 319 return -result; 320 else 321 return result; 322 } 323 324 /* See documentation in common-utils.h. */ 325 326 char * 327 skip_spaces (char *chp) 328 { 329 if (chp == NULL) 330 return NULL; 331 while (*chp && ISSPACE (*chp)) 332 chp++; 333 return chp; 334 } 335 336 /* A const-correct version of the above. */ 337 338 const char * 339 skip_spaces (const char *chp) 340 { 341 if (chp == NULL) 342 return NULL; 343 while (*chp && ISSPACE (*chp)) 344 chp++; 345 return chp; 346 } 347 348 /* See documentation in common-utils.h. */ 349 350 const char * 351 skip_to_space (const char *chp) 352 { 353 if (chp == NULL) 354 return NULL; 355 while (*chp && !ISSPACE (*chp)) 356 chp++; 357 return chp; 358 } 359 360 /* See documentation in common-utils.h. */ 361 362 char * 363 skip_to_space (char *chp) 364 { 365 return (char *) skip_to_space ((const char *) chp); 366 } 367 368 /* See gdbsupport/common-utils.h. */ 369 370 void 371 free_vector_argv (std::vector<char *> &v) 372 { 373 for (char *el : v) 374 xfree (el); 375 376 v.clear (); 377 } 378 379 /* See gdbsupport/common-utils.h. */ 380 381 ULONGEST 382 align_up (ULONGEST v, int n) 383 { 384 /* Check that N is really a power of two. */ 385 gdb_assert (n && (n & (n-1)) == 0); 386 return (v + n - 1) & -n; 387 } 388 389 /* See gdbsupport/common-utils.h. */ 390 391 ULONGEST 392 align_down (ULONGEST v, int n) 393 { 394 /* Check that N is really a power of two. */ 395 gdb_assert (n && (n & (n-1)) == 0); 396 return (v & -n); 397 } 398 399 /* See gdbsupport/common-utils.h. */ 400 401 int 402 fromhex (int a) 403 { 404 if (a >= '0' && a <= '9') 405 return a - '0'; 406 else if (a >= 'a' && a <= 'f') 407 return a - 'a' + 10; 408 else if (a >= 'A' && a <= 'F') 409 return a - 'A' + 10; 410 else 411 error (_("Invalid hex digit %d"), a); 412 } 413 414 /* See gdbsupport/common-utils.h. */ 415 416 int 417 hex2bin (const char *hex, gdb_byte *bin, int count) 418 { 419 int i; 420 421 for (i = 0; i < count; i++) 422 { 423 if (hex[0] == 0 || hex[1] == 0) 424 { 425 /* Hex string is short, or of uneven length. 426 Return the count that has been converted so far. */ 427 return i; 428 } 429 *bin++ = fromhex (hex[0]) * 16 + fromhex (hex[1]); 430 hex += 2; 431 } 432 return i; 433 } 434 435 /* See gdbsupport/common-utils.h. */ 436 437 gdb::byte_vector 438 hex2bin (const char *hex) 439 { 440 size_t bin_len = strlen (hex) / 2; 441 gdb::byte_vector bin (bin_len); 442 443 hex2bin (hex, bin.data (), bin_len); 444 445 return bin; 446 } 447 448 /* See gdbsupport/common-utils.h. */ 449 450 std::string 451 bytes_to_string (gdb::array_view<const gdb_byte> bytes) 452 { 453 std::string ret; 454 455 for (size_t i = 0; i < bytes.size (); i++) 456 { 457 if (i == 0) 458 ret += string_printf ("%02x", bytes[i]); 459 else 460 ret += string_printf (" %02x", bytes[i]); 461 } 462 463 return ret; 464 } 465