print.c 8.6 KB

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