22#include "gdbsupport/gdb_wait.h"
27#ifdef HAVE_SYS_RESOURCE_H
28#include <sys/resource.h>
51#include "gdbsupport/gdb_obstack.h"
61#include "readline/readline.h"
66#include "gdbsupport/gdb_regex.h"
67#include "gdbsupport/job-control.h"
68#include "gdbsupport/selftest.h"
69#include "gdbsupport/gdb_optional.h"
72#include "gdbsupport/pathstuff.h"
74#include "gdbsupport/scope-exit.h"
77#include "gdbsupport/gdb-safe-ctype.h"
79#include "gdbsupport/buildargv.h"
111 gdb_printf (file, _(
"Printing of 8-bit characters "
112 "in strings as \\nnn is %s.\n"),
141 (*deprecated_warning_hook) (string, args);
144 gdb::optional<target_terminal::scoped_restore_terminal_state> term_state;
147 term_state.emplace ();
164 throw_verror (GENERIC_ERROR,
string, args);
170 error ((
"%s"), stream.
c_str ());
175static void ATTRIBUTE_NORETURN
192 struct rlimit rlim = { (rlim_t) RLIM_INFINITY, (rlim_t) RLIM_INFINITY };
194 setrlimit (RLIMIT_CORE, &rlim);
200 signal (SIGABRT, SIG_DFL);
217 if (getrlimit (RLIMIT_CORE, &rlim) != 0)
223 if (rlim.rlim_cur == 0)
228 if (rlim.rlim_max == 0)
242 _(
"%s\nUnable to dump core, use `ulimit -c"
243 " unlimited' before executing GDB next time.\n"),
256 if (!core_dump_allowed)
259 return core_dump_allowed;
325 const
char *file,
int line, const
char *fmt, va_list ap)
334 static const char msg[] =
"Recursive internal problem.\n";
351 if (write (STDERR_FILENO, msg,
sizeof (msg)) !=
sizeof (msg))
363 std::string msg = string_vprintf (fmt, ap);
364 reason = string_printf (
"%s:%d: %s: %s\n"
365 "A problem internal to GDB has been detected,\n"
366 "further debugging may prove unreliable.",
367 file, line, problem->name, msg.c_str ());
373 fputs (reason.c_str (), stderr);
378 gdb::optional<target_terminal::scoped_restore_terminal_state> term_state;
381 term_state.emplace ();
392 || problem->should_print_backtrace)
395 if (problem->should_print_backtrace)
407 quit_p =
query (_(
"%s\nQuit this debugging session? "),
415 internal_error (_(
"bad switch"));
436 dump_core_p =
query (_(
"%s\nCreate a core file of GDB? "),
445 internal_error (_(
"bad switch"));
458#ifdef HAVE_WORKING_FORK
477 throw_quit (_(
"Command aborted."));
507 va_start (ap,
string);
535 *set_cmd_list = NULL;
536 *show_cmd_list = NULL;
542 = xstrprintf (_(
"Configure what GDB does when %s is detected."),
543 problem->
name).release ();
545 = xstrprintf (_(
"Show what GDB does when %s is detected."),
546 problem->
name).release ();
549 set_doc, show_doc, set_cmd_list, show_cmd_list,
554 std::string set_quit_doc
555 = string_printf (_(
"Set whether GDB should quit when an %s is "
556 "detected."), problem->
name);
557 std::string show_quit_doc
558 = string_printf (_(
"Show whether GDB will quit when an %s is "
559 "detected."), problem->
name);
563 set_quit_doc.c_str (),
564 show_quit_doc.c_str (),
574 std::string set_core_doc
575 = string_printf (_(
"Set whether GDB should create a core file of "
576 "GDB when %s is detected."), problem->
name);
577 std::string show_core_doc
578 = string_printf (_(
"Show whether GDB will create a core file of "
579 "GDB when %s is detected."), problem->
name);
583 set_core_doc.c_str (),
584 show_core_doc.c_str (),
594 std::string set_bt_doc
595 = string_printf (_(
"Set whether GDB should print a backtrace of "
596 "GDB when %s is detected."), problem->
name);
597 std::string show_bt_doc
598 = string_printf (_(
"Show whether GDB will print a backtrace of "
599 "GDB when %s is detected."), problem->
name);
603 show_bt_doc.c_str (),
618 const char *
err = safe_strerror (errno);
619 return std::string (
prefix) +
": " +
err;
626static void ATTRIBUTE_NORETURN
634 bfd_set_error (bfd_error_no_error);
637 throw_error (errcode, _(
"%s."), combined.c_str ());
655 warning (_(
"%s"), combined.c_str ());
664 const char *
err = safe_strerror (errcode);
690 throw_quit (
"Quit (expect signal SIGINT when the program is resumed)");
717 internal_error (_(
"virtual memory exhausted: can't allocate %ld bytes."),
722 internal_error (_(
"virtual memory exhausted."));
746 val =
read (desc, addr, len);
765 error (_(
"Attempt to raise 0 to negative power."));
839defaulted_query (const
char *ctlstr, const
char defchar, va_list args)
843 char def_answer, not_def_answer;
844 const char *y_string, *n_string;
851 not_def_answer =
'N';
855 else if (defchar ==
'y')
859 not_def_answer =
'N';
867 not_def_answer =
'Y';
892 "input not from terminal]\n"),
893 y_string, n_string, def_answer);
905 std::string question = string_vprintf (ctlstr, args);
907 = string_printf (_(
"%s%s(%s or %s) %s"),
909 question.c_str (), y_string, n_string,
914 using namespace std::chrono;
915 steady_clock::time_point prompt_started = steady_clock::now ();
921 char *response, answer;
926 if (response == NULL)
928 gdb_printf (
"EOF [assumed %c]\n", def_answer);
933 answer = response[0];
940 if (answer == not_def_answer)
948 if (answer == def_answer
949 || (defchar !=
'\0' && answer ==
'\0'))
980 va_start (args, ctlstr);
981 ret = defaulted_query (ctlstr,
'n', args);
998 va_start (args, ctlstr);
999 ret = defaulted_query (ctlstr,
'y', args);
1015 va_start (args, ctlstr);
1016 ret = defaulted_query (ctlstr,
'\0', args);
1032 auto_obstack host_data;
1035 (gdb_byte *) &the_char, 1, 1,
1038 if (obstack_object_size (&host_data) == 1)
1041 *target_c = *(
char *) obstack_base (&host_data);
1065 int target_char = -2;
1066 int c = *(*string_ptr)++;
1085 int i = fromhex (c);
1090 if (ISDIGIT (c) && c !=
'8' && c !=
'9')
1131 error (_(
"The escape sequence `\\%c' is equivalent to plain `%c',"
1132 " which has no equivalent\nin the `%s' character set."),
1145 _(
"Number of lines gdb thinks are in a page is %s.\n"),
1156 _(
"Number of characters gdb thinks "
1157 "are in a line is %s.\n"),
1197#if defined(__GO32__)
1198 rows = ScreenRows ();
1199 cols = ScreenCols ();
1204 rl_reset_terminal (NULL);
1207 rl_get_screen_size (&rows, &cols);
1214 if (((rows <= 0) && (
tgetnum ((
char *)
"li") < 0))
1217 || getenv (
"EMACS") || getenv (
"INSIDE_EMACS"))
1232 rl_catch_sigwinch = 0;
1283 const int sqrt_int_max =
INT_MAX >> (
sizeof (int) * 8 / 2);
1285 if (rows <= 0 || rows > sqrt_int_max)
1287 rows = sqrt_int_max;
1291 if (cols <= 0 || cols > sqrt_int_max)
1293 cols = sqrt_int_max;
1298 rl_set_screen_size (rows, cols);
1370 char cont_prompt[120];
1373 using namespace std::chrono;
1374 steady_clock::time_point prompt_started = steady_clock::now ();
1377 scoped_restore save_paging = make_scoped_restore (&
m_paging,
true);
1383 m_stream->
puts ((
"\n\032\032pre-prompt-for-continue\n"));
1385 strcpy (cont_prompt,
1386 "--Type <RET> for more, q to quit, "
1387 "c to continue without paging--");
1389 strcat (cont_prompt,
"\n\032\032prompt-for-continue\n");
1406 m_stream->
puts ((
"\n\032\032post-prompt-for-continue\n"));
1410 char *p = ignore.get ();
1412 while (*p ==
' ' || *p ==
'\t')
1416 throw_quit (
"Quit");
1418 disable_pagination =
true;
1434 using namespace std::chrono;
1441std::chrono::steady_clock::duration
1545 stringlen = strlen (
string);
1550 spaces += width - stringlen;
1552 spacebuf = (
char *) alloca (spaces + 1);
1553 spacebuf[spaces] =
'\0';
1555 spacebuf[spaces] =
' ';
1579 const char *lineptr;
1581 if (linebuffer == 0)
1596 = make_scope_exit ([&] ()
1613 lineptr = linebuffer;
1624 while (*lineptr && *lineptr !=
'\n')
1629 if (*lineptr ==
'\t')
1638 else if (*lineptr ==
'\033'
1644 lineptr += skip_bytes;
1646 else if (*lineptr ==
'\r')
1670 bool did_paginate =
false;
1696 if (pagination_enabled
1701 did_paginate =
true;
1725 else if (did_paginate)
1730 if (*lineptr ==
'\n')
1740 buffer_clearer.release ();
1748 std::string str (buf, length_buf);
1749 this->
puts (str.c_str ());
1764 scoped_restore save_enabled
1766 scoped_restore save_disabled
1768 scoped_restore save_batch
1770 scoped_restore save_lines
1773 scoped_restore save_chars
1775 scoped_restore save_printed
1778 pager.puts (
"aaaaaaaaaaaa");
1779 pager.wrap_here (2);
1780 pager.puts (
"bbbbbbbbbbbb\n");
1782 SELF_CHECK (strfile->
string () ==
"aaaaaaaaaaaa\n bbbbbbbbbbbb\n");
1790 stream->
puts (linebuffer);
1812 while (*str && highlight.exec (str, 1, &pmatch, 0) == 0)
1814 size_t n_highlight = pmatch.rm_eo - pmatch.rm_so;
1817 while (pmatch.rm_so > 0)
1826 while (n_highlight > 0)
1849 return stream->
putc (c);
1855 stream->
vprintf (format, args);
1869 va_start (args, format);
1878 const char *format, ...)
1883 va_start (args, format);
1894 va_start (args, format);
1905 va_start (args, format);
1907 file.vprintf (format, args);
1908 gdb_stdout->puts_unfiltered (file.string ().c_str ());
1929 static char *spaces = 0;
1930 static int max_spaces = -1;
1935 spaces = (
char *)
xmalloc (n + 1);
1936 for (t = spaces + n; t != spaces;)
1942 return spaces + max_spaces - n;
1972 gdb::unique_xmalloc_ptr<char> demangled
1974 gdb_puts (demangled ? demangled.get () :
name, stream);
1985 return (ISALNUM (ch) || ch ==
'_');
1994 const char *p =
token;
1995 while (p != end && !ISSPACE (*p) && *p !=
'(')
2008 static const char *ops[] =
2014 "-=",
"--",
"->",
"-",
2023 "<<=",
"<=",
"<<",
"<",
2024 ">>=",
">=",
">>",
">",
2028 for (
const char *op : ops)
2030 size_t oplen = strlen (op);
2031 size_t lencmp = std::min<size_t> (oplen, end - p);
2033 if (strncmp (p, op, lencmp) == 0)
2047skip_ws (
const char *&string1,
const char *&string2,
const char *end_str2)
2049 while (ISSPACE (*string1))
2051 while (string2 < end_str2 && ISSPACE (*string2))
2062 return ((
string == start
2076 const char *p = *
name;
2078 if (startswith (p,
"[abi:"))
2101 const char *p = *
name;
2107 if (template_param_list_end == NULL)
2110 p = template_param_list_end + 1;
2115 while (ISSPACE (*q))
2133 bool ignore_template_params)
2135 const char *string1_start = string1;
2136 const char *end_str2 = string2 + string2_len;
2137 bool skip_spaces =
true;
2148 skip_ws (string1, string2, end_str2);
2149 skip_spaces =
false;
2167 if (string2 == end_str2
2170 const char *abi_start = string1;
2176 if (match_for_lcd != NULL && abi_start != string1)
2179 while (ISSPACE (*string1))
2210 && *string1 ==
'<' && *string2 !=
'<')
2213 const char *template_start = string1;
2219 if (*string2 !=
'\0'
2220 && match_for_lcd != NULL && template_start != string1)
2225 if (*string1 ==
'\0' || string2 == end_str2)
2229 if (have_colon_op && string1[0] ==
':' && string1[1] ==
':')
2231 if (*string2 !=
':')
2237 if (string2 == end_str2)
2240 if (*string2 !=
':')
2246 while (ISSPACE (*string1))
2248 while (string2 < end_str2 && ISSPACE (*string2))
2262 if (strncmp (string1, string2, cmplen) != 0)
2268 if (string2 != end_str2)
2274 skip_ws (string1, string2, end_str2);
2278 if (*string1 ==
'(')
2280 if (string2 == end_str2)
2291 return *string1 !=
'\0';
2295 if (*string1 != *string2)
2304 skip_ws (string1, string2, end_str2);
2308 const char *end_str1 = string1 + strlen (string1);
2312 cmplen = std::min (p1 - string1, p2 - string2);
2315 if (strncmp (string1, string2, cmplen) != 0)
2320 if (p1 - string1 != p2 - string2)
2322 if (strncmp (string1, string2, cmplen) != 0)
2329 if (*string1 ==
'\0' || string2 == end_str2)
2331 if (*string1 ==
'(' || *string2 ==
'(')
2336 skip_ws (string1, string2, end_str2);
2337 if (*string1 ==
'<' || *string2 ==
'<')
2348 && (TOLOWER ((
unsigned char) *string1)
2349 != TOLOWER ((
unsigned char) *string2)))
2362 if (string2 == end_str2)
2382 if (match_for_lcd != NULL)
2384 while ((string1 = strstr (string1,
"[abi:")) != NULL)
2386 const char *abi_start = string1;
2392 if (abi_start != string1)
2400 return (*string1 !=
'\0' && *string1 !=
'(');
2410#define CHECK_MATCH_LM(S1, S2, MODE, LANG, LCD) \
2411 SELF_CHECK (strncmp_iw_with_mode ((S1), (S2), strlen ((S2)), \
2412 strncmp_iw_mode::MODE, \
2413 (LANG), (LCD)) == 0)
2415#define CHECK_MATCH_LANG(S1, S2, MODE, LANG) \
2416 CHECK_MATCH_LM ((S1), (S2), MODE, (LANG), nullptr)
2418#define CHECK_MATCH(S1, S2, MODE) \
2419 CHECK_MATCH_LANG ((S1), (S2), MODE, language_minimal)
2421#define CHECK_NO_MATCH_LM(S1, S2, MODE, LANG, LCD) \
2422 SELF_CHECK (strncmp_iw_with_mode ((S1), (S2), strlen ((S2)), \
2423 strncmp_iw_mode::MODE, \
2426#define CHECK_NO_MATCH_LANG(S1, S2, MODE, LANG) \
2427 CHECK_NO_MATCH_LM ((S1), (S2), MODE, (LANG), nullptr)
2429#define CHECK_NO_MATCH(S1, S2, MODE) \
2430 CHECK_NO_MATCH_LANG ((S1), (S2), MODE, language_minimal)
2433check_scope_operator (
enum language lang)
2435 CHECK_MATCH_LANG (
"::",
"::",
NORMAL, lang);
2436 CHECK_MATCH_LANG (
"::foo",
"::",
NORMAL, lang);
2437 CHECK_MATCH_LANG (
"::foo",
"::foo",
NORMAL, lang);
2438 CHECK_MATCH_LANG (
" :: foo ",
"::foo",
NORMAL, lang);
2439 CHECK_MATCH_LANG (
"a::b",
"a ::b",
NORMAL, lang);
2440 CHECK_MATCH_LANG (
"a::b",
"a\t::b",
NORMAL, lang);
2441 CHECK_MATCH_LANG (
"a::b",
"a \t::b",
NORMAL, lang);
2442 CHECK_MATCH_LANG (
"a::b",
"a\t ::b",
NORMAL, lang);
2443 CHECK_MATCH_LANG (
"a::b",
"a:: b",
NORMAL, lang);
2444 CHECK_MATCH_LANG (
"a::b",
"a::\tb",
NORMAL, lang);
2445 CHECK_MATCH_LANG (
"a::b",
"a:: \tb",
NORMAL, lang);
2446 CHECK_MATCH_LANG (
"a::b",
"a::\t b",
NORMAL, lang);
2447 CHECK_MATCH_LANG (
"a::b",
"a :: b",
NORMAL, lang);
2448 CHECK_MATCH_LANG (
"a::b",
"a ::\tb",
NORMAL, lang);
2449 CHECK_MATCH_LANG (
"a::b",
"a\t:: b",
NORMAL, lang);
2450 CHECK_MATCH_LANG (
"a::b",
"a \t::\t b",
NORMAL, lang);
2451 CHECK_MATCH_LANG (
"a ::b",
"a::b",
NORMAL, lang);
2452 CHECK_MATCH_LANG (
"a\t::b",
"a::b",
NORMAL, lang);
2453 CHECK_MATCH_LANG (
"a \t::b",
"a::b",
NORMAL, lang);
2454 CHECK_MATCH_LANG (
"a\t ::b",
"a::b",
NORMAL, lang);
2455 CHECK_MATCH_LANG (
"a:: b",
"a::b",
NORMAL, lang);
2456 CHECK_MATCH_LANG (
"a::\tb",
"a::b",
NORMAL, lang);
2457 CHECK_MATCH_LANG (
"a:: \tb",
"a::b",
NORMAL, lang);
2458 CHECK_MATCH_LANG (
"a::\t b",
"a::b",
NORMAL, lang);
2459 CHECK_MATCH_LANG (
"a :: b",
"a::b",
NORMAL, lang);
2460 CHECK_MATCH_LANG (
"a ::\tb",
"a::b",
NORMAL, lang);
2461 CHECK_MATCH_LANG (
"a\t:: b",
"a::b",
NORMAL, lang);
2462 CHECK_MATCH_LANG (
"a \t::\t b",
"a::b",
NORMAL, lang);
2463 CHECK_MATCH_LANG (
"a::b::c",
"a::b::c",
NORMAL, lang);
2464 CHECK_MATCH_LANG (
" a:: b:: c",
"a::b::c",
NORMAL, lang);
2465 CHECK_MATCH_LANG (
"a::b::c",
" a:: b:: c",
NORMAL, lang);
2466 CHECK_MATCH_LANG (
"a ::b ::c",
"a::b::c",
NORMAL, lang);
2467 CHECK_MATCH_LANG (
"a::b::c",
"a :: b:: c",
NORMAL, lang);
2468 CHECK_MATCH_LANG (
"\ta::\tb::\tc",
"\ta::\tb::\tc",
NORMAL, lang);
2469 CHECK_MATCH_LANG (
"a\t::b\t::c\t",
"a\t::b\t::c\t",
NORMAL, lang);
2470 CHECK_MATCH_LANG (
" \ta:: \tb:: \tc",
" \ta:: \tb:: \tc",
NORMAL, lang);
2471 CHECK_MATCH_LANG (
"\t a::\t b::\t c",
"\t a::\t b::\t c",
NORMAL, lang);
2472 CHECK_MATCH_LANG (
"a::b::c",
"\ta::\tb::\tc",
NORMAL, lang);
2473 CHECK_MATCH_LANG (
"a::b::c",
"a\t::b\t::c\t",
NORMAL, lang);
2474 CHECK_MATCH_LANG (
"a::b::c",
" \ta:: \tb:: \tc",
NORMAL, lang);
2475 CHECK_MATCH_LANG (
"a::b::c",
"\t a::\t b::\t c",
NORMAL, lang);
2476 CHECK_MATCH_LANG (
"\ta::\tb::\tc",
"a::b::c",
NORMAL, lang);
2477 CHECK_MATCH_LANG (
"a\t::b\t::c\t",
"a::b::c",
NORMAL, lang);
2478 CHECK_MATCH_LANG (
" \ta:: \tb:: \tc",
"a::b::c",
NORMAL, lang);
2479 CHECK_MATCH_LANG (
"\t a::\t b::\t c",
"a::b::c",
NORMAL, lang);
2480 CHECK_MATCH_LANG (
"a :: b:: c\t",
"\ta :: b\t:: c\t\t",
NORMAL, lang);
2481 CHECK_MATCH_LANG (
" a::\t \t b:: c\t",
"\ta ::b:: c\t\t",
2483 CHECK_MATCH_LANG (
"a :: b :: \t\t\tc\t",
2484 "\t\t\t\ta :: \t\t\t b \t\t::c",
2486 CHECK_MATCH_LANG (
"a::b()",
"a",
NORMAL, lang);
2487 CHECK_MATCH_LANG (
"a::b()",
"a::",
NORMAL, lang);
2488 CHECK_MATCH_LANG (
"a::b()",
"a::b",
NORMAL, lang);
2489 CHECK_MATCH_LANG (
"a::b(a)",
"a",
NORMAL, lang);
2490 CHECK_MATCH_LANG (
"a::b(a)",
"a::",
NORMAL, lang);
2491 CHECK_MATCH_LANG (
"a::b(a)",
"a::b",
NORMAL, lang);
2492 CHECK_MATCH_LANG (
"a::b(a,b)",
"a",
NORMAL, lang);
2493 CHECK_MATCH_LANG (
"a::b(a,b)",
"a::",
NORMAL, lang);
2494 CHECK_MATCH_LANG (
"a::b(a,b)",
"a::b",
NORMAL, lang);
2495 CHECK_MATCH_LANG (
"a::b(a,b,c)",
"a",
NORMAL, lang);
2496 CHECK_MATCH_LANG (
"a::b(a,b,c)",
"a::",
NORMAL, lang);
2497 CHECK_MATCH_LANG (
"a::b(a,b,c)",
"a::b",
NORMAL, lang);
2499 CHECK_NO_MATCH_LANG (
"a::",
"::a",
NORMAL, lang);
2500 CHECK_NO_MATCH_LANG (
"::a",
"::a()",
NORMAL, lang);
2501 CHECK_NO_MATCH_LANG (
"::",
"::a",
NORMAL, lang);
2502 CHECK_NO_MATCH_LANG (
"a:::b",
"a::b",
NORMAL, lang);
2503 CHECK_NO_MATCH_LANG (
"a::b()",
"a::b(a)",
NORMAL, lang);
2504 CHECK_NO_MATCH_LANG (
"a::b(a)",
"a::b()",
NORMAL, lang);
2505 CHECK_NO_MATCH_LANG (
"a::b(a,b)",
"a::b(a,a)",
NORMAL, lang);
2506 CHECK_NO_MATCH_LANG (
"a::b",
"a()",
NORMAL, lang);
2507 CHECK_NO_MATCH_LANG (
"a::b",
"a::()",
NORMAL, lang);
2508 CHECK_NO_MATCH_LANG (
"a::b",
"a::b()",
NORMAL, lang);
2509 CHECK_NO_MATCH_LANG (
"a::b",
"a(a)",
NORMAL, lang);
2510 CHECK_NO_MATCH_LANG (
"a::b",
"a::(a)",
NORMAL, lang);
2511 CHECK_NO_MATCH_LANG (
"a::b",
"a::b()",
NORMAL, lang);
2512 CHECK_NO_MATCH_LANG (
"a::b",
"a(a,b)",
NORMAL, lang);
2513 CHECK_NO_MATCH_LANG (
"a::b",
"a::(a,b)",
NORMAL, lang);
2514 CHECK_NO_MATCH_LANG (
"a::b",
"a::b(a,b)",
NORMAL, lang);
2515 CHECK_NO_MATCH_LANG (
"a::b",
"a(a,b,c)",
NORMAL, lang);
2516 CHECK_NO_MATCH_LANG (
"a::b",
"a::(a,b,c)",
NORMAL, lang);
2517 CHECK_NO_MATCH_LANG (
"a::b",
"a::b(a,b,c)",
NORMAL, lang);
2523strncmp_iw_with_mode_tests ()
2530 CHECK_MATCH (
"",
"",
NORMAL);
2531 CHECK_MATCH (
"foo",
"foo",
NORMAL);
2532 CHECK_MATCH (
" foo",
"foo",
NORMAL);
2533 CHECK_MATCH (
"foo ",
"foo",
NORMAL);
2534 CHECK_MATCH (
" foo ",
"foo",
NORMAL);
2535 CHECK_MATCH (
" foo",
"foo",
NORMAL);
2536 CHECK_MATCH (
"foo ",
"foo",
NORMAL);
2537 CHECK_MATCH (
" foo ",
"foo",
NORMAL);
2538 CHECK_MATCH (
"\tfoo",
"foo",
NORMAL);
2539 CHECK_MATCH (
"foo\t",
"foo",
NORMAL);
2540 CHECK_MATCH (
"\tfoo\t",
"foo",
NORMAL);
2541 CHECK_MATCH (
" \tfoo \t",
"foo",
NORMAL);
2542 CHECK_MATCH (
"\t foo\t ",
"foo",
NORMAL);
2543 CHECK_MATCH (
"\t \t \t\t\t\t foo\t\t\t \t\t \t \t \t \t ",
2546 "\t \t \t\t\t\t foo\t\t\t \t\t \t \t \t \t ",
2548 CHECK_MATCH (
"foo bar",
"foo",
NORMAL);
2549 CHECK_NO_MATCH (
"foo",
"bar",
NORMAL);
2550 CHECK_NO_MATCH (
"foo bar",
"foobar",
NORMAL);
2551 CHECK_NO_MATCH (
" foo ",
"bar",
NORMAL);
2552 CHECK_NO_MATCH (
"foo",
" bar ",
NORMAL);
2553 CHECK_NO_MATCH (
" \t\t foo\t\t ",
"\t \t \tbar\t",
NORMAL);
2554 CHECK_NO_MATCH (
"@!%&",
"@!%&foo",
NORMAL);
2557 CHECK_MATCH (
"foo()",
"foo()",
NORMAL);
2558 CHECK_MATCH (
"foo ()",
"foo()",
NORMAL);
2559 CHECK_MATCH (
"foo ()",
"foo()",
NORMAL);
2560 CHECK_MATCH (
"foo\t()",
"foo()",
NORMAL);
2561 CHECK_MATCH (
"foo\t ()",
"foo()",
NORMAL);
2562 CHECK_MATCH (
"foo \t()",
"foo()",
NORMAL);
2563 CHECK_MATCH (
"foo()",
"foo ()",
NORMAL);
2564 CHECK_MATCH (
"foo()",
"foo ()",
NORMAL);
2565 CHECK_MATCH (
"foo()",
"foo\t()",
NORMAL);
2566 CHECK_MATCH (
"foo()",
"foo\t ()",
NORMAL);
2567 CHECK_MATCH (
"foo()",
"foo \t()",
NORMAL);
2568 CHECK_MATCH (
"foo()",
"foo()",
NORMAL);
2569 CHECK_MATCH (
"foo ()",
"foo ()",
NORMAL);
2570 CHECK_MATCH (
"foo ()",
"foo ()",
NORMAL);
2571 CHECK_MATCH (
"foo\t()",
"foo\t()",
NORMAL);
2572 CHECK_MATCH (
"foo\t ()",
"foo\t ()",
NORMAL);
2573 CHECK_MATCH (
"foo \t()",
"foo \t()",
NORMAL);
2574 CHECK_MATCH (
"foo(a)",
"foo(a)",
NORMAL);
2575 CHECK_MATCH (
"foo( a)",
"foo(a)",
NORMAL);
2576 CHECK_MATCH (
"foo(a )",
"foo(a)",
NORMAL);
2577 CHECK_MATCH (
"foo(\ta)",
"foo(a)",
NORMAL);
2578 CHECK_MATCH (
"foo(a\t)",
"foo(a)",
NORMAL);
2579 CHECK_MATCH (
"foo(\t a)",
"foo(a)",
NORMAL);
2580 CHECK_MATCH (
"foo( \ta)",
"foo(a)",
NORMAL);
2581 CHECK_MATCH (
"foo(a\t )",
"foo(a)",
NORMAL);
2582 CHECK_MATCH (
"foo(a \t)",
"foo(a)",
NORMAL);
2583 CHECK_MATCH (
"foo( a )",
"foo(a)",
NORMAL);
2584 CHECK_MATCH (
"foo(\ta\t)",
"foo(a)",
NORMAL);
2585 CHECK_MATCH (
"foo(\t a\t )",
"foo(a)",
NORMAL);
2586 CHECK_MATCH (
"foo( \ta \t)",
"foo(a)",
NORMAL);
2587 CHECK_MATCH (
"foo(a)",
"foo( a)",
NORMAL);
2588 CHECK_MATCH (
"foo(a)",
"foo(a )",
NORMAL);
2589 CHECK_MATCH (
"foo(a)",
"foo(\ta)",
NORMAL);
2590 CHECK_MATCH (
"foo(a)",
"foo(a\t)",
NORMAL);
2591 CHECK_MATCH (
"foo(a)",
"foo(\t a)",
NORMAL);
2592 CHECK_MATCH (
"foo(a)",
"foo( \ta)",
NORMAL);
2593 CHECK_MATCH (
"foo(a)",
"foo(a\t )",
NORMAL);
2594 CHECK_MATCH (
"foo(a)",
"foo(a \t)",
NORMAL);
2595 CHECK_MATCH (
"foo(a)",
"foo( a )",
NORMAL);
2596 CHECK_MATCH (
"foo(a)",
"foo(\ta\t)",
NORMAL);
2597 CHECK_MATCH (
"foo(a)",
"foo(\t a\t )",
NORMAL);
2598 CHECK_MATCH (
"foo(a)",
"foo( \ta \t)",
NORMAL);
2599 CHECK_MATCH (
"foo(a,b)",
"foo(a,b)",
NORMAL);
2600 CHECK_MATCH (
"foo(a ,b)",
"foo(a,b)",
NORMAL);
2601 CHECK_MATCH (
"foo(a\t,b)",
"foo(a,b)",
NORMAL);
2602 CHECK_MATCH (
"foo(a,\tb)",
"foo(a,b)",
NORMAL);
2603 CHECK_MATCH (
"foo(a\t,\tb)",
"foo(a,b)",
NORMAL);
2604 CHECK_MATCH (
"foo(a \t,b)",
"foo(a,b)",
NORMAL);
2605 CHECK_MATCH (
"foo(a\t ,b)",
"foo(a,b)",
NORMAL);
2606 CHECK_MATCH (
"foo(a,\tb)",
"foo(a,b)",
NORMAL);
2607 CHECK_MATCH (
"foo(a, \tb)",
"foo(a,b)",
NORMAL);
2608 CHECK_MATCH (
"foo(a,\t b)",
"foo(a,b)",
NORMAL);
2609 CHECK_MATCH (
"foo(a,b)",
"foo(a ,b)",
NORMAL);
2610 CHECK_MATCH (
"foo(a,b)",
"foo(a\t,b)",
NORMAL);
2611 CHECK_MATCH (
"foo(a,b)",
"foo(a,\tb)",
NORMAL);
2612 CHECK_MATCH (
"foo(a,b)",
"foo(a\t,\tb)",
NORMAL);
2613 CHECK_MATCH (
"foo(a,b)",
"foo(a \t,b)",
NORMAL);
2614 CHECK_MATCH (
"foo(a,b)",
"foo(a\t ,b)",
NORMAL);
2615 CHECK_MATCH (
"foo(a,b)",
"foo(a,\tb)",
NORMAL);
2616 CHECK_MATCH (
"foo(a,b)",
"foo(a, \tb)",
NORMAL);
2617 CHECK_MATCH (
"foo(a,b)",
"foo(a,\t b)",
NORMAL);
2618 CHECK_MATCH (
"foo(a,b,c,d)",
"foo(a,b,c,d)",
NORMAL);
2619 CHECK_MATCH (
" foo ( a , b , c , d ) ",
"foo(a,b,c,d)",
NORMAL);
2620 CHECK_MATCH (
" foo ( a , b , c , d ) ",
"foo( a , b , c , d )",
NORMAL);
2621 CHECK_MATCH (
"foo &\t*(\ta b *\t\t&)",
"foo",
NORMAL);
2622 CHECK_MATCH (
"foo &\t*(\ta b *\t\t&)",
"foo&*(a b * &)",
NORMAL);
2623 CHECK_MATCH (
"foo(a) b",
"foo(a)",
NORMAL);
2624 CHECK_MATCH (
"*foo(*a&)",
"*foo",
NORMAL);
2625 CHECK_MATCH (
"*foo(*a&)",
"*foo(*a&)",
NORMAL);
2626 CHECK_MATCH (
"*a&b#c/^d$foo(*a&)",
"*a&b#c/^d$foo",
NORMAL);
2627 CHECK_MATCH (
"* foo",
"*foo",
NORMAL);
2628 CHECK_MATCH (
"foo&",
"foo",
NORMAL);
2629 CHECK_MATCH (
"foo*",
"foo",
NORMAL);
2630 CHECK_MATCH (
"foo.",
"foo",
NORMAL);
2631 CHECK_MATCH (
"foo->",
"foo",
NORMAL);
2633 CHECK_NO_MATCH (
"foo",
"foo(",
NORMAL);
2634 CHECK_NO_MATCH (
"foo",
"foo()",
NORMAL);
2635 CHECK_NO_MATCH (
"foo",
"foo(a)",
NORMAL);
2636 CHECK_NO_MATCH (
"foo",
"foo(a)",
NORMAL);
2637 CHECK_NO_MATCH (
"foo",
"foo*",
NORMAL);
2638 CHECK_NO_MATCH (
"foo",
"foo (*",
NORMAL);
2639 CHECK_NO_MATCH (
"foo*",
"foo (*",
NORMAL);
2640 CHECK_NO_MATCH (
"foo *",
"foo (*",
NORMAL);
2641 CHECK_NO_MATCH (
"foo&",
"foo (*",
NORMAL);
2642 CHECK_NO_MATCH (
"foo &",
"foo (*",
NORMAL);
2643 CHECK_NO_MATCH (
"foo &*",
"foo (&)",
NORMAL);
2644 CHECK_NO_MATCH (
"foo & \t *\t",
"foo (*",
NORMAL);
2645 CHECK_NO_MATCH (
"foo & \t *\t",
"foo (*",
NORMAL);
2646 CHECK_NO_MATCH (
"foo(a*) b",
"foo(a) b",
NORMAL);
2647 CHECK_NO_MATCH (
"foo[aqi:A](a)",
"foo(b)",
NORMAL);
2648 CHECK_NO_MATCH (
"*foo",
"foo",
NORMAL);
2649 CHECK_NO_MATCH (
"*foo",
"foo*",
NORMAL);
2650 CHECK_NO_MATCH (
"*foo*",
"*foo&",
NORMAL);
2651 CHECK_NO_MATCH (
"*foo*",
"foo *",
NORMAL);
2652 CHECK_NO_MATCH (
"&foo",
"foo",
NORMAL);
2653 CHECK_NO_MATCH (
"&foo",
"foo&",
NORMAL);
2654 CHECK_NO_MATCH (
"foo&",
"&foo",
NORMAL);
2655 CHECK_NO_MATCH (
"foo",
"foo&",
NORMAL);
2656 CHECK_NO_MATCH (
"foo",
"foo*",
NORMAL);
2657 CHECK_NO_MATCH (
"foo",
"foo.",
NORMAL);
2658 CHECK_NO_MATCH (
"foo",
"foo->",
NORMAL);
2659 CHECK_NO_MATCH (
"foo bar",
"foo()",
NORMAL);
2660 CHECK_NO_MATCH (
"foo bar",
"foo bar()",
NORMAL);
2661 CHECK_NO_MATCH (
"foo()",
"foo(a)",
NORMAL);
2662 CHECK_NO_MATCH (
"*(*)&",
"*(*)*",
NORMAL);
2663 CHECK_NO_MATCH (
"foo(a)",
"foo()",
NORMAL);
2664 CHECK_NO_MATCH (
"foo(a)",
"foo(b)",
NORMAL);
2665 CHECK_NO_MATCH (
"foo(a,b)",
"foo(a,b,c)",
NORMAL);
2666 CHECK_NO_MATCH (
"foo(a\\b)",
"foo()",
NORMAL);
2667 CHECK_NO_MATCH (
"foo bar(a b c d)",
"foobar",
NORMAL);
2668 CHECK_NO_MATCH (
"foo bar(a b c d)",
"foobar ( a b c \td\t)\t",
NORMAL);
2677 CHECK_MATCH_LANG (
"operator foo(int&)",
"operator foo(int &)",
NORMAL,
2679 CHECK_MATCH_LANG (
"operator foo(int &)",
"operator foo(int &)",
NORMAL,
2681 CHECK_MATCH_LANG (
"operator foo(int\t&)",
"operator foo(int\t&)",
NORMAL,
2683 CHECK_MATCH_LANG (
"operator foo (int)",
"operator foo(int)",
NORMAL,
2685 CHECK_MATCH_LANG (
"operator foo\t(int)",
"operator foo(int)",
NORMAL,
2687 CHECK_MATCH_LANG (
"operator foo \t(int)",
"operator foo(int)",
NORMAL,
2689 CHECK_MATCH_LANG (
"operator foo (int)",
"operator foo \t(int)",
NORMAL,
2691 CHECK_MATCH_LANG (
"operator foo\t(int)",
"operator foo \t(int)",
NORMAL,
2693 CHECK_MATCH_LANG (
"operator foo \t(int)",
"operator foo \t(int)",
NORMAL,
2696 CHECK_MATCH_LANG (
"a::operator foo(int&)",
"a::operator foo(int &)",
NORMAL,
2698 CHECK_MATCH_LANG (
"a :: operator foo(int &)",
"a::operator foo(int &)",
NORMAL,
2700 CHECK_MATCH_LANG (
"a \t:: \toperator foo(int\t&)",
"a::operator foo(int\t&)",
NORMAL,
2702 CHECK_MATCH_LANG (
"a::operator foo (int)",
"a::operator foo(int)",
NORMAL,
2704 CHECK_MATCH_LANG (
"a::operator foo\t(int)",
"a::operator foo(int)",
NORMAL,
2706 CHECK_MATCH_LANG (
"a::operator foo \t(int)",
"a::operator foo(int)",
NORMAL,
2708 CHECK_MATCH_LANG (
"a::operator foo (int)",
"a::operator foo \t(int)",
NORMAL,
2710 CHECK_MATCH_LANG (
"a::operator foo\t(int)",
"a::operator foo \t(int)",
NORMAL,
2712 CHECK_MATCH_LANG (
"a::operator foo \t(int)",
"a::operator foo \t(int)",
NORMAL,
2715 CHECK_NO_MATCH_LANG (
"operator foo(int)",
"operator foo(char)",
NORMAL,
2717 CHECK_NO_MATCH_LANG (
"operator foo(int)",
"operator foo(int *)",
NORMAL,
2719 CHECK_NO_MATCH_LANG (
"operator foo(int)",
"operator foo(int &)",
NORMAL,
2721 CHECK_NO_MATCH_LANG (
"operator foo(int)",
"operator foo(int, char *)",
NORMAL,
2723 CHECK_NO_MATCH_LANG (
"operator foo(int)",
"operator bar(int)",
NORMAL,
2726 CHECK_NO_MATCH_LANG (
"a::operator b::foo(int)",
"a::operator a::foo(char)",
NORMAL,
2728 CHECK_NO_MATCH_LANG (
"a::operator foo(int)",
"a::operator foo(int *)",
NORMAL,
2730 CHECK_NO_MATCH_LANG (
"a::operator foo(int)",
"a::operator foo(int &)",
NORMAL,
2732 CHECK_NO_MATCH_LANG (
"a::operator foo(int)",
"a::operator foo(int, char *)",
NORMAL,
2734 CHECK_NO_MATCH_LANG (
"a::operator foo(int)",
"a::operator bar(int)",
NORMAL,
2741 CHECK_MATCH (
"foo[abi:a]",
"foo",
NORMAL);
2742 CHECK_MATCH (
"foo[abi:a]()",
"foo",
NORMAL);
2743 CHECK_MATCH (
"foo[abi:a](a)",
"foo",
NORMAL);
2744 CHECK_MATCH (
"foo[abi:a](a&,b*)",
"foo",
NORMAL);
2745 CHECK_MATCH (
"foo[abi:a](a,b)",
"foo(a,b)",
NORMAL);
2746 CHECK_MATCH (
"foo[abi:a](a,b) c",
"foo(a,b) c",
NORMAL);
2747 CHECK_MATCH (
"foo[abi:a](a)",
"foo(a)",
NORMAL);
2748 CHECK_MATCH (
"foo[abi:a](a,b)",
"foo(a,b)",
NORMAL);
2749 CHECK_MATCH (
"foo[abi:a]",
"foo[abi:a]",
NORMAL);
2750 CHECK_MATCH (
"foo[ abi:a]",
"foo[abi:a]",
NORMAL);
2751 CHECK_MATCH (
"foo[\tabi:a]",
"foo[abi:a]",
NORMAL);
2752 CHECK_MATCH (
"foo[ \tabi:a]",
"foo[abi:a]",
NORMAL);
2753 CHECK_MATCH (
"foo[\t abi:a]",
"foo[abi:a]",
NORMAL);
2754 CHECK_MATCH (
"foo[abi :a]",
"foo[abi:a]",
NORMAL);
2755 CHECK_MATCH (
"foo[abi\t:a]",
"foo[abi:a]",
NORMAL);
2756 CHECK_MATCH (
"foo[abi \t:a]",
"foo[abi:a]",
NORMAL);
2757 CHECK_MATCH (
"foo[abi\t :a]",
"foo[abi:a]",
NORMAL);
2758 CHECK_MATCH (
"foo[abi:a]",
"foo[ abi:a]",
NORMAL);
2759 CHECK_MATCH (
"foo[abi:a]",
"foo[\tabi:a]",
NORMAL);
2760 CHECK_MATCH (
"foo[abi:a]",
"foo[ \tabi:a]",
NORMAL);
2761 CHECK_MATCH (
"foo[abi:a]",
"foo[\t abi:a]",
NORMAL);
2762 CHECK_MATCH (
"foo[abi:a]",
"foo[abi :a]",
NORMAL);
2763 CHECK_MATCH (
"foo[abi:a]",
"foo[abi\t:a]",
NORMAL);
2764 CHECK_MATCH (
"foo[abi:a]",
"foo[abi \t:a]",
NORMAL);
2765 CHECK_MATCH (
"foo[abi:a]",
"foo[abi\t :a]",
NORMAL);
2766 CHECK_MATCH (
"foo[abi:a]",
"foo[abi:a ]",
NORMAL);
2767 CHECK_MATCH (
"foo[abi:a]",
"foo[abi:a\t]",
NORMAL);
2768 CHECK_MATCH (
"foo[abi:a]",
"foo[abi:a \t]",
NORMAL);
2769 CHECK_MATCH (
"foo[abi:a]",
"foo[abi:a\t ]",
NORMAL);
2770 CHECK_MATCH (
"foo[abi:a,b]",
"foo[abi:a,b]",
NORMAL);
2771 CHECK_MATCH (
"foo[abi:::]",
"foo[abi:::]",
NORMAL);
2772 CHECK_MATCH (
"foo[abi : : : ]",
"foo[abi:::]",
NORMAL);
2773 CHECK_MATCH (
"foo[abi:::]",
"foo[abi : : : ]",
NORMAL);
2774 CHECK_MATCH (
"foo[ \t abi \t:\t: : \t]",
2775 "foo[ abi : \t ::]",
2777 CHECK_MATCH (
"foo< bar< baz< quxi > > >(int)",
"foo<bar<baz<quxi>>>(int)",
2779 CHECK_MATCH (
"\tfoo<\tbar<\tbaz\t<\tquxi\t>\t>\t>(int)",
2780 "foo<bar<baz<quxi>>>(int)",
NORMAL);
2781 CHECK_MATCH (
" \tfoo \t< \tbar \t< \tbaz \t< \tquxi \t> \t> \t> \t( \tint \t)",
2782 "foo<bar<baz<quxi>>>(int)",
NORMAL);
2783 CHECK_MATCH (
"foo<bar<baz<quxi>>>(int)",
2784 "foo < bar < baz < quxi > > > (int)",
NORMAL);
2785 CHECK_MATCH (
"foo<bar<baz<quxi>>>(int)",
2786 "\tfoo\t<\tbar\t<\tbaz\t<\tquxi\t>\t>\t>\t(int)",
NORMAL);
2787 CHECK_MATCH (
"foo<bar<baz<quxi>>>(int)",
2788 " \tfoo \t< \tbar \t< \tbaz \t< \tquxi \t> \t> \t> \t( \tint \t)",
NORMAL);
2789 CHECK_MATCH (
"foo<bar<baz>>::foo(quxi &)",
"fo",
NORMAL);
2790 CHECK_MATCH (
"foo<bar<baz>>::foo(quxi &)",
"foo",
NORMAL);
2791 CHECK_MATCH (
"foo<bar<baz>>::foo(quxi &)",
"foo<bar<baz>>::",
NORMAL);
2792 CHECK_MATCH (
"foo<bar<baz>>::foo(quxi &)",
"foo<bar<baz> >::foo",
NORMAL);
2793 CHECK_MATCH (
"foo[abi:a][abi:b](bar[abi:c][abi:d])",
"foo[abi:a][abi:b](bar[abi:c][abi:d])",
2795 CHECK_MATCH (
"foo[abi:a][abi:b](bar[abi:c][abi:d])",
"foo",
NORMAL);
2796 CHECK_MATCH (
"foo[abi:a][abi:b](bar[abi:c][abi:d])",
"foo(bar)",
NORMAL);
2797 CHECK_MATCH (
"foo[abi:a][abi:b](bar[abi:c][abi:d])",
"foo[abi:a](bar)",
NORMAL);
2798 CHECK_MATCH (
"foo[abi:a][abi:b](bar[abi:c][abi:d])",
"foo(bar[abi:c])",
NORMAL);
2799 CHECK_MATCH (
"foo[abi:a][abi:b](bar[abi:c][abi:d])",
"foo[abi:a](bar[abi:c])",
NORMAL);
2800 CHECK_MATCH (
"foo[abi:a][abi:b](bar[abi:c][abi:d])",
"foo[abi:a][abi:b](bar)",
NORMAL);
2801 CHECK_MATCH (
"foo[abi:a][abi:b](bar[abi:c][abi:d])",
"foo[abi:a][abi:b](bar[abi:c])",
2803 CHECK_MATCH(
"foo<bar[abi:a]>(char *, baz[abi:b])",
"foo",
NORMAL);
2804 CHECK_NO_MATCH(
"foo<bar[abi:a]>(char *, baz[abi:b])",
"foo()",
NORMAL);
2805 CHECK_MATCH(
"foo<bar[abi:a]>(char *, baz[abi:b])",
"foo<bar>",
NORMAL);
2806 CHECK_MATCH(
"foo<bar[abi:a]>(char *, baz[abi:b])",
"foo<bar>(char*, baz)",
NORMAL);
2807 CHECK_MATCH(
"foo<bar[abi:a]>(char *, baz[abi:b])",
"foo<bar>(char*, baz[abi:b])",
2809 CHECK_NO_MATCH(
"foo<bar[abi:a]>(char *, baz[abi:b])",
"foo<bar>(char*, baz[abi:A])",
2811 CHECK_MATCH(
"foo<bar[abi:a]>(char *, baz[abi:b])",
"foo<bar[abi:a]>(char*, baz)",
2813 CHECK_NO_MATCH(
"foo<bar[abi:a]>(char *, baz[abi:b])",
"foo<bar[abi:A]>(char*, baz)",
2815 CHECK_MATCH(
"foo<bar[abi:a]>(char *, baz[abi:b])",
"foo<bar[abi:a]>(char*, baz[abi:b])",
2817 CHECK_NO_MATCH(
"foo<bar[abi:a]>(char *, baz[abi:b])",
2818 "foo<bar[abi:a]>(char*, baz[abi:B])",
NORMAL);
2820 CHECK_NO_MATCH (
"foo",
"foo[",
NORMAL);
2821 CHECK_NO_MATCH (
"foo",
"foo[]",
NORMAL);
2822 CHECK_NO_MATCH (
"foo",
"foo[ a]",
NORMAL);
2823 CHECK_NO_MATCH (
"foo",
"foo[a ]",
NORMAL);
2824 CHECK_NO_MATCH (
"foo",
"foo[ a ]",
NORMAL);
2825 CHECK_NO_MATCH (
"foo",
"foo[\ta]",
NORMAL);
2826 CHECK_NO_MATCH (
"foo",
"foo[a \t]",
NORMAL);
2827 CHECK_NO_MATCH (
"foo",
"foo[a\t ]",
NORMAL);
2828 CHECK_NO_MATCH (
"foo",
"foo[ \ta]",
NORMAL);
2829 CHECK_NO_MATCH (
"foo",
"foo[\t a]",
NORMAL);
2830 CHECK_NO_MATCH (
"foo",
"foo[ \ta \t]",
NORMAL);
2831 CHECK_NO_MATCH (
"foo",
"foo[\t a\t ]",
NORMAL);
2832 CHECK_NO_MATCH (
"foo",
"foo[abi]",
NORMAL);
2833 CHECK_NO_MATCH (
"foo",
"foo[ abi]",
NORMAL);
2834 CHECK_NO_MATCH (
"foo",
"foo[abi ]",
NORMAL);
2835 CHECK_NO_MATCH (
"foo",
"foo[\tabi]",
NORMAL);
2836 CHECK_NO_MATCH (
"foo",
"foo[abi\t]",
NORMAL);
2837 CHECK_NO_MATCH (
"foo",
"foo[ \tabi]",
NORMAL);
2838 CHECK_NO_MATCH (
"foo",
"foo[\t abi]",
NORMAL);
2839 CHECK_NO_MATCH (
"foo",
"foo[abi \t]",
NORMAL);
2840 CHECK_NO_MATCH (
"foo",
"foo[abi\t ]",
NORMAL);
2841 CHECK_NO_MATCH (
"foo",
"foo[abi :]",
NORMAL);
2842 CHECK_NO_MATCH (
"foo",
"foo[abi\t:]",
NORMAL);
2843 CHECK_NO_MATCH (
"foo",
"foo[abi \t:]",
NORMAL);
2844 CHECK_NO_MATCH (
"foo",
"foo[abi\t :]",
NORMAL);
2845 CHECK_NO_MATCH (
"foo",
"foo[abi: ]",
NORMAL);
2846 CHECK_NO_MATCH (
"foo",
"foo[abi:\t]",
NORMAL);
2847 CHECK_NO_MATCH (
"foo",
"foo[abi: \t]",
NORMAL);
2848 CHECK_NO_MATCH (
"foo",
"foo[abi:\t ]",
NORMAL);
2849 CHECK_NO_MATCH (
"foo",
"foo[abi: a]",
NORMAL);
2850 CHECK_NO_MATCH (
"foo",
"foo[abi:\ta]",
NORMAL);
2851 CHECK_NO_MATCH (
"foo",
"foo[abi: \ta]",
NORMAL);
2852 CHECK_NO_MATCH (
"foo",
"foo[abi:\t a]",
NORMAL);
2853 CHECK_NO_MATCH (
"foo",
"foo[abi:a ]",
NORMAL);
2854 CHECK_NO_MATCH (
"foo",
"foo[abi:a\t]",
NORMAL);
2855 CHECK_NO_MATCH (
"foo",
"foo[abi:a \t]",
NORMAL);
2856 CHECK_NO_MATCH (
"foo",
"foo[abi:a\t ]",
NORMAL);
2857 CHECK_NO_MATCH (
"foo[abi:a]()",
"foo(a)",
NORMAL);
2858 CHECK_NO_MATCH (
"foo[abi:a]()",
"foo(a)",
NORMAL);
2859 CHECK_NO_MATCH (
"foo[abi:a]()",
"foo(a)",
NORMAL);
2860 CHECK_NO_MATCH (
"foo[abi:a]()",
"foo(a)",
NORMAL);
2861 CHECK_NO_MATCH (
"foo[abi:a]()",
"foo(a) c",
NORMAL);
2862 CHECK_NO_MATCH (
"foo[abi:a]()",
"foo(a) .",
NORMAL);
2863 CHECK_NO_MATCH (
"foo[abi:a]()",
"foo(a) *",
NORMAL);
2864 CHECK_NO_MATCH (
"foo[abi:a]()",
"foo(a) &",
NORMAL);
2865 CHECK_NO_MATCH (
"foo[abi:a](a,b)",
"foo(a,b) c",
NORMAL);
2866 CHECK_NO_MATCH (
"foo[abi:a](a,b)",
"foo(a,b) .",
NORMAL);
2867 CHECK_NO_MATCH (
"foo[abi:a](a,b)",
"foo(a,b) *",
NORMAL);
2868 CHECK_NO_MATCH (
"foo[abi:a](a,b)",
"foo(a,b) &",
NORMAL);
2869 CHECK_NO_MATCH (
"foo[abi:a](a,b)",
"foo(a,b)c",
NORMAL);
2870 CHECK_NO_MATCH (
"foo[abi:a](a,b)",
"foo(a,b).",
NORMAL);
2871 CHECK_NO_MATCH (
"foo[abi:a](a,b)",
"foo(a,b)*",
NORMAL);
2872 CHECK_NO_MATCH (
"foo[abi:a](a,b)",
"foo(a,b)&",
NORMAL);
2873 CHECK_NO_MATCH (
"foo[abi:a](a,b) d",
"foo(a,b) c",
NORMAL);
2874 CHECK_NO_MATCH (
"foo[abi:a](a)",
"foo()",
NORMAL);
2875 CHECK_NO_MATCH (
"foo[abi:a](a)",
"foo(b)",
NORMAL);
2876 CHECK_NO_MATCH (
"foo[abi:a](a)",
"foo[abi:b](a)",
NORMAL);
2877 CHECK_NO_MATCH (
"foo[abi:a](a)",
"foo[abi:a](b)",
NORMAL);
2878 CHECK_NO_MATCH (
"foo[abi:]",
"foo[abi:a]",
NORMAL);
2879 CHECK_NO_MATCH (
"foo[abi:",
"foo[abi:a]",
NORMAL);
2880 CHECK_NO_MATCH (
"foo[abi:]",
"foo[abi:a",
NORMAL);
2881 CHECK_NO_MATCH (
"foo[abi:,]",
"foo[abi:a]",
NORMAL);
2882 CHECK_NO_MATCH (
"foo[abi:a,b]",
"foo[abi:a]",
NORMAL);
2883 CHECK_NO_MATCH (
"foo[abi::a]",
"foo[abi:a]",
NORMAL);
2884 CHECK_NO_MATCH (
"foo[abi:,([a]",
"foo[abi:a]",
NORMAL);
2886 CHECK_MATCH (
"foo <a, b [, c (",
"foo",
NORMAL);
2887 CHECK_MATCH (
"foo >a, b ], c )",
"foo",
NORMAL);
2888 CHECK_MATCH (
"@!%&\\*",
"@!%&\\*",
NORMAL);
2889 CHECK_MATCH (
"()",
"()",
NORMAL);
2890 CHECK_MATCH (
"*(*)*",
"*(*)*",
NORMAL);
2891 CHECK_MATCH (
"[]",
"[]",
NORMAL);
2892 CHECK_MATCH (
"<>",
"<>",
NORMAL);
2895 CHECK_MATCH (
"foo2",
"foo",
NORMAL);
2912 CHECK_NO_MATCH (
" \tfoo2 \t",
" \tfoo \t",
MATCH_PARAMS);
2913 CHECK_NO_MATCH (
"\t foo2\t ",
"\t foo\t ",
MATCH_PARAMS);
2927 CHECK_NO_MATCH (
"foo2 (args \t)",
"foo",
MATCH_PARAMS);
2928 CHECK_NO_MATCH (
"foo2 (args\t )",
"foo",
MATCH_PARAMS);
2929 CHECK_MATCH (
"foo[abi:a][abi:b](bar[abi:c][abi:d])",
"foo[abi:a][abi:b](bar[abi:c][abi:d])",
2931 CHECK_MATCH (
"foo[abi:a][abi:b](bar[abi:c][abi:d])",
"foo",
MATCH_PARAMS);
2935 CHECK_NO_MATCH (
"FoO",
"foo",
NORMAL);
2941 CHECK_MATCH (
"FoO",
"foo",
NORMAL);
2943 CHECK_MATCH (
"foo",
"FoO",
NORMAL);
2946 CHECK_MATCH (
"FoO[AbI:abC]()",
"foo",
NORMAL);
2947 CHECK_NO_MATCH (
"FoO[AbI:abC]()",
"foo",
MATCH_PARAMS);
2948 CHECK_MATCH (
"FoO2[AbI:abC]()",
"foo",
NORMAL);
2949 CHECK_NO_MATCH (
"FoO2[AbI:abC]()",
"foo",
MATCH_PARAMS);
2951 CHECK_MATCH (
"foo[abi:abc]()",
"FoO[AbI:abC]()",
NORMAL);
2952 CHECK_MATCH (
"foo[abi:abc]()",
"FoO[AbI:AbC]()",
MATCH_PARAMS);
2953 CHECK_MATCH (
"foo[abi:abc](xyz)",
"FoO[AbI:abC](XyZ)",
NORMAL);
2954 CHECK_MATCH (
"foo[abi:abc](xyz)",
"FoO[AbI:abC](XyZ)",
MATCH_PARAMS);
2955 CHECK_MATCH (
"foo[abi:abc][abi:def](xyz)",
"FoO[AbI:abC](XyZ)",
NORMAL);
2956 CHECK_MATCH (
"foo[abi:abc][abi:def](xyz)",
"FoO[AbI:abC](XyZ)",
2958 CHECK_MATCH (
"foo<bar<baz>>(bar<baz>)",
"FoO<bAr<BaZ>>(bAr<BaZ>)",
2960 CHECK_MATCH (
"foo<bar<baz>>(bar<baz>)",
"FoO<bAr<BaZ>>(bAr<BaZ>)",
2972strncmp_iw (
const char *string1,
const char *string2,
size_t string2_len)
3027 const char *saved_string1 = string1, *saved_string2 = string2;
3035 char c1 =
'X',
c2 =
'X';
3037 while (*string1 !=
'\0' && *string2 !=
'\0')
3039 while (ISSPACE (*string1))
3041 while (ISSPACE (*string2))
3047 c1 = TOLOWER ((
unsigned char) *string1);
3048 c2 = TOLOWER ((
unsigned char) *string2);
3058 if (*string1 !=
'\0')
3071 if (*string2 ==
'\0')
3076 if (*string2 ==
'\0')
3081 if (*string2 ==
'\0' || *string2 ==
'(')
3097 string1 = saved_string1;
3098 string2 = saved_string2;
3108 gdb_printf (file, _(
"Timestamping debugging messages is %s.\n"),
3127 if (addr_bit < (
sizeof (CORE_ADDR) * HOST_CHAR_BIT))
3128 addr &= ((CORE_ADDR) 1 << addr_bit) - 1;
3129 return hex_string (addr);
3139 if (addr_bit < (
sizeof (CORE_ADDR) * HOST_CHAR_BIT))
3140 address &= ((CORE_ADDR) 1 << addr_bit) - 1;
3146 return hex_string_custom (address, 8);
3148 return hex_string_custom (address, 16);
3157 if (my_string[0] ==
'0' && TOLOWER (my_string[1]) ==
'x')
3162 for (i = 2; my_string[i] !=
'\0'; i++)
3164 if (ISDIGIT (my_string[i]))
3165 addr = (my_string[i] -
'0') + (addr * 16);
3166 else if (ISXDIGIT (my_string[i]))
3167 addr = (TOLOWER (my_string[i]) -
'a' + 0xa) + (addr * 16);
3169 error (_(
"invalid hex \"%s\""), my_string);
3177 for (i = 0; my_string[i] !=
'\0'; i++)
3179 if (ISDIGIT (my_string[i]))
3180 addr = (my_string[i] -
'0') + (addr * 10);
3182 error (_(
"invalid decimal \"%s\""), my_string);
3192gdb_realpath_check_trailer (
const char *input,
const char *trailer)
3194 gdb::unique_xmalloc_ptr<char> result = gdb_realpath (input);
3196 size_t len = strlen (result.get ());
3197 size_t trail_len = strlen (trailer);
3199 SELF_CHECK (len >= trail_len
3200 && strcmp (result.get () + len - trail_len, trailer) == 0);
3204gdb_realpath_tests ()
3207 gdb_realpath_check_trailer (
"./xfullpath.exp",
"/xfullpath.exp");
3209 gdb_realpath_check_trailer (
"../../defs.h",
"/defs.h");
3211 gdb_realpath_check_trailer (
"./a",
"/a");
3213 gdb_realpath_check_trailer (
"/root_file_which_should_exist",
3214 "/root_file_which_should_exist");
3216 gdb_realpath_check_trailer (
"xfullpath.exp",
"xfullpath.exp");
3218 gdb_realpath_check_trailer (
"a",
"a");
3220 gdb_realpath_check_trailer (
"",
"");
3226gdb_argv_as_array_view_test ()
3231 gdb::array_view<char *> view =
argv.as_array_view ();
3233 SELF_CHECK (view.data () ==
nullptr);
3234 SELF_CHECK (view.size () == 0);
3237 gdb_argv
argv (
"une bonne 50");
3239 gdb::array_view<char *> view =
argv.as_array_view ();
3241 SELF_CHECK (view.size () == 3);
3242 SELF_CHECK (strcmp (view[0],
"une") == 0);
3243 SELF_CHECK (strcmp (view[1],
"bonne") == 0);
3244 SELF_CHECK (strcmp (view[2],
"50") == 0);
3256 std::string dirname;
3257 const char *base = lbasename (filename);
3259 while (base > filename && IS_DIR_SEPARATOR (base[-1]))
3262 if (base == filename)
3265 dirname = std::string (filename, base - filename);
3269 if (base - filename == 2 && IS_ABSOLUTE_PATH (base)
3270 && !IS_DIR_SEPARATOR (filename[0]))
3271 dirname[base++ - filename] =
'.';
3287 dummy = (
char *) args;
3290 if ((
pid == 0 &&
dummy == args) ||
dummy != &args[strlen (args)])
3291 error (_(
"Illegal process-id: %s."), args);
3304 char *
string = *stringp, *s;
3305 const size_t from_len = strlen (from);
3306 const size_t to_len = strlen (to);
3310 s = strstr (s, from);
3314 if ((s ==
string || IS_DIR_SEPARATOR (s[-1])
3315 || s[-1] == DIRNAME_SEPARATOR)
3316 && (s[from_len] ==
'\0' || IS_DIR_SEPARATOR (s[from_len])
3317 || s[from_len] == DIRNAME_SEPARATOR))
3322 = (
char *)
xrealloc (
string, (strlen (
string) + to_len + 1));
3325 s = s -
string + string_new;
3326 string = string_new;
3329 memmove (&s[to_len], &s[from_len], strlen (&s[from_len]) + 1);
3330 memcpy (s, to, to_len);
3348sigalrm_handler (
int signo)
3367 pid_t waitpid_result;
3369 gdb_assert (
pid > 0);
3370 gdb_assert (timeout >= 0);
3375#if defined (HAVE_SIGACTION) && defined (SA_RESTART)
3376 struct sigaction sa, old_sa;
3378 sa.sa_handler = sigalrm_handler;
3379 sigemptyset (&sa.sa_mask);
3381 sigaction (SIGALRM, &sa, &old_sa);
3385 ofunc = signal (SIGALRM, sigalrm_handler);
3391 waitpid_result = waitpid (
pid,
status, 0);
3395#if defined (HAVE_SIGACTION) && defined (SA_RESTART)
3396 sigaction (SIGALRM, &old_sa, NULL);
3398 signal (SIGALRM,
ofunc);
3403 waitpid_result = waitpid (
pid,
status, WNOHANG);
3405 if (waitpid_result ==
pid)
3422 gdb_assert ((
flags & FNM_FILE_NAME) != 0);
3425 gdb_assert ((
flags & FNM_NOESCAPE) != 0);
3427#ifdef HAVE_DOS_BASED_FILE_SYSTEM
3429 char *pattern_slash, *string_slash;
3433 pattern_slash = (
char *) alloca (strlen (pattern) + 1);
3434 strcpy (pattern_slash, pattern);
3435 pattern = pattern_slash;
3436 for (; *pattern_slash != 0; pattern_slash++)
3437 if (IS_DIR_SEPARATOR (*pattern_slash))
3438 *pattern_slash =
'/';
3440 string_slash = (
char *) alloca (strlen (
string) + 1);
3441 strcpy (string_slash,
string);
3442 string = string_slash;
3443 for (; *string_slash != 0; string_slash++)
3444 if (IS_DIR_SEPARATOR (*string_slash))
3445 *string_slash =
'/';
3449#ifdef HAVE_CASE_INSENSITIVE_FILE_SYSTEM
3450 flags |= FNM_CASEFOLD;
3453 return fnmatch (pattern,
string,
flags);
3467 const char *p = path;
3469 if (HAS_DRIVE_SPEC (p))
3471 p = STRIP_DRIVE_SPEC (p);
3477 if (IS_DIR_SEPARATOR (*p))
3483 if (p > path + 1 && IS_DIR_SEPARATOR (p[-1]))
3487 if (p > path && !IS_DIR_SEPARATOR (p[-1]))
3503 const char *p = path;
3505 gdb_assert (n >= 0);
3510 if (HAS_DRIVE_SPEC (p))
3512 p = STRIP_DRIVE_SPEC (p);
3518 while (*p !=
'\0' && !IS_DIR_SEPARATOR (*p))
3537 const gdb_byte *source, ULONGEST source_offset,
3538 ULONGEST nbits,
int bits_big_endian)
3540 unsigned int buf, avail;
3545 if (bits_big_endian)
3548 dest_offset += nbits - 1;
3549 dest += dest_offset / 8;
3550 dest_offset = 7 - dest_offset % 8;
3551 source_offset += nbits - 1;
3552 source += source_offset / 8;
3553 source_offset = 7 - source_offset % 8;
3557 dest += dest_offset / 8;
3559 source += source_offset / 8;
3565 buf = *(bits_big_endian ? source-- : source++) >> source_offset;
3566 buf <<= dest_offset;
3567 buf |= *dest & ((1 << dest_offset) - 1);
3570 nbits += dest_offset;
3571 avail = dest_offset + 8 - source_offset;
3574 if (nbits >= 8 && avail >= 8)
3576 *(bits_big_endian ? dest-- : dest++) = buf;
3585 size_t len = nbits / 8;
3590 if (bits_big_endian)
3594 memcpy (dest + 1, source + 1, len);
3598 memcpy (dest, source, len);
3607 buf |= *(bits_big_endian ? source-- : source++) << avail;
3608 *(bits_big_endian ? dest-- : dest++) = buf;
3619 buf |= *source << avail;
3621 buf &= (1 << nbits) - 1;
3622 *dest = (*dest & (~0U << nbits)) | buf;
3631Set number of characters where GDB should wrap lines of its output."), _(
"\
3632Show number of characters where GDB should wrap lines of its output."), _(
"\
3633This affects where GDB wraps its output to fit the screen width.\n\
3634Setting this to \"unlimited\" or zero prevents GDB from wrapping its output."),
3640Set number of lines in a page for GDB output pagination."), _(
"\
3641Show number of lines in a page for GDB output pagination."), _(
"\
3642This affects the number of lines after which GDB will pause\n\
3643its output and ask you whether to continue.\n\
3644Setting this to \"unlimited\" or zero causes GDB never pause during output."),
3651Set state of GDB output pagination."), _(
"\
3652Show state of GDB output pagination."), _(
"\
3653When pagination is ON, GDB pauses at end of each screenful of\n\
3654its output and asks you whether to continue.\n\
3655Turning pagination off is an alternative to \"set height unlimited\"."),
3662Set printing of 8-bit characters in strings as \\nnn."), _(
"\
3663Show printing of 8-bit characters in strings as \\nnn."), NULL,
3670Set timestamping of debugging messages."), _(
"\
3671Show timestamping of debugging messages."), _(
"\
3672When set, debugging messages will be marked with seconds and microseconds."),
3682 selftests::register_test (
"gdb_realpath", gdb_realpath_tests);
3683 selftests::register_test (
"gdb_argv_array_view", gdb_argv_as_array_view_test);
3684 selftests::register_test (
"strncmp_iw_with_mode",
3685 strncmp_iw_with_mode_tests);
3686 selftests::register_test (
"pager", test_pager);
void * xrealloc(void *ptr, size_t size)
void gdb_internal_backtrace_set_cmd(const char *args, int from_tty, cmd_list_element *c)
void gdb_internal_backtrace()
#define GDB_PRINT_INTERNAL_BACKTRACE_INIT_ON
const char * host_charset(void)
void convert_between_encodings(const char *from, const char *to, const gdb_byte *bytes, unsigned int num_bytes, int width, struct obstack *output, enum transliterations translit)
const char * target_charset(struct gdbarch *gdbarch)
ui_file_style style() const
void mark_ignored_range(const char *begin, const char *end)
const char * c_str() const
const std::string & string()
static void ours_for_output()
virtual void puts(const char *str)
void vprintf(const char *, va_list) ATTRIBUTE_PRINTF(2
virtual void emit_style_escape(const ui_file_style &style)
ui_file_style m_applied_style
bool can_emit_style_escape() override
struct cmd_list_element * showlist
struct cmd_list_element * showprintlist
void error_no_arg(const char *why)
struct cmd_list_element * setprintlist
struct cmd_list_element * setlist
struct cmd_list_element * showdebuglist
struct cmd_list_element * setdebuglist
struct cmd_list_element * maintenance_show_cmdlist
struct cmd_list_element * maintenance_set_cmdlist
set_show_commands add_setshow_uinteger_cmd(const char *name, enum command_class theclass, unsigned int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_func_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
set_show_commands add_setshow_enum_cmd(const char *name, enum command_class theclass, const char *const *enumlist, const char **var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_func_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
set_show_commands add_setshow_prefix_cmd(const char *name, command_class theclass, const char *set_doc, const char *show_doc, cmd_list_element **set_subcommands_list, cmd_list_element **show_subcommands_list, cmd_list_element **set_list, cmd_list_element **show_list)
set_show_commands add_setshow_boolean_cmd(const char *name, enum command_class theclass, bool *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_func_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
cli_style_option highlight_style
cli_style_option file_name_style
const char * find_toplevel_char(const char *s, char c)
volatile int sync_quit_force_run
char * gdb_readline_wrapper(const char *)
int(* deprecated_query_hook)(const char *, va_list) ATTRIBUTE_FPTR_PRINTF(1
quit_handler_ftype * quit_handler
void default_quit_handler(void)
int(*) void(* deprecated_warning_hook)(const char *, va_list) ATTRIBUTE_FPTR_PRINTF(1
ssize_t read(int fd, void *buf, size_t count)
EXTERN_C int tgetnum(const char *)
int gdbarch_addr_bit(struct gdbarch *gdbarch)
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t err
mach_port_t kern_return_t mach_port_t mach_msg_type_name_t msgportsPoly mach_port_t kern_return_t pid_t pid mach_port_t kern_return_t mach_port_t task mach_port_t kern_return_t int flags
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t int int rusage_t pid_t pid
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t int status
struct interp * top_level_interpreter(void)
const struct language_defn * language_def(enum language lang)
gdb::unique_xmalloc_ptr< char > language_demangle(const struct language_defn *current_language, const char *mangled, int options)
static sighandler_t ofunc
#define prefix(a, b, R, do)
bool user_settable_should_print_backtrace
bool user_settable_should_quit
bool should_print_backtrace
const char * should_dump_core
bool user_settable_should_dump_core
set_batch_flag_and_restore_page_info()
~set_batch_flag_and_restore_page_info()
unsigned m_save_chars_per_line
unsigned m_save_lines_per_page
std::string to_ansi() const
enum prompt_state prompt_state
bool input_interactive_p() const
void unregister_file_handler()
void(* call_readline)(gdb_client_data)
void register_file_handler()
bool target_supports_terminal_ours(void)
void quit_force(int *exit_arg, int from_tty)
bool tui_get_command_dimension(unsigned int *width, unsigned int *height)
static styled_string_s * styled_string(const ui_file_style &style, const char *str, styled_string_s &&tmp={})
bool skip_ansi_escape(const char *buf, int *n_read)
void demangler_warning(const char *file, int line, const char *string,...)
const char internal_problem_ask[]
std::string ldirname(const char *filename)
void malloc_failure(long size)
void verror(const char *string, va_list args)
static bool skip_abi_tag(const char **name)
static bool pagination_disabled_for_command
void perror_with_name(const char *string)
int strncmp_iw(const char *string1, const char *string2, size_t string2_len)
void set_screen_width_and_height(int width, int height)
int nquery(const char *ctlstr,...)
static void ATTRIBUTE_NORETURN abort_with_message(const char *msg)
std::chrono::steady_clock::duration get_prompt_for_continue_wait_time()
void init_page_info(void)
void internal_verror(const char *file, int line, const char *fmt, va_list ap)
ULONGEST uinteger_pow(ULONGEST v1, LONGEST v2)
void reinitialize_more_filter(void)
const char * print_core_address(struct gdbarch *gdbarch, CORE_ADDR address)
int can_dump_core(enum resource_limit_kind limit_kind)
static void show_sevenbit_strings(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
static void ATTRIBUTE_NORETURN throw_perror_with_name(enum errors errcode, const char *string)
static void show_pagination_enabled(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
void gdb_vprintf(struct ui_file *stream, const char *format, va_list args)
int query(const char *ctlstr,...)
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
void demangler_vwarning(const char *file, int line, const char *fmt, va_list ap)
void perror_warning_with_name(const char *string)
void print_spaces(int n, struct ui_file *stream)
static void set_width(void)
static bool cp_is_operator(const char *string, const char *start)
void print_sys_errmsg(const char *string, int errcode)
static bool filter_initialized
const char * n_spaces(int n)
const char internal_problem_yes[]
static void add_internal_problem_command(struct internal_problem *problem)
int yquery(const char *ctlstr,...)
int strncmp_iw_with_mode(const char *string1, const char *string2, size_t string2_len, strncmp_iw_mode mode, enum language language, completion_match_for_lcd *match_for_lcd, bool ignore_template_params)
int strcmp_iw_ordered(const char *string1, const char *string2)
void fputs_highlighted(const char *str, const compiled_regex &highlight, struct ui_file *stream)
int filtered_printing_initialized(void)
static struct internal_problem demangler_warning_problem
static void skip_ws(const char *&string1, const char *&string2, const char *end_str2)
void reset_prompt_for_continue_wait_time(void)
void copy_bitwise(gdb_byte *dest, ULONGEST dest_offset, const gdb_byte *source, ULONGEST source_offset, ULONGEST nbits, int bits_big_endian)
static void set_height_command(const char *args, int from_tty, struct cmd_list_element *c)
int gdb_filename_fnmatch(const char *pattern, const char *string, int flags)
static int host_char_to_target(struct gdbarch *gdbarch, int c, int *target_c)
static void show_lines_per_page(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
static struct internal_problem internal_warning_problem
void fprintf_styled(struct ui_file *stream, const ui_file_style &style, const char *format,...)
static void show_debug_timestamp(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
pid_t wait_to_die_with_timeout(pid_t pid, int *status, int timeout)
int parse_escape(struct gdbarch *gdbarch, const char **string_ptr)
void gdb_printf(struct ui_file *stream, const char *format,...)
static bool skip_template_parameter_list(const char **name)
static std::string perror_string(const char *prefix)
void(* deprecated_error_begin_hook)(void)
static const char * cp_skip_operator_token(const char *token, const char *end)
int count_path_elements(const char *path)
void fputs_styled(const char *linebuffer, const ui_file_style &style, struct ui_file *stream)
static int can_dump_core_warn(enum resource_limit_kind limit_kind, const char *reason)
static void set_width_command(const char *args, int from_tty, struct cmd_list_element *c)
static void show_chars_per_line(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
static bool valid_identifier_name_char(int ch)
CORE_ADDR string_to_core_addr(const char *my_string)
void substitute_path_component(char **stringp, const char *from, const char *to)
void fprintf_symbol(struct ui_file *stream, const char *name, enum language lang, int arg_mode)
static unsigned int lines_per_page
const char * strip_leading_path_elements(const char *path, int n)
const char internal_problem_no[]
void gdb_flush(struct ui_file *stream)
void printf_unfiltered(const char *format,...)
void vwarning(const char *string, va_list args)
static struct internal_problem internal_error_problem
static std::chrono::steady_clock::duration prompt_for_continue_wait_time
static unsigned int chars_printed
const char * warning_pre_print
void warn_cant_dump_core(const char *reason)
static const char *const internal_problem_modes[]
void puts_tabular(char *string, int width, int right)
void gdb_puts(const char *linebuffer, struct ui_file *stream)
int myread(int desc, char *addr, int len)
static void ATTRIBUTE_PRINTF(4, 0)
static unsigned int chars_per_line
void error_stream(const string_file &stream)
void internal_vwarning(const char *file, int line, const char *fmt, va_list ap)
int parse_pid_to_attach(const char *args)
static void set_screen_size(void)
static unsigned int lines_printed
static bool readline_initialized(struct ui *ui)
int strcmp_iw(const char *string1, const char *string2)
void init_page_info(void)