Lines Matching +defs:decl +defs:type +defs:start
109 char *b; /* pointer to start of string */
132 int temp_start; /* index in demangled to start of template args */
133 int type_quals; /* The type qualifiers. */
234 /* These values are used to indicate the various type varieties.
451 /* There is a TYPE_QUAL value for each type qualifier. They can be
453 type. */
492 consume_count (const char **type)
496 if (! ISDIGIT ((unsigned char)**type))
499 while (ISDIGIT ((unsigned char)**type))
510 while (ISDIGIT ((unsigned char) **type))
511 (*type)++;
515 count += **type - '0';
516 (*type)++;
560 /* C is the code for a type-qualifier. Return the TYPE_QUAL
625 /* C is the code for a type-qualifier. Return the string
639 string type;
653 /* type conversion operator. */
655 if (do_type (work, &tem, &type))
658 strncat (result, type.b, type.p - type.b);
659 string_delete (&type);
744 else if (len >= 5 && memcmp (opname, "type", 4) == 0
747 /* type conversion operator */
749 if (do_type (work, &tem, &type))
752 strncat (result, type.b, type.p - type.b);
753 string_delete (&type);
1014 string decl;
1028 string_init (&decl);
1039 success = gnu_special (work, &mangled, &decl);
1043 success = demangle_prefix (work, &mangled, &decl);
1047 success = demangle_signature (work, &mangled, &decl);
1051 string_prepend (&decl, "global constructors keyed to ");
1056 string_prepend (&decl, "global destructors keyed to ");
1061 string_prepend (&decl, "import stub for ");
1064 demangled = mop_up (work, &decl, success);
1078 /* clean up the B and K type mangling types. */
1210 terminated and return it. Otherwise, free the demangling decl. */
1251 explicit token that marks the start of the outermost function
1385 find the function return type (preceded by an '_') or the
1390 /* At this level, we do not care about the return type. */
1434 /* Read the return type. */
1446 /* At the outermost level, we cannot have a return type specified,
1483 argument token, and start processing args. */
1489 /* Non-GNU demanglers use a specific token to mark the start
1587 /* Z for type parameters */
1735 multi-digit numbers that do not start with an underscore,
1900 or type-code information we have built up thus far; it is
1926 non-NULL. If IS_TYPE is nonzero, this template is a type template,
2011 /* Z for type parameters */
2146 /* Check if ARM template with "__pt__" in it ("parameterized type") */
2236 /* 'T' signals a type parameter */
2299 /* Check for type or literal here */
2303 /* spec: Xt1Lv1 where t1 is a type, v1 is a literal value */
2509 "__" sequence in them. We must start with the first (not the last)
2650 /* We found a sequence of two or more '_', ensure that we start at
2689 names like __Q2_3foo3bar for nested type names. So don't accept
2699 /* Cfront-style parameterized type. Handled later as a signature. */
2709 /* EDG-style parameterized type. Handled later as a signature. */
2740 /* Mangled name does not start with "__" but does have one somewhere
2814 and create the decl. Note that we consume the entire mangled
3049 and create the decl. Note that we consume the entire mangled
3214 in LAST_NAME. We do not remember the template type here,
3308 get_count (const char **type, int *count)
3312 Assume that *type points at a count in a mangled name; set
3313 *count to its value, and set *type to the next character after
3316 If *type does not point at a string of digits, return zero.
3318 If *type points at a string of digits followed by an
3320 *type to point *after the underscore, and return 1.
3322 If *type points at a string of digits not followed by an
3324 value as an integer, leave *type pointing after that digit,
3328 styles, a type can be followed by a repeat count of the form
3332 of the type to append to the argument list, and
3346 get_count (const char **type, int *count)
3351 if (!ISDIGIT ((unsigned char)**type))
3355 *count = **type - '0';
3356 (*type)++;
3357 if (ISDIGIT ((unsigned char)**type))
3359 p = *type;
3370 *type = p + 1;
3387 string decl;
3392 string_init (&decl);
3403 /* A pointer type */
3408 string_prepend (&decl, "*");
3413 /* A reference type */
3416 string_prepend (&decl, "&");
3425 if (!STRING_EMPTY (&decl)
3426 && (decl.b[0] == '*' || decl.b[0] == '&'))
3428 string_prepend (&decl, "(");
3429 string_append (&decl, ")");
3431 string_append (&decl, "[");
3433 success = demangle_template_value_parm (work, mangled, &decl,
3437 string_append (&decl, "]");
3441 /* A back reference to a previously seen type */
3458 if (!STRING_EMPTY (&decl)
3459 && (decl.b[0] == '*' || decl.b[0] == '&'))
3461 string_prepend (&decl, "(");
3462 string_append (&decl, ")");
3465 function return type (preceded by an '_') or the end of the
3467 if (!demangle_nested_args (work, mangled, &decl)
3485 string_append (&decl, ")");
3490 string_prepend (&decl, SCOPE_STRING (work));
3501 string_prependn (&decl, *mangled, n);
3508 string_prepends (&decl, &temp);
3519 string_prependn (&decl, temp.b, temp.p - temp.b);
3527 success = demangle_qualified (work, mangled, &decl,
3539 string_prepend (&decl, "(");
3561 if ((member && !demangle_nested_args (work, mangled, &decl))
3574 APPEND_BLANK (&decl);
3575 string_append (&decl, qualifier_string (type_quals));
3588 if (!STRING_EMPTY (&decl))
3589 string_prepend (&decl, " ");
3591 string_prepend (&decl, demangle_qualifier (**mangled));
3616 /* A back reference to a previously seen squangled type */
3660 if (!STRING_EMPTY (&decl))
3663 string_appends (result, &decl);
3668 string_delete (&decl);
3671 /* Assume an integral type, if we're not sure. */
3677 /* Given a pointer to a type string that represents a fundamental type
3700 /* First pick off any type qualifiers. There can be more than one. */
3738 /* Now pick off the fundamental type. There can be only one. */
3844 /* An explicit type, such as "6mytype" or "7integer" */
4021 /* Remember where we started so that we can record the type, for
4022 non-squangling type remembering. */
4023 const char *start = *mangled;
4034 /* We want to reissue the previous type in this argument list. */
4066 type vector when processing a repeated type. */
4077 remember_type (work, start, *mangled - start);
4082 remember_type (struct work_stuff *work, const char *start, int len)
4104 memcpy (tem, start, len);
4110 /* Remember a K type class qualifier. */
4112 remember_Ktype (struct work_stuff *work, const char *start, int len)
4131 memcpy (tem, start, len);
4164 /* Store a value into a previously registered B code type. */
4167 remember_Btype (struct work_stuff *work, const char *start,
4173 memcpy (tem, start, len);
4178 /* Lose all the info related to B and K type codes. */
4204 /* Forget the remembered types, but not the type vector itself. */
4254 Note that g++ bases its type numbers starting at zero and counts all
4255 previously seen types, while lucid/ARM bases its type numbers starting
4257 indicating the start of the function args. For lucid/ARM style, we
4259 we see the 'F' character, and subtracting one from the type number
4306 will lose if the next thing is a type name preceded by a
4326 /* Validate the type index. Protect against illegal indices from
4327 malformed type strings. */
4397 type vector updated by remember_type is not used. So, we turn
4429 string type;
4443 following _F marks the start of the function arguments. Handle
4456 If so, then just record it, clear the decl, and return.
4457 We can't build the actual constructor/destructor decl until later,
4513 else if (declp->p - declp->b >= 5 && memcmp (declp->b, "type", 4) == 0
4516 /* type conversion operator */
4518 if (do_type (work, &tem, &type))
4522 string_appends (declp, &type);
4523 string_delete (&type);
4530 /* type conversion operator. */
4532 if (do_type (work, &tem, &type))
4536 string_appends (declp, &type);
4537 string_delete (&type);