print.c 6.5 KB

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