1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
|
GDB Internals documentation
This needs to be wrapped in texinfo stuff...
Cleanups
Cleanups are a structured way to deal with things that need to be done
later. When your code does something (like malloc some memory, or open
a file) that needs to be undone later (e.g. free the memory or close
the file), it can make a cleanup. The cleanup will be done at some
future point: when the command is finished, when an error occurs, or
when your code decides it's time to do cleanups.
You can also discard cleanups, that is, throw them away without doing
what they say. This is only done if you ask that it be done.
Syntax:
old_chain = make_cleanup (function, arg);
This makes a cleanup which will cause FUNCTION to be called with ARG
(a char *) later. The result, OLD_CHAIN, is a handle that can be
passed to do_cleanups or discard_cleanups later. Unless you are
going to call do_cleanups or discard_cleanups yourself,
you can ignore the result from make_cleanup.
do_cleanups (old_chain);
Performs all cleanups done since make_cleanup returned OLD_CHAIN.
E.g.: make_cleanup (a, 0); old = make_cleanup (b, 0); do_cleanups (old);
will call b() but will not call a(). The cleanup that calls a() will remain
in the cleanup chain, and will be done later unless otherwise discarded.
discard_cleanups (old_chain);
Same as do_cleanups except that it just removes the cleanups from the
chain and does not call the specified functions.
Some functions, e.g. fputs_filtered() or error(), specify that they
"should not be called when cleanups are not in place". This means
that any actions you need to reverse in the case of an error or
interruption must be on the cleanup chain before you call these functions,
since they might never return to your code (they "longjmp" instead).
Wrapping output lines
Output that goes through printf_filtered or fputs_filtered or
fputs_demangled needs only to have calls to wrap_here() added
in places that would be good breaking points. The utility routines
will take care of actually wrapping if the line width is exceeded.
The argument to wrap_here() is an indentation string which is printed
ONLY if the line breaks there. This argument is saved away and used
later. It must remain valid until the next call to wrap_here() or
until a newline has been printed through the *_filtered functions.
Don't pass in a local variable and then return!
It is usually best to call wrap_here() after printing a comma or space.
If you call it before printing a space, make sure that your indentation
properly accounts for the leading space that will print if the line wraps
there.
Configuring GDB for release
GDB should be released after doing "config.gdb none" in the top level
directory. This will leave a makefile there, but no tm- or xm- files.
The makefile is needed, for example, for "make gdb.tar.Z"... If you
have tm- or xm-files in the main source directory, C's include rules
cause them to be used in preference to tm- and xm-files in the
subdirectories where the user will actually configure and build the
binaries.
"config.gdb none" is also a good way to rebuild the top level Makefile
after changing Makefile.dist, alldeps.mak, etc.
The README file
Check the README file, it often has useful information that does not
appear anywhere else in the directory.
|
