Lines Matching refs:is
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
12 This program is distributed in the hope that it will be useful,
59 differently signed operands (truncation direction is undefined in C).
241 /* FIXME: brobecker/2003-09-17: No longer a const because it is
254 /* The name of the runtime function called when an exception is raised. */
258 is raised. */
261 /* The name of the runtime function called when an assert failure is
355 /* Assuming TYPE is a TYPE_CODE_STRUCT, find the field whose name matches
360 number if MAYBE_MISSING is set. Otherwise raise an error. */
395 /* Return non-zero if SUFFIX is a suffix of STR.
396 Return zero if STR is null. */
410 is non-null, and whose memory address (in the inferior) is
429 result is an lval in memory if VAL is. */
441 /* Make sure that the object size is not unreasonable before
483 /* FIXME: cagney/2004-10-10: This function is mimicking the behavior
500 /* Issue an error if the size of an object of type T is unreasonable,
508 error ("object size is larger than varsize-limit");
617 /* If the main program is in Ada, return language_ada, otherwise return LANG
618 (the main program is in Ada iif the adainit symbol is found).
620 MAIN_PST is not used. */
633 /* If the main procedure is written in Ada, then return its name.
634 The result is good until the next call. Return NULL if the main
644 /* For Ada, the name of the main procedure is stored in a specific
647 that string, then most probably the main procedure is not written
668 /* Table of Ada operators and their GNAT-encoded names. Last entry is pair
733 The result is valid until the next call to ada_encode. */
819 5. Remove everything after first ___ if it is followed by
825 The resulting string is valid until the next call of ada_decode.
826 If the string is unchanged by demangling, the original string pointer
827 is returned. */
860 the suffix is located before the current "end" of ENCODED. We want
970 allocated, names in this table are never released. While this is a
982 The GSYMBOL parameter is "mutable" in the C++ sense: logically
984 when a decoded name is cached in it.
1038 information that is ignored). If WILD, then NAME need only match a
1040 either argument is NULL. */
1170 /* If TYPE is the type of an array descriptor (fat or thin pointer) or a
1200 /* If ARR is an array descriptor (fat or thin pointer), or pointer to
1216 /* NOTE: The following calculation is not really kosher, but
1217 since desc_type is an XVE-encoded type (and shouldn't be),
1218 the correct calculation is a real pain. FIXME (and fix GCC). */
1236 /* If TYPE is the type of an array-descriptor (fat pointer), the bit
1245 /* If TYPE is the type of an array-descriptor (fat pointer), the bit
1259 /* If TYPE is the type of an array descriptor (fat or thin pointer) or a
1269 /* NOTE: The following is bogus; see comment in desc_bounds. */
1279 /* If ARR is an array descriptor (fat or thin pointer), a pointer to
1296 /* If TYPE is the type of an array-descriptor (fat pointer), the bit
1305 /* If TYPE is the type of an array-descriptor (fat pointer), the bit
1319 /* If BOUNDS is an array-bounds structure (or pointer to one), return
1320 the Ith lower bound stored in it, if WHICH is 0, and the Ith upper
1321 bound, if WHICH is 1. The first bound is I=1. */
1330 /* If BOUNDS is an array-bounds structure type, return the bit position
1331 of the Ith lower bound stored in it, if WHICH is 0, and the Ith upper
1332 bound, if WHICH is 1. The first bound is I=1. */
1340 /* If BOUNDS is an array-bounds structure type, return the bit field size
1341 of the Ith lower bound stored in it, if WHICH is 0, and the Ith upper
1342 bound, if WHICH is 1. The first bound is I=1. */
1355 /* If TYPE is the type of an array-bounds structure, the type of its
1370 Return 0 if TYPE is NULL. */
1382 /* Non-zero iff TYPE is a simple array type (not a pointer to one) or
1396 /* Non-zero iff TYPE is a simple array type or pointer to one. */
1428 /* Non-zero iff type is a partially mal-formed GNAT array
1429 descriptor. FIXME: This is to compensate for some problems with
1431 is still needed. */
1447 a pointer-to-array type. If BOUNDS is non-zero, the bounds data are filled
1449 the ARR denotes a null array descriptor and BOUNDS is non-zero,
1450 returns NULL. The result is simply the type of ARR if ARR is not
1500 appropriately or, if ARR is a non-null fat pointer, a pointer to a standard
1501 GDB array. Returns NULL if ARR is a null fat pointer. */
1521 be ARR itself if it already is in the proper form). */
1541 packing). For other types, is the identity. */
1569 /* Given that TYPE is a standard GDB array type with all bounds filled
1571 (that is, either its elements, or, if it is an array of arrays, its
1572 elements' elements, etc.) is *ELT_BITS, return an identical type,
1655 /* Given that ARR is a struct value *indicating a GNAT packed array,
1656 returns a simple array that denotes that array. Its type is a
1659 type length is set appropriately. */
1679 /* This is a (right-justified) modular type representing a packed
1777 proceeding for BIT_SIZE bits. If OBJ is an lval in memory, then
1779 VALADDR is ignored unless OBJ is NULL, in which case,
1781 packed value. The value returned in this case is never an lval.
1802 /* Transmit bytes from least to most significant; delta is the direction
2010 error ("Left operand of assignment is not a modifiable lvalue.");
2078 /* Assuming ARR is a pointer to a standard GDB array of type TYPE, the
2108 /* Given that ARRAY_PTR is a pointer or reference to an array of type TYPE (the
2109 actual type of ARRAY_PTR is ignored), returns a reference to
2111 bound of this array is LOW, as per Ada rules. */
2139 /* If type is a record type in the form of a standard GNAT array
2140 descriptor, returns the number of dimensions for type. If arr is a
2167 /* If TYPE is a record type in the form of a standard GNAT array
2170 NINDICES is -1. Otherwise, returns NULL. */
2244 /* Given that arr is an array type, returns the lower bound of the
2245 Nth index (numbering from 1) if WHICH is 0, and the upper bound if
2246 WHICH is 1. This returns bounds 0 .. -1 if ARR_TYPE is an
2247 array-descriptor type. If TYPEP is non-null, *TYPEP is set to the
2310 /* Given that arr is an array value, returns the lower bound of the
2311 nth index (numbering from 1) if which is 0, and the upper bound if
2312 which is 1. This routine will also work for arrays with bounds
2332 /* Given that arr is an array value, returns the length of the
2363 /* An empty array whose type is that of ARR_TYPE (an array type),
2400 user-defined into appropriate function calls. If CONTEXT_TYPE is
2404 return type is preferred. May change (expand) *EXP. */
2419 when DEPROCEDURE_P is non-zero, converting function-valued variables
2781 MAY_DEREF is non-zero, the formal may be a pointer and the actual
2782 a non-pointer. A type of 'void' (which is never a valid expression type)
2784 /* The term "match" here is rather loose. The match is heuristic and
2846 may also be an enumeral, in which case it is treated as a 0-
2882 FUNC_TYPE is not a valid function type with a non-null return type
2913 ARGS. If CONTEXT_TYPE is non-null and there is at least one match
2915 CONTEXT_TYPE is void and there is at least one match that does not
2918 Asks the user if there is more than one match remaining. Returns -1
2919 if there is no such symbol or none is selected. NAME is used
2921 the process; the index returned is for the modified vector. */
2972 The idea is that overloadings of a subprogram name from the
3131 The user is not allowed to choose more than MAX_RESULTS values.
3133 ANNOTATION_SUFFIX, if present, is used to annotate the input
3246 /* True iff TYPE is numeric (i.e., an INT, RANGE (of numeric type),
3270 /* True iff TYPE is integral (an INT or RANGE of INTs). */
3292 /* True iff TYPE is scalar (INT, RANGE, FLOAT, ENUM). */
3314 /* True iff TYPE is discrete (INT, RANGE, ENUM). */
3406 is XR for an object renaming, XRP for a procedure renaming, XRE for
3438 name of the renamed entity. The name is good until the end of
3468 /* Return an lvalue containing the value VAL. This is the identity on
3480 /* The following is taken from the structure-return code in
3560 an lvalue representing the new descriptor, or (if TYPE is a pointer-
3630 /* Dummy definitions for an experimental caching module that is not
3669 /* Non-zero iff there is at least one non-function/non-enumeral symbol
3706 /* True iff SYM0 represents the same entity as SYM1, or one that is
3744 records in OBSTACKP. Do nothing if SYM is a duplicate. */
3999 rules. Returns NULL if there is no such minimal symbol. Names
4000 prefixed with "standard__" are handled specially: "standard__" is
4066 /* True if TYPE is definitely an artificial type supplied to a symbol
4078 this happens is when object files containing stabs-in-ecoff are
4140 at suffix - 3, as the <rename> part is at least one character long. */
4165 to NAME not existing in our list of symbols. There is only one
4170 /* If it is a function that has not been defined at library level,
4188 /* Return nonzero if SYM corresponds to a renaming entity that is
4198 /* If the rename has been defined in a package, then it is visible. */
4202 /* Check that the rename is in the current function scope by checking
4205 /* If the function name starts with "_ada_", it means that it is
4216 a renaming entity that is not visible from the function associated
4235 is another rename entity defined in a package: Normally, the
4237 package, so the latter should be removed from the list. This is
4267 /* Check each of the symbols, and remove it from the list if it is
4268 a type corresponding to a renaming that is out of the scope of
4295 symbol match within the nest of blocks whose innermost member is BLOCK0,
4296 is the one match returned (no other matches in that or
4297 enclosing blocks is returned). If there are any matches in or
4301 is first stripped off, and only static and global symbols are searched. */
4495 scope and in global scopes, or NULL if none. NAME is folded and
4496 encoded first. Otherwise, the result is as for ada_lookup_symbol_list,
4498 *IS_A_FIELD_OF_THIS is set to 0 and *SYMTAB is set to the symbol
4561 /* True iff STR is a possible encoded suffix of a normal Ada name
4562 that is to be ignored for matching purposes. Suffixes of parallel
4610 is fine in this case, but may become problematic later if we find
4672 is only used to work around a problem found during wild matching
4674 obtained from dwarf-2 data. This function is therefore currently
4675 only used in wild_match() and is likely to be deleted when the
4676 problem in dwarf-2 is fixed. */
4692 informational suffixes of NAME (i.e., for which is_name_suffix is
4703 stored in the symbol table for nested function names is sometimes
4705 the dwarf-2 data: This is the case for nested subprograms, where
4714 Ada programs. A corollary is that the symbol names in the dwarf-2
4718 Until the compiler is properly fixed, we work-around the problem
4788 OBJFILE is the section containing BLOCK.
4789 SYMTAB is recorded with each symbol added. */
4941 /* True if field number FIELD_NUM in struct or union type TYPE is supposed
4998 saved at VALADDR, if it is non-null, or is at memory address
5035 The value stored in ARGS->name is valid until the next call to
5095 parent-type (inherited) fields of a derived type. Assumes TYPE is
5107 /* True iff field number FIELD_NUM of structure type TYPE is a
5109 field selection and flattened when printing). Assumes TYPE is a
5125 is a variant wrapper. Assumes TYPE is a structure type with at least
5138 /* Assuming that VAR_TYPE is a variant wrapper (type of the variant part)
5154 /* Assuming that TYPE is the type of a variant wrapper, and FIELD_NUM is a
5165 /* Assuming that TYPE0 is the type of the variant part of a record,
5167 The value is valid until the next call to ada_variant_discrim_name. */
5254 above is always equivalent to the negative of RU. */
5261 /* Assuming that TYPE is a variant part wrapper type (a VARIANTS field),
5262 and FIELD_NUM is a valid field number within it, returns 1 iff VAL is
5340 *BIT_SIZE_P to its size in bits if the field is packed, and 0 otherwise.
5456 appropriate type. If ARG is a pointer or reference and the field
5457 is not packed, returns a reference to the field, otherwise the
5458 value of the field (an lvalue if ARG is an lvalue).
5464 ERR is a name (for use in error messages) that identifies the class
5465 of entity that ARG is supposed to be. ERR may be null, indicating
5467 throw an error. (FIXME: True only if ARG is a pointer or reference
5521 error ("Attempt to extract a component of a value that is not a %s.",
5560 error ("There is no member named %s.", name);
5566 If DISPP is non-null, add its byte displacement from the beginning of a
5579 If NOERR is nonzero, return NULL if NAME is not suitably defined or
5580 TYPE is not a type of the right kind. */
5616 error (" is not a structure or union type");
5686 /* Assuming that VAR_TYPE is the type of a variant part of a record (a union),
5687 within a value of type OUTER_TYPE that is stored in GDB at
5689 numbering from 0) is applicable. Returns -1 if none are. */
5727 (i.e., a size that is not statically recorded in the debugging
5729 Our strategy is to convert these values to values with accurate,
5732 /* There is a subtle and tricky problem here. In general, we cannot
5748 Unfortunately, there is one exception: if one of the internal
5749 history variables is an array whose elements are unconstrained
5753 /* The upshot of all of this is that many routines take a (type, host
5755 The host address, if non-null, is supposed to contain an internal
5756 copy of the relevant data; otherwise, the program is to consult the
5848 for its ___XR counterpart, which is the ``renaming'' symbol
5860 /* If the symbol is defined inside a function, NAME is not fully
5891 given type name. If the type denoted by TYPE0 is to be preferred to
5919 /* The name of TYPE, which is either its TYPE_NAME, or, if that is
5920 null, its TYPE_TAG_NAME. Null if TYPE is null. */
5933 /* Find a parallel type to TYPE whose name is formed by appending
5958 /* If TYPE is a variable-size record type, return the corresponding template
5979 /* Assuming that TEMPL_TYPE is a union or struct type, returns
6030 necessary discriminants. It should be NULL if VALUE_TYPE (VAL) is
6032 variant field (unless unchecked) is replaced by a particular branch
6134 odd cases in which it is re-ordered so as NOT the last field of
6175 positive value. If null or negative, then something is wrong, most
6177 of the resulting type. If this record is not part of another structure,
6193 error ("record type with dynamic size is larger than varsize-limit");
6261 whose address in memory is ADDRESS, returns a revision of TYPE --
6263 the variant part is replaced with the appropriate branch. Looks
6335 unchecked) is replaced by a particular branch of the variant.
6337 NOTE: the case in which DVAL and VALADDR are NULL and ADDRESS is 0
6338 is questionable and may be removed. It can arise during the
6340 variant branches have exactly the same size. This is because in
6374 the value at (VAR_TYPE0, VALADDR, ADDRESS), where VAR_TYPE0 is a
6376 a record value. That is, this routine selects the appropriate
6416 /* Assuming that TYPE0 is an array type describing the type of a value
6419 contains no dynamic components (that is, no components whose sizes
6420 are determined by run-time quantities). Unless IGNORE_TOO_BIG is
6421 true, gives an error message if the resulting type's size is over
6472 error ("array type with dynamic size is larger than varsize-limit");
6580 type FooP is access Foo;
6582 type Foo is array ...;
6583 ). In these cases, since there is no mechanism for producing
6585 stub enumeration type that is nowhere resolved, and whose tag is
6588 /* A type equivalent to TYPE that is not a non-record stub, if one
6609 describes it. If VAL0 is not NULL and TYPE0 already is a standard
6610 type, then return VAL0 [this feature is simply to avoid redundant
6639 types, therefore, the type of the result is likely to be inaccurate. */
6705 error ("enumeration value is invalid: can't find 'POS");
6743 [At the moment, this is true only for Character and Wide_Character;
6744 It is a heuristic test that could stand improvement]. */
6781 /* True if TYPE is a struct type introduced by the compiler to force the
6791 be used instead of this type. And hence, this is not an aligner
6801 /* If there is an ___XVS-convention type parallel to SUBTYPE, return
6856 name NAME. The value is good to the next call of ada_enum_name. */
6870 but stop searching when we hit an overloading suffix, which is
6944 /* If VAL is wrapped in an aligner or subtype wrapper, return the
7167 /* This is in case of the really obscure (and undocumented,
7169 is an integer constant and Foo is a dynamic-sized type.
7286 context other than a function call, in which case, it is
7429 /* If this is a reference to an aligner type, then remove all
7439 /* If this is a reference to an array or an array lvalue,
7463 the compiler is incorrect or incomplete. */
7599 ("attempt to take bound of something that is not an array");
7653 ("attempt to take bound of something that is not an array");
7806 arg1 = ada_coerce_ref (arg1); /* FIXME: What is this for?? */
7849 /* The value is not supposed to be used. This is here to make it
7909 /* Assuming that TYPE is the representation of an Ada fixed-point
7910 type, return its delta, or -1 if the type is malformed and the
7946 /* Assuming that X is the representation of a value of fixed-point
7982 /* The type of special VAX floating-point type this is, assuming
8017 PNEW_K is not null, put the position of the character beyond the
8060 no such variable found, then if ERR_MSG is null, returns 0, and
8107 /* Return a range type whose base type is that of the range type named
8112 information, in general, is encoded in NAME, the base type given in
8199 /* True iff NAME is the name of a range type. */
8211 /* True iff TYPE is an Ada modular type. */
8284 /* As for operator_length, but assumes PC is pointing at the first
8504 (short, int, long) in the debugging information. There is some dis-
8505 agreement as to how useful this feature is. In particular, gcc does
8728 case_sensitive_on, /* Yes, Ada is case-insensitive, but