~ubuntu-branches/ubuntu/raring/crash/raring-proposed
» Revision
20
: gdb-6.1/gdb-6.1/gdb-6.1/gdb-6.1/gdb-6.1/gdb-6.1/gdb/utils.c
« back to all changes in this revision
Viewing changes to gdb-6.1/gdb-6.1/gdb-6.1/gdb-6.1/gdb-6.1/gdb-6.1/gdb/utils.c
- browse files at revision 20
- compare with another revision
- download diff
- download tarball
- view history from revision 20
- Committer: Bazaar Package Importer
- Author(s): Mario Limonciello
- Date: 2008-11-04 13:04:16 UTC
- mfrom: (0.1.11 upstream)
- Revision ID: james.westby@ubuntu.com-20081104130416-7s1imz9huwwfzrbt
Tags: 4.0-7.2-1ubuntu1
* Merge from debian unstable, remaining changes:
- debian/patches/01_spu_commands.dpatch
+ Provides SPU extension support
- debian/rules:
+ Patch support
+ Enable SPU on PPC
- debian/control:
+ Enable LPIA builds.
+ Build depend on dpatch.
- debian/patches/01_spu_commands.dpatch
+ Provides SPU extension support
- debian/rules:
+ Patch support
+ Enable SPU on PPC
- debian/control:
+ Enable LPIA builds.
+ Build depend on dpatch.
- files removed:
- debian/gdb-6.1.back/gdb-6.1/gdb-6.1/gdb-6.1
- debian/gdb-6.1.back/gdb-6.1/gdb-6.1/gdb-6.1/gdb
- debian/gdb-6.1.back/gdb-6.1/gdb-6.1/gdb-6.1/gdb-6.1
- debian/gdb-6.1.back/gdb-6.1/gdb-6.1/gdb-6.1/gdb-6.1/gdb
- debian/gdb-6.1.back/gdb-6.1/gdb-6.1/gdb-6.1/gdb-6.1/gdb-6.1
- debian/gdb-6.1.back/gdb-6.1/gdb-6.1/gdb-6.1/gdb-6.1/gdb-6.1/gdb
- debian/gdb-6.1.back/gdb-6.1/gdb-6.1/gdb-6.1/gdb-6.1/gdb-6.1/gdb-6.1
- debian/gdb-6.1.back/gdb-6.1/gdb-6.1/gdb-6.1/gdb-6.1/gdb-6.1/gdb-6.1/gdb
- debian/gdb-6.1.back/gdb-6.1/gdb-6.1/gdb-6.1/gdb-6.1/gdb-6.1/gdb-6.1/include
- debian/gdb-6.1.back/gdb-6.1/gdb-6.1/gdb-6.1/gdb-6.1/gdb-6.1/include
- debian/gdb-6.1.back/gdb-6.1/gdb-6.1/gdb-6.1/gdb-6.1/include
- debian/gdb-6.1.back/gdb-6.1/gdb-6.1/gdb-6.1/include
- gdb-6.1/gdb-6.1/gdb-6.1/gdb-6.1
- gdb-6.1/gdb-6.1/gdb-6.1/gdb-6.1/gdb
- gdb-6.1/gdb-6.1/gdb-6.1/gdb-6.1/gdb-6.1
- gdb-6.1/gdb-6.1/gdb-6.1/gdb-6.1/gdb-6.1/gdb
- gdb-6.1/gdb-6.1/gdb-6.1/gdb-6.1/gdb-6.1/gdb-6.1
- gdb-6.1/gdb-6.1/gdb-6.1/gdb-6.1/gdb-6.1/gdb-6.1/gdb
- gdb-6.1/gdb-6.1/gdb-6.1/gdb-6.1/gdb-6.1/gdb-6.1/gdb-6.1
- gdb-6.1/gdb-6.1/gdb-6.1/gdb-6.1/gdb-6.1/gdb-6.1/gdb-6.1/gdb
- gdb-6.1/gdb-6.1/gdb-6.1/gdb-6.1/gdb-6.1/gdb-6.1/gdb-6.1/include
- gdb-6.1/gdb-6.1/gdb-6.1/gdb-6.1/gdb-6.1/gdb-6.1/include
- gdb-6.1/gdb-6.1/gdb-6.1/gdb-6.1/gdb-6.1/include
- gdb-6.1/gdb-6.1/gdb-6.1/gdb-6.1/include
- files modified:
- .rh_rpm_package
- COPYING *
added
removed
gdb-6.1/gdb-6.1/gdb-6.1/gdb-6.1/gdb-6.1/gdb-6.1/gdb/utils.c
1
/* General utility routines for GDB, the GNU debugger.
2
3
Copyright 1986, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4
1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free Software
5
Foundation, Inc.
6
Portions Copyright (C) 2001, 2002 Mission Critical Linux, Inc.
7
Copyright (c) 2002, 2003, 2004, 2005 Red Hat, Inc. All rights reserved.
8
9
This file is part of GDB.
10
11
This program is free software; you can redistribute it and/or modify
12
it under the terms of the GNU General Public License as published by
13
the Free Software Foundation; either version 2 of the License, or
14
(at your option) any later version.
15
16
This program is distributed in the hope that it will be useful,
17
but WITHOUT ANY WARRANTY; without even the implied warranty of
18
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19
GNU General Public License for more details.
20
21
You should have received a copy of the GNU General Public License
22
along with this program; if not, write to the Free Software
23
Foundation, Inc., 59 Temple Place - Suite 330,
24
Boston, MA 02111-1307, USA. */
25
26
#include "defs.h"
27
#include "gdb_assert.h"
28
#include <ctype.h>
29
#include "gdb_string.h"
30
#include "event-top.h"
31
32
#ifdef TUI
33
#include "tui/tui.h" /* For tui_get_command_dimension. */
34
#endif
35
36
#ifdef __GO32__
37
#include <pc.h>
38
#endif
39
40
/* SunOS's curses.h has a '#define reg register' in it. Thank you Sun. */
41
#ifdef reg
42
#undef reg
43
#endif
44
45
#include <signal.h>
46
#include "gdbcmd.h"
47
#include "serial.h"
48
#include "bfd.h"
49
#include "target.h"
50
#include "demangle.h"
51
#include "expression.h"
52
#include "language.h"
53
#include "charset.h"
54
#include "annotate.h"
55
#include "filenames.h"
56
57
#include "inferior.h" /* for signed_pointer_to_address */
58
59
#include <sys/param.h> /* For MAXPATHLEN */
60
61
#ifdef HAVE_CURSES_H
62
#include <curses.h>
63
#endif
64
#ifdef HAVE_TERM_H
65
#include <term.h>
66
#endif
67
68
#include "readline/readline.h"
69
70
#ifdef NEED_DECLARATION_MALLOC
71
extern PTR malloc (); /* OK: PTR */
72
#endif
73
#ifdef NEED_DECLARATION_REALLOC
74
extern PTR realloc (); /* OK: PTR */
75
#endif
76
#ifdef NEED_DECLARATION_FREE
77
extern void free ();
78
#endif
79
/* Actually, we'll never have the decl, since we don't define _GNU_SOURCE. */
80
#if defined(HAVE_CANONICALIZE_FILE_NAME) \
81
&& defined(NEED_DECLARATION_CANONICALIZE_FILE_NAME)
82
extern char *canonicalize_file_name (const char *);
83
#endif
84
85
/* readline defines this. */
86
#undef savestring
87
88
void (*error_begin_hook) (void);
89
90
/* Holds the last error message issued by gdb */
91
92
static struct ui_file *gdb_lasterr;
93
94
/* Prototypes for local functions */
95
96
static void vfprintf_maybe_filtered (struct ui_file *, const char *,
97
va_list, int);
98
99
static void fputs_maybe_filtered (const char *, struct ui_file *, int);
100
101
static void do_my_cleanups (struct cleanup **, struct cleanup *);
102
103
static void prompt_for_continue (void);
104
105
static void set_screen_size (void);
106
static void set_width (void);
107
108
/* Chain of cleanup actions established with make_cleanup,
109
to be executed if an error happens. */
110
111
static struct cleanup *cleanup_chain; /* cleaned up after a failed command */
112
static struct cleanup *final_cleanup_chain; /* cleaned up when gdb exits */
113
static struct cleanup *run_cleanup_chain; /* cleaned up on each 'run' */
114
static struct cleanup *exec_cleanup_chain; /* cleaned up on each execution command */
115
/* cleaned up on each error from within an execution command */
116
static struct cleanup *exec_error_cleanup_chain;
117
118
/* Pointer to what is left to do for an execution command after the
119
target stops. Used only in asynchronous mode, by targets that
120
support async execution. The finish and until commands use it. So
121
does the target extended-remote command. */
122
struct continuation *cmd_continuation;
123
struct continuation *intermediate_continuation;
124
125
/* Nonzero if we have job control. */
126
127
int job_control;
128
129
/* Nonzero means a quit has been requested. */
130
131
int quit_flag;
132
133
/* Nonzero means quit immediately if Control-C is typed now, rather
134
than waiting until QUIT is executed. Be careful in setting this;
135
code which executes with immediate_quit set has to be very careful
136
about being able to deal with being interrupted at any time. It is
137
almost always better to use QUIT; the only exception I can think of
138
is being able to quit out of a system call (using EINTR loses if
139
the SIGINT happens between the previous QUIT and the system call).
140
To immediately quit in the case in which a SIGINT happens between
141
the previous QUIT and setting immediate_quit (desirable anytime we
142
expect to block), call QUIT after setting immediate_quit. */
143
144
int immediate_quit;
145
146
/* Nonzero means that encoded C++/ObjC names should be printed out in their
147
C++/ObjC form rather than raw. */
148
149
int demangle = 1;
150
151
/* Nonzero means that encoded C++/ObjC names should be printed out in their
152
C++/ObjC form even in assembler language displays. If this is set, but
153
DEMANGLE is zero, names are printed raw, i.e. DEMANGLE controls. */
154
155
int asm_demangle = 0;
156
157
/* Nonzero means that strings with character values >0x7F should be printed
158
as octal escapes. Zero means just print the value (e.g. it's an
159
international character, and the terminal or window can cope.) */
160
161
int sevenbit_strings = 0;
162
163
/* String to be printed before error messages, if any. */
164
165
char *error_pre_print;
166
167
/* String to be printed before quit messages, if any. */
168
169
char *quit_pre_print;
170
171
/* String to be printed before warning messages, if any. */
172
173
char *warning_pre_print = "\nwarning: ";
174
175
int pagination_enabled = 1;
176
177
178
/* Add a new cleanup to the cleanup_chain,
179
and return the previous chain pointer
180
to be passed later to do_cleanups or discard_cleanups.
181
Args are FUNCTION to clean up with, and ARG to pass to it. */
182
183
struct cleanup *
184
make_cleanup (make_cleanup_ftype *function, void *arg)
185
{
186
return make_my_cleanup (&cleanup_chain, function, arg);
187
}
188
189
struct cleanup *
190
make_final_cleanup (make_cleanup_ftype *function, void *arg)
191
{
192
return make_my_cleanup (&final_cleanup_chain, function, arg);
193
}
194
195
struct cleanup *
196
make_run_cleanup (make_cleanup_ftype *function, void *arg)
197
{
198
return make_my_cleanup (&run_cleanup_chain, function, arg);
199
}
200
201
struct cleanup *
202
make_exec_cleanup (make_cleanup_ftype *function, void *arg)
203
{
204
return make_my_cleanup (&exec_cleanup_chain, function, arg);
205
}
206
207
struct cleanup *
208
make_exec_error_cleanup (make_cleanup_ftype *function, void *arg)
209
{
210
return make_my_cleanup (&exec_error_cleanup_chain, function, arg);
211
}
212
213
static void
214
do_freeargv (void *arg)
215
{
216
freeargv ((char **) arg);
217
}
218
219
struct cleanup *
220
make_cleanup_freeargv (char **arg)
221
{
222
return make_my_cleanup (&cleanup_chain, do_freeargv, arg);
223
}
224
225
static void
226
do_bfd_close_cleanup (void *arg)
227
{
228
bfd_close (arg);
229
}
230
231
struct cleanup *
232
make_cleanup_bfd_close (bfd *abfd)
233
{
234
return make_cleanup (do_bfd_close_cleanup, abfd);
235
}
236
237
static void
238
do_close_cleanup (void *arg)
239
{
240
int *fd = arg;
241
close (*fd);
242
xfree (fd);
243
}
244
245
struct cleanup *
246
make_cleanup_close (int fd)
247
{
248
int *saved_fd = xmalloc (sizeof (fd));
249
*saved_fd = fd;
250
return make_cleanup (do_close_cleanup, saved_fd);
251
}
252
253
static void
254
do_ui_file_delete (void *arg)
255
{
256
ui_file_delete (arg);
257
}
258
259
struct cleanup *
260
make_cleanup_ui_file_delete (struct ui_file *arg)
261
{
262
return make_my_cleanup (&cleanup_chain, do_ui_file_delete, arg);
263
}
264
265
struct cleanup *
266
make_my_cleanup (struct cleanup **pmy_chain, make_cleanup_ftype *function,
267
void *arg)
268
{
269
struct cleanup *new
270
= (struct cleanup *) xmalloc (sizeof (struct cleanup));
271
struct cleanup *old_chain = *pmy_chain;
272
273
new->next = *pmy_chain;
274
new->function = function;
275
new->arg = arg;
276
*pmy_chain = new;
277
278
return old_chain;
279
}
280
281
/* Discard cleanups and do the actions they describe
282
until we get back to the point OLD_CHAIN in the cleanup_chain. */
283
284
void
285
do_cleanups (struct cleanup *old_chain)
286
{
287
do_my_cleanups (&cleanup_chain, old_chain);
288
}
289
290
void
291
do_final_cleanups (struct cleanup *old_chain)
292
{
293
do_my_cleanups (&final_cleanup_chain, old_chain);
294
}
295
296
void
297
do_run_cleanups (struct cleanup *old_chain)
298
{
299
do_my_cleanups (&run_cleanup_chain, old_chain);
300
}
301
302
void
303
do_exec_cleanups (struct cleanup *old_chain)
304
{
305
do_my_cleanups (&exec_cleanup_chain, old_chain);
306
}
307
308
void
309
do_exec_error_cleanups (struct cleanup *old_chain)
310
{
311
do_my_cleanups (&exec_error_cleanup_chain, old_chain);
312
}
313
314
static void
315
do_my_cleanups (struct cleanup **pmy_chain,
316
struct cleanup *old_chain)
317
{
318
struct cleanup *ptr;
319
while ((ptr = *pmy_chain) != old_chain)
320
{
321
*pmy_chain = ptr->next; /* Do this first incase recursion */
322
(*ptr->function) (ptr->arg);
323
xfree (ptr);
324
}
325
}
326
327
/* Discard cleanups, not doing the actions they describe,
328
until we get back to the point OLD_CHAIN in the cleanup_chain. */
329
330
void
331
discard_cleanups (struct cleanup *old_chain)
332
{
333
discard_my_cleanups (&cleanup_chain, old_chain);
334
}
335
336
void
337
discard_final_cleanups (struct cleanup *old_chain)
338
{
339
discard_my_cleanups (&final_cleanup_chain, old_chain);
340
}
341
342
void
343
discard_exec_error_cleanups (struct cleanup *old_chain)
344
{
345
discard_my_cleanups (&exec_error_cleanup_chain, old_chain);
346
}
347
348
void
349
discard_my_cleanups (struct cleanup **pmy_chain,
350
struct cleanup *old_chain)
351
{
352
struct cleanup *ptr;
353
while ((ptr = *pmy_chain) != old_chain)
354
{
355
*pmy_chain = ptr->next;
356
xfree (ptr);
357
}
358
}
359
360
/* Set the cleanup_chain to 0, and return the old cleanup chain. */
361
struct cleanup *
362
save_cleanups (void)
363
{
364
return save_my_cleanups (&cleanup_chain);
365
}
366
367
struct cleanup *
368
save_final_cleanups (void)
369
{
370
return save_my_cleanups (&final_cleanup_chain);
371
}
372
373
struct cleanup *
374
save_my_cleanups (struct cleanup **pmy_chain)
375
{
376
struct cleanup *old_chain = *pmy_chain;
377
378
*pmy_chain = 0;
379
return old_chain;
380
}
381
382
/* Restore the cleanup chain from a previously saved chain. */
383
void
384
restore_cleanups (struct cleanup *chain)
385
{
386
restore_my_cleanups (&cleanup_chain, chain);
387
}
388
389
void
390
restore_final_cleanups (struct cleanup *chain)
391
{
392
restore_my_cleanups (&final_cleanup_chain, chain);
393
}
394
395
void
396
restore_my_cleanups (struct cleanup **pmy_chain, struct cleanup *chain)
397
{
398
*pmy_chain = chain;
399
}
400
401
/* This function is useful for cleanups.
402
Do
403
404
foo = xmalloc (...);
405
old_chain = make_cleanup (free_current_contents, &foo);
406
407
to arrange to free the object thus allocated. */
408
409
void
410
free_current_contents (void *ptr)
411
{
412
void **location = ptr;
413
if (location == NULL)
414
internal_error (__FILE__, __LINE__,
415
"free_current_contents: NULL pointer");
416
if (*location != NULL)
417
{
418
xfree (*location);
419
*location = NULL;
420
}
421
}
422
423
/* Provide a known function that does nothing, to use as a base for
424
for a possibly long chain of cleanups. This is useful where we
425
use the cleanup chain for handling normal cleanups as well as dealing
426
with cleanups that need to be done as a result of a call to error().
427
In such cases, we may not be certain where the first cleanup is, unless
428
we have a do-nothing one to always use as the base. */
429
430
void
431
null_cleanup (void *arg)
432
{
433
}
434
435
/* Add a continuation to the continuation list, the global list
436
cmd_continuation. The new continuation will be added at the front.*/
437
void
438
add_continuation (void (*continuation_hook) (struct continuation_arg *),
439
struct continuation_arg *arg_list)
440
{
441
struct continuation *continuation_ptr;
442
443
continuation_ptr =
444
(struct continuation *) xmalloc (sizeof (struct continuation));
445
continuation_ptr->continuation_hook = continuation_hook;
446
continuation_ptr->arg_list = arg_list;
447
continuation_ptr->next = cmd_continuation;
448
cmd_continuation = continuation_ptr;
449
}
450
451
/* Walk down the cmd_continuation list, and execute all the
452
continuations. There is a problem though. In some cases new
453
continuations may be added while we are in the middle of this
454
loop. If this happens they will be added in the front, and done
455
before we have a chance of exhausting those that were already
456
there. We need to then save the beginning of the list in a pointer
457
and do the continuations from there on, instead of using the
458
global beginning of list as our iteration pointer.*/
459
void
460
do_all_continuations (void)
461
{
462
struct continuation *continuation_ptr;
463
struct continuation *saved_continuation;
464
465
/* Copy the list header into another pointer, and set the global
466
list header to null, so that the global list can change as a side
467
effect of invoking the continuations and the processing of
468
the preexisting continuations will not be affected. */
469
continuation_ptr = cmd_continuation;
470
cmd_continuation = NULL;
471
472
/* Work now on the list we have set aside. */
473
while (continuation_ptr)
474
{
475
(continuation_ptr->continuation_hook) (continuation_ptr->arg_list);
476
saved_continuation = continuation_ptr;
477
continuation_ptr = continuation_ptr->next;
478
xfree (saved_continuation);
479
}
480
}
481
482
/* Walk down the cmd_continuation list, and get rid of all the
483
continuations. */
484
void
485
discard_all_continuations (void)
486
{
487
struct continuation *continuation_ptr;
488
489
while (cmd_continuation)
490
{
491
continuation_ptr = cmd_continuation;
492
cmd_continuation = continuation_ptr->next;
493
xfree (continuation_ptr);
494
}
495
}
496
497
/* Add a continuation to the continuation list, the global list
498
intermediate_continuation. The new continuation will be added at the front.*/
499
void
500
add_intermediate_continuation (void (*continuation_hook)
501
(struct continuation_arg *),
502
struct continuation_arg *arg_list)
503
{
504
struct continuation *continuation_ptr;
505
506
continuation_ptr =
507
(struct continuation *) xmalloc (sizeof (struct continuation));
508
continuation_ptr->continuation_hook = continuation_hook;
509
continuation_ptr->arg_list = arg_list;
510
continuation_ptr->next = intermediate_continuation;
511
intermediate_continuation = continuation_ptr;
512
}
513
514
/* Walk down the cmd_continuation list, and execute all the
515
continuations. There is a problem though. In some cases new
516
continuations may be added while we are in the middle of this
517
loop. If this happens they will be added in the front, and done
518
before we have a chance of exhausting those that were already
519
there. We need to then save the beginning of the list in a pointer
520
and do the continuations from there on, instead of using the
521
global beginning of list as our iteration pointer.*/
522
void
523
do_all_intermediate_continuations (void)
524
{
525
struct continuation *continuation_ptr;
526
struct continuation *saved_continuation;
527
528
/* Copy the list header into another pointer, and set the global
529
list header to null, so that the global list can change as a side
530
effect of invoking the continuations and the processing of
531
the preexisting continuations will not be affected. */
532
continuation_ptr = intermediate_continuation;
533
intermediate_continuation = NULL;
534
535
/* Work now on the list we have set aside. */
536
while (continuation_ptr)
537
{
538
(continuation_ptr->continuation_hook) (continuation_ptr->arg_list);
539
saved_continuation = continuation_ptr;
540
continuation_ptr = continuation_ptr->next;
541
xfree (saved_continuation);
542
}
543
}
544
545
/* Walk down the cmd_continuation list, and get rid of all the
546
continuations. */
547
void
548
discard_all_intermediate_continuations (void)
549
{
550
struct continuation *continuation_ptr;
551
552
while (intermediate_continuation)
553
{
554
continuation_ptr = intermediate_continuation;
555
intermediate_continuation = continuation_ptr->next;
556
xfree (continuation_ptr);
557
}
558
}
559
560
561
562
/* Print a warning message. The first argument STRING is the warning
563
message, used as an fprintf format string, the second is the
564
va_list of arguments for that string. A warning is unfiltered (not
565
paginated) so that the user does not need to page through each
566
screen full of warnings when there are lots of them. */
567
568
void
569
vwarning (const char *string, va_list args)
570
{
571
if (warning_hook)
572
(*warning_hook) (string, args);
573
else
574
{
575
target_terminal_ours ();
576
wrap_here (""); /* Force out any buffered output */
577
gdb_flush (gdb_stdout);
578
if (warning_pre_print)
579
fputs_unfiltered (warning_pre_print, gdb_stderr);
580
vfprintf_unfiltered (gdb_stderr, string, args);
581
fprintf_unfiltered (gdb_stderr, "\n");
582
va_end (args);
583
}
584
}
585
586
/* Print a warning message.
587
The first argument STRING is the warning message, used as a fprintf string,
588
and the remaining args are passed as arguments to it.
589
The primary difference between warnings and errors is that a warning
590
does not force the return to command level. */
591
592
void
593
warning (const char *string, ...)
594
{
595
va_list args;
596
va_start (args, string);
597
vwarning (string, args);
598
va_end (args);
599
}
600
601
/* Print an error message and return to command level.
602
The first argument STRING is the error message, used as a fprintf string,
603
and the remaining args are passed as arguments to it. */
604
605
NORETURN void
606
verror (const char *string, va_list args)
607
{
608
struct ui_file *tmp_stream = mem_fileopen ();
609
make_cleanup_ui_file_delete (tmp_stream);
610
vfprintf_unfiltered (tmp_stream, string, args);
611
error_stream (tmp_stream);
612
}
613
614
NORETURN void
615
error (const char *string, ...)
616
{
617
va_list args;
618
va_start (args, string);
619
verror (string, args);
620
va_end (args);
621
}
622
623
static void
624
do_write (void *data, const char *buffer, long length_buffer)
625
{
626
ui_file_write (data, buffer, length_buffer);
627
}
628
629
/* Cause a silent error to occur. Any error message is recorded
630
though it is not issued. */
631
NORETURN void
632
error_silent (const char *string, ...)
633
{
634
va_list args;
635
struct ui_file *tmp_stream = mem_fileopen ();
636
va_start (args, string);
637
make_cleanup_ui_file_delete (tmp_stream);
638
vfprintf_unfiltered (tmp_stream, string, args);
639
/* Copy the stream into the GDB_LASTERR buffer. */
640
ui_file_rewind (gdb_lasterr);
641
ui_file_put (tmp_stream, do_write, gdb_lasterr);
642
va_end (args);
643
644
throw_exception (RETURN_ERROR);
645
}
646
647
/* Output an error message including any pre-print text to gdb_stderr. */
648
void
649
error_output_message (char *pre_print, char *msg)
650
{
651
target_terminal_ours ();
652
wrap_here (""); /* Force out any buffered output */
653
gdb_flush (gdb_stdout);
654
annotate_error_begin ();
655
if (pre_print)
656
fputs_filtered (pre_print, gdb_stderr);
657
fputs_filtered (msg, gdb_stderr);
658
fprintf_filtered (gdb_stderr, "\n");
659
}
660
661
NORETURN void
662
error_stream (struct ui_file *stream)
663
{
664
if (error_begin_hook)
665
error_begin_hook ();
666
667
/* Copy the stream into the GDB_LASTERR buffer. */
668
ui_file_rewind (gdb_lasterr);
669
ui_file_put (stream, do_write, gdb_lasterr);
670
671
/* Write the message plus any error_pre_print to gdb_stderr. */
672
target_terminal_ours ();
673
wrap_here (""); /* Force out any buffered output */
674
gdb_flush (gdb_stdout);
675
annotate_error_begin ();
676
if (error_pre_print)
677
fputs_filtered (error_pre_print, gdb_stderr);
678
ui_file_put (stream, do_write, gdb_stderr);
679
fprintf_filtered (gdb_stderr, "\n");
680
#ifdef CRASH_MERGE
681
if (error_hook)
682
(*error_hook)();
683
else {
684
int console(char *, ...);
685
console("verror() called without error_hook\n");
686
}
687
#endif
688
throw_exception (RETURN_ERROR);
689
}
690
691
/* Get the last error message issued by gdb */
692
693
char *
694
error_last_message (void)
695
{
696
long len;
697
return ui_file_xstrdup (gdb_lasterr, &len);
698
}
699
700
/* This is to be called by main() at the very beginning */
701
702
void
703
error_init (void)
704
{
705
gdb_lasterr = mem_fileopen ();
706
}
707
708
/* Print a message reporting an internal error/warning. Ask the user
709
if they want to continue, dump core, or just exit. Return
710
something to indicate a quit. */
711
712
struct internal_problem
713
{
714
const char *name;
715
/* FIXME: cagney/2002-08-15: There should be ``maint set/show''
716
commands available for controlling these variables. */
717
enum auto_boolean should_quit;
718
enum auto_boolean should_dump_core;
719
};
720
721
/* Report a problem, internal to GDB, to the user. Once the problem
722
has been reported, and assuming GDB didn't quit, the caller can
723
either allow execution to resume or throw an error. */
724
725
static void
726
internal_vproblem (struct internal_problem *problem,
727
const char *file, int line, const char *fmt, va_list ap)
728
{
729
static int dejavu;
730
int quit_p;
731
int dump_core_p;
732
char *reason;
733
734
/* Don't allow infinite error/warning recursion. */
735
{
736
static char msg[] = "Recursive internal problem.\n";
737
switch (dejavu)
738
{
739
case 0:
740
dejavu = 1;
741
break;
742
case 1:
743
dejavu = 2;
744
fputs_unfiltered (msg, gdb_stderr);
745
abort (); /* NOTE: GDB has only three calls to abort(). */
746
default:
747
dejavu = 3;
748
write (STDERR_FILENO, msg, sizeof (msg));
749
exit (1);
750
}
751
}
752
753
/* Try to get the message out and at the start of a new line. */
754
target_terminal_ours ();
755
begin_line ();
756
757
/* Create a string containing the full error/warning message. Need
758
to call query with this full string, as otherwize the reason
759
(error/warning) and question become separated. Format using a
760
style similar to a compiler error message. Include extra detail
761
so that the user knows that they are living on the edge. */
762
{
763
char *msg;
764
xvasprintf (&msg, fmt, ap);
765
xasprintf (&reason, "\
766
%s:%d: %s: %s\n\
767
A problem internal to GDB has been detected,\n\
768
further debugging may prove unreliable.", file, line, problem->name, msg);
769
xfree (msg);
770
make_cleanup (xfree, reason);
771
}
772
773
switch (problem->should_quit)
774
{
775
case AUTO_BOOLEAN_AUTO:
776
/* Default (yes/batch case) is to quit GDB. When in batch mode
777
this lessens the likelhood of GDB going into an infinate
778
loop. */
779
quit_p = query ("%s\nQuit this debugging session? ", reason);
780
break;
781
case AUTO_BOOLEAN_TRUE:
782
quit_p = 1;
783
break;
784
case AUTO_BOOLEAN_FALSE:
785
quit_p = 0;
786
break;
787
default:
788
internal_error (__FILE__, __LINE__, "bad switch");
789
}
790
791
switch (problem->should_dump_core)
792
{
793
case AUTO_BOOLEAN_AUTO:
794
/* Default (yes/batch case) is to dump core. This leaves a GDB
795
`dropping' so that it is easier to see that something went
796
wrong in GDB. */
797
dump_core_p = query ("%s\nCreate a core file of GDB? ", reason);
798
break;
799
break;
800
case AUTO_BOOLEAN_TRUE:
801
dump_core_p = 1;
802
break;
803
case AUTO_BOOLEAN_FALSE:
804
dump_core_p = 0;
805
break;
806
default:
807
internal_error (__FILE__, __LINE__, "bad switch");
808
}
809
810
if (quit_p)
811
{
812
if (dump_core_p)
813
abort (); /* NOTE: GDB has only three calls to abort(). */
814
else
815
exit (1);
816
}
817
else
818
{
819
if (dump_core_p)
820
{
821
if (fork () == 0)
822
abort (); /* NOTE: GDB has only three calls to abort(). */
823
}
824
}
825
826
dejavu = 0;
827
}
828
829
static struct internal_problem internal_error_problem = {
830
"internal-error", AUTO_BOOLEAN_AUTO, AUTO_BOOLEAN_AUTO
831
};
832
833
NORETURN void
834
internal_verror (const char *file, int line, const char *fmt, va_list ap)
835
{
836
internal_vproblem (&internal_error_problem, file, line, fmt, ap);
837
throw_exception (RETURN_ERROR);
838
}
839
840
NORETURN void
841
internal_error (const char *file, int line, const char *string, ...)
842
{
843
va_list ap;
844
va_start (ap, string);
845
internal_verror (file, line, string, ap);
846
va_end (ap);
847
}
848
849
static struct internal_problem internal_warning_problem = {
850
"internal-error", AUTO_BOOLEAN_AUTO, AUTO_BOOLEAN_AUTO
851
};
852
853
void
854
internal_vwarning (const char *file, int line, const char *fmt, va_list ap)
855
{
856
internal_vproblem (&internal_warning_problem, file, line, fmt, ap);
857
}
858
859
void
860
internal_warning (const char *file, int line, const char *string, ...)
861
{
862
va_list ap;
863
va_start (ap, string);
864
internal_vwarning (file, line, string, ap);
865
va_end (ap);
866
}
867
868
/* The strerror() function can return NULL for errno values that are
869
out of range. Provide a "safe" version that always returns a
870
printable string. */
871
872
char *
873
safe_strerror (int errnum)
874
{
875
char *msg;
876
static char buf[32];
877
878
msg = strerror (errnum);
879
if (msg == NULL)
880
{
881
sprintf (buf, "(undocumented errno %d)", errnum);
882
msg = buf;
883
}
884
return (msg);
885
}
886
887
/* Print the system error message for errno, and also mention STRING
888
as the file name for which the error was encountered.
889
Then return to command level. */
890
891
NORETURN void
892
perror_with_name (const char *string)
893
{
894
char *err;
895
char *combined;
896
897
err = safe_strerror (errno);
898
combined = (char *) alloca (strlen (err) + strlen (string) + 3);
899
strcpy (combined, string);
900
strcat (combined, ": ");
901
strcat (combined, err);
902
903
/* I understand setting these is a matter of taste. Still, some people
904
may clear errno but not know about bfd_error. Doing this here is not
905
unreasonable. */
906
bfd_set_error (bfd_error_no_error);
907
errno = 0;
908
909
error ("%s.", combined);
910
}
911
912
/* Print the system error message for ERRCODE, and also mention STRING
913
as the file name for which the error was encountered. */
914
915
void
916
print_sys_errmsg (const char *string, int errcode)
917
{
918
char *err;
919
char *combined;
920
921
err = safe_strerror (errcode);
922
combined = (char *) alloca (strlen (err) + strlen (string) + 3);
923
strcpy (combined, string);
924
strcat (combined, ": ");
925
strcat (combined, err);
926
927
/* We want anything which was printed on stdout to come out first, before
928
this message. */
929
gdb_flush (gdb_stdout);
930
fprintf_unfiltered (gdb_stderr, "%s.\n", combined);
931
}
932
933
/* Control C eventually causes this to be called, at a convenient time. */
934
935
void
936
quit (void)
937
{
938
struct serial *gdb_stdout_serial = serial_fdopen (1);
939
940
target_terminal_ours ();
941
942
/* We want all output to appear now, before we print "Quit". We
943
have 3 levels of buffering we have to flush (it's possible that
944
some of these should be changed to flush the lower-level ones
945
too): */
946
947
/* 1. The _filtered buffer. */
948
wrap_here ((char *) 0);
949
950
/* 2. The stdio buffer. */
951
gdb_flush (gdb_stdout);
952
gdb_flush (gdb_stderr);
953
954
/* 3. The system-level buffer. */
955
serial_drain_output (gdb_stdout_serial);
956
serial_un_fdopen (gdb_stdout_serial);
957
958
annotate_error_begin ();
959
960
/* Don't use *_filtered; we don't want to prompt the user to continue. */
961
if (quit_pre_print)
962
fputs_unfiltered (quit_pre_print, gdb_stderr);
963
964
#ifdef __MSDOS__
965
/* No steenking SIGINT will ever be coming our way when the
966
program is resumed. Don't lie. */
967
fprintf_unfiltered (gdb_stderr, "Quit\n");
968
#else
969
if (job_control
970
/* If there is no terminal switching for this target, then we can't
971
possibly get screwed by the lack of job control. */
972
|| current_target.to_terminal_ours == NULL)
973
fprintf_unfiltered (gdb_stderr, "Quit\n");
974
else
975
fprintf_unfiltered (gdb_stderr,
976
"Quit (expect signal SIGINT when the program is resumed)\n");
977
#endif
978
throw_exception (RETURN_QUIT);
979
}
980
981
/* Control C comes here */
982
void
983
request_quit (int signo)
984
{
985
quit_flag = 1;
986
/* Restore the signal handler. Harmless with BSD-style signals, needed
987
for System V-style signals. So just always do it, rather than worrying
988
about USG defines and stuff like that. */
989
signal (signo, request_quit);
990
991
if (immediate_quit)
992
quit ();
993
}
994
995
/* Memory management stuff (malloc friends). */
996
997
static void *
998
mmalloc (void *md, size_t size)
999
{
1000
return malloc (size); /* NOTE: GDB's only call to malloc() */
1001
}
1002
1003
static void *
1004
mrealloc (void *md, void *ptr, size_t size)
1005
{
1006
if (ptr == 0) /* Guard against old realloc's */
1007
return mmalloc (md, size);
1008
else
1009
return realloc (ptr, size); /* NOTE: GDB's only call to ralloc() */
1010
}
1011
1012
static void *
1013
mcalloc (void *md, size_t number, size_t size)
1014
{
1015
return calloc (number, size); /* NOTE: GDB's only call to calloc() */
1016
}
1017
1018
static void
1019
mfree (void *md, void *ptr)
1020
{
1021
free (ptr); /* NOTE: GDB's only call to free() */
1022
}
1023
1024
/* This used to do something interesting with USE_MMALLOC.
1025
* It can be retired any time. -- chastain 2004-01-19. */
1026
void
1027
init_malloc (void *md)
1028
{
1029
}
1030
1031
/* Called when a memory allocation fails, with the number of bytes of
1032
memory requested in SIZE. */
1033
1034
NORETURN void
1035
nomem (long size)
1036
{
1037
if (size > 0)
1038
{
1039
internal_error (__FILE__, __LINE__,
1040
"virtual memory exhausted: can't allocate %ld bytes.",
1041
size);
1042
}
1043
else
1044
{
1045
internal_error (__FILE__, __LINE__, "virtual memory exhausted.");
1046
}
1047
}
1048
1049
/* The xmmalloc() family of memory management routines.
1050
1051
These are are like the mmalloc() family except that they implement
1052
consistent semantics and guard against typical memory management
1053
problems: if a malloc fails, an internal error is thrown; if
1054
free(NULL) is called, it is ignored; if *alloc(0) is called, NULL
1055
is returned.
1056
1057
All these routines are implemented using the mmalloc() family. */
1058
1059
void *
1060
xmmalloc (void *md, size_t size)
1061
{
1062
void *val;
1063
1064
/* See libiberty/xmalloc.c. This function need's to match that's
1065
semantics. It never returns NULL. */
1066
if (size == 0)
1067
size = 1;
1068
1069
val = mmalloc (md, size);
1070
if (val == NULL)
1071
nomem (size);
1072
1073
return (val);
1074
}
1075
1076
void *
1077
xmrealloc (void *md, void *ptr, size_t size)
1078
{
1079
void *val;
1080
1081
/* See libiberty/xmalloc.c. This function need's to match that's
1082
semantics. It never returns NULL. */
1083
if (size == 0)
1084
size = 1;
1085
1086
if (ptr != NULL)
1087
val = mrealloc (md, ptr, size);
1088
else
1089
val = mmalloc (md, size);
1090
if (val == NULL)
1091
nomem (size);
1092
1093
return (val);
1094
}
1095
1096
void *
1097
xmcalloc (void *md, size_t number, size_t size)
1098
{
1099
void *mem;
1100
1101
/* See libiberty/xmalloc.c. This function need's to match that's
1102
semantics. It never returns NULL. */
1103
if (number == 0 || size == 0)
1104
{
1105
number = 1;
1106
size = 1;
1107
}
1108
1109
mem = mcalloc (md, number, size);
1110
if (mem == NULL)
1111
nomem (number * size);
1112
1113
return mem;
1114
}
1115
1116
void
1117
xmfree (void *md, void *ptr)
1118
{
1119
if (ptr != NULL)
1120
mfree (md, ptr);
1121
}
1122
1123
/* The xmalloc() (libiberty.h) family of memory management routines.
1124
1125
These are like the ISO-C malloc() family except that they implement
1126
consistent semantics and guard against typical memory management
1127
problems. See xmmalloc() above for further information.
1128
1129
All these routines are wrappers to the xmmalloc() family. */
1130
1131
/* NOTE: These are declared using PTR to ensure consistency with
1132
"libiberty.h". xfree() is GDB local. */
1133
1134
PTR /* OK: PTR */
1135
xmalloc (size_t size)
1136
{
1137
return xmmalloc (NULL, size);
1138
}
1139
1140
PTR /* OK: PTR */
1141
xrealloc (PTR ptr, size_t size) /* OK: PTR */
1142
{
1143
return xmrealloc (NULL, ptr, size);
1144
}
1145
1146
PTR /* OK: PTR */
1147
xcalloc (size_t number, size_t size)
1148
{
1149
return xmcalloc (NULL, number, size);
1150
}
1151
1152
void
1153
xfree (void *ptr)
1154
{
1155
xmfree (NULL, ptr);
1156
}
1157
1158
1159
/* Like asprintf/vasprintf but get an internal_error if the call
1160
fails. */
1161
1162
char *
1163
xstrprintf (const char *format, ...)
1164
{
1165
char *ret;
1166
va_list args;
1167
va_start (args, format);
1168
xvasprintf (&ret, format, args);
1169
va_end (args);
1170
return ret;
1171
}
1172
1173
void
1174
xasprintf (char **ret, const char *format, ...)
1175
{
1176
va_list args;
1177
va_start (args, format);
1178
xvasprintf (ret, format, args);
1179
va_end (args);
1180
}
1181
1182
void
1183
xvasprintf (char **ret, const char *format, va_list ap)
1184
{
1185
int status = vasprintf (ret, format, ap);
1186
/* NULL could be returned due to a memory allocation problem; a
1187
badly format string; or something else. */
1188
if ((*ret) == NULL)
1189
internal_error (__FILE__, __LINE__,
1190
"vasprintf returned NULL buffer (errno %d)", errno);
1191
/* A negative status with a non-NULL buffer shouldn't never
1192
happen. But to be sure. */
1193
if (status < 0)
1194
internal_error (__FILE__, __LINE__,
1195
"vasprintf call failed (errno %d)", errno);
1196
}
1197
1198
1199
/* My replacement for the read system call.
1200
Used like `read' but keeps going if `read' returns too soon. */
1201
1202
int
1203
myread (int desc, char *addr, int len)
1204
{
1205
int val;
1206
int orglen = len;
1207
1208
while (len > 0)
1209
{
1210
val = read (desc, addr, len);
1211
if (val < 0)
1212
return val;
1213
if (val == 0)
1214
return orglen - len;
1215
len -= val;
1216
addr += val;
1217
}
1218
return orglen;
1219
}
1220
1221
/* Make a copy of the string at PTR with SIZE characters
1222
(and add a null character at the end in the copy).
1223
Uses malloc to get the space. Returns the address of the copy. */
1224
1225
char *
1226
savestring (const char *ptr, size_t size)
1227
{
1228
char *p = (char *) xmalloc (size + 1);
1229
memcpy (p, ptr, size);
1230
p[size] = 0;
1231
return p;
1232
}
1233
1234
char *
1235
msavestring (void *md, const char *ptr, size_t size)
1236
{
1237
char *p = (char *) xmmalloc (md, size + 1);
1238
memcpy (p, ptr, size);
1239
p[size] = 0;
1240
return p;
1241
}
1242
1243
char *
1244
mstrsave (void *md, const char *ptr)
1245
{
1246
return (msavestring (md, ptr, strlen (ptr)));
1247
}
1248
1249
void
1250
print_spaces (int n, struct ui_file *file)
1251
{
1252
fputs_unfiltered (n_spaces (n), file);
1253
}
1254
1255
/* Print a host address. */
1256
1257
void
1258
gdb_print_host_address (const void *addr, struct ui_file *stream)
1259
{
1260
1261
/* We could use the %p conversion specifier to fprintf if we had any
1262
way of knowing whether this host supports it. But the following
1263
should work on the Alpha and on 32 bit machines. */
1264
1265
fprintf_filtered (stream, "0x%lx", (unsigned long) addr);
1266
}
1267
1268
/* Ask user a y-or-n question and return 1 iff answer is yes.
1269
Takes three args which are given to printf to print the question.
1270
The first, a control string, should end in "? ".
1271
It should not say how to answer, because we do that. */
1272
1273
/* VARARGS */
1274
int
1275
query (const char *ctlstr, ...)
1276
{
1277
va_list args;
1278
int answer;
1279
int ans2;
1280
int retval;
1281
1282
va_start (args, ctlstr);
1283
1284
if (query_hook)
1285
{
1286
return query_hook (ctlstr, args);
1287
}
1288
1289
/* Automatically answer "yes" if input is not from a terminal. */
1290
if (!input_from_terminal_p ())
1291
return 1;
1292
1293
while (1)
1294
{
1295
wrap_here (""); /* Flush any buffered output */
1296
gdb_flush (gdb_stdout);
1297
1298
if (annotation_level > 1)
1299
printf_filtered ("\n\032\032pre-query\n");
1300
1301
vfprintf_filtered (gdb_stdout, ctlstr, args);
1302
printf_filtered ("(y or n) ");
1303
1304
if (annotation_level > 1)
1305
printf_filtered ("\n\032\032query\n");
1306
1307
wrap_here ("");
1308
gdb_flush (gdb_stdout);
1309
1310
answer = fgetc (stdin);
1311
clearerr (stdin); /* in case of C-d */
1312
if (answer == EOF) /* C-d */
1313
{
1314
retval = 1;
1315
break;
1316
}
1317
/* Eat rest of input line, to EOF or newline */
1318
if (answer != '\n')
1319
do
1320
{
1321
ans2 = fgetc (stdin);
1322
clearerr (stdin);
1323
}
1324
while (ans2 != EOF && ans2 != '\n' && ans2 != '\r');
1325
1326
if (answer >= 'a')
1327
answer -= 040;
1328
if (answer == 'Y')
1329
{
1330
retval = 1;
1331
break;
1332
}
1333
if (answer == 'N')
1334
{
1335
retval = 0;
1336
break;
1337
}
1338
printf_filtered ("Please answer y or n.\n");
1339
}
1340
1341
if (annotation_level > 1)
1342
printf_filtered ("\n\032\032post-query\n");
1343
return retval;
1344
}
1345
1346
1347
/* This function supports the nquery() and yquery() functions.
1348
Ask user a y-or-n question and return 0 if answer is no, 1 if
1349
answer is yes, or default the answer to the specified default.
1350
DEFCHAR is either 'y' or 'n' and refers to the default answer.
1351
CTLSTR is the control string and should end in "? ". It should
1352
not say how to answer, because we do that.
1353
ARGS are the arguments passed along with the CTLSTR argument to
1354
printf. */
1355
1356
static int
1357
defaulted_query (const char *ctlstr, const char defchar, va_list args)
1358
{
1359
int answer;
1360
int ans2;
1361
int retval;
1362
int def_value;
1363
char def_answer, not_def_answer;
1364
char *y_string, *n_string;
1365
1366
/* Set up according to which answer is the default. */
1367
if (defchar == 'y')
1368
{
1369
def_value = 1;
1370
def_answer = 'Y';
1371
not_def_answer = 'N';
1372
y_string = "[y]";
1373
n_string = "n";
1374
}
1375
else
1376
{
1377
def_value = 0;
1378
def_answer = 'N';
1379
not_def_answer = 'Y';
1380
y_string = "y";
1381
n_string = "[n]";
1382
}
1383
1384
if (query_hook)
1385
{
1386
return query_hook (ctlstr, args);
1387
}
1388
1389
/* Automatically answer default value if input is not from a terminal. */
1390
if (!input_from_terminal_p ())
1391
return def_value;
1392
1393
while (1)
1394
{
1395
wrap_here (""); /* Flush any buffered output */
1396
gdb_flush (gdb_stdout);
1397
1398
if (annotation_level > 1)
1399
printf_filtered ("\n\032\032pre-%cquery\n", defchar);
1400
1401
vfprintf_filtered (gdb_stdout, ctlstr, args);
1402
printf_filtered ("(%s or %s) ", y_string, n_string);
1403
1404
if (annotation_level > 1)
1405
printf_filtered ("\n\032\032%cquery\n", defchar);
1406
1407
wrap_here ("");
1408
gdb_flush (gdb_stdout);
1409
1410
answer = fgetc (stdin);
1411
clearerr (stdin); /* in case of C-d */
1412
if (answer == EOF) /* C-d */
1413
{
1414
retval = def_value;
1415
break;
1416
}
1417
/* Eat rest of input line, to EOF or newline */
1418
if (answer != '\n')
1419
do
1420
{
1421
ans2 = fgetc (stdin);
1422
clearerr (stdin);
1423
}
1424
while (ans2 != EOF && ans2 != '\n' && ans2 != '\r');
1425
1426
if (answer >= 'a')
1427
answer -= 040;
1428
/* Check answer. For the non-default, the user must specify
1429
the non-default explicitly. */
1430
if (answer == not_def_answer)
1431
{
1432
retval = !def_value;
1433
break;
1434
}
1435
/* Otherwise, for the default, the user may either specify
1436
the required input or have it default by entering nothing. */
1437
if (answer == def_answer || answer == '\n' ||
1438
answer == '\r' || answer == EOF)
1439
{
1440
retval = def_value;
1441
break;
1442
}
1443
/* Invalid entries are not defaulted and require another selection. */
1444
printf_filtered ("Please answer %s or %s.\n",
1445
y_string, n_string);
1446
}
1447
1448
if (annotation_level > 1)
1449
printf_filtered ("\n\032\032post-%cquery\n", defchar);
1450
return retval;
1451
}
1452
1453
1454
/* Ask user a y-or-n question and return 0 if answer is no, 1 if
1455
answer is yes, or 0 if answer is defaulted.
1456
Takes three args which are given to printf to print the question.
1457
The first, a control string, should end in "? ".
1458
It should not say how to answer, because we do that. */
1459
1460
int
1461
nquery (const char *ctlstr, ...)
1462
{
1463
va_list args;
1464
1465
va_start (args, ctlstr);
1466
return defaulted_query (ctlstr, 'n', args);
1467
va_end (args);
1468
}
1469
1470
/* Ask user a y-or-n question and return 0 if answer is no, 1 if
1471
answer is yes, or 1 if answer is defaulted.
1472
Takes three args which are given to printf to print the question.
1473
The first, a control string, should end in "? ".
1474
It should not say how to answer, because we do that. */
1475
1476
int
1477
yquery (const char *ctlstr, ...)
1478
{
1479
va_list args;
1480
1481
va_start (args, ctlstr);
1482
return defaulted_query (ctlstr, 'y', args);
1483
va_end (args);
1484
}
1485
1486
/* Print an error message saying that we couldn't make sense of a
1487
\^mumble sequence in a string or character constant. START and END
1488
indicate a substring of some larger string that contains the
1489
erroneous backslash sequence, missing the initial backslash. */
1490
static NORETURN int
1491
no_control_char_error (const char *start, const char *end)
1492
{
1493
int len = end - start;
1494
char *copy = alloca (end - start + 1);
1495
1496
memcpy (copy, start, len);
1497
copy[len] = '\0';
1498
1499
error ("There is no control character `\\%s' in the `%s' character set.",
1500
copy, target_charset ());
1501
}
1502
1503
/* Parse a C escape sequence. STRING_PTR points to a variable
1504
containing a pointer to the string to parse. That pointer
1505
should point to the character after the \. That pointer
1506
is updated past the characters we use. The value of the
1507
escape sequence is returned.
1508
1509
A negative value means the sequence \ newline was seen,
1510
which is supposed to be equivalent to nothing at all.
1511
1512
If \ is followed by a null character, we return a negative
1513
value and leave the string pointer pointing at the null character.
1514
1515
If \ is followed by 000, we return 0 and leave the string pointer
1516
after the zeros. A value of 0 does not mean end of string. */
1517
1518
int
1519
parse_escape (char **string_ptr)
1520
{
1521
int target_char;
1522
int c = *(*string_ptr)++;
1523
if (c_parse_backslash (c, &target_char))
1524
return target_char;
1525
else
1526
switch (c)
1527
{
1528
case '\n':
1529
return -2;
1530
case 0:
1531
(*string_ptr)--;
1532
return 0;
1533
case '^':
1534
{
1535
/* Remember where this escape sequence started, for reporting
1536
errors. */
1537
char *sequence_start_pos = *string_ptr - 1;
1538
1539
c = *(*string_ptr)++;
1540
1541
if (c == '?')
1542
{
1543
/* XXXCHARSET: What is `delete' in the host character set? */
1544
c = 0177;
1545
1546
if (!host_char_to_target (c, &target_char))
1547
error ("There is no character corresponding to `Delete' "
1548
"in the target character set `%s'.", host_charset ());
1549
1550
return target_char;
1551
}
1552
else if (c == '\\')
1553
target_char = parse_escape (string_ptr);
1554
else
1555
{
1556
if (!host_char_to_target (c, &target_char))
1557
no_control_char_error (sequence_start_pos, *string_ptr);
1558
}
1559
1560
/* Now target_char is something like `c', and we want to find
1561
its control-character equivalent. */
1562
if (!target_char_to_control_char (target_char, &target_char))
1563
no_control_char_error (sequence_start_pos, *string_ptr);
1564
1565
return target_char;
1566
}
1567
1568
/* XXXCHARSET: we need to use isdigit and value-of-digit
1569
methods of the host character set here. */
1570
1571
case '0':
1572
case '1':
1573
case '2':
1574
case '3':
1575
case '4':
1576
case '5':
1577
case '6':
1578
case '7':
1579
{
1580
int i = c - '0';
1581
int count = 0;
1582
while (++count < 3)
1583
{
1584
c = (**string_ptr);
1585
if (c >= '0' && c <= '7')
1586
{
1587
(*string_ptr)++;
1588
i *= 8;
1589
i += c - '0';
1590
}
1591
else
1592
{
1593
break;
1594
}
1595
}
1596
return i;
1597
}
1598
default:
1599
if (!host_char_to_target (c, &target_char))
1600
error
1601
("The escape sequence `\%c' is equivalent to plain `%c', which"
1602
" has no equivalent\n" "in the `%s' character set.", c, c,
1603
target_charset ());
1604
return target_char;
1605
}
1606
}
1607
1608
/* Print the character C on STREAM as part of the contents of a literal
1609
string whose delimiter is QUOTER. Note that this routine should only
1610
be call for printing things which are independent of the language
1611
of the program being debugged. */
1612
1613
static void
1614
printchar (int c, void (*do_fputs) (const char *, struct ui_file *),
1615
void (*do_fprintf) (struct ui_file *, const char *, ...),
1616
struct ui_file *stream, int quoter)
1617
{
1618
1619
c &= 0xFF; /* Avoid sign bit follies */
1620
1621
if (c < 0x20 || /* Low control chars */
1622
(c >= 0x7F && c < 0xA0) || /* DEL, High controls */
1623
(sevenbit_strings && c >= 0x80))
1624
{ /* high order bit set */
1625
switch (c)
1626
{
1627
case '\n':
1628
do_fputs ("\\n", stream);
1629
break;
1630
case '\b':
1631
do_fputs ("\\b", stream);
1632
break;
1633
case '\t':
1634
do_fputs ("\\t", stream);
1635
break;
1636
case '\f':
1637
do_fputs ("\\f", stream);
1638
break;
1639
case '\r':
1640
do_fputs ("\\r", stream);
1641
break;
1642
case '\033':
1643
do_fputs ("\\e", stream);
1644
break;
1645
case '\007':
1646
do_fputs ("\\a", stream);
1647
break;
1648
default:
1649
do_fprintf (stream, "\\%.3o", (unsigned int) c);
1650
break;
1651
}
1652
}
1653
else
1654
{
1655
if (c == '\\' || c == quoter)
1656
do_fputs ("\\", stream);
1657
do_fprintf (stream, "%c", c);
1658
}
1659
}
1660
1661
/* Print the character C on STREAM as part of the contents of a
1662
literal string whose delimiter is QUOTER. Note that these routines
1663
should only be call for printing things which are independent of
1664
the language of the program being debugged. */
1665
1666
void
1667
fputstr_filtered (const char *str, int quoter, struct ui_file *stream)
1668
{
1669
while (*str)
1670
printchar (*str++, fputs_filtered, fprintf_filtered, stream, quoter);
1671
}
1672
1673
void
1674
fputstr_unfiltered (const char *str, int quoter, struct ui_file *stream)
1675
{
1676
while (*str)
1677
printchar (*str++, fputs_unfiltered, fprintf_unfiltered, stream, quoter);
1678
}
1679
1680
void
1681
fputstrn_unfiltered (const char *str, int n, int quoter,
1682
struct ui_file *stream)
1683
{
1684
int i;
1685
for (i = 0; i < n; i++)
1686
printchar (str[i], fputs_unfiltered, fprintf_unfiltered, stream, quoter);
1687
}
1688
1689
1690
/* Number of lines per page or UINT_MAX if paging is disabled. */
1691
static unsigned int lines_per_page;
1692
1693
/* Number of chars per line or UINT_MAX if line folding is disabled. */
1694
static unsigned int chars_per_line;
1695
1696
/* Current count of lines printed on this page, chars on this line. */
1697
static unsigned int lines_printed, chars_printed;
1698
1699
/* Buffer and start column of buffered text, for doing smarter word-
1700
wrapping. When someone calls wrap_here(), we start buffering output
1701
that comes through fputs_filtered(). If we see a newline, we just
1702
spit it out and forget about the wrap_here(). If we see another
1703
wrap_here(), we spit it out and remember the newer one. If we see
1704
the end of the line, we spit out a newline, the indent, and then
1705
the buffered output. */
1706
1707
/* Malloc'd buffer with chars_per_line+2 bytes. Contains characters which
1708
are waiting to be output (they have already been counted in chars_printed).
1709
When wrap_buffer[0] is null, the buffer is empty. */
1710
static char *wrap_buffer;
1711
1712
/* Pointer in wrap_buffer to the next character to fill. */
1713
static char *wrap_pointer;
1714
1715
/* String to indent by if the wrap occurs. Must not be NULL if wrap_column
1716
is non-zero. */
1717
static char *wrap_indent;
1718
1719
/* Column number on the screen where wrap_buffer begins, or 0 if wrapping
1720
is not in effect. */
1721
static int wrap_column;
1722
1723
1724
/* Inialize the number of lines per page and chars per line. */
1725
1726
void
1727
init_page_info (void)
1728
{
1729
#if defined(TUI)
1730
if (!tui_get_command_dimension (&chars_per_line, &lines_per_page))
1731
#endif
1732
{
1733
int rows, cols;
1734
1735
#if defined(__GO32__)
1736
rows = ScreenRows ();
1737
cols = ScreenCols ();
1738
lines_per_page = rows;
1739
chars_per_line = cols;
1740
#else
1741
/* Make sure Readline has initialized its terminal settings. */
1742
rl_reset_terminal (NULL);
1743
1744
/* Get the screen size from Readline. */
1745
rl_get_screen_size (&rows, &cols);
1746
lines_per_page = rows;
1747
chars_per_line = cols;
1748
1749
/* Readline should have fetched the termcap entry for us. */
1750
if (tgetnum ("li") < 0 || getenv ("EMACS"))
1751
{
1752
/* The number of lines per page is not mentioned in the
1753
terminal description. This probably means that paging is
1754
not useful (e.g. emacs shell window), so disable paging. */
1755
lines_per_page = UINT_MAX;
1756
}
1757
1758
/* FIXME: Get rid of this junk. */
1759
#if defined(SIGWINCH) && defined(SIGWINCH_HANDLER)
1760
SIGWINCH_HANDLER (SIGWINCH);
1761
#endif
1762
1763
/* If the output is not a terminal, don't paginate it. */
1764
if (!ui_file_isatty (gdb_stdout))
1765
lines_per_page = UINT_MAX;
1766
#endif
1767
}
1768
1769
set_screen_size ();
1770
set_width ();
1771
}
1772
1773
/* Set the screen size based on LINES_PER_PAGE and CHARS_PER_LINE. */
1774
1775
static void
1776
set_screen_size (void)
1777
{
1778
int rows = lines_per_page;
1779
int cols = chars_per_line;
1780
1781
if (rows <= 0)
1782
rows = INT_MAX;
1783
1784
if (cols <= 0)
1785
rl_get_screen_size (NULL, &cols);
1786
1787
/* Update Readline's idea of the terminal size. */
1788
rl_set_screen_size (rows, cols);
1789
}
1790
1791
/* Reinitialize WRAP_BUFFER according to the current value of
1792
CHARS_PER_LINE. */
1793
1794
static void
1795
set_width (void)
1796
{
1797
if (chars_per_line == 0)
1798
init_page_info ();
1799
1800
if (!wrap_buffer)
1801
{
1802
wrap_buffer = (char *) xmalloc (chars_per_line + 2);
1803
wrap_buffer[0] = '\0';
1804
}
1805
else
1806
wrap_buffer = (char *) xrealloc (wrap_buffer, chars_per_line + 2);
1807
wrap_pointer = wrap_buffer; /* Start it at the beginning. */
1808
}
1809
1810
static void
1811
set_width_command (char *args, int from_tty, struct cmd_list_element *c)
1812
{
1813
set_screen_size ();
1814
set_width ();
1815
}
1816
1817
static void
1818
set_height_command (char *args, int from_tty, struct cmd_list_element *c)
1819
{
1820
set_screen_size ();
1821
}
1822
1823
/* Wait, so the user can read what's on the screen. Prompt the user
1824
to continue by pressing RETURN. */
1825
1826
static void
1827
prompt_for_continue (void)
1828
{
1829
char *ignore;
1830
char cont_prompt[120];
1831
1832
if (annotation_level > 1)
1833
printf_unfiltered ("\n\032\032pre-prompt-for-continue\n");
1834
1835
strcpy (cont_prompt,
1836
"---Type <return> to continue, or q <return> to quit---");
1837
if (annotation_level > 1)
1838
strcat (cont_prompt, "\n\032\032prompt-for-continue\n");
1839
1840
/* We must do this *before* we call gdb_readline, else it will eventually
1841
call us -- thinking that we're trying to print beyond the end of the
1842
screen. */
1843
reinitialize_more_filter ();
1844
1845
immediate_quit++;
1846
/* On a real operating system, the user can quit with SIGINT.
1847
But not on GO32.
1848
1849
'q' is provided on all systems so users don't have to change habits
1850
from system to system, and because telling them what to do in
1851
the prompt is more user-friendly than expecting them to think of
1852
SIGINT. */
1853
/* Call readline, not gdb_readline, because GO32 readline handles control-C
1854
whereas control-C to gdb_readline will cause the user to get dumped
1855
out to DOS. */
1856
ignore = gdb_readline_wrapper (cont_prompt);
1857
1858
if (annotation_level > 1)
1859
printf_unfiltered ("\n\032\032post-prompt-for-continue\n");
1860
1861
if (ignore)
1862
{
1863
char *p = ignore;
1864
while (*p == ' ' || *p == '\t')
1865
++p;
1866
if (p[0] == 'q')
1867
{
1868
if (!event_loop_p)
1869
request_quit (SIGINT);
1870
else
1871
async_request_quit (0);
1872
}
1873
xfree (ignore);
1874
}
1875
immediate_quit--;
1876
1877
/* Now we have to do this again, so that GDB will know that it doesn't
1878
need to save the ---Type <return>--- line at the top of the screen. */
1879
reinitialize_more_filter ();
1880
1881
dont_repeat (); /* Forget prev cmd -- CR won't repeat it. */
1882
}
1883
1884
/* Reinitialize filter; ie. tell it to reset to original values. */
1885
1886
void
1887
reinitialize_more_filter (void)
1888
{
1889
lines_printed = 0;
1890
chars_printed = 0;
1891
}
1892
1893
/* Indicate that if the next sequence of characters overflows the line,
1894
a newline should be inserted here rather than when it hits the end.
1895
If INDENT is non-null, it is a string to be printed to indent the
1896
wrapped part on the next line. INDENT must remain accessible until
1897
the next call to wrap_here() or until a newline is printed through
1898
fputs_filtered().
1899
1900
If the line is already overfull, we immediately print a newline and
1901
the indentation, and disable further wrapping.
1902
1903
If we don't know the width of lines, but we know the page height,
1904
we must not wrap words, but should still keep track of newlines
1905
that were explicitly printed.
1906
1907
INDENT should not contain tabs, as that will mess up the char count
1908
on the next line. FIXME.
1909
1910
This routine is guaranteed to force out any output which has been
1911
squirreled away in the wrap_buffer, so wrap_here ((char *)0) can be
1912
used to force out output from the wrap_buffer. */
1913
1914
void
1915
wrap_here (char *indent)
1916
{
1917
/* This should have been allocated, but be paranoid anyway. */
1918
if (!wrap_buffer)
1919
internal_error (__FILE__, __LINE__, "failed internal consistency check");
1920
1921
if (wrap_buffer[0])
1922
{
1923
*wrap_pointer = '\0';
1924
fputs_unfiltered (wrap_buffer, gdb_stdout);
1925
}
1926
wrap_pointer = wrap_buffer;
1927
wrap_buffer[0] = '\0';
1928
if (chars_per_line == UINT_MAX) /* No line overflow checking */
1929
{
1930
wrap_column = 0;
1931
}
1932
else if (chars_printed >= chars_per_line)
1933
{
1934
puts_filtered ("\n");
1935
if (indent != NULL)
1936
puts_filtered (indent);
1937
wrap_column = 0;
1938
}
1939
else
1940
{
1941
wrap_column = chars_printed;
1942
if (indent == NULL)
1943
wrap_indent = "";
1944
else
1945
wrap_indent = indent;
1946
}
1947
}
1948
1949
/* Print input string to gdb_stdout, filtered, with wrap,
1950
arranging strings in columns of n chars. String can be
1951
right or left justified in the column. Never prints
1952
trailing spaces. String should never be longer than
1953
width. FIXME: this could be useful for the EXAMINE
1954
command, which currently doesn't tabulate very well */
1955
1956
void
1957
puts_filtered_tabular (char *string, int width, int right)
1958
{
1959
int spaces = 0;
1960
int stringlen;
1961
char *spacebuf;
1962
1963
gdb_assert (chars_per_line > 0);
1964
if (chars_per_line == UINT_MAX)
1965
{
1966
fputs_filtered (string, gdb_stdout);
1967
fputs_filtered ("\n", gdb_stdout);
1968
return;
1969
}
1970
1971
if (((chars_printed - 1) / width + 2) * width >= chars_per_line)
1972
fputs_filtered ("\n", gdb_stdout);
1973
1974
if (width >= chars_per_line)
1975
width = chars_per_line - 1;
1976
1977
stringlen = strlen (string);
1978
1979
if (chars_printed > 0)
1980
spaces = width - (chars_printed - 1) % width - 1;
1981
if (right)
1982
spaces += width - stringlen;
1983
1984
spacebuf = alloca (spaces + 1);
1985
spacebuf[spaces] = '\0';
1986
while (spaces--)
1987
spacebuf[spaces] = ' ';
1988
1989
fputs_filtered (spacebuf, gdb_stdout);
1990
fputs_filtered (string, gdb_stdout);
1991
}
1992
1993
1994
/* Ensure that whatever gets printed next, using the filtered output
1995
commands, starts at the beginning of the line. I.E. if there is
1996
any pending output for the current line, flush it and start a new
1997
line. Otherwise do nothing. */
1998
1999
void
2000
begin_line (void)
2001
{
2002
if (chars_printed > 0)
2003
{
2004
puts_filtered ("\n");
2005
}
2006
}
2007
2008
2009
/* Like fputs but if FILTER is true, pause after every screenful.
2010
2011
Regardless of FILTER can wrap at points other than the final
2012
character of a line.
2013
2014
Unlike fputs, fputs_maybe_filtered does not return a value.
2015
It is OK for LINEBUFFER to be NULL, in which case just don't print
2016
anything.
2017
2018
Note that a longjmp to top level may occur in this routine (only if
2019
FILTER is true) (since prompt_for_continue may do so) so this
2020
routine should not be called when cleanups are not in place. */
2021
2022
static void
2023
fputs_maybe_filtered (const char *linebuffer, struct ui_file *stream,
2024
int filter)
2025
{
2026
const char *lineptr;
2027
2028
if (linebuffer == 0)
2029
return;
2030
2031
/* Don't do any filtering if it is disabled. */
2032
if ((stream != gdb_stdout) || !pagination_enabled
2033
|| (lines_per_page == UINT_MAX && chars_per_line == UINT_MAX))
2034
{
2035
fputs_unfiltered (linebuffer, stream);
2036
return;
2037
}
2038
2039
/* Go through and output each character. Show line extension
2040
when this is necessary; prompt user for new page when this is
2041
necessary. */
2042
2043
lineptr = linebuffer;
2044
while (*lineptr)
2045
{
2046
/* Possible new page. */
2047
if (filter && (lines_printed >= lines_per_page - 1))
2048
prompt_for_continue ();
2049
2050
while (*lineptr && *lineptr != '\n')
2051
{
2052
/* Print a single line. */
2053
if (*lineptr == '\t')
2054
{
2055
if (wrap_column)
2056
*wrap_pointer++ = '\t';
2057
else
2058
fputc_unfiltered ('\t', stream);
2059
/* Shifting right by 3 produces the number of tab stops
2060
we have already passed, and then adding one and
2061
shifting left 3 advances to the next tab stop. */
2062
chars_printed = ((chars_printed >> 3) + 1) << 3;
2063
lineptr++;
2064
}
2065
else
2066
{
2067
if (wrap_column)
2068
*wrap_pointer++ = *lineptr;
2069
else
2070
fputc_unfiltered (*lineptr, stream);
2071
chars_printed++;
2072
lineptr++;
2073
}
2074
2075
if (chars_printed >= chars_per_line)
2076
{
2077
unsigned int save_chars = chars_printed;
2078
2079
chars_printed = 0;
2080
lines_printed++;
2081
/* If we aren't actually wrapping, don't output newline --
2082
if chars_per_line is right, we probably just overflowed
2083
anyway; if it's wrong, let us keep going. */
2084
if (wrap_column)
2085
fputc_unfiltered ('\n', stream);
2086
2087
/* Possible new page. */
2088
if (lines_printed >= lines_per_page - 1)
2089
prompt_for_continue ();
2090
2091
/* Now output indentation and wrapped string */
2092
if (wrap_column)
2093
{
2094
fputs_unfiltered (wrap_indent, stream);
2095
*wrap_pointer = '\0'; /* Null-terminate saved stuff */
2096
fputs_unfiltered (wrap_buffer, stream); /* and eject it */
2097
/* FIXME, this strlen is what prevents wrap_indent from
2098
containing tabs. However, if we recurse to print it
2099
and count its chars, we risk trouble if wrap_indent is
2100
longer than (the user settable) chars_per_line.
2101
Note also that this can set chars_printed > chars_per_line
2102
if we are printing a long string. */
2103
chars_printed = strlen (wrap_indent)
2104
+ (save_chars - wrap_column);
2105
wrap_pointer = wrap_buffer; /* Reset buffer */
2106
wrap_buffer[0] = '\0';
2107
wrap_column = 0; /* And disable fancy wrap */
2108
}
2109
}
2110
}
2111
2112
if (*lineptr == '\n')
2113
{
2114
chars_printed = 0;
2115
wrap_here ((char *) 0); /* Spit out chars, cancel further wraps */
2116
lines_printed++;
2117
fputc_unfiltered ('\n', stream);
2118
lineptr++;
2119
}
2120
}
2121
}
2122
2123
void
2124
fputs_filtered (const char *linebuffer, struct ui_file *stream)
2125
{
2126
fputs_maybe_filtered (linebuffer, stream, 1);
2127
}
2128
2129
int
2130
putchar_unfiltered (int c)
2131
{
2132
char buf = c;
2133
ui_file_write (gdb_stdout, &buf, 1);
2134
return c;
2135
}
2136
2137
/* Write character C to gdb_stdout using GDB's paging mechanism and return C.
2138
May return nonlocally. */
2139
2140
int
2141
putchar_filtered (int c)
2142
{
2143
return fputc_filtered (c, gdb_stdout);
2144
}
2145
2146
int
2147
fputc_unfiltered (int c, struct ui_file *stream)
2148
{
2149
char buf = c;
2150
ui_file_write (stream, &buf, 1);
2151
return c;
2152
}
2153
2154
int
2155
fputc_filtered (int c, struct ui_file *stream)
2156
{
2157
char buf[2];
2158
2159
buf[0] = c;
2160
buf[1] = 0;
2161
fputs_filtered (buf, stream);
2162
return c;
2163
}
2164
2165
/* puts_debug is like fputs_unfiltered, except it prints special
2166
characters in printable fashion. */
2167
2168
void
2169
puts_debug (char *prefix, char *string, char *suffix)
2170
{
2171
int ch;
2172
2173
/* Print prefix and suffix after each line. */
2174
static int new_line = 1;
2175
static int return_p = 0;
2176
static char *prev_prefix = "";
2177
static char *prev_suffix = "";
2178
2179
if (*string == '\n')
2180
return_p = 0;
2181
2182
/* If the prefix is changing, print the previous suffix, a new line,
2183
and the new prefix. */
2184
if ((return_p || (strcmp (prev_prefix, prefix) != 0)) && !new_line)
2185
{
2186
fputs_unfiltered (prev_suffix, gdb_stdlog);
2187
fputs_unfiltered ("\n", gdb_stdlog);
2188
fputs_unfiltered (prefix, gdb_stdlog);
2189
}
2190
2191
/* Print prefix if we printed a newline during the previous call. */
2192
if (new_line)
2193
{
2194
new_line = 0;
2195
fputs_unfiltered (prefix, gdb_stdlog);
2196
}
2197
2198
prev_prefix = prefix;
2199
prev_suffix = suffix;
2200
2201
/* Output characters in a printable format. */
2202
while ((ch = *string++) != '\0')
2203
{
2204
switch (ch)
2205
{
2206
default:
2207
if (isprint (ch))
2208
fputc_unfiltered (ch, gdb_stdlog);
2209
2210
else
2211
fprintf_unfiltered (gdb_stdlog, "\\x%02x", ch & 0xff);
2212
break;
2213
2214
case '\\':
2215
fputs_unfiltered ("\\\\", gdb_stdlog);
2216
break;
2217
case '\b':
2218
fputs_unfiltered ("\\b", gdb_stdlog);
2219
break;
2220
case '\f':
2221
fputs_unfiltered ("\\f", gdb_stdlog);
2222
break;
2223
case '\n':
2224
new_line = 1;
2225
fputs_unfiltered ("\\n", gdb_stdlog);
2226
break;
2227
case '\r':
2228
fputs_unfiltered ("\\r", gdb_stdlog);
2229
break;
2230
case '\t':
2231
fputs_unfiltered ("\\t", gdb_stdlog);
2232
break;
2233
case '\v':
2234
fputs_unfiltered ("\\v", gdb_stdlog);
2235
break;
2236
}
2237
2238
return_p = ch == '\r';
2239
}
2240
2241
/* Print suffix if we printed a newline. */
2242
if (new_line)
2243
{
2244
fputs_unfiltered (suffix, gdb_stdlog);
2245
fputs_unfiltered ("\n", gdb_stdlog);
2246
}
2247
}
2248
2249
2250
/* Print a variable number of ARGS using format FORMAT. If this
2251
information is going to put the amount written (since the last call
2252
to REINITIALIZE_MORE_FILTER or the last page break) over the page size,
2253
call prompt_for_continue to get the users permision to continue.
2254
2255
Unlike fprintf, this function does not return a value.
2256
2257
We implement three variants, vfprintf (takes a vararg list and stream),
2258
fprintf (takes a stream to write on), and printf (the usual).
2259
2260
Note also that a longjmp to top level may occur in this routine
2261
(since prompt_for_continue may do so) so this routine should not be
2262
called when cleanups are not in place. */
2263
2264
static void
2265
vfprintf_maybe_filtered (struct ui_file *stream, const char *format,
2266
va_list args, int filter)
2267
{
2268
char *linebuffer;
2269
struct cleanup *old_cleanups;
2270
2271
xvasprintf (&linebuffer, format, args);
2272
old_cleanups = make_cleanup (xfree, linebuffer);
2273
fputs_maybe_filtered (linebuffer, stream, filter);
2274
do_cleanups (old_cleanups);
2275
}
2276
2277
2278
void
2279
vfprintf_filtered (struct ui_file *stream, const char *format, va_list args)
2280
{
2281
vfprintf_maybe_filtered (stream, format, args, 1);
2282
}
2283
2284
void
2285
vfprintf_unfiltered (struct ui_file *stream, const char *format, va_list args)
2286
{
2287
char *linebuffer;
2288
struct cleanup *old_cleanups;
2289
2290
xvasprintf (&linebuffer, format, args);
2291
old_cleanups = make_cleanup (xfree, linebuffer);
2292
fputs_unfiltered (linebuffer, stream);
2293
do_cleanups (old_cleanups);
2294
}
2295
2296
void
2297
vprintf_filtered (const char *format, va_list args)
2298
{
2299
vfprintf_maybe_filtered (gdb_stdout, format, args, 1);
2300
}
2301
2302
void
2303
vprintf_unfiltered (const char *format, va_list args)
2304
{
2305
vfprintf_unfiltered (gdb_stdout, format, args);
2306
}
2307
2308
void
2309
fprintf_filtered (struct ui_file *stream, const char *format, ...)
2310
{
2311
va_list args;
2312
va_start (args, format);
2313
vfprintf_filtered (stream, format, args);
2314
va_end (args);
2315
}
2316
2317
void
2318
fprintf_unfiltered (struct ui_file *stream, const char *format, ...)
2319
{
2320
va_list args;
2321
va_start (args, format);
2322
vfprintf_unfiltered (stream, format, args);
2323
va_end (args);
2324
}
2325
2326
/* Like fprintf_filtered, but prints its result indented.
2327
Called as fprintfi_filtered (spaces, stream, format, ...); */
2328
2329
void
2330
fprintfi_filtered (int spaces, struct ui_file *stream, const char *format,
2331
...)
2332
{
2333
va_list args;
2334
va_start (args, format);
2335
print_spaces_filtered (spaces, stream);
2336
2337
vfprintf_filtered (stream, format, args);
2338
va_end (args);
2339
}
2340
2341
2342
void
2343
printf_filtered (const char *format, ...)
2344
{
2345
va_list args;
2346
va_start (args, format);
2347
vfprintf_filtered (gdb_stdout, format, args);
2348
va_end (args);
2349
}
2350
2351
2352
void
2353
printf_unfiltered (const char *format, ...)
2354
{
2355
va_list args;
2356
va_start (args, format);
2357
vfprintf_unfiltered (gdb_stdout, format, args);
2358
va_end (args);
2359
}
2360
2361
/* Like printf_filtered, but prints it's result indented.
2362
Called as printfi_filtered (spaces, format, ...); */
2363
2364
void
2365
printfi_filtered (int spaces, const char *format, ...)
2366
{
2367
va_list args;
2368
va_start (args, format);
2369
print_spaces_filtered (spaces, gdb_stdout);
2370
vfprintf_filtered (gdb_stdout, format, args);
2371
va_end (args);
2372
}
2373
2374
/* Easy -- but watch out!
2375
2376
This routine is *not* a replacement for puts()! puts() appends a newline.
2377
This one doesn't, and had better not! */
2378
2379
void
2380
puts_filtered (const char *string)
2381
{
2382
fputs_filtered (string, gdb_stdout);
2383
}
2384
2385
void
2386
puts_unfiltered (const char *string)
2387
{
2388
fputs_unfiltered (string, gdb_stdout);
2389
}
2390
2391
/* Return a pointer to N spaces and a null. The pointer is good
2392
until the next call to here. */
2393
char *
2394
n_spaces (int n)
2395
{
2396
char *t;
2397
static char *spaces = 0;
2398
static int max_spaces = -1;
2399
2400
if (n > max_spaces)
2401
{
2402
if (spaces)
2403
xfree (spaces);
2404
spaces = (char *) xmalloc (n + 1);
2405
for (t = spaces + n; t != spaces;)
2406
*--t = ' ';
2407
spaces[n] = '\0';
2408
max_spaces = n;
2409
}
2410
2411
return spaces + max_spaces - n;
2412
}
2413
2414
/* Print N spaces. */
2415
void
2416
print_spaces_filtered (int n, struct ui_file *stream)
2417
{
2418
fputs_filtered (n_spaces (n), stream);
2419
}
2420
2421
/* C++/ObjC demangler stuff. */
2422
2423
/* fprintf_symbol_filtered attempts to demangle NAME, a symbol in language
2424
LANG, using demangling args ARG_MODE, and print it filtered to STREAM.
2425
If the name is not mangled, or the language for the name is unknown, or
2426
demangling is off, the name is printed in its "raw" form. */
2427
2428
void
2429
fprintf_symbol_filtered (struct ui_file *stream, char *name,
2430
enum language lang, int arg_mode)
2431
{
2432
char *demangled;
2433
2434
if (name != NULL)
2435
{
2436
/* If user wants to see raw output, no problem. */
2437
if (!demangle)
2438
{
2439
fputs_filtered (name, stream);
2440
}
2441
else
2442
{
2443
demangled = language_demangle (language_def (lang), name, arg_mode);
2444
fputs_filtered (demangled ? demangled : name, stream);
2445
if (demangled != NULL)
2446
{
2447
xfree (demangled);
2448
}
2449
}
2450
}
2451
}
2452
2453
/* Do a strcmp() type operation on STRING1 and STRING2, ignoring any
2454
differences in whitespace. Returns 0 if they match, non-zero if they
2455
don't (slightly different than strcmp()'s range of return values).
2456
2457
As an extra hack, string1=="FOO(ARGS)" matches string2=="FOO".
2458
This "feature" is useful when searching for matching C++ function names
2459
(such as if the user types 'break FOO', where FOO is a mangled C++
2460
function). */
2461
2462
int
2463
strcmp_iw (const char *string1, const char *string2)
2464
{
2465
while ((*string1 != '\0') && (*string2 != '\0'))
2466
{
2467
while (isspace (*string1))
2468
{
2469
string1++;
2470
}
2471
while (isspace (*string2))
2472
{
2473
string2++;
2474
}
2475
if (*string1 != *string2)
2476
{
2477
break;
2478
}
2479
if (*string1 != '\0')
2480
{
2481
string1++;
2482
string2++;
2483
}
2484
}
2485
return (*string1 != '\0' && *string1 != '(') || (*string2 != '\0');
2486
}
2487
2488
/* This is like strcmp except that it ignores whitespace and treats
2489
'(' as the first non-NULL character in terms of ordering. Like
2490
strcmp (and unlike strcmp_iw), it returns negative if STRING1 <
2491
STRING2, 0 if STRING2 = STRING2, and positive if STRING1 > STRING2
2492
according to that ordering.
2493
2494
If a list is sorted according to this function and if you want to
2495
find names in the list that match some fixed NAME according to
2496
strcmp_iw(LIST_ELT, NAME), then the place to start looking is right
2497
where this function would put NAME.
2498
2499
Here are some examples of why using strcmp to sort is a bad idea:
2500
2501
Whitespace example:
2502
2503
Say your partial symtab contains: "foo<char *>", "goo". Then, if
2504
we try to do a search for "foo<char*>", strcmp will locate this
2505
after "foo<char *>" and before "goo". Then lookup_partial_symbol
2506
will start looking at strings beginning with "goo", and will never
2507
see the correct match of "foo<char *>".
2508
2509
Parenthesis example:
2510
2511
In practice, this is less like to be an issue, but I'll give it a
2512
shot. Let's assume that '$' is a legitimate character to occur in
2513
symbols. (Which may well even be the case on some systems.) Then
2514
say that the partial symbol table contains "foo$" and "foo(int)".
2515
strcmp will put them in this order, since '$' < '('. Now, if the
2516
user searches for "foo", then strcmp will sort "foo" before "foo$".
2517
Then lookup_partial_symbol will notice that strcmp_iw("foo$",
2518
"foo") is false, so it won't proceed to the actual match of
2519
"foo(int)" with "foo". */
2520
2521
int
2522
strcmp_iw_ordered (const char *string1, const char *string2)
2523
{
2524
while ((*string1 != '\0') && (*string2 != '\0'))
2525
{
2526
while (isspace (*string1))
2527
{
2528
string1++;
2529
}
2530
while (isspace (*string2))
2531
{
2532
string2++;
2533
}
2534
if (*string1 != *string2)
2535
{
2536
break;
2537
}
2538
if (*string1 != '\0')
2539
{
2540
string1++;
2541
string2++;
2542
}
2543
}
2544
2545
switch (*string1)
2546
{
2547
/* Characters are non-equal unless they're both '\0'; we want to
2548
make sure we get the comparison right according to our
2549
comparison in the cases where one of them is '\0' or '('. */
2550
case '\0':
2551
if (*string2 == '\0')
2552
return 0;
2553
else
2554
return -1;
2555
case '(':
2556
if (*string2 == '\0')
2557
return 1;
2558
else
2559
return -1;
2560
default:
2561
if (*string2 == '(')
2562
return 1;
2563
else
2564
return *string1 - *string2;
2565
}
2566
}
2567
2568
/* A simple comparison function with opposite semantics to strcmp. */
2569
2570
int
2571
streq (const char *lhs, const char *rhs)
2572
{
2573
return !strcmp (lhs, rhs);
2574
}
2575
2576
2577
/*
2578
** subset_compare()
2579
** Answer whether string_to_compare is a full or partial match to
2580
** template_string. The partial match must be in sequence starting
2581
** at index 0.
2582
*/
2583
int
2584
subset_compare (char *string_to_compare, char *template_string)
2585
{
2586
int match;
2587
if (template_string != (char *) NULL && string_to_compare != (char *) NULL
2588
&& strlen (string_to_compare) <= strlen (template_string))
2589
match =
2590
(strncmp
2591
(template_string, string_to_compare, strlen (string_to_compare)) == 0);
2592
else
2593
match = 0;
2594
return match;
2595
}
2596
2597
2598
static void pagination_on_command (char *arg, int from_tty);
2599
static void
2600
pagination_on_command (char *arg, int from_tty)
2601
{
2602
pagination_enabled = 1;
2603
}
2604
2605
static void pagination_on_command (char *arg, int from_tty);
2606
static void
2607
pagination_off_command (char *arg, int from_tty)
2608
{
2609
pagination_enabled = 0;
2610
}
2611
2612
2613
void
2614
initialize_utils (void)
2615
{
2616
struct cmd_list_element *c;
2617
2618
c = add_set_cmd ("width", class_support, var_uinteger, &chars_per_line,
2619
"Set number of characters gdb thinks are in a line.",
2620
&setlist);
2621
add_show_from_set (c, &showlist);
2622
set_cmd_sfunc (c, set_width_command);
2623
2624
c = add_set_cmd ("height", class_support, var_uinteger, &lines_per_page,
2625
"Set number of lines gdb thinks are in a page.", &setlist);
2626
add_show_from_set (c, &showlist);
2627
set_cmd_sfunc (c, set_height_command);
2628
2629
init_page_info ();
2630
2631
add_show_from_set
2632
(add_set_cmd ("demangle", class_support, var_boolean,
2633
(char *) &demangle,
2634
"Set demangling of encoded C++/ObjC names when displaying symbols.",
2635
&setprintlist), &showprintlist);
2636
2637
add_show_from_set
2638
(add_set_cmd ("pagination", class_support,
2639
var_boolean, (char *) &pagination_enabled,
2640
"Set state of pagination.", &setlist), &showlist);
2641
2642
if (xdb_commands)
2643
{
2644
add_com ("am", class_support, pagination_on_command,
2645
"Enable pagination");
2646
add_com ("sm", class_support, pagination_off_command,
2647
"Disable pagination");
2648
}
2649
2650
add_show_from_set
2651
(add_set_cmd ("sevenbit-strings", class_support, var_boolean,
2652
(char *) &sevenbit_strings,
2653
"Set printing of 8-bit characters in strings as \\nnn.",
2654
&setprintlist), &showprintlist);
2655
2656
add_show_from_set
2657
(add_set_cmd ("asm-demangle", class_support, var_boolean,
2658
(char *) &asm_demangle,
2659
"Set demangling of C++/ObjC names in disassembly listings.",
2660
&setprintlist), &showprintlist);
2661
}
2662
2663
/* Machine specific function to handle SIGWINCH signal. */
2664
2665
#ifdef SIGWINCH_HANDLER_BODY
2666
SIGWINCH_HANDLER_BODY
2667
#endif
2668
/* print routines to handle variable size regs, etc. */
2669
/* temporary storage using circular buffer */
2670
#define NUMCELLS 16
2671
#define CELLSIZE 32
2672
static char *
2673
get_cell (void)
2674
{
2675
static char buf[NUMCELLS][CELLSIZE];
2676
static int cell = 0;
2677
if (++cell >= NUMCELLS)
2678
cell = 0;
2679
return buf[cell];
2680
}
2681
2682
int
2683
strlen_paddr (void)
2684
{
2685
return (TARGET_ADDR_BIT / 8 * 2);
2686
}
2687
2688
char *
2689
paddr (CORE_ADDR addr)
2690
{
2691
return phex (addr, TARGET_ADDR_BIT / 8);
2692
}
2693
2694
char *
2695
paddr_nz (CORE_ADDR addr)
2696
{
2697
return phex_nz (addr, TARGET_ADDR_BIT / 8);
2698
}
2699
2700
static void
2701
decimal2str (char *paddr_str, char *sign, ULONGEST addr)
2702
{
2703
/* steal code from valprint.c:print_decimal(). Should this worry
2704
about the real size of addr as the above does? */
2705
unsigned long temp[3];
2706
int i = 0;
2707
do
2708
{
2709
temp[i] = addr % (1000 * 1000 * 1000);
2710
addr /= (1000 * 1000 * 1000);
2711
i++;
2712
}
2713
while (addr != 0 && i < (sizeof (temp) / sizeof (temp[0])));
2714
switch (i)
2715
{
2716
case 1:
2717
sprintf (paddr_str, "%s%lu", sign, temp[0]);
2718
break;
2719
case 2:
2720
sprintf (paddr_str, "%s%lu%09lu", sign, temp[1], temp[0]);
2721
break;
2722
case 3:
2723
sprintf (paddr_str, "%s%lu%09lu%09lu", sign, temp[2], temp[1], temp[0]);
2724
break;
2725
default:
2726
internal_error (__FILE__, __LINE__,
2727
"failed internal consistency check");
2728
}
2729
}
2730
2731
char *
2732
paddr_u (CORE_ADDR addr)
2733
{
2734
char *paddr_str = get_cell ();
2735
decimal2str (paddr_str, "", addr);
2736
return paddr_str;
2737
}
2738
2739
char *
2740
paddr_d (LONGEST addr)
2741
{
2742
char *paddr_str = get_cell ();
2743
if (addr < 0)
2744
decimal2str (paddr_str, "-", -addr);
2745
else
2746
decimal2str (paddr_str, "", addr);
2747
return paddr_str;
2748
}
2749
2750
/* eliminate warning from compiler on 32-bit systems */
2751
static int thirty_two = 32;
2752
2753
char *
2754
phex (ULONGEST l, int sizeof_l)
2755
{
2756
char *str;
2757
switch (sizeof_l)
2758
{
2759
case 8:
2760
str = get_cell ();
2761
sprintf (str, "%08lx%08lx",
2762
(unsigned long) (l >> thirty_two),
2763
(unsigned long) (l & 0xffffffff));
2764
break;
2765
case 4:
2766
str = get_cell ();
2767
sprintf (str, "%08lx", (unsigned long) l);
2768
break;
2769
case 2:
2770
str = get_cell ();
2771
sprintf (str, "%04x", (unsigned short) (l & 0xffff));
2772
break;
2773
default:
2774
str = phex (l, sizeof (l));
2775
break;
2776
}
2777
return str;
2778
}
2779
2780
char *
2781
phex_nz (ULONGEST l, int sizeof_l)
2782
{
2783
char *str;
2784
switch (sizeof_l)
2785
{
2786
case 8:
2787
{
2788
unsigned long high = (unsigned long) (l >> thirty_two);
2789
str = get_cell ();
2790
if (high == 0)
2791
sprintf (str, "%lx", (unsigned long) (l & 0xffffffff));
2792
else
2793
sprintf (str, "%lx%08lx", high, (unsigned long) (l & 0xffffffff));
2794
break;
2795
}
2796
case 4:
2797
str = get_cell ();
2798
sprintf (str, "%lx", (unsigned long) l);
2799
break;
2800
case 2:
2801
str = get_cell ();
2802
sprintf (str, "%x", (unsigned short) (l & 0xffff));
2803
break;
2804
default:
2805
str = phex_nz (l, sizeof (l));
2806
break;
2807
}
2808
return str;
2809
}
2810
2811
2812
/* Convert a CORE_ADDR into a string. */
2813
const char *
2814
core_addr_to_string (const CORE_ADDR addr)
2815
{
2816
char *str = get_cell ();
2817
strcpy (str, "0x");
2818
strcat (str, phex (addr, sizeof (addr)));
2819
return str;
2820
}
2821
2822
const char *
2823
core_addr_to_string_nz (const CORE_ADDR addr)
2824
{
2825
char *str = get_cell ();
2826
strcpy (str, "0x");
2827
strcat (str, phex_nz (addr, sizeof (addr)));
2828
return str;
2829
}
2830
2831
/* Convert a string back into a CORE_ADDR. */
2832
CORE_ADDR
2833
string_to_core_addr (const char *my_string)
2834
{
2835
CORE_ADDR addr = 0;
2836
if (my_string[0] == '0' && tolower (my_string[1]) == 'x')
2837
{
2838
/* Assume that it is in decimal. */
2839
int i;
2840
for (i = 2; my_string[i] != '\0'; i++)
2841
{
2842
if (isdigit (my_string[i]))
2843
addr = (my_string[i] - '0') + (addr * 16);
2844
else if (isxdigit (my_string[i]))
2845
addr = (tolower (my_string[i]) - 'a' + 0xa) + (addr * 16);
2846
else
2847
internal_error (__FILE__, __LINE__, "invalid hex");
2848
}
2849
}
2850
else
2851
{
2852
/* Assume that it is in decimal. */
2853
int i;
2854
for (i = 0; my_string[i] != '\0'; i++)
2855
{
2856
if (isdigit (my_string[i]))
2857
addr = (my_string[i] - '0') + (addr * 10);
2858
else
2859
internal_error (__FILE__, __LINE__, "invalid decimal");
2860
}
2861
}
2862
return addr;
2863
}
2864
2865
char *
2866
gdb_realpath (const char *filename)
2867
{
2868
/* Method 1: The system has a compile time upper bound on a filename
2869
path. Use that and realpath() to canonicalize the name. This is
2870
the most common case. Note that, if there isn't a compile time
2871
upper bound, you want to avoid realpath() at all costs. */
2872
#if defined(HAVE_REALPATH)
2873
{
2874
# if defined (PATH_MAX)
2875
char buf[PATH_MAX];
2876
# define USE_REALPATH
2877
# elif defined (MAXPATHLEN)
2878
char buf[MAXPATHLEN];
2879
# define USE_REALPATH
2880
# endif
2881
# if defined (USE_REALPATH)
2882
const char *rp = realpath (filename, buf);
2883
if (rp == NULL)
2884
rp = filename;
2885
return xstrdup (rp);
2886
# endif
2887
}
2888
#endif /* HAVE_REALPATH */
2889
2890
/* Method 2: The host system (i.e., GNU) has the function
2891
canonicalize_file_name() which malloc's a chunk of memory and
2892
returns that, use that. */
2893
#if defined(HAVE_CANONICALIZE_FILE_NAME)
2894
{
2895
char *rp = canonicalize_file_name (filename);
2896
if (rp == NULL)
2897
return xstrdup (filename);
2898
else
2899
return rp;
2900
}
2901
#endif
2902
2903
/* FIXME: cagney/2002-11-13:
2904
2905
Method 2a: Use realpath() with a NULL buffer. Some systems, due
2906
to the problems described in in method 3, have modified their
2907
realpath() implementation so that it will allocate a buffer when
2908
NULL is passed in. Before this can be used, though, some sort of
2909
configure time test would need to be added. Otherwize the code
2910
will likely core dump. */
2911
2912
/* Method 3: Now we're getting desperate! The system doesn't have a
2913
compile time buffer size and no alternative function. Query the
2914
OS, using pathconf(), for the buffer limit. Care is needed
2915
though, some systems do not limit PATH_MAX (return -1 for
2916
pathconf()) making it impossible to pass a correctly sized buffer
2917
to realpath() (it could always overflow). On those systems, we
2918
skip this. */
2919
#if defined (HAVE_REALPATH) && defined (HAVE_UNISTD_H) && defined(HAVE_ALLOCA)
2920
{
2921
/* Find out the max path size. */
2922
long path_max = pathconf ("/", _PC_PATH_MAX);
2923
if (path_max > 0)
2924
{
2925
/* PATH_MAX is bounded. */
2926
char *buf = alloca (path_max);
2927
char *rp = realpath (filename, buf);
2928
return xstrdup (rp ? rp : filename);
2929
}
2930
}
2931
#endif
2932
2933
/* This system is a lost cause, just dup the buffer. */
2934
return xstrdup (filename);
2935
}
2936
2937
/* Return a copy of FILENAME, with its directory prefix canonicalized
2938
by gdb_realpath. */
2939
2940
char *
2941
xfullpath (const char *filename)
2942
{
2943
const char *base_name = lbasename (filename);
2944
char *dir_name;
2945
char *real_path;
2946
char *result;
2947
2948
/* Extract the basename of filename, and return immediately
2949
a copy of filename if it does not contain any directory prefix. */
2950
if (base_name == filename)
2951
return xstrdup (filename);
2952
2953
dir_name = alloca ((size_t) (base_name - filename + 2));
2954
/* Allocate enough space to store the dir_name + plus one extra
2955
character sometimes needed under Windows (see below), and
2956
then the closing \000 character */
2957
strncpy (dir_name, filename, base_name - filename);
2958
dir_name[base_name - filename] = '\000';
2959
2960
#ifdef HAVE_DOS_BASED_FILE_SYSTEM
2961
/* We need to be careful when filename is of the form 'd:foo', which
2962
is equivalent of d:./foo, which is totally different from d:/foo. */
2963
if (strlen (dir_name) == 2 && isalpha (dir_name[0]) && dir_name[1] == ':')
2964
{
2965
dir_name[2] = '.';
2966
dir_name[3] = '\000';
2967
}
2968
#endif
2969
2970
/* Canonicalize the directory prefix, and build the resulting
2971
filename. If the dirname realpath already contains an ending
2972
directory separator, avoid doubling it. */
2973
real_path = gdb_realpath (dir_name);
2974
if (IS_DIR_SEPARATOR (real_path[strlen (real_path) - 1]))
2975
result = concat (real_path, base_name, NULL);
2976
else
2977
result = concat (real_path, SLASH_STRING, base_name, NULL);
2978
2979
xfree (real_path);
2980
return result;
2981
}
2982
2983
2984
/* This is the 32-bit CRC function used by the GNU separate debug
2985
facility. An executable may contain a section named
2986
.gnu_debuglink, which holds the name of a separate executable file
2987
containing its debug info, and a checksum of that file's contents,
2988
computed using this function. */
2989
unsigned long
2990
gnu_debuglink_crc32 (unsigned long crc, unsigned char *buf, size_t len)
2991
{
2992
static const unsigned long crc32_table[256] = {
2993
0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
2994
0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
2995
0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
2996
0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
2997
0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
2998
0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
2999
0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
3000
0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
3001
0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
3002
0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
3003
0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
3004
0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
3005
0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
3006
0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
3007
0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
3008
0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
3009
0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
3010
0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
3011
0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
3012
0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
3013
0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
3014
0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
3015
0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
3016
0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
3017
0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
3018
0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
3019
0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
3020
0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
3021
0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
3022
0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
3023
0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
3024
0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
3025
0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
3026
0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
3027
0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
3028
0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
3029
0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
3030
0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
3031
0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
3032
0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
3033
0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
3034
0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
3035
0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
3036
0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
3037
0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
3038
0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
3039
0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
3040
0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
3041
0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
3042
0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
3043
0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
3044
0x2d02ef8d
3045
};
3046
unsigned char *end;
3047
3048
crc = ~crc & 0xffffffff;
3049
for (end = buf + len; buf < end; ++buf)
3050
crc = crc32_table[(crc ^ *buf) & 0xff] ^ (crc >> 8);
3051
return ~crc & 0xffffffff;;
3052
}
3053
3054
ULONGEST
3055
align_up (ULONGEST v, int n)
3056
{
3057
/* Check that N is really a power of two. */
3058
gdb_assert (n && (n & (n-1)) == 0);
3059
return (v + n - 1) & -n;
3060
}
3061
3062
ULONGEST
3063
align_down (ULONGEST v, int n)
3064
{
3065
/* Check that N is really a power of two. */
3066
gdb_assert (n && (n & (n-1)) == 0);
3067
return (v & -n);
3068
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.1