util/ceg/defaults/C_out_skel.c

   1 /* $Id: C_out_skel.c,v 1.8 1994/06/24 10:54:42 ceriel Exp $ */
   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                 C_out
  10 */
  11
  12 #define CODE_EXPANDER
  13 #define EXPORT
  14 #define PRIVATE static
  15
  16 #include <em_spec.h>
  17 #include <em_mnem.h>
  18 #include <em_pseu.h>
  19 #include <em_flag.h>
  20 #include "em_ptyp.h"
  21 #include <em.h>
  22 #include <em_comp.h>
  23 #include <assert.h>
  24
  25 extern char em_flag[];  /* One per EM instruction: indicates parameter kind */
  26 extern short em_ptyp[]; /* One per parameter kind: indicates parameter type */
  27 char *C_error;
  28
  29 PRIVATE C_dopseudo();
  30
  31 EXPORT int
  32 C_out(p)
  33         register struct e_instr *p;
  34 {
  35         C_error = 0;
  36         switch(p->em_type) {
  37                 default:
  38                         C_error = "Illegal EM line";
  39                         break;
  40                 case EM_MNEM:
  41                         /* normal instruction */
  42                         if ((em_flag[p->em_opcode-sp_fmnem] & EM_PAR) == PAR_W &&
  43                             p->em_argtype == 0) {
  44 #include "C_mnem_narg"
  45                         } else {
  46 #include "C_mnem"
  47                         }
  48
  49                         break;
  50                 case EM_DEFILB:
  51                         /* defining occurrence of an instruction label */
  52                         C_df_ilb(p->em_ilb);
  53                         break;
  54                 case EM_DEFDLB:
  55                         /* defining occurrence of a global data label */
  56                         C_df_dlb(p->em_dlb);
  57                         break;
  58                 case EM_DEFDNAM:
  59                         /* defining occurrence of a non-numeric data label */
  60                         C_df_dnam(p->em_dnam);
  61                         break;
  62                 case EM_PSEU:
  63                         /* pseudo */
  64                         C_dopseudo(p);
  65                         break;
  66                 case EM_STARTMES:
  67                         /* start of a MES pseudo */
  68                         C_mes_begin((int) (p->em_cst));
  69                         break;
  70                 case EM_MESARG:
  71                         switch(p->em_argtype) {
  72                         case ilb_ptyp:
  73                                 C_ilb(p->em_ilb);
  74                                 break;
  75                         case nof_ptyp:
  76                                 C_dlb(p->em_dlb, p->em_off);
  77                                 break;
  78                         case sof_ptyp:
  79                                 C_dnam(p->em_dnam, p->em_off);
  80                                 break;
  81                         case cst_ptyp:
  82                                 C_cst(p->em_cst);
  83                                 break;
  84                         case pro_ptyp:
  85                                 C_pnam(p->em_pnam);
  86                                 break;
  87                         case str_ptyp:
  88                                 C_scon(p->em_string, p->em_size);
  89                                 break;
  90                         case ico_ptyp:
  91                                 C_icon(p->em_string, p->em_size);
  92                                 break;
  93                         case uco_ptyp:
  94                                 C_ucon(p->em_string, p->em_size);
  95                                 break;
  96                         case fco_ptyp:
  97                                 C_fcon(p->em_string, p->em_size);
  98                                 break;
  99                         default:
 100                                 C_error = "Illegal argument type";
 101                                 break;
 102                         }
 103                         break;
 104                 case EM_ENDMES:
 105                         C_mes_end();
 106                         break;
 107         }
 108         if (C_error) return 0;
 109         return 1;
 110 }
 111
 112 PRIVATE
 113 C_dopseudo(p)
 114         register struct e_instr *p;
 115 {
 116
 117         switch(p->em_opcode) {
 118                 case ps_exc: {
 119                         C_error = "EXC not allowed";
 120                         break;
 121                 }
 122                 case ps_hol: {
 123                         switch(p->em_argtype) {
 124                             case cst_ptyp:
 125                                 C_hol_cst(EM_holsize,
 126                                           p->em_cst,
 127                                           EM_holinit);
 128                                 break;
 129                             case ico_ptyp:
 130                                 C_hol_icon(EM_holsize,
 131                                            p->em_string,
 132                                            p->em_size,
 133                                            EM_holinit);
 134                                 break;
 135                             case uco_ptyp:
 136                                 C_hol_ucon(EM_holsize,
 137                                            p->em_string,
 138                                            p->em_size,
 139                                            EM_holinit);
 140                                 break;
 141                             case fco_ptyp:
 142                                 C_hol_fcon(EM_holsize,
 143                                            p->em_string,
 144                                            p->em_size,
 145                                            EM_holinit);
 146                                 break;
 147                             case sof_ptyp:
 148                                 C_hol_dnam(EM_holsize,
 149                                            p->em_dnam,
 150                                            p->em_off,
 151                                            EM_holinit);
 152                                 break;
 153                             case nof_ptyp:
 154                                 C_hol_dlb(EM_holsize,
 155                                           p->em_dlb,
 156                                           p->em_off,
 157                                           EM_holinit);
 158                                 break;
 159                             case ilb_ptyp:
 160                                 C_hol_ilb(EM_holsize,
 161                                           p->em_ilb,
 162                                           EM_holinit);
 163                                 break;
 164                             case pro_ptyp:
 165                                 C_hol_pnam(EM_holsize,
 166                                            p->em_pnam,
 167                                            EM_holinit);
 168                                 break;
 169                             default:
 170                                 C_error = "Illegal parameter type";
 171                                 break;
 172                         }
 173                         break;
 174                 }
 175                 case ps_bss: {
 176                         switch(p->em_argtype) {
 177                             case cst_ptyp:
 178                                 C_bss_cst(EM_bsssize,
 179                                           p->em_cst,
 180                                           EM_bssinit);
 181                                 break;
 182                             case ico_ptyp:
 183                                 C_bss_icon(EM_bsssize,
 184                                            p->em_string,
 185                                            p->em_size,
 186                                            EM_bssinit);
 187                                 break;
 188                             case uco_ptyp:
 189                                 C_bss_ucon(EM_bsssize,
 190                                            p->em_string,
 191                                            p->em_size,
 192                                            EM_bssinit);
 193                                 break;
 194                             case fco_ptyp:
 195                                 C_bss_fcon(EM_bsssize,
 196                                            p->em_string,
 197                                            p->em_size,
 198                                            EM_bssinit);
 199                                 break;
 200                             case sof_ptyp:
 201                                 C_bss_dnam(EM_bsssize,
 202                                            p->em_dnam,
 203                                            p->em_off,
 204                                            EM_bssinit);
 205                                 break;
 206                             case nof_ptyp:
 207                                 C_bss_dlb(EM_bsssize,
 208                                           p->em_dlb,
 209                                           p->em_off,
 210                                           EM_bssinit);
 211                                 break;
 212                             case ilb_ptyp:
 213                                 C_bss_ilb(EM_bsssize,
 214                                           p->em_ilb,
 215                                           EM_bssinit);
 216                                 break;
 217                             case pro_ptyp:
 218                                 C_bss_pnam(EM_bsssize,
 219                                            p->em_pnam,
 220                                            EM_bssinit);
 221                                 break;
 222                             default:
 223                                 C_error = "Illegal parameter type";
 224                                 break;
 225                         }
 226                         break;
 227                 }
 228                 case ps_end:
 229                         if (p->em_argtype != 0) {
 230                                 C_end(p->em_cst);
 231                                 break;
 232                         }
 233                         C_end_narg();
 234                         break;
 235                 case ps_exa:
 236                 case ps_ina:
 237                         if (p->em_argtype == nof_ptyp) {
 238                                 if (p->em_opcode == ps_exa) {
 239                                         C_exa_dlb(p->em_dlb);
 240                                 }
 241                                 else    C_ina_dlb(p->em_dlb);
 242                                 break;
 243                         }
 244                         if (p->em_opcode == ps_exa) {
 245                                 C_exa_dnam(p->em_dnam);
 246                         }
 247                         else    C_ina_dnam(p->em_dnam);
 248                         break;
 249                 case ps_exp:
 250                         C_exp(p->em_pnam);
 251                         break;
 252                 case ps_inp:
 253                         C_inp(p->em_pnam);
 254                         break;
 255                 case ps_pro:
 256                         if (p->em_nlocals >= 0) {
 257                                 C_pro(p->em_pnam, p->em_nlocals);
 258                         }
 259                         else    C_pro_narg(p->em_pnam);
 260                         break;
 261                 case ps_con:
 262                         switch(p->em_argtype) {
 263                                 case ilb_ptyp:
 264                                         C_con_ilb(p->em_ilb);
 265                                         break;
 266                                 case nof_ptyp:
 267                                         C_con_dlb(p->em_dlb, p->em_off);
 268                                         break;
 269                                 case sof_ptyp:
 270                                         C_con_dnam(p->em_dnam, p->em_off);
 271                                         break;
 272                                 case cst_ptyp:
 273                                         C_con_cst(p->em_cst);
 274                                         break;
 275                                 case pro_ptyp:
 276                                         C_con_pnam(p->em_pnam);
 277                                         break;
 278                                 case str_ptyp:
 279                                         C_con_scon(p->em_string, p->em_size);
 280                                         break;
 281                                 case ico_ptyp:
 282                                         C_con_icon(p->em_string, p->em_size);
 283                                         break;
 284                                 case uco_ptyp:
 285                                         C_con_ucon(p->em_string, p->em_size);
 286                                         break;
 287                                 case fco_ptyp:
 288                                         C_con_fcon(p->em_string, p->em_size);
 289                                         break;
 290                                 default:
 291                                         C_error = "Illegal argument type";
 292                                         return;
 293                         }
 294                         break;
 295                 case ps_rom:
 296                         switch(p->em_argtype) {
 297                                 case ilb_ptyp:
 298                                         C_rom_ilb(p->em_ilb);
 299                                         break;
 300                                 case nof_ptyp:
 301                                         C_rom_dlb(p->em_dlb, p->em_off);
 302                                         break;
 303                                 case sof_ptyp:
 304                                         C_rom_dnam(p->em_dnam, p->em_off);
 305                                         break;
 306                                 case cst_ptyp:
 307                                         C_rom_cst(p->em_cst);
 308                                         break;
 309                                 case pro_ptyp:
 310                                         C_rom_pnam(p->em_pnam);
 311                                         break;
 312                                 case str_ptyp:
 313                                         C_rom_scon(p->em_string, p->em_size);
 314                                         break;
 315                                 case ico_ptyp:
 316                                         C_rom_icon(p->em_string, p->em_size);
 317                                         break;
 318                                 case uco_ptyp:
 319                                         C_rom_ucon(p->em_string, p->em_size);
 320                                         break;
 321                                 case fco_ptyp:
 322                                         C_rom_fcon(p->em_string, p->em_size);
 323                                         break;
 324                                 default:
 325                                         C_error = "Illegal argument type";
 326                                         return;
 327                         }
 328                         break;
 329                 default:
 330                         C_error = "Illegal pseudo instruction";
 331                         break;
 332         }
 333 }