print.c 6.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322
  1. /* $Header$ */
  2. #include <alloc.h>
  3. #include <assert.h>
  4. #include <stdio.h>
  5. #include "type.h"
  6. #include "message.h"
  7. #include "langdep.h"
  8. #include "scope.h"
  9. #include "symbol.h"
  10. #include "position.h"
  11. #include "idf.h"
  12. extern FILE *db_out;
  13. extern long float_size, pointer_size, int_size;
  14. static
  15. print_literal(tp, v)
  16. p_type tp;
  17. int v;
  18. {
  19. register struct literal *lit = tp->ty_literals;
  20. register int i;
  21. for (i = tp->ty_nenums; i; i--, lit++) {
  22. if (lit->lit_val == v) {
  23. fprintf(db_out, lit->lit_name);
  24. break;
  25. }
  26. }
  27. if (! i) {
  28. fprintf(db_out, "unknown enumeration value %d", v);
  29. }
  30. }
  31. static
  32. print_unsigned(tp, v)
  33. p_type tp;
  34. long v;
  35. {
  36. if (tp == uchar_type) {
  37. fprintf(db_out, currlang->char_fmt, (int) v);
  38. }
  39. else fprintf(db_out, currlang->uns_fmt, v);
  40. }
  41. static
  42. print_integer(tp, v)
  43. p_type tp;
  44. long v;
  45. {
  46. if (tp == char_type) {
  47. fprintf(db_out, currlang->char_fmt, (int) v);
  48. }
  49. else fprintf(db_out, currlang->decint_fmt, v);
  50. }
  51. print_params(tp, AB, static_link)
  52. p_type tp;
  53. t_addr AB;
  54. {
  55. char *param_bytes;
  56. register char *p;
  57. register int i;
  58. register struct param *par;
  59. long size;
  60. if (! tp) return;
  61. assert(tp->ty_class == T_PROCEDURE);
  62. if ((i = tp->ty_nparams) == 0) return;
  63. /* get parameter bytes */
  64. par = tp->ty_params;
  65. size = tp->ty_nbparams;
  66. if (static_link) size += pointer_size;
  67. param_bytes = p = Malloc((unsigned)size);
  68. if (static_link) p += pointer_size;
  69. if (! get_bytes(size, AB, param_bytes)) {
  70. error("no debuggee");
  71. free(param_bytes);
  72. return;
  73. }
  74. while (i--) {
  75. if (par->par_kind == 'v' || par->par_kind == 'i') {
  76. /* call by reference parameter, or
  77. call by value parameter, but address is passed;
  78. try and get value.
  79. */
  80. char *q;
  81. if ((size = par->par_type->ty_size) == 0) {
  82. size = compute_size(par->par_type, param_bytes);
  83. }
  84. q = Malloc((unsigned) size);
  85. if (! get_bytes(size, (t_addr) BUFTOA(p), q)) {
  86. fprintf(db_out, currlang->addr_fmt, BUFTOA(p));
  87. }
  88. else {
  89. print_val(par->par_type, q, 1, 0, param_bytes);
  90. }
  91. free(q);
  92. }
  93. else print_val(par->par_type, p, 1, 0, param_bytes);
  94. if (i) fputs(", ", db_out);
  95. p += param_size(par->par_type, par->par_kind);
  96. par++;
  97. }
  98. free(param_bytes);
  99. }
  100. print_val(tp, addr, compressed, indent, AB)
  101. p_type tp; /* type of value to be printed */
  102. char *addr; /* address to get value from */
  103. int compressed; /* for parameter lists */
  104. int indent; /* indentation */
  105. char *AB; /* argument base for dynamic subranges */
  106. {
  107. long sz;
  108. register int i;
  109. long elsize;
  110. if (indent == 0) indent = 4;
  111. switch(tp->ty_class) {
  112. case T_SUBRANGE:
  113. print_val(tp->ty_base, addr, compressed, indent, AB);
  114. break;
  115. case T_ARRAY:
  116. if (tp->ty_elements == char_type ||
  117. tp->ty_elements == uchar_type) {
  118. print_val(string_type, addr, compressed, indent, AB);
  119. break;
  120. }
  121. if ((sz = tp->ty_size) == 0) sz = compute_size(tp, AB);
  122. if (compressed) {
  123. fprintf(db_out, currlang->open_array_display);
  124. }
  125. else {
  126. fprintf(db_out, "\n%*c%s%*c",
  127. indent,
  128. ' ',
  129. currlang->open_array_display,
  130. 4-strlen(currlang->open_array_display), ' ');
  131. }
  132. indent += 4;
  133. elsize = (*currlang->arrayelsize)(tp->ty_elements->ty_size);
  134. for (i = sz/elsize; i; i--) {
  135. print_val(tp->ty_elements, addr, compressed, indent, AB);
  136. addr += elsize;
  137. if (compressed && i > 1) {
  138. fprintf(db_out, ", ...");
  139. break;
  140. }
  141. if (i > 1) {
  142. fputc(',', db_out);
  143. }
  144. fprintf(db_out, "\n%*c", i > 1 ? indent : indent - 4, ' ');
  145. }
  146. fprintf(db_out, currlang->close_array_display);
  147. indent -= 4;
  148. break;
  149. case T_STRUCT: {
  150. register struct fields *fld = tp->ty_fields;
  151. if (compressed) {
  152. fprintf(db_out, currlang->open_struct_display);
  153. }
  154. else {
  155. fprintf(db_out, "\n%*c%s%*c",
  156. indent,
  157. ' ',
  158. currlang->open_struct_display,
  159. 4-strlen(currlang->open_struct_display), ' ');
  160. }
  161. indent += 4;
  162. for (i = tp->ty_nfields; i; i--, fld++) {
  163. if (! compressed) fprintf(db_out, "%s = ", fld->fld_name);
  164. if (fld->fld_bitsize != fld->fld_type->ty_size << 3) {
  165. /* apparently a bit field */
  166. /* ??? */
  167. fprintf(db_out, "<bitfield, %d, %d>", fld->fld_bitsize, fld->fld_type->ty_size);
  168. }
  169. else print_val(fld->fld_type, addr+(fld->fld_pos>>3), compressed, indent, AB);
  170. if (compressed && i > 1) {
  171. fprintf(db_out, ", ...");
  172. break;
  173. }
  174. if (i > 1) {
  175. fputc(',', db_out);
  176. }
  177. fprintf(db_out, "\n%*c", i > 1 ? indent : indent - 4, ' ');
  178. }
  179. indent -= 4;
  180. fprintf(db_out, currlang->close_struct_display);
  181. break;
  182. }
  183. case T_UNION:
  184. fprintf(db_out, "<union>");
  185. break;
  186. case T_ENUM:
  187. print_literal(tp, tp->ty_size == 1
  188. ? (*addr & 0xFF)
  189. : tp->ty_size == 2
  190. ? (BUFTOS(addr) & 0xFFFF)
  191. : (int) BUFTOL(addr));
  192. break;
  193. case T_PROCEDURE: {
  194. register p_scope sc = get_scope_from_addr((t_addr) BUFTOA(addr));
  195. if (sc && sc->sc_definedby) {
  196. fprintf(db_out, sc->sc_definedby->sy_idf->id_text);
  197. break;
  198. }
  199. }
  200. /* Fall through */
  201. case T_POINTER:
  202. fprintf(db_out, currlang->addr_fmt, (long) BUFTOA(addr));
  203. break;
  204. case T_FILE:
  205. fprintf(db_out, "<file>");
  206. break;
  207. case T_SET: {
  208. long val = tp->ty_setlow;
  209. p_type base = tp->ty_setbase;
  210. long nelements = tp->ty_size << 3;
  211. int count = 0;
  212. int rsft = 3 + (int_size == 2 ? 1 : 2);
  213. long mask = int_size == 2 ? 0xFFFF : 0xFFFFFFFF;
  214. if (base->ty_class == T_SUBRANGE) base = base->ty_base;
  215. if (compressed) {
  216. fprintf(db_out, currlang->open_set_display);
  217. }
  218. else {
  219. fprintf(db_out, "\n%*c%s%*c",
  220. indent,
  221. ' ',
  222. currlang->open_set_display,
  223. 4-strlen(currlang->open_set_display), ' ');
  224. }
  225. indent += 4;
  226. for (i = 0; i < nelements; i++) {
  227. if (*((int *) addr + (i >> rsft)) & (1 << (i & mask))) {
  228. count++;
  229. if (count > 1) {
  230. if (compressed) {
  231. fprintf(db_out, ", ...");
  232. break;
  233. }
  234. fprintf(db_out, ",\n%*c", indent , ' ');
  235. }
  236. switch(base->ty_class) {
  237. case T_INTEGER:
  238. print_integer(base, val+i);
  239. break;
  240. case T_UNSIGNED:
  241. print_unsigned(base, val+i);
  242. break;
  243. case T_ENUM:
  244. print_literal(base, (int)val+i);
  245. break;
  246. default:
  247. assert(0);
  248. }
  249. }
  250. }
  251. if (! compressed) {
  252. fprintf(db_out, "\n%*c", indent-4 , ' ');
  253. }
  254. indent -= 4;
  255. fprintf(db_out, currlang->close_set_display);
  256. }
  257. break;
  258. case T_REAL: {
  259. double val = tp->ty_size == float_size
  260. ? BUFTOF(addr)
  261. : BUFTOD(addr);
  262. fprintf(db_out, currlang->real_fmt, val);
  263. break;
  264. }
  265. case T_UNSIGNED:
  266. print_unsigned(tp, tp->ty_size == 1
  267. ? (*addr & 0xFF)
  268. : tp->ty_size == 2
  269. ? (BUFTOS(addr) & 0xFFFF)
  270. : BUFTOL(addr));
  271. break;
  272. case T_INTEGER:
  273. print_integer(tp, tp->ty_size == 1
  274. ? *addr
  275. : tp->ty_size == 2
  276. ? BUFTOS(addr)
  277. : BUFTOL(addr));
  278. break;
  279. case T_STRING:
  280. (*currlang->printstring)(addr);
  281. break;
  282. default:
  283. assert(0);
  284. break;
  285. }
  286. }
  287. int
  288. print_sym(sym)
  289. p_symbol sym;
  290. {
  291. char *buf;
  292. char *AB;
  293. if (get_value(sym, &buf, &AB)) {
  294. fputs(" = ", db_out);
  295. print_val(sym->sy_type, buf, 0, 0, AB);
  296. if (buf) free(buf);
  297. if (AB) free(AB);
  298. fputs("\n", db_out);
  299. return 1;
  300. }
  301. return 0;
  302. }