From: kaashoek Date: Fri, 20 Nov 1987 11:12:07 +0000 (+0000) Subject: Initial revision X-Git-Tag: release-5-5~3721 X-Git-Url: https://git.ndcode.org/public/gitweb.cgi?a=commitdiff_plain;h=75e0c5f7edcc52eb794a9f84e2ed7f36f0b246d7;p=ack.git Initial revision --- diff --git a/util/ceg/EM_parser/as_EM_pars/Makefile b/util/ceg/EM_parser/as_EM_pars/Makefile new file mode 100644 index 000000000..295e2d0ca --- /dev/null +++ b/util/ceg/EM_parser/as_EM_pars/Makefile @@ -0,0 +1,12 @@ +EM=/proj/em/Work + +OFILES = dist.o error.o + +IFILES = -I$(EM)/h -I$(EM)/modules/h +CC = cc + +.c.o : + $(CC) $(IFILES) -c $< + +em_parser : $(OFILES) + touch em_parser diff --git a/util/ceg/EM_parser/as_EM_pars/arg_type.h b/util/ceg/EM_parser/as_EM_pars/arg_type.h new file mode 100644 index 000000000..5bad322e0 --- /dev/null +++ b/util/ceg/EM_parser/as_EM_pars/arg_type.h @@ -0,0 +1,3 @@ +#define STRING 0 +#define ARITH 1 +#define INT 2 diff --git a/util/ceg/EM_parser/as_EM_pars/dist.c b/util/ceg/EM_parser/as_EM_pars/dist.c new file mode 100644 index 000000000..d799af75f --- /dev/null +++ b/util/ceg/EM_parser/as_EM_pars/dist.c @@ -0,0 +1,11 @@ +#include "em.h" +arith cur_pos; + +back_patch() +{ +} + + +save_output() +{ +} diff --git a/util/ceg/EM_parser/as_EM_pars/em_decl.h b/util/ceg/EM_parser/as_EM_pars/em_decl.h new file mode 100644 index 000000000..24b258f0d --- /dev/null +++ b/util/ceg/EM_parser/as_EM_pars/em_decl.h @@ -0,0 +1,66 @@ +#define SEGBSS 0 +#define SEGHOL 1 +#define SEGCON 2 +#define SEGROM 3 +#define SEGTXT 4 +#define NOSEG 5 +#define UNKNOWN (-1) + + +#define TRUE 1 +#define FALSE 0 + + +#define STRING 0 +#define LABEL 1 +#define ARITH 2 +#define INT 3 + + +#define MAX_ARGS 4 + +#define NO_ARGS 0 +#define C_ARG 1 +#define D_ARG 2 +#define F_ARG 3 +#define L_ARG 4 +#define N_ARG 5 +#define O_ARG 6 +#define R_ARG 7 +#define S_ARG 8 +#define Z_ARG 9 +#define W_ARG 10 +#define EXTERNAL 11 +#define EXTERNAL_DNAM 12 +#define EXTERNAL_DLB 13 +#define P_ARG 14 +#define B_ARG 15 +#define STRING_ARITH 16 +#define BSS_EXT_DNAM 17 +#define BSS_EXT_DLB 18 +#define BSS_STR_AR 19 +#define BSS_W_ARG 20 +#define BSS_PNAM 21 +#define BSS_ILB 22 +#define ID_N_ARG 23 +#define ARITH_ARITH 24 +#define EXT_DNAM 25 +#define EXT_DLB 26 +#define ONE_INT 27 +#define _STRING 28 + + +typedef struct { + char *header; + int arg_type[MAX_ARGS]; /* Zoals ze eruit gaan!! */ + char *arg_id[MAX_ARGS], *arg_conv[MAX_ARGS]; + } t_C_info; + +typedef struct { + char *lexeme; + int C_instr_type; + } t_token; + + +extern t_C_info C_info[], *C_instr_info; +extern int storage_default[4][3], segment; diff --git a/util/ceg/EM_parser/as_EM_pars/em_parser.h b/util/ceg/EM_parser/as_EM_pars/em_parser.h new file mode 100644 index 000000000..036770f2b --- /dev/null +++ b/util/ceg/EM_parser/as_EM_pars/em_parser.h @@ -0,0 +1,10 @@ +#define SEGBSS 0 +#define SEGHOL 1 +#define SEGCON 2 +#define SEGROM 3 +#define SEGTXT 4 + +#define STRING 0 +#define LABEL 1 +#define ARITH 2 +#define INT 3 diff --git a/util/ceg/EM_parser/as_EM_pars/error.c b/util/ceg/EM_parser/as_EM_pars/error.c new file mode 100644 index 000000000..e6c97e9c9 --- /dev/null +++ b/util/ceg/EM_parser/as_EM_pars/error.c @@ -0,0 +1,10 @@ +#include + +error( fmt, argv) +char *fmt; +int argv; +{ + fprint( STDERR, "!! ERROR : "); + doprnt( STDERR, fmt, &argv); + fprint( STDERR, " !!\n"); +} diff --git a/util/ceg/EM_parser/common/C_instr2.c b/util/ceg/EM_parser/common/C_instr2.c new file mode 100644 index 000000000..adf87f4db --- /dev/null +++ b/util/ceg/EM_parser/common/C_instr2.c @@ -0,0 +1,436 @@ +#include "decl.h" + + +t_C_info C_info[] = { + /* NO_ARGS */ { "()\n{\n", + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}}, + /* C_ARG */ { "( c)\narith c;\n{\n", + { ARITH, 0, 0, 0}, + { "c", 0, 0, 0}, + { "c", 0, 0, 0}}, + /* D_ARG */ { "( d)\narith d;\n{\n", + { ARITH, 0, 0, 0}, + { "d", 0, 0, 0}, + { "d", 0, 0, 0}}, + /* F_ARG */ { "( f)\narith f;\n{\n", + { ARITH, 0, 0, 0}, + { "f", 0, 0, 0}, + { "f", 0, 0, 0}}, + /* L_ARG */ { "( l)\narith l;\n{\n", + { ARITH, 0, 0, 0}, + { "l", 0, 0, 0}, + { "(l >= 0 ? l + EM_BSIZE : l)", 0, 0, 0}}, + /* N_ARG */ { "( n)\narith n;\n{\n", + { ARITH, 0, 0, 0}, + { "n", 0, 0, 0}, + { "n", 0, 0, 0}}, + /* O_ARG */ { "( o)\narith o;\n{\n", + { ARITH, 0, 0, 0}, + { "o", 0, 0, 0}, + { "o", 0, 0, 0}}, + /* R_ARG */ { "( r)\narith r;\n{\n", + { ARITH, 0, 0, 0}, + { "r", 0, 0, 0}, + { "r", 0, 0, 0}}, + /* S_ARG */ { "( s)\narith s;\n{\n", + { ARITH, 0, 0, 0}, + { "s", 0, 0, 0}, + { "s", 0, 0, 0}}, + /* Z_ARG */ { "( z)\narith z;\n{\n", + { ARITH, 0, 0, 0}, + { "z", 0, 0, 0}, + { "z", 0, 0, 0}}, + /* W_ARG */ { "( w)\narith w;\n{\n", + { ARITH, 0, 0, 0}, + { "w", 0, 0, 0}, + { "w", 0, 0, 0}}, + /* EXTERNAL */ { "( g)\narith g;\n{\n", + { STRING, ARITH, 0, 0}, + { "FAKE-ARGUMENT", "g", 0, 0}, + { "extnd_hol( holno)", "g", 0, 0}}, + /* EXTERNAL_DNAM*/ { "( g, o)\nchar *g;\narith o;\n{\n", + { STRING, ARITH, 0, 0}, + { "g", "o", 0, 0}, + { "extnd_dnam( g)", "o", 0, 0}}, + /* EXTERNAL_DLB */ { "( g, o)\nchar *g;\narith o;\n{\n", + { STRING, ARITH, 0, 0}, + { "g", "o", 0, 0}, + { "extnd_dlb( g)", "o", 0, 0}}, + /* P_ARG */ { "( p)\nchar *p;\n{\n", + { STRING, 0, 0, 0}, + { "p", 0, 0, 0}, + { "extnd_name( p)", 0, 0, 0}}, + /* B_ARG */ { "( b)\nlabel b;\n{\n", + { STRING, 0, 0, 0}, + { "b", 0, 0, 0}, + { "extnd_ilb( b)", 0, 0, 0}}, + /* STRING+ARITH */ { "( val, sz)\nchar *val;\narith sz;\n{\n", + { STRING, ARITH, 0, 0}, + { "val", "sz", 0, 0}, + { "val", "sz", 0, 0}}, + /* BSS_EXT_DNAM */ { "( n, g, o, i)\nchar *g;\narith n, o;\nint i;\n{\n", + { ARITH, STRING, ARITH, INT}, + { "n", "g", "o", "i"}, + { "n", "extnd_dnam( g)", "o", "i"}}, + /* BSS_EXT_DLB */ { "( n, g, o, i)\nchar *g;\narith n, o;\nint i;\n{\n", + { ARITH, STRING, ARITH, INT}, + { "n", "g", "o", "i"}, + { "n", "extnd_dlb( g)", "o", "i"}}, + /* BSS_STR+AR */ { "( n, val, sz, i)\nchar *val;\narith n, sz;\nint i;\n{\n", + { ARITH, STRING, ARITH, INT}, + { "n", "val", "sz", "i"}, + { "n", "val", "sz", "i"}}, + /* BSS_W_ARG */ { "( n, w, i)\narith n, w;\nint i;\n{\n", + { ARITH, ARITH, INT, 0}, + { "n", "w", "i", 0}, + { "n", "w", "i", 0}}, + /* BSS_PNAM */ { "( n, p, i)\narith n;\nchar *p;int i;\n\n{\n", + { ARITH, STRING, INT, 0}, + { "n", "p", "i", 0}, + { "n", "extnd_name( p)", "i", 0}}, + /* BSS_ILB */ { "( n, b, i)\narith n;\nlabel b;int i;\n\n{\n", + { ARITH, STRING, INT, 0}, + { "n", "b", "i", 0}, + { "n", "extnd_ilb( b)", "i", 0}}, + /* ID+N_ARG */ { "( p, n)\nchar *p;\narith n;\n{\n", + { STRING, ARITH, 0, 0}, + { "p", "n", 0, 0}, + { "extnd_name( p)", "n", 0, 0}}, + /* ARITH+ARITH */ { "( n, w)\narith n, w;\n{\n", + { ARITH, ARITH, 0, 0}, + { "n", "w", 0, 0}, + { "n", "w", 0, 0}}, + /* EXT_DNAM */ { "( g)\nchar *g;\n{\n", + { STRING, 0, 0, 0}, + { "g", 0, 0, 0}, + { "extnd_dnam( g)", 0, 0, 0}}, + /* EXT_DLB */ { "( g)\nchar *g;\n{\n", + { STRING, 0, 0, 0}, + { "g", 0, 0, 0}, + { "extnd_dlb( g)", 0, 0, 0}}, + /* ONE_INT */ { "( i)\nint i;\n{\n", + { INT, 0, 0, 0}, + { "i", 0, 0, 0}, + { "i", 0, 0, 0}}, + /* _STRING */ { "( str)\nchar *str;\n{\n", + { STRING, 0, 0, 0}, + { "str", 0, 0, 0}, + { "str", 0, 0, 0}} + }, *C_instr_info; + +#define N_INSTR 269 + +struct { char *name; int class, segment;} + EM_instr[ N_INSTR ] = { + { "C_aar", W_ARG, SEGTXT}, + { "C_aar_narg", NO_ARGS, SEGTXT}, + { "C_adf", W_ARG, SEGTXT}, + { "C_adf_narg", NO_ARGS, SEGTXT}, + { "C_adi", W_ARG, SEGTXT}, + { "C_adi_narg", NO_ARGS, SEGTXT}, + { "C_adp", F_ARG, SEGTXT}, + { "C_ads", W_ARG, SEGTXT}, + { "C_ads_narg", NO_ARGS, SEGTXT}, + { "C_adu", W_ARG, SEGTXT}, + { "C_adu_narg", NO_ARGS, SEGTXT}, + { "C_and", W_ARG, SEGTXT}, + { "C_and_narg", NO_ARGS, SEGTXT}, + { "C_asp", F_ARG, SEGTXT}, + { "C_ass", W_ARG, SEGTXT}, + { "C_ass_narg", NO_ARGS, SEGTXT}, + { "C_beq", B_ARG, SEGTXT}, + { "C_bge", B_ARG, SEGTXT}, + { "C_bgt", B_ARG, SEGTXT}, + { "C_ble", B_ARG, SEGTXT}, + { "C_blm", Z_ARG, SEGTXT}, + { "C_bls", W_ARG, SEGTXT}, + { "C_bls_narg", NO_ARGS, SEGTXT}, + { "C_blt", B_ARG, SEGTXT}, + { "C_bne", B_ARG, SEGTXT}, + { "C_bra", B_ARG, SEGTXT}, + { "C_bss_cst", BSS_W_ARG, SEGBSS}, + { "C_bss_dlb", BSS_EXT_DLB, SEGBSS}, + { "C_bss_dnam", BSS_EXT_DNAM, SEGBSS}, + { "C_bss_fcon", BSS_STR_AR, SEGBSS}, + { "C_bss_icon", BSS_STR_AR, SEGBSS}, + { "C_bss_ilb", BSS_ILB, SEGBSS}, + { "C_bss_pnam", BSS_PNAM, SEGBSS}, + { "C_bss_ucon", BSS_STR_AR, SEGBSS}, + { "C_cai", NO_ARGS, SEGTXT}, + { "C_cal", P_ARG, SEGTXT}, + { "C_cff", NO_ARGS, SEGTXT}, + { "C_cfi", NO_ARGS, SEGTXT}, + { "C_cfu", NO_ARGS, SEGTXT}, + { "C_cif", NO_ARGS, SEGTXT}, + { "C_cii", NO_ARGS, SEGTXT}, + { "C_ciu", NO_ARGS, SEGTXT}, + { "C_close", NO_ARGS, NOSEG}, + { "C_cmf", W_ARG, SEGTXT}, + { "C_cmf_narg", NO_ARGS, SEGTXT}, + { "C_cmi", W_ARG, SEGTXT}, + { "C_cmi_narg", NO_ARGS, SEGTXT}, + { "C_cmp", NO_ARGS, SEGTXT}, + { "C_cms", W_ARG, SEGTXT}, + { "C_cms_narg", NO_ARGS, SEGTXT}, + { "C_cmu", W_ARG, SEGTXT}, + { "C_cmu_narg", NO_ARGS, SEGTXT}, + { "C_com", W_ARG, SEGTXT}, + { "C_com_narg", NO_ARGS, SEGTXT}, + { "C_con_cst", C_ARG, SEGCON}, + { "C_con_dlb", EXTERNAL_DLB, SEGCON}, + { "C_con_dnam", EXTERNAL_DNAM, SEGCON}, + { "C_con_fcon", STRING_ARITH, SEGCON}, + { "C_con_icon", STRING_ARITH, SEGCON}, + { "C_con_ilb", B_ARG, SEGCON}, + { "C_con_pnam", P_ARG, SEGCON}, + { "C_con_scon", STRING_ARITH, SEGCON}, + { "C_con_ucon", STRING_ARITH, SEGCON}, + { "C_csa", W_ARG, SEGTXT}, + { "C_csa_narg", NO_ARGS, SEGTXT}, + { "C_csb", W_ARG, SEGTXT}, + { "C_csb_narg", NO_ARGS, SEGTXT}, + { "C_cst", C_ARG, NOSEG}, + { "C_cuf", NO_ARGS, SEGTXT}, + { "C_cui", NO_ARGS, SEGTXT}, + { "C_cuu", NO_ARGS, SEGTXT}, + { "C_dch", NO_ARGS, SEGTXT}, + { "C_dec", NO_ARGS, SEGTXT}, + { "C_dee", EXTERNAL, SEGTXT}, + { "C_dee_dlb", EXTERNAL_DLB, SEGTXT}, + { "C_dee_dnam", EXTERNAL_DNAM, SEGTXT}, + { "C_del", L_ARG, SEGTXT}, + { "C_df_dlb", EXT_DLB, NOSEG}, + { "C_df_dnam", EXT_DNAM, NOSEG}, + { "C_df_ilb", B_ARG, SEGTXT}, + { "C_dlb", STRING_ARITH, SEGTXT}, + { "C_dnam", STRING_ARITH, SEGTXT}, + { "C_dup", S_ARG, SEGTXT}, + { "C_dus", W_ARG, SEGTXT}, + { "C_dus_narg", NO_ARGS, SEGTXT}, + { "C_dvf", W_ARG, SEGTXT}, + { "C_dvf_narg", NO_ARGS, SEGTXT}, + { "C_dvi", W_ARG, SEGTXT}, + { "C_dvi_narg", NO_ARGS, SEGTXT}, + { "C_dvu", W_ARG, SEGTXT}, + { "C_dvu_narg", NO_ARGS, SEGTXT}, + { "C_end", Z_ARG, SEGTXT}, + { "C_end_narg", NO_ARGS, SEGTXT}, + { "C_exa_dlb", EXT_DLB, NOSEG}, + { "C_exa_dnam", EXT_DNAM, NOSEG}, + { "C_exc", ARITH_ARITH, NOSEG}, + { "C_exg", W_ARG, SEGTXT}, + { "C_exg_narg", NO_ARGS, SEGTXT}, + { "C_exp", P_ARG, SEGTXT}, + { "C_fcon", STRING_ARITH, SEGTXT}, + { "C_fef", W_ARG, SEGTXT}, + { "C_fef_narg", NO_ARGS, SEGTXT}, + { "C_fif", W_ARG, SEGTXT}, + { "C_fif_narg", NO_ARGS, SEGTXT}, + { "C_fil", EXTERNAL, SEGTXT}, + { "C_fil_dlb", EXTERNAL_DLB, SEGTXT}, + { "C_fil_dnam", EXTERNAL_DNAM, SEGTXT}, + { "C_gto", EXTERNAL, SEGTXT}, + { "C_gto_dlb", EXTERNAL_DLB, SEGTXT}, + { "C_gto_dnam", EXTERNAL_DNAM, SEGTXT}, + { "C_hol_cst", BSS_W_ARG, SEGHOL}, + { "C_hol_dlb", BSS_EXT_DLB, SEGHOL}, + { "C_hol_dnam", BSS_EXT_DNAM, SEGHOL}, + { "C_hol_fcon", BSS_STR_AR, SEGHOL}, + { "C_hol_icon", BSS_STR_AR, SEGHOL}, + { "C_hol_ilb", BSS_ILB, SEGHOL}, + { "C_hol_pnam", BSS_PNAM, SEGHOL}, + { "C_hol_ucon", BSS_STR_AR, SEGHOL}, + { "C_icon", STRING_ARITH, SEGTXT}, + { "C_ilb", B_ARG, SEGTXT}, + { "C_ina_dlb", EXT_DLB, SEGTXT}, + { "C_ina_dnam", EXT_DNAM, SEGTXT}, + { "C_inc", NO_ARGS, SEGTXT}, + { "C_ine", EXTERNAL, SEGTXT}, + { "C_ine_dlb", EXTERNAL_DLB, SEGTXT}, + { "C_ine_dnam", EXTERNAL_DNAM, SEGTXT}, + { "C_init", ARITH_ARITH, SEGTXT}, + { "C_inl", L_ARG, SEGTXT}, + { "C_inn", W_ARG, SEGTXT}, + { "C_inn_narg", NO_ARGS, SEGTXT}, + { "C_inp", P_ARG, NOSEG}, + { "C_ior", W_ARG, SEGTXT}, + { "C_ior_narg", NO_ARGS, SEGTXT}, + { "C_lae", EXTERNAL, SEGTXT}, + { "C_lae_dlb", EXTERNAL_DLB, SEGTXT}, + { "C_lae_dnam", EXTERNAL_DNAM, SEGTXT}, + { "C_lal", L_ARG, SEGTXT}, + { "C_lar", W_ARG, SEGTXT}, + { "C_lar_narg", NO_ARGS, SEGTXT}, + { "C_ldc", D_ARG, SEGTXT}, + { "C_lde", EXTERNAL, SEGTXT}, + { "C_lde_dlb", EXTERNAL_DLB, SEGTXT}, + { "C_lde_dnam", EXTERNAL_DNAM, SEGTXT}, + { "C_ldf", F_ARG, SEGTXT}, + { "C_ldl", L_ARG, SEGTXT}, + { "C_lfr", S_ARG, SEGTXT}, + { "C_lil", L_ARG, SEGTXT}, + { "C_lim", NO_ARGS, SEGTXT}, + { "C_lin", N_ARG, SEGTXT}, + { "C_lni", NO_ARGS, SEGTXT}, + { "C_loc", C_ARG, SEGTXT}, + { "C_loe", EXTERNAL, SEGTXT}, + { "C_loe_dlb", EXTERNAL_DLB, SEGTXT}, + { "C_loe_dnam", EXTERNAL_DNAM, SEGTXT}, + { "C_lof", F_ARG, SEGTXT}, + { "C_loi", O_ARG, SEGTXT}, + { "C_lol", L_ARG, SEGTXT}, + { "C_lor", R_ARG, SEGTXT}, + { "C_los", W_ARG, SEGTXT}, + { "C_los_narg", NO_ARGS, SEGTXT}, + { "C_lpb", NO_ARGS, SEGTXT}, + { "C_lpi", P_ARG, SEGTXT}, + { "C_lxa", N_ARG, SEGTXT}, + { "C_lxl", N_ARG, SEGTXT}, + { "C_magic", NO_ARGS, NOSEG}, + { "C_mes_begin", ONE_INT, NOSEG}, + { "C_mes_end", NO_ARGS, NOSEG}, + { "C_mlf", W_ARG, SEGTXT}, + { "C_mlf_narg", NO_ARGS, SEGTXT}, + { "C_mli", W_ARG, SEGTXT}, + { "C_mli_narg", NO_ARGS, SEGTXT}, + { "C_mlu", W_ARG, SEGTXT}, + { "C_mlu_narg", NO_ARGS, SEGTXT}, + { "C_mon", NO_ARGS, SEGTXT}, + { "C_ngf", W_ARG, SEGTXT}, + { "C_ngf_narg", NO_ARGS, SEGTXT}, + { "C_ngi", W_ARG, SEGTXT}, + { "C_ngi_narg", NO_ARGS, SEGTXT}, + { "C_nop", NO_ARGS, SEGTXT}, + { "C_open", _STRING, NOSEG}, + { "C_pnam", P_ARG, NOSEG}, + { "C_pro", P_ARG, SEGTXT}, + { "C_pro_narg", NO_ARGS, SEGTXT}, + { "C_rck", W_ARG, SEGTXT}, + { "C_rck_narg", NO_ARGS, SEGTXT}, + { "C_ret", Z_ARG, SEGTXT}, + { "C_rmi", W_ARG, SEGTXT}, + { "C_rmi_narg", NO_ARGS, SEGTXT}, + { "C_rmu", W_ARG, SEGTXT}, + { "C_rmu_narg", NO_ARGS, SEGTXT}, + { "C_rol", W_ARG, SEGTXT}, + { "C_rol_narg", NO_ARGS, SEGTXT}, + { "C_rom_cst", C_ARG, SEGROM}, + { "C_rom_dlb", EXTERNAL_DLB, SEGROM}, + { "C_rom_dnam", EXTERNAL_DNAM, SEGROM}, + { "C_rom_fcon", STRING_ARITH, SEGROM}, + { "C_rom_icon", STRING_ARITH, SEGROM}, + { "C_rom_ilb", B_ARG, SEGROM}, + { "C_rom_pnam", P_ARG, SEGROM}, + { "C_rom_scon", STRING_ARITH, SEGROM}, + { "C_rom_ucon", STRING_ARITH, SEGROM}, + { "C_ror", W_ARG, SEGTXT}, + { "C_ror_narg", NO_ARGS, SEGTXT}, + { "C_rtt", NO_ARGS, SEGTXT}, + { "C_sar", W_ARG, SEGTXT}, + { "C_sar_narg", NO_ARGS, SEGTXT}, + { "C_sbf", W_ARG, SEGTXT}, + { "C_sbf_narg", NO_ARGS, SEGTXT}, + { "C_sbi", W_ARG, SEGTXT}, + { "C_sbi_narg", NO_ARGS, SEGTXT}, + { "C_sbs", W_ARG, SEGTXT}, + { "C_sbs_narg", NO_ARGS, SEGTXT}, + { "C_sbu", W_ARG, SEGTXT}, + { "C_sbu_narg", NO_ARGS, SEGTXT}, + { "C_scon", STRING_ARITH, NOSEG}, + { "C_sde", EXTERNAL, SEGTXT}, + { "C_sde_dlb", EXTERNAL_DLB, SEGTXT}, + { "C_sde_dnam", EXTERNAL_DNAM, SEGTXT}, + { "C_sdf", F_ARG, SEGTXT}, + { "C_sdl", L_ARG, SEGTXT}, + { "C_set", W_ARG, SEGTXT}, + { "C_set_narg", NO_ARGS, SEGTXT}, + { "C_sig", NO_ARGS, SEGTXT}, + { "C_sil", L_ARG, SEGTXT}, + { "C_sim", NO_ARGS, SEGTXT}, + { "C_sli", W_ARG, SEGTXT}, + { "C_sli_narg", NO_ARGS, SEGTXT}, + { "C_slu", W_ARG, SEGTXT}, + { "C_slu_narg", NO_ARGS, SEGTXT}, + { "C_sri", W_ARG, SEGTXT}, + { "C_sri_narg", NO_ARGS, SEGTXT}, + { "C_sru", W_ARG, SEGTXT}, + { "C_sru_narg", NO_ARGS, SEGTXT}, + { "C_ste", EXTERNAL, SEGTXT}, + { "C_ste_dlb", EXTERNAL_DLB, SEGTXT}, + { "C_ste_dnam", EXTERNAL_DNAM, SEGTXT}, + { "C_stf", F_ARG, SEGTXT}, + { "C_sti", O_ARG, SEGTXT}, + { "C_stl", L_ARG, SEGTXT}, + { "C_str", R_ARG, SEGTXT}, + { "C_sts", W_ARG, SEGTXT}, + { "C_sts_narg", NO_ARGS, SEGTXT}, + { "C_teq", NO_ARGS, SEGTXT}, + { "C_tge", NO_ARGS, SEGTXT}, + { "C_tgt", NO_ARGS, SEGTXT}, + { "C_tle", NO_ARGS, SEGTXT}, + { "C_tlt", NO_ARGS, SEGTXT}, + { "C_tne", NO_ARGS, SEGTXT}, + { "C_trp", NO_ARGS, SEGTXT}, + { "C_ucon", STRING_ARITH, NOSEG}, + { "C_xor", W_ARG, SEGTXT}, + { "C_xor_narg", NO_ARGS, SEGTXT}, + { "C_zeq", B_ARG, SEGTXT}, + { "C_zer", W_ARG, SEGTXT}, + { "C_zer_narg", NO_ARGS, SEGTXT}, + { "C_zge", B_ARG, SEGTXT}, + { "C_zgt", B_ARG, SEGTXT}, + { "C_zle", B_ARG, SEGTXT}, + { "C_zlt", B_ARG, SEGTXT}, + { "C_zne", B_ARG, SEGTXT}, + { "C_zre", EXTERNAL, SEGTXT}, + { "C_zre_dlb", EXTERNAL_DLB, SEGTXT}, + { "C_zre_dnam", EXTERNAL_DNAM, SEGTXT}, + { "C_zrf", W_ARG, SEGTXT}, + { "C_zrf_narg", NO_ARGS, SEGTXT}, + { "C_zrl", L_ARG, SEGTXT}, + { "jump", _STRING, SEGTXT}, + { "locals", N_ARG, SEGTXT}, + { "prolog", NO_ARGS, SEGTXT} + }; + +set_C_instr_info( instr) +char *instr; +{ + int low, high, mid, rel; + + low = 0; + high = N_INSTR - 1; + + while ( TRUE) { + mid = ( low + high) / 2; + rel = strcmp( instr, EM_instr[mid].name); + + if ( rel == 0 ) + break; + else if ( high == low) { + out( "ERROR : can't find >>%s<< !!\n", instr); + abort(); + } + else if ( rel < 0) + high = mid; + else + /* pas op, mid is naar beneden afgerond !! */ + low = ( mid == low ? low + 1: mid); + } + C_instr_info = &C_info[ EM_instr[mid].class]; + segment = EM_instr[mid].segment; +} + +int arg_type( arg) +char *arg; + +/* return argument-type from $i */ + +{ + int i; + + i = *(arg+1) - '0' - 1; + return( C_instr_info->arg_type[i]); +} diff --git a/util/ceg/EM_parser/common/Makefile b/util/ceg/EM_parser/common/Makefile new file mode 100644 index 000000000..72f28c08e --- /dev/null +++ b/util/ceg/EM_parser/common/Makefile @@ -0,0 +1,25 @@ +EM=/proj/em/Work + +GFILES = pars.g +OFILES = pars.o Lpars.o scan.o mylex.o default.o C_instr2.o assem.o eval.o\ + action.o +IFILES = -I$(EM)/h -I$(EM)/modules/h +CC = cc + +.c.o : + $(CC) $(IFILES) -c $< + rm -f ../obj_EM_pars/$*.o + rm -f ../as_EM_pars/$*.o + ln $*.o ../obj_EM_pars/$*.o + ln $*.o ../as_EM_pars/$*.o + +common : dummy $(OFILES) + touch ../*/em_parser + +dummy : $(GFILES) + LLgen $(LLOPT) $(GFILES) + touch dummy + +Lpars.o : Lpars.h decl.h +pars.o : Lpars.h decl.h +Lpars.o : Lpars.h decl.h diff --git a/util/ceg/EM_parser/common/action.c b/util/ceg/EM_parser/common/action.c new file mode 100644 index 000000000..cecbd1dc1 --- /dev/null +++ b/util/ceg/EM_parser/common/action.c @@ -0,0 +1,45 @@ +#include "decl.h" +#include + +int quantum = 0, nr_instr, block_saved, first_action, last_action; +extern char *malloc(), *realloc(), *Salloc(); +char **as_instructions; + +init_as_block() +{ + nr_instr = 0; + block_saved = TRUE; + + if ( quantum == 0) { + quantum = 16; + as_instructions = (char **)malloc( quantum*sizeof( char *)); + } +} + + +save_as( instr) +char *instr; +{ + if ( nr_instr == quantum) { + quantum *= 2; + as_instructions = (char **) realloc( as_instructions, + quantum*sizeof( char *)); + } + + as_instructions[nr_instr++] = Salloc( instr, strlen( instr) + 1); +} + +do_block_assemble() +{ + int i; + + if ( block_saved) { + block_assemble( as_instructions, nr_instr, + first_action, last_action); + + for ( i=0; i + +File *save_file; +extern File *outfile; +extern char yytext[]; +int def_start, def_end, save_lineno; +extern int yylineno; + +init_defaults( instr) +char *instr; +{ + save_file = outfile; + save_lineno = yylineno; + sys_open( ".default", OP_WRITE, &outfile); + set_def_params( instr); +} + +#define _ICON 0 +#define _UCON 4 +#define _FCON 8 +#define C_DEE 12 +#define C_FIL 15 +#define C_GTO 18 +#define C_INE 21 +#define C_LAE 24 +#define C_LDE 27 +#define C_LOE 30 +#define C_SDE 33 +#define C_STE 36 +#define C_ZRE 39 + +struct { char *name; int segment, generated} + def_info[] = { + /* _ICON */ { "C_con_icon", SEGCON, 0}, + { "C_rom_icon", SEGROM, 0}, + { "C_hol_icon", NOSEG, 0}, + { "C_bss_icon", NOSEG, 0}, + + /* _UCON */ { "C_con_ucon", SEGCON, 0}, + { "C_rom_ucon", SEGROM, 0}, + { "C_hol_ucon", NOSEG, 0}, + { "C_bss_ucon", NOSEG, 0}, + + /* _FCON */ { "C_con_fcon", SEGCON, 0}, + { "C_rom_fcon", SEGROM, 0}, + { "C_hol_fcon", NOSEG, 0}, + { "C_bss_fcon", NOSEG, 0}, + + /* C_DEE */ { "C_dee", SEGTXT, 0}, + { "C_dee_dnam", SEGTXT, 0}, + { "C_dee_dlb", SEGTXT, 0}, + + /* C_FIL */ { "C_fil", SEGTXT, 0}, + { "C_fil_dnam", SEGTXT, 0}, + { "C_fil_dlb", SEGTXT, 0}, + + /* C_GTO */ { "C_gto", SEGTXT, 0}, + { "C_gto_dnam", SEGTXT, 0}, + { "C_gto_dlb", SEGTXT, 0}, + + /* C_INE */ { "C_ine", SEGTXT, 0}, + { "C_ine_dnam", SEGTXT, 0}, + { "C_ine_dlb", SEGTXT, 0}, + + /* C_LAE */ { "C_lae", SEGTXT, 0}, + { "C_lae_dnam", SEGTXT, 0}, + { "C_lae_dlb", SEGTXT, 0}, + + /* C_LDE */ { "C_lde", SEGTXT, 0}, + { "C_lde_dnam", SEGTXT, 0}, + { "C_lde_dlb", SEGTXT, 0}, + + /* C_LOE */ { "C_loe", SEGTXT, 0}, + { "C_loe_dnam", SEGTXT, 0}, + { "C_loe_dlb", SEGTXT, 0}, + + /* C_SDE */ { "C_sde", SEGTXT, 0}, + { "C_sde_dnam", SEGTXT, 0}, + { "C_sde_dlb", SEGTXT, 0}, + + /* C_STE */ { "C_ste", SEGTXT, 0}, + { "C_ste_dnam", SEGTXT, 0}, + { "C_ste_dlb", SEGTXT, 0}, + + /* C_ZRE */ { "C_zre", SEGTXT, 0}, + { "C_zre_dnam", SEGTXT, 0}, + { "C_zre_dlb", SEGTXT, 0} + }; + +int bss_or_hol_instr( index) +int index; +{ + return ( index == _ICON + 2 || index == _ICON + 3 || + index == _UCON + 2 || index == _UCON + 3 || + index == _FCON + 2 || index == _FCON + 3); +} + +set_def_params( instr) +char *instr; + +/* geef def_start en def_end een waarde */ + +{ + int low, high, mid, rel; + + if ( *instr == '.') { /* ..icon | ..ucon | ..fcon */ + switch ( *(instr+2)) { + case 'i' : def_start = _ICON; + break; + case 'u' : def_start = _UCON; + break; + case 'f' : def_start = _FCON; + break; + } + def_end = def_start + 3; + } + else { + low = C_DEE; + high = C_ZRE; + + while ( TRUE) { + mid = ( low + high) / 6 * 3; + rel = strncmp( instr, def_info[mid].name, 5); + + if ( rel == 0 ) + break; + else if ( high == low) + abort(); + else if ( rel < 0) + high = mid; + else + /* pas op, mid is naar beneden afgerond !! */ + low = ( mid == low ? low + 3: mid); + } + def_start = mid; + def_end = def_start + 2; + } +} + +#include +#include "Lpars.h" + +handle_defaults() + +/* Zorgen dat de lexical-analyzer nu van de .default-file leest. */ + +{ + FILE *old, *tmp, *switch_input(); + int i, old_yylineno; + extern int CD_pos; + + sys_close( outfile); + outfile = save_file; + + tmp = fopen( ".default", "r"); + old = switch_input( tmp); + old_yylineno = yylineno; + + for ( i = def_start; i <= def_end; i++) { + yylineno = save_lineno; + if ( !def_info[i].generated) { + set_C_instr_info( def_info[i].name); + segment = def_info[i].segment; + + set_outfile( def_info[i].name); + header( def_info[i].name); + CD_pos = TRUE; /* zet mylex() in juiste positie! */ + + if ( bss_or_hol_instr( i)) { + extnd_header(); + /* Zorg voor de juiste $args */ + set_C_instr_info( def_info[i-2].name); + def_row(); + out( "}\n\n"); + } + else + def_row(); + rewind( tmp); + } + } + fclose( tmp); + switch_input( old); + yylineno = old_yylineno; +} + +def_admn( instr) +char *instr; +{ + /* Noteer dat deze instructie gegenereerd is */ + + int low, high, mid, rel; + + low = _ICON; + high = C_ZRE + 2; + + while ( TRUE) { + mid = ( low + high) / 2; + rel = strcmp( instr, def_info[mid].name); + + if ( rel == 0 ) + break; + else if ( high == low) + return; + else if ( rel < 0) + high = mid; + else + /* pas op, mid is naar beneden afgerond !! */ + low = ( mid == low ? low + 1: mid); + } + def_info[mid].generated = 1; +} + +extnd_header() +{ + out( "if ( %s == 0 ) {\n", C_instr_info->arg_id[3]); + set_segment( SEGBSS); + out( "bss( %s);\n", C_instr_info->arg_id[0]); + out( "}\nelse {\n"); + set_segment( SEGCON); + out( "for ( %s = 0; %s < %s/EM_WSIZE; %s++)\n", + C_instr_info->arg_id[3], C_instr_info->arg_id[3], + C_instr_info->arg_id[0], C_instr_info->arg_id[3]); +} diff --git a/util/ceg/EM_parser/common/em_parser.h b/util/ceg/EM_parser/common/em_parser.h new file mode 100644 index 000000000..036770f2b --- /dev/null +++ b/util/ceg/EM_parser/common/em_parser.h @@ -0,0 +1,10 @@ +#define SEGBSS 0 +#define SEGHOL 1 +#define SEGCON 2 +#define SEGROM 3 +#define SEGTXT 4 + +#define STRING 0 +#define LABEL 1 +#define ARITH 2 +#define INT 3 diff --git a/util/ceg/EM_parser/common/eval.c b/util/ceg/EM_parser/common/eval.c new file mode 100644 index 000000000..0c180c250 --- /dev/null +++ b/util/ceg/EM_parser/common/eval.c @@ -0,0 +1,20 @@ +#include +#include "decl.h" + + +eval( str) +char *str; +{ + register char c; + int i; + + for ( c = *str++; c != '\0'; c= *str++) + if ( c == '$' && isdigit( *str)) { + + i = *str++ - '0' - 1; + + out( "%s", C_instr_info->arg_conv[i]); + } + else + out( "%c", c); +} diff --git a/util/ceg/EM_parser/common/mylex.c b/util/ceg/EM_parser/common/mylex.c new file mode 100644 index 000000000..825e31638 --- /dev/null +++ b/util/ceg/EM_parser/common/mylex.c @@ -0,0 +1,272 @@ +#include "Lpars.h" +#include +#include + +#define YYTEXT 256 +#define FALSE 0 +#define TRUE 1 + +char yytext[YYTEXT], *next; +int CD_pos = FALSE; /* condition or default allowed ? */ + +int mylex() +{ + char c, scanc(), skip_space(); + + static int special = FALSE; /* rule with conditions + default ? */ + + next = yytext; + c = *next++ = skip_space(); + switch ( c) { + case EOF : next = yytext; + return( 0); + + case '"' : read_string(); + return( ASSEM_INSTR); + + case '.' : c = scanc(); + backc( c); + if ( c != '.') { /* geen ..icon o.i.d. */ + if ( special) + CD_pos = TRUE; + return( '.'); + } + break; + + case ';' : return( ';'); + + case '=' : if ( arrow()) { + CD_pos = FALSE; + return( ARROW); + } + break; + + case ':' : if ( equiv()) { + CD_pos = FALSE; + return( EQUIV); + } + break; + + case 'd' : if ( CD_pos && _default()) { + CD_pos = FALSE; + special = FALSE; + return( DEFAULT); + } + break; + } + if ( CD_pos) { + read_condition(); + CD_pos = FALSE; + special = TRUE; + return( CONDITION); + } + if ( isalpha( c)) { + read_ident(); + c = skip_space(); + if ( c == '(') { + *next++ = c; + read_call(); + return( CALL); + } + else { + backc( c); + if ( is_DEF_C_INSTR( yytext)) { + CD_pos = TRUE; + return( DEF_C_INSTR); + } + if ( is_C_INSTR( yytext)) { + CD_pos = TRUE; + return( C_INSTR); + } + return( ERROR); + } + } + if ( c == '.') { + c = scanc(); + if ( c == '.') { + *next++ = '.'; + read_ident(); + if ( is_DEF_C_INSTR( yytext)) { + CD_pos = TRUE; + return( DEF_C_INSTR); + } + return( ERROR); + } + else { + backc( c); + return( '.'); + } + } + return( c); +} + +int isletter( c) +char c; +{ + return( isalpha( c) || isdigit( c) || c == '_'); +} + +static char skip_space() +{ + char c; + + while ( isspace( c = scanc())) + ; + return( c); +} + + +/* first character has been read */ + +read_string() + +/* de "'s eraf strippen!! */ + +{ + next--; + while( ( *next = scanc()) != '"' || *(next-1) == '\\') + next++; +} + +int arrow() +{ + if ( ( *next++ = scanc()) == '=') + if ( ( *next++ = scanc()) == '>') + return( TRUE); + else + backc( *--next); + else + backc( *--next); + return( FALSE); +} + +int equiv() +{ + if ( ( *next++ = scanc()) == ':') + if ( ( *next++ = scanc()) == '=') + return( TRUE); + else + backc( *--next); + else + backc( *--next); + return( FALSE); +} + +int _default() +{ + char c; + + if ( ( *next++ = scanc()) == 'e') + if ( ( *next++ = scanc()) == 'f') + if ( ( *next++ = scanc()) == 'a') + if ( ( *next++ = scanc()) == 'u') + if ( ( *next++ = scanc()) == 'l') + if ( ( *next++ = scanc()) == 't') + if ( !isletter( c = scanc())) { + backc( c); + return( TRUE); + } + else + backc( c); + else + backc( *--next); + else + backc( *--next); + else + backc( *--next); + else + backc( *--next); + else + backc( *--next); + else + backc( *--next); + return( FALSE); +} + +read_ident() +{ + char c; + + while ( isletter( c = scanc())) + *next++ = c; + backc( c); +} + +read_call() +{ + int n = 1; + + while ( TRUE) + switch( *next++ = scanc()) { + case EOF : return; + + case '(' : n++; + break; + + case ')' : n--; + if ( n == 0) + return; + break; + } +} + +read_condition() +{ + while ( TRUE) { + switch ( *next++ = scanc()) { + case EOF : return; + + case '=' : if ( arrow()) { + backc( '>'); + backc( '='); + backc( '='); + next -= 3; + return; + } + break; + + case ':' : if ( equiv()) { + backc( '='); + backc( ':'); + backc( ':'); + next -= 3; + return; + } + break; + } + } +} + +is_C_INSTR( str) +char *str; +{ + if ( *str == 'C' && *(str+1) == '_') + return( TRUE); + else if ( strncmp( "locals", str, 6) == 0) + return( TRUE); + else if ( strncmp( "jump", str, 4) == 0) + return( TRUE); + else if ( strncmp( "prolog", str, 6) == 0) + return( TRUE); + else + return( FALSE); +} + +is_DEF_C_INSTR( str) +char *str; + +/* Er is gelezen [..][letter]* */ + +{ + if ( *str == '.' && *(str+1) == '.') + return( next > yytext+1); + + if ( ( *next++ = scanc()) == '.') + if ( ( *next++ = scanc()) == '.') + return( next > yytext+1); + else + backc( *--next); + else + backc( *--next); + return( FALSE); +} diff --git a/util/ceg/EM_parser/common/scan.c b/util/ceg/EM_parser/common/scan.c new file mode 100644 index 000000000..44f1e13ae --- /dev/null +++ b/util/ceg/EM_parser/common/scan.c @@ -0,0 +1,76 @@ +#include + +FILE *infile = stdin; + +#define BUF_SIZE 16 +char buf[BUF_SIZE], /* Bufer to save backc()-characters */ + *bufptr = buf; /* Pointer to space for backc()-character */ +int yylineno = 1; + + +char nextc() +{ + if ( bufptr > buf) + return( *--bufptr); + else + return( getc( infile)); +} + + +backc( c) +char c; +{ + if ( bufptr > buf + BUF_SIZE) + error( "backc(), no space in buffer left!"); + else { + if ( c == '\n') + yylineno--; + *bufptr++ = c; + } +} + + +char scanc() + +/* Get next character, but delete al C-comments */ + +{ + char c; + + c = nextc(); + while ( c == '/') { + c = nextc(); + if ( c == '*') { /* start of comment */ + while ( nextc() != '*' || nextc() != '/') + ; + c = nextc(); + } + else { + backc( c); + return( '/'); + } + } + if ( c == '\n') + yylineno++; + return( c); +} + + +FILE *switch_input( new) +FILE *new; + +/* Return the current FILE, if buf[] can't be cleaned NULL will be returned */ + +{ + char *ptr; FILE *old; + + /* Clean buf[] */ + for ( ptr = buf; ptr < bufptr; ptr++) + if ( ungetc( *ptr, infile) == EOF && *ptr != EOF) + return( NULL); + + bufptr = buf; + old = infile; + infile = new; + return( old); +} diff --git a/util/ceg/EM_parser/obj_EM_pars/Makefile b/util/ceg/EM_parser/obj_EM_pars/Makefile new file mode 100644 index 000000000..12e3cd930 --- /dev/null +++ b/util/ceg/EM_parser/obj_EM_pars/Makefile @@ -0,0 +1,12 @@ +EM=/proj/em/Work + +OFILES = dist.o + +IFILES = -I$(EM)/h -I$(EM)/modules/h +CC = cc + +.c.o : + $(CC) $(IFILES) -c $< + +em_parser : $(OFILES) + touch em_parser diff --git a/util/ceg/EM_parser/obj_EM_pars/arg_type.h b/util/ceg/EM_parser/obj_EM_pars/arg_type.h new file mode 100644 index 000000000..5bad322e0 --- /dev/null +++ b/util/ceg/EM_parser/obj_EM_pars/arg_type.h @@ -0,0 +1,3 @@ +#define STRING 0 +#define ARITH 1 +#define INT 2 diff --git a/util/ceg/EM_parser/obj_EM_pars/dist.c b/util/ceg/EM_parser/obj_EM_pars/dist.c new file mode 100644 index 000000000..0acf8eb20 --- /dev/null +++ b/util/ceg/EM_parser/obj_EM_pars/dist.c @@ -0,0 +1,102 @@ +#include +#include "em.h" + +arith cur_pos = 0; + +dist( lab) +char *lab; +{ + out( "$%s$ - %ld", lab, cur_pos); +} + +#define MAX_LABEL 10 +#define TRUE 1 +#define FALSE 0 + + +struct t_label { + char *lab; + arith position; + }; + +struct t_label label_list[ MAX_LABEL]; +int n_labs = 0; + +handle_label( lab) +char *lab; +{ + char *Salloc(); + + if ( n_labs >= MAX_LABEL) + error( "Too many labels!!\n"); + else { + label_list[ n_labs].lab = Salloc( lab, strlen( lab) + 1); + label_list[ n_labs++].position = cur_pos; + } + process_label( lab); +} + + +relocate( f) +FILE *f; +{ + char buf[256]; + int i; + + fscanf( f, " %[^$]$", buf); + for ( i = 0; i < n_labs; i++) + if ( strcmp( buf, label_list[i].lab) == 0) { + out( "%ld", label_list[i].position); + return; + } + error( "relocate() : can't find local label %s\n", buf); +} + +#include + +File *oldout; +extern File *outfile; + +back_patch() +{ + FILE *save; + char c, c1; + + sys_close( outfile); + outfile = oldout; + save = fopen( ".tmp", "r"); + + while ( ( c = getc( save)) != EOF) + if ( c == '$') + relocate( save); + else if ( c == '/') { /* skip comments */ + c = getc( save); + out( "/%c", c); + if ( c == '*') { + c = getc( save); + do { + out( "%c", c); + c1 = c; + c = getc( save); + } + while ( !( c1 == '*' && c == '/')); + out( "%c", c); + } + } + else + out( "%c", c); + fclose( save); +} + + +save_output() +{ + extern arith cur_pos; + extern int n_labs; + + oldout = outfile; + if ( ! sys_open( ".tmp", OP_WRITE, &outfile)) + fprint( STDERR, "can't open .tmp\n"); + cur_pos = 0; + n_labs = 0; /* geheugen-ruimte teruggeven? */ +} diff --git a/util/ceg/EM_parser/obj_EM_pars/em_parser.h b/util/ceg/EM_parser/obj_EM_pars/em_parser.h new file mode 100644 index 000000000..036770f2b --- /dev/null +++ b/util/ceg/EM_parser/obj_EM_pars/em_parser.h @@ -0,0 +1,10 @@ +#define SEGBSS 0 +#define SEGHOL 1 +#define SEGCON 2 +#define SEGROM 3 +#define SEGTXT 4 + +#define STRING 0 +#define LABEL 1 +#define ARITH 2 +#define INT 3 diff --git a/util/ceg/as_parser/Makefile b/util/ceg/as_parser/Makefile new file mode 100644 index 000000000..a1b8a082c --- /dev/null +++ b/util/ceg/as_parser/Makefile @@ -0,0 +1,28 @@ +EM=/proj/em/Work + +GFILES = pars.g +OFILES = pars.o Lpars.o lex.yy.o help.o conversion.o +IFILES = -I$(EM)/h -I$(EM)/modules/h +LIBS = $(EM)/modules/lib/liballoc.a\ + $(EM)/modules/lib/libprint.a\ + $(EM)/modules/lib/libstring.a\ + $(EM)/modules/lib/libsystem.a +CC = cc + +.c.o : + $(CC) $(IFILES) -c $< + +as_parser : dummy $(OFILES) + $(CC) -o as_parser $(OFILES) $(LIBS) -ll + +lex.yy.c : table.l + lex table.l + +dummy : $(GFILES) + LLgen $(LLOPT) $(GFILES) + touch dummy + +Lpars.o : Lpars.h decl.h +pars.o : Lpars.h decl.h +Lpars.o : Lpars.h decl.h +lex.yy.o : Lpars.h decl.h diff --git a/util/ceg/as_parser/as_parser.h b/util/ceg/as_parser/as_parser.h new file mode 100644 index 000000000..8de0d14dc --- /dev/null +++ b/util/ceg/as_parser/as_parser.h @@ -0,0 +1,5 @@ +#include +#include + +extern File *outfile; +extern arith cur_pos; diff --git a/util/ceg/as_parser/const.h b/util/ceg/as_parser/const.h new file mode 100644 index 000000000..e5acbcc43 --- /dev/null +++ b/util/ceg/as_parser/const.h @@ -0,0 +1,7 @@ + +#define Bool int + +#define TRUE 1 +#define FALSE 0 +#define MAX_OPERANDS 4 +#define MAX_MNEMONICS 100 diff --git a/util/ceg/as_parser/conversion.c b/util/ceg/as_parser/conversion.c new file mode 100644 index 000000000..7b9dfc6e0 --- /dev/null +++ b/util/ceg/as_parser/conversion.c @@ -0,0 +1,97 @@ +pr_text_with_conversions( str) +char *str; +{ + char *ptr, *next_conversion(), *pr_conversion(); + + while ( ptr = next_conversion( str)) { + /* ptr points to '%'-sign */ + *ptr = '\0'; + out( "fprint( outfile, \"%s\");", str); + *ptr = '%'; + str = pr_conversion( ptr); + } + out( "fprint( outfile, \"%s\");", str); +} + +char *next_conversion( str) +char *str; +{ + char *match(); + + while ( *str && *str != '%') { + switch ( *str++) { + case '\'' : str = match( '\'', str) + 1; + break; + case '"' : str = match( '"', str) + 1; + break; + } + } + return( *str == '%' ? str : (char *)0); +} + +char *match( c, str) +char c, *str; +{ + while ( *str && ( *str != c || *(str-1) == '\\')) + str++; + return( *str ? str : str-1); +} + +char *match_bracket( str) +char *str; + +/* find ')', but look at nesting '('-')' pairs, return position of ')'. + */ +{ + int depth; + char *match(); + + depth = 1; + while ( *str && depth != 0) { + switch ( *str++) { + case '\'' : str = match( '\'', str+1) + 1; + break; + case '"' : str = match( '"', str+1) + 1; + break; + case '(' : depth++; + break; + case ')' : depth--; + break; + } + } + return( str-1); +} + + +char *find( c, str) +char c, *str; +{ + while ( *str && *str != c) + str++; + return( str); +} + +char *pr_conversion( str) +char *str; + +/* str points to '%'-sign, returns pointer to first character AFTER the + * conversion + */ +{ + char *start, *ptr, *match_bracket(), *find(); + + start = find( '(', str+1); + *start++ = '\0'; + + ptr = match_bracket( start); + *ptr = '\0'; + + if ( *(str+1) == '$') + out( "eval( %s);", start); + else if ( strncmp( str+1, "dist", 4) == 0) + out( "dist( %s);", start); + else + out( "fprint( outfile, \"%%%s\", %s);", str+1, start); + + return( ptr+1); +} diff --git a/util/ceg/as_parser/decl.h b/util/ceg/as_parser/decl.h new file mode 100644 index 000000000..8be2405b0 --- /dev/null +++ b/util/ceg/as_parser/decl.h @@ -0,0 +1,3 @@ +#include +#include +#include "const.h" diff --git a/util/ceg/as_parser/eval/Makefile b/util/ceg/as_parser/eval/Makefile new file mode 100644 index 000000000..50a71e643 --- /dev/null +++ b/util/ceg/as_parser/eval/Makefile @@ -0,0 +1,2 @@ +eval : eval.c states.h + cc -o eval eval.c diff --git a/util/ceg/as_parser/eval/eval.c b/util/ceg/as_parser/eval/eval.c new file mode 100644 index 000000000..1998d1b75 --- /dev/null +++ b/util/ceg/as_parser/eval/eval.c @@ -0,0 +1,309 @@ +#include +#include +#include "states.h" + + +#define is_letter( c) ( isalpha( c) || isdigit( c) || c == '_') +#define save_or_put(c) if(previous_state==TEXT)putchar(c);else *bufptr++=c + + + + +main() +{ + char buffer[256], *bufptr = buffer; + int c, state = TEXT, previous_state = TEXT, depth = 0; + + pr_header(); + while ( ( c = getchar()) != EOF) + switch ( state) { + case TEXT : + switch ( c) { + case '/' : state = SLASH; + previous_state = TEXT; + save_or_put( c); + break; + case '"' : state = STRING; + previous_state = TEXT; + save_or_put( c); + break; + case '\'': state = CHAR_CONST; + previous_state = TEXT; + save_or_put( c); + break; + case '@' : state = AT; + break; + default : putchar( c); + break; + } + break; + + + case SLASH : + state = ( c == '*' ? COMMENT : TEXT); + save_or_put( c); + break; + case COMMENT : + if ( c == '*') + state = STAR; + save_or_put( c); + break; + case STAR : + if ( c == '/') + state = previous_state; + else if ( c != '*') + state = COMMENT; + save_or_put( c); + break; + + + + case STRING : + if ( c == '"') + state = previous_state; + else if ( c == '\\') + state = BACKSLASH_in_STRING; + save_or_put( c); + break; + + case BACKSLASH_in_STRING : + state = STRING; + save_or_put( c); + break; + + + + + case CHAR_CONST : + if ( c == '\'') + state = previous_state; + else if ( c == '\\') + state = BACKSLASH_in_CHAR_CONST; + save_or_put( c); + break; + + case BACKSLASH_in_CHAR_CONST : + state = CHAR_CONST; + save_or_put( c); + break; + + + + case AT : /* @if '(' ')' + * @elsif '(' ')' + * @else + * @fi + * @ '(' ')' + */ + if ( is_letter( c)) + *bufptr++ = c; + else { + ungetc( c, stdin); + state = WHITE_SPACE; + } + break; + + case WHITE_SPACE : + if ( isspace( c)) + *bufptr++ = c; + else if ( c == '(') { + *bufptr++ = c; + depth = 1; + state = CAL_or_QUEST; + } + else { + *bufptr = '\0'; + pr_ELSE_or_FI( buffer); + bufptr = buffer; + ungetc( c, stdin); + state = TEXT; + } + break; + + case CAL_or_QUEST : /* match ')' */ + *bufptr++ =c; + switch ( c) { + case '(' : depth++; + break; + case ')' : depth--; + if ( depth == 0) { + *bufptr = '\0'; + pr_CALL_or_QUEST( buffer); + bufptr = buffer; + state = TEXT; + } + break; + case '/' : state = SLASH; + previous_state = CAL_or_QUEST; + break; + case '"' : state = STRING; + previous_state = CAL_or_QUEST; + break; + case '\'': state = CHAR_CONST; + previous_state = CAL_or_QUEST; + break; + } + break; + default : + fprintf( stderr, "Unknown state : %d\n", state); + break; + } + exit( 0); +} + +pr_header() +{ + printf( "#include \"as_parser.h\"\n"); + printf( "#line 1 \"as.c\"\n"); +} + + +pr_ELSE_or_FI( str) +char *str; +{ + if ( strncmp( str, "else", 4) == 0) + printf( "fprint( outfile, \"}\else {\");%s", str+4); + else if ( strncmp( str, "fi", 2) == 0) + printf( "fprint( outfile, \"}\");%s", str+2); + else + fprintf( stderr, "%s unexpected!!\n", str); +} + + +pr_CALL_or_QUEST( str) +char *str; +{ + if ( strncmp( str, "if", 2) == 0 && !(is_letter( *(str+2)))) + pr_if( str); + else if ( strncmp( str, "elsif", 5) == 0 && !(is_letter( *(str+5)))) + pr_elsif( str); + else + pr_call( str); +} + + +pr_call( call) +char *call; +{ + if ( strncmp( "text", call, 4) == 0 && isdigit( *(call+4))) + printf( "cur_pos += %d;", *(call+4) - '0'); + else if ( strncmp( "reloc", call, 5) == 0 && isdigit( *(call+5))) + printf( "cur_pos += %d;", *(call+5) - '0'); + + pr_text_with_conversions( call); + printf( "fprint( outfile, \";\")"); +} + +pr_elsif( quest) +char *quest; +{ + printf( "fprint( outfile, \"}\else if\");"); + pr_text_with_conversions( quest+5); + printf( "fprint( outfile, \"{\");"); +} + +pr_if( quest) +char *quest; +{ + pr_text_with_conversions( quest); + printf( "fprint( outfile, \"{\");"); +} + + +pr_text_with_conversions( str) +char *str; +{ + char *ptr, *next_conversion(), *pr_conversion(); + + while ( ptr = next_conversion( str)) { + /* ptr points to '%'-sign */ + *ptr = '\0'; + printf( "fprint( outfile, \"%s\");", str); + *ptr = '%'; + str = pr_conversion( ptr); + } + printf( "fprint( outfile, \"%s\");", str); +} + +char *next_conversion( str) +char *str; +{ + char *match(); + + while ( *str && *str != '%') { + switch ( *str++) { + case '\'' : str = match( '\'', str) + 1; + break; + case '"' : str = match( '"', str) + 1; + break; + } + } + return( *str == '%' ? str : (char *)0); +} + +char *match( c, str) +char c, *str; +{ + while ( *str && ( *str != c || *(str-1) == '\\')) + str++; + return( *str ? str : str-1); +} + +char *match_bracket( str) +char *str; + +/* find ')', but look at nesting '('-')' pairs, return position of ')'. + */ +{ + int depth; + char *match(); + + depth = 1; + while ( *str && depth != 0) { + switch ( *str++) { + case '\'' : str = match( '\'', str+1) + 1; + break; + case '"' : str = match( '"', str+1) + 1; + break; + case '(' : depth++; + break; + case ')' : depth--; + break; + } + } + return( str-1); +} + + +char *find( c, str) +char c, *str; +{ + while ( *str && *str != c) + str++; + return( str); +} + +char *pr_conversion( str) +char *str; + +/* str points to '%'-sign, returns pointer to first character AFTER the + * conversion + */ +{ + char *start, *ptr, *match_bracket(), *find(); + + start = find( '(', str+1); + *start++ = '\0'; + + ptr = match_bracket( start); + *ptr = '\0'; + + if ( *(str+1) == '$') + printf( "eval( %s);", start); + else if ( strncmp( str+1, "dist", 4) == 0) + printf( "dist( %s);", start); + else + printf( "fprint( outfile, \"%%%s\", %s);", str+1, start); + + return( ptr+1); +} diff --git a/util/ceg/as_parser/eval/states.h b/util/ceg/as_parser/eval/states.h new file mode 100644 index 000000000..33da441aa --- /dev/null +++ b/util/ceg/as_parser/eval/states.h @@ -0,0 +1,11 @@ +#define TEXT 1 +#define SLASH 2 +#define COMMENT 3 +#define STAR 4 +#define STRING 5 +#define BACKSLASH_in_STRING 6 +#define CHAR_CONST 7 +#define BACKSLASH_in_CHAR_CONST 8 +#define AT 9 +#define CAL_or_QUEST 10 +#define WHITE_SPACE 11 diff --git a/util/ceg/as_parser/help.c b/util/ceg/as_parser/help.c new file mode 100644 index 000000000..002d141f9 --- /dev/null +++ b/util/ceg/as_parser/help.c @@ -0,0 +1,287 @@ +#include "decl.h" +extern char *strindex(); + +static struct Op_info { char *name, *type} + op_info[ MAX_OPERANDS] = { { 0, 0}}; +static int n_ops = 0; +static char *assem_instr = 0; +static Bool restriction = FALSE; +File *outfile; + +save_instr( instr, len) +char *instr; +int len; +{ + assem_instr = Salloc( instr, len + 1); +} + +save_name( name, len) +char *name; +int len; +{ + op_info[ n_ops].name = Salloc( name, len + 1); +} + +save_type( type, len) +char *type; +int len; +{ + op_info[ n_ops].type = Salloc( type, len + 1); + restriction = TRUE; +} + +pr_header() +{ + out( "%s_instr", assem_instr); + param_list(); + out( "{\n"); + save_mnem( assem_instr); +} + +param_list() +{ + int i; + + out( "("); + if ( n_ops > 0) { + out( " %s", op_info[0].name); + for ( i = 1; i < n_ops; i++) + out( ", %s", op_info[i].name); + } + + out( ")\n"); + if ( n_ops > 0) { + out( "struct t_operand *%s", op_info[0].name); + for ( i = 1; i < n_ops; i++) + out( ", *%s", op_info[i].name); + out( ";\n"); + } +} + + +pr_restriction() +{ + int i; + Bool more = FALSE; + + if ( !restriction) + return; + + out( "if ( "); + for ( i = 0; i < n_ops; i++) + if ( op_info[i].type != 0) { + if ( more) + out( " &&"); + out( " %s( %s)", op_info[i].type, op_info[i].name); + more = TRUE; + } + out( ") "); +} + +pr_warning() +{ + if ( restriction) + out( "else\nerror( \"No match for %s\");\n", assem_instr); + restriction = FALSE; +} + +clear_restriction() +{ + restriction = FALSE; +} + +char *skip_string( str) +char *str; +{ + for ( str++; *str != '"' || *(str-1) == '\\'; str++); + return( str + 1); +} + +pr_subroutine( str) +char *str; +{ + out( "%s;\n", str); +} + + +#include + +pr_call( str) +char *str; +{ + if ( strncmp( "text", str, 4) == 0 && isdigit( *(str+4))) + out( "cur_pos += %d;\n", *(str+4) - '0'); + else if ( strncmp( "reloc", str, 5) == 0 && isdigit( *(str+5))) + out( "cur_pos += %d;\n", *(str+5) - '0'); + + pr_text_with_conversions( str); + out( "fprint( outfile, \";\");"); +} + +pr_end() +{ + out( "fprint( outfile, \"}\\n\");"); +} + +pr_els() +{ + out( "fprint( outfile, \"else\\n\");"); +} + +pr_else() +{ + out( "fprint( outfile, \"else {\\n\");"); +} + +pr_question( quest) +char *quest; +{ + out( "fprint( outfile, \"if\");"); + pr_text_with_conversions( quest); + out( "fprint( outfile, \"{\\n\");"); +} + + +init_table() +{ + outfile = STDOUT; + out( "#include \"as.h\"\n"); + out( "#include \"as_parser.h\"\n"); +} + +clean() +{ + int i; + + if ( assem_instr != 0) { + free( assem_instr); + assem_instr = 0; + } + + for ( i = 0; i < n_ops; i++) { + free( op_info[i].name); + op_info[i].name = 0; + if ( op_info[i].type != 0) { + free( op_info[i].type); + op_info[i].type = 0; + } + } + n_ops = 0; +} + +operand_clean() + +/* Naam van de assembler-instr bewaren! */ + +{ + int i; + + for ( i = 0; i < n_ops; i++) { + free( op_info[i].name); + op_info[i].name = 0; + if ( op_info[i].type != 0) { + free( op_info[i].type); + op_info[i].type = 0; + } + } + n_ops = 0; +} + +out( fmt, argv) +char *fmt; +int argv; +{ + doprnt( outfile, fmt, &argv); +} + +error( fmt, argv) +char *fmt; +int argv; +{ + fprint( STDERR, "!! ERROR : "); + doprnt( STDERR, fmt, &argv); + fprint( STDERR, " !!\n"); +} + +inc_ops() +{ + n_ops++; +} + + +/**********************************/ + +char *mnemonic[ MAX_MNEMONICS]; +int n_mnems = 0; + +save_mnem( mnem) +char *mnem; +{ + if ( n_mnems == MAX_MNEMONICS) + error( "too many assembler instructions!! MAX_MNEMONICS = %d", + MAX_MNEMONICS); + else + mnemonic[ n_mnems++] = Salloc( mnem, strlen( mnem) + 1); +} + +end_table() + +/* array's wegschrijven !! */ + +{ + int i; + + quicksort( 0, n_mnems - 1); + + out( "char *mnemonic[] = {\n"); + for ( i = 0; i < n_mnems - 1; i++) + out( "\t\"%s\",\n", mnemonic[i]); + out( "\t\"%s\"};\n\n", mnemonic[ n_mnems-1]); + + out( "int (*instruction[])() = {\n"); + for ( i = 0; i < n_mnems - 1; i++) + out( "\t%s_instr,\n", mnemonic[i]); + out( "\t%s_instr};\n\n", mnemonic[ n_mnems-1]); + out( "int n_mnems = %d;\n", n_mnems); +} + +quicksort( lower, upper) +int lower, upper; + +/* Deze routine sorteert het array 'mnemonic' mbv. het algorithme quick_sort. + * ( zie diktaat "inleiding programmeren" voor een PASCAL versie.) + */ +{ + char *key, *tmp; + int index1, index2; + + if ( lower >= upper) + return; + + key = mnemonic[lower]; + index1 = lower; + index2 = upper+1; + + while ( index1 < index2) { + + do + index1++; + while (index1 <= upper && strcmp( mnemonic[index1], key) < 0 ); + + do + index2--; + while ( strcmp( mnemonic[index2], key) > 0); + + if ( index1 < index2) { + tmp = mnemonic[index2]; + mnemonic[index2] = mnemonic[index1]; + mnemonic[index1] = tmp; + } + } + + mnemonic[lower] = mnemonic[index2]; + mnemonic[index2] = key; + + quicksort( lower, index2-1); + quicksort( index2+1, upper); +} diff --git a/util/ceg/as_parser/pars.g b/util/ceg/as_parser/pars.g new file mode 100644 index 000000000..81f0ac778 --- /dev/null +++ b/util/ceg/as_parser/pars.g @@ -0,0 +1,157 @@ +{ + +#include "decl.h" +extern int yylineno, yyleng, yymorfg; +extern char yytext[]; + +} + +%token IDENTIFIER, CALL, CONDITION, IF, ELSIF, ELSE, FI, ARROW, MORE; +%start table, table; +%lexical lex_analyzer ; + + +table : { init_table();} + instruction* { end_table();} + ; + +instruction : { clean();} + first_row + [ { operand_clean();} + extra_row + ]* { pr_warning(); out( "}\n\n");} + ; + +first_row : mnemonic { save_instr( yytext, yyleng);} + [ decl_list]? + ARROW { pr_header(); pr_restriction();} + action_list + ; + +extra_row : MORE + [ decl_list]? + ARROW { out( "else "); pr_restriction();} + action_list + ; + +mnemonic : IDENTIFIER + ; + +decl_list : { clear_restriction();} + declaration + [ ',' declaration] *7 + ; + +declaration : IDENTIFIER { save_name( yytext, yyleng);} + [ ':' + IDENTIFIER { save_type( yytext, yyleng);} + ]? { inc_ops();} + ; + +action_list : { out( "{\n");} + [ action [ ';' action]* ]? '.' { out( "}\n");} + ; + +action : if_statement + | call + | subroutine + ; + +subroutine : IDENTIFIER { yymorfg=1;} + CONDITION { pr_subroutine( yytext);} + ; + +call : '@' + IDENTIFIER { yymorfg=1;} + CONDITION { pr_call( yytext);} + ; + +if_statement : IF + CONDITION { pr_question( yytext);} + action_list { pr_end();} + [ ELSIF { pr_els();} + CONDITION { pr_question( yytext);} + action_list { pr_end();} + ]* + [ ELSE { pr_else();} + action_list { pr_end();} + ]? + FI + ; + +{ + +static int saved = 0, token; + + +LLmessage( inserted_token) +int inserted_token; +{ + if ( inserted_token == 0) { + fprint( STDERR, "Sytax error in line %d, ", yylineno); + print_token( LLsymb); + fprint( STDERR, " will be deleted!!\n"); + } + else if ( inserted_token < 0) { + fprint( STDERR, "Stack overflow in line %d, fatal error!\n", + yylineno); + exit( 1); + } + else { + fprint( STDERR, "Sytax error in line %d, ", yylineno); + print_token( inserted_token); + fprint( STDERR, " will be inserted!!\n"); + token = LLsymb; + saved = 1; + } +} + +print_token( token) +int token; +{ + switch ( token) { + case IDENTIFIER : fprint( STDERR, "IDENTIFIER %s", yytext); + break; + case CALL : fprint( STDERR, "CALL %s", yytext); + break; + case CONDITION: fprint( STDERR, "CONDITION %s", yytext); + break; + case IF : fprint( STDERR, "@if "); + break; + case ELSIF : fprint( STDERR, "@elsif "); + break; + case ELSE : fprint( STDERR, "@else "); + break; + case FI : fprint( STDERR, "@fi "); + break; + case ARROW : fprint( STDERR, "==> "); + break; + case MORE : fprint( STDERR, "... "); + break; + default : fprint( STDERR, "%c ", token); + break; + } +} + +int lex_analyzer() +{ + int tok; + + if ( saved) { + saved = 0; + return( token); + } + else { + tok = yylex(); + yytext[yyleng] = '\0'; /* strings moeten op een '\0' eindigen */ + return( tok); + } +} + +main() +{ + table(); + return( 0); +} + +} diff --git a/util/ceg/as_parser/table.l b/util/ceg/as_parser/table.l new file mode 100644 index 000000000..9d072746d --- /dev/null +++ b/util/ceg/as_parser/table.l @@ -0,0 +1,52 @@ + +ws ([ \t\n]*) +arrow ("==>") +letter ([a-zA-Z_]) +digit ([0-9]) +identifier ({letter}({letter}|{digit})*) + +%start COM CAL CON + +%{ + +#include "Lpars.h" +#include "decl.h" +int special, n_haakjes; + +%} + + +%% + +"/*" BEGIN COM; +[^\n\*]*"*"+"/" BEGIN 0; +[^\n^\*]*"*"+ ; +[^\n\*]*"\n" ; + +";" return( ';'); +"." return( '.'); +"," return( ','); +":" return( ':'); +"@" return( '@'); +"@if"{ws} return( IF); +"@elsif"{ws} return( ELSIF); +"@else"{ws} return( ELSE); +"@fi"{ws} return( FI); +"..." return( MORE); +{arrow} return( ARROW); +{identifier} return( IDENTIFIER); + + +"(" { BEGIN CON; n_haakjes = 1; yymore();} +[^()]*"(" { n_haakjes++; yymore();} +[^()]*")" { if ( n_haakjes == 1) { + BEGIN 0; + return( CONDITION); + } + else { + n_haakjes--; + yymore(); + } + } + +{ws} ; diff --git a/util/ceg/assemble/as_assemble/assemble.c b/util/ceg/assemble/as_assemble/assemble.c new file mode 100644 index 000000000..1a7500fc4 --- /dev/null +++ b/util/ceg/assemble/as_assemble/assemble.c @@ -0,0 +1,51 @@ +#include +#include +#include "em_decl.h" +#include "as.h" + + +assemble( str) +char *str; +{ + char buf[512] , *b_ptr, *arg_format(); + int nr; + + b_ptr = buf; + + out( "fprint( codefile,\""); + + while ( *str) { + switch ( *str) { + case '$' : if ( *(str+1) == '$') { + *b_ptr++ = '$'; + str = str + 2; + } + else { + nr = atoi( str+1) - 1; + *b_ptr = '\0'; + out( "%s%s\", %s);", buf, + arg_format( nr), + C_instr_info->arg_conv[nr]); + out( "fprint( codefile,\""); + b_ptr = buf; + str = str + 2; + } + break; + default : *b_ptr++ = *str++; + } + } + + *b_ptr = '\0'; + out( "%s\\n\");\n", buf); +} + + +char *arg_format( nr) +int nr; +{ + switch ( C_instr_info->arg_type[nr]) { + case ARITH : return( ARITH_FMT); + case STRING: return( "%s"); + case INT : return( INT_FMT); + } +} diff --git a/util/ceg/assemble/as_assemble/block_as.c b/util/ceg/assemble/as_assemble/block_as.c new file mode 100644 index 000000000..2b93b4d36 --- /dev/null +++ b/util/ceg/assemble/as_assemble/block_as.c @@ -0,0 +1,9 @@ +block_assemble( instructions, nr, first, last) +char **instructions; +int nr, first, last; +{ + int i; + + for ( i=0; i +#include +#include "as.h" +#include "const.h" + +extern char *mnemonic[]; +extern int (*instruction[])(), n_mnems; +struct t_operand operand[ MAX_OPERANDS]; + +/* To change MAX_OPERANDS, the last statement in execute_mnem() must + * be changed. + */ + + +char *skip_space(), *parse_label(), *parse_mnemonic(), *parse_operand(), + *skip_string(), *match_ch(), *Salloc(), *skip_operand(); +int label(); + + +assemble( instr) + char *instr; + +/* INSTR ::= [ STRING ':']? [ STRING [ OPERAND ( ',' OPERAND)*]? ]? + * OPERAND ::= STRING [ '{' char* '}' | + * '(' char* ')' | + * '[' char* ']' ]? + * Break an assembly instruction down in a LABEL, MNEMONIC and OPERANDS. + */ +{ + char *ptr, *copy, *mnem; + int n_ops = 0; + + copy = ptr = Salloc( instr, strlen( instr)+1); + + ptr = skip_space( ptr); + if ( label( ptr)) { + ptr = parse_label( ptr); + if ( *ptr == '\0') return; + } + + ptr = parse_mnemonic( ptr, &mnem); + while ( *ptr != '\0') { + if ( n_ops++ == MAX_OPERANDS) + error( "to many operands\n"); + ptr = parse_operand( ptr, n_ops, instr); + } + + execute_mnemonic( mnem); + free( copy); +} + + +int label( ptr) + char *ptr; +{ + ptr = skip_string( ptr); + ptr = skip_space( ptr); + return( *ptr == ':'); +} + + +char *parse_label( ptr) + char *ptr; +{ + char *lab = ptr; + + ptr = skip_string( ptr); + if ( *ptr == ':') + *ptr++ = '\0'; + else { + *ptr++ = '\0'; + ptr = skip_space( ptr); + ptr++; /* skip ':' */ + } + handle_label( lab); + ptr = skip_space( ptr); + return( ptr); +} + + +char *parse_mnemonic( ptr, mnem) + char *ptr, **mnem; +{ + *mnem = ptr; + ptr = skip_string( ptr); + if ( *ptr != '\0') { + *ptr++ = '\0'; + ptr = skip_space( ptr); + } + return( ptr); +} + + +char *parse_operand( ptr, n_ops, instr) + char *ptr, *instr; + int n_ops; +{ + char *op = ptr; + + ptr = skip_operand( ptr, instr); + if ( *ptr != '\0') { + if ( *ptr == ',') + *ptr++ = '\0'; + else { + *ptr++ = '\0'; + ptr = skip_space( ptr); + if ( *ptr != '\0') ptr++; /* skip ';' */ + } + ptr = skip_space( ptr); + } + process_operand( op, &operand[ n_ops-1]); + return( ptr); +} + + +char *skip_operand( ptr, instr) + char *ptr, *instr; +{ + while ( *ptr != ',' && *ptr != '\0') { + switch ( *ptr) { + case '{' : ptr = match_ch( '}', ptr, instr); + break; + case '(' : ptr = match_ch( ')', ptr, instr); + break; + case '[' : ptr = match_ch( ']', ptr, instr); + break; + } + ptr++; + } + return( ptr); +} + + +char *match_ch( c, str, instr) + char c, *str, *instr; +{ + char *ptr, *strindex(); + + ptr = strindex( str, c); + if ( ptr == 0) { + error( "syntax error in %s : %c expected\n", instr, c); + return( str); + } + else + return( ptr); +} + + +char *skip_string( ptr) + char *ptr; +{ + while ( isalnum( *ptr) || ( *ptr == '_')) + ptr++; + return( ptr); +} + + +char *skip_space( ptr) +char *ptr; +{ + while ( isspace( *ptr) ) + ptr++; + return( ptr); +} + + +/****************************************************************************/ + + +execute_mnemonic( mnem) +char *mnem; + +/* Find the function by "mnem" and execute it. + */ +{ + int low, mid, high, rel; + + low = 0; + high = n_mnems-1; + + while ( TRUE) { + mid = ( low + high) / 2; + rel = strcmp(mnem, mnemonic[ mid]); + + if ( rel == 0 ) + break; + else if ( high == low) + error( "can't find %s", mnem); + else if ( rel < 0) + high = mid; + else + /* pas op, mid is naar beneden afgerond !! */ + low = ( mid == low ? low + 1: mid); + } + process_mnemonic( mnem); + ( *( instruction[ mid]))( &operand[0], &operand[1], &operand[2], + &operand[3]); +} + + +error( fmt, argv) +char *fmt; +int argv; +{ + extern int yylineno; + + fprint( STDERR, "!! ERROR in line %d : ", yylineno); + doprnt( STDERR, fmt, &argv); + fprint( STDERR, " !!\n"); +} diff --git a/util/ceg/assemble/obj_assemble/block_as.c b/util/ceg/assemble/obj_assemble/block_as.c new file mode 100644 index 000000000..2b93b4d36 --- /dev/null +++ b/util/ceg/assemble/obj_assemble/block_as.c @@ -0,0 +1,9 @@ +block_assemble( instructions, nr, first, last) +char **instructions; +int nr, first, last; +{ + int i; + + for ( i=0; i