diff options
Diffstat (limited to 'binutils/stabs.c')
| -rw-r--r-- | binutils/stabs.c | 941 |
1 files changed, 476 insertions, 465 deletions
diff --git a/binutils/stabs.c b/binutils/stabs.c index d3efdf1..1ff4f6f 100644 --- a/binutils/stabs.c +++ b/binutils/stabs.c @@ -53,8 +53,8 @@ struct stab_handle { /* The BFD. */ bfd *abfd; - /* True if this is stabs in sections. */ - boolean sections; + /* TRUE if this is stabs in sections. */ + bfd_boolean sections; /* The symbol table. */ asymbol **syms; /* The number of symbols. */ @@ -74,7 +74,7 @@ struct stab_handle int gcc_compiled; /* Whether an N_OPT symbol was seen that was not generated by gcc, so that we can detect the SunPRO compiler. */ - boolean n_opt_found; + bfd_boolean n_opt_found; /* The main file name. */ char *main_filename; /* A stack of unfinished N_BINCL files. */ @@ -82,7 +82,7 @@ struct stab_handle /* A list of finished N_BINCL files. */ struct bincl_file *bincl_list; /* Whether we are inside a function or not. */ - boolean within_function; + bfd_boolean within_function; /* The address of the end of the function, used if we have seen an N_FUN symbol while in a function. This is -1 if we have not seen an N_FUN (the normal case). */ @@ -101,7 +101,7 @@ struct stab_handle struct stab_tag *tags; /* Set by parse_stab_type if it sees a structure defined as a cross reference to itself. Reset by parse_stab_type otherwise. */ - boolean self_crossref; + bfd_boolean self_crossref; }; /* A list of these structures is used to hold pending variable @@ -151,61 +151,70 @@ struct stab_tag debug_type type; }; -static char *savestring PARAMS ((const char *, int)); -static bfd_vma parse_number PARAMS ((const char **, boolean *)); -static void bad_stab PARAMS ((const char *)); -static void warn_stab PARAMS ((const char *, const char *)); -static boolean parse_stab_string +static char *savestring + PARAMS ((const char *, int)); +static bfd_vma parse_number + PARAMS ((const char **, bfd_boolean *)); +static void bad_stab + PARAMS ((const char *)); +static void warn_stab + PARAMS ((const char *, const char *)); +static bfd_boolean parse_stab_string PARAMS ((PTR, struct stab_handle *, int, int, bfd_vma, const char *)); static debug_type parse_stab_type PARAMS ((PTR, struct stab_handle *, const char *, const char **, debug_type **)); -static boolean parse_stab_type_number +static bfd_boolean parse_stab_type_number PARAMS ((const char **, int *)); static debug_type parse_stab_range_type PARAMS ((PTR, struct stab_handle *, const char *, const char **, const int *)); -static debug_type parse_stab_sun_builtin_type PARAMS ((PTR, const char **)); +static debug_type parse_stab_sun_builtin_type + PARAMS ((PTR, const char **)); static debug_type parse_stab_sun_floating_type PARAMS ((PTR, const char **)); -static debug_type parse_stab_enum_type PARAMS ((PTR, const char **)); +static debug_type parse_stab_enum_type + PARAMS ((PTR, const char **)); static debug_type parse_stab_struct_type - PARAMS ((PTR, struct stab_handle *, const char *, const char **, boolean, + PARAMS ((PTR, struct stab_handle *, const char *, const char **, bfd_boolean, const int *)); -static boolean parse_stab_baseclasses +static bfd_boolean parse_stab_baseclasses PARAMS ((PTR, struct stab_handle *, const char **, debug_baseclass **)); -static boolean parse_stab_struct_fields +static bfd_boolean parse_stab_struct_fields PARAMS ((PTR, struct stab_handle *, const char **, debug_field **, - boolean *)); -static boolean parse_stab_cpp_abbrev + bfd_boolean *)); +static bfd_boolean parse_stab_cpp_abbrev PARAMS ((PTR, struct stab_handle *, const char **, debug_field *)); -static boolean parse_stab_one_struct_field +static bfd_boolean parse_stab_one_struct_field PARAMS ((PTR, struct stab_handle *, const char **, const char *, - debug_field *, boolean *)); -static boolean parse_stab_members + debug_field *, bfd_boolean *)); +static bfd_boolean parse_stab_members PARAMS ((PTR, struct stab_handle *, const char *, const char **, const int *, debug_method **)); static debug_type parse_stab_argtypes PARAMS ((PTR, struct stab_handle *, debug_type, const char *, const char *, - debug_type, const char *, boolean, boolean, const char **)); -static boolean parse_stab_tilde_field + debug_type, const char *, bfd_boolean, bfd_boolean, const char **)); +static bfd_boolean parse_stab_tilde_field PARAMS ((PTR, struct stab_handle *, const char **, const int *, - debug_type *, boolean *)); + debug_type *, bfd_boolean *)); static debug_type parse_stab_array_type - PARAMS ((PTR, struct stab_handle *, const char **, boolean)); -static void push_bincl PARAMS ((struct stab_handle *, const char *, bfd_vma)); -static const char *pop_bincl PARAMS ((struct stab_handle *)); -static boolean find_excl + PARAMS ((PTR, struct stab_handle *, const char **, bfd_boolean)); +static void push_bincl + PARAMS ((struct stab_handle *, const char *, bfd_vma)); +static const char *pop_bincl + PARAMS ((struct stab_handle *)); +static bfd_boolean find_excl PARAMS ((struct stab_handle *, const char *, bfd_vma)); -static boolean stab_record_variable +static bfd_boolean stab_record_variable PARAMS ((PTR, struct stab_handle *, const char *, debug_type, enum debug_var_kind, bfd_vma)); -static boolean stab_emit_pending_vars PARAMS ((PTR, struct stab_handle *)); +static bfd_boolean stab_emit_pending_vars + PARAMS ((PTR, struct stab_handle *)); static debug_type *stab_find_slot PARAMS ((struct stab_handle *, const int *)); static debug_type stab_find_type PARAMS ((PTR, struct stab_handle *, const int *)); -static boolean stab_record_type +static bfd_boolean stab_record_type PARAMS ((PTR, struct stab_handle *, const int *, debug_type)); static debug_type stab_xcoff_builtin_type PARAMS ((PTR, struct stab_handle *, int)); @@ -213,7 +222,7 @@ static debug_type stab_find_tagged_type PARAMS ((PTR, struct stab_handle *, const char *, int, enum debug_type_kind)); static debug_type *stab_demangle_argtypes - PARAMS ((PTR, struct stab_handle *, const char *, boolean *, unsigned int)); + PARAMS ((PTR, struct stab_handle *, const char *, bfd_boolean *, unsigned int)); /* Save a string in memory. */ @@ -235,13 +244,13 @@ savestring (start, len) static bfd_vma parse_number (pp, poverflow) const char **pp; - boolean *poverflow; + bfd_boolean *poverflow; { unsigned long ul; const char *orig; if (poverflow != NULL) - *poverflow = false; + *poverflow = FALSE; orig = *pp; @@ -263,22 +272,22 @@ parse_number (pp, poverflow) if (sizeof (bfd_vma) > sizeof (unsigned long)) { const char *p; - boolean neg; + bfd_boolean neg; int base; bfd_vma over, lastdig; - boolean overflow; + bfd_boolean overflow; bfd_vma v; /* Our own version of strtoul, for a bfd_vma. */ p = orig; - neg = false; + neg = FALSE; if (*p == '+') ++p; else if (*p == '-') { - neg = true; + neg = TRUE; ++p; } @@ -300,7 +309,7 @@ parse_number (pp, poverflow) over = ((bfd_vma) (bfd_signed_vma) -1) / (bfd_vma) base; lastdig = ((bfd_vma) (bfd_signed_vma) -1) % (bfd_vma) base; - overflow = false; + overflow = FALSE; v = 0; while (1) { @@ -321,7 +330,7 @@ parse_number (pp, poverflow) if (v > over || (v == over && (bfd_vma) d > lastdig)) { - overflow = true; + overflow = TRUE; break; } } @@ -338,7 +347,7 @@ parse_number (pp, poverflow) bfd_vma. */ if (poverflow != NULL) - *poverflow = true; + *poverflow = TRUE; else warn_stab (orig, _("numeric overflow")); @@ -370,7 +379,7 @@ PTR start_stab (dhandle, abfd, sections, syms, symcount) PTR dhandle ATTRIBUTE_UNUSED; bfd *abfd; - boolean sections; + bfd_boolean sections; asymbol **syms; long symcount; { @@ -392,7 +401,7 @@ start_stab (dhandle, abfd, sections, syms, symcount) /* When we have processed all the stabs information, we need to go through and fill in all the undefined tags. */ -boolean +bfd_boolean finish_stab (dhandle, handle) PTR dhandle; PTR handle; @@ -404,8 +413,8 @@ finish_stab (dhandle, handle) { if (! stab_emit_pending_vars (dhandle, info) || ! debug_end_function (dhandle, info->function_end)) - return false; - info->within_function = false; + return FALSE; + info->within_function = FALSE; info->function_end = (bfd_vma) -1; } @@ -418,15 +427,15 @@ finish_stab (dhandle, handle) kind = DEBUG_KIND_STRUCT; st->slot = debug_make_undefined_tagged_type (dhandle, st->name, kind); if (st->slot == DEBUG_TYPE_NULL) - return false; + return FALSE; } - return true; + return TRUE; } /* Handle a single stabs symbol. */ -boolean +bfd_boolean parse_stab (dhandle, handle, type, desc, value, string) PTR dhandle; PTR handle; @@ -445,11 +454,11 @@ parse_stab (dhandle, handle, type, desc, value, string) && (type != N_SO || *string == '\0' || value != info->so_value)) { if (! debug_set_filename (dhandle, info->so_string)) - return false; + return FALSE; info->main_filename = info->so_string; info->gcc_compiled = 0; - info->n_opt_found = false; + info->n_opt_found = FALSE; /* Generally, for stabs in the symbol table, the N_LBRAC and N_RBRAC symbols are relative to the N_SO symbol value. */ @@ -483,7 +492,7 @@ parse_stab (dhandle, handle, type, desc, value, string) if (! info->within_function) { fprintf (stderr, _("N_LBRAC not within function\n")); - return false; + return FALSE; } /* Start an inner lexical block. */ @@ -491,11 +500,11 @@ parse_stab (dhandle, handle, type, desc, value, string) (value + info->file_start_offset + info->function_start_offset))) - return false; + return FALSE; /* Emit any pending variable definitions. */ if (! stab_emit_pending_vars (dhandle, info)) - return false; + return FALSE; ++info->block_depth; break; @@ -509,20 +518,20 @@ parse_stab (dhandle, handle, type, desc, value, string) if we do, we probably need to emit them before closing the block. */ if (! stab_emit_pending_vars (dhandle, info)) - return false; + return FALSE; /* End an inner lexical block. */ if (! debug_end_block (dhandle, (value + info->file_start_offset + info->function_start_offset))) - return false; + return FALSE; --info->block_depth; if (info->block_depth < 0) { fprintf (stderr, _("Too many N_RBRACs\n")); - return false; + return FALSE; } break; @@ -539,15 +548,15 @@ parse_stab (dhandle, handle, type, desc, value, string) endval = info->function_end; if (! stab_emit_pending_vars (dhandle, info) || ! debug_end_function (dhandle, endval)) - return false; - info->within_function = false; + return FALSE; + info->within_function = FALSE; info->function_end = (bfd_vma) -1; } /* An empty string is emitted by gcc at the end of a compilation unit. */ if (*string == '\0') - return true; + return TRUE; /* Just accumulate strings until we see a non N_SO symbol. If the string starts with a directory separator or some other @@ -576,43 +585,43 @@ parse_stab (dhandle, handle, type, desc, value, string) case N_SOL: /* Start an include file. */ if (! debug_start_source (dhandle, string)) - return false; + return FALSE; break; case N_BINCL: /* Start an include file which may be replaced. */ push_bincl (info, string, value); if (! debug_start_source (dhandle, string)) - return false; + return FALSE; break; case N_EINCL: /* End an N_BINCL include. */ if (! debug_start_source (dhandle, pop_bincl (info))) - return false; + return FALSE; break; case N_EXCL: /* This is a duplicate of a header file named by N_BINCL which was eliminated by the linker. */ if (! find_excl (info, string, value)) - return false; + return FALSE; break; case N_SLINE: if (! debug_record_line (dhandle, desc, value + info->function_start_offset)) - return false; + return FALSE; break; case N_BCOMM: if (! debug_start_common_block (dhandle, string)) - return false; + return FALSE; break; case N_ECOMM: if (! debug_end_common_block (dhandle, string)) - return false; + return FALSE; break; case N_FUN: @@ -626,8 +635,8 @@ parse_stab (dhandle, handle, type, desc, value, string) value += info->function_start_offset; if (! stab_emit_pending_vars (dhandle, info) || ! debug_end_function (dhandle, value)) - return false; - info->within_function = false; + return FALSE; + info->within_function = FALSE; info->function_end = (bfd_vma) -1; } break; @@ -667,18 +676,18 @@ parse_stab (dhandle, handle, type, desc, value, string) endval = info->function_end; if (! stab_emit_pending_vars (dhandle, info) || ! debug_end_function (dhandle, endval)) - return false; + return FALSE; info->function_end = (bfd_vma) -1; } /* For stabs in sections, line numbers and block addresses are offsets from the start of the function. */ if (info->sections) info->function_start_offset = value; - info->within_function = true; + info->within_function = TRUE; } if (! parse_stab_string (dhandle, info, type, desc, value, string)) - return false; + return FALSE; } break; @@ -688,7 +697,7 @@ parse_stab (dhandle, handle, type, desc, value, string) else if (string != NULL && strcmp (string, "gcc_compiled.") == 0) info->gcc_compiled = 1; else - info->n_opt_found = true; + info->n_opt_found = TRUE; break; case N_OBJ: @@ -698,12 +707,12 @@ parse_stab (dhandle, handle, type, desc, value, string) break; } - return true; + return TRUE; } /* Parse the stabs string. */ -static boolean +static bfd_boolean parse_stab_string (dhandle, info, stabtype, desc, value, string) PTR dhandle; struct stab_handle *info; @@ -716,14 +725,14 @@ parse_stab_string (dhandle, info, stabtype, desc, value, string) char *name; int type; debug_type dtype; - boolean synonym; - boolean self_crossref; + bfd_boolean synonym; + bfd_boolean self_crossref; unsigned int lineno; debug_type *slot; p = strchr (string, ':'); if (p == NULL) - return true; + return TRUE; while (p[1] == ':') { @@ -732,7 +741,7 @@ parse_stab_string (dhandle, info, stabtype, desc, value, string) if (p == NULL) { bad_stab (string); - return false; + return FALSE; } } @@ -797,7 +806,7 @@ parse_stab_string (dhandle, info, stabtype, desc, value, string) if (*p != '=') { bad_stab (string); - return false; + return FALSE; } ++p; switch (*p++) @@ -805,7 +814,7 @@ parse_stab_string (dhandle, info, stabtype, desc, value, string) case 'r': /* Floating point constant. */ if (! debug_record_float_const (dhandle, name, atof (p))) - return false; + return FALSE; break; case 'i': /* Integer constant. */ @@ -816,7 +825,7 @@ parse_stab_string (dhandle, info, stabtype, desc, value, string) other languages probably should have at least unsigned as well as signed constants. */ if (! debug_record_int_const (dhandle, name, atoi (p))) - return false; + return FALSE; break; case 'e': /* SYMBOL:c=eTYPE,INTVALUE for a constant symbol whose value @@ -826,18 +835,18 @@ parse_stab_string (dhandle, info, stabtype, desc, value, string) dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p, (debug_type **) NULL); if (dtype == DEBUG_TYPE_NULL) - return false; + return FALSE; if (*p != ',') { bad_stab (string); - return false; + return FALSE; } if (! debug_record_typed_const (dhandle, name, dtype, atoi (p))) - return false; + return FALSE; break; default: bad_stab (string); - return false; + return FALSE; } break; @@ -847,9 +856,9 @@ parse_stab_string (dhandle, info, stabtype, desc, value, string) dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p, (debug_type **) NULL); if (dtype == DEBUG_TYPE_NULL) - return false; + return FALSE; if (! debug_record_label (dhandle, name, dtype, value)) - return false; + return FALSE; break; case 'f': @@ -858,9 +867,9 @@ parse_stab_string (dhandle, info, stabtype, desc, value, string) dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p, (debug_type **) NULL); if (dtype == DEBUG_TYPE_NULL) - return false; + return FALSE; if (! debug_record_function (dhandle, name, dtype, type == 'F', value)) - return false; + return FALSE; /* Sun acc puts declared types of arguments here. We don't care about their actual types (FIXME -- we should remember the whole @@ -872,7 +881,7 @@ parse_stab_string (dhandle, info, stabtype, desc, value, string) if (parse_stab_type (dhandle, info, (const char *) NULL, &p, (debug_type **) NULL) == DEBUG_TYPE_NULL) - return false; + return FALSE; } break; @@ -888,7 +897,7 @@ parse_stab_string (dhandle, info, stabtype, desc, value, string) dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p, (debug_type **) NULL); if (dtype == DEBUG_TYPE_NULL) - return false; + return FALSE; leading = bfd_get_symbol_leading_char (info->abfd); for (c = info->symcount, ps = info->syms; c > 0; --c, ++ps) { @@ -904,7 +913,7 @@ parse_stab_string (dhandle, info, stabtype, desc, value, string) value = bfd_asymbol_value (*ps); if (! stab_record_variable (dhandle, info, name, dtype, DEBUG_GLOBAL, value)) - return false; + return FALSE; } break; @@ -916,10 +925,10 @@ parse_stab_string (dhandle, info, stabtype, desc, value, string) dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p, (debug_type **) NULL); if (dtype == DEBUG_TYPE_NULL) - return false; + return FALSE; if (! stab_record_variable (dhandle, info, name, dtype, DEBUG_LOCAL, value)) - return false; + return FALSE; break; case 'p': @@ -940,15 +949,15 @@ parse_stab_string (dhandle, info, stabtype, desc, value, string) debug_type ftype; ftype = debug_make_function_type (dhandle, dtype, - (debug_type *) NULL, false); + (debug_type *) NULL, FALSE); dtype = debug_make_pointer_type (dhandle, ftype); } } if (dtype == DEBUG_TYPE_NULL) - return false; + return FALSE; if (! debug_record_parameter (dhandle, name, dtype, DEBUG_PARM_STACK, value)) - return false; + return FALSE; /* FIXME: At this point gdb considers rearranging the parameter address on a big endian machine if it is smaller than an int. @@ -967,7 +976,7 @@ parse_stab_string (dhandle, info, stabtype, desc, value, string) if (parse_stab_type (dhandle, info, (const char *) NULL, &p, (debug_type **) NULL) == DEBUG_TYPE_NULL) - return false; + return FALSE; } break; } @@ -977,10 +986,10 @@ parse_stab_string (dhandle, info, stabtype, desc, value, string) dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p, (debug_type **) NULL); if (dtype == DEBUG_TYPE_NULL) - return false; + return FALSE; if (! debug_record_parameter (dhandle, name, dtype, DEBUG_PARM_REG, value)) - return false; + return FALSE; break; case 'r': @@ -988,10 +997,10 @@ parse_stab_string (dhandle, info, stabtype, desc, value, string) dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p, (debug_type **) NULL); if (dtype == DEBUG_TYPE_NULL) - return false; + return FALSE; if (! stab_record_variable (dhandle, info, name, dtype, DEBUG_REGISTER, value)) - return false; + return FALSE; /* FIXME: At this point gdb checks to combine pairs of 'p' and 'r' stabs into a single 'P' stab. */ @@ -1003,26 +1012,26 @@ parse_stab_string (dhandle, info, stabtype, desc, value, string) dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p, (debug_type **) NULL); if (dtype == DEBUG_TYPE_NULL) - return false; + return FALSE; if (! stab_record_variable (dhandle, info, name, dtype, DEBUG_STATIC, value)) - return false; + return FALSE; break; case 't': /* A typedef. */ dtype = parse_stab_type (dhandle, info, name, &p, &slot); if (dtype == DEBUG_TYPE_NULL) - return false; + return FALSE; if (name == NULL) { /* A nameless type. Nothing to do. */ - return true; + return TRUE; } dtype = debug_name_type (dhandle, name, dtype); if (dtype == DEBUG_TYPE_NULL) - return false; + return FALSE; if (slot != NULL) *slot = dtype; @@ -1034,21 +1043,21 @@ parse_stab_string (dhandle, info, stabtype, desc, value, string) by 't' which means we are typedef'ing it as well. */ if (*p != 't') { - synonym = false; - /* FIXME: gdb sets synonym to true if the current language + synonym = FALSE; + /* FIXME: gdb sets synonym to TRUE if the current language is C++. */ } else { - synonym = true; + synonym = TRUE; ++p; } dtype = parse_stab_type (dhandle, info, name, &p, &slot); if (dtype == DEBUG_TYPE_NULL) - return false; + return FALSE; if (name == NULL) - return true; + return TRUE; /* INFO->SELF_CROSSREF is set by parse_stab_type if this type is a cross reference to itself. These are generated by some @@ -1057,7 +1066,7 @@ parse_stab_string (dhandle, info, stabtype, desc, value, string) dtype = debug_tag_type (dhandle, name, dtype); if (dtype == DEBUG_TYPE_NULL) - return false; + return FALSE; if (slot != NULL) *slot = dtype; @@ -1084,7 +1093,7 @@ parse_stab_string (dhandle, info, stabtype, desc, value, string) { dtype = debug_name_type (dhandle, name, dtype); if (dtype == DEBUG_TYPE_NULL) - return false; + return FALSE; if (slot != NULL) *slot = dtype; @@ -1097,11 +1106,11 @@ parse_stab_string (dhandle, info, stabtype, desc, value, string) dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p, (debug_type **) NULL); if (dtype == DEBUG_TYPE_NULL) - return false; + return FALSE; /* FIXME: gdb checks os9k_stabs here. */ if (! stab_record_variable (dhandle, info, name, dtype, DEBUG_LOCAL_STATIC, value)) - return false; + return FALSE; break; case 'v': @@ -1109,10 +1118,10 @@ parse_stab_string (dhandle, info, stabtype, desc, value, string) dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p, (debug_type **) NULL); if (dtype == DEBUG_TYPE_NULL) - return false; + return FALSE; if (! debug_record_parameter (dhandle, name, dtype, DEBUG_PARM_REFERENCE, value)) - return false; + return FALSE; break; case 'a': @@ -1120,10 +1129,10 @@ parse_stab_string (dhandle, info, stabtype, desc, value, string) dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p, (debug_type **) NULL); if (dtype == DEBUG_TYPE_NULL) - return false; + return FALSE; if (! debug_record_parameter (dhandle, name, dtype, DEBUG_PARM_REF_REG, value)) - return false; + return FALSE; break; case 'X': @@ -1134,21 +1143,21 @@ parse_stab_string (dhandle, info, stabtype, desc, value, string) dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p, (debug_type **) NULL); if (dtype == DEBUG_TYPE_NULL) - return false; + return FALSE; if (! stab_record_variable (dhandle, info, name, dtype, DEBUG_LOCAL, value)) - return false; + return FALSE; break; default: bad_stab (string); - return false; + return FALSE; } /* FIXME: gdb converts structure values to structure pointers in a couple of cases, depending upon the target. */ - return true; + return TRUE; } /* Parse a stabs type. The typename argument is non-NULL if this is a @@ -1167,7 +1176,7 @@ parse_stab_type (dhandle, info, typename, pp, slotp) const char *orig; int typenums[2]; int size; - boolean stringp; + bfd_boolean stringp; int descriptor; debug_type dtype; @@ -1177,9 +1186,9 @@ parse_stab_type (dhandle, info, typename, pp, slotp) orig = *pp; size = -1; - stringp = false; + stringp = FALSE; - info->self_crossref = false; + info->self_crossref = FALSE; /* Read type number if present. The type number may be omitted. for instance in a two-dimensional array declared with type @@ -1256,7 +1265,7 @@ parse_stab_type (dhandle, info, typename, pp, slotp) break; case 'S': - stringp = true; + stringp = TRUE; break; default: @@ -1334,7 +1343,7 @@ parse_stab_type (dhandle, info, typename, pp, slotp) if (typename != NULL && strncmp (typename, *pp, p - *pp) == 0 && typename[p - *pp] == '\0') - info->self_crossref = true; + info->self_crossref = TRUE; dtype = stab_find_tagged_type (dhandle, info, *pp, p - *pp, code); @@ -1418,7 +1427,7 @@ parse_stab_type (dhandle, info, typename, pp, slotp) (dhandle, parse_stab_type (dhandle, info, (const char *) NULL, pp, (debug_type **) NULL), - (debug_type *) NULL, false)); + (debug_type *) NULL, FALSE)); break; case 'k': @@ -1489,7 +1498,7 @@ parse_stab_type (dhandle, info, typename, pp, slotp) ++*pp; dtype = debug_make_method_type (dhandle, return_type, DEBUG_TYPE_NULL, - (debug_type *) NULL, false); + (debug_type *) NULL, FALSE); } else { @@ -1498,7 +1507,7 @@ parse_stab_type (dhandle, info, typename, pp, slotp) debug_type *args; unsigned int n; unsigned int alloc; - boolean varargs; + bfd_boolean varargs; domain = parse_stab_type (dhandle, info, (const char *) NULL, pp, (debug_type **) NULL); @@ -1549,11 +1558,11 @@ parse_stab_type (dhandle, info, typename, pp, slotp) the void type. */ if (n == 0 || debug_get_type_kind (dhandle, args[n - 1]) != DEBUG_KIND_VOID) - varargs = true; + varargs = TRUE; else { --n; - varargs = false; + varargs = FALSE; } args[n] = DEBUG_TYPE_NULL; @@ -1640,7 +1649,7 @@ parse_stab_type (dhandle, info, typename, pp, slotp) single number N is equivalent to (0,N). Return the two numbers by storing them in the vector TYPENUMS. */ -static boolean +static bfd_boolean parse_stab_type_number (pp, typenums) const char **pp; int *typenums; @@ -1652,28 +1661,28 @@ parse_stab_type_number (pp, typenums) if (**pp != '(') { typenums[0] = 0; - typenums[1] = (int) parse_number (pp, (boolean *) NULL); + typenums[1] = (int) parse_number (pp, (bfd_boolean *) NULL); } else { ++*pp; - typenums[0] = (int) parse_number (pp, (boolean *) NULL); + typenums[0] = (int) parse_number (pp, (bfd_boolean *) NULL); if (**pp != ',') { bad_stab (orig); - return false; + return FALSE; } ++*pp; - typenums[1] = (int) parse_number (pp, (boolean *) NULL); + typenums[1] = (int) parse_number (pp, (bfd_boolean *) NULL); if (**pp != ')') { bad_stab (orig); - return false; + return FALSE; } ++*pp; } - return true; + return TRUE; } /* Parse a range type. */ @@ -1688,11 +1697,11 @@ parse_stab_range_type (dhandle, info, typename, pp, typenums) { const char *orig; int rangenums[2]; - boolean self_subrange; + bfd_boolean self_subrange; debug_type index_type; const char *s2, *s3; bfd_signed_vma n2, n3; - boolean ov2, ov3; + bfd_boolean ov2, ov3; orig = *pp; @@ -1749,11 +1758,11 @@ parse_stab_range_type (dhandle, info, typename, pp, typenums) { if (strncmp (s2, LLLOW, sizeof LLLOW - 1) == 0 && strncmp (s3, LLHIGH, sizeof LLHIGH - 1) == 0) - return debug_make_int_type (dhandle, 8, false); + return debug_make_int_type (dhandle, 8, FALSE); if (! ov2 && n2 == 0 && strncmp (s3, ULLHIGH, sizeof ULLHIGH - 1) == 0) - return debug_make_int_type (dhandle, 8, true); + return debug_make_int_type (dhandle, 8, TRUE); } warn_stab (orig, _("numeric overflow")); @@ -1786,50 +1795,50 @@ parse_stab_range_type (dhandle, info, typename, pp, typenums) if (typename != NULL) { if (strcmp (typename, "long long int") == 0) - return debug_make_int_type (dhandle, 8, false); + return debug_make_int_type (dhandle, 8, FALSE); else if (strcmp (typename, "long long unsigned int") == 0) - return debug_make_int_type (dhandle, 8, true); + return debug_make_int_type (dhandle, 8, TRUE); } /* FIXME: The size here really depends upon the target. */ - return debug_make_int_type (dhandle, 4, true); + return debug_make_int_type (dhandle, 4, TRUE); } /* A range of 0 to 127 is char. */ if (self_subrange && n2 == 0 && n3 == 127) - return debug_make_int_type (dhandle, 1, false); + return debug_make_int_type (dhandle, 1, FALSE); /* FIXME: gdb checks for the language CHILL here. */ if (n2 == 0) { if (n3 < 0) - return debug_make_int_type (dhandle, - n3, true); + return debug_make_int_type (dhandle, - n3, TRUE); else if (n3 == 0xff) - return debug_make_int_type (dhandle, 1, true); + return debug_make_int_type (dhandle, 1, TRUE); else if (n3 == 0xffff) - return debug_make_int_type (dhandle, 2, true); + return debug_make_int_type (dhandle, 2, TRUE); else if (n3 == (bfd_signed_vma) 0xffffffff) - return debug_make_int_type (dhandle, 4, true); + return debug_make_int_type (dhandle, 4, TRUE); #ifdef BFD64 else if (n3 == ((((bfd_signed_vma) 0xffffffff) << 32) | 0xffffffff)) - return debug_make_int_type (dhandle, 8, true); + return debug_make_int_type (dhandle, 8, TRUE); #endif } else if (n3 == 0 && n2 < 0 && (self_subrange || n2 == -8)) - return debug_make_int_type (dhandle, - n2, true); + return debug_make_int_type (dhandle, - n2, TRUE); else if (n2 == - n3 - 1 || n2 == n3 + 1) { if (n3 == 0x7f) - return debug_make_int_type (dhandle, 1, false); + return debug_make_int_type (dhandle, 1, FALSE); else if (n3 == 0x7fff) - return debug_make_int_type (dhandle, 2, false); + return debug_make_int_type (dhandle, 2, FALSE); else if (n3 == 0x7fffffff) - return debug_make_int_type (dhandle, 4, false); + return debug_make_int_type (dhandle, 4, FALSE); #ifdef BFD64 else if (n3 == ((((bfd_vma) 0x7fffffff) << 32) | 0xffffffff)) - return debug_make_int_type (dhandle, 8, false); + return debug_make_int_type (dhandle, 8, FALSE); #endif } } @@ -1849,7 +1858,7 @@ parse_stab_range_type (dhandle, info, typename, pp, typenums) /* Does this actually ever happen? Is that why we are worrying about dealing with it rather than just calling error_type? */ warn_stab (orig, _("missing index type")); - index_type = debug_make_int_type (dhandle, 4, false); + index_type = debug_make_int_type (dhandle, 4, FALSE); } return debug_make_range_type (dhandle, index_type, n2, n3); @@ -1873,7 +1882,7 @@ parse_stab_sun_builtin_type (dhandle, pp) const char **pp; { const char *orig; - boolean unsignedp; + bfd_boolean unsignedp; bfd_vma bits; orig = *pp; @@ -1881,10 +1890,10 @@ parse_stab_sun_builtin_type (dhandle, pp) switch (**pp) { case 's': - unsignedp = false; + unsignedp = FALSE; break; case 'u': - unsignedp = true; + unsignedp = TRUE; break; default: bad_stab (orig); @@ -1903,7 +1912,7 @@ parse_stab_sun_builtin_type (dhandle, pp) by this type, except that unsigned short is 4 instead of 2. Since this information is redundant with the third number, we will ignore it. */ - (void) parse_number (pp, (boolean *) NULL); + (void) parse_number (pp, (bfd_boolean *) NULL); if (**pp != ';') { bad_stab (orig); @@ -1912,7 +1921,7 @@ parse_stab_sun_builtin_type (dhandle, pp) ++*pp; /* The second number is always 0, so ignore it too. */ - (void) parse_number (pp, (boolean *) NULL); + (void) parse_number (pp, (bfd_boolean *) NULL); if (**pp != ';') { bad_stab (orig); @@ -1921,7 +1930,7 @@ parse_stab_sun_builtin_type (dhandle, pp) ++*pp; /* The third number is the number of bits for this type. */ - bits = parse_number (pp, (boolean *) NULL); + bits = parse_number (pp, (bfd_boolean *) NULL); /* The type *should* end with a semicolon. If it are embedded in a larger type the semicolon may be the only way to know where @@ -1953,7 +1962,7 @@ parse_stab_sun_floating_type (dhandle, pp) /* The first number has more details about the type, for example FN_COMPLEX. */ - details = parse_number (pp, (boolean *) NULL); + details = parse_number (pp, (bfd_boolean *) NULL); if (**pp != ';') { bad_stab (orig); @@ -1961,7 +1970,7 @@ parse_stab_sun_floating_type (dhandle, pp) } /* The second number is the number of bytes occupied by this type */ - bytes = parse_number (pp, (boolean *) NULL); + bytes = parse_number (pp, (bfd_boolean *) NULL); if (**pp != ';') { bad_stab (orig); @@ -2022,7 +2031,7 @@ parse_stab_enum_type (dhandle, pp) name = savestring (*pp, p - *pp); *pp = p + 1; - val = (bfd_signed_vma) parse_number (pp, (boolean *) NULL); + val = (bfd_signed_vma) parse_number (pp, (bfd_boolean *) NULL); if (**pp != ',') { bad_stab (orig); @@ -2066,22 +2075,22 @@ parse_stab_struct_type (dhandle, info, tagname, pp, structp, typenums) struct stab_handle *info; const char *tagname; const char **pp; - boolean structp; + bfd_boolean structp; const int *typenums; { const char *orig; bfd_vma size; debug_baseclass *baseclasses; debug_field *fields; - boolean statics; + bfd_boolean statics; debug_method *methods; debug_type vptrbase; - boolean ownvptr; + bfd_boolean ownvptr; orig = *pp; /* Get the size. */ - size = parse_number (pp, (boolean *) NULL); + size = parse_number (pp, (bfd_boolean *) NULL); /* Get the other information. */ if (! parse_stab_baseclasses (dhandle, info, pp, &baseclasses) @@ -2124,9 +2133,9 @@ parse_stab_struct_type (dhandle, info, tagname, pp, structp, typenums) Offset in bits from start of class ________________________| | Type number of base class ____________________________________| - Return true for success, false for failure. */ + Return TRUE for success, FALSE for failure. */ -static boolean +static bfd_boolean parse_stab_baseclasses (dhandle, info, pp, retp) PTR dhandle; struct stab_handle *info; @@ -2144,16 +2153,16 @@ parse_stab_baseclasses (dhandle, info, pp, retp) if (**pp != '!') { /* No base classes. */ - return true; + return TRUE; } ++*pp; - c = (unsigned int) parse_number (pp, (boolean *) NULL); + c = (unsigned int) parse_number (pp, (bfd_boolean *) NULL); if (**pp != ',') { bad_stab (orig); - return false; + return FALSE; } ++*pp; @@ -2161,7 +2170,7 @@ parse_stab_baseclasses (dhandle, info, pp, retp) for (i = 0; i < c; i++) { - boolean virtual; + bfd_boolean virtual; enum debug_visibility visibility; bfd_vma bitpos; debug_type type; @@ -2169,14 +2178,14 @@ parse_stab_baseclasses (dhandle, info, pp, retp) switch (**pp) { case '0': - virtual = false; + virtual = FALSE; break; case '1': - virtual = true; + virtual = TRUE; break; default: warn_stab (orig, _("unknown virtual character for baseclass")); - virtual = false; + virtual = FALSE; break; } ++*pp; @@ -2202,26 +2211,26 @@ parse_stab_baseclasses (dhandle, info, pp, retp) /* The remaining value is the bit offset of the portion of the object corresponding to this baseclass. Always zero in the absence of multiple inheritance. */ - bitpos = parse_number (pp, (boolean *) NULL); + bitpos = parse_number (pp, (bfd_boolean *) NULL); if (**pp != ',') { bad_stab (orig); - return false; + return FALSE; } ++*pp; type = parse_stab_type (dhandle, info, (const char *) NULL, pp, (debug_type **) NULL); if (type == DEBUG_TYPE_NULL) - return false; + return FALSE; classes[i] = debug_make_baseclass (dhandle, type, bitpos, virtual, visibility); if (classes[i] == DEBUG_BASECLASS_NULL) - return false; + return FALSE; if (**pp != ';') - return false; + return FALSE; ++*pp; } @@ -2229,7 +2238,7 @@ parse_stab_baseclasses (dhandle, info, pp, retp) *retp = classes; - return true; + return TRUE; } /* Read struct or class data fields. They have the form: @@ -2252,13 +2261,13 @@ parse_stab_baseclasses (dhandle, info, pp, retp) Returns 1 for success, 0 for failure. */ -static boolean +static bfd_boolean parse_stab_struct_fields (dhandle, info, pp, retp, staticsp) PTR dhandle; struct stab_handle *info; const char **pp; debug_field **retp; - boolean *staticsp; + bfd_boolean *staticsp; { const char *orig; const char *p; @@ -2267,7 +2276,7 @@ parse_stab_struct_fields (dhandle, info, pp, retp, staticsp) unsigned int alloc; *retp = NULL; - *staticsp = false; + *staticsp = FALSE; orig = *pp; @@ -2299,7 +2308,7 @@ parse_stab_struct_fields (dhandle, info, pp, retp, staticsp) { ++*pp; if (! parse_stab_cpp_abbrev (dhandle, info, pp, fields + c)) - return false; + return FALSE; ++c; continue; } @@ -2313,7 +2322,7 @@ parse_stab_struct_fields (dhandle, info, pp, retp, staticsp) if (p == NULL) { bad_stab (orig); - return false; + return FALSE; } if (p[1] == ':') @@ -2321,7 +2330,7 @@ parse_stab_struct_fields (dhandle, info, pp, retp, staticsp) if (! parse_stab_one_struct_field (dhandle, info, pp, p, fields + c, staticsp)) - return false; + return FALSE; ++c; } @@ -2330,12 +2339,12 @@ parse_stab_struct_fields (dhandle, info, pp, retp, staticsp) *retp = fields; - return true; + return TRUE; } /* Special GNU C++ name. */ -static boolean +static bfd_boolean parse_stab_cpp_abbrev (dhandle, info, pp, retp) PTR dhandle; struct stab_handle *info; @@ -2357,7 +2366,7 @@ parse_stab_cpp_abbrev (dhandle, info, pp, retp) if (**pp != 'v') { bad_stab (*pp); - return false; + return FALSE; } ++*pp; @@ -2372,7 +2381,7 @@ parse_stab_cpp_abbrev (dhandle, info, pp, retp) context = parse_stab_type (dhandle, info, (const char *) NULL, pp, (debug_type **) NULL); if (context == DEBUG_TYPE_NULL) - return false; + return FALSE; switch (cpp_abbrev) { @@ -2399,7 +2408,7 @@ parse_stab_cpp_abbrev (dhandle, info, pp, retp) if (**pp != ':') { bad_stab (orig); - return false; + return FALSE; } ++*pp; @@ -2408,36 +2417,36 @@ parse_stab_cpp_abbrev (dhandle, info, pp, retp) if (**pp != ',') { bad_stab (orig); - return false; + return FALSE; } ++*pp; - bitpos = parse_number (pp, (boolean *) NULL); + bitpos = parse_number (pp, (bfd_boolean *) NULL); if (**pp != ';') { bad_stab (orig); - return false; + return FALSE; } ++*pp; *retp = debug_make_field (dhandle, name, type, bitpos, 0, DEBUG_VISIBILITY_PRIVATE); if (*retp == DEBUG_FIELD_NULL) - return false; + return FALSE; - return true; + return TRUE; } /* Parse a single field in a struct or union. */ -static boolean +static bfd_boolean parse_stab_one_struct_field (dhandle, info, pp, p, retp, staticsp) PTR dhandle; struct stab_handle *info; const char **pp; const char *p; debug_field *retp; - boolean *staticsp; + bfd_boolean *staticsp; { const char *orig; char *name; @@ -2481,7 +2490,7 @@ parse_stab_one_struct_field (dhandle, info, pp, p, retp, staticsp) type = parse_stab_type (dhandle, info, (const char *) NULL, pp, (debug_type **) NULL); if (type == DEBUG_TYPE_NULL) - return false; + return FALSE; if (**pp == ':') { @@ -2493,7 +2502,7 @@ parse_stab_one_struct_field (dhandle, info, pp, p, retp, staticsp) if (p == NULL) { bad_stab (orig); - return false; + return FALSE; } varname = savestring (*pp, p - *pp); @@ -2502,31 +2511,31 @@ parse_stab_one_struct_field (dhandle, info, pp, p, retp, staticsp) *retp = debug_make_static_member (dhandle, name, type, varname, visibility); - *staticsp = true; + *staticsp = TRUE; - return true; + return TRUE; } if (**pp != ',') { bad_stab (orig); - return false; + return FALSE; } ++*pp; - bitpos = parse_number (pp, (boolean *) NULL); + bitpos = parse_number (pp, (bfd_boolean *) NULL); if (**pp != ',') { bad_stab (orig); - return false; + return FALSE; } ++*pp; - bitsize = parse_number (pp, (boolean *) NULL); + bitsize = parse_number (pp, (bfd_boolean *) NULL); if (**pp != ';') { bad_stab (orig); - return false; + return FALSE; } ++*pp; @@ -2552,7 +2561,7 @@ parse_stab_one_struct_field (dhandle, info, pp, p, retp, staticsp) *retp = debug_make_field (dhandle, name, type, bitpos, bitsize, visibility); - return true; + return TRUE; } /* Read member function stabs info for C++ classes. The form of each member @@ -2568,7 +2577,7 @@ parse_stab_one_struct_field (dhandle, info, pp, p, retp, staticsp) $ is the CPLUS_MARKER (usually '$'), `*' holds the place for an operator name (such as `+=') and `.' marks the end of the operator name. */ -static boolean +static bfd_boolean parse_stab_members (dhandle, info, tagname, pp, typenums, retp) PTR dhandle; struct stab_handle *info; @@ -2623,7 +2632,7 @@ parse_stab_members (dhandle, info, tagname, pp, typenums, retp) if (*p != '.') { bad_stab (orig); - return false; + return FALSE; } name = savestring (*pp, p - *pp); *pp = p + 1; @@ -2639,14 +2648,14 @@ parse_stab_members (dhandle, info, tagname, pp, typenums, retp) do { debug_type type; - boolean stub; + bfd_boolean stub; char *argtypes; enum debug_visibility visibility; - boolean constp, volatilep, staticp; + bfd_boolean constp, volatilep, staticp; bfd_vma voffset; debug_type context; const char *physname; - boolean varargs; + bfd_boolean varargs; if (look_ahead_type != DEBUG_TYPE_NULL) { @@ -2659,11 +2668,11 @@ parse_stab_members (dhandle, info, tagname, pp, typenums, retp) type = parse_stab_type (dhandle, info, (const char *) NULL, pp, (debug_type **) NULL); if (type == DEBUG_TYPE_NULL) - return false; + return FALSE; if (**pp != ':') { bad_stab (orig); - return false; + return FALSE; } } @@ -2672,13 +2681,13 @@ parse_stab_members (dhandle, info, tagname, pp, typenums, retp) if (p == NULL) { bad_stab (orig); - return false; + return FALSE; } - stub = false; + stub = FALSE; if (debug_get_type_kind (dhandle, type) == DEBUG_KIND_METHOD && debug_get_parameter_types (dhandle, type, &varargs) == NULL) - stub = true; + stub = TRUE; argtypes = savestring (*pp, p - *pp); *pp = p + 1; @@ -2697,8 +2706,8 @@ parse_stab_members (dhandle, info, tagname, pp, typenums, retp) } ++*pp; - constp = false; - volatilep = false; + constp = FALSE; + volatilep = FALSE; switch (**pp) { case 'A': @@ -2707,18 +2716,18 @@ parse_stab_members (dhandle, info, tagname, pp, typenums, retp) break; case 'B': /* const member function. */ - constp = true; + constp = TRUE; ++*pp; break; case 'C': /* volatile member function. */ - volatilep = true; + volatilep = TRUE; ++*pp; break; case 'D': /* const volatile member function. */ - constp = true; - volatilep = true; + constp = TRUE; + volatilep = TRUE; ++*pp; break; case '*': @@ -2731,7 +2740,7 @@ parse_stab_members (dhandle, info, tagname, pp, typenums, retp) break; } - staticp = false; + staticp = FALSE; switch (**pp) { case '*': @@ -2739,11 +2748,11 @@ parse_stab_members (dhandle, info, tagname, pp, typenums, retp) bit is supposedly set to distinguish pointers-to-methods from virtual function indicies. */ ++*pp; - voffset = parse_number (pp, (boolean *) NULL); + voffset = parse_number (pp, (bfd_boolean *) NULL); if (**pp != ';') { bad_stab (orig); - return false; + return FALSE; } ++*pp; voffset &= 0x7fffffff; @@ -2774,7 +2783,7 @@ parse_stab_members (dhandle, info, tagname, pp, typenums, retp) if (**pp != ';') { bad_stab (orig); - return false; + return FALSE; } ++*pp; } @@ -2784,11 +2793,11 @@ parse_stab_members (dhandle, info, tagname, pp, typenums, retp) case '?': /* static member function. */ ++*pp; - staticp = true; + staticp = TRUE; voffset = 0; context = DEBUG_TYPE_NULL; if (strncmp (argtypes, name, strlen (name)) != 0) - stub = true; + stub = TRUE; break; default: @@ -2817,18 +2826,18 @@ parse_stab_members (dhandle, info, tagname, pp, typenums, retp) class_type = stab_find_type (dhandle, info, typenums); if (class_type == DEBUG_TYPE_NULL) - return false; + return FALSE; return_type = debug_get_return_type (dhandle, type); if (return_type == DEBUG_TYPE_NULL) { bad_stab (orig); - return false; + return FALSE; } type = parse_stab_argtypes (dhandle, info, class_type, name, tagname, return_type, argtypes, constp, volatilep, &physname); if (type == DEBUG_TYPE_NULL) - return false; + return FALSE; } if (cvars + 1 >= allocvars) @@ -2852,7 +2861,7 @@ parse_stab_members (dhandle, info, tagname, pp, typenums, retp) constp, volatilep); if (variants[cvars] == DEBUG_METHOD_VARIANT_NULL) - return false; + return FALSE; ++cvars; } @@ -2880,7 +2889,7 @@ parse_stab_members (dhandle, info, tagname, pp, typenums, retp) *retp = methods; - return true; + return TRUE; } /* Parse a string representing argument types for a method. Stabs @@ -2899,15 +2908,15 @@ parse_stab_argtypes (dhandle, info, class_type, fieldname, tagname, const char *tagname; debug_type return_type; const char *argtypes; - boolean constp; - boolean volatilep; + bfd_boolean constp; + bfd_boolean volatilep; const char **pphysname; { - boolean is_full_physname_constructor; - boolean is_constructor; - boolean is_destructor; + bfd_boolean is_full_physname_constructor; + bfd_boolean is_constructor; + bfd_boolean is_destructor; debug_type *args; - boolean varargs; + bfd_boolean varargs; unsigned int physname_len = 0; /* Constructors are sometimes handled specially. */ @@ -2999,7 +3008,7 @@ parse_stab_argtypes (dhandle, info, class_type, fieldname, tagname, args = (debug_type *) xmalloc (sizeof *args); *args = NULL; return debug_make_method_type (dhandle, return_type, class_type, args, - false); + FALSE); } args = stab_demangle_argtypes (dhandle, info, *pphysname, &varargs, physname_len); @@ -3018,21 +3027,21 @@ parse_stab_argtypes (dhandle, info, class_type, fieldname, tagname, This function is called when we have parsed all the method declarations, so we can look for the vptr base class info. */ -static boolean +static bfd_boolean parse_stab_tilde_field (dhandle, info, pp, typenums, retvptrbase, retownvptr) PTR dhandle; struct stab_handle *info; const char **pp; const int *typenums; debug_type *retvptrbase; - boolean *retownvptr; + bfd_boolean *retownvptr; { const char *orig; const char *hold; int vtypenums[2]; *retvptrbase = DEBUG_TYPE_NULL; - *retownvptr = false; + *retownvptr = FALSE; orig = *pp; @@ -3041,7 +3050,7 @@ parse_stab_tilde_field (dhandle, info, pp, typenums, retvptrbase, retownvptr) ++*pp; if (**pp != '~') - return true; + return TRUE; ++*pp; @@ -3053,7 +3062,7 @@ parse_stab_tilde_field (dhandle, info, pp, typenums, retvptrbase, retownvptr) } if (**pp != '%') - return true; + return TRUE; ++*pp; @@ -3062,11 +3071,11 @@ parse_stab_tilde_field (dhandle, info, pp, typenums, retvptrbase, retownvptr) /* The next number is the type number of the base class (possibly our own class) which supplies the vtable for this class. */ if (! parse_stab_type_number (pp, vtypenums)) - return false; + return FALSE; if (vtypenums[0] == typenums[0] && vtypenums[1] == typenums[1]) - *retownvptr = true; + *retownvptr = TRUE; else { debug_type vtype; @@ -3081,7 +3090,7 @@ parse_stab_tilde_field (dhandle, info, pp, typenums, retvptrbase, retownvptr) if (*p != ';') { bad_stab (orig); - return false; + return FALSE; } *retvptrbase = vtype; @@ -3089,7 +3098,7 @@ parse_stab_tilde_field (dhandle, info, pp, typenums, retvptrbase, retownvptr) *pp = p + 1; } - return true; + return TRUE; } /* Read a definition of an array type. */ @@ -3099,13 +3108,13 @@ parse_stab_array_type (dhandle, info, pp, stringp) PTR dhandle; struct stab_handle *info; const char **pp; - boolean stringp; + bfd_boolean stringp; { const char *orig; const char *p; int typenums[2]; debug_type index_type; - boolean adjustable; + bfd_boolean adjustable; bfd_signed_vma lower, upper; debug_type element_type; @@ -3129,7 +3138,7 @@ parse_stab_array_type (dhandle, info, pp, stringp) index_type = debug_find_named_type (dhandle, "int"); if (index_type == DEBUG_TYPE_NULL) { - index_type = debug_make_int_type (dhandle, 4, false); + index_type = debug_make_int_type (dhandle, 4, FALSE); if (index_type == DEBUG_TYPE_NULL) return DEBUG_TYPE_NULL; } @@ -3148,15 +3157,15 @@ parse_stab_array_type (dhandle, info, pp, stringp) } ++*pp; - adjustable = false; + adjustable = FALSE; if (! ISDIGIT (**pp) && **pp != '-') { ++*pp; - adjustable = true; + adjustable = TRUE; } - lower = (bfd_signed_vma) parse_number (pp, (boolean *) NULL); + lower = (bfd_signed_vma) parse_number (pp, (bfd_boolean *) NULL); if (**pp != ';') { bad_stab (orig); @@ -3167,10 +3176,10 @@ parse_stab_array_type (dhandle, info, pp, stringp) if (! ISDIGIT (**pp) && **pp != '-') { ++*pp; - adjustable = true; + adjustable = TRUE; } - upper = (bfd_signed_vma) parse_number (pp, (boolean *) NULL); + upper = (bfd_signed_vma) parse_number (pp, (bfd_boolean *) NULL); if (**pp != ';') { bad_stab (orig); @@ -3263,7 +3272,7 @@ pop_bincl (info) /* Handle an N_EXCL: get the types from the corresponding N_BINCL. */ -static boolean +static bfd_boolean find_excl (info, name, hash) struct stab_handle *info; const char *name; @@ -3284,12 +3293,12 @@ find_excl (info, name, hash) { warn_stab (name, _("Undefined N_EXCL")); info->file_types[info->files - 1] = NULL; - return true; + return TRUE; } info->file_types[info->files - 1] = l->file_types; - return true; + return TRUE; } /* Handle a variable definition. gcc emits variable definitions for a @@ -3297,7 +3306,7 @@ find_excl (info, name, hash) it. The SunPRO compiler emits variable definitions after the N_LBRAC, so we can call debug_record_variable immediately. */ -static boolean +static bfd_boolean stab_record_variable (dhandle, info, name, type, kind, val) PTR dhandle; struct stab_handle *info; @@ -3323,13 +3332,13 @@ stab_record_variable (dhandle, info, name, type, kind, val) v->val = val; info->pending = v; - return true; + return TRUE; } /* Emit pending variable definitions. This is called after we see the N_LBRAC that starts the block. */ -static boolean +static bfd_boolean stab_emit_pending_vars (dhandle, info) PTR dhandle; struct stab_handle *info; @@ -3342,7 +3351,7 @@ stab_emit_pending_vars (dhandle, info) struct stab_pending_var *next; if (! debug_record_variable (dhandle, v->name, v->type, v->kind, v->val)) - return false; + return FALSE; next = v->next; free (v); @@ -3351,7 +3360,7 @@ stab_emit_pending_vars (dhandle, info) info->pending = NULL; - return true; + return TRUE; } /* Find the slot for a type in the database. */ @@ -3429,7 +3438,7 @@ stab_find_type (dhandle, info, typenums) /* Record that a given type number refers to a given type. */ -static boolean +static bfd_boolean stab_record_type (dhandle, info, typenums, type) PTR dhandle ATTRIBUTE_UNUSED; struct stab_handle *info; @@ -3440,13 +3449,13 @@ stab_record_type (dhandle, info, typenums, type) slot = stab_find_slot (info, typenums); if (slot == NULL) - return false; + return FALSE; /* gdb appears to ignore type redefinitions, so we do as well. */ *slot = type; - return true; + return TRUE; } /* Return an XCOFF builtin type. */ @@ -3474,42 +3483,42 @@ stab_xcoff_builtin_type (dhandle, info, typenum) /* The size of this and all the other types are fixed, defined by the debugging format. */ name = "int"; - rettype = debug_make_int_type (dhandle, 4, false); + rettype = debug_make_int_type (dhandle, 4, FALSE); break; case 2: name = "char"; - rettype = debug_make_int_type (dhandle, 1, false); + rettype = debug_make_int_type (dhandle, 1, FALSE); break; case 3: name = "short"; - rettype = debug_make_int_type (dhandle, 2, false); + rettype = debug_make_int_type (dhandle, 2, FALSE); break; case 4: name = "long"; - rettype = debug_make_int_type (dhandle, 4, false); + rettype = debug_make_int_type (dhandle, 4, FALSE); break; case 5: name = "unsigned char"; - rettype = debug_make_int_type (dhandle, 1, true); + rettype = debug_make_int_type (dhandle, 1, TRUE); break; case 6: name = "signed char"; - rettype = debug_make_int_type (dhandle, 1, false); + rettype = debug_make_int_type (dhandle, 1, FALSE); break; case 7: name = "unsigned short"; - rettype = debug_make_int_type (dhandle, 2, true); + rettype = debug_make_int_type (dhandle, 2, TRUE); break; case 8: name = "unsigned int"; - rettype = debug_make_int_type (dhandle, 4, true); + rettype = debug_make_int_type (dhandle, 4, TRUE); break; case 9: name = "unsigned"; - rettype = debug_make_int_type (dhandle, 4, true); + rettype = debug_make_int_type (dhandle, 4, TRUE); case 10: name = "unsigned long"; - rettype = debug_make_int_type (dhandle, 4, true); + rettype = debug_make_int_type (dhandle, 4, TRUE); break; case 11: name = "void"; @@ -3534,7 +3543,7 @@ stab_xcoff_builtin_type (dhandle, info, typenum) break; case 15: name = "integer"; - rettype = debug_make_int_type (dhandle, 4, false); + rettype = debug_make_int_type (dhandle, 4, FALSE); break; case 16: name = "boolean"; @@ -3556,7 +3565,7 @@ stab_xcoff_builtin_type (dhandle, info, typenum) case 20: /* FIXME */ name = "character"; - rettype = debug_make_int_type (dhandle, 1, true); + rettype = debug_make_int_type (dhandle, 1, TRUE); break; case 21: name = "logical*1"; @@ -3586,28 +3595,28 @@ stab_xcoff_builtin_type (dhandle, info, typenum) break; case 27: name = "integer*1"; - rettype = debug_make_int_type (dhandle, 1, false); + rettype = debug_make_int_type (dhandle, 1, FALSE); break; case 28: name = "integer*2"; - rettype = debug_make_int_type (dhandle, 2, false); + rettype = debug_make_int_type (dhandle, 2, FALSE); break; case 29: name = "integer*4"; - rettype = debug_make_int_type (dhandle, 4, false); + rettype = debug_make_int_type (dhandle, 4, FALSE); break; case 30: /* FIXME */ name = "wchar"; - rettype = debug_make_int_type (dhandle, 2, false); + rettype = debug_make_int_type (dhandle, 2, FALSE); break; case 31: name = "long long"; - rettype = debug_make_int_type (dhandle, 8, false); + rettype = debug_make_int_type (dhandle, 8, FALSE); break; case 32: name = "unsigned long long"; - rettype = debug_make_int_type (dhandle, 8, true); + rettype = debug_make_int_type (dhandle, 8, TRUE); break; case 33: name = "logical*8"; @@ -3615,7 +3624,7 @@ stab_xcoff_builtin_type (dhandle, info, typenum) break; case 34: name = "integer*8"; - rettype = debug_make_int_type (dhandle, 8, false); + rettype = debug_make_int_type (dhandle, 8, FALSE); break; default: abort (); @@ -3717,7 +3726,7 @@ struct stab_demangle_info /* The array of arguments we are building. */ debug_type *args; /* Whether the method takes a variable number of arguments. */ - boolean varargs; + bfd_boolean varargs; /* The array of types we have remembered. */ struct stab_demangle_typestring *typestrings; /* The number of typestrings. */ @@ -3726,33 +3735,35 @@ struct stab_demangle_info unsigned int typestring_alloc; }; -static void stab_bad_demangle PARAMS ((const char *)); -static unsigned int stab_demangle_count PARAMS ((const char **)); -static boolean stab_demangle_get_count +static void stab_bad_demangle + PARAMS ((const char *)); +static unsigned int stab_demangle_count + PARAMS ((const char **)); +static bfd_boolean stab_demangle_get_count PARAMS ((const char **, unsigned int *)); -static boolean stab_demangle_prefix +static bfd_boolean stab_demangle_prefix PARAMS ((struct stab_demangle_info *, const char **, unsigned int)); -static boolean stab_demangle_function_name +static bfd_boolean stab_demangle_function_name PARAMS ((struct stab_demangle_info *, const char **, const char *)); -static boolean stab_demangle_signature +static bfd_boolean stab_demangle_signature PARAMS ((struct stab_demangle_info *, const char **)); -static boolean stab_demangle_qualified +static bfd_boolean stab_demangle_qualified PARAMS ((struct stab_demangle_info *, const char **, debug_type *)); -static boolean stab_demangle_template +static bfd_boolean stab_demangle_template PARAMS ((struct stab_demangle_info *, const char **, char **)); -static boolean stab_demangle_class +static bfd_boolean stab_demangle_class PARAMS ((struct stab_demangle_info *, const char **, const char **)); -static boolean stab_demangle_args +static bfd_boolean stab_demangle_args PARAMS ((struct stab_demangle_info *, const char **, debug_type **, - boolean *)); -static boolean stab_demangle_arg + bfd_boolean *)); +static bfd_boolean stab_demangle_arg PARAMS ((struct stab_demangle_info *, const char **, debug_type **, unsigned int *, unsigned int *)); -static boolean stab_demangle_type +static bfd_boolean stab_demangle_type PARAMS ((struct stab_demangle_info *, const char **, debug_type *)); -static boolean stab_demangle_fund_type +static bfd_boolean stab_demangle_fund_type PARAMS ((struct stab_demangle_info *, const char **, debug_type *)); -static boolean stab_demangle_remember_type +static bfd_boolean stab_demangle_remember_type PARAMS ((struct stab_demangle_info *, const char *, int)); /* Warn about a bad demangling. */ @@ -3785,13 +3796,13 @@ stab_demangle_count (pp) /* Require a count in a string. The count may be multiple digits, in which case it must end in an underscore. */ -static boolean +static bfd_boolean stab_demangle_get_count (pp, pi) const char **pp; unsigned int *pi; { if (! ISDIGIT (**pp)) - return false; + return FALSE; *pi = **pp - '0'; ++*pp; @@ -3816,7 +3827,7 @@ stab_demangle_get_count (pp, pi) } } - return true; + return TRUE; } /* This function demangles a physical name, returning a NULL @@ -3827,7 +3838,7 @@ stab_demangle_argtypes (dhandle, info, physname, pvarargs, physname_len) PTR dhandle; struct stab_handle *info; const char *physname; - boolean *pvarargs; + bfd_boolean *pvarargs; unsigned int physname_len; { struct stab_demangle_info minfo; @@ -3835,7 +3846,7 @@ stab_demangle_argtypes (dhandle, info, physname, pvarargs, physname_len) minfo.dhandle = dhandle; minfo.info = info; minfo.args = NULL; - minfo.varargs = false; + minfo.varargs = FALSE; minfo.typestring_alloc = 10; minfo.typestrings = ((struct stab_demangle_typestring *) xmalloc (minfo.typestring_alloc @@ -3871,7 +3882,7 @@ stab_demangle_argtypes (dhandle, info, physname, pvarargs, physname_len) /* Demangle the prefix of the mangled name. */ -static boolean +static bfd_boolean stab_demangle_prefix (minfo, pp, physname_len) struct stab_demangle_info *minfo; const char **pp; @@ -3896,7 +3907,7 @@ stab_demangle_prefix (minfo, pp, physname_len) if (scan == NULL) { stab_bad_demangle (*pp); - return false; + return FALSE; } --scan; @@ -3914,7 +3925,7 @@ stab_demangle_prefix (minfo, pp, physname_len) { /* This is a GNU style constructor name. */ *pp = scan + 2; - return true; + return TRUE; } else if (scan == *pp && ! ISDIGIT (scan[2]) @@ -3928,7 +3939,7 @@ stab_demangle_prefix (minfo, pp, physname_len) if (scan == NULL || scan[2] == '\0') { stab_bad_demangle (*pp); - return false; + return FALSE; } return stab_demangle_function_name (minfo, pp, scan); @@ -3941,7 +3952,7 @@ stab_demangle_prefix (minfo, pp, physname_len) else { stab_bad_demangle (*pp); - return false; + return FALSE; } /*NOTREACHED*/ } @@ -3950,7 +3961,7 @@ stab_demangle_prefix (minfo, pp, physname_len) double underscore which separates the function name from the signature. */ -static boolean +static bfd_boolean stab_demangle_function_name (minfo, pp, scan) struct stab_demangle_info *minfo; const char **pp; @@ -3975,7 +3986,7 @@ stab_demangle_function_name (minfo, pp, scan) /* This is a type conversion operator. */ tem = name + 5; if (! stab_demangle_type (minfo, &tem, (debug_type *) NULL)) - return false; + return FALSE; } else if (name[0] == '_' && name[1] == '_' @@ -3987,28 +3998,28 @@ stab_demangle_function_name (minfo, pp, scan) /* This is a type conversion operator. */ tem = name + 4; if (! stab_demangle_type (minfo, &tem, (debug_type *) NULL)) - return false; + return FALSE; } - return true; + return TRUE; } /* Demangle the signature. This is where the argument types are found. */ -static boolean +static bfd_boolean stab_demangle_signature (minfo, pp) struct stab_demangle_info *minfo; const char **pp; { const char *orig; - boolean expect_func, func_done; + bfd_boolean expect_func, func_done; const char *hold; orig = *pp; - expect_func = false; - func_done = false; + expect_func = FALSE; + func_done = FALSE; hold = NULL; while (**pp != '\0') @@ -4019,8 +4030,8 @@ stab_demangle_signature (minfo, pp) hold = *pp; if (! stab_demangle_qualified (minfo, pp, (debug_type *) NULL) || ! stab_demangle_remember_type (minfo, hold, *pp - hold)) - return false; - expect_func = true; + return FALSE; + expect_func = TRUE; hold = NULL; break; @@ -4044,8 +4055,8 @@ stab_demangle_signature (minfo, pp) hold = *pp; if (! stab_demangle_class (minfo, pp, (const char **) NULL) || ! stab_demangle_remember_type (minfo, hold, *pp - hold)) - return false; - expect_func = true; + return FALSE; + expect_func = TRUE; hold = NULL; break; @@ -4053,10 +4064,10 @@ stab_demangle_signature (minfo, pp) /* Function. I don't know if this actually happens with g++ output. */ hold = NULL; - func_done = true; + func_done = TRUE; ++*pp; if (! stab_demangle_args (minfo, pp, &minfo->args, &minfo->varargs)) - return false; + return FALSE; break; case 't': @@ -4065,9 +4076,9 @@ stab_demangle_signature (minfo, pp) hold = *pp; if (! stab_demangle_template (minfo, pp, (char **) NULL) || ! stab_demangle_remember_type (minfo, hold, *pp - hold)) - return false; + return FALSE; hold = NULL; - expect_func = true; + expect_func = TRUE; break; case '_': @@ -4077,22 +4088,22 @@ stab_demangle_signature (minfo, pp) has been mangled by some algorithm we don't know how to deal with. So just reject the entire demangling. */ stab_bad_demangle (orig); - return false; + return FALSE; default: /* Assume we have stumbled onto the first outermost function argument token, and start processing args. */ - func_done = true; + func_done = TRUE; if (! stab_demangle_args (minfo, pp, &minfo->args, &minfo->varargs)) - return false; + return FALSE; break; } if (expect_func) { - func_done = true; + func_done = TRUE; if (! stab_demangle_args (minfo, pp, &minfo->args, &minfo->varargs)) - return false; + return FALSE; } } @@ -4103,16 +4114,16 @@ stab_demangle_signature (minfo, pp) first case, and need to ensure that the '(void)' gets added to the current declp. */ if (! stab_demangle_args (minfo, pp, &minfo->args, &minfo->varargs)) - return false; + return FALSE; } - return true; + return TRUE; } /* Demangle a qualified name, such as "Q25Outer5Inner" which is the mangled form of "Outer::Inner". */ -static boolean +static bfd_boolean stab_demangle_qualified (minfo, pp, ptype) struct stab_demangle_info *minfo; const char **pp; @@ -4135,7 +4146,7 @@ stab_demangle_qualified (minfo, pp, ptype) if (! ISDIGIT (*p) || *p == '0') { stab_bad_demangle (orig); - return false; + return FALSE; } qualifiers = atoi (p); while (ISDIGIT (*p)) @@ -4143,7 +4154,7 @@ stab_demangle_qualified (minfo, pp, ptype) if (*p != '_') { stab_bad_demangle (orig); - return false; + return FALSE; } *pp = p + 1; break; @@ -4160,7 +4171,7 @@ stab_demangle_qualified (minfo, pp, ptype) case '0': default: stab_bad_demangle (orig); - return false; + return FALSE; } context = DEBUG_TYPE_NULL; @@ -4176,7 +4187,7 @@ stab_demangle_qualified (minfo, pp, ptype) if (! stab_demangle_template (minfo, pp, ptype != NULL ? &name : NULL)) - return false; + return FALSE; if (ptype != NULL) { @@ -4185,7 +4196,7 @@ stab_demangle_qualified (minfo, pp, ptype) DEBUG_KIND_CLASS); free (name); if (context == DEBUG_TYPE_NULL) - return false; + return FALSE; } } else @@ -4196,7 +4207,7 @@ stab_demangle_qualified (minfo, pp, ptype) if (strlen (*pp) < len) { stab_bad_demangle (orig); - return false; + return FALSE; } if (ptype != NULL) @@ -4230,7 +4241,7 @@ stab_demangle_qualified (minfo, pp, ptype) ft = debug_get_field_type (minfo->dhandle, *fields); if (ft == NULL) - return false; + return FALSE; dn = debug_get_type_name (minfo->dhandle, ft); if (dn != NULL && strcmp (dn, name) == 0) { @@ -4267,7 +4278,7 @@ stab_demangle_qualified (minfo, pp, ptype) ? DEBUG_KIND_ILLEGAL : DEBUG_KIND_CLASS)); if (context == DEBUG_TYPE_NULL) - return false; + return FALSE; } } } @@ -4279,13 +4290,13 @@ stab_demangle_qualified (minfo, pp, ptype) if (ptype != NULL) *ptype = context; - return true; + return TRUE; } /* Demangle a template. If PNAME is not NULL, this sets *PNAME to a string representation of the template. */ -static boolean +static bfd_boolean stab_demangle_template (minfo, pp, pname) struct stab_demangle_info *minfo; const char **pp; @@ -4303,7 +4314,7 @@ stab_demangle_template (minfo, pp, pname) if (r == 0 || strlen (*pp) < r) { stab_bad_demangle (orig); - return false; + return FALSE; } *pp += r; @@ -4311,7 +4322,7 @@ stab_demangle_template (minfo, pp, pname) if (stab_demangle_get_count (pp, &r) == 0) { stab_bad_demangle (orig); - return false; + return FALSE; } for (i = 0; i < r; i++) @@ -4321,26 +4332,26 @@ stab_demangle_template (minfo, pp, pname) /* This is a type parameter. */ ++*pp; if (! stab_demangle_type (minfo, pp, (debug_type *) NULL)) - return false; + return FALSE; } else { const char *old_p; - boolean pointerp, realp, integralp, charp, boolp; - boolean done; + bfd_boolean pointerp, realp, integralp, charp, boolp; + bfd_boolean done; old_p = *pp; - pointerp = false; - realp = false; - integralp = false; - charp = false; - boolp = false; - done = false; + pointerp = FALSE; + realp = FALSE; + integralp = FALSE; + charp = FALSE; + boolp = FALSE; + done = FALSE; /* This is a value parameter. */ if (! stab_demangle_type (minfo, pp, (debug_type *) NULL)) - return false; + return FALSE; while (*old_p != '\0' && ! done) { @@ -4349,8 +4360,8 @@ stab_demangle_template (minfo, pp, pname) case 'P': case 'p': case 'R': - pointerp = true; - done = true; + pointerp = TRUE; + done = TRUE; break; case 'C': /* Const. */ case 'S': /* Signed. */ @@ -4362,8 +4373,8 @@ stab_demangle_template (minfo, pp, pname) ++old_p; break; case 'Q': /* Qualified name. */ - integralp = true; - done = true; + integralp = TRUE; + done = TRUE; break; case 'T': /* Remembered type. */ abort (); @@ -4374,27 +4385,27 @@ stab_demangle_template (minfo, pp, pname) case 'i': /* Int. */ case 's': /* Short. */ case 'w': /* Wchar_t. */ - integralp = true; - done = true; + integralp = TRUE; + done = TRUE; break; case 'b': /* Bool. */ - boolp = true; - done = true; + boolp = TRUE; + done = TRUE; break; case 'c': /* Char. */ - charp = true; - done = true; + charp = TRUE; + done = TRUE; break; case 'r': /* Long double. */ case 'd': /* Double. */ case 'f': /* Float. */ - realp = true; - done = true; + realp = TRUE; + done = TRUE; break; default: /* Assume it's a user defined integral type. */ - integralp = true; - done = true; + integralp = TRUE; + done = TRUE; break; } } @@ -4416,7 +4427,7 @@ stab_demangle_template (minfo, pp, pname) if (val == 0) { stab_bad_demangle (orig); - return false; + return FALSE; } } else if (boolp) @@ -4427,7 +4438,7 @@ stab_demangle_template (minfo, pp, pname) if (val != 0 && val != 1) { stab_bad_demangle (orig); - return false; + return FALSE; } } else if (realp) @@ -4456,7 +4467,7 @@ stab_demangle_template (minfo, pp, pname) if (! stab_demangle_get_count (pp, &len)) { stab_bad_demangle (orig); - return false; + return FALSE; } *pp += len; } @@ -4487,7 +4498,7 @@ stab_demangle_template (minfo, pp, pname) stab_bad_demangle (orig); if (s3 != NULL) free (s3); - return false; + return FALSE; } /* Eliminating all spaces, except those between > characters, @@ -4503,12 +4514,12 @@ stab_demangle_template (minfo, pp, pname) free (s3); } - return true; + return TRUE; } /* Demangle a class name. */ -static boolean +static bfd_boolean stab_demangle_class (minfo, pp, pstart) struct stab_demangle_info *minfo ATTRIBUTE_UNUSED; const char **pp; @@ -4523,7 +4534,7 @@ stab_demangle_class (minfo, pp, pstart) if (strlen (*pp) < n) { stab_bad_demangle (orig); - return false; + return FALSE; } if (pstart != NULL) @@ -4531,18 +4542,18 @@ stab_demangle_class (minfo, pp, pstart) *pp += n; - return true; + return TRUE; } /* Demangle function arguments. If the pargs argument is not NULL, it is set to a NULL terminated array holding the arguments. */ -static boolean +static bfd_boolean stab_demangle_args (minfo, pp, pargs, pvarargs) struct stab_demangle_info *minfo; const char **pp; debug_type **pargs; - boolean *pvarargs; + bfd_boolean *pvarargs; { const char *orig; unsigned int alloc, count; @@ -4553,7 +4564,7 @@ stab_demangle_args (minfo, pp, pargs, pvarargs) if (pargs != NULL) { *pargs = (debug_type *) xmalloc (alloc * sizeof **pargs); - *pvarargs = false; + *pvarargs = FALSE; } count = 0; @@ -4574,20 +4585,20 @@ stab_demangle_args (minfo, pp, pargs, pvarargs) if (! stab_demangle_get_count (pp, &r)) { stab_bad_demangle (orig); - return false; + return FALSE; } } if (! stab_demangle_get_count (pp, &t)) { stab_bad_demangle (orig); - return false; + return FALSE; } if (t >= minfo->typestring_count) { stab_bad_demangle (orig); - return false; + return FALSE; } while (r-- > 0) { @@ -4595,13 +4606,13 @@ stab_demangle_args (minfo, pp, pargs, pvarargs) tem = minfo->typestrings[t].typestring; if (! stab_demangle_arg (minfo, &tem, pargs, &count, &alloc)) - return false; + return FALSE; } } else { if (! stab_demangle_arg (minfo, pp, pargs, &count, &alloc)) - return false; + return FALSE; } } @@ -4611,16 +4622,16 @@ stab_demangle_args (minfo, pp, pargs, pvarargs) if (**pp == 'e') { if (pargs != NULL) - *pvarargs = true; + *pvarargs = TRUE; ++*pp; } - return true; + return TRUE; } /* Demangle a single argument. */ -static boolean +static bfd_boolean stab_demangle_arg (minfo, pp, pargs, pcount, palloc) struct stab_demangle_info *minfo; const char **pp; @@ -4635,12 +4646,12 @@ stab_demangle_arg (minfo, pp, pargs, pcount, palloc) if (! stab_demangle_type (minfo, pp, pargs == NULL ? (debug_type *) NULL : &type) || ! stab_demangle_remember_type (minfo, start, *pp - start)) - return false; + return FALSE; if (pargs != NULL) { if (type == DEBUG_TYPE_NULL) - return false; + return FALSE; if (*pcount + 1 >= *palloc) { @@ -4652,13 +4663,13 @@ stab_demangle_arg (minfo, pp, pargs, pcount, palloc) ++*pcount; } - return true; + return TRUE; } /* Demangle a type. If the ptype argument is not NULL, *ptype is set to the newly allocated type. */ -static boolean +static bfd_boolean stab_demangle_type (minfo, pp, ptype) struct stab_demangle_info *minfo; const char **pp; @@ -4675,7 +4686,7 @@ stab_demangle_type (minfo, pp, ptype) /* A pointer type. */ ++*pp; if (! stab_demangle_type (minfo, pp, ptype)) - return false; + return FALSE; if (ptype != NULL) *ptype = debug_make_pointer_type (minfo->dhandle, *ptype); break; @@ -4684,7 +4695,7 @@ stab_demangle_type (minfo, pp, ptype) /* A reference type. */ ++*pp; if (! stab_demangle_type (minfo, pp, ptype)) - return false; + return FALSE; if (ptype != NULL) *ptype = debug_make_reference_type (minfo->dhandle, *ptype); break; @@ -4701,7 +4712,7 @@ stab_demangle_type (minfo, pp, ptype) if (! ISDIGIT (**pp)) { stab_bad_demangle (orig); - return false; + return FALSE; } high *= 10; high += **pp - '0'; @@ -4710,21 +4721,21 @@ stab_demangle_type (minfo, pp, ptype) if (**pp != '_') { stab_bad_demangle (orig); - return false; + return FALSE; } ++*pp; if (! stab_demangle_type (minfo, pp, ptype)) - return false; + return FALSE; if (ptype != NULL) { debug_type int_type; int_type = debug_find_named_type (minfo->dhandle, "int"); if (int_type == NULL) - int_type = debug_make_int_type (minfo->dhandle, 4, false); + int_type = debug_make_int_type (minfo->dhandle, 4, FALSE); *ptype = debug_make_array_type (minfo->dhandle, *ptype, int_type, - 0, high, false); + 0, high, FALSE); } } break; @@ -4739,16 +4750,16 @@ stab_demangle_type (minfo, pp, ptype) if (! stab_demangle_get_count (pp, &i)) { stab_bad_demangle (orig); - return false; + return FALSE; } if (i >= minfo->typestring_count) { stab_bad_demangle (orig); - return false; + return FALSE; } p = minfo->typestrings[i].typestring; if (! stab_demangle_type (minfo, &p, ptype)) - return false; + return FALSE; } break; @@ -4756,7 +4767,7 @@ stab_demangle_type (minfo, pp, ptype) /* A function. */ { debug_type *args; - boolean varargs; + bfd_boolean varargs; ++*pp; if (! stab_demangle_args (minfo, pp, @@ -4764,20 +4775,20 @@ stab_demangle_type (minfo, pp, ptype) ? (debug_type **) NULL : &args), (ptype == NULL - ? (boolean *) NULL + ? (bfd_boolean *) NULL : &varargs))) - return false; + return FALSE; if (**pp != '_') { /* cplus_demangle will accept a function without a return type, but I don't know when that will happen, or what to do if it does. */ stab_bad_demangle (orig); - return false; + return FALSE; } ++*pp; if (! stab_demangle_type (minfo, pp, ptype)) - return false; + return FALSE; if (ptype != NULL) *ptype = debug_make_function_type (minfo->dhandle, *ptype, args, varargs); @@ -4788,18 +4799,18 @@ stab_demangle_type (minfo, pp, ptype) case 'M': case 'O': { - boolean memberp, constp, volatilep; + bfd_boolean memberp, constp, volatilep; debug_type class_type = DEBUG_TYPE_NULL; debug_type *args; - boolean varargs; + bfd_boolean varargs; unsigned int n; const char *name; memberp = **pp == 'M'; - constp = false; - volatilep = false; + constp = FALSE; + volatilep = FALSE; args = NULL; - varargs = false; + varargs = FALSE; ++*pp; if (ISDIGIT (**pp)) @@ -4808,7 +4819,7 @@ stab_demangle_type (minfo, pp, ptype) if (strlen (*pp) < n) { stab_bad_demangle (orig); - return false; + return FALSE; } name = *pp; *pp += n; @@ -4820,7 +4831,7 @@ stab_demangle_type (minfo, pp, ptype) name, (int) n, DEBUG_KIND_CLASS); if (class_type == DEBUG_TYPE_NULL) - return false; + return FALSE; } } else if (**pp == 'Q') @@ -4829,30 +4840,30 @@ stab_demangle_type (minfo, pp, ptype) (ptype == NULL ? (debug_type *) NULL : &class_type))) - return false; + return FALSE; } else { stab_bad_demangle (orig); - return false; + return FALSE; } if (memberp) { if (**pp == 'C') { - constp = true; + constp = TRUE; ++*pp; } else if (**pp == 'V') { - volatilep = true; + volatilep = TRUE; ++*pp; } if (**pp != 'F') { stab_bad_demangle (orig); - return false; + return FALSE; } ++*pp; if (! stab_demangle_args (minfo, pp, @@ -4860,20 +4871,20 @@ stab_demangle_type (minfo, pp, ptype) ? (debug_type **) NULL : &args), (ptype == NULL - ? (boolean *) NULL + ? (bfd_boolean *) NULL : &varargs))) - return false; + return FALSE; } if (**pp != '_') { stab_bad_demangle (orig); - return false; + return FALSE; } ++*pp; if (! stab_demangle_type (minfo, pp, ptype)) - return false; + return FALSE; if (ptype != NULL) { @@ -4894,13 +4905,13 @@ stab_demangle_type (minfo, pp, ptype) case 'G': ++*pp; if (! stab_demangle_type (minfo, pp, ptype)) - return false; + return FALSE; break; case 'C': ++*pp; if (! stab_demangle_type (minfo, pp, ptype)) - return false; + return FALSE; if (ptype != NULL) *ptype = debug_make_const_type (minfo->dhandle, *ptype); break; @@ -4911,66 +4922,66 @@ stab_demangle_type (minfo, pp, ptype) hold = *pp; if (! stab_demangle_qualified (minfo, pp, ptype)) - return false; + return FALSE; } break; default: if (! stab_demangle_fund_type (minfo, pp, ptype)) - return false; + return FALSE; break; } - return true; + return TRUE; } /* Demangle a fundamental type. If the ptype argument is not NULL, *ptype is set to the newly allocated type. */ -static boolean +static bfd_boolean stab_demangle_fund_type (minfo, pp, ptype) struct stab_demangle_info *minfo; const char **pp; debug_type *ptype; { const char *orig; - boolean constp, volatilep, unsignedp, signedp; - boolean done; + bfd_boolean constp, volatilep, unsignedp, signedp; + bfd_boolean done; orig = *pp; - constp = false; - volatilep = false; - unsignedp = false; - signedp = false; + constp = FALSE; + volatilep = FALSE; + unsignedp = FALSE; + signedp = FALSE; - done = false; + done = FALSE; while (! done) { switch (**pp) { case 'C': - constp = true; + constp = TRUE; ++*pp; break; case 'U': - unsignedp = true; + unsignedp = TRUE; ++*pp; break; case 'S': - signedp = true; + signedp = TRUE; ++*pp; break; case 'V': - volatilep = true; + volatilep = TRUE; ++*pp; break; default: - done = true; + done = TRUE; break; } } @@ -5075,7 +5086,7 @@ stab_demangle_fund_type (minfo, pp, ptype) { *ptype = debug_find_named_type (minfo->dhandle, "__wchar_t"); if (*ptype == DEBUG_TYPE_NULL) - *ptype = debug_make_int_type (minfo->dhandle, 2, true); + *ptype = debug_make_int_type (minfo->dhandle, 2, TRUE); } ++*pp; break; @@ -5115,7 +5126,7 @@ stab_demangle_fund_type (minfo, pp, ptype) if (! ISDIGIT (**pp)) { stab_bad_demangle (orig); - return false; + return FALSE; } /* Fall through. */ case '0': case '1': case '2': case '3': case '4': @@ -5124,7 +5135,7 @@ stab_demangle_fund_type (minfo, pp, ptype) const char *hold; if (! stab_demangle_class (minfo, pp, &hold)) - return false; + return FALSE; if (ptype != NULL) { char *name; @@ -5140,7 +5151,7 @@ stab_demangle_fund_type (minfo, pp, ptype) hold, *pp - hold, DEBUG_KIND_ILLEGAL); if (*ptype == DEBUG_TYPE_NULL) - return false; + return FALSE; } } } @@ -5152,7 +5163,7 @@ stab_demangle_fund_type (minfo, pp, ptype) if (! stab_demangle_template (minfo, pp, ptype != NULL ? &name : NULL)) - return false; + return FALSE; if (ptype != NULL) { *ptype = stab_find_tagged_type (minfo->dhandle, minfo->info, @@ -5160,14 +5171,14 @@ stab_demangle_fund_type (minfo, pp, ptype) DEBUG_KIND_CLASS); free (name); if (*ptype == DEBUG_TYPE_NULL) - return false; + return FALSE; } } break; default: stab_bad_demangle (orig); - return false; + return FALSE; } if (ptype != NULL) @@ -5178,12 +5189,12 @@ stab_demangle_fund_type (minfo, pp, ptype) *ptype = debug_make_volatile_type (minfo->dhandle, *ptype); } - return true; + return TRUE; } /* Remember a type string in a demangled string. */ -static boolean +static bfd_boolean stab_demangle_remember_type (minfo, p, len) struct stab_demangle_info *minfo; const char *p; @@ -5202,5 +5213,5 @@ stab_demangle_remember_type (minfo, p, len) minfo->typestrings[minfo->typestring_count].len = (unsigned int) len; ++minfo->typestring_count; - return true; + return TRUE; } |