print.c 8.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393
  1. /* $Id$ */
  2. #include <alloc.h>
  3. #include <assert.h>
  4. #include <stdio.h>
  5. #include "type.h"
  6. #include "langdep.h"
  7. #include "scope.h"
  8. #include "symbol.h"
  9. #include "position.h"
  10. #include "idf.h"
  11. #include "expr.h"
  12. #include "misc.h"
  13. extern FILE *db_out;
  14. extern char *strchr();
  15. extern char *malloc();
  16. static
  17. print_unsigned(tp, v, format)
  18. p_type tp;
  19. long v;
  20. register char *format;
  21. {
  22. while (format && *format) {
  23. if (strchr("cdohx", *format)) break;
  24. format++;
  25. }
  26. switch(format == 0 ? 0 : *format) {
  27. case 'u':
  28. fprintf(db_out, currlang->uns_fmt, v);
  29. break;
  30. default:
  31. if (tp != uchar_type) {
  32. fprintf(db_out, currlang->uns_fmt, v);
  33. break;
  34. }
  35. /* fall through */
  36. case 'c':
  37. (*currlang->printchar)((int) v);
  38. break;
  39. case 'd':
  40. fprintf(db_out, currlang->decint_fmt, v);
  41. break;
  42. case 'o':
  43. fprintf(db_out, currlang->octint_fmt, v);
  44. break;
  45. case 'x':
  46. case 'h':
  47. fprintf(db_out, currlang->hexint_fmt, v);
  48. break;
  49. }
  50. }
  51. static
  52. print_literal(tp, v, compressed, format)
  53. p_type tp;
  54. long v;
  55. int compressed;
  56. char *format;
  57. {
  58. register struct literal *lit = tp->ty_literals;
  59. register int i;
  60. if (format) {
  61. print_unsigned(tp, v, format);
  62. return;
  63. }
  64. for (i = tp->ty_nenums; i; i--, lit++) {
  65. if (lit->lit_val == v) {
  66. fputs(lit->lit_name, db_out);
  67. break;
  68. }
  69. }
  70. if (! i) {
  71. fprintf(db_out,
  72. compressed ? "?%ld?" : "unknown enumeration value %ld",
  73. v);
  74. }
  75. }
  76. static
  77. print_integer(tp, v, format)
  78. p_type tp;
  79. long v;
  80. register char *format;
  81. {
  82. while (format && *format) {
  83. if (strchr("cdohx", *format)) break;
  84. format++;
  85. }
  86. switch(format == 0 ? 0 : *format) {
  87. default:
  88. if (tp != char_type) {
  89. fprintf(db_out, currlang->decint_fmt, v);
  90. break;
  91. }
  92. /* fall through */
  93. case 'c':
  94. (*currlang->printchar)((int) v);
  95. break;
  96. case 'd':
  97. fprintf(db_out, currlang->decint_fmt, v);
  98. break;
  99. case 'o':
  100. fprintf(db_out, currlang->octint_fmt, v);
  101. break;
  102. case 'x':
  103. case 'h':
  104. fprintf(db_out, currlang->hexint_fmt, v);
  105. break;
  106. case 'u':
  107. fprintf(db_out, currlang->uns_fmt, v);
  108. break;
  109. }
  110. }
  111. print_params(tp, AB, static_link)
  112. p_type tp;
  113. t_addr AB;
  114. {
  115. char *param_bytes;
  116. register char *p;
  117. register int i;
  118. register struct param *par;
  119. long size;
  120. if (! tp) return;
  121. assert(tp->ty_class == T_PROCEDURE);
  122. if ((i = tp->ty_nparams) == 0) return;
  123. /* get parameter bytes */
  124. par = tp->ty_params;
  125. size = tp->ty_nbparams;
  126. if (static_link) size += pointer_size;
  127. param_bytes = p = malloc((unsigned)size);
  128. if (! p) {
  129. error("could not allocate enough memory");
  130. return;
  131. }
  132. if (! get_bytes(size, AB, p)) {
  133. free(p);
  134. return;
  135. }
  136. while (i--) {
  137. p = param_bytes + par->par_off;
  138. if (par->par_kind == 'v' || par->par_kind == 'i') {
  139. /* call by reference parameter, or
  140. call by value parameter, but address is passed;
  141. try and get value.
  142. */
  143. char *q;
  144. t_addr addr = get_int(p, pointer_size, T_UNSIGNED);
  145. if ((size = par->par_type->ty_size) == 0) {
  146. size = compute_size(par->par_type, param_bytes);
  147. }
  148. q = malloc((unsigned) size);
  149. if (! q) {
  150. error("could not allocate enough memory");
  151. free(param_bytes);
  152. return;
  153. }
  154. if (! get_bytes(size, addr, q)) {
  155. fprintf(db_out, currlang->addr_fmt, (long) addr);
  156. }
  157. else {
  158. print_val(par->par_type, size, q, 1, 0, (char *)0);
  159. }
  160. free(q);
  161. }
  162. else print_val(par->par_type, par->par_type->ty_size, p, 1, 0, (char *)0);
  163. if (i) fputs(", ", db_out);
  164. par++;
  165. }
  166. free(param_bytes);
  167. }
  168. print_val(tp, tp_sz, addr, compressed, indent, format)
  169. p_type tp; /* type of value to be printed */
  170. long tp_sz; /* size of object to be printed */
  171. char *addr; /* address to get value from */
  172. int compressed; /* for parameter lists */
  173. int indent; /* indentation */
  174. register char *format; /* format given or 0 */
  175. {
  176. register int i;
  177. long elsize;
  178. if (indent == 0) indent = 4;
  179. switch(tp->ty_class) {
  180. case T_CROSS:
  181. if (! tp->ty_cross) {
  182. error("unknown type");
  183. break;
  184. }
  185. print_val(tp->ty_cross, tp_sz, addr, compressed, indent, format);
  186. break;
  187. case T_SUBRANGE:
  188. print_val(tp->ty_base, tp_sz, addr, compressed, indent, format);
  189. break;
  190. case T_ARRAY:
  191. if ((!format || strchr(format, 'a') == 0) &&
  192. (tp->ty_elements == char_type ||
  193. tp->ty_elements == uchar_type)) {
  194. print_val(string_type, tp_sz, addr, compressed, indent, format);
  195. break;
  196. }
  197. if (compressed) {
  198. fprintf(db_out, currlang->open_array_display);
  199. }
  200. else {
  201. fprintf(db_out, "\n%*c%s%*c",
  202. indent,
  203. ' ',
  204. currlang->open_array_display,
  205. 4-strlen(currlang->open_array_display), ' ');
  206. }
  207. indent += 4;
  208. elsize = (*currlang->arrayelsize)(tp->ty_elements->ty_size);
  209. for (i = tp_sz/elsize; i; i--) {
  210. print_val(tp->ty_elements, tp->ty_elements->ty_size, addr, compressed, indent, format);
  211. addr += elsize;
  212. if (compressed && i > 1) {
  213. fprintf(db_out, ", ...");
  214. break;
  215. }
  216. if (i > 1) {
  217. putc(',', db_out);
  218. }
  219. fprintf(db_out, "\n%*c", i > 1 ? indent : indent - 4, ' ');
  220. }
  221. fprintf(db_out, currlang->close_array_display);
  222. indent -= 4;
  223. break;
  224. case T_STRUCT: {
  225. register struct fields *fld = tp->ty_fields;
  226. if (compressed) {
  227. fprintf(db_out, currlang->open_struct_display);
  228. }
  229. else {
  230. fprintf(db_out, "\n%*c%s%*c",
  231. indent,
  232. ' ',
  233. currlang->open_struct_display,
  234. 4-strlen(currlang->open_struct_display), ' ');
  235. }
  236. indent += 4;
  237. for (i = tp->ty_nfields; i; i--, fld++) {
  238. long sz = fld->fld_type->ty_size;
  239. if (! compressed) fprintf(db_out, "%s = ", fld->fld_name);
  240. if (fld->fld_bitsize < (sz << 3)) {
  241. /* apparently a bit field */
  242. /* ??? */
  243. fprintf(db_out, "<bitfield, %ld, %ld>", fld->fld_bitsize, sz);
  244. }
  245. else print_val(fld->fld_type, sz, addr+(fld->fld_pos>>3), compressed, indent, format);
  246. if (compressed && i > 1) {
  247. fprintf(db_out, ", ...");
  248. break;
  249. }
  250. if (i > 1) {
  251. putc(',', db_out);
  252. }
  253. fprintf(db_out, "\n%*c", i > 1 ? indent : indent - 4, ' ');
  254. }
  255. indent -= 4;
  256. fprintf(db_out, currlang->close_struct_display);
  257. break;
  258. }
  259. case T_UNION:
  260. fprintf(db_out, "<union>");
  261. break;
  262. case T_ENUM:
  263. print_literal(tp, get_int(addr, tp_sz, T_ENUM), compressed, format);
  264. break;
  265. case T_PROCEDURE: {
  266. register p_scope sc = get_scope_from_addr((t_addr) get_int(addr, pointer_size, T_UNSIGNED));
  267. if (sc && sc->sc_definedby) {
  268. fprintf(db_out, sc->sc_definedby->sy_idf->id_text);
  269. break;
  270. }
  271. }
  272. fprintf(db_out, currlang->addr_fmt, get_int(addr, pointer_size, T_UNSIGNED));
  273. break;
  274. case T_POINTER: {
  275. t_addr a = get_int(addr, tp_sz, T_UNSIGNED);
  276. fprintf(db_out, currlang->addr_fmt, a);
  277. if (format && strchr(format, 's') &&
  278. (tp->ty_ptrto == char_type || tp->ty_ptrto == uchar_type)) {
  279. char *naddr = malloc(512);
  280. if (! naddr) {
  281. fputs(" (could not allocate memory)", db_out);
  282. break;
  283. }
  284. if (! get_string(511L, a, naddr)) {
  285. fputs(" (not a valid pointer)", db_out);
  286. free(naddr);
  287. break;
  288. }
  289. fputs(" (", db_out);
  290. print_val(string_type, 512L, naddr, 0, indent, format);
  291. fputs(")", db_out);
  292. free(naddr);
  293. break;
  294. }
  295. if (tp->ty_ptrto->ty_class == T_PROCEDURE) {
  296. p_scope sc = get_scope_from_addr(a);
  297. if (sc && sc->sc_definedby && a == sc->sc_start) {
  298. fprintf(db_out, " (%s)", sc->sc_definedby->sy_idf->id_text);
  299. }
  300. }
  301. break;
  302. }
  303. case T_FILE:
  304. fprintf(db_out, "<file>");
  305. break;
  306. case T_SET: {
  307. long val = tp->ty_setlow;
  308. p_type base = tp->ty_setbase;
  309. long nelements = tp->ty_size << 3;
  310. int count = 0;
  311. int rsft = 3 + (int_size == 2 ? 1 : 2);
  312. long mask = int_size == 2 ? 017: 037;
  313. if (base->ty_class == T_SUBRANGE) base = base->ty_base;
  314. if (compressed) {
  315. fprintf(db_out, currlang->open_set_display);
  316. }
  317. else {
  318. fprintf(db_out, "\n%*c%s%*c",
  319. indent,
  320. ' ',
  321. currlang->open_set_display,
  322. 4-strlen(currlang->open_set_display), ' ');
  323. }
  324. indent += 4;
  325. for (i = 0; i < nelements; i++) {
  326. if (get_int(addr + (i >> rsft), int_size, T_UNSIGNED) & (1 << (i & mask))) {
  327. count++;
  328. if (count > 1) {
  329. if (compressed) {
  330. fprintf(db_out, ", ...");
  331. break;
  332. }
  333. fprintf(db_out, ",\n%*c", indent , ' ');
  334. }
  335. switch(base->ty_class) {
  336. case T_INTEGER:
  337. print_integer(base, val+i, format);
  338. break;
  339. case T_UNSIGNED:
  340. print_unsigned(base, val+i, format);
  341. break;
  342. case T_ENUM:
  343. print_literal(base, val+i, compressed, format);
  344. break;
  345. default:
  346. assert(0);
  347. }
  348. }
  349. }
  350. if (! compressed) {
  351. fprintf(db_out, "\n%*c", indent-4 , ' ');
  352. }
  353. indent -= 4;
  354. fprintf(db_out, currlang->close_set_display);
  355. }
  356. break;
  357. case T_REAL:
  358. fprintf(db_out, currlang->real_fmt, get_real(addr, tp->ty_size));
  359. break;
  360. case T_UNSIGNED:
  361. print_unsigned(tp, get_int(addr, tp_sz, T_UNSIGNED), format);
  362. break;
  363. case T_INTEGER:
  364. print_integer(tp, get_int(addr, tp_sz, T_INTEGER), format);
  365. break;
  366. case T_STRING:
  367. (*currlang->printstring)(db_out, addr, (int) tp_sz);
  368. break;
  369. default:
  370. assert(0);
  371. break;
  372. }
  373. }