#include "annotate.h"
#include "symfile.h"
#include "objfiles.h"
+#include "linespec.h"
#ifdef UI_OUT
#include "ui-out.h"
#endif
{
if (b->cond)
{
- free ((PTR) b->cond);
+ xfree (b->cond);
b->cond = 0;
}
if (b->cond_string != NULL)
- free ((PTR) b->cond_string);
+ xfree (b->cond_string);
if (*p == 0)
{
/* Check to see if breakpoint is in an overlay section;
if so, we should remove the breakpoint at the LMA address.
If that is not equal to the raw address, then we should
- presumable remove the breakpoint there as well. */
+ presumably remove the breakpoint there as well. */
if (overlay_debugging && b->section &&
section_is_overlay (b->section))
{
q = p->next;
if (p->old_val != NULL)
value_free (p->old_val);
- free ((PTR) p);
+ xfree (p);
p = q;
}
*bsp = NULL;
back and decide something of a lower priority is better. The
ordering is:
- kc < clr sgl shl slr sn sr ss ts
+ kc < clr sgl shl shlr slr sn sr ss ts
sgl < clrs shl shlr slr sn sr ss ts
slr < err shl shlr sn sr ss ts
clr < clrs err shl shlr sn sr ss ts
catchpoint triggers. Clients who may wish to know the name
later must get it from the catchpoint itself.) */
if (ep->triggered_dll_pathname != NULL)
- free (ep->triggered_dll_pathname);
+ xfree (ep->triggered_dll_pathname);
if (ep->type == bp_catch_load)
dll_pathname = SOLIB_LOADED_LIBRARY_PATHNAME (inferior_pid);
else
int bnum = -1;
if (bnum_exp)
- bnum = parse_and_eval_address (bnum_exp);
+ bnum = parse_and_eval_long (bnum_exp);
breakpoint_1 (bnum, 0);
}
int bnum = -1;
if (bnum_exp)
- bnum = parse_and_eval_address (bnum_exp);
+ bnum = parse_and_eval_long (bnum_exp);
breakpoint_1 (bnum, 1);
}
/* Make sure that all storage allocated in decode_line_1 gets freed
in case the following errors out. */
- old_chain = make_cleanup (free, sals.sals);
+ old_chain = make_cleanup (xfree, sals.sals);
if (canonical != (char **) NULL)
{
- make_cleanup (free, canonical);
+ make_cleanup (xfree, canonical);
canonical_strings_chain = make_cleanup (null_cleanup, 0);
if (canonical[0] != NULL)
- make_cleanup (free, canonical[0]);
+ make_cleanup (xfree, canonical[0]);
}
resolve_sal_pc (&sals.sals[0]);
old_chain = make_cleanup (null_cleanup, 0);
/* Make sure that all storage allocated to SALS gets freed. */
- make_cleanup (free, sals.sals);
+ make_cleanup (xfree, sals.sals);
/* Cleanup the addr_string array but not its contents. */
- make_cleanup (free, addr_string);
+ make_cleanup (xfree, addr_string);
/* Allocate space for all the cond expressions. */
cond = xcalloc (sals.nelts, sizeof (struct expression *));
- make_cleanup (free, cond);
+ make_cleanup (xfree, cond);
/* Allocate space for all the cond strings. */
cond_string = xcalloc (sals.nelts, sizeof (char **));
- make_cleanup (free, cond_string);
+ make_cleanup (xfree, cond_string);
/* ----------------------------- SNIP -----------------------------
Anything added to the cleanup chain beyond this point is assumed
for (i = 0; i < sals.nelts; i++)
{
if (addr_string[i] != NULL)
- make_cleanup (free, addr_string[i]);
+ make_cleanup (xfree, addr_string[i]);
}
/* Resolve all line numbers to PC's and verify that the addresses
{
tok = cond_start = end_tok + 1;
cond[i] = parse_exp_1 (&tok, block_for_pc (sals.sals[i].pc), 0);
- make_cleanup (free, cond[i]);
+ make_cleanup (xfree, cond[i]);
cond_end = tok;
cond_string[i] = savestring (cond_start, cond_end - cond_start);
- make_cleanup (free, cond_string[i]);
+ make_cleanup (xfree, cond_string[i]);
}
else if (toklen >= 1 && strncmp (tok, "thread", toklen) == 0)
{
old_chain = make_cleanup (null_cleanup, 0);
/* Always have a addr_string array, even if it is empty. */
- make_cleanup (free, addr_string);
+ make_cleanup (xfree, addr_string);
/* Make sure that all storage allocated to SALS gets freed. */
- make_cleanup (free, sals.sals);
+ make_cleanup (xfree, sals.sals);
/* Allocate space for all the cond expressions. */
cond = xcalloc (sals.nelts, sizeof (struct expression *));
- make_cleanup (free, cond);
+ make_cleanup (xfree, cond);
/* Allocate space for all the cond strings. */
cond_string = xcalloc (sals.nelts, sizeof (char **));
- make_cleanup (free, cond_string);
+ make_cleanup (xfree, cond_string);
/* ----------------------------- SNIP -----------------------------
Anything added to the cleanup chain beyond this point is assumed
for (i = 0; i < sals.nelts; i++)
{
if (addr_string[i] != NULL)
- make_cleanup (free, addr_string[i]);
+ make_cleanup (xfree, addr_string[i]);
}
/* Wait until now before checking for garbage at the end of the
cond[i] = parse_exp_1 (&tok, block_for_pc (sals.sals[i].pc), 0);
if (*tok != '\0')
error ("Garbage %s follows condition", tok);
- make_cleanup (free, cond[i]);
+ make_cleanup (xfree, cond[i]);
cond_string[i] = xstrdup (args->condition);
}
}
{
struct frame_info *frame;
CORE_ADDR low, high, selected_pc = 0;
- char *extra_args, *level_arg, *addr_string;
+ char *extra_args = NULL;
+ char *level_arg;
+ char *addr_string;
int extra_args_len = 0, if_arg = 0;
if (!arg ||
else
sprintf (addr_string, "*0x%s", paddr_nz (high));
break_command_1 (addr_string, flag, from_tty);
- free (addr_string);
+ xfree (addr_string);
}
else
error ("No function contains the specified address");
struct symtabs_and_lines sals;
struct symtab_and_line sal;
struct cleanup *old_chain;
- char *extra_args;
+ char *extra_args = NULL;
int extra_args_len = 0;
int i, if_arg = 0;
sals = decode_line_1 (&addr_string, 1, (struct symtab *) NULL, 0,
(char ***) NULL);
- free (beg_addr_string);
- old_chain = make_cleanup (free, sals.sals);
+ xfree (beg_addr_string);
+ old_chain = make_cleanup (xfree, sals.sals);
for (i = 0; (i < sals.nelts); i++)
{
sal = sals.sals[i];
else
sprintf (break_string, "*0x%s", paddr_nz (high));
break_command_1 (break_string, flag, from_tty);
- free (break_string);
+ xfree (break_string);
}
else
error ("No function contains the specified address");
error ("Couldn't get information on specified line.");
sal = sals.sals[0];
- free ((PTR) sals.sals); /* malloc'd, so freed */
+ xfree (sals.sals); /* malloc'd, so freed */
if (*arg)
error ("Junk at end of arguments.");
warning ("Multiple breakpoints were set.");
warning ("Use the \"delete\" command to delete unwanted breakpoints.");
}
- free ((PTR) sals.sals);
+ xfree (sals.sals);
}
#if 0
if (from_tty)
putchar_unfiltered ('\n');
}
- free ((PTR) sals.sals);
+ xfree (sals.sals);
}
\f
/* Delete breakpoint in BS if they are `delete' breakpoints and
free_command_lines (&bpt->commands);
if (bpt->cond)
- free (bpt->cond);
+ xfree (bpt->cond);
if (bpt->cond_string != NULL)
- free (bpt->cond_string);
+ xfree (bpt->cond_string);
if (bpt->addr_string != NULL)
- free (bpt->addr_string);
+ xfree (bpt->addr_string);
if (bpt->exp != NULL)
- free (bpt->exp);
+ xfree (bpt->exp);
if (bpt->exp_string != NULL)
- free (bpt->exp_string);
+ xfree (bpt->exp_string);
if (bpt->val != NULL)
value_free (bpt->val);
if (bpt->source_file != NULL)
- free (bpt->source_file);
+ xfree (bpt->source_file);
if (bpt->dll_pathname != NULL)
- free (bpt->dll_pathname);
+ xfree (bpt->dll_pathname);
if (bpt->triggered_dll_pathname != NULL)
- free (bpt->triggered_dll_pathname);
+ xfree (bpt->triggered_dll_pathname);
if (bpt->exec_pathname != NULL)
- free (bpt->exec_pathname);
+ xfree (bpt->exec_pathname);
/* Be sure no bpstat's are pointing at it after it's been freed. */
/* FIXME, how can we find all bpstat's?
bp, we mark it as deleted before freeing its storage. */
bpt->type = bp_none;
- free ((PTR) bpt);
+ xfree (bpt);
}
static void
{
s = b->cond_string;
if (b->cond)
- free ((PTR) b->cond);
+ xfree (b->cond);
b->cond = parse_exp_1 (&s, block_for_pc (sals.sals[i].pc), 0);
}
)
{
if (b->source_file != NULL)
- free (b->source_file);
+ xfree (b->source_file);
if (sals.sals[i].symtab == NULL)
b->source_file = NULL;
else
check_duplicates (b->address, b->section);
}
- free ((PTR) sals.sals);
+ xfree (sals.sals);
break;
case bp_watchpoint:
/* So for now, just use a global context. */
if (b->exp)
- free ((PTR) b->exp);
+ xfree (b->exp);
b->exp = parse_expression (b->exp_string);
b->exp_valid_block = innermost_block;
mark = value_mark ();
{
s = b->cond_string;
if (b->cond)
- free ((PTR) b->cond);
+ xfree (b->cond);
b->cond = parse_exp_1 (&s, (struct block *) 0, 0);
}
if (b->enable == enabled)