static int ppc_stap_parse_special_token (struct gdbarch *gdbarch, struct stap_parse_info *p) { if (isdigit (*p->arg)) { /* This temporary pointer is needed because we have to do a lookahead. We could be dealing with a register displacement, and in such case we would not need to do anything. */ const char *s = p->arg; char *regname; int len; struct stoken str; while (isdigit (*s)) ++s; if (*s == '(') { /* It is a register displacement indeed. Returning 0 means we are deferring the treatment of this case to the generic parser. */ return 0; } len = s - p->arg; regname = alloca (len + 2); regname[0] = 'r'; strncpy (regname + 1, p->arg, len); ++len; regname[len] = '\0'; if (user_reg_map_name_to_regnum (gdbarch, regname, len) == -1) error (_("Invalid register name `%s' on expression `%s'."), regname, p->saved_arg); write_exp_elt_opcode (&p->pstate, OP_REGISTER); str.ptr = regname; str.length = len; write_exp_string (&p->pstate, str); write_exp_elt_opcode (&p->pstate, OP_REGISTER); p->arg = s; } else { /* All the other tokens should be handled correctly by the generic parser. */ return 0; } return 1; }
int scm_parse (void) { char *start; while (*lexptr == ' ') lexptr++; start = lexptr; scm_lreadr (USE_EXPRSTRING); #if USE_EXPRSTRING str.length = lexptr - start; str.ptr = start; write_exp_elt_opcode (OP_EXPRSTRING); write_exp_string (str); write_exp_elt_opcode (OP_EXPRSTRING); #endif return 0; }
static void scm_lreadr (int skipping) { int c, j; struct stoken str; LONGEST svalue = 0; tryagain: c = *lexptr++; switch (c) { case '\0': lexptr--; return; case '[': case '(': scm_lreadparen (skipping); return; case ']': case ')': error ("unexpected #\\%c", c); goto tryagain; case '\'': case '`': str.ptr = lexptr - 1; scm_lreadr (skipping); if (!skipping) { struct value *val = scm_evaluate_string (str.ptr, lexptr - str.ptr); if (!is_scmvalue_type (value_type (val))) error ("quoted scm form yields non-SCM value"); svalue = extract_signed_integer (value_contents (val), TYPE_LENGTH (value_type (val))); goto handle_immediate; } return; case ',': c = *lexptr++; if ('@' != c) lexptr--; scm_lreadr (skipping); return; case '#': c = *lexptr++; switch (c) { case '[': case '(': scm_lreadparen (skipping); return; case 't': case 'T': svalue = SCM_BOOL_T; goto handle_immediate; case 'f': case 'F': svalue = SCM_BOOL_F; goto handle_immediate; case 'b': case 'B': case 'o': case 'O': case 'd': case 'D': case 'x': case 'X': case 'i': case 'I': case 'e': case 'E': lexptr--; c = '#'; goto num; case '*': /* bitvector */ scm_read_token (c, 0); return; case '{': scm_read_token (c, 1); return; case '\\': /* character */ c = *lexptr++; scm_read_token (c, 0); return; case '|': j = 1; /* here j is the comment nesting depth */ lp: c = *lexptr++; lpc: switch (c) { case '\0': error ("unbalanced comment"); default: goto lp; case '|': if ('#' != (c = *lexptr++)) goto lpc; if (--j) goto lp; break; case '#': if ('|' != (c = *lexptr++)) goto lpc; ++j; goto lp; } goto tryagain; case '.': default: #if 0 callshrp: #endif scm_lreadr (skipping); return; } case '\"': while ('\"' != (c = *lexptr++)) { if (c == '\\') switch (c = *lexptr++) { case '\0': error ("non-terminated string literal"); case '\n': continue; case '0': case 'f': case 'n': case 'r': case 't': case 'a': case 'v': break; } } return; case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': case '.': case '-': case '+': num: { str.ptr = lexptr - 1; scm_read_token (c, 0); if (!skipping) { svalue = scm_istring2number (str.ptr, lexptr - str.ptr, 10); if (svalue != SCM_BOOL_F) goto handle_immediate; goto tok; } } return; case ':': scm_read_token ('-', 0); return; #if 0 do_symbol: #endif default: str.ptr = lexptr - 1; scm_read_token (c, 0); tok: if (!skipping) { str.length = lexptr - str.ptr; if (str.ptr[0] == '$') { write_dollar_variable (str); return; } write_exp_elt_opcode (OP_NAME); write_exp_string (str); write_exp_elt_opcode (OP_NAME); } return; } handle_immediate: if (!skipping) { write_exp_elt_opcode (OP_LONG); write_exp_elt_type (builtin_type_scm); write_exp_elt_longcst (svalue); write_exp_elt_opcode (OP_LONG); } }
static int aarch64_stap_parse_special_token (struct gdbarch *gdbarch, struct stap_parse_info *p) { if (*p->arg == '[') { /* Temporary holder for lookahead. */ const char *tmp = p->arg; char *endp; /* Used to save the register name. */ const char *start; char *regname; int len; int got_minus = 0; long displacement; struct stoken str; ++tmp; start = tmp; /* Register name. */ while (isalnum (*tmp)) ++tmp; if (*tmp != ',') return 0; len = tmp - start; regname = (char *) alloca (len + 2); strncpy (regname, start, len); regname[len] = '\0'; if (user_reg_map_name_to_regnum (gdbarch, regname, len) == -1) error (_("Invalid register name `%s' on expression `%s'."), regname, p->saved_arg); ++tmp; tmp = skip_spaces_const (tmp); /* Now we expect a number. It can begin with '#' or simply a digit. */ if (*tmp == '#') ++tmp; if (*tmp == '-') { ++tmp; got_minus = 1; } else if (*tmp == '+') ++tmp; if (!isdigit (*tmp)) return 0; displacement = strtol (tmp, &endp, 10); tmp = endp; /* Skipping last `]'. */ if (*tmp++ != ']') return 0; /* The displacement. */ write_exp_elt_opcode (&p->pstate, OP_LONG); write_exp_elt_type (&p->pstate, builtin_type (gdbarch)->builtin_long); write_exp_elt_longcst (&p->pstate, displacement); write_exp_elt_opcode (&p->pstate, OP_LONG); if (got_minus) write_exp_elt_opcode (&p->pstate, UNOP_NEG); /* The register name. */ write_exp_elt_opcode (&p->pstate, OP_REGISTER); str.ptr = regname; str.length = len; write_exp_string (&p->pstate, str); write_exp_elt_opcode (&p->pstate, OP_REGISTER); write_exp_elt_opcode (&p->pstate, BINOP_ADD); /* Casting to the expected type. */ write_exp_elt_opcode (&p->pstate, UNOP_CAST); write_exp_elt_type (&p->pstate, lookup_pointer_type (p->arg_type)); write_exp_elt_opcode (&p->pstate, UNOP_CAST); write_exp_elt_opcode (&p->pstate, UNOP_IND); p->arg = tmp; } else return 0; return 1; }
static int arm_stap_parse_special_token (struct gdbarch *gdbarch, struct stap_parse_info *p) { if (*p->arg == '[') { /* Temporary holder for lookahead. */ const char *tmp = p->arg; char *endp; /* Used to save the register name. */ const char *start; char *regname; int len, offset; int got_minus = 0; long displacement; struct stoken str; ++tmp; start = tmp; /* Register name. */ while (isalnum (*tmp)) ++tmp; if (*tmp != ',') return 0; len = tmp - start; regname = alloca (len + 2); offset = 0; if (isdigit (*start)) { /* If we are dealing with a register whose name begins with a digit, it means we should prefix the name with the letter `r', because GDB expects this name pattern. Otherwise (e.g., we are dealing with the register `fp'), we don't need to add such a prefix. */ regname[0] = 'r'; offset = 1; } strncpy (regname + offset, start, len); len += offset; regname[len] = '\0'; if (user_reg_map_name_to_regnum (gdbarch, regname, len) == -1) error (_("Invalid register name `%s' on expression `%s'."), regname, p->saved_arg); ++tmp; tmp = skip_spaces_const (tmp); if (*tmp++ != '#') return 0; if (*tmp == '-') { ++tmp; got_minus = 1; } displacement = strtol (tmp, &endp, 10); tmp = endp; /* Skipping last `]'. */ if (*tmp++ != ']') return 0; /* The displacement. */ write_exp_elt_opcode (OP_LONG); write_exp_elt_type (builtin_type (gdbarch)->builtin_long); write_exp_elt_longcst (displacement); write_exp_elt_opcode (OP_LONG); if (got_minus) write_exp_elt_opcode (UNOP_NEG); /* The register name. */ write_exp_elt_opcode (OP_REGISTER); str.ptr = regname; str.length = len; write_exp_string (str); write_exp_elt_opcode (OP_REGISTER); write_exp_elt_opcode (BINOP_ADD); /* Casting to the expected type. */ write_exp_elt_opcode (UNOP_CAST); write_exp_elt_type (lookup_pointer_type (p->arg_type)); write_exp_elt_opcode (UNOP_CAST); write_exp_elt_opcode (UNOP_IND); p->arg = tmp; } else return 0; return 1; }