Added mechanism to generate C_out

diff --git a/util/ceg/defaults/C_out_skel.c b/util/ceg/defaults/C_out_skel.c
new file mode 100644 (file)
index 0000000..15d50ee
--- /dev/null
+++ b/util/ceg/defaults/C_out_skel.c
@@ -0,0 +1,441 @@
+/* $Header$ */
+/*
+ * (c) copyright 1987 by the Vrije Universiteit, Amsterdam, The Netherlands.
+ * See the copyright notice in the ACK home directory, in the file "Copyright".
+ */
+/*     makecalls: expand a datastructure as delivered by "EM_getline"
+       into calls to the procedural interface.
+       Exported routine:
+               C_out
+*/
+
+#include <em_spec.h>
+#include <em_mnem.h>
+#include <em_pseu.h>
+#include <em_flag.h>
+#include "em_ptyp.h"
+#include <em.h>
+#include <em_comp.h>
+#include <assert.h>
+
+extern char em_flag[]; /* One per EM instruction: indicates parameter kind */
+extern short em_ptyp[];        /* One per parameter kind: indicates parameter type */
+static char *C_error;
+
+static int listtype = 0;       /* indicates pseudo when generating code for
+                                  variable length argument lists
+                                  (only for MES)
+                               */
+
+#ifdef CHECKING
+/*     c_getarg: Check the argument indicated by "args".
+       The argument must be of a type allowed by "typset".
+       Return a pointer to the next argument.
+*/
+PRIVATE
+checkarg(arg, typset)
+       register struct e_arg *arg;
+{
+
+       if (((!typset) && arg->ema_argtype) ||
+           ((!arg->ema_argtype) && typset)) {
+               /* End of arguments expected, but there are more, or
+                  an argument expected, but there is none
+               */
+               C_error = "Illegal number of parameters";
+               return 0;
+       }
+
+       if (!(arg->ema_argtype & typset)) {
+               /* Type error */
+               C_error = "Illegal parameter type";
+               return 0;
+       }
+       return 1;
+}
+#else not CHECKING
+#define checkarg(arg, x) 1
+#endif CHECKING
+
+/*     EM_doinstr: An EM instruction
+*/
+PRIVATE
+EM_doinstr(p)
+       register struct e_instr *p;
+{
+       register int parametertype;     /* parametertype of the instruction */
+
+       parametertype = em_flag[p->em_opcode-sp_fmnem] & EM_PAR;
+#ifdef CHECKING
+       if (parametertype != PAR_NO && parametertype != PAR_W) {
+               if (p->em_argtype == 0) {
+                       C_error = "Illegal number of parameters";
+                       return;
+               }
+       }
+#endif CHECKING
+       switch(parametertype) {
+               case PAR_NO:
+                       break;
+               default:
+                       if (! checkarg(&(p->em_arg), em_ptyp[parametertype])) {
+                               return;
+                       }
+                       break;
+               case PAR_W:
+                       if (p->em_argtype != 0) {
+                               if (! checkarg(&(p->em_arg), cst_ptyp)) return;
+                       }
+                       else {
+#include "C_mnem_narg"
+                               return;
+                       }
+                       break;
+       }
+#include "C_mnem"
+}
+
+PRIVATE
+EM_dopseudo(p)
+       register struct e_instr *p;
+{
+
+       switch(p->em_opcode) {
+               case ps_exc: {
+                       C_exc(p->em_exc1, p->em_exc2);
+                       break;
+               }
+               case ps_hol: {
+                       if (! checkarg(&(p->em_arg), par_ptyp)) break;
+                       switch(p->em_argtype) {
+                           case cst_ptyp:
+                               C_hol_cst(EM_holsize,
+                                         p->em_cst,
+                                         EM_holinit);
+                               break;
+                           case ico_ptyp:
+                               C_hol_icon(EM_holsize,
+                                          p->em_string,
+                                          p->em_size, 
+                                          EM_holinit);
+                               break;
+                           case uco_ptyp:
+                               C_hol_ucon(EM_holsize,
+                                          p->em_string,
+                                          p->em_size,
+                                          EM_holinit);
+                               break;
+                           case fco_ptyp:
+                               C_hol_fcon(EM_holsize,
+                                          p->em_string,
+                                          p->em_size, 
+                                          EM_holinit);
+                               break;
+                           case sof_ptyp:
+                               C_hol_dnam(EM_holsize,
+                                          p->em_dnam,
+                                          p->em_off, 
+                                          EM_holinit);
+                               break;
+                           case nof_ptyp:
+                               C_hol_dlb(EM_holsize,
+                                         p->em_dlb,
+                                         p->em_off, 
+                                         EM_holinit);
+                               break;
+                           case ilb_ptyp:
+                               C_hol_ilb(EM_holsize,
+                                         p->em_ilb, 
+                                         EM_holinit);
+                               break;
+                           case pro_ptyp:
+                               C_hol_pnam(EM_holsize,
+                                          p->em_pnam, 
+                                          EM_holinit);
+                               break;
+                           default:
+                               C_error = "Illegal parameter type";
+                               break;
+                       }
+                       break;
+               }
+               case ps_bss: {
+                       if (! checkarg(&(p->em_arg), par_ptyp)) break;
+                       switch(p->em_argtype) {
+                           case cst_ptyp:
+                               C_bss_cst(EM_bsssize,
+                                         p->em_cst,
+                                         EM_bssinit);
+                               break;
+                           case ico_ptyp:
+                               C_bss_icon(EM_bsssize,
+                                          p->em_string,
+                                          p->em_size, 
+                                          EM_bssinit);
+                               break;
+                           case uco_ptyp:
+                               C_bss_ucon(EM_bsssize,
+                                          p->em_string,
+                                          p->em_size,
+                                          EM_bssinit);
+                               break;
+                           case fco_ptyp:
+                               C_bss_fcon(EM_bsssize,
+                                          p->em_string,
+                                          p->em_size, 
+                                          EM_bssinit);
+                               break;
+                           case sof_ptyp:
+                               C_bss_dnam(EM_bsssize,
+                                          p->em_dnam,
+                                          p->em_off, 
+                                          EM_bssinit);
+                               break;
+                           case nof_ptyp:
+                               C_bss_dlb(EM_bsssize,
+                                         p->em_dlb,
+                                         p->em_off, 
+                                         EM_bssinit);
+                               break;
+                           case ilb_ptyp:
+                               C_bss_ilb(EM_bsssize,
+                                         p->em_ilb, 
+                                         EM_bssinit);
+                               break;
+                           case pro_ptyp:
+                               C_bss_pnam(EM_bsssize, 
+                                          p->em_pnam, 
+                                          EM_bssinit);
+                               break;
+                           default:
+                               C_error = "Illegal parameter type";
+                               break;
+                       }
+                       break;
+               }
+               case ps_end:
+                       if (p->em_argtype != 0) {
+                               if (! checkarg(&(p->em_arg), cst_ptyp)) break;
+                               C_end(p->em_cst);
+                               break;
+                       }
+                       C_end_narg();
+                       break;
+               case ps_exa:
+               case ps_ina:
+                       if (! checkarg(&(p->em_arg), lab_ptyp)) break;
+                       if (p->em_argtype == nof_ptyp) {
+                               if (p->em_opcode == ps_exa) {
+                                       C_exa_dlb(p->em_dlb);
+                               }
+                               else    C_ina_dlb(p->em_dlb);
+                               break;
+                       }
+                       if (p->em_opcode == ps_exa) {
+                               C_exa_dnam(p->em_dnam);
+                       }
+                       else    C_ina_dnam(p->em_dnam);
+                       break;
+               case ps_exp:
+                       if (! checkarg(&(p->em_arg), pro_ptyp)) break;
+                       C_exp(p->em_pnam);
+                       break;
+               case ps_inp:
+                       if (! checkarg(&(p->em_arg), pro_ptyp)) break;
+                       C_inp(p->em_pnam);
+                       break;
+               case ps_pro:
+                       if (! checkarg(&(p->em_arg), pro_ptyp)) break;
+                       if (p->em_nlocals >= 0) {
+                               C_pro(p->em_pnam, p->em_nlocals);
+                       }
+                       else    C_pro_narg(p->em_pnam);
+                       break;
+               case ps_con:
+                       if (! checkarg(&(p->em_arg), val_ptyp)) break;
+                       switch(p->em_argtype) {
+                               case ilb_ptyp:
+                                       C_con_ilb(p->em_ilb);
+                                       break;
+                               case nof_ptyp:
+                                       C_con_dlb(p->em_dlb, p->em_off);
+                                       break;
+                               case sof_ptyp:
+                                       C_con_dnam(p->em_dnam, p->em_off);
+                                       break;
+                               case cst_ptyp:
+                                       C_con_cst(p->em_cst);
+                                       break;
+                               case pro_ptyp:
+                                       C_con_pnam(p->em_pnam);
+                                       break;
+                               case str_ptyp:
+                                       C_con_scon(p->em_string, p->em_size);
+                                       break;
+                               case ico_ptyp:
+                                       C_con_icon(p->em_string, p->em_size);
+                                       break;
+                               case uco_ptyp:
+                                       C_con_ucon(p->em_string, p->em_size);
+                                       break;
+                               case fco_ptyp:
+                                       C_con_fcon(p->em_string, p->em_size);
+                                       break;
+                               default:
+                                       C_error = "Illegal argument type";
+                                       return;
+                       }
+                       break;
+               case ps_rom:
+                       if (! checkarg(&(p->em_arg), val_ptyp)) break;
+                       switch(p->em_argtype) {
+                               case ilb_ptyp:
+                                       C_rom_ilb(p->em_ilb);
+                                       break;
+                               case nof_ptyp:
+                                       C_rom_dlb(p->em_dlb, p->em_off);
+                                       break;
+                               case sof_ptyp:
+                                       C_rom_dnam(p->em_dnam, p->em_off);
+                                       break;
+                               case cst_ptyp:
+                                       C_rom_cst(p->em_cst);
+                                       break;
+                               case pro_ptyp:
+                                       C_rom_pnam(p->em_pnam);
+                                       break;
+                               case str_ptyp:
+                                       C_rom_scon(p->em_string, p->em_size);
+                                       break;
+                               case ico_ptyp:
+                                       C_rom_icon(p->em_string, p->em_size);
+                                       break;
+                               case uco_ptyp:
+                                       C_rom_ucon(p->em_string, p->em_size);
+                                       break;
+                               case fco_ptyp:
+                                       C_rom_fcon(p->em_string, p->em_size);
+                                       break;
+                               default:
+                                       C_error = "Illegal argument type";
+                                       return;
+                       }
+                       break;
+               default: 
+                       C_error = "Illegal pseudo instruction";
+                       break;
+       }
+}
+
+PRIVATE
+EM_docon(p)
+       register struct e_instr *p;
+{
+       checkarg(&(p->em_arg), val_ptyp);
+       switch(p->em_argtype) {
+               case ilb_ptyp:
+                       C_ilb(p->em_ilb);
+                       break;
+               case nof_ptyp:
+                       C_dlb(p->em_dlb, p->em_off);
+                       break;
+               case sof_ptyp:
+                       C_dnam(p->em_dnam, p->em_off);
+                       break;
+               case cst_ptyp:
+                       C_cst(p->em_cst);
+                       break;
+               case pro_ptyp:
+                       C_pnam(p->em_pnam);
+                       break;
+               case str_ptyp:
+                       C_scon(p->em_string, p->em_size);
+                       break;
+               case ico_ptyp:
+                       C_icon(p->em_string, p->em_size);
+                       break;
+               case uco_ptyp:
+                       C_ucon(p->em_string, p->em_size);
+                       break;
+               case fco_ptyp:
+                       C_fcon(p->em_string, p->em_size);
+                       break;
+               default:
+                       C_error = "Illegal argument type";
+                       break;
+       }
+}
+
+PRIVATE
+EM_dostartmes(p)
+       register struct e_instr *p;
+{
+
+       if (listtype) {
+               C_error = "Message not ended";
+               return;
+       }
+       if (! checkarg(&(p->em_arg), cst_ptyp)) return;
+       C_mes_begin((int) (p->em_cst));
+       listtype = ps_mes;
+}
+
+EXPORT int
+C_out(line)
+       register struct e_instr *line;
+{
+
+#ifdef CHECKING
+       if (listtype && line->em_type != EM_MESARG && line->em_type != EM_ENDMES) {
+               C_error = "Message not ended";
+               return 0;
+       }
+#endif CHECKING
+       C_error = 0;
+       switch(line->em_type) {
+               default:
+                       C_error = "Illegal EM line";
+                       break;
+               case EM_MNEM:
+                       /* normal instruction */
+                       EM_doinstr(line);
+                       break;
+               case EM_DEFILB:
+                       /* defining occurrence of an instruction label */
+                       C_df_ilb(line->em_ilb);
+                       break;
+               case EM_DEFDLB:
+                       /* defining occurrence of a global data label */
+                       C_df_dlb(line->em_dlb);
+                       break;
+               case EM_DEFDNAM:
+                       /* defining occurrence of a non-numeric data label */
+                       C_df_dnam(line->em_dnam);
+                       break;
+               case EM_PSEU:
+                       /* pseudo */
+                       EM_dopseudo(line);
+                       break;
+               case EM_STARTMES:
+                       /* start of a MES pseudo */
+                       EM_dostartmes(line);
+                       break;
+               case EM_MESARG:
+               case EM_ENDMES:
+#ifdef CHECKING
+                       if (!listtype) {
+                               C_error = "Message not started";
+                               return 0;
+                       }
+#endif
+                       if (line->em_type == EM_MESARG) {
+                               EM_docon(line);
+                               break;
+                       }
+                       C_mes_end();
+                       listtype = 0;
+                       break;
+       }
+       if (C_error) return 0;
+       return 1;
+}

diff --git a/util/ceg/defaults/Makefile b/util/ceg/defaults/Makefile
index 350f1bd..9367d12 100644 (file)
--- a/util/ceg/defaults/Makefile
+++ b/util/ceg/defaults/Makefile
@@ -14,11 +14,12 @@ StorageList = C_bss_cst.c C_bss_dlb.c C_bss_dnam.c C_bss_ilb.c C_bss_pnam.c \
                C_hol_pnam.c C_rom_cst.c C_rom_dlb.c C_rom_dnam.c C_rom_ilb.c \
                C_rom_pnam.c C_rom_scon.c
 
-all:
+all:   C_out.c
 
 clean:
+       rm -f C_out.c C_mnem C_mnem_narg
 
-install:
+install:       all
        -mkdir $(CEGLIB)
        -mkdir $(DEF)
        -mkdir $(DEF)/message
@@ -30,6 +31,7 @@ install:
        for i in $(NotimplList) ; do cp not_impl/$$i $(DEF)/not_impl/$$i ; done
        for i in $(PseudoList) ; do cp pseudo/$$i $(DEF)/pseudo/$$i ; done
        for i in $(StorageList) ; do cp storage/$$i $(DEF)/storage/$$i ; done
+       cp C_out.c $(DEF)/C_out.c
 
 cmp:
        -cmp pseudo_vars.c $(DEF)/pseudo_vars.c
@@ -37,6 +39,7 @@ cmp:
        -for i in $(NotimplList) ; do cmp not_impl/$$i $(DEF)/not_impl/$$i ; done
        -for i in $(PseudoList) ; do cmp pseudo/$$i $(DEF)/pseudo/$$i ; done
        -for i in $(StorageList) ; do cmp storage/$$i $(DEF)/storage/$$i ; done
+       -cmp C_out.c $(DEF)/C_out.c
 
 pr:
        @for i in $(MessageList) ; do pr message/$$i ; done
@@ -46,3 +49,12 @@ pr:
 
 opr:
        make pr | opr
+
+C_out.c:       C_out_skel.c C_mnem C_mnem_narg mk_C_out
+       mk_C_out > C_out.c
+
+C_mnem:                m_C_mnem argtype
+               sh m_C_mnem > C_mnem
+
+C_mnem_narg:   m_C_mnem_na argtype
+               sh m_C_mnem_na > C_mnem_narg

diff --git a/util/ceg/defaults/argtype b/util/ceg/defaults/argtype
new file mode 100755 (executable)
index 0000000..3ca1d7d
--- /dev/null
+++ b/util/ceg/defaults/argtype
@@ -0,0 +1,14 @@
+: argtype lists all em mnemonics that have an argument type equal to
+: one of the letters specified in the argument
+case x$# in
+       x2)     
+               ;;
+       x*)     echo "Usage: $0 argtypes <em_table>" 1>&2
+               exit 1
+               ;;
+esac
+ed - $2 << A
+1,/^\$/d
+1,/^\$/d
+1,/^\$/g/^\(...\)      [$1].*/s//\\1/gp
+A

diff --git a/util/ceg/defaults/m_C_mnem b/util/ceg/defaults/m_C_mnem
new file mode 100755 (executable)
index 0000000..68aaf9d
--- /dev/null
+++ b/util/ceg/defaults/m_C_mnem
@@ -0,0 +1,91 @@
+EM_TABLE=../../../etc/em_table
+echo "switch(p->em_opcode) {"
+for i in - cdflnorswz p b
+do
+       list=`./argtype $i $EM_TABLE`
+       case $i in
+       -)      args='()'
+               echo "  /* no arguments */"
+               ;;
+       cdflnorswz)
+               args='(p->em_cst)'
+               echo "  /* one integer constant argument */"
+               ;;
+       p)
+               args='(p->em_pnam)'
+               echo "  /* a procedure name argument */"
+               ;;
+       b)
+
+: Grumbl, an instruction label as argument is encoded in a sp_cst2
+
+               args='((label) (p->em_cst))'
+               echo "  /* An instruction label argument */"
+               ;;
+       esac
+       for i in $list
+       do
+               cat << EOF
+       case op_$i:
+               C_$i$args;
+               break;
+EOF
+       done
+done
+list=`./argtype g $EM_TABLE`
+cat << 'EOF'
+       default:
+/* a "g" argument */
+               if (p->em_argtype == nof_ptyp) {
+                       switch(p->em_opcode) {
+                               default:
+                                       C_error = "Illegal mnemonic";
+                                       break;
+EOF
+for i in $list
+do
+       cat << EOF
+                               case op_$i:
+                                       C_${i}_dlb(p->em_dlb, p->em_off);
+                                       break;
+EOF
+done
+cat << 'EOF'
+                       }
+               }
+               else if (p->em_argtype == sof_ptyp) {
+                       switch(p->em_opcode) {
+                               default:
+                                       C_error = "Illegal mnemonic";
+                                       break;
+EOF
+for i in $list
+do
+       cat << EOF
+                               case op_$i:
+                                       C_${i}_dnam(p->em_dnam, p->em_off);
+                                       break;
+EOF
+done
+cat << 'EOF'
+                       }
+               }
+               else /*argtype == cst_ptyp */ {
+                       switch(p->em_opcode) {
+                               default:
+                                       C_error = "Illegal mnemonic";
+                                       break;
+EOF
+for i in $list
+do
+       cat << EOF
+                               case op_$i:
+                                       C_$i(p->em_cst);
+                                       break;
+EOF
+done
+cat << 'EOF'
+                       }
+               }
+}
+EOF

diff --git a/util/ceg/defaults/m_C_mnem_na b/util/ceg/defaults/m_C_mnem_na
new file mode 100755 (executable)
index 0000000..7f1af29
--- /dev/null
+++ b/util/ceg/defaults/m_C_mnem_na
@@ -0,0 +1,15 @@
+EM_TABLE=../../../etc/em_table
+list=`./argtype w $EM_TABLE`
+echo "switch(p->em_opcode) {"
+for i in $list
+do
+       cat << EOF
+       case op_$i:
+               C_${i}_narg();
+               break;
+EOF
+done
+cat << EOF
+       default: C_error = "Illegal mnemonic";
+}
+EOF

diff --git a/util/ceg/defaults/mk_C_out b/util/ceg/defaults/mk_C_out
new file mode 100755 (executable)
index 0000000..159b262
--- /dev/null
+++ b/util/ceg/defaults/mk_C_out
@@ -0,0 +1,12 @@
+trap "rm -f tmp$$"  1 2 3 15
+cp C_out_skel.c tmp$$
+ed - tmp$$ <<'EOF'
+/^#include "C_mnem_narg"/d
+.-1r C_mnem_narg
+/^#include "C_mnem"/d
+.-1r C_mnem
+w
+q
+EOF
+cat tmp$$
+rm -f tmp$$