1 /* Print in infix form a struct expression. 2 3 Copyright (C) 1986-2023 Free Software Foundation, Inc. 4 5 This file is part of GDB. 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 3 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 19 20 #include "defs.h" 21 #include "symtab.h" 22 #include "gdbtypes.h" 23 #include "expression.h" 24 #include "value.h" 25 #include "language.h" 26 #include "parser-defs.h" 27 #include "user-regs.h" /* For user_reg_map_regnum_to_name. */ 28 #include "target.h" 29 #include "block.h" 30 #include "objfiles.h" 31 #include "valprint.h" 32 #include "cli/cli-style.h" 33 #include "c-lang.h" 34 #include "expop.h" 35 #include "ada-exp.h" 36 37 #include <ctype.h> 38 39 /* Default name for the standard operator OPCODE (i.e., one defined in 40 the definition of enum exp_opcode). */ 41 42 const char * 43 op_name (enum exp_opcode opcode) 44 { 45 switch (opcode) 46 { 47 default: 48 { 49 static char buf[30]; 50 51 xsnprintf (buf, sizeof (buf), "<unknown %d>", opcode); 52 return buf; 53 } 54 #define OP(name) \ 55 case name: \ 56 return #name ; 57 #include "std-operator.def" 58 #undef OP 59 } 60 } 61 62 /* Meant to be used in debug sessions, so don't export it in a header file. */ 63 extern void ATTRIBUTE_USED debug_exp (struct expression *exp); 64 65 /* Print EXP. */ 66 67 void 68 ATTRIBUTE_USED 69 debug_exp (struct expression *exp) 70 { 71 exp->op->dump (gdb_stdlog, 0); 72 gdb_flush (gdb_stdlog); 73 } 74 75 namespace expr 76 { 77 78 void 79 dump_for_expression (struct ui_file *stream, int depth, enum exp_opcode op) 80 { 81 gdb_printf (stream, _("%*sOperation: %s\n"), depth, "", op_name (op)); 82 } 83 84 void 85 dump_for_expression (struct ui_file *stream, int depth, const std::string &str) 86 { 87 gdb_printf (stream, _("%*sString: %s\n"), depth, "", str.c_str ()); 88 } 89 90 void 91 dump_for_expression (struct ui_file *stream, int depth, struct type *type) 92 { 93 gdb_printf (stream, _("%*sType: "), depth, ""); 94 type_print (type, nullptr, stream, 0); 95 gdb_printf (stream, "\n"); 96 } 97 98 void 99 dump_for_expression (struct ui_file *stream, int depth, CORE_ADDR addr) 100 { 101 gdb_printf (stream, _("%*sConstant: %s\n"), depth, "", 102 core_addr_to_string (addr)); 103 } 104 105 void 106 dump_for_expression (struct ui_file *stream, int depth, internalvar *ivar) 107 { 108 gdb_printf (stream, _("%*sInternalvar: $%s\n"), depth, "", 109 internalvar_name (ivar)); 110 } 111 112 void 113 dump_for_expression (struct ui_file *stream, int depth, symbol *sym) 114 { 115 gdb_printf (stream, _("%*sSymbol: %s\n"), depth, "", 116 sym->print_name ()); 117 } 118 119 void 120 dump_for_expression (struct ui_file *stream, int depth, 121 bound_minimal_symbol msym) 122 { 123 gdb_printf (stream, _("%*sMinsym %s in objfile %s\n"), depth, "", 124 msym.minsym->print_name (), objfile_name (msym.objfile)); 125 } 126 127 void 128 dump_for_expression (struct ui_file *stream, int depth, const block *bl) 129 { 130 gdb_printf (stream, _("%*sBlock: %p\n"), depth, "", bl); 131 } 132 133 void 134 dump_for_expression (struct ui_file *stream, int depth, 135 const block_symbol &sym) 136 { 137 gdb_printf (stream, _("%*sBlock symbol:\n"), depth, ""); 138 dump_for_expression (stream, depth + 1, sym.symbol); 139 dump_for_expression (stream, depth + 1, sym.block); 140 } 141 142 void 143 dump_for_expression (struct ui_file *stream, int depth, 144 type_instance_flags flags) 145 { 146 gdb_printf (stream, _("%*sType flags: "), depth, ""); 147 if (flags & TYPE_INSTANCE_FLAG_CONST) 148 gdb_puts ("const ", stream); 149 if (flags & TYPE_INSTANCE_FLAG_VOLATILE) 150 gdb_puts ("volatile", stream); 151 gdb_printf (stream, "\n"); 152 } 153 154 void 155 dump_for_expression (struct ui_file *stream, int depth, 156 enum c_string_type_values flags) 157 { 158 gdb_printf (stream, _("%*sC string flags: "), depth, ""); 159 switch (flags & ~C_CHAR) 160 { 161 case C_WIDE_STRING: 162 gdb_puts (_("wide "), stream); 163 break; 164 case C_STRING_16: 165 gdb_puts (_("u16 "), stream); 166 break; 167 case C_STRING_32: 168 gdb_puts (_("u32 "), stream); 169 break; 170 default: 171 gdb_puts (_("ordinary "), stream); 172 break; 173 } 174 175 if ((flags & C_CHAR) != 0) 176 gdb_puts (_("char"), stream); 177 else 178 gdb_puts (_("string"), stream); 179 gdb_puts ("\n", stream); 180 } 181 182 void 183 dump_for_expression (struct ui_file *stream, int depth, 184 enum range_flag flags) 185 { 186 gdb_printf (stream, _("%*sRange:"), depth, ""); 187 if ((flags & RANGE_LOW_BOUND_DEFAULT) != 0) 188 gdb_puts (_("low-default "), stream); 189 if ((flags & RANGE_HIGH_BOUND_DEFAULT) != 0) 190 gdb_puts (_("high-default "), stream); 191 if ((flags & RANGE_HIGH_BOUND_EXCLUSIVE) != 0) 192 gdb_puts (_("high-exclusive "), stream); 193 if ((flags & RANGE_HAS_STRIDE) != 0) 194 gdb_puts (_("has-stride"), stream); 195 gdb_printf (stream, "\n"); 196 } 197 198 void 199 dump_for_expression (struct ui_file *stream, int depth, 200 const std::unique_ptr<ada_component> &comp) 201 { 202 comp->dump (stream, depth); 203 } 204 205 void 206 float_const_operation::dump (struct ui_file *stream, int depth) const 207 { 208 gdb_printf (stream, _("%*sFloat: "), depth, ""); 209 print_floating (m_data.data (), m_type, stream); 210 gdb_printf (stream, "\n"); 211 } 212 213 } /* namespace expr */ 214