mkcalls.c 9.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472
  1. /* $Header$ */
  2. /*
  3. * (c) copyright 1987 by the Vrije Universiteit, Amsterdam, The Netherlands.
  4. * See the copyright notice in the ACK home directory, in the file "Copyright".
  5. */
  6. /* makecalls: expand a datastructure as delivered by "EM_getline"
  7. into calls to the procedural interface.
  8. Exported routine:
  9. EM_mkcalls
  10. */
  11. #include <em_spec.h>
  12. #include <em_mnem.h>
  13. #include <em_pseu.h>
  14. #include <em_flag.h>
  15. #include "em_ptyp.h"
  16. #include <em.h>
  17. #include "em_comp.h"
  18. #include <assert.h>
  19. extern char em_flag[]; /* One per EM instruction: indicates parameter kind */
  20. extern short em_ptyp[]; /* One per parameter kind: indicates parameter type */
  21. static int listtype = 0; /* indicates pseudo when generating code for
  22. variable length argument lists
  23. (only for MES)
  24. */
  25. #ifdef CHECKING
  26. /* c_getarg: Check the argument indicated by "args".
  27. The argument must be of a type allowed by "typset".
  28. Return a pointer to the next argument.
  29. */
  30. PRIVATE struct e_args *
  31. c_getarg(args, typset)
  32. register struct e_args *args;
  33. {
  34. if (((!typset) && args) ||
  35. ((!args) && typset)) {
  36. /* End of arguments expected, but there are more, or
  37. an argument expected, but there is none
  38. */
  39. EM_error = "Illegal number of parameters";
  40. return 0;
  41. }
  42. if (!args) return 0;
  43. if (!(args->em_argtype & typset)) {
  44. /* Type error */
  45. EM_error = "Illegal parameter type";
  46. }
  47. return args->em_next;
  48. }
  49. #else not CHECKING
  50. #define c_getarg(arg, x) ((arg) ? (arg)->em_next : (arg))
  51. #endif CHECKING
  52. /* EM_doinstr: An EM instruction
  53. */
  54. PRIVATE
  55. EM_doinstr(opcode, arg)
  56. register struct e_args *arg;
  57. {
  58. register int parametertype; /* parametertype of the instruction */
  59. register struct e_args *args;
  60. parametertype = em_flag[opcode-sp_fmnem] & EM_PAR;
  61. #ifdef CHECKING
  62. if (parametertype != PAR_NO && parametertype != PAR_W) {
  63. if (!arg) {
  64. EM_error = "Illegal number of parameters";
  65. return;
  66. }
  67. }
  68. #endif CHECKING
  69. switch(parametertype) {
  70. case PAR_NO:
  71. break;
  72. default:
  73. args = c_getarg(arg, em_ptyp[parametertype]);
  74. args = c_getarg(args, 0);
  75. break;
  76. case PAR_W:
  77. if (arg) {
  78. args = c_getarg(arg, cst_ptyp);
  79. args = c_getarg(args, 0);
  80. }
  81. else {
  82. #include "C_mnem_narg"
  83. return;
  84. }
  85. break;
  86. }
  87. #include "C_mnem"
  88. }
  89. PRIVATE
  90. EM_dopseudo(opcode, args)
  91. register struct e_args *args;
  92. {
  93. register struct e_args *arg;
  94. switch(opcode) {
  95. case ps_exc: {
  96. register struct e_args *args2;
  97. arg = c_getarg(args, cst_ptyp);
  98. args2 = c_getarg(arg, cst_ptyp);
  99. args2 = c_getarg(args2, 0);
  100. C_exc(args->em_cst, arg->em_cst);
  101. break;
  102. }
  103. case ps_hol: {
  104. register struct e_args *args2, *args3;
  105. arg = c_getarg(args, cst_ptyp);
  106. args2 = c_getarg(arg, par_ptyp);
  107. args3 = c_getarg(args2, cst_ptyp);
  108. args3 = c_getarg(args3, 0);
  109. switch(arg->em_argtype) {
  110. case cst_ptyp:
  111. C_hol_cst(args->em_cst,
  112. arg->em_cst,
  113. args2->em_cst);
  114. break;
  115. case ico_ptyp:
  116. C_hol_icon(args->em_cst,
  117. arg->em_str,
  118. arg->em_size,
  119. args2->em_cst);
  120. break;
  121. case uco_ptyp:
  122. C_hol_ucon(args->em_cst,
  123. arg->em_str,
  124. arg->em_size,
  125. args2->em_cst);
  126. break;
  127. case fco_ptyp:
  128. C_hol_fcon(args->em_cst,
  129. arg->em_str,
  130. arg->em_size,
  131. args2->em_cst);
  132. break;
  133. case sof_ptyp:
  134. C_hol_dnam(args->em_cst,
  135. arg->em_dnam,
  136. arg->em_soff,
  137. args2->em_cst);
  138. break;
  139. case nof_ptyp:
  140. C_hol_dlb(args->em_cst,
  141. arg->em_dlb,
  142. arg->em_noff,
  143. args2->em_cst);
  144. break;
  145. case ilb_ptyp:
  146. C_hol_ilb(args->em_cst,
  147. arg->em_ilb,
  148. args2->em_cst);
  149. break;
  150. case pro_ptyp:
  151. C_hol_pnam(args->em_cst,
  152. arg->em_pnam,
  153. args2->em_cst);
  154. break;
  155. default:
  156. EM_error = "Illegal parameter type";
  157. break;
  158. }
  159. break;
  160. }
  161. case ps_bss: {
  162. register struct e_args *args2, *args3;
  163. arg = c_getarg(args, cst_ptyp);
  164. args2 = c_getarg(arg, par_ptyp);
  165. args3 = c_getarg(args2, cst_ptyp);
  166. args3 = c_getarg(args3, 0);
  167. switch(arg->em_argtype) {
  168. case cst_ptyp:
  169. C_bss_cst(args->em_cst,
  170. arg->em_cst,
  171. args2->em_cst);
  172. break;
  173. case ico_ptyp:
  174. C_bss_icon(args->em_cst,
  175. arg->em_str,
  176. arg->em_size,
  177. args2->em_cst);
  178. break;
  179. case uco_ptyp:
  180. C_bss_ucon(args->em_cst,
  181. arg->em_str,
  182. arg->em_size,
  183. args2->em_cst);
  184. break;
  185. case fco_ptyp:
  186. C_bss_fcon(args->em_cst,
  187. arg->em_str,
  188. arg->em_size,
  189. args2->em_cst);
  190. break;
  191. case sof_ptyp:
  192. C_bss_dnam(args->em_cst,
  193. arg->em_dnam,
  194. arg->em_soff,
  195. args2->em_cst);
  196. break;
  197. case nof_ptyp:
  198. C_bss_dlb(args->em_cst,
  199. arg->em_dlb,
  200. arg->em_noff,
  201. args2->em_cst);
  202. break;
  203. case ilb_ptyp:
  204. C_bss_ilb(args->em_cst,
  205. arg->em_ilb,
  206. args2->em_cst);
  207. break;
  208. case pro_ptyp:
  209. C_bss_pnam(args->em_cst,
  210. arg->em_pnam,
  211. args2->em_cst);
  212. break;
  213. default:
  214. EM_error = "Illegal parameter type";
  215. break;
  216. }
  217. break;
  218. }
  219. case ps_end:
  220. if (args) {
  221. arg = c_getarg(args, cst_ptyp);
  222. arg = c_getarg(arg, 0);
  223. C_end(args->em_cst);
  224. break;
  225. }
  226. C_end_narg();
  227. break;
  228. case ps_exa:
  229. case ps_ina:
  230. arg = c_getarg(args, lab_ptyp);
  231. arg = c_getarg(arg, 0);
  232. if (args->em_argtype == nof_ptyp) {
  233. if (opcode == ps_exa) {
  234. C_exa_dlb(args->em_dlb);
  235. }
  236. else C_ina_dlb(args->em_dlb);
  237. break;
  238. }
  239. if (opcode == ps_exa) {
  240. C_exa_dnam(args->em_dnam);
  241. }
  242. else C_ina_dnam(args->em_dnam);
  243. break;
  244. case ps_exp:
  245. case ps_inp:
  246. arg = c_getarg(args, pro_ptyp);
  247. arg = c_getarg(arg, 0);
  248. if (opcode == ps_exp) {
  249. C_exp(args->em_pnam);
  250. }
  251. else C_inp(args->em_pnam);
  252. break;
  253. case ps_pro:
  254. arg = c_getarg(args, pro_ptyp);
  255. if (arg) {
  256. struct e_args *args2;
  257. args2 = c_getarg(arg, cst_ptyp);
  258. args2 = c_getarg(args2, 0);
  259. C_pro(args->em_pnam, arg->em_cst);
  260. }
  261. else C_pro_narg(args->em_pnam);
  262. break;
  263. case ps_con:
  264. arg = c_getarg(args, val_ptyp);
  265. arg = c_getarg(arg, 0);
  266. switch(args->em_argtype) {
  267. case ilb_ptyp:
  268. C_con_ilb(args->em_ilb);
  269. break;
  270. case nof_ptyp:
  271. C_con_dlb(args->em_dlb, args->em_noff);
  272. break;
  273. case sof_ptyp:
  274. C_con_dnam(args->em_dnam, args->em_soff);
  275. break;
  276. case cst_ptyp:
  277. C_con_cst(args->em_cst);
  278. break;
  279. case pro_ptyp:
  280. C_con_pnam(args->em_pnam);
  281. break;
  282. case str_ptyp:
  283. C_con_scon(args->em_str, args->em_size);
  284. break;
  285. case ico_ptyp:
  286. C_con_icon(args->em_str, args->em_size);
  287. break;
  288. case uco_ptyp:
  289. C_con_ucon(args->em_str, args->em_size);
  290. break;
  291. case fco_ptyp:
  292. C_con_fcon(args->em_str, args->em_size);
  293. break;
  294. default:
  295. EM_error = "Illegal argument type";
  296. return 0;
  297. }
  298. break;
  299. case ps_rom:
  300. arg = c_getarg(args, val_ptyp);
  301. arg = c_getarg(arg, 0);
  302. switch(args->em_argtype) {
  303. case ilb_ptyp:
  304. C_rom_ilb(args->em_ilb);
  305. break;
  306. case nof_ptyp:
  307. C_rom_dlb(args->em_dlb, args->em_noff);
  308. break;
  309. case sof_ptyp:
  310. C_rom_dnam(args->em_dnam, args->em_soff);
  311. break;
  312. case cst_ptyp:
  313. C_rom_cst(args->em_cst);
  314. break;
  315. case pro_ptyp:
  316. C_rom_pnam(args->em_pnam);
  317. break;
  318. case str_ptyp:
  319. C_rom_scon(args->em_str, args->em_size);
  320. break;
  321. case ico_ptyp:
  322. C_rom_icon(args->em_str, args->em_size);
  323. break;
  324. case uco_ptyp:
  325. C_rom_ucon(args->em_str, args->em_size);
  326. break;
  327. case fco_ptyp:
  328. C_rom_fcon(args->em_str, args->em_size);
  329. break;
  330. default:
  331. EM_error = "Illegal argument type";
  332. return 0;
  333. }
  334. break;
  335. default:
  336. EM_error = "Illegal pseudo instruction";
  337. break;
  338. }
  339. }
  340. PRIVATE
  341. EM_docon(args)
  342. register struct e_args *args;
  343. {
  344. register struct e_args *arg;
  345. arg = c_getarg(args, val_ptyp);
  346. arg = c_getarg(arg, 0);
  347. switch(args->em_argtype) {
  348. case ilb_ptyp:
  349. C_ilb(args->em_ilb);
  350. break;
  351. case nof_ptyp:
  352. C_dlb(args->em_dlb, args->em_noff);
  353. break;
  354. case sof_ptyp:
  355. C_dnam(args->em_dnam, args->em_soff);
  356. break;
  357. case cst_ptyp:
  358. C_cst(args->em_cst);
  359. break;
  360. case pro_ptyp:
  361. C_pnam(args->em_pnam);
  362. break;
  363. case str_ptyp:
  364. C_scon(args->em_str, args->em_size);
  365. break;
  366. case ico_ptyp:
  367. C_icon(args->em_str, args->em_size);
  368. break;
  369. case uco_ptyp:
  370. C_ucon(args->em_str, args->em_size);
  371. break;
  372. case fco_ptyp:
  373. C_fcon(args->em_str, args->em_size);
  374. break;
  375. default:
  376. EM_error = "Illegal argument type";
  377. break;
  378. }
  379. }
  380. PRIVATE
  381. EM_dostartmes(args)
  382. register struct e_args *args;
  383. {
  384. register struct e_args *arg;
  385. if (listtype) {
  386. EM_error = "Message not ended";
  387. return;
  388. }
  389. arg = c_getarg(args, cst_ptyp);
  390. arg = c_getarg(arg, 0);
  391. C_mes_begin(args->em_cst);
  392. listtype = ps_mes;
  393. }
  394. EXPORT int
  395. EM_mkcalls(line)
  396. register struct e_instr *line;
  397. {
  398. #ifdef CHECKING
  399. if (listtype && line->em_type != EM_MESARG && line->em_type != EM_ENDMES) {
  400. EM_error = "Message not ended";
  401. return 0;
  402. }
  403. #endif CHECKING
  404. EM_error = 0;
  405. switch(line->em_type) {
  406. default:
  407. EM_error = "Illegal EM line";
  408. break;
  409. case EM_MNEM:
  410. /* normal instruction */
  411. EM_doinstr(line->em_opcode, line->em_args);
  412. break;
  413. case EM_DEFILB:
  414. /* defining occurrence of an instruction label */
  415. C_df_ilb(line->em_deflb);
  416. break;
  417. case EM_DEFDLB:
  418. /* defining occurrence of a global data label */
  419. C_df_dlb(line->em_deflb);
  420. break;
  421. case EM_DEFDNAM:
  422. /* defining occurrence of a non-numeric data label */
  423. C_df_dnam(line->em_defdnam);
  424. break;
  425. case EM_PSEU:
  426. /* pseudo */
  427. EM_dopseudo(line->em_opcode, line->em_args);
  428. break;
  429. case EM_STARTMES:
  430. /* start of a MES pseudo */
  431. EM_dostartmes(line->em_arg);
  432. break;
  433. case EM_MESARG:
  434. case EM_ENDMES:
  435. #ifdef CHECKING
  436. if (!listtype) {
  437. EM_error = "Message not started";
  438. return 0;
  439. }
  440. #endif
  441. if (line->em_type == EM_MESARG) {
  442. EM_docon(line->em_arg);
  443. break;
  444. }
  445. C_mes_end();
  446. listtype = 0;
  447. break;
  448. }
  449. if (EM_error) return 0;
  450. return 1;
  451. }