many re-arrangements

modules/src/em_code/Makefile

@@ -1,9 +1,9 @@
 EMHOME = ../../..
 INSTALL = $(EMHOME)/modules/install
 COMPARE = $(EMHOME)/modules/compare
-INCORE = -DINCORE
 CFLAGS = -I$(EMHOME)/h -I$(EMHOME)/modules/h -O
-OBS = failed.o insert.o internerr.o io.o getid.o
+SRC = failed.c insert.c internerr.c getid.c
+OBS = failed.o insert.o internerr.o getid.o
 
 all:		libeme.a libemk.a em_code.3
 		rm -f C_*.c
@@ -22,11 +22,11 @@ em_code.3:	em_code.3X
 		-sh -c 'tbl < em_code.3X > em_code.3'
 		-sh -c 'if test -s em_code.3 ; then : ; else cp em_code.3X em_code.3 ; fi '
 
-libeme.a:	make.sh e/em_private.h e/em.c $(OBS)
+libeme.a:	make.sh e/em_private.h e/em.c $(OBS) io.c
 		EMHOME=$(EMHOME); export EMHOME; sh make.sh e
 		-sh -c 'ranlib libeme.a'
 
-libemk.a:	make.sh k/em_private.h k/em.c $(OBS)
+libemk.a:	make.sh k/em_private.h k/em.c $(OBS) io.c
 		EMHOME=$(EMHOME); export EMHOME; sh make.sh k
 		-sh -c 'ranlib libemk.a'
 
@@ -37,7 +37,7 @@ em.gen:		make.em.gen $(EMHOME)/etc/em_table
 		make.em.gen $(EMHOME)/etc/em_table > em.gen
 
 pr:
-		@pr Makefile make.em.gen make.fun em.nogen e/em_private.h e/em.c k/em_private.h k/em.c
+		@pr Makefile make.em.gen make.fun em.nogen insert.h $(SRC) e/em_private.h e/em.c k/em_private.h k/em.c
 
 opr:
 		make pr | opr
@@ -50,12 +50,9 @@ clean:
 		rm -f *.a em_code.3 em.gen make.sh
 
 lintlib:	make.sh
-		lint -I../../h -I../../../h -Ie -Ceme *.c e/*.c
+		lint -I. -I../../h -I../../../h -Ie -Ceme $(SRC) e/*.c
-		lint -I../../h -I../../../h -Ik -Cemk *.c k/*.c
+		lint -I. -I../../h -I../../../h -Ik -Cemk $(SRC) k/*.c
 		mv llib-leme.ln llib-lemk.ln $(EMHOME)/modules/lib
 
 insert.o:	insert.c insert.h
-		$(CC) $(CFLAGS) -c $(INCORE) insert.c
+		$(CC) $(CFLAGS) -c insert.c
-
-io.o:		io.c insert.h
-		$(CC) $(CFLAGS) -c $(INCORE) io.c

modules/src/em_code/e/em.c

@@ -5,7 +5,7 @@
  */
 /* EM CODE OUTPUT ROUTINES */
 
-#include <system.h>
+#include "io.c"
 #include "em_private.h"
 
 /*
@@ -26,7 +26,9 @@ static
 wrs(s)
 	register char *s;
 {
-	while (*s) C_putbyte(*s++);
+	while (*s) {
+		C_putbyte(*s++);
+	}
 }
 
 C_pt_dnam(s)
@@ -74,8 +76,9 @@ C_pt_scon(x, y)
 	C_putbyte('\'');
 	p = bts2str(x, (int) y, xbuf);
 	while (*p) {
-		if (*p == '\'')
+		if (*p == '\'') {
 			C_putbyte('\\');
+		}
 		C_putbyte(*p++);
 	}
 	C_putbyte('\'');
@@ -144,11 +147,13 @@ C_pt_wcon(sp, v, sz)	/* sp_icon, sp_ucon or sp_fcon with int repr	*/
 	char *v;
 	arith sz;
 {
+	int ch = sp == sp_icon ? 'I' : sp == sp_ucon ? 'U' : 'F';
+
 	wrs(v);
-	C_putbyte(sp == sp_icon ? 'I' : sp == sp_ucon ? 'U' : 'F');
+	C_putbyte(ch);
 	C_pt_cst(sz);
 }
 
 C_pt_nl() { C_putbyte('\n'); }
 C_pt_comma() { C_putbyte(','); }
-C_pt_ccend() { wrs(" ?"); }
+C_pt_ccend() { C_putbyte('?'); }

modules/src/em_code/em.nogen

@@ -24,38 +24,38 @@ C_ina_dlb	| label:l	| PS(ps_ina); DLB(l); NL()
 C_inp		| char *:s	| PS(ps_inp); PNAM(s); NL()
 
 C_bss_cst	| arith:n arith:w int:i	|
-	PS(ps_bss); DCST(n); COMMA(); CST(w); COMMA(); CST((arith) i); NL()
+	PS(ps_bss); CST(n); COMMA(); CST(w); COMMA(); CST((arith) i); NL()
 C_bss_icon	| arith:n char *:s arith:sz int:i	|
-	PS(ps_bss); DCST(n); COMMA(); WCON(sp_icon, s, sz); COMMA(); CST((arith) i); NL()
+	PS(ps_bss); CST(n); COMMA(); WCON(sp_icon, s, sz); COMMA(); CST((arith) i); NL()
 C_bss_ucon	| arith:n char *:s arith:sz int:i	|
-	PS(ps_bss); DCST(n); COMMA(); WCON(sp_ucon, s, sz); COMMA(); CST((arith) i); NL()
+	PS(ps_bss); CST(n); COMMA(); WCON(sp_ucon, s, sz); COMMA(); CST((arith) i); NL()
 C_bss_fcon	| arith:n char *:s arith:sz int:i	|
-	PS(ps_bss); DCST(n); COMMA(); WCON(sp_fcon, s, sz); COMMA(); CST((arith) i); NL()
+	PS(ps_bss); CST(n); COMMA(); WCON(sp_fcon, s, sz); COMMA(); CST((arith) i); NL()
 C_bss_dnam	| arith:n char *:s arith:offs int:i	|
-	PS(ps_bss); DCST(n); COMMA(); NOFF(s, offs); COMMA(); CST((arith) i); NL()
+	PS(ps_bss); CST(n); COMMA(); NOFF(s, offs); COMMA(); CST((arith) i); NL()
 C_bss_dlb	| arith:n label:l arith:offs int:i	|
-	PS(ps_bss); DCST(n); COMMA(); DOFF(l, offs); COMMA(); CST((arith) i); NL()
+	PS(ps_bss); CST(n); COMMA(); DOFF(l, offs); COMMA(); CST((arith) i); NL()
 C_bss_ilb	| arith:n label:l int:i			|
-	PS(ps_bss); DCST(n); COMMA(); ILB(l); COMMA(); CST((arith) i); NL()
+	PS(ps_bss); CST(n); COMMA(); ILB(l); COMMA(); CST((arith) i); NL()
 C_bss_pnam	| arith:n char *:s int:i		|
-	PS(ps_bss); DCST(n); COMMA(); PNAM(s); COMMA(); CST((arith) i); NL()
+	PS(ps_bss); CST(n); COMMA(); PNAM(s); COMMA(); CST((arith) i); NL()
 
 C_hol_cst	| arith:n arith:w int:i	|
-	PS(ps_hol); DCST(n); COMMA(); CST(w); COMMA(); CST((arith) i); NL()
+	PS(ps_hol); CST(n); COMMA(); CST(w); COMMA(); CST((arith) i); NL()
 C_hol_icon	| arith:n char *:s arith:sz int:i	|
-	PS(ps_hol); DCST(n); COMMA(); WCON(sp_icon, s, sz); COMMA(); CST((arith) i); NL()
+	PS(ps_hol); CST(n); COMMA(); WCON(sp_icon, s, sz); COMMA(); CST((arith) i); NL()
 C_hol_ucon	| arith:n char *:s arith:sz int:i	|
-	PS(ps_hol); DCST(n); COMMA(); WCON(sp_ucon, s, sz); COMMA(); CST((arith) i); NL()
+	PS(ps_hol); CST(n); COMMA(); WCON(sp_ucon, s, sz); COMMA(); CST((arith) i); NL()
 C_hol_fcon	| arith:n char *:s arith:sz int:i	|
-	PS(ps_hol); DCST(n); COMMA(); WCON(sp_fcon, s, sz); COMMA(); CST((arith) i); NL()
+	PS(ps_hol); CST(n); COMMA(); WCON(sp_fcon, s, sz); COMMA(); CST((arith) i); NL()
 C_hol_dnam	| arith:n char *:s arith:offs int:i	|
-	PS(ps_hol); DCST(n); COMMA(); NOFF(s, offs); COMMA(); CST((arith) i); NL()
+	PS(ps_hol); CST(n); COMMA(); NOFF(s, offs); COMMA(); CST((arith) i); NL()
 C_hol_dlb	| arith:n label:l arith:offs int:i	|
-	PS(ps_hol); DCST(n); COMMA(); DOFF(l, offs); COMMA(); CST((arith) i); NL()
+	PS(ps_hol); CST(n); COMMA(); DOFF(l, offs); COMMA(); CST((arith) i); NL()
 C_hol_ilb	| arith:n label:l int:i			|
-	PS(ps_hol); DCST(n); COMMA(); ILB(l); COMMA(); CST((arith) i); NL()
+	PS(ps_hol); CST(n); COMMA(); ILB(l); COMMA(); CST((arith) i); NL()
 C_hol_pnam	| arith:n char *:s int:i		|
-	PS(ps_hol); DCST(n); COMMA(); PNAM(s); COMMA(); CST((arith) i); NL()
+	PS(ps_hol); CST(n); COMMA(); PNAM(s); COMMA(); CST((arith) i); NL()
 
 C_con_cst	| arith:l		| PS(ps_con); CST(l); CEND(); NL()
 C_con_icon	| char *:val arith:siz	|

modules/src/em_code/em_code.3X

@@ -64,6 +64,8 @@ emcode \- EM code interface for compilers
 .B int id;
 .PP
 .B int C_getid()
+.PP
+.B char *C_tmpdir;
 .fi
 .SH DESCRIPTION
 This package provides a procedural EM code interface to be used in
@@ -419,11 +421,22 @@ The order in which the parts are defined is not significant.
 However, when
 .I C_close
 is called, all parts that have been inserted, must also be defined.
+Parts may themselves again have sub-parts.
 .PP
 The routine
 .I C_getid
 can be used to obtain a valid and unique part
 .IR id .
+.PP
+On implementations with limited memory, the mechanism is implemented with a
+temporary file.
+The directory in which this file resides is indicated by
+.IR C_tmpdir .
+The default is the #define TMP_DIR from ~em/h/em_path.h.
+The user can change this by just changing
+.I C_tmpdir
+before calling
+.IR C_open.
 .SH FILES
 .nf
 ~em/modules/h/em.h

modules/src/em_code/insert.c

@@ -12,11 +12,182 @@
 #include <alloc.h>
 #include "insert.h"
 
-#ifdef INCORE
+#ifndef INCORE
-#define		C_switchtotmp()		(C_ontmpfile = 1)
+static int
-#define		C_switchtoout()		(C_ontmpfile = 0)
+getbyte(b)
+	long b;
+{
+	/*	Get the byte at offset "b" from the start of the
+		temporary file, and try to do so in an efficient way.
+	*/
+	static long	start_core, curr_pos;
+
+	if (b < start_core || b >= curr_pos) {
+		/* the block wanted is not in core, so get it */
+		long nb = (b & ~(BUFSIZ - 1));
+		int n;
+
+		C_flush();
+		if (nb != curr_pos) {
+			if (sys_seek(tfr, nb, 0, &curr_pos) == 0) {
+				C_failed();
+			}
+		}
+		if (! ibuf) {
+			ibuf = Malloc(BUFSIZ);
+		}
+		if (sys_read(tfr, ibuf, BUFSIZ, &n) == 0) {
+			C_failed();
+		}
+		curr_pos += n;
+		start_core = nb;
+	}
+
+	return ibuf[(int) (b - start_core)];
+}
 #endif
 
+static C_out_parts();
+static Part *C_findpart();
+
+outpart(id)
+	int id;
+{
+	/*	Output part "id", if present.
+	*/
+	Part *p = C_findpart(id);
+
+	if (p) C_out_parts(p->p_parts);
+}
+
+static
+C_out_parts(pp)
+	register PartOfPart *pp;
+{
+	/*	Output the list of chunks started by "pp".
+		The list is build in reverse order, so this routine is
+		recursive.
+	*/
+	PartOfPart *prev = 0, *next;
+
+	while (pp) {
+		next = pp->pp_next;
+		pp->pp_next = prev;
+		prev = pp;
+		pp = next;
+	}
+	pp = prev;
+
+	while (pp) {
+		if (pp->pp_type == INSERT) {
+			C_outpart(pp->pp_id);
+		}
+		else {
+			/* copy the chunk to output */
+#ifdef INCORE
+			register char *s = C_BASE + pp->pp_begin;
+			char *se = C_BASE + pp->pp_end;
+
+			while (s < se) {
+				put(*s++);
+			}
+#else
+			register long b = pp->pp_begin;
+
+			while (b < pp->pp_end) {
+				put(getbyte(b++));
+			}
+#endif
+		}
+		pp = pp->pp_next;
+	}
+}
+
+static Part *
+C_findpart(part)
+	int part;
+{
+	/*	Look for part "part" in the table.
+		Return 0 if not present,
+	*/
+	register Part *p = C_stable[part % TABSIZ];
+
+	while (p && p->p_id != part) {
+		p = p->p_next;
+	}
+	return p;
+}
+
+static
+switchtotmp()
+{
+#ifndef INCORE
+	if (C_tmpfile == 0) {
+		static char tmpbuf[64];
+		register char *p = tmpbuf;
+
+		strcpy(p, C_tmpdir);
+		strcat(p, "/CodeXXXXXX");
+		tmpfile = mktemp(p);
+		if (! sys_open(p, OP_WRITE, &C_old_ofp)) {
+			C_failed();
+		}
+		if (! sys_open(p, OP_READ, &C_tfr)) {
+			C_failed();
+		}
+	}
+	if (! C_ontmpfile) {
+		File *p = C_ofp;
+
+		C_flush();
+		C_ofp = C_old_ofp;
+		C_old_ofp = p;
+		C_ontmpfile = 1;
+	}
+#else
+	if (! C_ontmpfile) {
+		char *p;
+
+		p = C_opp;
+		C_opp = C_old_opp;
+		C_old_opp = p;
+
+		p = C_top;
+		C_top = C_old_top;
+		C_old_top = p;
+		C_ontmpfile = 1;
+	}
+#endif
+}
+
+static
+switchtoout()
+{
+#ifndef INCORE
+	if (C_ontmpfile) {
+		File *p = C_ofp;
+
+		C_flush();
+		C_ofp = C_old_ofp;
+		C_old_ofp = p;
+		C_ontmpfile = 0;
+	}
+#else
+	if (C_ontmpfile) {
+		char *p;
+
+		p = C_opp;
+		C_opp = C_old_opp;
+		C_old_opp = p;
+
+		p = C_top;
+		C_top = C_old_top;
+		C_old_top = p;
+		C_ontmpfile = 0;
+	}
+#endif
+}
+
 static int
 available(part)
 	int part;
@@ -88,7 +259,7 @@ end_partofpart(p)
 	if (p) {
 		register PartOfPart *pp = p->p_parts;
 
-		pp->pp_end = C_current_out;
+		pp->pp_end = C_current_out - C_BASE;
 		if (pp->pp_begin == pp->pp_end) {
 			/* nothing in this chunk, so give it back */
 			p->p_parts = pp->pp_next;
@@ -106,12 +277,12 @@ resume(p)
 	*/
 	register PartOfPart *pp = (PartOfPart *) Malloc(sizeof(PartOfPart));
 
-	C_switchtotmp();
+	switchtotmp();
 	C_curr_part = p;
 	pp->pp_next = p->p_parts;
 	p->p_parts = pp;
 	pp->pp_type = TEXT;
-	pp->pp_begin = C_current_out;
+	pp->pp_begin = C_current_out - C_BASE;
 }
 
 C_insertpart(part)
@@ -124,6 +295,9 @@ C_insertpart(part)
 	register Part *p;
 	register PartOfPart *pp;
 
+	C_outpart = outpart;
+	C_switchtotmp = switchtotmp;
+	C_switchtoout = switchtoout;
 	if (C_sequential && available(part)) {
 		outpart(part);
 		return;
@@ -158,6 +332,10 @@ C_beginpart(part)
 	*/
 	register Part *p = mkpart(part);
 
+	C_outpart = outpart;
+	C_switchtotmp = switchtotmp;
+	C_switchtoout = switchtoout;
+
 	end_partofpart(C_curr_part);
 
 	p->p_prevpart = C_curr_part;
@@ -181,6 +359,6 @@ C_endpart(part)
 	if (p->p_prevpart) resume(p->p_prevpart);
 	else {
 		C_curr_part = 0;
-		C_switchtoout();
+		switchtoout();
 	}
 }

modules/src/em_code/insert.h

@@ -4,6 +4,10 @@
    end-pointer.
 */
 
+#include <system.h>
+
+#define INCORE	/* mechanism implemented incore */
+
 typedef struct partofpart {
 	struct partofpart	*pp_next;
 	char			pp_type;
@@ -29,15 +33,34 @@ typedef struct part {
 	int		p_id;		/* id of this part */
 } Part;
 
-#define		outpart(xxx)		C_out_parts(C_findpart(xxx)->p_parts)
-
 #define TABSIZ	32
 
 extern int
 	C_ontmpfile, C_sequential;
 extern Part
 	*C_curr_part, *C_stable[];
+#ifdef INCORE
+extern char
+	*C_current_out, *C_BASE;
+#define C_opp C_current_out
+#else
 extern long
 	C_current_out;
-extern Part
+extern char	*C_opp;
-	*C_findpart();
+#define C_BASE 0
+#endif
+extern int (*C_outpart)(), (*C_switchtoout)(), (*C_switchtotmp)();
+
+extern File	*C_ofp;
+
+#ifndef INCORE
+extern File	*C_tfr, *C_old_ofp;
+extern char	*C_tmpfile;
+#endif
+
+extern char	*C_top;
+extern char	*C_old_top;
+extern char	*C_old_opp;
+
+#define put(c)	if (C_opp == C_top) C_flush(); *C_opp++ = (c)
+

modules/src/em_code/io.c

@@ -3,108 +3,85 @@
 /*	I/O part of em_code module.
 	Also contains C_open, C_close
 */
-#include <system.h>
 #include <alloc.h>
 #include <em_path.h>
 #include <em_arith.h>
+#include <local.h>
 #include "insert.h"
 
-int
+int		C_ontmpfile = 0;
-	C_ontmpfile = 0,
+int		C_sequential = 1;
-	C_sequential = 1;
+Part		*C_curr_part;
-Part
+Part		*C_stable[TABSIZ];
-	*C_curr_part, *C_stable[TABSIZ];
+char		*C_tmpdir = TMP_DIR;
-long
+int		(*C_outpart)(), (*C_switchtoout)(), (*C_switchtotmp)();
-	C_current_out;
 
 #ifdef INCORE
-static char	*BASE;
+char		*C_BASE;
 #endif
-static File	*ofp;
+
+File		*C_ofp;
 
 #ifndef INCORE
-static File	*tfr, *old_ofp;
+File		*C_tfr, *C_old_ofp;
-static char	*tmpfile;
+char		*C_tmpfile;
 char		*strcpy(), *strcat(), *mktemp();
 static char	*ibuf = 0;
+long		C_current_out;
 #endif
 
-static char	obuf[BUFSIZ];
+#if BUFSIZ <= 1024 && BIGMACHINE
-static char	*opp = obuf;
+#define BUFFERSIZ	8*BUFSIZ
+#else
+#define BUFFERSIZ	BUFSIZ
+#endif
 
-static
+static char	obuf[BUFFERSIZ];
-flush() {
+char		*C_top = &obuf[BUFFERSIZ];
-	if (opp != obuf && sys_write(ofp, obuf, opp - obuf) == 0) {
+char		*C_old_top;
+char		*C_old_opp;
+#ifdef INCORE
+char		*C_current_out = obuf;
+#endif
+
+C_flush() {
+#ifdef INCORE
+	static unsigned int bufsiz;
+
+	if (C_ontmpfile) {
+		if (C_BASE == 0) {
+			C_BASE = Malloc(BUFFERSIZ);
+			bufsiz = BUFFERSIZ;
+			C_current_out = C_BASE;
+		}
+		else {
+			C_BASE = Srealloc(C_BASE, (bufsiz << 1));
+			C_current_out = C_BASE + bufsiz;
+			bufsiz <<= 1;
+		}
+		C_top = C_BASE + bufsiz;
+		return;
+	}
+#endif
+	if (C_opp != obuf && sys_write(C_ofp, obuf, C_opp - obuf) == 0) {
 		C_failed();
 	}
-	opp = obuf;
+	C_opp = obuf;
 }
 
-#define put(c)	if (opp == &obuf[BUFSIZ]) flush(); *opp++ = (c)
+#ifndef INCORE
+#define Xputbyte(c) if (C_ontmpfile) C_current_out++; put(c)
+#else
+#define Xputbyte(c) put(c)
+#endif
 
 C_putbyte(c)
 	int c;
 {
-	if (C_ontmpfile) {
+	Xputbyte(c);
-#ifdef INCORE
-		static unsigned sz;
-
-		if (BASE == 0) {
-			BASE = Malloc(BUFSIZ);
-			sz = BUFSIZ;
-		}
-		else if (C_current_out >= sz) {
-			BASE = Srealloc(BASE, (sz <<= 1));
-		}
-		*(BASE + C_current_out) = c;
-#endif
-		C_current_out++;
-#ifdef INCORE
-		return;
-#endif
-	}
-	put(c);
 }
 
-#ifndef INCORE
+#define C_putbyte Xputbyte
-C_switchtotmp()
-{
-	if (tmpfile == 0) {
-		static char tmpbuf[64];
-		register char *p = tmpbuf;
-
-		strcpy(p, TMP_DIR);
-		strcat(p, "/CodeXXXXXX");
-		tmpfile = mktemp(p);
-		if (! sys_open(p, OP_WRITE, &old_ofp)) {
-			C_failed();
-		}
-		if (! sys_open(p, OP_READ, &tfr)) {
-			C_failed();
-		}
-	}
-	if (! C_ontmpfile) {
-		File *p = ofp;
-
-		flush();
-		ofp = old_ofp;
-		old_ofp = p;
-		C_ontmpfile = 1;
-	}
-}
-
-C_switchtoout()
-{
-	if (C_ontmpfile) {
-		File *p = ofp;
-
-		flush();
-		ofp = old_ofp;
-		old_ofp = p;
-		C_ontmpfile = 0;
-	}
-}
-#endif
 
 C_init(w, p)
 	arith w, p;
@@ -118,9 +95,9 @@ C_open(nm)
 	*/
 
 	if (nm == 0)
-		ofp = STDOUT;	/* standard output	*/
+		C_ofp = STDOUT;	/* standard output	*/
 	else
-	if (sys_open(nm, OP_WRITE, &ofp) == 0)
+	if (sys_open(nm, OP_WRITE, &C_ofp) == 0)
 		return 0;
 	return 1;
 }
@@ -131,119 +108,35 @@ C_close()
 	*/
 
 #ifndef INCORE
-	flush();
+	C_flush();
 	if (tmpfile) {
-		C_switchtotmp();
+		(*C_switchtotmp)();
-		sys_close(ofp);
+		sys_close(C_ofp);
-		ofp = old_ofp;
 #else
-	if (BASE) {
+	if (C_BASE) {
 #endif
 		if (C_curr_part) {
-			C_curr_part->p_parts->pp_end = C_current_out;
+			C_curr_part->p_parts->pp_end = C_current_out - C_BASE;
 		}
+		(*C_switchtoout)();
 		if (! C_sequential) {
-			outpart(0);
+			(*C_outpart)(0);
 		}
 #ifndef INCORE
-		sys_close(tfr);
+		sys_close(C_tfr);
 		sys_remove(tmpfile);
 		if (ibuf) free(ibuf);
 #else
-		free(BASE);
+		free(C_BASE);
 #endif
 	}
-	flush();
+	C_flush();
-	if (ofp != STDOUT)
+	if (C_ofp != STDOUT)
-		sys_close(ofp);
+		sys_close(C_ofp);
-	ofp = 0;
+	C_ofp = 0;
 }
 
 C_busy()
 {
-	return ofp != 0; /* true if code is being generated */
+	return C_ofp != 0; /* true if code is being generated */
 }
-
-#ifndef INCORE
-static int
-getbyte(b)
-	long b;
-{
-	/*	Get the byte at offset "b" from the start of the
-		temporary file, and try to do so in an efficient way.
-	*/
-	static long	start_core, curr_pos;
-
-	if (b < start_core || b >= curr_pos) {
-		/* the block wanted is not in core, so get it */
-		long nb = (b & ~(BUFSIZ - 1));
-		int n;
-
-		flush();
-		if (nb != curr_pos) {
-			if (sys_seek(tfr, nb, 0, &curr_pos) == 0) {
-				C_failed();
-			}
-		}
-		if (! ibuf) {
-			ibuf = Malloc(BUFSIZ);
-		}
-		if (sys_read(tfr, ibuf, BUFSIZ, &n) == 0) {
-			C_failed();
-		}
-		curr_pos += n;
-		start_core = nb;
-	}
-
-	return ibuf[(int) (b - start_core)];
-}
-#endif
-
-C_out_parts(pp)
-	register PartOfPart *pp;
-{
-	/*	Output the list of chunks started by "pp".
-		The list is build in reverse order, so this routine is
-		recursive.
-	*/
-
-	if (!pp) return;
-	if (pp->pp_next) C_out_parts(pp->pp_next);
-
-	if (pp->pp_type == INSERT) {
-		outpart(pp->pp_id);
-	}
-	else {
-		/* copy the chunk to output */
-#ifdef INCORE
-		register char *s = BASE + pp->pp_begin;
-		char *se = BASE + pp->pp_end;
-
-		while (s < se) {
-			put(*s++);
-		}
-#else
-		register long b = pp->pp_begin;
-
-		while (b < pp->pp_end) {
-			put(getbyte(b++));
-		}
-#endif
-	}
-}
-
-Part *
-C_findpart(part)
-	int part;
-{
-	/*	Look for part "part" in the table.
-		Return 0 if not present,
-	*/
-	register Part *p = C_stable[part % TABSIZ];
-
-	while (p && p->p_id != part) {
-		p = p->p_next;
-	}
-	return p;
-}
-

modules/src/em_code/k/em.c

@@ -5,7 +5,7 @@
 /* $Header$ */
 /* EM CODE OUTPUT ROUTINES */
 
-#include <system.h>
+#include "io.c"
 #include "em_private.h"
 
 #define	put8(x)		C_putbyte(x)

modules/src/em_code/make.em.gen

@@ -3,7 +3,7 @@ ed - $1 <<'EOI'
 1,/^$/d
 1,/^$/d
 1,$s/^\(...\)	\(.\).*/\1:\2/
-g/:d/s/^\(...\):\(.\).*/C_\1	| arith:\2	| OP(op_\1); DCST(\2); NL()/
+g/:d/s/^\(...\):\(.\).*/C_\1	| arith:\2	| OP(op_\1); CST(\2); NL()/
 g/:[cslnfzor]/s/^\(...\):\(.\).*/C_\1	| arith:\2	| OP(op_\1); CST(\2); NL()/
 g/:w/s/^\(...\).*/C_\1	| arith:w	| OP(op_\1); CST(w); NL()\
 C_\1_narg	| 	| OP(op_\1); CCEND(); NL()/

modules/src/em_code/make.fun

@@ -41,9 +41,9 @@ rm -f C_*.o
 .
 $a
 rm -f libem$1.a
-cc -c -O -I$1 -I$EMHOME/modules/h -I$EMHOME/h $1/em.c
+cc -c -O -I. -I$1 -I$EMHOME/modules/h -I$EMHOME/h $1/em.c
 mv em.o em$1.o
-ar rc libem$1.a C_*.o em$1.o insert.o io.o failed.o internerr.o getid.o
+ar rc libem$1.a C_*.o em$1.o insert.o failed.o internerr.o getid.o
 rm -f C_*.o
 --EOF--
 .