diff --git a/lang/cem/cemcom.ansi/BigPars b/lang/cem/cemcom.ansi/BigPars
index 6f4b0971d..bf92e22fe 100644
--- a/lang/cem/cemcom.ansi/BigPars
+++ b/lang/cem/cemcom.ansi/BigPars
@@ -1,138 +1,138 @@
-!File: lint.h
-/*#define	LINT		1	/* if defined, 'lint' is produced	*/
-
-
-!File: pathlength.h
-#define PATHLENGTH	1024	/* max. length of path to file		*/
-
-
-!File: errout.h
-#define	ERROUT		STDERR	/* file pointer for writing messages	*/
-#define	ERR_SHADOW	5	/* a syntax error overshadows error messages
-					until ERR_SHADOW symbols have been
-					accepted without syntax error */
-
-
-!File: idfsize.h
-#define	IDFSIZE	64	/* maximum significant length of an identifier	*/
-
-
-!File: numsize.h
-#define	NUMSIZE	256	/* maximum length of a numeric constant		*/
-
-
-!File: nparams.h
-#define	NPARAMS 32	/* maximum number of parameters 		*/
-#define	STDC_NPARAMS 31	/* ANSI limit on number of parameters		*/
-
-
-!File: ifdepth.h
-#define	IFDEPTH	256	/* maximum number of nested if-constructions	*/
-
-
-!File: density.h
-#define	DENSITY	3	/* see switch.[ch] for an explanation		*/
-
-
-!File: macbuf.h
-#define	LAPBUF	128	/* initial size of macro replacement buffer	*/
-#define ARGBUF	128	/* initial size of macro parameter buffer(s)	*/
-
-
-!File: strsize.h
-#define ISTRSIZE	32	/* minimum number of bytes allocated for
-					storing a string		*/
-#define RSTRSIZE	16	/* step size in enlarging the memory for
-					the storage of a string		*/
-
-
-!File: trgt_sizes.h
-#define MAXSIZE		8	/* the maximum of the SZ_* constants	*/
-
-/* target machine sizes	*/
-#define	SZ_CHAR		1
-#define	SZ_SHORT	2
-#define SZ_WORD		4
-#define	SZ_INT		4
-#define	SZ_LONG		4
-#define	SZ_FLOAT	4
-#define	SZ_DOUBLE	8
-#define	SZ_LNGDBL	8	/* for now */
-#define	SZ_POINTER	4
-
-/* target machine alignment requirements	*/
-#define	AL_CHAR		1
-#define	AL_SHORT	SZ_SHORT
-#define AL_WORD		SZ_WORD
-#define	AL_INT		SZ_WORD
-#define	AL_LONG		SZ_WORD
-#define	AL_FLOAT	SZ_WORD
-#define	AL_DOUBLE	SZ_WORD
-#define	AL_LNGDBL	SZ_WORD
-#define	AL_POINTER	SZ_WORD
-#define AL_STRUCT	1
-#define AL_UNION	1
-
-
-!File: botch_free.h
-/*#define BOTCH_FREE	1	/* when defined, botch freed memory, as a check	*/
-
-
-!File: dataflow.h
-#define DATAFLOW	1	/* produce some compile-time xref	*/
-
-
-!File: debug.h
-/*#define DEBUG		1	/* perform various self-tests		*/
-#define NDEBUG		1	/* disable assertions			*/
-
-
-!File: use_tmp.h
-#define PREPEND_SCOPES	1	/* collect exa, exp, ina and inp commands
-					and if USE_TMP is defined let them
-					precede the rest of the generated
-					compact code	*/
-#define USE_TMP		1	/* use C_insertpart, C_endpart mechanism
-					to generate EM-code in the order needed
-					for the code-generators. If not defined,
-					the old-style peephole optimizer is
-					needed.	*/
-
-
-!File: parbufsize.h
-#define PARBUFSIZE	1024
-
-
-!File: textsize.h
-#define ITEXTSIZE	32	/* 1st piece of memory for repl. text	*/
-
-
-!File: inputtype.h
-#define INP_READ_IN_ONE	1	/* read input file in one	*/
-
-
-!File: nobitfield.h
-/*#define NOBITFIELD	1	/* if NOT defined, implement bitfields	*/
-
-
-!File: spec_arith.h
-/* describes internal compiler arithmetics */
-#undef	SPECIAL_ARITHMETICS	/* something different from native long */
-
-
-!File: static.h
-#define GSTATIC			/* for large global "static" arrays */
-
-
-!File: nocross.h
-/*#define NOCROSS		1	/* if NOT defined, cross compiler */
-
-
-!File: regcount.h
-/*#define REGCOUNT		1	/* count occurrences for register messages */
-
-
-!File: dbsymtab.h
-#define DBSYMTAB	1	/* ability to produce symbol table for debugger */
-
-
+!File: lint.h
+/*#define	LINT		1	*//* if defined, 'lint' is produced	*/
+
+
+!File: pathlength.h
+#define PATHLENGTH	1024	/* max. length of path to file		*/
+
+
+!File: errout.h
+#define	ERROUT		STDERR	/* file pointer for writing messages	*/
+#define	ERR_SHADOW	5	/* a syntax error overshadows error messages
+					until ERR_SHADOW symbols have been
+					accepted without syntax error */
+
+
+!File: idfsize.h
+#define	IDFSIZE	64	/* maximum significant length of an identifier	*/
+
+
+!File: numsize.h
+#define	NUMSIZE	256	/* maximum length of a numeric constant		*/
+
+
+!File: nparams.h
+#define	NPARAMS 32	/* maximum number of parameters 		*/
+#define	STDC_NPARAMS 31	/* ANSI limit on number of parameters		*/
+
+
+!File: ifdepth.h
+#define	IFDEPTH	256	/* maximum number of nested if-constructions	*/
+
+
+!File: density.h
+#define	DENSITY	3	/* see switch.[ch] for an explanation		*/
+
+
+!File: macbuf.h
+#define	LAPBUF	128	/* initial size of macro replacement buffer	*/
+#define ARGBUF	128	/* initial size of macro parameter buffer(s)	*/
+
+
+!File: strsize.h
+#define ISTRSIZE	32	/* minimum number of bytes allocated for
+					storing a string		*/
+#define RSTRSIZE	16	/* step size in enlarging the memory for
+					the storage of a string		*/
+
+
+!File: trgt_sizes.h
+#define MAXSIZE		8	/* the maximum of the SZ_* constants	*/
+
+/* target machine sizes	*/
+#define	SZ_CHAR		1
+#define	SZ_SHORT	2
+#define SZ_WORD		4
+#define	SZ_INT		4
+#define	SZ_LONG		4
+#define	SZ_FLOAT	4
+#define	SZ_DOUBLE	8
+#define	SZ_LNGDBL	8	/* for now */
+#define	SZ_POINTER	4
+
+/* target machine alignment requirements	*/
+#define	AL_CHAR		1
+#define	AL_SHORT	SZ_SHORT
+#define AL_WORD		SZ_WORD
+#define	AL_INT		SZ_WORD
+#define	AL_LONG		SZ_WORD
+#define	AL_FLOAT	SZ_WORD
+#define	AL_DOUBLE	SZ_WORD
+#define	AL_LNGDBL	SZ_WORD
+#define	AL_POINTER	SZ_WORD
+#define AL_STRUCT	1
+#define AL_UNION	1
+
+
+!File: botch_free.h
+/*#define BOTCH_FREE	1*	*//* when defined, botch freed memory, as a check	*/
+
+
+!File: dataflow.h
+#define DATAFLOW	1	/* produce some compile-time xref	*/
+
+
+!File: debug.h
+/*#define DEBUG		1	*//* perform various self-tests		*/
+#define NDEBUG		1	/* disable assertions			*/
+
+
+!File: use_tmp.h
+#define PREPEND_SCOPES	1	/* collect exa, exp, ina and inp commands
+					and if USE_TMP is defined let them
+					precede the rest of the generated
+					compact code	*/
+#define USE_TMP		1	/* use C_insertpart, C_endpart mechanism
+					to generate EM-code in the order needed
+					for the code-generators. If not defined,
+					the old-style peephole optimizer is
+					needed.	*/
+
+
+!File: parbufsize.h
+#define PARBUFSIZE	1024
+
+
+!File: textsize.h
+#define ITEXTSIZE	32	/* 1st piece of memory for repl. text	*/
+
+
+!File: inputtype.h
+#define INP_READ_IN_ONE	1	/* read input file in one	*/
+
+
+!File: nobitfield.h
+/*#define NOBITFIELD	1	*//* if NOT defined, implement bitfields	*/
+
+
+!File: spec_arith.h
+/* describes internal compiler arithmetics */
+#undef	SPECIAL_ARITHMETICS	/* something different from native long */
+
+
+!File: static.h
+#define GSTATIC			/* for large global "static" arrays */
+
+
+!File: nocross.h
+/*#define NOCROSS		1	*//* if NOT defined, cross compiler */
+
+
+!File: regcount.h
+/*#define REGCOUNT		1	*//* count occurrences for register messages */
+
+
+!File: dbsymtab.h
+#define DBSYMTAB	1	/* ability to produce symbol table for debugger */
+
+
diff --git a/lang/cem/cemcom.ansi/CMakeLists.txt b/lang/cem/cemcom.ansi/CMakeLists.txt
new file mode 100644
index 000000000..3777b042e
--- /dev/null
+++ b/lang/cem/cemcom.ansi/CMakeLists.txt
@@ -0,0 +1,318 @@
+cmake_minimum_required (VERSION 3.0)
+project(em_cemcom.ansi)
+
+
+##################################
+# Location of built scripts.
+##################################
+set(PROJECT_SCRIPTS_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../../../util/scripts)
+
+set(SRC_C
+	align.h
+	arith.c
+	arith.h
+	atw.h
+	blocks.c
+	blocks.h
+	ch3.c
+	ch3.h
+	ch3bin.c
+	ch3bin.h
+	ch3mon.c
+	ch3mon.h
+	class.h
+	code.c
+	conversion.c
+	conversion.h
+	cstoper.c
+	cstoper.h
+	dataflow.c
+	dataflow.h
+	declarator.c
+	declarator.h
+	decspecs.c
+	decspecs.h
+	domacro.c
+	domacro.h
+	dumpidf.c
+	error.c
+	error.h
+	eval.c
+	eval.h
+	expr.c
+	field.c
+	file_info.h
+	fltcstoper.c
+	fltcstoper.h
+	idf.c
+	input.c
+	input.h
+	interface.h
+	idf.c
+	input.c
+	input.h
+	l_class.h
+	l_comment.c
+	l_comment.h
+	l_em.h
+	l_ev_ord.c
+	l_lint.c
+	l_lint.h
+	l_misc.c
+	l_outdef.c
+	l_states.c
+	label.c
+	label.h
+	level.h
+	LLlex.c
+	LLlex.h
+	LLmessage.c
+	main.c
+	mes.h
+	options.c
+	options.h
+	pragma.c
+	pragma.h
+	proto.c
+	sizes.h
+	skip.c
+	skip.h
+	specials.h
+	stab.c
+	stab.h
+	stack.c
+	stb.c
+	struct.c
+	switch.c
+	tokenname.c
+	tokenname.h
+	type.c
+	util.c
+)
+
+set(INCLUDE_DIRS
+ .
+ ${CMAKE_CURRENT_BINARY_DIR}
+ ${CMAKE_CURRENT_SOURCE_DIR}/../include
+ ${CMAKE_CURRENT_SOURCE_DIR}/../../../modules/src/idf
+ ${CMAKE_CURRENT_SOURCE_DIR}/../../../modules/src/input
+)
+
+############################################
+# LLgen inputs
+############################################
+
+set(GEN_G
+	${CMAKE_CURRENT_BINARY_DIR}/tokenfile.g
+)
+
+
+
+set(SRC_G
+ ${CMAKE_CURRENT_SOURCE_DIR}/program.g
+ ${CMAKE_CURRENT_SOURCE_DIR}/declar.g
+ ${CMAKE_CURRENT_SOURCE_DIR}/expression.g
+ ${CMAKE_CURRENT_SOURCE_DIR}/statement.g
+ ${CMAKE_CURRENT_SOURCE_DIR}/ival.g
+)
+
+
+############################################
+# LLgen outputs
+############################################
+
+set(GEN_SRC 
+ ${CMAKE_CURRENT_BINARY_DIR}/program.c 
+ ${CMAKE_CURRENT_BINARY_DIR}/declar.c 
+ ${CMAKE_CURRENT_BINARY_DIR}/expression.c 
+ ${CMAKE_CURRENT_BINARY_DIR}/statement.c
+ ${CMAKE_CURRENT_BINARY_DIR}/ival.c
+ ${CMAKE_CURRENT_BINARY_DIR}/tokenfile.c
+ ${CMAKE_CURRENT_BINARY_DIR}/Lpars.c
+ ${CMAKE_CURRENT_BINARY_DIR}/Lpars.h
+ ${CMAKE_CURRENT_BINARY_DIR}/Lncor.c
+)
+
+
+
+
+
+
+set(GFILES
+ ${GEN_G}
+ ${SRC_G}
+)
+
+
+
+############################################
+# Configuration parameters generated files
+############################################
+
+set(GEN_H_CONFIG
+	${CMAKE_CURRENT_BINARY_DIR}/parameters.h
+)
+
+set(GEN_OTHERS
+	${CMAKE_CURRENT_BINARY_DIR}/code.h
+	${CMAKE_CURRENT_BINARY_DIR}/declar.h
+	${CMAKE_CURRENT_BINARY_DIR}/def.h	
+	${CMAKE_CURRENT_BINARY_DIR}/expr.h
+	${CMAKE_CURRENT_BINARY_DIR}/field.h
+	${CMAKE_CURRENT_BINARY_DIR}/estack.h
+	${CMAKE_CURRENT_BINARY_DIR}/util.h
+	${CMAKE_CURRENT_BINARY_DIR}/proto.h
+	${CMAKE_CURRENT_BINARY_DIR}/replace.h
+	${CMAKE_CURRENT_BINARY_DIR}/idf.h
+	${CMAKE_CURRENT_BINARY_DIR}/macro.h
+	${CMAKE_CURRENT_BINARY_DIR}/stack.h
+	${CMAKE_CURRENT_BINARY_DIR}/stmt.h
+	${CMAKE_CURRENT_BINARY_DIR}/struct.h
+	${CMAKE_CURRENT_BINARY_DIR}/switch.h
+	${CMAKE_CURRENT_BINARY_DIR}/type.h
+	${CMAKE_CURRENT_BINARY_DIR}/l_brace.h
+	${CMAKE_CURRENT_BINARY_DIR}/l_state.h
+	${CMAKE_CURRENT_BINARY_DIR}/l_outdef.h
+	${CMAKE_CURRENT_BINARY_DIR}/next.c
+)
+
+
+
+
+
+
+set(CFILES
+	${SRC_C}
+	${GEN_SRC}
+	${GEN_H_CONFIG}
+	${GEN_OTHERS}
+	symbol2str.c
+	char.c
+)
+
+set(LLGENOPTIONS
+ -n
+)
+
+###############################################
+# Generate the compile time configuration file 
+###############################################
+add_custom_command(
+    OUTPUT ${GEN_H_CONFIG} BigPars mkparams.sed
+    COMMAND ${CMAKE_COMMAND} -E copy
+                ${PROJECT_SCRIPTS_SOURCE_DIR}/mkparams.sed
+                ${CMAKE_CURRENT_BINARY_DIR}/mkparams.sed
+    COMMAND ${CMAKE_COMMAND} -E copy
+                ${CMAKE_CURRENT_SOURCE_DIR}/BigPars
+                ${CMAKE_CURRENT_BINARY_DIR}/BigPars                      
+    COMMAND sed -f ${PROJECT_SCRIPTS_SOURCE_DIR}/mkparams.sed ${CMAKE_CURRENT_BINARY_DIR}/BigPars>parameters.h
+    DEPENDS BigPars)
+    
+###############################################
+# Generate other source files
+###############################################     
+
+
+add_custom_command(
+    OUTPUT ${GEN_OTHERS} mkalloc1.sed mkalloc2.sed mknext.sed
+    COMMAND ${CMAKE_COMMAND} -E copy
+                ${PROJECT_SCRIPTS_SOURCE_DIR}/mkalloc1.sed
+                ${CMAKE_CURRENT_BINARY_DIR}/mkalloc1.sed
+    COMMAND ${CMAKE_COMMAND} -E copy
+                ${PROJECT_SCRIPTS_SOURCE_DIR}/mkalloc2.sed
+                ${CMAKE_CURRENT_BINARY_DIR}/mkalloc2.sed
+    COMMAND ${CMAKE_COMMAND} -E copy
+                ${PROJECT_SCRIPTS_SOURCE_DIR}/mknext.sed
+                ${CMAKE_CURRENT_BINARY_DIR}/mknext.sed   
+                
+
+                
+                                                    
+    COMMAND sed -f ${CMAKE_CURRENT_BINARY_DIR}/mkalloc1.sed -f ${CMAKE_CURRENT_BINARY_DIR}/mkalloc2.sed ${CMAKE_CURRENT_SOURCE_DIR}/code.str>code.h
+    COMMAND sed -f ${CMAKE_CURRENT_BINARY_DIR}/mkalloc1.sed -f ${CMAKE_CURRENT_BINARY_DIR}/mkalloc2.sed ${CMAKE_CURRENT_SOURCE_DIR}/declar.str>declar.h
+    COMMAND sed -f ${CMAKE_CURRENT_BINARY_DIR}/mkalloc1.sed -f ${CMAKE_CURRENT_BINARY_DIR}/mkalloc2.sed ${CMAKE_CURRENT_SOURCE_DIR}/def.str>def.h
+    COMMAND sed -f ${CMAKE_CURRENT_BINARY_DIR}/mkalloc1.sed -f ${CMAKE_CURRENT_BINARY_DIR}/mkalloc2.sed ${CMAKE_CURRENT_SOURCE_DIR}/expr.str>expr.h      
+    COMMAND sed -f ${CMAKE_CURRENT_BINARY_DIR}/mkalloc1.sed -f ${CMAKE_CURRENT_BINARY_DIR}/mkalloc2.sed ${CMAKE_CURRENT_SOURCE_DIR}/field.str>field.h
+    COMMAND sed -f ${CMAKE_CURRENT_BINARY_DIR}/mkalloc1.sed -f ${CMAKE_CURRENT_BINARY_DIR}/mkalloc2.sed ${CMAKE_CURRENT_SOURCE_DIR}/estack.str>estack.h      
+    COMMAND sed -f ${CMAKE_CURRENT_BINARY_DIR}/mkalloc1.sed -f ${CMAKE_CURRENT_BINARY_DIR}/mkalloc2.sed ${CMAKE_CURRENT_SOURCE_DIR}/util.str>util.h
+    COMMAND sed -f ${CMAKE_CURRENT_BINARY_DIR}/mkalloc1.sed -f ${CMAKE_CURRENT_BINARY_DIR}/mkalloc2.sed ${CMAKE_CURRENT_SOURCE_DIR}/proto.str>proto.h
+    COMMAND sed -f ${CMAKE_CURRENT_BINARY_DIR}/mkalloc1.sed -f ${CMAKE_CURRENT_BINARY_DIR}/mkalloc2.sed ${CMAKE_CURRENT_SOURCE_DIR}/idf.str>idf.h
+    COMMAND sed -f ${CMAKE_CURRENT_BINARY_DIR}/mkalloc1.sed -f ${CMAKE_CURRENT_BINARY_DIR}/mkalloc2.sed ${CMAKE_CURRENT_SOURCE_DIR}/macro.str>macro.h
+    COMMAND sed -f ${CMAKE_CURRENT_BINARY_DIR}/mkalloc1.sed -f ${CMAKE_CURRENT_BINARY_DIR}/mkalloc2.sed ${CMAKE_CURRENT_SOURCE_DIR}/stack.str>stack.h
+    COMMAND sed -f ${CMAKE_CURRENT_BINARY_DIR}/mkalloc1.sed -f ${CMAKE_CURRENT_BINARY_DIR}/mkalloc2.sed ${CMAKE_CURRENT_SOURCE_DIR}/stmt.str>stmt.h
+    COMMAND sed -f ${CMAKE_CURRENT_BINARY_DIR}/mkalloc1.sed -f ${CMAKE_CURRENT_BINARY_DIR}/mkalloc2.sed ${CMAKE_CURRENT_SOURCE_DIR}/struct.str>struct.h
+    COMMAND sed -f ${CMAKE_CURRENT_BINARY_DIR}/mkalloc1.sed -f ${CMAKE_CURRENT_BINARY_DIR}/mkalloc2.sed ${CMAKE_CURRENT_SOURCE_DIR}/switch.str>switch.h
+    COMMAND sed -f ${CMAKE_CURRENT_BINARY_DIR}/mkalloc1.sed -f ${CMAKE_CURRENT_BINARY_DIR}/mkalloc2.sed ${CMAKE_CURRENT_SOURCE_DIR}/type.str>type.h
+    COMMAND sed -f ${CMAKE_CURRENT_BINARY_DIR}/mkalloc1.sed -f ${CMAKE_CURRENT_BINARY_DIR}/mkalloc2.sed ${CMAKE_CURRENT_SOURCE_DIR}/l_brace.str>l_brace.h
+    COMMAND sed -f ${CMAKE_CURRENT_BINARY_DIR}/mkalloc1.sed -f ${CMAKE_CURRENT_BINARY_DIR}/mkalloc2.sed ${CMAKE_CURRENT_SOURCE_DIR}/l_state.str>l_state.h
+    COMMAND sed -f ${CMAKE_CURRENT_BINARY_DIR}/mkalloc1.sed -f ${CMAKE_CURRENT_BINARY_DIR}/mkalloc2.sed ${CMAKE_CURRENT_SOURCE_DIR}/l_outdef.str>l_outdef.h
+    # Create next file from above files
+    COMMAND ${CMAKE_COMMAND} -E copy
+                ${CMAKE_CURRENT_SOURCE_DIR}/next.str
+                ${CMAKE_CURRENT_BINARY_DIR}/next.c
+    COMMAND sed -n -f ${CMAKE_CURRENT_BINARY_DIR}/mknext.sed ${CMAKE_CURRENT_SOURCE_DIR}/code.str>>next.c
+    COMMAND sed -n -f ${CMAKE_CURRENT_BINARY_DIR}/mknext.sed ${CMAKE_CURRENT_SOURCE_DIR}/declar.str>>next.c
+    COMMAND sed -n -f ${CMAKE_CURRENT_BINARY_DIR}/mknext.sed ${CMAKE_CURRENT_SOURCE_DIR}/def.str>>next.c
+    COMMAND sed -n -f ${CMAKE_CURRENT_BINARY_DIR}/mknext.sed ${CMAKE_CURRENT_SOURCE_DIR}/expr.str>>next.c  
+    COMMAND sed -n -f ${CMAKE_CURRENT_BINARY_DIR}/mknext.sed ${CMAKE_CURRENT_SOURCE_DIR}/field.str>>next.c
+    COMMAND sed -n -f ${CMAKE_CURRENT_BINARY_DIR}/mknext.sed ${CMAKE_CURRENT_SOURCE_DIR}/estack.str>>next.c
+    COMMAND sed -n -f ${CMAKE_CURRENT_BINARY_DIR}/mknext.sed ${CMAKE_CURRENT_SOURCE_DIR}/util.str>>next.c 
+    COMMAND sed -n -f ${CMAKE_CURRENT_BINARY_DIR}/mknext.sed ${CMAKE_CURRENT_SOURCE_DIR}/proto.str>>next.c      
+    COMMAND sed -n -f ${CMAKE_CURRENT_BINARY_DIR}/mknext.sed ${CMAKE_CURRENT_SOURCE_DIR}/idf.str>>next.c      
+    COMMAND sed -n -f ${CMAKE_CURRENT_BINARY_DIR}/mknext.sed ${CMAKE_CURRENT_SOURCE_DIR}/macro.str>>next.c      
+    COMMAND sed -n -f ${CMAKE_CURRENT_BINARY_DIR}/mknext.sed ${CMAKE_CURRENT_SOURCE_DIR}/stack.str>>next.c      
+    COMMAND sed -n -f ${CMAKE_CURRENT_BINARY_DIR}/mknext.sed ${CMAKE_CURRENT_SOURCE_DIR}/stmt.str>>next.c      
+    COMMAND sed -n -f ${CMAKE_CURRENT_BINARY_DIR}/mknext.sed ${CMAKE_CURRENT_SOURCE_DIR}/struct.str>>next.c      
+    COMMAND sed -n -f ${CMAKE_CURRENT_BINARY_DIR}/mknext.sed ${CMAKE_CURRENT_SOURCE_DIR}/switch.str>>next.c      
+    COMMAND sed -n -f ${CMAKE_CURRENT_BINARY_DIR}/mknext.sed ${CMAKE_CURRENT_SOURCE_DIR}/type.str>>next.c
+    COMMAND sed -n -f ${CMAKE_CURRENT_BINARY_DIR}/mknext.sed ${CMAKE_CURRENT_SOURCE_DIR}/l_brace.str>>next.c      
+    COMMAND sed -n -f ${CMAKE_CURRENT_BINARY_DIR}/mknext.sed ${CMAKE_CURRENT_SOURCE_DIR}/l_state.str>>next.c      
+    COMMAND sed -n -f ${CMAKE_CURRENT_BINARY_DIR}/mknext.sed ${CMAKE_CURRENT_SOURCE_DIR}/l_outdef.str>>next.c      
+)
+
+
+
+
+
+add_custom_command(
+	OUTPUT char.c
+	COMMAND ${CMAKE_CURRENT_BINARY_DIR}/../../../util/cmisc/tabgen -f${CMAKE_CURRENT_SOURCE_DIR}/char.tab >char.c
+)
+
+###############################################
+# Generate the LLGen source files 
+# NOTE: Order of input file is important
+############################################### 
+
+add_custom_command(
+    OUTPUT tokenfile.g mktkfile.sed
+    COMMAND ${CMAKE_COMMAND} -E copy
+                ${PROJECT_SCRIPTS_SOURCE_DIR}/mktkfile.sed
+                ${CMAKE_CURRENT_BINARY_DIR}/mktkfile.sed    
+    COMMAND sed -f ${CMAKE_CURRENT_BINARY_DIR}/mktkfile.sed ${CMAKE_CURRENT_SOURCE_DIR}/tokenname.c>tokenfile.g
+)
+
+add_custom_command(
+    OUTPUT ${GEN_SRC}
+    COMMAND  ${CMAKE_COMMAND} -E env LLGEN_LIB_DIR=${CMAKE_CURRENT_SOURCE_DIR}/../../../util/LLgen/lib ${CMAKE_CURRENT_BINARY_DIR}/../../../util/LLgen/LLgen ${LLGENOPTIONS} ${GEN_G} ${SRC_G}
+    DEPENDS LLgen tokenfile.g)
+    
+    
+add_custom_command(
+   OUTPUT symbol2str.c
+   COMMAND cat ${CMAKE_CURRENT_SOURCE_DIR}/tokcaseh.in >symbol2str.c 
+   COMMAND sed -f ${CMAKE_CURRENT_SOURCE_DIR}/tokcase.sed ${CMAKE_CURRENT_SOURCE_DIR}/tokenname.c >>symbol2str.c 
+   COMMAND cat ${CMAKE_CURRENT_SOURCE_DIR}/tokcasee.in >>symbol2str.c 
+)     
+ 
+
+add_executable(${PROJECT_NAME} ${CFILES})
+target_compile_definitions(${PROJECT_NAME} PUBLIC NORCSID=1)
+target_include_directories(${PROJECT_NAME} PUBLIC ${INCLUDE_DIRS})
+
+target_link_libraries(${PROJECT_NAME} emheaders emh flt alloc print string system em_data eme em_mes)
+
+install(TARGETS ${PROJECT_NAME} RUNTIME DESTINATION bin)
+install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/cemcom.ansi.1 DESTINATION man OPTIONAL)
+
+
diff --git a/lang/cem/cemcom.ansi/LLlex.c b/lang/cem/cemcom.ansi/LLlex.c
index f0f5d5c24..d4be03449 100644
--- a/lang/cem/cemcom.ansi/LLlex.c
+++ b/lang/cem/cemcom.ansi/LLlex.c
@@ -17,6 +17,8 @@
 #include "Lpars.h"
 #include "class.h"
 #include "sizes.h"
+#include "error.h"
+#include "domacro.h"
 #include "specials.h" /* registration of special identifiers */
 
 /* Data about the token yielded */
@@ -41,7 +43,16 @@ extern arith full_mask[];
 extern int lint_skip_comment;
 #endif
 
-int LLlex()
+
+/* Internal function declarations */
+static arith char_constant(char*);
+static char* string_token(char *, int , int *);
+static int quoted(register int);
+static int hex_val(register int);
+static void strflt2tok(char [], struct token *);
+static void strint2tok(char [], struct token *);
+
+int LLlex(void)
 {
 	/*	LLlex() plays the role of Lexical Analyzer for the C parser.
 	    The look-ahead and putting aside of tokens are taken into
@@ -72,10 +83,8 @@ int LLlex()
 	return DOT;
 }
 
-char* string_token();
-arith char_constant();
 
-int GetToken(ptok) register struct token* ptok;
+int GetToken(register struct token* ptok)
 {
 	/*	GetToken() is the actual token recognizer. It calls the
 	    control line interpreter if it encounters a "\n{w}*#"
@@ -379,7 +388,7 @@ go_on: /* rescan, the following character has been read	*/
 	/*NOTREACHED*/
 }
 
-arith char_constant(nm) char* nm;
+static arith char_constant(char* nm)
 {
 	register arith val = 0;
 	register int ch;
@@ -413,8 +422,7 @@ arith char_constant(nm) char* nm;
 	return val;
 }
 
-char* string_token(nm, stop_char, plen) char* nm;
-int* plen;
+static char* string_token(char *nm, int stop_char, int *plen)
 {
 	register int ch;
 	register int str_size;
@@ -447,7 +455,7 @@ int* plen;
 	return str;
 }
 
-int quoted(ch) register int ch;
+static int quoted(register int ch)
 {
 	/*	quoted() replaces an escaped character sequence by the
 	    character meant.
@@ -510,12 +518,12 @@ int quoted(ch) register int ch;
 	return ch & 0377;
 }
 
-int hex_val(ch) register int ch;
+static int hex_val(register int ch)
 {
 	return is_dig(ch) ? ch - '0' : is_hex(ch) ? (ch - 'a' + 10) & 017 : -1;
 }
 
-int GetChar()
+int GetChar(void)
 {
 	/*	The routines GetChar and trigraph parses the trigraph
 	    sequences and removes occurences of \\\n.
@@ -529,8 +537,7 @@ int GetChar()
 /* strflt2tok only checks the syntax of the floating-point number and
  * selects the right type for the number.
  */
-strflt2tok(fltbuf, ptok) char fltbuf[];
-struct token* ptok;
+static void strflt2tok(char fltbuf[], struct token* ptok)
 {
 	register char* cp = fltbuf;
 	int malformed = 0;
@@ -584,8 +591,7 @@ struct token* ptok;
 	}
 }
 
-strint2tok(intbuf, ptok) char intbuf[];
-struct token* ptok;
+static void strint2tok(char intbuf[], struct token* ptok)
 {
 	register char* cp = intbuf;
 	int base = 10;
diff --git a/lang/cem/cemcom.ansi/LLlex.h b/lang/cem/cemcom.ansi/LLlex.h
index 678149d9f..a52f5ed78 100644
--- a/lang/cem/cemcom.ansi/LLlex.h
+++ b/lang/cem/cemcom.ansi/LLlex.h
@@ -9,6 +9,8 @@
 	called a "symbol", but it may have other information associated
 	to it.
 */
+#ifndef LLLEX_H_
+#define LLLEX_H_
 
 #include "file_info.h"
 
@@ -56,3 +58,9 @@ extern int err_occurred;	/* "error.c"	*/
 #define	ASIDE	aside.tk_symb
 
 #define EOF	(-1)
+
+int GetChar(void);
+int LLlex(void);
+int GetToken(register struct token* ptok);
+
+#endif /* LLLEX_H_ */
diff --git a/lang/cem/cemcom.ansi/LLmessage.c b/lang/cem/cemcom.ansi/LLmessage.c
index c88c5eb24..299d4a82d 100644
--- a/lang/cem/cemcom.ansi/LLmessage.c
+++ b/lang/cem/cemcom.ansi/LLmessage.c
@@ -10,21 +10,28 @@
 #include	"arith.h"
 #include	"LLlex.h"
 #include	"Lpars.h"
+#include    "error.h"
 
 extern char *symbol2str();
 
-LLmessage(tk)	{
+static void insert_token(int );
+
+void LLmessage(int tk)
+{
 	err_occurred = 1;
-	if (tk < 0)	{
+	if (tk < 0)
+	{
 		error("end of file expected");
 	}
-	else if (tk)	{
+	else if (tk)
+	{
 #ifndef LLNONCORR
 		error("%s missing before %s", symbol2str(tk), symbol2str(DOT));
 #endif
 		insert_token(tk);
 	}
-	else	{
+	else
+	{
 #ifndef LLNONCORR
 		error("%s deleted", symbol2str(DOT));
 #else
@@ -34,14 +41,14 @@ LLmessage(tk)	{
 	tk_nmb_at_last_syn_err = token_nmb;
 }
 
-insert_token(tk)
-	int tk;
+static void insert_token(int tk)
 {
 	aside = dot;
 
 	DOT = tk;
 
-	switch (tk)	{
+	switch (tk)
+	{
 	/* The operands need some body */
 	case IDENTIFIER:
 		dot.tk_idf = gen_idf();
diff --git a/lang/cem/cemcom.ansi/arith.c b/lang/cem/cemcom.ansi/arith.c
index b402e4b35..10d149911 100644
--- a/lang/cem/cemcom.ansi/arith.c
+++ b/lang/cem/cemcom.ansi/arith.c
@@ -24,16 +24,19 @@
 #include	"Lpars.h"
 #include	"field.h"
 #include	"mes.h"
+#include    "cstoper.h"
+#include    "ch3bin.h"
+#include    "ch3.h"
+#include    "error.h"
+
 
 extern char *symbol2str();
 extern char options[];
 extern arith flt_flt2arith();
 extern label code_string();
 
-void
-arithbalance(e1p, oper, e2p)	/* 3.1.2.5 */
-	register struct expr **e1p, **e2p;
-	int oper;
+/* 3.1.2.5 */
+void arithbalance(register struct expr **e1p, int oper, register struct expr **e2p)
 {
 	/*	The expressions *e1p and *e2p are balanced to be operands
 		of the arithmetic operator oper.
@@ -171,8 +174,7 @@ arithbalance(e1p, oper, e2p)	/* 3.1.2.5 */
 	}
 }
 
-relbalance(e1p, oper, e2p)
-	register struct expr **e1p, **e2p;
+void relbalance(register struct expr **e1p, int oper, register struct expr **e2p)
 {
 	/*	The expressions *e1p and *e2p are balanced to be operands
 		of the relational operator oper, or the ':'.
@@ -204,9 +206,7 @@ relbalance(e1p, oper, e2p)
 		arithbalance(e1p, oper, e2p);
 }
 
-ch3pointer(expp, oper, tp)
-	struct expr **expp;
-	register struct type *tp;
+void ch3pointer(struct expr **expp, int oper, register struct type *tp)
 {
 	/*	Checks whether *expp may be compared to tp using oper,
 		as described in chapter 3.3.8 and 3.3.9.
@@ -238,9 +238,7 @@ ch3pointer(expp, oper, tp)
 }
 
 int
-any2arith(expp, oper)
-	register struct expr **expp;
-	register int oper;
+any2arith(register struct expr **expp, register int oper)
 {
 	/*	Turns any expression into int_type, long_type,
 		float_type, double_type or lngdbl_type.
@@ -295,8 +293,7 @@ any2arith(expp, oper)
 	return (*expp)->ex_type->tp_fund;
 }
 
-erroneous2int(expp)
-	struct expr **expp;
+void erroneous2int(struct expr **expp)
 {
 	/*	the (erroneous) expression *expp is replaced by an
 		int expression
@@ -310,11 +307,7 @@ erroneous2int(expp)
 	*expp = exp;
 }
 
-struct expr *
-arith2arith(tp, oper, expr)
-	struct type *tp;
-	int oper;
-	register struct expr *expr;
+struct expr *arith2arith(struct type *tp, int oper, register struct expr *expr)
 {
 	/*	arith2arith constructs a new expression containing a
 		run-time conversion between some arithmetic types.
@@ -328,10 +321,7 @@ arith2arith(tp, oper, expr)
 	return new_oper(tp, new, oper, expr);
 }
 
-int
-int2int(expp, tp)
-	struct expr **expp;
-	register struct type *tp;
+int int2int(struct expr **expp, register struct type *tp)
 {
 	/*	The expression *expp, which is of some integral type, is
 		converted to the integral type tp.
@@ -369,9 +359,7 @@ int2int(expp, tp)
 /* With compile-time constants, we don't set fp_used, since this is done
  * only when necessary in eval.c.
  */
-int2float(expp, tp)
-	register struct expr **expp;
-	struct type *tp;
+void int2float(register struct expr **expp, struct type *tp)
 {
 	/*	The expression *expp, which is of some integral type, is
 		converted to the floating type tp.
@@ -390,9 +378,7 @@ int2float(expp, tp)
 	}
 }
 
-float2int(expp, tp)
-	struct expr **expp;
-	struct type *tp;
+void float2int(struct expr **expp, struct type *tp)
 {
 	/*	The expression *expp, which is of some floating type, is
 		converted to the integral type tp.
@@ -418,9 +404,7 @@ float2int(expp, tp)
 	}
 }
 
-float2float(expp, tp)
-	register struct expr **expp;
-	struct type *tp;
+void float2float(register struct expr **expp, struct type *tp)
 {
 	/*	The expression *expp, which is of some floating type, is
 		converted to the floating type tp.
@@ -436,8 +420,7 @@ float2float(expp, tp)
 	}
 }
 
-array2pointer(exp)
-	register struct expr *exp;
+void array2pointer(register struct expr *exp)
 {
 	/*	The expression, which must be an array, is converted
 		to a pointer.
@@ -447,8 +430,7 @@ array2pointer(exp)
 				    , (arith)0, NO_PROTO);
 }
 
-function2pointer(exp)
-	register struct expr *exp;
+void function2pointer(register struct expr *exp)
 {
 	/*	The expression, which must be a function, is converted
 		to a pointer to the function.
@@ -457,8 +439,7 @@ function2pointer(exp)
 				     (arith)0, NO_PROTO);
 }
 
-string2pointer(ex)
-	register struct expr *ex;
+void string2pointer(register struct expr *ex)
 {
 	/*	The expression, which must be a string constant, is converted
 		to a pointer to the string-containing area.
@@ -472,9 +453,7 @@ string2pointer(ex)
 	ex->VL_VALUE = (arith)0;
 }
 
-opnd2integral(expp, oper)
-	register struct expr **expp;
-	int oper;
+void opnd2integral(register struct expr **expp, int oper)
 {
 	register int fund = (*expp)->ex_type->tp_fund;
 
@@ -486,9 +465,7 @@ opnd2integral(expp, oper)
 	}
 }
 
-opnd2logical(expp, oper)
-	register struct expr **expp;
-	int oper;
+void opnd2logical(register struct expr **expp, int oper)
 {
 	int fund = (*expp)->ex_type->tp_fund;
 
@@ -525,8 +502,7 @@ opnd2logical(expp, oper)
 }
 
 void
-opnd2test(expp, oper)
-	register struct expr **expp;
+opnd2test(register struct expr **expp, int oper)
 {
 	opnd2logical(expp, oper);
 	if ((*expp)->ex_class == Oper) {
@@ -550,9 +526,7 @@ opnd2test(expp, oper)
 	ch3bin(expp, NOTEQUAL, intexpr((arith)0, INT));
 }
 
-void
-any2opnd(expp, oper)
-	register struct expr **expp;
+void any2opnd(register struct expr **expp, int oper)
 {
 	if (!*expp)
 		return;
@@ -584,8 +558,7 @@ any2opnd(expp, oper)
 	}
 }
 
-any2parameter(expp)
-	register struct expr **expp;
+void any2parameter(register struct expr **expp)
 {
 	/*	To handle default argument promotions
 	*/
@@ -598,8 +571,7 @@ any2parameter(expp)
 }
 
 #ifndef NOBITFIELD
-field2arith(expp)
-	register struct expr **expp;
+void field2arith(register struct expr **expp)
 {
 	/*	The expression to extract the bitfield value from the
 		memory word is put in the tree.
@@ -630,8 +602,7 @@ field2arith(expp)
 /*	switch_sign_fp() negates the given floating constant expression,
  *	and frees the string representing the old value.
  */
-switch_sign_fp(expr)
-	register struct expr *expr;
+void switch_sign_fp(register struct expr *expr)
 {
 	flt_umin(&(expr->FL_ARITH));
 }
diff --git a/lang/cem/cemcom.ansi/arith.h b/lang/cem/cemcom.ansi/arith.h
index 4bb403458..65b0003de 100644
--- a/lang/cem/cemcom.ansi/arith.h
+++ b/lang/cem/cemcom.ansi/arith.h
@@ -12,12 +12,15 @@
 	to save storage on small machines, SPECIAL_ARITHMETICS will
 	be handy.
 */
+#ifndef ARITH_H_
+#define ARITH_H_
 
 #include	"parameters.h"
 
 #ifndef	SPECIAL_ARITHMETICS
 
-#include <em_arith.h>		/* obtain definition of "arith"	*/
+#include    <em_arith.h>		/* obtain definition of "arith"	*/
+#include	<flt_arith.h>
 
 #else	/* SPECIAL_ARITHMETICS */
 
@@ -27,6 +30,32 @@
 
 #endif	/* SPECIAL_ARITHMETICS */
 
+struct expr;
+struct type;
+
 #define	arith_size	(sizeof(arith))
 #define	arith_sign	((arith) 1 << (arith_size * 8 - 1))
 #define	max_arith	(~arith_sign)
+
+void arithbalance(register struct expr **e1p, int oper, register struct expr **e2p);
+void relbalance(register struct expr **e1p, int oper, register struct expr **e2p);
+void ch3pointer(struct expr **expp, int oper, register struct type *tp);
+int any2arith(register struct expr **expp, register int oper);
+void erroneous2int(struct expr **expp);
+struct expr *arith2arith(struct type *tp, int oper, register struct expr *expr);
+int int2int(struct expr **expp, register struct type *tp);
+void int2float(register struct expr **expp, struct type *tp);
+void float2int(struct expr **expp, struct type *tp);
+void float2float(register struct expr **expp, struct type *tp);
+void array2pointer(register struct expr *exp);
+void function2pointer(register struct expr *exp);
+void string2pointer(register struct expr *ex);
+void opnd2integral(register struct expr **expp, int oper);
+void opnd2logical(register struct expr **expp, int oper);
+void opnd2test(register struct expr **expp, int oper);
+void any2opnd(register struct expr **expp, int oper);
+void any2parameter(register struct expr **expp);
+void field2arith(register struct expr **expp);
+void switch_sign_fp(register struct expr *expr);
+
+#endif /* ARITH_H_ */
diff --git a/lang/cem/cemcom.ansi/blocks.c b/lang/cem/cemcom.ansi/blocks.c
index 6d75a3670..d4df8b73e 100644
--- a/lang/cem/cemcom.ansi/blocks.c
+++ b/lang/cem/cemcom.ansi/blocks.c
@@ -18,7 +18,10 @@
 #include "label.h"
 #include "stack.h"
 #include "Lpars.h"
-extern arith NewLocal();
+#include "blocks.h"
+#include "macro.h"
+#include "util.h"
+
 #define LocalPtrVar()	NewLocal(pointer_size, pointer_align, reg_pointer, REGISTER)
 #define LocalIntVar()	NewLocal(int_size, int_align, reg_any, REGISTER)
 #endif /* STB */
@@ -52,9 +55,7 @@ extern arith NewLocal();
 	while we need a loop to store the stack block into a memory object.
 */
 
-suitable_sz(sz, al)
-	arith sz;
-	int al;
+int suitable_sz(arith sz, int al)
 {
 	return	((int)sz % (int)word_size == 0 && al % word_align == 0) ||
 		(
@@ -64,9 +65,7 @@ suitable_sz(sz, al)
 		);
 }
 
-store_block(sz, al)
-	arith sz;
-	int al;
+void store_block(arith sz, int al)
 {
 	if (suitable_sz(sz, al))
 		C_sti(sz);
@@ -102,9 +101,7 @@ store_block(sz, al)
 	}
 }
 
-load_block(sz, al)
-	arith sz;
-	int al;
+void load_block(arith sz, int al)
 {
 
 	if (suitable_sz(sz, al))
@@ -138,9 +135,7 @@ load_block(sz, al)
 	}
 }
 
-copy_block(sz, al)
-	arith sz;
-	int al;
+void copy_block(arith sz, int al)
 {
 
 	if (suitable_sz(sz, al))
@@ -167,8 +162,7 @@ copy_block(sz, al)
 }
 
 #ifndef STB
-copy_loop(sz, src, dst)
-	arith sz, src, dst;
+void copy_loop(arith sz, arith src, arith dst)
 {
 	/* generate inline byte-copy loop */
 	label l_cont = text_label(), l_stop = text_label();
diff --git a/lang/cem/cemcom.ansi/blocks.h b/lang/cem/cemcom.ansi/blocks.h
new file mode 100644
index 000000000..45f18d491
--- /dev/null
+++ b/lang/cem/cemcom.ansi/blocks.h
@@ -0,0 +1,20 @@
+/*  Copyright (c) 2019 ACK Project.
+ *  See the copyright notice in the ACK home directory,
+ *  in the file "Copyright".
+ *
+ *  Created on: 2019-02-06
+ *
+ */
+#ifndef BLOCKS_H_
+#define BLOCKS_H_
+
+#include "parameters.h"
+#include "arith.h"
+
+int suitable_sz(arith sz, int al);
+void store_block(arith sz, int al);
+void load_block(arith sz, int al);
+void copy_block(arith sz, int al);
+void copy_loop(arith sz, arith src, arith dst);
+
+#endif /* BLOCKS_H_ */
diff --git a/lang/cem/cemcom.ansi/ch3.c b/lang/cem/cemcom.ansi/ch3.c
index 535426937..3132ccbb9 100644
--- a/lang/cem/cemcom.ansi/ch3.c
+++ b/lang/cem/cemcom.ansi/ch3.c
@@ -9,6 +9,7 @@
 #include	"parameters.h"
 #include	<flt_arith.h>
 #include	"arith.h"
+#include    "ch3.h"
 #include    "idf.h"
 #include	"proto.h"
 #include	"type.h"
@@ -17,23 +18,22 @@
 #include	"expr.h"
 #include	"def.h"
 #include	"Lpars.h"
+#include    "error.h"
+#include    "ch3bin.h"
 #include	"file_info.h"
 
 extern char options[];
 extern char *symbol2str();
 extern struct type *qualifier_type();
 
-void ch3cast();
+
 
 /*	Most expression-handling routines have a pointer to a
 	(struct type *) as first parameter. The object under the pointer
 	gets updated in the process.
 */
 
-void
-ch3sel(expp, oper, idf)
-	struct expr **expp;
-	struct idf *idf;
+void ch3sel(struct expr **expp, int oper, struct idf *idf)
 {
 	/*	The selector idf is applied to *expp; oper may be '.' or
 		ARROW.
@@ -163,8 +163,7 @@ ch3sel(expp, oper, idf)
 	*expp = exp;
 }
 
-ch3incr(expp, oper)
-	struct expr **expp;
+void ch3incr(struct expr **expp, int oper)
 {
 	/*	The monadic prefix/postfix incr/decr operator oper is
 		applied to *expp.
@@ -172,10 +171,7 @@ ch3incr(expp, oper)
 	ch3asgn(expp, oper, intexpr((arith)1, INT));
 }
 
-void
-ch3cast(expp, oper, tp)
-	register struct expr **expp;
-	register struct type *tp;
+void ch3cast(register struct expr **expp, int oper, register struct type *tp)
 {
 	/*	The expression *expp is cast to type tp; the cast is
 		caused by the operator oper.  If the cast has
@@ -412,9 +408,7 @@ ch3cast(expp, oper, tp)
 
 /*	Determine whether two types are equal.
 */
-equal_type(tp, otp, qual_lev, diag)
-	register struct type *tp, *otp;
-	int qual_lev, diag;
+int equal_type(register struct type *tp,register struct type *otp, int qual_lev, int diag)
 {
 	 if (tp == otp)
 		return 1;
@@ -475,8 +469,7 @@ equal_type(tp, otp, qual_lev, diag)
 	}
 }
 
-check_pseudoproto(pl, opl, diag)
-	register struct proto *pl, *opl;
+int check_pseudoproto(register struct proto *pl,register struct proto *opl, int diag)
 {
 	int retval = 1;
 
@@ -519,9 +512,7 @@ check_pseudoproto(pl, opl, diag)
 	return retval;
 }
 
-legal_mixture(tp, otp, diag)
-	struct type *tp, *otp;
-	int diag;
+int legal_mixture(struct type *tp, struct type *otp, int diag)
 {
 	struct proto *pl = tp->tp_proto, *opl = otp->tp_proto;
 	int retval = 1;
@@ -562,9 +553,7 @@ legal_mixture(tp, otp, diag)
 	return retval;
 }
 
-equal_proto(pl, opl, diag)
-	register struct proto *pl, *opl;
-	int diag;
+int equal_proto(register struct proto *pl, register struct proto *opl, int diag)
 {
 	if (pl == opl)
 		return 1;
@@ -586,9 +575,7 @@ equal_proto(pl, opl, diag)
 }
 
 /* check if a type has a consqualified member */
-recurqual(tp, qual)
-struct type *tp;
-int qual;
+int recurqual(struct type *tp, int qual)
 {
 	register struct sdef *sdf;
 
@@ -610,9 +597,7 @@ int qual;
 	return 0;
 }
 
-ch3asgn(expp, oper, expr)
-	struct expr **expp;
-	struct expr *expr;
+void ch3asgn(struct expr **expp, int oper, struct expr *expr)
 {
 	/*	The assignment operators.
 		"f op= e" should be interpreted as
@@ -687,9 +672,7 @@ ch3asgn(expp, oper, expr)
 
 /*	Some interesting (?) questions answered.
 */
-int
-is_integral_type(tp)
-	register struct type *tp;
+int is_integral_type(register struct type *tp)
 {
 	switch (tp->tp_fund)	{
 	case CHAR:
@@ -707,9 +690,7 @@ is_integral_type(tp)
 	}
 }
 
-int
-is_arith_type(tp)
-	register struct type *tp;
+int is_arith_type(register struct type *tp)
 {
 	switch (tp->tp_fund)	{
 	case CHAR:
diff --git a/lang/cem/cemcom.ansi/ch3.h b/lang/cem/cemcom.ansi/ch3.h
new file mode 100644
index 000000000..a8970f75e
--- /dev/null
+++ b/lang/cem/cemcom.ansi/ch3.h
@@ -0,0 +1,29 @@
+/*  Copyright (c) 2019 ACK Project. See the file Copyright in
+ *  the project root directory for more information.
+ *
+ *  Created on: 2019-02-06
+ *
+ */
+#ifndef CH3_H_
+#define CH3_H_
+
+/* Structure forward declarations. */
+struct expr;
+struct type;
+struct proto;
+struct idf;
+
+
+void ch3sel(struct expr **expp, int oper, struct idf *idf);
+void ch3incr(struct expr **expp, int oper);
+void ch3cast(register struct expr **expp, int oper, register struct type *tp);
+int equal_type(register struct type *tp,register struct type *otp, int qual_lev, int diag);
+int check_pseudoproto(register struct proto *pl,register struct proto *opl, int diag);
+int legal_mixture(struct type *tp, struct type *otp, int diag);
+int equal_proto(register struct proto *pl, register struct proto *opl, int diag);
+int recurqual(struct type *tp, int qual);
+void ch3asgn(struct expr **expp, int oper, struct expr *expr);
+int is_integral_type(register struct type *tp);
+int is_arith_type(register struct type *tp);
+
+#endif /* CH3_H_ */
diff --git a/lang/cem/cemcom.ansi/ch3bin.c b/lang/cem/cemcom.ansi/ch3bin.c
index ba75c112c..e692e98fa 100644
--- a/lang/cem/cemcom.ansi/ch3bin.c
+++ b/lang/cem/cemcom.ansi/ch3bin.c
@@ -15,6 +15,12 @@
 #include	"expr.h"
 #include	"Lpars.h"
 #include	"sizes.h"
+#include    "ch3bin.h"
+#include    "ch3mon.h"
+#include    "ch3.h"
+#include    "error.h"
+#include    "cstoper.h"
+#include    "fltcstoper.h"
 
 extern char options[];
 extern char *symbol2str();
@@ -34,10 +40,7 @@ void pntminuspnt();
 #define commutative_binop(expp, oper, expr)	mk_binop(expp, oper, expr, 1)
 #define non_commutative_relop(expp, oper, expr)	mk_binop(expp, oper, expr, 1)
 
-void
-ch3bin(expp, oper, expr)
-	register struct expr **expp;
-	struct expr *expr;
+void ch3bin(register struct expr **expp, int oper, struct expr *expr)
 {
 	/*	apply binary operator oper between *expp and expr.
 		NB: don't swap operands if op is one of the op= operators!!!
@@ -295,9 +298,7 @@ ch3bin(expp, oper, expr)
 	}
 }
 
-void
-pntminuspnt(expp, oper, expr)
-	register struct expr **expp, *expr;
+void pntminuspnt(register struct expr **expp, int oper, register struct expr *expr)
 {
 	/*	Subtracting two pointers is so complicated it merits a
 		routine of its own.
@@ -328,8 +329,7 @@ pntminuspnt(expp, oper, expr)
  * when the arguments are switched.  This is special for some relational
  * operators.
  */
-int
-arg_switched(oper)
+int arg_switched(int oper)
 {
 	switch (oper) {
 	case '<':	return '>';
@@ -340,9 +340,7 @@ arg_switched(oper)
 	}
 }
 
-mk_binop(expp, oper, expr, commutative)
-	struct expr **expp;
-	register struct expr *expr;
+void mk_binop(struct expr **expp, int oper, register struct expr *expr, int commutative)
 {
 	/*	Constructs in *expp the operation indicated by the operands.
 		"commutative" indicates whether "oper" is a commutative
@@ -366,8 +364,7 @@ mk_binop(expp, oper, expr, commutative)
 	}
 }
 
-pointer_arithmetic(expp1, oper, expp2)
-	register struct expr **expp1, **expp2;
+void pointer_arithmetic(register struct expr **expp1, int oper, register struct expr **expp2)
 {
 	int typ;
 	/*	prepares the integral expression expp2 in order to
@@ -387,8 +384,7 @@ pointer_arithmetic(expp1, oper, expp2)
 	);
 }
 
-pointer_binary(expp, oper, expr)
-	register struct expr **expp, *expr;
+void pointer_binary(register struct expr **expp, int oper, register struct expr *expr)
 {
 	/*	constructs the pointer arithmetic expression out of
 		a pointer expression, a binary operator and an integral
diff --git a/lang/cem/cemcom.ansi/ch3bin.h b/lang/cem/cemcom.ansi/ch3bin.h
new file mode 100644
index 000000000..bc6ea2d20
--- /dev/null
+++ b/lang/cem/cemcom.ansi/ch3bin.h
@@ -0,0 +1,21 @@
+/*  Copyright (c) 2019 ACK Project.
+ *  See the copyright notice in the ACK home directory,
+ *  in the file "Copyright".
+ *
+ *  Created on: 2019-02-06
+ *
+ */
+#ifndef CH3BIN_H_
+#define CH3BIN_H_
+
+struct expr;
+
+void ch3bin(register struct expr **expp, int oper, struct expr *expr);
+void pntminuspnt(register struct expr **expp, int oper, register struct expr *expr);
+int arg_switched(int oper);
+void mk_binop(struct expr **expp, int oper, register struct expr *expr, int commutative);
+void pointer_arithmetic(register struct expr **expp1, int oper, register struct expr **expp2);
+void pointer_binary(register struct expr **expp, int oper, register struct expr *expr);
+
+
+#endif /* CH3BIN_H_ */
diff --git a/lang/cem/cemcom.ansi/ch3mon.c b/lang/cem/cemcom.ansi/ch3mon.c
index 8cffc2c9d..a84a141f2 100644
--- a/lang/cem/cemcom.ansi/ch3mon.c
+++ b/lang/cem/cemcom.ansi/ch3mon.c
@@ -5,6 +5,7 @@
 /* $Id$ */
 /* SEMANTIC ANALYSIS (CHAPTER 3.3) -- MONADIC OPERATORS */
 
+#include    "ch3mon.h"
 #include	"parameters.h"
 #include	<alloc.h>
 #include	"Lpars.h"
@@ -16,13 +17,15 @@
 #include	"expr.h"
 #include	"def.h"
 #include	"sizes.h"
+#include    "ch3.h"
+#include    "error.h"
+
 
 extern char options[];
 extern arith full_mask[/*MAXSIZE + 1*/];	/* cstoper.c */
 char *symbol2str();
 
-ch3mon(oper, expp)
-	register struct expr **expp;
+void ch3mon(int oper, register struct expr **expp)
 {
 	/*	The monadic prefix operator oper is applied to *expp.
 	*/
diff --git a/lang/cem/cemcom.ansi/ch3mon.h b/lang/cem/cemcom.ansi/ch3mon.h
new file mode 100644
index 000000000..354738c42
--- /dev/null
+++ b/lang/cem/cemcom.ansi/ch3mon.h
@@ -0,0 +1,22 @@
+/*  Copyright (c) 2019 ACK Project.
+ *  See the copyright notice in the ACK home directory, 
+ *  in the file "Copyright".
+ *
+ *  Created on: 2019-02-06
+ *  
+ */
+#ifndef CH3MON_H_
+#define CH3MON_H_
+
+struct expr;
+
+void ch3mon(int oper, register struct expr **expp);
+void ch3bin(register struct expr **expp, int oper, struct expr *expr);
+void pntminuspnt(register struct expr **expp, int oper, register struct expr *expr);
+int arg_switched(int oper);
+void mk_binop(struct expr **expp, int oper, register struct expr *expr, int commutative);
+void pointer_arithmetic(register struct expr **expp1, int oper, register struct expr **expp2);
+void pointer_binary(register struct expr **expp, int oper, register struct expr *expr);
+
+
+#endif /* CH3MON_H_ */
diff --git a/lang/cem/cemcom.ansi/code.c b/lang/cem/cemcom.ansi/code.c
index a6a898ab7..d50700056 100644
--- a/lang/cem/cemcom.ansi/code.c
+++ b/lang/cem/cemcom.ansi/code.c
@@ -27,14 +27,24 @@
 #include	"expr.h"
 #include	"sizes.h"
 #include	"stack.h"
+#include    "blocks.h"
+#include    "struct.h"
 #include	"level.h"
+#include    "dataflow.h"
+#include    "conversion.h"
 #include	"decspecs.h"
 #include	"declar.h"
 #include	"Lpars.h"
 #include	"specials.h"
 #include	"atw.h"
+#include    "ch3.h"
+#include    "eval.h"
+#include    "stab.h"
 #include	"LLlex.h"
 #include	"align.h"
+#include    "util.h"
+#include    "error.h"
+
 #ifdef	LINT
 #include	"l_lint.h"
 #endif	/* LINT */
@@ -46,7 +56,10 @@ label lab_count = 1;
 label datlab_count = 1;
 
 int fp_used;
-extern arith NewLocal();	/* util.c	*/
+
+extern void str_cst(register char *, register int, int);  /* ival.c */
+
+
 
 /* global function info */
 char *func_name;
@@ -67,8 +80,7 @@ extern char *source;
 void loc_init();
 
 #ifndef	LINT
-init_code(dst_file)
-	char *dst_file;
+void init_code(char *dst_file)
 {
 	/*	init_code() initialises the output file on which the
 		compact EM code is written
@@ -105,10 +117,7 @@ init_code(dst_file)
 
 struct string_cst *str_list = 0;
 
-label
-code_string(val, len)
-	char *val;
-	int len;
+label code_string(char* val, int len)
 {
 	register struct string_cst *sc = new_string_cst();
 	label dlb = data_label();
@@ -122,8 +131,7 @@ code_string(val, len)
 	return dlb;
 }
 
-def_strings(sc)
-	register struct string_cst *sc;
+void def_strings(register struct string_cst *sc)
 {
 	while (sc) {
 		struct string_cst *sc1 = sc;
@@ -137,7 +145,7 @@ def_strings(sc)
 }
 
 /* flush_strings() is called from program.g after each external definition */
-flush_strings() {
+void flush_strings(void) {
 	if (str_list) {
 		def_strings(str_list);
 		str_list = 0;
@@ -145,7 +153,7 @@ flush_strings() {
 }
 
 #ifndef	LINT
-end_code()
+void end_code(void)
 {
 	/*	end_code() performs the actions to be taken when closing
 		the output stream.
@@ -160,7 +168,7 @@ end_code()
 #endif	/* LINT */
 
 #ifdef	PREPEND_SCOPES
-prepend_scopes()
+void prepend_scopes(void)
 {
 	/*	prepend_scopes() runs down the list of global idf's
 		and generates those exa's, exp's, ina's and inp's
@@ -185,9 +193,7 @@ prepend_scopes()
 }
 #endif	/* PREPEND_SCOPES */
 
-code_scope(text, def)
-	char *text;
-	register struct def *def;
+void code_scope(char* text, register struct def *def)
 {
 	/*	generates code for one name, text, of the storage class
 		as given by def, if meaningful.
@@ -218,9 +224,7 @@ static int struct_return;
 static char *last_fn_given = (char *)0;
 static label file_name_label;
 
-begin_proc(ds, idf)		/* to be called when entering a procedure */
-	struct decspecs *ds;
-	struct idf *idf;
+void begin_proc(struct decspecs *ds, struct idf *idf)		/* to be called when entering a procedure */
 {
 	/*	begin_proc() is called at the entrance of a new function
 		and performs the necessary code generation:
@@ -317,8 +321,7 @@ begin_proc(ds, idf)		/* to be called when entering a procedure */
 #endif
 }
 
-end_proc(fbytes)
-	arith fbytes;
+void end_proc(arith fbytes)
 {
 	/*	end_proc() deals with the code to be generated at the end of
 		a function, as there is:
@@ -388,7 +391,7 @@ end_proc(fbytes)
 	options['n'] = optionsn;
 }
 
-do_return()
+void do_return(void)
 {
 	/*	do_return handles the case of a return without expression.
 		This version branches to the return label, which is
@@ -401,8 +404,7 @@ do_return()
 	C_bra(return2_label);
 }
 
-do_return_expr(expr)
-	struct expr *expr;
+void do_return_expr(struct expr *expr)
 {
 	/*	do_return_expr() generates the expression and the jump for
 		a return statement with an expression.
@@ -418,11 +420,11 @@ do_return_expr(expr)
 }
 
 void
-code_declaration(idf, expr, lvl, sc)
-	register struct idf *idf;	/* idf to be declared	*/
-	struct expr *expr;	/* initialisation; NULL if absent	*/
-	int lvl;		/* declaration level	*/
-	int sc;			/* storage class, as in the declaration */
+code_declaration(
+	register struct idf *idf,	/* idf to be declared	*/
+	struct expr *expr,	/* initialisation; NULL if absent	*/
+	int lvl,		/* declaration level	*/
+	int sc)		/* storage class, as in the declaration */
 {
 	/*	code_declaration() does the actual declaration of the
 		variable indicated by "idf" on declaration level "lvl".
@@ -530,10 +532,7 @@ code_declaration(idf, expr, lvl, sc)
 	}
 }
 
-void
-loc_init(expr, id)
-	struct expr *expr;
-	struct idf *id;
+void loc_init(struct expr *expr, struct idf *id)
 {
 	/*	loc_init() generates code for the assignment of
 		expression expr to the local variable described by id.
@@ -609,8 +608,7 @@ loc_init(expr, id)
 	}
 }
 
-bss(idf)
-	register struct idf *idf;
+void bss(register struct idf *idf)
 {
 	/*	bss() allocates bss space for the global idf.
 	*/
@@ -640,9 +638,7 @@ bss(idf)
 	}
 }
 
-formal_cvt(hasproto,df)
-	int hasproto;
-	register struct def *df;
+void formal_cvt(int hasproto, register struct def *df)
 {
 	/*	formal_cvt() converts a formal parameter of type char or
 		short from int to that type. It also converts a formal
@@ -672,9 +668,7 @@ formal_cvt(hasproto,df)
 #ifdef	LINT
 /*ARGSUSED*/
 #endif	/* LINT */
-code_expr(expr, val, code, tlbl, flbl)
-	struct expr *expr;
-	label tlbl, flbl;
+void code_expr(struct expr *expr, int val, int code, label tlbl, label flbl)
 {
 	/*	code_expr() is the parser's interface to the expression code
 		generator.  If line number trace is wanted, it generates a
@@ -707,7 +701,7 @@ static struct stmt_block *stmt_stack;	/* top of statement stack */
 	which are the only ones that are stacked, only the top of
 	the stack is interesting.
 */
-code_break()
+void code_break(void)
 {
 	register struct stmt_block *stmt_block = stmt_stack;
 
@@ -726,7 +720,7 @@ code_break()
 	innermost statement in which continue has a meaning.
 */
 void
-code_continue()
+code_continue(void)
 {
 	register struct stmt_block *stmt_block = stmt_stack;
 
@@ -743,8 +737,7 @@ code_continue()
 	error("continue not inside for, while or do");
 }
 
-stack_stmt(break_label, cont_label)
-	label break_label, cont_label;
+void stack_stmt(label break_label, label cont_label)
 {
 	register struct stmt_block *stmt_block = new_stmt_block();
 
@@ -754,7 +747,7 @@ stack_stmt(break_label, cont_label)
 	stmt_stack = stmt_block;
 }
 
-unstack_stmt()
+void unstack_stmt(void)
 {
 	/*	unstack_stmt() unstacks the data of a statement
 		which may contain break or continue
@@ -766,8 +759,7 @@ unstack_stmt()
 
 static label prc_name;
 
-prc_entry(name)
-	char *name;
+void prc_entry(char* name)
 {
 	if (options['p']) {
 		C_df_dlb(prc_name = data_label());
@@ -778,7 +770,7 @@ prc_entry(name)
 	}
 }
 
-prc_exit()
+void prc_exit(void)
 {
 	if (options['p']) {
 		C_lae_dlb(prc_name, (arith) 0);
@@ -788,9 +780,7 @@ prc_exit()
 }
 
 #ifdef DBSYMTAB
-db_line(file, line)
-	char		*file;
-	unsigned int	line;
+void db_line(char *file, unsigned int line)
 {
 	static unsigned oldline;
 	static char	*oldfile;
diff --git a/lang/cem/cemcom.ansi/code.str b/lang/cem/cemcom.ansi/code.str
index b818bbea0..b3770395f 100644
--- a/lang/cem/cemcom.ansi/code.str
+++ b/lang/cem/cemcom.ansi/code.str
@@ -2,9 +2,15 @@
  * (c) copyright 1987 by the Vrije Universiteit, Amsterdam, The Netherlands.
  * See the copyright notice in the ACK home directory, in the file "Copyright".
  */
+#ifndef CODE_H_
+#define CODE_H_
 /* $Id$ */
 /*	C O D E - G E N E R A T O R   D E F I N I T I O N S	*/
 
+#include "arith.h"
+#include "label.h"
+
+
 struct string_cst	{	/* storing string constants */
 	struct string_cst *next;
 	char *sc_value;
@@ -20,3 +26,44 @@ extern struct string_cst *str_list;
 #define	RVAL	1
 #define	FALSE	0
 #define	TRUE	1
+
+
+#ifndef	LINT
+void init_code(char *dst_file);
+void end_code(void);
+#endif
+
+struct expr;
+struct def;
+struct idf;
+
+label code_string(char* val, int len);
+void def_strings(register struct string_cst *sc);
+void flush_strings(void);
+void code_scope(char* text, register struct def *def);
+void begin_proc(struct decspecs *ds, struct idf *idf);
+void end_proc(arith fbytes);
+void do_return(void);
+void do_return_expr(struct expr *expr);
+void code_declaration(register struct idf *idf, struct expr *expr, 
+		int lvl, int sc);
+void loc_init(struct expr *expr, struct idf *id);
+void bss(register struct idf *idf);
+void formal_cvt(int hasproto, register struct def *df);
+void code_expr(struct expr *expr, int val, int code, label tlbl, label flbl);
+void code_break(void);
+void code_continue(void);
+void stack_stmt(label break_label, label cont_label);
+void unstack_stmt(void);
+void prc_entry(char* name);
+void prc_exit(void);
+
+#ifdef	PREPEND_SCOPES
+void prepend_scopes(void);
+#endif
+
+#ifdef DBSYMTAB
+void db_line(char *file, unsigned int line);
+#endif
+
+#endif
diff --git a/lang/cem/cemcom.ansi/conversion.c b/lang/cem/cemcom.ansi/conversion.c
index 485d8b8bd..60d4c45b5 100644
--- a/lang/cem/cemcom.ansi/conversion.c
+++ b/lang/cem/cemcom.ansi/conversion.c
@@ -8,11 +8,15 @@
 #include	"parameters.h"
 #ifndef	LINT
 
+#include    "conversion.h"
 #include	<em.h>
+#include    "interface.h"
 #include	"arith.h"
 #include	"type.h"
 #include	"sizes.h"
 #include	"Lpars.h"
+#include    "error.h"
+
 
 #define	T_SIGNED		1
 #define	T_UNSIGNED		2
@@ -27,10 +31,9 @@
 		C??
 */
 
-static int convtype();
+static int convtype(register struct type *);
 
-conversion(from_type, to_type)
-	register struct type *from_type, *to_type;
+void conversion(register struct type *from_type, register struct type *to_type)
 {
 	register arith from_size = from_type->tp_size;
 	register arith to_size = to_type->tp_size;
@@ -126,9 +129,7 @@ conversion(from_type, to_type)
 /*	convtype() returns in which category a given type falls:
 	signed, unsigned or floating
 */
-static int
-convtype(tp)
-	register struct type *tp;
+static int convtype(register struct type *tp)
 {
 	switch (tp->tp_fund)	{
 	case CHAR:
diff --git a/lang/cem/cemcom.ansi/conversion.h b/lang/cem/cemcom.ansi/conversion.h
new file mode 100644
index 000000000..25756a94d
--- /dev/null
+++ b/lang/cem/cemcom.ansi/conversion.h
@@ -0,0 +1,15 @@
+/*  Copyright (c) 2019 ACK Project.
+ *  See the copyright notice in the ACK home directory, 
+ *  in the file "Copyright".
+ *
+ *  Created on: 2019-02-06
+ *  
+ */
+#ifndef CONVERSION_H_
+#define CONVERSION_H_
+
+struct type;
+
+void conversion(register struct type *from_type, register struct type *to_type);
+
+#endif /* CONVERSION_H_ */
diff --git a/lang/cem/cemcom.ansi/cstoper.c b/lang/cem/cemcom.ansi/cstoper.c
index a63103ba3..774e356d6 100644
--- a/lang/cem/cemcom.ansi/cstoper.c
+++ b/lang/cem/cemcom.ansi/cstoper.c
@@ -6,6 +6,7 @@
 /*	C O N S T A N T   E X P R E S S I O N   H A N D L I N G		*/
 
 #include	<assert.h>
+#include    "cstoper.h"
 #include    "parameters.h"
 #include	<flt_arith.h>
 #include	"arith.h"
@@ -14,6 +15,7 @@
 #include	"expr.h"
 #include	"sizes.h"
 #include	"Lpars.h"
+#include    "error.h"
 
 /* full_mask[1] == 0XFF, full_mask[2] == 0XFFFF, .. */
 arith full_mask[MAXSIZE + 1];
@@ -23,8 +25,7 @@ arith max_unsigned;	/* maximum unsigned on target machine	*/
 #endif /* NOCROSS */
 extern int ResultKnown;
 
-cstbin(expp, oper, expr)
-	register struct expr **expp, *expr;
+void cstbin(register struct expr **expp, int oper, register struct expr *expr)
 {
 	/*	The operation oper is performed on the constant
 		expressions *expp(ld) and expr(ct), and the result restored in
@@ -134,8 +135,7 @@ cstbin(expp, oper, expr)
 	free_expression(expr);
 }
 
-cut_size(expr)
-	register struct expr *expr;
+void cut_size(register struct expr *expr)
 {
 	/*	The constant value of the expression expr is made to
 		conform to the size of the type of the expression.
@@ -170,7 +170,7 @@ cut_size(expr)
 	expr->VL_VALUE = o1;
 }
 
-init_cst()
+void init_cst(void)
 {
 	register int i = 0;
 	register arith bt = (arith)0;
diff --git a/lang/cem/cemcom.ansi/cstoper.h b/lang/cem/cemcom.ansi/cstoper.h
new file mode 100644
index 000000000..4d0d971f1
--- /dev/null
+++ b/lang/cem/cemcom.ansi/cstoper.h
@@ -0,0 +1,17 @@
+/*  Copyright (c) 2019 ACK Project.
+ *  See the copyright notice in the ACK home directory, 
+ *  in the file "Copyright".
+ *
+ *  Created on: 2019-02-06
+ *  
+ */
+#ifndef CSTOPER_H_
+#define CSTOPER_H_
+
+struct expr;
+
+void cstbin(register struct expr **expp, int oper, register struct expr *expr);
+void cut_size(register struct expr *expr);
+void init_cst(void);
+
+#endif /* CSTOPER_H_ */
diff --git a/lang/cem/cemcom.ansi/dataflow.c b/lang/cem/cemcom.ansi/dataflow.c
index 6a3fbcf65..cdd7781cf 100644
--- a/lang/cem/cemcom.ansi/dataflow.c
+++ b/lang/cem/cemcom.ansi/dataflow.c
@@ -10,26 +10,26 @@
 */
 
 #include	"parameters.h"	/* UF */
+#include    "dataflow.h"
+#include    "print.h"
 
 #ifdef	DATAFLOW
 char *CurrentFunction = 0;
 int NumberOfCalls;
 
-DfaStartFunction(nm)
-	char *nm;
+void DfaStartFunction(char* nm)
 {
 	CurrentFunction = nm;
 	NumberOfCalls = 0;
 }
 
-DfaEndFunction()
+void DfaEndFunction(void)
 {
 	if (NumberOfCalls == 0)
 		print("DFA: %s: --none--\n", CurrentFunction);
 }
 
-DfaCallFunction(s)
-	char *s;
+void DfaCallFunction(char* s)
 {
 	print("DFA: %s: %s\n", CurrentFunction, s);
 	++NumberOfCalls;
diff --git a/lang/cem/cemcom.ansi/dataflow.h b/lang/cem/cemcom.ansi/dataflow.h
new file mode 100644
index 000000000..e353b9ac8
--- /dev/null
+++ b/lang/cem/cemcom.ansi/dataflow.h
@@ -0,0 +1,19 @@
+/*  Copyright (c) 2019 ACK Project.
+ *  See the copyright notice in the ACK home directory, 
+ *  in the file "Copyright".
+ *
+ *  Created on: 2019-02-06
+ *  
+ */
+#ifndef DATAFLOW_H_
+#define DATAFLOW_H_
+
+#ifdef	DATAFLOW
+
+void DfaStartFunction(char* nm);
+void DfaEndFunction(void);
+void DfaCallFunction(char* s);
+
+#endif
+
+#endif /* DATAFLOW_H_ */
diff --git a/lang/cem/cemcom.ansi/declar.g b/lang/cem/cemcom.ansi/declar.g
index d6119f59d..92adefb5f 100644
--- a/lang/cem/cemcom.ansi/declar.g
+++ b/lang/cem/cemcom.ansi/declar.g
@@ -1,764 +1,768 @@
-/*
- * (c) copyright 1987 by the Vrije Universiteit, Amsterdam, The Netherlands.
- * See the copyright notice in the ACK home directory, in the file "Copyright".
- */
-/* $Id$ */
-/*	DECLARATION SYNTAX PARSER	*/
-
-{
-#include	"parameters.h"
-#include	<alloc.h>
-#include	<flt_arith.h>
-#include    "idf.h"
-#include	"arith.h"
-#include	"LLlex.h"
-#include	"label.h"
-#include	"code.h"
-#include	"type.h"
-#include	"proto.h"
-#include	"struct.h"
-#include	"field.h"
-#include	"decspecs.h"
-#include	"def.h"
-#include	"declar.h"
-#include	"label.h"
-#include	"expr.h"
-#include	"sizes.h"
-#include	"level.h"
-#ifdef	LINT
-#include	"l_lint.h"
-#endif	/* LINT */
-
-extern char	options[];
-}
-
-/* 3.5 */
-declaration
-	{struct decspecs Ds;}
-:
-	{Ds = null_decspecs;}
-	decl_specifiers(&Ds)
-	init_declarator_list(&Ds)?
-	';'
-;
-
-/*	A `decl_specifiers' describes a sequence of a storage_class_specifier,
-	an unsigned_specifier, a size_specifier and a simple type_specifier,
-	which may occur in arbitrary order and each of which may be absent;
-	at least one of them must be present, however, since the totally
-	empty case has already be dealt with in `external_definition'.
-	This means that something like:
-		unsigned extern int short xx;
-	is perfectly legal C.
-	
-	On top of that, multiple occurrences of storage_class_specifiers,
-	unsigned_specifiers and size_specifiers are errors, but a second
-	type_specifier should end the decl_specifiers and be treated as
-	the name to be declared.
-	Such a language is not easily expressed in a grammar; enumeration
-	of the permutations is unattractive. We solve the problem by
-	having a regular grammar for the "soft" items, handling the single
-	occurrence of the type_specifier in the grammar (we have no choice),
-	collecting all data in a `struct decspecs' and turning that data
-	structure into what we want.
-	
-	The existence of declarations like
-		short typedef yepp;
-	makes all hope of writing a specific grammar for typedefs illusory.
-*/
-/*      Accept a single declaration specifier.  Then accept zero or more
-	declaration specifiers.  There can be a conflict on both
-	TYPE_IDENTIFIER and IDENTIFIER.
-	The following rule is used:
-	When we see a TYPE_IDENTIFIER, we accept it if no type-specifier was
-	given, and it is not directly followed by an identifier.  If a
-	type-specifier was given, it is taken as the identifier being
-	declared.  If it is followed by an identifier, we assume that an
-	error has been  made, (e.g. unsigned typedeffed_int x;) and that
-	this will be detected later on.
-	When we see an IDENTIFIER, directly followed by another IDENTIFIER,
-	we assume that a typing mistake has been made, and we accept it as
-	an erroneous type-identifier.
-*/
-
-decl_specifiers	/* non-empty */ (register struct decspecs *ds;)
-	/*	Reads a non-empty decl_specifiers and fills the struct
-		decspecs *ds.
-	*/
-:
-	single_decl_specifier(ds)
-	[ %while(  (DOT==TYPE_IDENTIFIER
-			&& ds->ds_size == 0
-			&& ds->ds_unsigned == 0
-			&& ds->ds_type == (struct type *)0)
-		    || AHEAD == IDENTIFIER)	/* always an error */
-		single_decl_specifier(ds)
-	]*
-	{do_decspecs(ds);}
-;
-
-single_decl_specifier /* non_empty */ (register struct decspecs *ds;)
-:
-	[ AUTO | STATIC | EXTERN | TYPEDEF | REGISTER ]
-	{	if (ds->ds_sc_given)
-			error("repeated storage class specifier");
-		ds->ds_sc_given = 1;
-		ds->ds_sc = DOT;
-	}
-|
-	VOLATILE
-	{	if (ds->ds_typequal & TQ_VOLATILE)
-			error("repeated type qualifier");
-		ds->ds_typequal |= TQ_VOLATILE;
-	}
-|
-	CONST
-	{	if (ds->ds_typequal & TQ_CONST)
-			error("repeated type qualifier");
-		ds->ds_typequal |= TQ_CONST;
-	}
-|
-	[ SHORT | LONG ]
-	{	if (ds->ds_size)
-			error("repeated size specifier");
-		ds->ds_size = DOT;
-	}
-|
-	[ SIGNED | UNSIGNED ]
-	{	if (ds->ds_unsigned != 0)
-			error("repeated sign specifier");
-		ds->ds_unsigned = DOT;
-	}
-|
-	[ VOID | CHAR | INT | FLOAT | DOUBLE ]
-	{
-		idf2type(dot.tk_idf, &ds->ds_type);
-		ds->ds_typedef = 0;
-	}
-|
-	%default TYPE_IDENTIFIER
-	{
-		idf2type(dot.tk_idf, &ds->ds_type);
-		ds->ds_typedef = 1;
-	}
-|
-	%erroneous
-	IDENTIFIER
-	{
-		error("%s is not a type identifier", dot.tk_idf->id_text);
-		ds->ds_type = error_type;
-		if (dot.tk_idf->id_def) {
-			dot.tk_idf->id_def->df_type = error_type;
-			dot.tk_idf->id_def->df_sc = TYPEDEF;
-		}
-	}
-|
-	%illegal
-	IDENTIFIER
-|
-	struct_or_union_specifier(&ds->ds_type)
-|
-	enum_specifier(&ds->ds_type)
-;
-
-/* 3.5.2 */
-type_specifier(struct type **tpp;)
-	/*	Used in struct/union declarations and in casts; only the
-		type is relevant.
-	*/
-	{struct decspecs Ds; Ds = null_decspecs;}
-:
-	decl_specifiers(&Ds)
-	{
-		if (Ds.ds_sc_given)
-			error("storage class ignored");
-		if (Ds.ds_sc == REGISTER)
-			error("register ignored");
-	}
-	{*tpp = Ds.ds_type;}
-;
-
-/* 3.5 */
-init_declarator_list(struct decspecs *ds;):
-	init_declarator(ds)
-	[ ',' init_declarator(ds) ]*
-;
-
-init_declarator(register struct decspecs *ds;)
-	{
-		struct declarator Dc;
-	}
-:
-	{
-		Dc = null_declarator;
-	}
-[
-	declarator(&Dc)
-	{
-		reject_params(&Dc);
-		declare_idf(ds, &Dc, level);
-#ifdef	LINT
-		lint_declare_idf(Dc.dc_idf, ds->ds_sc);
-#endif	/* LINT */
-	}
-	[
-		initializer(Dc.dc_idf, ds->ds_sc)
-	|
-		{ code_declaration(Dc.dc_idf, (struct expr *) 0, level, ds->ds_sc); }
-	]
-]
-	{
-#ifdef	LINT
-		add_auto(Dc.dc_idf);
-#endif	/* LINT */
-		remove_declarator(&Dc);
-	}
-;
-
-/* 3.5.7: initializer */
-initializer(struct idf *idf; int sc;)
-	{
-		struct expr *expr = (struct expr *) 0;
-		int fund = idf->id_def->df_type->tp_fund;
-		int autoagg = (level >= L_LOCAL
-				&& sc != STATIC
-				&& ( fund == STRUCT
-				    || fund == UNION
-				    || fund == ARRAY));
-		int globalflag = level == L_GLOBAL
-				|| (level >= L_LOCAL && sc == STATIC);
-	}
-:
-	{	if (idf->id_def->df_type->tp_fund == FUNCTION)	{
-			error("illegal initialization of function");
-			idf->id_def->df_type->tp_fund = ERRONEOUS;
-		}
-		if (level == L_FORMAL2)
-			error("illegal initialization of formal parameter");
-	}
-	'='
-	{
-		if (AHEAD != '{' && AHEAD != STRING ) autoagg = 0;
-#ifdef	LINT
-		lint_statement();
-#endif	/* LINT */
-		if (globalflag) {
-			struct expr ex;
-			code_declaration(idf, &ex, level, sc);
-		}
-		else if (autoagg)
-			loc_init((struct expr *) 0, idf);
-	}
-	initial_value((globalflag || autoagg) ?
-				&(idf->id_def->df_type)
-				: (struct type **)0,
-			&expr)
-	{	if (! globalflag) {
-			if (idf->id_def->df_type->tp_fund == FUNCTION)	{
-				free_expression(expr);
-				expr = 0;
-			}
-#ifdef	DEBUG
-			print_expr("initializer-expression", expr);
-#endif	/* DEBUG */
-#ifdef	LINT
-			change_state(idf, SET);
-#endif	/* LINT */
-#ifdef	DBSYMTAB
-			if (options['g'] && level >= L_LOCAL && expr) {
-				db_line(expr->ex_file, (unsigned) expr->ex_line);
-			}
-#endif	/* DBSYMTAB */
-			if (autoagg)
-				loc_init((struct expr *) 0, idf);
-			else	code_declaration(idf, expr, level, sc);
-		}
-#ifdef	DBSYMTAB
-		if (options['g'] && globalflag) {
-			stb_string(idf->id_def, sc, idf->id_text);
-		}
-#endif	/* DBSYMTAB */
-		idf_initialized(idf);
-	}
-;
-
-/*
-	Functions yielding pointers to functions must be declared as, e.g.,
-		int (*hehe(par1, par2))() char *par1, *par2;	{}
-	Since the function heading is read as a normal declarator,
-	we just include the (formal) parameter list in the declarator
-	description list dc.
-*/
-/* 3.5.4 */
-declarator(register struct declarator *dc;)
-	{	struct formal *fm = NO_PARAMS;
-		struct proto *pl = NO_PROTO;
-		arith count;
-		int qual;
-	}
-:
-	primary_declarator(dc)
-	[/*%while(1)*/
-		'('
-		[ %if (DOT != IDENTIFIER)
-			parameter_type_list(&pl)
-		|
-			formal_list(&fm)
-		|
-			/* empty */
-		]
-		')'
-		{	add_decl_unary(dc, FUNCTION, 0, (arith)0, fm, pl);
-			fm = NO_PARAMS;
-		}
-	|
-		arrayer(&count)
-		{add_decl_unary(dc, ARRAY, 0, count, NO_PARAMS, NO_PROTO);}
-	]*
-|
-	pointer(&qual) declarator(dc)
-	{add_decl_unary(dc, POINTER, qual, (arith)0, NO_PARAMS, NO_PROTO);}
-;
-
-primary_declarator(register struct declarator *dc;) :
-	identifier(&dc->dc_idf)
-|
-	'(' declarator(dc) ')'
-;
-
-arrayer(arith *sizep;)
-	{ struct expr *expr; }
-:
-	'['
-		{ *sizep = (arith)-1; }
-		[
-			constant_expression(&expr)
-			{
-				check_array_subscript(expr);
-				*sizep = expr->VL_VALUE;
-				free_expression(expr);
-			}
-		]?
-	']'
-;
-
-formal_list (struct formal **fmp;)
-:
-	formal(fmp) [ %persistent ',' formal(fmp) ]*
-;
-
-formal(struct formal **fmp;)
-	{struct idf *idf;	}
-:
-	identifier(&idf)
-	{
-		register struct formal *new = new_formal();
-		
-		new->fm_idf = idf;
-		new->next = *fmp;
-		*fmp = new;
-		if (idf->id_def && idf->id_def->df_sc == TYPEDEF) {
-			error("typedef name %s may not be redeclared as a parameter", idf->id_text);
-		}
-	}
-;
-
-/* Change 2 */
-enum_specifier(register struct type **tpp;)
-	{
-		struct idf *idf;
-		arith l = (arith)0;
-	}
-:
-	{if (*tpp) error("multiple types in declaration");}
-	ENUM
-	[
-		{declare_struct(ENUM, (struct idf *) 0, tpp);}
-		enumerator_pack(*tpp, &l)
-	|
-		identifier(&idf)
-		[
-			{declare_struct(ENUM, idf, tpp);}
-			enumerator_pack(*tpp, &l)
-			{
-#ifdef DBSYMTAB
-				if (options['g']) {
-					stb_tag(idf->id_tag, idf->id_text);
-				}
-#endif /*DBSYMTAB */
-			}
-		|
-			{apply_struct(ENUM, idf, tpp);}
-			/* empty */
-		]
-	]
-;
-
-enumerator_pack(register struct type *tp; arith *lp;) :
-	'{'
-	enumerator(tp, lp)
-	[%while (AHEAD != '}')
-		','
-		enumerator(tp, lp)
-	]*
-	[
-		','	{warning("unexpected trailing comma in enumerator pack");}
-	]?
-	'}'
-	{tp->tp_size = int_size;}
-	/*	fancy implementations that put small enums in 1 byte
-		or so should start here.
-	*/
-;
-
-enumerator(struct type *tp; arith *lp;)
-	{
-		struct idf *idf;
-		struct expr *expr;
-	}
-:
-	identifier(&idf)
-	[
-		'='
-		constant_expression(&expr)
-		{
-			*lp = expr->VL_VALUE;
-			free_expression(expr);
-		}
-	]?
-	{declare_enum(tp, idf, (*lp)++);}
-;
-
-/* 8.5 */
-struct_or_union_specifier(register struct type **tpp;)
-	{
-		int fund;
-		struct idf *idfX;
-		register struct idf *idf;
-	}
-:
-	{if (*tpp) error("multiple types in declaration");}
-	[ STRUCT | UNION ]
-	{fund = DOT;}
-	[
-		{
-			declare_struct(fund, (struct idf *)0, tpp);
-		}
-		struct_declaration_pack(*tpp)
-	|
-		identifier(&idfX)	{ idf = idfX; }
-		[
-			{
-				declare_struct(fund, idf, tpp);
-				(idf->id_tag->tg_busy)++;
-			}
-			struct_declaration_pack(*tpp)
-			{
-				(idf->id_tag->tg_busy)--;
-#ifdef DBSYMTAB
-				if (options['g']) {
-					stb_tag(idf->id_tag, idf->id_text);
-				}
-#endif /*DBSYMTAB */
-			}
-		|
-			{
-			  /* a ';' means an empty declaration (probably)
-			   * this means that we have to declare a new
-			   * structure. (yegh)
-			   */
-			  if (DOT == ';' &&
-			      ( !idf->id_tag ||
-				 idf->id_tag->tg_level != level ||
-				 idf->id_tag->tg_type->tp_size < 0
-			     )) declare_struct(fund, idf, tpp);
-			  else apply_struct(fund, idf, tpp);
-			}
-			/* empty */
-		]
-	]
-;
-
-struct_declaration_pack(register struct type *stp;)
-	{
-		struct sdef **sdefp = &stp->tp_sdef;
-		arith size = (arith)0;
-	}
-:
-	/*	The size is only filled in after the whole struct has
-		been read, to prevent recursive definitions.
-	*/
-	'{'
-	struct_declaration(stp, &sdefp, &size)+
-	'}'
-	{stp->tp_size = align(size, stp->tp_align);
-	 completed(stp);
-	}
-;
-
-struct_declaration(struct type *stp; struct sdef ***sdefpp; arith *szp;)
-	{struct type *tp;}
-:
-	type_specifier(&tp) struct_declarator_list(tp, stp, sdefpp, szp) ';'
-;
-
-struct_declarator_list(struct type *tp; struct type *stp;
-			struct sdef ***sdefpp; arith *szp;)
-:
-	struct_declarator(tp, stp, sdefpp, szp)
-	[ ',' struct_declarator(tp, stp, sdefpp, szp) ]*
-;
-
-struct_declarator(struct type *tp; struct type *stp;
-			struct sdef ***sdefpp; arith *szp;)
-	{
-		struct declarator Dc;
-		struct field *fd = 0;
-	}
-:
-	{
-		Dc = null_declarator;
-	}
-[
-	declarator(&Dc)
-	{reject_params(&Dc);}
-	bit_expression(&fd)?
-|
-	{Dc.dc_idf = gen_idf();}
-	bit_expression(&fd)
-]
-	{add_sel(stp, declare_type(tp, &Dc), Dc.dc_idf, sdefpp, szp, fd);}
-	{remove_declarator(&Dc);}
-;
-
-bit_expression(struct field **fd;)
-	{ struct expr *expr; }
-:
-	{
-		*fd = new_field();
-	}
-	':'
-	constant_expression(&expr)
-	{
-		(*fd)->fd_width = expr->VL_VALUE;
-		free_expression(expr);
-#ifdef NOBITFIELD
-		error("bitfields are not implemented");
-#endif /* NOBITFIELD */
-	}
-;
-
-/* 8.7 */
-cast(struct type **tpp;)
-	{struct declarator Dc;}
-:
-	{Dc = null_declarator;}
-	'('
-	type_specifier(tpp)
-	abstract_declarator(&Dc)
-	')'
-	{*tpp = declare_type(*tpp, &Dc);}
-	{remove_declarator(&Dc);}
-;
-
-/*	This code is an abject copy of that of 'declarator', for lack of
-	a two-level grammar.
-*/
-abstract_declarator(register struct declarator *dc;)
-	{	struct proto *pl = NO_PROTO;
-		arith count;
-		int qual;
-	}
-:
-	primary_abstract_declarator(dc)
-	[
-		'('
-		[
-			parameter_type_list(&pl)
-		|
-			/* empty */
-		]
-		')'
-		{add_decl_unary(dc, FUNCTION, 0, (arith)0, NO_PARAMS, pl);
-		 if (pl) remove_proto_idfs(pl);
-		}
-	|
-		arrayer(&count)
-		{add_decl_unary(dc, ARRAY, 0, count, NO_PARAMS, NO_PROTO);}
-	]*
-|
-	pointer(&qual) abstract_declarator(dc)
-	{add_decl_unary(dc, POINTER, qual, (arith)0, NO_PARAMS, NO_PROTO);}
-;
-
-%first first_of_parameter_type_list, parameter_type_list;
-
-primary_abstract_declarator(struct declarator *dc;)
-:
-[%if (AHEAD == ')' || first_of_parameter_type_list(AHEAD))
-	/* empty */
-|
-	'(' abstract_declarator(dc) ')'
-]
-;
-
-parameter_type_list(struct proto **plp;)
-	{	int save_level; }
-:
-	{	if (level > L_PROTO) {
-			save_level = level;
-			level = L_PROTO;
-		} else level--;
-	}
-	parameter_decl_list(plp)
-	[
-		',' ELLIPSIS
-		{	register struct proto *new = new_proto();
-
-			new->next = *plp;
-			new->pl_flag = PL_ELLIPSIS;
-			*plp = new;
-		}
-
-	]?
-	{	check_for_void(*plp);
-		if (level == L_PROTO)
-			level = save_level;
-		else level++;
-	}
-;
-
-parameter_decl_list(struct proto **plp;)
-:
-	parameter_decl(plp)
-	[ %while (AHEAD != ELLIPSIS)
-	  %persistent
-		',' parameter_decl(plp)
-	]*
-;
-
-parameter_decl(struct proto **plp;)
-	{	register struct proto *new = new_proto();
-		struct declarator Dc;
-		struct decspecs Ds;
-	}
-:
-	{	Dc = null_declarator;
-		Ds = null_decspecs;
-	}
-	decl_specifiers(&Ds)
-	parameter_declarator(&Dc)
-	{	add_proto(new, &Ds, &Dc, level);
-		new->next = *plp;
-		*plp = new;
-		remove_declarator(&Dc);
-	}
-;
-
-/*	This is weird. Due to the LR structure of the ANSI C grammar
-	we have to duplicate the actions of 'declarator' and
-	'abstract_declarator'. Calling these separately, as in
-
-	parameter_decl:
-		decl_specifiers
-		[
-			declarator
-		|
-			abstract_declarator
-		]
-
-
-	gives us a conflict on the terminals '(' and '*'. E.i. on
-	some input, it is impossible to decide which rule we take.
-	Combining the two declarators into one common declarator
-	is out of the question, since this results in an empty
-	string for the non-terminal 'declarator'.
-	So we combine the two only for the use of parameter_decl,
-	since this is the only place where they don't give
-	conflicts. However, this makes the grammar messy.
-*/
-parameter_declarator(register struct declarator *dc;)
-	{	struct formal *fm = NO_PARAMS;
-		struct proto *pl = NO_PROTO;
-		arith count;
-		int qual;
-	}
-:
-	primary_parameter_declarator(dc)
-	[
-		'('
-		[ %if (DOT != IDENTIFIER)
-			parameter_type_list(&pl)
-		|
-			formal_list(&fm)
-		|
-			/* empty */
-		]
-		')'
-		{   add_decl_unary(dc, FUNCTION, 0, (arith)0, fm, pl);
-		    reject_params(dc);
-		}
-	|
-		arrayer(&count)
-		{add_decl_unary(dc, ARRAY, 0, count, NO_PARAMS, NO_PROTO);}
-	]*
-|
-	pointer(&qual) parameter_declarator(dc)
-	{add_decl_unary(dc, POINTER, qual, (arith)0, NO_PARAMS, NO_PROTO);}
-;
-
-primary_parameter_declarator(register struct declarator *dc;)
-:
-[%if (AHEAD == ')' || first_of_parameter_type_list(AHEAD)
-				    && (AHEAD != IDENTIFIER))
-	/* empty */
-|
-	identifier(&dc->dc_idf)
-|
-	'(' parameter_declarator(dc) ')'
-]
-;
-
-pointer(int *qual;)
-:
-	'*' type_qualifier_list(qual)
-;
-
-/*	Type qualifiers may come in three flavours:
-	volatile, const, const volatile.
-	These all have different semantic properties:
-
-	volatile:
-		means that the object can be modified
-		without prior knowledge of the implementation.
-
-	const:
-		means that the object can not be modified; thus
-		it's illegal to use this as a l-value.
-
-	const volatile:
-		means  that the object can be modified without
-		prior knowledge of the implementation, but may
-		not be used as a l-value.
-*/
-/* 3.5.4 */
-type_qualifier_list(int *qual;)
-:
-	{ *qual = 0; }
-	[
-		VOLATILE
-		{	if (*qual & TQ_VOLATILE)
-				error("repeated type qualifier");
-			*qual |= TQ_VOLATILE;
-		}
-	|
-		CONST
-		{	if (*qual & TQ_CONST)
-				error("repeated type qualifier");
-			*qual |= TQ_CONST;
-		}
-	]*
-;
-
-empty:
-;
+/*
+ * (c) copyright 1987 by the Vrije Universiteit, Amsterdam, The Netherlands.
+ * See the copyright notice in the ACK home directory, in the file "Copyright".
+ */
+/* $Id$ */
+/*	DECLARATION SYNTAX PARSER	*/
+
+{
+#include	"parameters.h"
+#include	<alloc.h>
+#include	<flt_arith.h>
+#include    "idf.h"
+#include	"arith.h"
+#include	"LLlex.h"
+#include	"label.h"
+#include	"code.h"
+#include	"type.h"
+#include	"proto.h"
+#include	"struct.h"
+#include	"field.h"
+#include	"decspecs.h"
+#include    "declarator.h"
+#include	"def.h"
+#include	"declar.h"
+#include	"label.h"
+#include	"expr.h"
+#include	"sizes.h"
+#include	"level.h"
+#include    "error.h"
+#include    "stab.h"
+
+#ifdef	LINT
+#include	"l_lint.h"
+#endif	/* LINT */
+
+extern char	options[];
+}
+
+/* 3.5 */
+declaration
+	{struct decspecs Ds;}
+:
+	{Ds = null_decspecs;}
+	decl_specifiers(&Ds)
+	init_declarator_list(&Ds)?
+	';'
+;
+
+/*	A `decl_specifiers' describes a sequence of a storage_class_specifier,
+	an unsigned_specifier, a size_specifier and a simple type_specifier,
+	which may occur in arbitrary order and each of which may be absent;
+	at least one of them must be present, however, since the totally
+	empty case has already be dealt with in `external_definition'.
+	This means that something like:
+		unsigned extern int short xx;
+	is perfectly legal C.
+	
+	On top of that, multiple occurrences of storage_class_specifiers,
+	unsigned_specifiers and size_specifiers are errors, but a second
+	type_specifier should end the decl_specifiers and be treated as
+	the name to be declared.
+	Such a language is not easily expressed in a grammar; enumeration
+	of the permutations is unattractive. We solve the problem by
+	having a regular grammar for the "soft" items, handling the single
+	occurrence of the type_specifier in the grammar (we have no choice),
+	collecting all data in a `struct decspecs' and turning that data
+	structure into what we want.
+	
+	The existence of declarations like
+		short typedef yepp;
+	makes all hope of writing a specific grammar for typedefs illusory.
+*/
+/*      Accept a single declaration specifier.  Then accept zero or more
+	declaration specifiers.  There can be a conflict on both
+	TYPE_IDENTIFIER and IDENTIFIER.
+	The following rule is used:
+	When we see a TYPE_IDENTIFIER, we accept it if no type-specifier was
+	given, and it is not directly followed by an identifier.  If a
+	type-specifier was given, it is taken as the identifier being
+	declared.  If it is followed by an identifier, we assume that an
+	error has been  made, (e.g. unsigned typedeffed_int x;) and that
+	this will be detected later on.
+	When we see an IDENTIFIER, directly followed by another IDENTIFIER,
+	we assume that a typing mistake has been made, and we accept it as
+	an erroneous type-identifier.
+*/
+
+decl_specifiers	/* non-empty */ (register struct decspecs *ds;)
+	/*	Reads a non-empty decl_specifiers and fills the struct
+		decspecs *ds.
+	*/
+:
+	single_decl_specifier(ds)
+	[ %while(  (DOT==TYPE_IDENTIFIER
+			&& ds->ds_size == 0
+			&& ds->ds_unsigned == 0
+			&& ds->ds_type == (struct type *)0)
+		    || AHEAD == IDENTIFIER)	/* always an error */
+		single_decl_specifier(ds)
+	]*
+	{do_decspecs(ds);}
+;
+
+single_decl_specifier /* non_empty */ (register struct decspecs *ds;)
+:
+	[ AUTO | STATIC | EXTERN | TYPEDEF | REGISTER ]
+	{	if (ds->ds_sc_given)
+			error("repeated storage class specifier");
+		ds->ds_sc_given = 1;
+		ds->ds_sc = DOT;
+	}
+|
+	VOLATILE
+	{	if (ds->ds_typequal & TQ_VOLATILE)
+			error("repeated type qualifier");
+		ds->ds_typequal |= TQ_VOLATILE;
+	}
+|
+	CONST
+	{	if (ds->ds_typequal & TQ_CONST)
+			error("repeated type qualifier");
+		ds->ds_typequal |= TQ_CONST;
+	}
+|
+	[ SHORT | LONG ]
+	{	if (ds->ds_size)
+			error("repeated size specifier");
+		ds->ds_size = DOT;
+	}
+|
+	[ SIGNED | UNSIGNED ]
+	{	if (ds->ds_unsigned != 0)
+			error("repeated sign specifier");
+		ds->ds_unsigned = DOT;
+	}
+|
+	[ VOID | CHAR | INT | FLOAT | DOUBLE ]
+	{
+		idf2type(dot.tk_idf, &ds->ds_type);
+		ds->ds_typedef = 0;
+	}
+|
+	%default TYPE_IDENTIFIER
+	{
+		idf2type(dot.tk_idf, &ds->ds_type);
+		ds->ds_typedef = 1;
+	}
+|
+	%erroneous
+	IDENTIFIER
+	{
+		error("%s is not a type identifier", dot.tk_idf->id_text);
+		ds->ds_type = error_type;
+		if (dot.tk_idf->id_def) {
+			dot.tk_idf->id_def->df_type = error_type;
+			dot.tk_idf->id_def->df_sc = TYPEDEF;
+		}
+	}
+|
+	%illegal
+	IDENTIFIER
+|
+	struct_or_union_specifier(&ds->ds_type)
+|
+	enum_specifier(&ds->ds_type)
+;
+
+/* 3.5.2 */
+type_specifier(struct type **tpp;)
+	/*	Used in struct/union declarations and in casts; only the
+		type is relevant.
+	*/
+	{struct decspecs Ds; Ds = null_decspecs;}
+:
+	decl_specifiers(&Ds)
+	{
+		if (Ds.ds_sc_given)
+			error("storage class ignored");
+		if (Ds.ds_sc == REGISTER)
+			error("register ignored");
+	}
+	{*tpp = Ds.ds_type;}
+;
+
+/* 3.5 */
+init_declarator_list(struct decspecs *ds;):
+	init_declarator(ds)
+	[ ',' init_declarator(ds) ]*
+;
+
+init_declarator(register struct decspecs *ds;)
+	{
+		struct declarator Dc;
+	}
+:
+	{
+		Dc = null_declarator;
+	}
+[
+	declarator(&Dc)
+	{
+		reject_params(&Dc);
+		declare_idf(ds, &Dc, level);
+#ifdef	LINT
+		lint_declare_idf(Dc.dc_idf, ds->ds_sc);
+#endif	/* LINT */
+	}
+	[
+		initializer(Dc.dc_idf, ds->ds_sc)
+	|
+		{ code_declaration(Dc.dc_idf, (struct expr *) 0, level, ds->ds_sc); }
+	]
+]
+	{
+#ifdef	LINT
+		add_auto(Dc.dc_idf);
+#endif	/* LINT */
+		remove_declarator(&Dc);
+	}
+;
+
+/* 3.5.7: initializer */
+initializer(struct idf *idf; int sc;)
+	{
+		struct expr *expr = (struct expr *) 0;
+		int fund = idf->id_def->df_type->tp_fund;
+		int autoagg = (level >= L_LOCAL
+				&& sc != STATIC
+				&& ( fund == STRUCT
+				    || fund == UNION
+				    || fund == ARRAY));
+		int globalflag = level == L_GLOBAL
+				|| (level >= L_LOCAL && sc == STATIC);
+	}
+:
+	{	if (idf->id_def->df_type->tp_fund == FUNCTION)	{
+			error("illegal initialization of function");
+			idf->id_def->df_type->tp_fund = ERRONEOUS;
+		}
+		if (level == L_FORMAL2)
+			error("illegal initialization of formal parameter");
+	}
+	'='
+	{
+		if (AHEAD != '{' && AHEAD != STRING ) autoagg = 0;
+#ifdef	LINT
+		lint_statement();
+#endif	/* LINT */
+		if (globalflag) {
+			struct expr ex;
+			code_declaration(idf, &ex, level, sc);
+		}
+		else if (autoagg)
+			loc_init((struct expr *) 0, idf);
+	}
+	initial_value((globalflag || autoagg) ?
+				&(idf->id_def->df_type)
+				: (struct type **)0,
+			&expr)
+	{	if (! globalflag) {
+			if (idf->id_def->df_type->tp_fund == FUNCTION)	{
+				free_expression(expr);
+				expr = 0;
+			}
+#ifdef	DEBUG
+			print_expr("initializer-expression", expr);
+#endif	/* DEBUG */
+#ifdef	LINT
+			change_state(idf, SET);
+#endif	/* LINT */
+#ifdef	DBSYMTAB
+			if (options['g'] && level >= L_LOCAL && expr) {
+				db_line(expr->ex_file, (unsigned) expr->ex_line);
+			}
+#endif	/* DBSYMTAB */
+			if (autoagg)
+				loc_init((struct expr *) 0, idf);
+			else	code_declaration(idf, expr, level, sc);
+		}
+#ifdef	DBSYMTAB
+		if (options['g'] && globalflag) {
+			stb_string(idf->id_def, sc, idf->id_text);
+		}
+#endif	/* DBSYMTAB */
+		idf_initialized(idf);
+	}
+;
+
+/*
+	Functions yielding pointers to functions must be declared as, e.g.,
+		int (*hehe(par1, par2))() char *par1, *par2;	{}
+	Since the function heading is read as a normal declarator,
+	we just include the (formal) parameter list in the declarator
+	description list dc.
+*/
+/* 3.5.4 */
+declarator(register struct declarator *dc;)
+	{	struct formal *fm = NO_PARAMS;
+		struct proto *pl = NO_PROTO;
+		arith count;
+		int qual;
+	}
+:
+	primary_declarator(dc)
+	[/*%while(1)*/
+		'('
+		[ %if (DOT != IDENTIFIER)
+			parameter_type_list(&pl)
+		|
+			formal_list(&fm)
+		|
+			/* empty */
+		]
+		')'
+		{	add_decl_unary(dc, FUNCTION, 0, (arith)0, fm, pl);
+			fm = NO_PARAMS;
+		}
+	|
+		arrayer(&count)
+		{add_decl_unary(dc, ARRAY, 0, count, NO_PARAMS, NO_PROTO);}
+	]*
+|
+	pointer(&qual) declarator(dc)
+	{add_decl_unary(dc, POINTER, qual, (arith)0, NO_PARAMS, NO_PROTO);}
+;
+
+primary_declarator(register struct declarator *dc;) :
+	identifier(&dc->dc_idf)
+|
+	'(' declarator(dc) ')'
+;
+
+arrayer(arith *sizep;)
+	{ struct expr *expr; }
+:
+	'['
+		{ *sizep = (arith)-1; }
+		[
+			constant_expression(&expr)
+			{
+				check_array_subscript(expr);
+				*sizep = expr->VL_VALUE;
+				free_expression(expr);
+			}
+		]?
+	']'
+;
+
+formal_list (struct formal **fmp;)
+:
+	formal(fmp) [ %persistent ',' formal(fmp) ]*
+;
+
+formal(struct formal **fmp;)
+	{struct idf *idf;	}
+:
+	identifier(&idf)
+	{
+		register struct formal *new = new_formal();
+		
+		new->fm_idf = idf;
+		new->next = *fmp;
+		*fmp = new;
+		if (idf->id_def && idf->id_def->df_sc == TYPEDEF) {
+			error("typedef name %s may not be redeclared as a parameter", idf->id_text);
+		}
+	}
+;
+
+/* Change 2 */
+enum_specifier(register struct type **tpp;)
+	{
+		struct idf *idf;
+		arith l = (arith)0;
+	}
+:
+	{if (*tpp) error("multiple types in declaration");}
+	ENUM
+	[
+		{declare_struct(ENUM, (struct idf *) 0, tpp);}
+		enumerator_pack(*tpp, &l)
+	|
+		identifier(&idf)
+		[
+			{declare_struct(ENUM, idf, tpp);}
+			enumerator_pack(*tpp, &l)
+			{
+#ifdef DBSYMTAB
+				if (options['g']) {
+					stb_tag(idf->id_tag, idf->id_text);
+				}
+#endif /*DBSYMTAB */
+			}
+		|
+			{apply_struct(ENUM, idf, tpp);}
+			/* empty */
+		]
+	]
+;
+
+enumerator_pack(register struct type *tp; arith *lp;) :
+	'{'
+	enumerator(tp, lp)
+	[%while (AHEAD != '}')
+		','
+		enumerator(tp, lp)
+	]*
+	[
+		','	{warning("unexpected trailing comma in enumerator pack");}
+	]?
+	'}'
+	{tp->tp_size = int_size;}
+	/*	fancy implementations that put small enums in 1 byte
+		or so should start here.
+	*/
+;
+
+enumerator(struct type *tp; arith *lp;)
+	{
+		struct idf *idf;
+		struct expr *expr;
+	}
+:
+	identifier(&idf)
+	[
+		'='
+		constant_expression(&expr)
+		{
+			*lp = expr->VL_VALUE;
+			free_expression(expr);
+		}
+	]?
+	{declare_enum(tp, idf, (*lp)++);}
+;
+
+/* 8.5 */
+struct_or_union_specifier(register struct type **tpp;)
+	{
+		int fund;
+		struct idf *idfX;
+		register struct idf *idf;
+	}
+:
+	{if (*tpp) error("multiple types in declaration");}
+	[ STRUCT | UNION ]
+	{fund = DOT;}
+	[
+		{
+			declare_struct(fund, (struct idf *)0, tpp);
+		}
+		struct_declaration_pack(*tpp)
+	|
+		identifier(&idfX)	{ idf = idfX; }
+		[
+			{
+				declare_struct(fund, idf, tpp);
+				(idf->id_tag->tg_busy)++;
+			}
+			struct_declaration_pack(*tpp)
+			{
+				(idf->id_tag->tg_busy)--;
+#ifdef DBSYMTAB
+				if (options['g']) {
+					stb_tag(idf->id_tag, idf->id_text);
+				}
+#endif /*DBSYMTAB */
+			}
+		|
+			{
+			  /* a ';' means an empty declaration (probably)
+			   * this means that we have to declare a new
+			   * structure. (yegh)
+			   */
+			  if (DOT == ';' &&
+			      ( !idf->id_tag ||
+				 idf->id_tag->tg_level != level ||
+				 idf->id_tag->tg_type->tp_size < 0
+			     )) declare_struct(fund, idf, tpp);
+			  else apply_struct(fund, idf, tpp);
+			}
+			/* empty */
+		]
+	]
+;
+
+struct_declaration_pack(register struct type *stp;)
+	{
+		struct sdef **sdefp = &stp->tp_sdef;
+		arith size = (arith)0;
+	}
+:
+	/*	The size is only filled in after the whole struct has
+		been read, to prevent recursive definitions.
+	*/
+	'{'
+	struct_declaration(stp, &sdefp, &size)+
+	'}'
+	{stp->tp_size = align(size, stp->tp_align);
+	 completed(stp);
+	}
+;
+
+struct_declaration(struct type *stp; struct sdef ***sdefpp; arith *szp;)
+	{struct type *tp;}
+:
+	type_specifier(&tp) struct_declarator_list(tp, stp, sdefpp, szp) ';'
+;
+
+struct_declarator_list(struct type *tp; struct type *stp;
+			struct sdef ***sdefpp; arith *szp;)
+:
+	struct_declarator(tp, stp, sdefpp, szp)
+	[ ',' struct_declarator(tp, stp, sdefpp, szp) ]*
+;
+
+struct_declarator(struct type *tp; struct type *stp;
+			struct sdef ***sdefpp; arith *szp;)
+	{
+		struct declarator Dc;
+		struct field *fd = 0;
+	}
+:
+	{
+		Dc = null_declarator;
+	}
+[
+	declarator(&Dc)
+	{reject_params(&Dc);}
+	bit_expression(&fd)?
+|
+	{Dc.dc_idf = gen_idf();}
+	bit_expression(&fd)
+]
+	{add_sel(stp, declare_type(tp, &Dc), Dc.dc_idf, sdefpp, szp, fd);}
+	{remove_declarator(&Dc);}
+;
+
+bit_expression(struct field **fd;)
+	{ struct expr *expr; }
+:
+	{
+		*fd = new_field();
+	}
+	':'
+	constant_expression(&expr)
+	{
+		(*fd)->fd_width = expr->VL_VALUE;
+		free_expression(expr);
+#ifdef NOBITFIELD
+		error("bitfields are not implemented");
+#endif /* NOBITFIELD */
+	}
+;
+
+/* 8.7 */
+cast(struct type **tpp;)
+	{struct declarator Dc;}
+:
+	{Dc = null_declarator;}
+	'('
+	type_specifier(tpp)
+	abstract_declarator(&Dc)
+	')'
+	{*tpp = declare_type(*tpp, &Dc);}
+	{remove_declarator(&Dc);}
+;
+
+/*	This code is an abject copy of that of 'declarator', for lack of
+	a two-level grammar.
+*/
+abstract_declarator(register struct declarator *dc;)
+	{	struct proto *pl = NO_PROTO;
+		arith count;
+		int qual;
+	}
+:
+	primary_abstract_declarator(dc)
+	[
+		'('
+		[
+			parameter_type_list(&pl)
+		|
+			/* empty */
+		]
+		')'
+		{add_decl_unary(dc, FUNCTION, 0, (arith)0, NO_PARAMS, pl);
+		 if (pl) remove_proto_idfs(pl);
+		}
+	|
+		arrayer(&count)
+		{add_decl_unary(dc, ARRAY, 0, count, NO_PARAMS, NO_PROTO);}
+	]*
+|
+	pointer(&qual) abstract_declarator(dc)
+	{add_decl_unary(dc, POINTER, qual, (arith)0, NO_PARAMS, NO_PROTO);}
+;
+
+%first first_of_parameter_type_list, parameter_type_list;
+
+primary_abstract_declarator(struct declarator *dc;)
+:
+[%if (AHEAD == ')' || first_of_parameter_type_list(AHEAD))
+	/* empty */
+|
+	'(' abstract_declarator(dc) ')'
+]
+;
+
+parameter_type_list(struct proto **plp;)
+	{	int save_level; }
+:
+	{	if (level > L_PROTO) {
+			save_level = level;
+			level = L_PROTO;
+		} else level--;
+	}
+	parameter_decl_list(plp)
+	[
+		',' ELLIPSIS
+		{	register struct proto *new = new_proto();
+
+			new->next = *plp;
+			new->pl_flag = PL_ELLIPSIS;
+			*plp = new;
+		}
+
+	]?
+	{	check_for_void(*plp);
+		if (level == L_PROTO)
+			level = save_level;
+		else level++;
+	}
+;
+
+parameter_decl_list(struct proto **plp;)
+:
+	parameter_decl(plp)
+	[ %while (AHEAD != ELLIPSIS)
+	  %persistent
+		',' parameter_decl(plp)
+	]*
+;
+
+parameter_decl(struct proto **plp;)
+	{	register struct proto *new = new_proto();
+		struct declarator Dc;
+		struct decspecs Ds;
+	}
+:
+	{	Dc = null_declarator;
+		Ds = null_decspecs;
+	}
+	decl_specifiers(&Ds)
+	parameter_declarator(&Dc)
+	{	add_proto(new, &Ds, &Dc, level);
+		new->next = *plp;
+		*plp = new;
+		remove_declarator(&Dc);
+	}
+;
+
+/*	This is weird. Due to the LR structure of the ANSI C grammar
+	we have to duplicate the actions of 'declarator' and
+	'abstract_declarator'. Calling these separately, as in
+
+	parameter_decl:
+		decl_specifiers
+		[
+			declarator
+		|
+			abstract_declarator
+		]
+
+
+	gives us a conflict on the terminals '(' and '*'. E.i. on
+	some input, it is impossible to decide which rule we take.
+	Combining the two declarators into one common declarator
+	is out of the question, since this results in an empty
+	string for the non-terminal 'declarator'.
+	So we combine the two only for the use of parameter_decl,
+	since this is the only place where they don't give
+	conflicts. However, this makes the grammar messy.
+*/
+parameter_declarator(register struct declarator *dc;)
+	{	struct formal *fm = NO_PARAMS;
+		struct proto *pl = NO_PROTO;
+		arith count;
+		int qual;
+	}
+:
+	primary_parameter_declarator(dc)
+	[
+		'('
+		[ %if (DOT != IDENTIFIER)
+			parameter_type_list(&pl)
+		|
+			formal_list(&fm)
+		|
+			/* empty */
+		]
+		')'
+		{   add_decl_unary(dc, FUNCTION, 0, (arith)0, fm, pl);
+		    reject_params(dc);
+		}
+	|
+		arrayer(&count)
+		{add_decl_unary(dc, ARRAY, 0, count, NO_PARAMS, NO_PROTO);}
+	]*
+|
+	pointer(&qual) parameter_declarator(dc)
+	{add_decl_unary(dc, POINTER, qual, (arith)0, NO_PARAMS, NO_PROTO);}
+;
+
+primary_parameter_declarator(register struct declarator *dc;)
+:
+[%if (AHEAD == ')' || first_of_parameter_type_list(AHEAD)
+				    && (AHEAD != IDENTIFIER))
+	/* empty */
+|
+	identifier(&dc->dc_idf)
+|
+	'(' parameter_declarator(dc) ')'
+]
+;
+
+pointer(int *qual;)
+:
+	'*' type_qualifier_list(qual)
+;
+
+/*	Type qualifiers may come in three flavours:
+	volatile, const, const volatile.
+	These all have different semantic properties:
+
+	volatile:
+		means that the object can be modified
+		without prior knowledge of the implementation.
+
+	const:
+		means that the object can not be modified; thus
+		it's illegal to use this as a l-value.
+
+	const volatile:
+		means  that the object can be modified without
+		prior knowledge of the implementation, but may
+		not be used as a l-value.
+*/
+/* 3.5.4 */
+type_qualifier_list(int *qual;)
+:
+	{ *qual = 0; }
+	[
+		VOLATILE
+		{	if (*qual & TQ_VOLATILE)
+				error("repeated type qualifier");
+			*qual |= TQ_VOLATILE;
+		}
+	|
+		CONST
+		{	if (*qual & TQ_CONST)
+				error("repeated type qualifier");
+			*qual |= TQ_CONST;
+		}
+	]*
+;
+
+empty:
+;
diff --git a/lang/cem/cemcom.ansi/declar.str b/lang/cem/cemcom.ansi/declar.str
index 884bd97e7..ebe1869bd 100644
--- a/lang/cem/cemcom.ansi/declar.str
+++ b/lang/cem/cemcom.ansi/declar.str
@@ -2,6 +2,9 @@
  * (c) copyright 1987 by the Vrije Universiteit, Amsterdam, The Netherlands.
  * See the copyright notice in the ACK home directory, in the file "Copyright".
  */
+ #ifndef DECLAR_H_
+ #define DECLAR_H_
+ 
 /* $Id$ */
 /* DEFINITION OF DECLARATOR DESCRIPTORS */
 
@@ -39,3 +42,5 @@ struct decl_unary	{
 
 extern struct type *declare_type();
 extern struct declarator null_declarator;
+
+#endif
diff --git a/lang/cem/cemcom.ansi/declarator.c b/lang/cem/cemcom.ansi/declarator.c
index 212b8aeb1..2795bda86 100644
--- a/lang/cem/cemcom.ansi/declarator.c
+++ b/lang/cem/cemcom.ansi/declarator.c
@@ -6,6 +6,7 @@
 /*	D E C L A R A T O R   M A N I P U L A T I O N		*/
 
 #include	"parameters.h"
+#include    "declarator.h"
 #include	<alloc.h>
 #include	<flt_arith.h>
 #include	"arith.h"
@@ -14,18 +15,20 @@
 #include	"Lpars.h"
 #include	"declar.h"
 #include	"def.h"
+#include    "idf.h"
 #include	"label.h"
 #include	"expr.h"
 #include	"sizes.h"
 #include	"level.h"
+#include    "error.h"
 
 extern char options[];
 struct declarator null_declarator;
 
 struct type *
-declare_type(tp, dc)
-	struct type *tp;
-	struct declarator *dc;
+declare_type(
+	struct type *tp,
+	struct declarator *dc)
 {
 	/*	Applies the decl_unary list starting at dc->dc_decl_unary
 		to the type tp and returns the result.
@@ -43,12 +46,7 @@ declare_type(tp, dc)
 	return tp;
 }
 
-add_decl_unary(dc, fund, qual,  count, fm, pl)
-	register struct declarator *dc;
-	int qual;
-	arith count;
-	struct formal *fm;
-	struct proto *pl;
+void add_decl_unary(register struct declarator *dc, int fund, int qual,  arith count, struct formal *fm, struct proto *pl)
 {
 	/*	A decl_unary describing a constructor with fundamental
 		type fund and with size count is inserted in front of the
@@ -75,8 +73,7 @@ add_decl_unary(dc, fund, qual,  count, fm, pl)
 	dc->dc_decl_unary = new;
 }
 
-remove_declarator(dc)
-	struct declarator *dc;
+void remove_declarator(struct declarator *dc)
 {
 	/*	The decl_unary list starting at dc->dc_decl_unary is
 		removed.
@@ -91,8 +88,7 @@ remove_declarator(dc)
 	}
 }
 
-reject_params(dc)
-	register struct declarator *dc;
+void reject_params(register struct declarator *dc)
 {
 	/*	The declarator is checked to have no parameters, if it
 		is an old-style function.  If it is a new-style function,
@@ -120,8 +116,7 @@ reject_params(dc)
 	}
 }
 
-check_array_subscript(expr)
-	register struct expr *expr;
+void check_array_subscript(register struct expr *expr)
 {
 	arith size = expr->VL_VALUE;
 
diff --git a/lang/cem/cemcom.ansi/declarator.h b/lang/cem/cemcom.ansi/declarator.h
new file mode 100644
index 000000000..abda9de1f
--- /dev/null
+++ b/lang/cem/cemcom.ansi/declarator.h
@@ -0,0 +1,28 @@
+/*  Copyright (c) 2019 ACK Project.
+ *  See the copyright notice in the ACK home directory, 
+ *  in the file "Copyright".
+ *
+ *  Created on: 2019-02-06
+ *  
+ */
+#ifndef DECLARATOR_H_
+#define DECLARATOR_H_
+
+#include "arith.h"
+
+/* Forward declarations. */
+struct type;
+struct declarator;
+struct formal;
+struct proto;
+struct expr;
+
+struct type *
+declare_type(struct type *tp, struct declarator *dc);
+void add_decl_unary(register struct declarator *dc, int fund, int qual,
+		arith count, struct formal *fm, struct proto *pl);
+void remove_declarator(struct declarator *dc);
+void reject_params(register struct declarator *dc);
+void check_array_subscript(register struct expr *expr);
+
+#endif /* DECLARATOR_H_ */
diff --git a/lang/cem/cemcom.ansi/decspecs.c b/lang/cem/cemcom.ansi/decspecs.c
index bef0c0d2b..42465e213 100644
--- a/lang/cem/cemcom.ansi/decspecs.c
+++ b/lang/cem/cemcom.ansi/decspecs.c
@@ -6,12 +6,13 @@
 /*	D E C L A R A T I O N   S P E C I F I E R   C H E C K I N G	*/
 
 #include	<assert.h>
-#include	"Lpars.h"
 #include	"decspecs.h"
+#include	"Lpars.h"
 #include	"arith.h"
 #include	"type.h"
 #include	"level.h"
 #include	"def.h"
+#include    "error.h"
 
 extern char options[];
 extern int level;
@@ -20,36 +21,35 @@ extern struct type *qualifier_type();
 
 struct decspecs null_decspecs;
 
-do_decspecs(ds)
-	register struct decspecs *ds;
+void do_decspecs(register struct decspecs *ds)
 {
 	/*	The provisional decspecs ds as obtained from the program
-		is turned into a legal consistent decspecs.
-	*/
+	 is turned into a legal consistent decspecs.
+	 */
 	register struct type *tp = ds->ds_type;
-	
+
 	assert(level != L_FORMAL1);
-	
-	if (	level == L_GLOBAL &&
-		(ds->ds_sc == AUTO || ds->ds_sc == REGISTER)
-	)	{
-		error("no global %s variable allowed",
-			symbol2str(ds->ds_sc));
+
+	if (level == L_GLOBAL && (ds->ds_sc == AUTO || ds->ds_sc == REGISTER))
+	{
+		error("no global %s variable allowed", symbol2str(ds->ds_sc));
 		ds->ds_sc = GLOBAL;
 	}
 
-	if (level == L_FORMAL2)	{
-		if (ds->ds_sc_given &&
-		    ds->ds_sc != REGISTER){
+	if (level == L_FORMAL2)
+	{
+		if (ds->ds_sc_given && ds->ds_sc != REGISTER)
+		{
 			error("%s formal illegal", symbol2str(ds->ds_sc));
 			ds->ds_sc = FORMAL;
 		}
 	}
 
 	/*	Since type qualifiers may be associated with types by means
-		of typedefs, we have to perform same basic tests down here.
-	*/
-	if (tp != (struct type *)0) {
+	 of typedefs, we have to perform same basic tests down here.
+	 */
+	if (tp != (struct type *) 0)
+	{
 		if ((ds->ds_typequal & TQ_VOLATILE) && (tp->tp_typequal & TQ_VOLATILE))
 			error("indirect repeated type qualifier");
 		if ((ds->ds_typequal & TQ_CONST) && (tp->tp_typequal & TQ_CONST))
@@ -58,49 +58,74 @@ do_decspecs(ds)
 	}
 
 	/*	The tests concerning types require a full knowledge of the
-		type and will have to be postponed to declare_idf.
-	*/
+	 type and will have to be postponed to declare_idf.
+	 */
 
 	/* some adjustments as described in 3.5.2. */
-	if (tp == 0) {
+	if (tp == 0)
+	{
 		ds->ds_notypegiven = 1;
 		tp = int_type;
 	}
-	if (ds->ds_size) {
+	if (ds->ds_size)
+	{
 		register int ds_isshort = (ds->ds_size == SHORT);
 
-		if (ds->ds_typedef) goto SIZE_ERROR;		/* yes */
-		if (tp == int_type) {
-			if (ds_isshort) tp = short_type;
-			else tp = long_type;
-		} else if (tp == double_type && !ds_isshort ) {
+		if (ds->ds_typedef)
+			goto SIZE_ERROR;
+		/* yes */
+		if (tp == int_type)
+		{
+			if (ds_isshort)
+				tp = short_type;
+			else
+				tp = long_type;
+		}
+		else if (tp == double_type && !ds_isshort)
+		{
 			tp = lngdbl_type;
-		} else {
-	SIZE_ERROR:
-			error("%s with illegal type",symbol2str(ds->ds_size));
+		}
+		else
+		{
+			SIZE_ERROR: error("%s with illegal type", symbol2str(ds->ds_size));
 		}
 		ds->ds_notypegiven = 0;
 	}
-	if (ds->ds_unsigned) {
+	if (ds->ds_unsigned)
+	{
 		register int ds_isunsigned = (ds->ds_unsigned == UNSIGNED);
 
-		if (ds->ds_typedef) goto SIGN_ERROR;		/* yes */
+		if (ds->ds_typedef)
+			goto SIGN_ERROR;
+		/* yes */
 		/*
 		 * All integral types are signed by default (char too),
 		 * so the case that ds->ds_unsigned == SIGNED can be ignored.
 		 */
-		if (tp == schar_type) {
-			if (ds_isunsigned) tp = uchar_type;
-		} else if (tp == short_type) {
-			if (ds_isunsigned) tp = ushort_type;
-		} else if (tp == int_type) {
-			if (ds_isunsigned) tp = uint_type;
-		} else if (tp == long_type) {
-			if (ds_isunsigned) tp = ulong_type;
-		} else {
-	SIGN_ERROR:
-			error("%s with illegal type"
-				, symbol2str(ds->ds_unsigned));
+		if (tp == schar_type)
+		{
+			if (ds_isunsigned)
+				tp = uchar_type;
+		}
+		else if (tp == short_type)
+		{
+			if (ds_isunsigned)
+				tp = ushort_type;
+		}
+		else if (tp == int_type)
+		{
+			if (ds_isunsigned)
+				tp = uint_type;
+		}
+		else if (tp == long_type)
+		{
+			if (ds_isunsigned)
+				tp = ulong_type;
+		}
+		else
+		{
+			SIGN_ERROR: error("%s with illegal type",
+					symbol2str(ds->ds_unsigned));
 		}
 		ds->ds_notypegiven = 0;
 	}
@@ -108,15 +133,12 @@ do_decspecs(ds)
 }
 
 /*	Make tp into a qualified type. This is not as trivial as it
-	may seem. If tp is a fundamental type the qualified type is
-	either existent or will be generated.
-	In case of a complex type the top of the type list will be
-	replaced by a qualified version.
-*/
-struct type *
-qualifier_type(tp, typequal)
-	register struct type *tp;
-	int typequal;
+ may seem. If tp is a fundamental type the qualified type is
+ either existent or will be generated.
+ In case of a complex type the top of the type list will be
+ replaced by a qualified version.
+ */
+struct type *qualifier_type(register struct type *tp, int typequal)
 {
 	register struct type *dtp = tp;
 	register int fund = tp->tp_fund;
@@ -124,32 +146,34 @@ qualifier_type(tp, typequal)
 	while (dtp && dtp->tp_typequal != typequal)
 		dtp = dtp->next;
 
-	if (!dtp) {
+	if (!dtp)
+	{
 		dtp = create_type(fund);
 		dtp->tp_unsigned = tp->tp_unsigned;
 		dtp->tp_align = tp->tp_align;
 		dtp->tp_typequal = typequal;
 		dtp->tp_size = tp->tp_size;
 #if 0
-/* The tp_function field does not exist now. See the comment in the
-   function_of() routine.
-*/
+		/* The tp_function field does not exist now. See the comment in the
+		 function_of() routine.
+		 */
 		dtp->tp_function = tp->tp_function;
 #endif
-		switch (fund) {
+		switch (fund)
+		{
 		case ARRAY:
-			if (typequal) {
-			    tp->tp_up = qualifier_type(tp->tp_up, typequal);
-			    dtp->tp_typequal = typequal = 0;
+			if (typequal)
+			{
+				tp->tp_up = qualifier_type(tp->tp_up, typequal);
+				dtp->tp_typequal = typequal = 0;
 			}
 			goto nottagged;
 		case FIELD:
 			dtp->tp_field = tp->tp_field;
 			/* fallthrough */
 		case POINTER:
-		case FUNCTION:			/* dont't assign tp_proto */
-		nottagged:
-			dtp->tp_up = tp->tp_up;
+		case FUNCTION: /* dont't assign tp_proto */
+			nottagged: dtp->tp_up = tp->tp_up;
 			break;
 		case STRUCT:
 		case UNION:
@@ -163,6 +187,6 @@ qualifier_type(tp, typequal)
 		dtp->next = tp->next; /* don't know head or tail */
 		tp->next = dtp;
 	}
-	return(dtp);
+	return (dtp);
 }
 
diff --git a/lang/cem/cemcom.ansi/decspecs.h b/lang/cem/cemcom.ansi/decspecs.h
index 73a4048e2..7256b739d 100644
--- a/lang/cem/cemcom.ansi/decspecs.h
+++ b/lang/cem/cemcom.ansi/decspecs.h
@@ -2,6 +2,9 @@
  * (c) copyright 1987 by the Vrije Universiteit, Amsterdam, The Netherlands.
  * See the copyright notice in the ACK home directory, in the file "Copyright".
  */
+#ifndef DECSPECS_H_
+#define DECSPECS_H_
+
 /* $Id$ */
 /* DECLARATION SPECIFIER DEFINITION */
 
@@ -19,3 +22,10 @@ struct decspecs	{
 
 extern struct type *qualifier_type();
 extern struct decspecs null_decspecs;
+
+struct type;
+
+void do_decspecs(register struct decspecs *ds);
+struct type *qualifier_type(register struct type *tp, int typequal);
+
+#endif
diff --git a/lang/cem/cemcom.ansi/def.str b/lang/cem/cemcom.ansi/def.str
index 0ad7af339..ad528a664 100644
--- a/lang/cem/cemcom.ansi/def.str
+++ b/lang/cem/cemcom.ansi/def.str
@@ -2,6 +2,9 @@
  * (c) copyright 1987 by the Vrije Universiteit, Amsterdam, The Netherlands.
  * See the copyright notice in the ACK home directory, in the file "Copyright".
  */
+#ifndef DEF_H_
+#define DEF_H_
+
 /* $Id$ */
 /* IDENTIFIER DEFINITION DESCRIPTOR */
 
@@ -38,3 +41,5 @@ struct def	{		/* for ordinary tags */
 #define REG_BONUS	10	/* register candidate, declared as such */
 
 /* ALLOCDEF "def" 50 */
+
+#endif
diff --git a/lang/cem/cemcom.ansi/domacro.c b/lang/cem/cemcom.ansi/domacro.c
index d6fc4c501..dc77827ea 100644
--- a/lang/cem/cemcom.ansi/domacro.c
+++ b/lang/cem/cemcom.ansi/domacro.c
@@ -8,12 +8,17 @@
 #include <assert.h>
 #include <stdlib.h>
 #include <string.h>
+#include "domacro.h"
 #include "parameters.h"
 #include "idf.h"
+#include "interface.h"
 #include "arith.h"
 #include "LLlex.h"
 #include "Lpars.h"
 #include "input.h"
+#include "pragma.h"
+#include "skip.h"
+#include "error.h"
 
 #ifdef DBSYMTAB
 #include <stb.h>
@@ -23,7 +28,9 @@ int IncludeLevel = 0;
 
 extern char options[];
 
-struct idf* GetIdentifier(skiponerr) int skiponerr; /* skip the rest of the line on error */
+static void do_line(unsigned int);
+
+struct idf* GetIdentifier(int skiponerr) /* skip the rest of the line on error */
 {
 	/*	returns a pointer to the descriptor of the identifier that is
 	    read from the input stream. When the input does not contain
@@ -44,7 +51,7 @@ struct idf* GetIdentifier(skiponerr) int skiponerr; /* skip the rest of the line
 	return tk.tk_idf;
 }
 
-domacro()
+void domacro(void)
 {
 	int tok;
 	struct token tk;
@@ -70,7 +77,7 @@ domacro()
 	SkipToNewLine();
 }
 
-do_line(l) unsigned int l;
+static void do_line(unsigned int l)
 {
 	struct token tk;
 	int t = GetToken(&tk);
diff --git a/lang/cem/cemcom.ansi/domacro.h b/lang/cem/cemcom.ansi/domacro.h
new file mode 100644
index 000000000..75d6085a0
--- /dev/null
+++ b/lang/cem/cemcom.ansi/domacro.h
@@ -0,0 +1,16 @@
+/*  Copyright (c) 2019 ACK Project.
+ *  See the copyright notice in the ACK home directory, 
+ *  in the file "Copyright".
+ *
+ *  Created on: 2019-02-06
+ *  
+ */
+#ifndef DOMACRO_H_
+#define DOMACRO_H_
+
+struct idf;
+
+struct idf* GetIdentifier(int skiponerr) ;
+void domacro(void);
+
+#endif /* DOMACRO_H_ */
diff --git a/lang/cem/cemcom.ansi/error.c b/lang/cem/cemcom.ansi/error.c
index 6f2283b74..76421ed80 100644
--- a/lang/cem/cemcom.ansi/error.c
+++ b/lang/cem/cemcom.ansi/error.c
@@ -6,6 +6,7 @@
 /*	E R R O R   A N D  D I A G N O S T I C   R O U T I N E S	*/
 
 #include	"parameters.h"
+#include    "error.h"
 #if __STDC__
 #include	<stdarg.h>
 #else
@@ -17,13 +18,15 @@
 #else
 #include	"l_em.h"
 #endif	/* LINT */
-
+#include    <stdio.h>
 #include	"tokenname.h"
 #include	<flt_arith.h>
+#include    "interface.h"
 #include	"arith.h"
 #include	"label.h"
 #include	"expr.h"
 #include	"def.h"
+#include    "print.h"
 #include	"LLlex.h"
 
 /*	This file contains the error-message and diagnostic
@@ -56,12 +59,11 @@ extern char loptions[];
 	FileName, expression errors get their information from the
 	expression, whereas other errors use the information in the token.
 */
-
-static void _error();
+static void _error(int, char *, unsigned int, char*, va_list);
 
 #if __STDC__
 /*VARARGS*/
-error(char *fmt, ...)
+void error(char *fmt, ...)
 {
 	va_list ap;
 
@@ -73,7 +75,7 @@ error(char *fmt, ...)
 }
 
 /*VARARGS*/
-expr_error(struct expr *expr, char *fmt, ...)
+void expr_error(struct expr *expr, char *fmt, ...)
 {
 	va_list ap;
 
@@ -89,7 +91,7 @@ expr_error(struct expr *expr, char *fmt, ...)
 }
 
 /*VARARGS*/
-lexstrict(char *fmt, ...)
+void lexstrict(char *fmt, ...)
 {
 	va_list ap;
 
@@ -101,7 +103,7 @@ lexstrict(char *fmt, ...)
 }
 
 /*VARARGS*/
-strict(char *fmt, ...)
+void strict(char *fmt, ...)
 {
 	va_list ap;
 
@@ -113,7 +115,7 @@ strict(char *fmt, ...)
 }
 
 /*VARARGS*/
-expr_strict(struct expr *expr, char *fmt, ...)
+void expr_strict(struct expr *expr, char *fmt, ...)
 {
 	va_list ap;
 
@@ -129,7 +131,7 @@ expr_strict(struct expr *expr, char *fmt, ...)
 
 #ifdef DEBUG
 /*VARARGS*/
-debug(char *fmt, ...)
+void debug(char *fmt, ...)
 {
 	va_list ap;
 
@@ -142,7 +144,7 @@ debug(char *fmt, ...)
 #endif /* DEBUG */
 
 /*VARARGS*/
-warning(char *fmt, ...)
+void warning(char *fmt, ...)
 {
 	va_list ap;
 
@@ -154,7 +156,7 @@ warning(char *fmt, ...)
 }
 
 /*VARARGS*/
-expr_warning(struct expr *expr, char *fmt, ...)
+void expr_warning(struct expr *expr, char *fmt, ...)
 {
 	va_list ap;
 
@@ -171,7 +173,7 @@ expr_warning(struct expr *expr, char *fmt, ...)
 #ifdef	LINT
 
 /*VARARGS*/
-def_warning(struct def *def, char *fmt, ...)
+void def_warning(struct def *def, char *fmt, ...)
 {
 	va_list ap;
 
@@ -184,7 +186,7 @@ def_warning(struct def *def, char *fmt, ...)
 
 
 /*VARARGS*/
-hwarning(char *fmt, ...)
+void hwarning(char *fmt, ...)
 {
 	va_list ap;
 
@@ -197,7 +199,7 @@ hwarning(char *fmt, ...)
 }
 
 /*VARARGS*/
-awarning(char *fmt, ...)
+void awarning(char *fmt, ...)
 {
 	va_list ap;
 
@@ -212,7 +214,7 @@ awarning(char *fmt, ...)
 #endif	/* LINT */
 
 /*VARARGS*/
-lexerror(char *fmt, ...)
+void lexerror(char *fmt, ...)
 {
 	va_list ap;
 
@@ -224,7 +226,7 @@ lexerror(char *fmt, ...)
 }
 
 /*VARARGS*/
-lexwarning(char *fmt, ...)
+void lexwarning(char *fmt, ...)
 {
 	va_list ap;
 
@@ -236,7 +238,7 @@ lexwarning(char *fmt, ...)
 }
 
 /*VARARGS*/
-crash(char *fmt, ...)
+void crash(char *fmt, ...)
 {
 	va_list ap;
 
@@ -256,7 +258,7 @@ crash(char *fmt, ...)
 }
 
 /*VARARGS*/
-fatal(char *fmt, ...)
+void fatal(char *fmt, ...)
 {
 	va_list ap;
 
@@ -272,7 +274,7 @@ fatal(char *fmt, ...)
 }
 #else
 /*VARARGS*/
-error(va_alist)				/* fmt, args */
+void error(va_alist)				/* fmt, args */
 	va_dcl
 {
 	va_list ap;
@@ -286,7 +288,7 @@ error(va_alist)				/* fmt, args */
 }
 
 /*VARARGS*/
-expr_error(va_alist)			/* expr, fmt, args */
+void expr_error(va_alist)			/* expr, fmt, args */
 	va_dcl
 {
 	va_list ap;
@@ -306,7 +308,7 @@ expr_error(va_alist)			/* expr, fmt, args */
 }
 
 /*VARARGS*/
-lexstrict(va_alist)
+void lexstrict(va_alist)
 	va_dcl
 {
 	va_list ap;
@@ -320,7 +322,7 @@ lexstrict(va_alist)
 }
 
 /*VARARGS*/
-strict(va_alist)
+void strict(va_alist)
 	va_dcl
 {
 	va_list ap;
@@ -334,7 +336,7 @@ strict(va_alist)
 }
 
 /*VARARGS*/
-expr_strict(va_alist)			/* expr, fmt, args */
+void expr_strict(va_alist)			/* expr, fmt, args */
 	va_dcl
 {
 	va_list ap;
@@ -354,7 +356,7 @@ expr_strict(va_alist)			/* expr, fmt, args */
 
 #ifdef DEBUG
 /*VARARGS*/
-debug(va_alist)
+void debug(va_alist)
 	va_dcl
 {
 	va_list ap;
@@ -369,7 +371,7 @@ debug(va_alist)
 #endif /* DEBUG */
 
 /*VARARGS*/
-warning(va_alist)
+void warning(va_alist)
 	va_dcl
 {
 	va_list ap;
@@ -383,7 +385,7 @@ warning(va_alist)
 }
 
 /*VARARGS*/
-expr_warning(va_alist)			/* expr, fmt, args */
+void expr_warning(va_alist)			/* expr, fmt, args */
 	va_dcl
 {
 	va_list ap;
@@ -404,7 +406,7 @@ expr_warning(va_alist)			/* expr, fmt, args */
 #ifdef	LINT
 
 /*VARARGS*/
-def_warning(va_alist)			/* def, fmt, args */
+void def_warning(va_alist)			/* def, fmt, args */
 	va_dcl
 {
 	va_list ap;
@@ -421,7 +423,7 @@ def_warning(va_alist)			/* def, fmt, args */
 
 
 /*VARARGS*/
-hwarning(va_alist)			/* fmt, args */
+void hwarning(va_alist)			/* fmt, args */
 	va_dcl
 {
 	va_list ap;
@@ -436,7 +438,7 @@ hwarning(va_alist)			/* fmt, args */
 }
 
 /*VARARGS*/
-awarning(va_alist)			/* fmt, args */
+void awarning(va_alist)			/* fmt, args */
 	va_dcl
 {
 	va_list ap;
@@ -453,7 +455,7 @@ awarning(va_alist)			/* fmt, args */
 #endif	/* LINT */
 
 /*VARARGS*/
-lexerror(va_alist)			/* fmt, args */
+void lexerror(va_alist)			/* fmt, args */
 	va_dcl
 {
 	va_list ap;
@@ -467,7 +469,7 @@ lexerror(va_alist)			/* fmt, args */
 }
 
 /*VARARGS*/
-lexwarning(va_alist)			/* fmt, args */
+void lexwarning(va_alist)			/* fmt, args */
 	va_dcl
 {
 	va_list ap;
@@ -481,7 +483,7 @@ lexwarning(va_alist)			/* fmt, args */
 }
 
 /*VARARGS*/
-crash(va_alist)				/* fmt, args */
+void crash(va_alist)				/* fmt, args */
 	va_dcl
 {
 	va_list ap;
@@ -503,7 +505,7 @@ crash(va_alist)				/* fmt, args */
 }
 
 /*VARARGS*/
-fatal(va_alist)				/* fmt, args */
+void fatal(va_alist)				/* fmt, args */
 	va_dcl
 {
 	va_list ap;
@@ -521,13 +523,7 @@ fatal(va_alist)				/* fmt, args */
 }
 #endif
 
-static void
-_error(class, fn, ln, fmt, ap)
-	int class;
-	char *fn;
-	unsigned int ln;
-	char *fmt;
-	va_list ap;
+static void _error(int class, char *fn, unsigned int ln, char* fmt, va_list ap)
 {
 	char *remark;
 	
@@ -614,9 +610,9 @@ _error(class, fn, ln, fmt, ap)
 #endif	/* LINT */
 	
 	if (fn)
-		fprint(ERROUT, "\"%s\", line %u: ", fn, ln);
+		fprint(stderr, "\"%s\", line %u: ", fn, ln);
 	if (remark)
-		fprint(ERROUT, "%s ", remark);
-	doprnt(ERROUT, fmt, ap);		/* contents of error */
-	fprint(ERROUT, "\n");
+		fprint(stderr, "%s ", remark);
+	doprnt(stderr, fmt, ap);		/* contents of error */
+	fprint(stderr, "\n");
 }
diff --git a/lang/cem/cemcom.ansi/error.h b/lang/cem/cemcom.ansi/error.h
new file mode 100644
index 000000000..595cd2aba
--- /dev/null
+++ b/lang/cem/cemcom.ansi/error.h
@@ -0,0 +1,94 @@
+/*  Copyright (c) 2019 ACK Project.
+ *  See the copyright notice in the ACK home directory, 
+ *  in the file "Copyright".
+ *
+ *  Created on: 2019-02-06
+ *  
+ */
+#ifndef ERROR_H_
+#define ERROR_H_
+
+struct expr;
+
+#if __STDC__
+/*VARARGS*/
+void error(char *fmt, ...);
+/*VARARGS*/
+void expr_error(struct expr *expr, char *fmt, ...);
+/*VARARGS*/
+void lexstrict(char *fmt, ...);
+/*VARARGS*/
+void strict(char *fmt, ...);
+/*VARARGS*/
+void expr_strict(struct expr *expr, char *fmt, ...);
+
+#ifdef DEBUG
+/*VARARGS*/
+void debug(char *fmt, ...);
+#endif /* DEBUG */
+
+/*VARARGS*/
+void warning(char *fmt, ...);
+/*VARARGS*/
+void expr_warning(struct expr *expr, char *fmt, ...);
+#ifdef	LINT
+/*VARARGS*/
+void def_warning(struct def *def, char *fmt, ...);
+/*VARARGS*/
+void hwarning(char *fmt, ...);
+/*VARARGS*/
+void awarning(char *fmt, ...);
+#endif	/* LINT */
+
+/*VARARGS*/
+void lexerror(char *fmt, ...);
+/*VARARGS*/
+void lexwarning(char *fmt, ...);
+/*VARARGS*/
+void crash(char *fmt, ...);
+/*VARARGS*/
+void fatal(char *fmt, ...);
+
+#else
+/*VARARGS*/
+void error(va_alist);				/* fmt, args */
+/*VARARGS*/
+void expr_error(va_alist);			/* expr, fmt, args */
+/*VARARGS*/
+void lexstrict(va_alist);
+/*VARARGS*/
+void strict(va_alist);
+/*VARARGS*/
+void expr_strict(va_alist);			/* expr, fmt, args */
+#ifdef DEBUG
+/*VARARGS*/
+void debug(va_alist);
+#endif /* DEBUG */
+
+/*VARARGS*/
+void warning(va_alist);
+/*VARARGS*/
+void expr_warning(va_alist);			/* expr, fmt, args */
+#ifdef	LINT
+
+/*VARARGS*/
+void def_warning(va_alist);			/* def, fmt, args */
+/*VARARGS*/
+void hwarning(va_alist);			/* fmt, args */
+/*VARARGS*/
+void awarning(va_alist);			/* fmt, args */
+#endif	/* LINT */
+
+/*VARARGS*/
+void lexerror(va_alist);			/* fmt, args */
+/*VARARGS*/
+void lexwarning(va_alist);			/* fmt, args */
+/*VARARGS*/
+void crash(va_alist);				/* fmt, args */
+/*VARARGS*/
+void fatal(va_alist);				/* fmt, args */
+#endif
+
+
+
+#endif /* ERROR_H_ */
diff --git a/lang/cem/cemcom.ansi/estack.str b/lang/cem/cemcom.ansi/estack.str
index b65629ed6..0718cca64 100644
--- a/lang/cem/cemcom.ansi/estack.str
+++ b/lang/cem/cemcom.ansi/estack.str
@@ -2,6 +2,9 @@
  * (c) copyright 1987 by the Vrije Universiteit, Amsterdam, The Netherlands.
  * See the copyright notice in the ACK home directory, in the file "Copyright".
  */
+ #ifndef ESTACK_H_
+ #define ESTACK_H_
+ 
 /* $Id$ */
 /* EXPRESSION STACK */
 /* Used for global initializations */
@@ -19,3 +22,5 @@ struct e_stack {
 #define last_offset	s_cnt2
 #define elem_count	s_cnt1
 #define nelem		s_cnt2
+
+#endif
\ No newline at end of file
diff --git a/lang/cem/cemcom.ansi/eval.c b/lang/cem/cemcom.ansi/eval.c
index 0ec25dac6..352d590b3 100644
--- a/lang/cem/cemcom.ansi/eval.c
+++ b/lang/cem/cemcom.ansi/eval.c
@@ -14,6 +14,8 @@
 #include	<em_reg.h>
 #include	<alloc.h>
 #include	<flt_arith.h>
+#include    "interface.h"
+#include    "eval.h"
 #include    "idf.h"
 #include	"arith.h"
 #include	"type.h"
@@ -22,13 +24,21 @@
 #include	"def.h"
 #include	"expr.h"
 #include	"sizes.h"
+#include    "field.h"
 #include	"Lpars.h"
 #include	"level.h"
+#include    "conversion.h"
 #include	"stack.h"
+#include    "struct.h"
 #include	"align.h"
 #include	"mes.h"
 #include	"atw.h"
+#include    "ch3.h"
+#include    "util.h"
+#include    "blocks.h"
+#include    "dataflow.h"
 #include	"specials.h"
+#include    "error.h"
 
 #define	CRASH()		crash("EVAL: CRASH at line %u", __LINE__)
 
@@ -37,8 +47,12 @@ arith NewLocal();	/* util.c */
 #define LocalPtrVar()	NewLocal(pointer_size, pointer_align, reg_pointer, REGISTER)
 extern int	err_occurred; /* error.c */
 
-void store_val();
-void load_val();
+
+/* Forward internal declarations */
+static void operands(register struct expr *, int);
+static void ptr_add(arith size);
+static void truthvalue(int relop);
+static void compare(int relop, label lbl);
 
 /*	EVAL() is the main expression-tree evaluator, which turns
 	any legal expression tree into EM code. parameters.h:
@@ -66,11 +80,7 @@ void load_val();
 		labels, in case they are specified (i.e. are non-zero)
 */
 
-void
-EVAL(expr, val, code, true_label, false_label)
-	register struct expr *expr;
-	int val, code;
-	label true_label, false_label;
+void EVAL(register struct expr *expr, int val, int code, label true_label, label false_label)
 {
 	int vol = (code != TRUE && recurqual(expr->ex_type, TQ_VOLATILE));
 	register int gencode = code == TRUE;
@@ -659,9 +669,7 @@ EVAL(expr, val, code, true_label, false_label)
 }
 
 /*	compare() serves as an auxiliary function of EVAL	*/
-compare(relop, lbl)
-	int relop;
-	label lbl;
+static void compare(int relop, label lbl)
 {
 	switch (relop) {
 	case '<':
@@ -688,8 +696,7 @@ compare(relop, lbl)
 }
 
 /*	truthvalue() serves as an auxiliary function of EVAL	*/
-truthvalue(relop)
-	int relop;
+static void truthvalue(int relop)
 {
 	switch (relop)	{
 	case '<':
@@ -717,12 +724,10 @@ truthvalue(relop)
 
 
 /*	assop() generates the opcode of an assignment operators op=	*/
-assop(type, oper)
-	register struct type *type;
-	int oper;
+void assop(register struct type *type, int oper)
 {
 	register arith size;
-	register uns = type->tp_unsigned;
+	register int uns = type->tp_unsigned;
 
 	if ((int)(size = type->tp_size) < (int)word_size)
 		size = word_size;
@@ -822,8 +827,7 @@ assop(type, oper)
 	}
 }
 
-ptr_add(size)
-	arith size;
+static void ptr_add(arith size)
 {
 	if (size != pointer_size) {
 		C_loc(size);
@@ -840,10 +844,7 @@ ptr_add(size)
 	- into a local static variable
 	- absolute addressing
 */
-void
-store_val(vl, tp)
-	register struct value *vl;
-	register struct type *tp;
+void store_val(register struct value *vl, register struct type *tp)
 {
 	register int inword = 0;
 	register int indword = 0;
@@ -911,11 +912,10 @@ store_val(vl, tp)
 	- global variable
 	- static variable
 	- local variable
+
+	rlval generate rlval or lval
 */
-void
-load_val(expr, rlval)
-	register struct expr *expr; /* expression containing the value	*/
-	int rlval;		/* generate either LVAL or RVAL		*/
+void load_val(register struct expr *expr, int rlval)
 {
 	register struct type *tp = expr->ex_type;
 	int rvalue = (rlval == RVAL && expr->ex_lvalue != 0);
@@ -1012,8 +1012,7 @@ load_val(expr, rlval)
 	}
 }
 
-load_cst(val, siz)
-	arith val, siz;
+void load_cst(arith val, arith siz)
 {
 	if ((int)siz <= (int)word_size)
 		C_loc(val);
@@ -1030,8 +1029,7 @@ load_cst(val, siz)
 	}
 }
 
-operands(expr, gencode)
-	register struct expr *expr;
+static void operands(register struct expr *expr, int gencode)
 {
 	EVAL(expr->OP_LEFT, RVAL, gencode, NO_LABEL, NO_LABEL);
 	EVAL(expr->OP_RIGHT, RVAL, gencode, NO_LABEL, NO_LABEL);
diff --git a/lang/cem/cemcom.ansi/eval.h b/lang/cem/cemcom.ansi/eval.h
new file mode 100644
index 000000000..337b5ac57
--- /dev/null
+++ b/lang/cem/cemcom.ansi/eval.h
@@ -0,0 +1,37 @@
+/*  Copyright (c) 2019 ACK Project.
+ *  See the copyright notice in the ACK home directory, 
+ *  in the file "Copyright".
+ *
+ *  Created on: 2019-02-06
+ *  
+ */
+#ifndef EVAL_H_
+#define EVAL_H_
+
+#ifndef	LINT
+
+
+#include <em.h>
+
+struct expr;
+struct value;
+struct type;
+
+void EVAL(register struct expr *expr, int val, int code, label true_label, label false_label);
+
+/*	assop() generates the opcode of an assignment operators op=	*/
+void assop(register struct type *type, int oper);
+/*	store_val() generates code for a store operation.
+	There are four ways of storing data:
+	- into a global variable
+	- into an automatic local variable
+	- into a local static variable
+	- absolute addressing
+*/
+void store_val(register struct value *vl, register struct type *tp);
+void load_val(register struct expr *expr, int rlval);
+void load_cst(arith val, arith siz);
+
+#endif /* LINT */
+
+#endif /* EVAL_H_ */
diff --git a/lang/cem/cemcom.ansi/expr.c b/lang/cem/cemcom.ansi/expr.c
index 7b686c3fe..b24c408d0 100644
--- a/lang/cem/cemcom.ansi/expr.c
+++ b/lang/cem/cemcom.ansi/expr.c
@@ -10,6 +10,7 @@
 #include	"parameters.h"
 #include	<alloc.h>
 #include	<flt_arith.h>
+#include    "expr.h"
 #include    "idf.h"
 #include	"arith.h"
 #include	"def.h"
@@ -22,20 +23,21 @@
 #include	"declar.h"
 #include	"sizes.h"
 #include	"level.h"
+#include    "cstoper.h"
+#include    "error.h"
 
 extern char *symbol2str();
 extern char options[];
 extern int InSizeof;
 
-int
-rank_of(oper)
-	int oper;
+int rank_of(int oper)
 {
 	/*	The rank of the operator oper is returned.
-	*/
-	switch (oper)	{
+	 */
+	switch (oper)
+	{
 	default:
-		return 0;			/* INT2INT etc. */
+		return 0; /* INT2INT etc. */
 	case '[':
 	case '(':
 	case '.':
@@ -48,7 +50,7 @@ rank_of(oper)
 	case CAST:
 	case SIZEOF:
 	case ADDRESSOF:
-		return 2;			/* monadic */
+		return 2; /* monadic */
 	case '*':
 	case '/':
 	case '%':
@@ -98,18 +100,18 @@ rank_of(oper)
 	/*NOTREACHED*/
 }
 
-dot2expr(expp)
-	struct expr **expp;
+void dot2expr(struct expr **expp)
 {
 	/*	The token in dot is converted into an expression, a
-		pointer to which is stored in *expp.
-	*/
+	 pointer to which is stored in *expp.
+	 */
 	register struct expr *ex = new_expr();
 
 	*expp = ex;
 	ex->ex_file = dot.tk_file;
 	ex->ex_line = dot.tk_line;
-	switch (DOT)	{
+	switch (DOT)
+	{
 	case IDENTIFIER:
 		idf2expr(ex);
 		break;
@@ -125,25 +127,27 @@ dot2expr(expp)
 	}
 }
 
-idf2expr(expr)
-	register struct expr *expr;
+void idf2expr(register struct expr *expr)
 {
 	/*	Dot contains an identifier which is turned into an
-		expression.
-		Note that this constitutes an applied occurrence of
-		the identifier.
-	*/
-	register struct idf *idf = dot.tk_idf;	/* != 0*/
+	 expression.
+	 Note that this constitutes an applied occurrence of
+	 the identifier.
+	 */
+	register struct idf *idf = dot.tk_idf; /* != 0*/
 	register struct def *def = idf->id_def;
-	
-	if (def == 0)	{
-		if (AHEAD == '(') {
+
+	if (def == 0)
+	{
+		if (AHEAD == '(')
+		{
 			/* function call, declare name implicitly (3.3.2.2) */
 			if (!options['o'])
-				warning("implicit declaration of function %s"
-					, idf->id_text);
+				warning("implicit declaration of function %s", idf->id_text);
 			add_def(idf, EXTERN, funint_type, level);
-		} else	{
+		}
+		else
+		{
 			if (!is_anon_idf(idf))
 				error("%s undefined", idf->id_text);
 			/* declare idf anyway */
@@ -153,8 +157,10 @@ idf2expr(expr)
 	}
 	/* now def != 0 */
 #ifndef	LINT
-	if (!InSizeof) {
-		if (! def->df_used) {
+	if (!InSizeof)
+	{
+		if (!def->df_used)
+		{
 #ifndef PREPEND_SCOPES
 			code_scope(idf->id_text, def);
 #endif /* PREPEND_SCOPES */
@@ -163,46 +169,45 @@ idf2expr(expr)
 	}
 #endif	/* LINT */
 	expr->ex_type = def->df_type;
-	if (expr->ex_type == error_type) {
+	if (expr->ex_type == error_type)
+	{
 		expr->ex_flags |= EX_ERROR;
 	}
 	expr->ex_lvalue =
-		(	def->df_type->tp_fund == FUNCTION ||
-			def->df_type->tp_fund == ARRAY ||
-			def->df_sc == ENUM
-		) ? 0 : 1;
+			(def->df_type->tp_fund == FUNCTION || def->df_type->tp_fund == ARRAY
+					|| def->df_sc == ENUM) ? 0 : 1;
 	if (def->df_type->tp_typequal & TQ_CONST)
 		expr->ex_flags |= EX_READONLY;
 	if (def->df_type->tp_typequal & TQ_VOLATILE)
 		expr->ex_flags |= EX_VOLATILE;
 	expr->ex_class = Value;
-	if (def->df_sc == ENUM)	{
+	if (def->df_sc == ENUM)
+	{
 		expr->VL_CLASS = Const;
 		expr->VL_VALUE = def->df_address;
 	}
 #ifndef	LINT
-	else
-	if (def->df_sc == STATIC && def->df_level >= L_LOCAL) {
+	else if (def->df_sc == STATIC && def->df_level >= L_LOCAL)
+	{
 		expr->VL_CLASS = Label;
 		expr->VL_LBL = def->df_address;
-		expr->VL_VALUE = (arith)0;
+		expr->VL_VALUE = (arith) 0;
 	}
 #endif	/* LINT */
-	else {
+	else
+	{
 		expr->VL_CLASS = Name;
 		expr->VL_IDF = idf;
-		expr->VL_VALUE = (arith)0;
+		expr->VL_VALUE = (arith) 0;
 	}
 }
 
-string2expr(expp, str, len)
-	register struct expr **expp;
-	int len;
-	char *str;
+void string2expr(register struct expr **expp, char *str, int len)
+
 {
 	/*	The string in the argument is converted into an expression,
-		a pointer to which is stored in *expp.
-	*/
+	 a pointer to which is stored in *expp.
+	 */
 	register struct expr *ex = new_expr();
 
 	*expp = ex;
@@ -217,25 +222,24 @@ string2expr(expp, str, len)
 	ex->SG_LEN = len;
 }
 
-int2expr(expr)
-	struct expr *expr;
+void int2expr(struct expr *expr)
 {
 	/*	Dot contains an integer constant which is turned
-		into an expression.
-	*/
+	 into an expression.
+	 */
 	fill_int_expr(expr, dot.tk_ival, dot.tk_fund);
 }
 
-float2expr(expr)
-	register struct expr *expr;
+void float2expr(register struct expr *expr)
 {
 	/*	Dot contains a floating point constant which is turned
-		into an expression.
-	*/
+	 into an expression.
+	 */
 	register int fund;
 
 	fund = dot.tk_fund;
-	switch (fund) {
+	switch (fund)
+	{
 	case FLOAT:
 		expr->ex_type = float_type;
 		break;
@@ -253,17 +257,15 @@ float2expr(expr)
 	free(dot.tk_fval);
 	assert(flt_status != FLT_NOFLT);
 	if (flt_status == FLT_OVFL)
-		expr_warning(expr,"internal floating point overflow");
+		expr_warning(expr, "internal floating point overflow");
 }
 
-struct expr*
-intexpr(ivalue, fund)
-	arith ivalue;
-	int fund;
+struct expr*intexpr(
+arith ivalue, int fund)
 {
 	/*	The value ivalue is turned into an integer expression of
-		the size indicated by fund.
-	*/
+	 the size indicated by fund.
+	 */
 	register struct expr *expr = new_expr();
 
 	expr->ex_file = dot.tk_file;
@@ -272,15 +274,14 @@ intexpr(ivalue, fund)
 	return expr;
 }
 
-fill_int_expr(ex, ivalue, fund)
-	register struct expr *ex;
-	arith ivalue;
-	int fund;
+void fill_int_expr(register struct expr *ex,
+arith ivalue, int fund)
 {
 	/*	Details derived from ivalue and fund are put into the
-		constant integer expression ex.
-	*/
-	switch (fund) {
+	 constant integer expression ex.
+	 */
+	switch (fund)
+	{
 	case INT:
 		ex->ex_type = int_type;
 		break;
@@ -288,7 +289,7 @@ fill_int_expr(ex, ivalue, fund)
 		ex->ex_type = uint_type;
 		break;
 	case LONG:
-		ex->ex_type =  long_type;
+		ex->ex_type = long_type;
 		break;
 	case ULONG:
 		ex->ex_type = ulong_type;
@@ -303,38 +304,38 @@ fill_int_expr(ex, ivalue, fund)
 	cut_size(ex);
 }
 
-struct expr *
-new_oper(tp, e1, oper, e2)
-	struct type *tp;
-	register struct expr *e1, *e2;
+struct expr *new_oper(struct type *tp, register struct expr *e1, int oper,
+		register struct expr *e2)
 {
 	/*	A new expression is constructed which consists of the
-		operator oper which has e1 and e2 as operands; for a
-		monadic operator e1 == NILEXPR.
-		During the construction of the right recursive initialisation
-		tree it is possible for e2 to be NILEXPR.
-	*/
+	 operator oper which has e1 and e2 as operands; for a
+	 monadic operator e1 == NILEXPR.
+	 During the construction of the right recursive initialisation
+	 tree it is possible for e2 to be NILEXPR.
+	 */
 	register struct expr *expr = new_expr();
 	register struct oper *op;
 
-	if (e2)	{
+	if (e2)
+	{
 		register struct expr *e = e2;
-		
+
 		while (e->ex_class == Oper && e->OP_LEFT)
 			e = e->OP_LEFT;
 		expr->ex_file = e->ex_file;
 		expr->ex_line = e->ex_line;
 	}
-	else
-	if (e1)	{
+	else if (e1)
+	{
 		register struct expr *e = e1;
-		
+
 		while (e->ex_class == Oper && e->OP_RIGHT)
 			e = e->OP_RIGHT;
 		expr->ex_file = e->ex_file;
 		expr->ex_line = e->ex_line;
 	}
-	else	{
+	else
+	{
 		expr->ex_file = dot.tk_file;
 		expr->ex_line = dot.tk_line;
 	}
@@ -342,20 +343,22 @@ new_oper(tp, e1, oper, e2)
 	expr->ex_type = tp;
 	expr->ex_class = Oper;
 	/* combine depths and flags of both expressions */
-	if (e2)	{
+	if (e2)
+	{
 		int e1_depth = e1 ? e1->ex_depth : 0;
 		int e1_flags = e1 ? e1->ex_flags : 0;
-		
-		expr->ex_depth =
-			(e1_depth > e2->ex_depth ? e1_depth : e2->ex_depth) + 1;
+
+		expr->ex_depth = (e1_depth > e2->ex_depth ? e1_depth : e2->ex_depth)
+				+ 1;
 		expr->ex_flags = (e1_flags | e2->ex_flags)
-			& ~(EX_PARENS | EX_READONLY | EX_VOLATILE );
+				& ~(EX_PARENS | EX_READONLY | EX_VOLATILE);
 	}
 	/*
 	 * A function call should be evaluated first when possible.  Just say
 	 * that the expression tree is very deep.
 	 */
-	if (oper == '(') {
+	if (oper == '(')
+	{
 		expr->ex_depth = 50;
 	}
 	op = &expr->ex_object.ex_oper;
@@ -369,42 +372,42 @@ new_oper(tp, e1, oper, e2)
 	return expr;
 }
 
-void
-chk_cst_expr(expp)
-	struct expr **expp;
+void chk_cst_expr(struct expr **expp)
 {
 	/*	The expression expr is checked for constancy.
-	
-		There are 6 places where constant expressions occur in C:
-		1.	after #if
-		2.	in a global initialization
-		3.	as size in an array declaration
-		4.	as value in an enum declaration
-		5.	as width in a bit field
-		6.	as case value in a switch
-		
-		The constant expression in a global initialization is
-		handled separately (by IVAL()).
-		
-		There are various disparate restrictions on each of
-		the others in the various C compilers.  I have tried some
-		hypotheses to unify them, but all have failed.
-		
-		Special problems (of which there is only one, sizeof in
-		Preprocessor #if) have to be dealt with locally
-	*/
+
+	 There are 6 places where constant expressions occur in C:
+	 1.	after #if
+	 2.	in a global initialization
+	 3.	as size in an array declaration
+	 4.	as value in an enum declaration
+	 5.	as width in a bit field
+	 6.	as case value in a switch
+
+	 The constant expression in a global initialization is
+	 handled separately (by IVAL()).
+
+	 There are various disparate restrictions on each of
+	 the others in the various C compilers.  I have tried some
+	 hypotheses to unify them, but all have failed.
+
+	 Special problems (of which there is only one, sizeof in
+	 Preprocessor #if) have to be dealt with locally
+	 */
 	register struct expr *expr = *expp;
-	
+
 #ifdef	DEBUG
 	print_expr("constant_expression", expr);
 #endif	/* DEBUG */
-	switch(expr->ex_type->tp_fund) {
+	switch (expr->ex_type->tp_fund)
+	{
 	case CHAR:
 	case SHORT:
 	case INT:
 	case ENUM:
 	case LONG:
-		if (is_ld_cst(expr)) {
+		if (is_ld_cst(expr))
+		{
 			return;
 		}
 		expr_error(expr, "expression is not constant");
@@ -416,67 +419,58 @@ chk_cst_expr(expp)
 	erroneous2int(expp);
 }
 
-init_expression(eppp, expr)
-	register struct expr ***eppp;
-	struct expr *expr;
+void init_expression(register struct expr ***eppp, struct expr *expr)
 {
 	/*	The expression expr is added to the tree designated
-		indirectly by **eppp.
-		The natural form of a tree representing an
-		initial_value_list is right-recursive, ie. with the
-		left-most comma as main operator. The iterative grammar in
-		expression.g, however, tends to produce a left-recursive
-		tree, ie. one with the right-most comma as its main
-		operator.
-		To produce a right-recursive tree from the iterative
-		grammar, we keep track of the address of the pointer where
-		the next expression must be hooked in.
-	*/
+	 indirectly by **eppp.
+	 The natural form of a tree representing an
+	 initial_value_list is right-recursive, ie. with the
+	 left-most comma as main operator. The iterative grammar in
+	 expression.g, however, tends to produce a left-recursive
+	 tree, ie. one with the right-most comma as its main
+	 operator.
+	 To produce a right-recursive tree from the iterative
+	 grammar, we keep track of the address of the pointer where
+	 the next expression must be hooked in.
+	 */
 	**eppp = new_oper(void_type, expr, INITCOMMA, NILEXPR);
 	*eppp = &(**eppp)->OP_RIGHT;
 }
 
-int
-is_ld_cst(expr)
-	register struct expr *expr;
+int is_ld_cst(register struct expr *expr)
 {
 	/*	An expression is a `load-time constant' if it is of the form
-		<idf> +/- <integral> or <integral>.
-	*/
+	 <idf> +/- <integral> or <integral>.
+	 */
 #ifdef	LINT
 	if (expr->ex_class == String)
-		return 1;
+	return 1;
 #endif	/* LINT */
 	return expr->ex_lvalue == 0 && expr->ex_class == Value;
 }
 
-int
-is_cp_cst(expr)
-	struct expr *expr;
+int is_cp_cst(struct expr *expr)
 {
 	/*	An expression is a `compile-time constant' if it is a
-		load-time constant, and the idf is not there.
-	*/
+	 load-time constant, and the idf is not there.
+	 */
 	return is_ld_cst(expr) && expr->VL_CLASS == Const;
 }
 
-int
-is_fp_cst(expr)
-	struct expr *expr;
+int is_fp_cst(struct expr *expr)
 {
 	/*	An expression is a `floating-point constant' if it consists
-		of the float only.
-	*/
+	 of the float only.
+	 */
 	return expr->ex_class == Float;
 }
 
-int
-is_zero_cst(expr)
-	register struct expr *expr;
+int is_zero_cst(register struct expr *expr)
 {
 	flt_arith var;
 
-	switch(expr->ex_class) {
+	switch (expr->ex_class)
+	{
 	case Value:
 		return expr->VL_VALUE == 0;
 	case Float:
@@ -486,13 +480,14 @@ is_zero_cst(expr)
 	/*NOTREACHED*/
 }
 
-free_expression(expr)
-	register struct expr *expr;
+void free_expression(register struct expr *expr)
 {
 	/*	The expression expr is freed recursively.
-	*/
-	if (expr) {
-		if (expr->ex_class == Oper)	{
+	 */
+	if (expr)
+	{
+		if (expr->ex_class == Oper)
+		{
 			free_expression(expr->OP_LEFT);
 			free_expression(expr->OP_RIGHT);
 		}
diff --git a/lang/cem/cemcom.ansi/expr.str b/lang/cem/cemcom.ansi/expr.str
index b341524ed..97ac5b1f9 100644
--- a/lang/cem/cemcom.ansi/expr.str
+++ b/lang/cem/cemcom.ansi/expr.str
@@ -4,6 +4,13 @@
  */
 /* $Id$ */
 /* EXPRESSION DESCRIPTOR */
+#ifndef EXPR_H_
+#define EXPR_H_
+
+#include "parameters.h"
+#include "arith.h"
+#include "label.h"
+#include "flt_arith.h"
 
 /*	What we want to define is the struct expr, but since it contains
 	a union of various goodies, we define them first; so be patient.
@@ -97,3 +104,24 @@ extern struct expr *intexpr(), *new_oper();
 
 /* ALLOCDEF "expr" 20 */
 
+
+
+int rank_of(int oper);
+void dot2expr(struct expr **expp);
+void idf2expr(register struct expr *expr);
+void string2expr(register struct expr **expp, char *str, int len);
+void int2expr(struct expr *expr);
+void float2expr(register struct expr *expr);
+struct expr* intexpr(arith ivalue, int fund);
+void fill_int_expr(register struct expr *ex,arith ivalue, int fund);
+struct expr *new_oper(struct type *tp, register struct expr *e1, int oper,
+		register struct expr *e2);
+void chk_cst_expr(struct expr **expp);
+void init_expression(register struct expr ***eppp, struct expr *expr);
+int is_ld_cst(register struct expr *expr);
+int is_cp_cst(struct expr *expr);
+int is_fp_cst(struct expr *expr);
+int is_zero_cst(register struct expr *expr);
+void free_expression(register struct expr *expr);
+
+#endif
\ No newline at end of file
diff --git a/lang/cem/cemcom.ansi/expression.g b/lang/cem/cemcom.ansi/expression.g
index 3a1284e69..0998883c1 100644
--- a/lang/cem/cemcom.ansi/expression.g
+++ b/lang/cem/cemcom.ansi/expression.g
@@ -1,349 +1,354 @@
-/*
- * (c) copyright 1987 by the Vrije Universiteit, Amsterdam, The Netherlands.
- * See the copyright notice in the ACK home directory, in the file "Copyright".
- */
-/* $Id$ */
-/*	EXPRESSION SYNTAX PARSER	*/
-
-{
-#include	<alloc.h>
-#include	"parameters.h"
-#include	<flt_arith.h>
-#include	"arith.h"
-#include	"LLlex.h"
-#include	"type.h"
-#include	"label.h"
-#include	"expr.h"
-#include	"code.h"
-#include	"sizes.h"
-
-extern struct expr *intexpr();
-int InSizeof = 0;	/* inside a sizeof- expression */
-int ResultKnown = 0;	/* result of the expression is already known */
-
-/* Since the grammar in the standard is not LL(n), it is modified so that
- * it accepts basically the same grammar. This means that there is no 1-1
- * mapping from the grammar in the standard to the grammar given here.
- * Such is life.
- */
-}
-
-/* 3.3.1 */
-primary(register struct expr **expp;) :
-	IDENTIFIER
-	{dot2expr(expp);}
-|
-	constant(expp)
-|
-	string(expp)
-|
-	'(' expression(expp) ')'
-	{ (*expp)->ex_flags |= EX_PARENS; }
-;
-
-
-/* Character string literals that are adjacent tokens
- * are concatenated into a single character string
- * literal.
- */
-string(register struct expr **expp;)
-	{	register int i, len;
-		register char *str;
-		register int fund;
-	}
-:
-	STRING
-	{	str = dot.tk_bts;
-		len = dot.tk_len;
-		fund = dot.tk_fund;
-	}
-	[
-		STRING
-		{	/* A pasted string keeps the type of the first
-			 * string literal.
-			 * The pasting of normal strings and wide
-			 * character strings are stated as having an
-			 * undefined behaviour.
-			 */
-			if (dot.tk_fund != fund)
-				warning("illegal pasting of string literals");
-			str = Realloc(str, (unsigned) (--len + dot.tk_len));
-			for (i = 0; i < dot.tk_len; i++)
-				str[len++] = dot.tk_bts[i];
-		}
-	]*
-	{ string2expr(expp, str, len); }
-;
-
-/* 3.3.2 */
-postfix_expression(register struct expr **expp;)
-	{ int oper; 
-	  struct expr *e1 = 0;
-	  struct idf *idf;
-	}
-:
-	primary(expp)
-	[
-		'[' expression(&e1) ']'
-			{ ch3bin(expp, '[', e1); e1 = 0; }
-	|
-		'(' parameter_list(&e1)? ')'
-			{ ch3bin(expp, '(', e1); call_proto(expp); e1 = 0; }
-	|
-		[ '.' | ARROW ]			{ oper = DOT; }
-		identifier(&idf)		{ ch3sel(expp, oper, idf); }
-	|
-		[
-			PLUSPLUS	{ oper = POSTINCR; }
-		|
-			MINMIN		{ oper = POSTDECR; }
-		]
-		    { ch3incr(expp, oper); }
-	]*
-;
-
-parameter_list(struct expr **expp;)
-	{struct expr *e1 = 0;}
-:
-	assignment_expression(expp)
-	{any2opnd(expp, PARCOMMA);}
-	[ %persistent
-		','
-		assignment_expression(&e1)
-		{any2opnd(&e1, PARCOMMA);}
-		{ch3bin(expp, PARCOMMA, e1);}
-	]*
-;
-
-%first	first_of_type_specifier, type_specifier;
-
-/* 3.3.3 & 3.3.4 */
-unary(register struct expr **expp;)
-	{struct type *tp; int oper;}
-:
-%if (first_of_type_specifier(AHEAD) && AHEAD != IDENTIFIER)
-	cast(&tp) unary(expp)
-	{	ch3cast(expp, CAST, tp);
-		(*expp)->ex_flags |= EX_CAST;
-		if (int_size != pointer_size)
-			(*expp)->ex_flags &= ~EX_PTRDIFF;
-	}
-|
-	postfix_expression(expp)
-|
-	unop(&oper) unary(expp)
-	{ch3mon(oper, expp);}
-|
-	size_of(expp)
-;
-
-/* When an identifier is used in a sizeof()-expression, we must stil not
- * mark it as used.
- * extern int i;  ....  sizeof(i)  .... need not have a definition for i
- */
-size_of(register struct expr **expp;)
-	{struct type *tp;}
-:
-	SIZEOF { InSizeof++; }	/* handle (sizeof(sizeof(int))) too */
-	[%if (first_of_type_specifier(AHEAD) && AHEAD != IDENTIFIER)
-		cast(&tp)
-		{
-			*expp = intexpr(size_of_type(tp, "type"), UNSIGNED);
-			(*expp)->ex_flags |= EX_SIZEOF;
-		}
-	|
-		unary(expp)
-		{ch3mon(SIZEOF, expp);}
-	]
-	{ InSizeof--; }
-;
-
-/* 3.3.5-3.3.17 */
-/*	The set of operators in C is stratified in 15 levels, with level
-	N being treated in RM 7.N (although this is not the standard
-	anymore). The standard describes this in phrase-structure-grammar,
-	which we are unable to parse. The description that follows comes
-	from the old C-compiler.
-
-	In principle each operator is assigned a rank, ranging
-	from 1 to 15.  Such an expression can be parsed by a construct
-	like:
-		binary_expression(int maxrank;)
-			{int oper;}
-		:
-			binary_expression(maxrank - 1)
-			[%if (rank_of(DOT) <= maxrank)
-				binop(&oper)
-				binary_expression(rank_of(oper)-1)
-			]?
-		;
-	except that some call of 'unary' is necessary, depending on the
-	grammar.
-	
-	This simple view is marred by three complications:
-	1.	Level 15 (comma operator) is not allowed in many
-		contexts and is different.
-	2.	Level 13 (conditional operator) is a ternary operator,
-		which does not fit this scheme at all.
-	3.	Level 14 (assignment operators) group right-to-left, as
-		opposed to 2-12, which group left-to-right (or are
-		immaterial).
-	4.	The operators in level 14 start with operators in levels
-		2-13 (RM 7.14: The two parts of a compound assignment
-		operator are separate tokens.)  This causes LL1 problems.
-	This forces us to have four rules:
-		binary_expression	for level 2-12
-		conditional_expression	for level 13
-		assignment_expression	for level 14 and
-		expression		for the most general expression
-*/
-
-binary_expression(int maxrank; struct expr **expp;)
-	{int oper, OldResultKnown; struct expr *e1;}
-:
-	unary(expp)
-	[%while (rank_of(DOT) <= maxrank )
-		/*	'?', '=', and ',' are no binops
-		 */
-		binop(&oper)
-		{ OldResultKnown = ResultKnown;
-		  if (oper == OR || oper == AND) {
-			  if (is_cp_cst(*expp) || is_fp_cst(*expp)) {
-				  if (is_zero_cst(*expp)) {
-					  if (oper == AND) ResultKnown++;
-				  } else if (oper == OR) ResultKnown++;
-			  }
-		  }
-		}
-		binary_expression(rank_of(oper)-1, &e1)
-		{
-			ch3bin(expp, oper, e1);
-			ResultKnown = OldResultKnown;
-		}
-	]*
-;
-
-/* 3.3.15 */
-conditional_expression(struct expr **expp;)
-	{struct expr *e1 = 0, *e2 = 0; int OldResultKnown, ConstExpr=0;}
-:
-	/* allow all binary operators */
-	binary_expression(rank_of('?') - 1, expp)
-	[	'?'
-		{ OldResultKnown = ResultKnown;
-		  if (is_cp_cst(*expp) || is_fp_cst(*expp)) {
-			  ConstExpr++;
-			  if (is_zero_cst(*expp)) ResultKnown++;
-		  }
-		}
-		expression(&e1)
-		':'
-		{ if (ConstExpr) {
-			if (OldResultKnown == ResultKnown) ResultKnown++;
-			else ResultKnown = OldResultKnown;
-		  }
-		}
-		conditional_expression(&e2)
-		{	
-			ResultKnown = OldResultKnown;
-			ch3bin(&e1, ':', e2);
-			opnd2test(expp, '?');
-			ch3bin(expp, '?', e1);
-		}
-	]?
-;
-
-/* 3.3.16 */
-assignment_expression(struct expr **expp;)
-	{ int oper;
-	  struct expr *e1 = 0;
-	}
-:
-	conditional_expression(expp)
-	[
-		asgnop(&oper)
-		assignment_expression(&e1)
-		{ch3asgn(expp, oper, e1);}
-	|
-		empty		/* LLgen artefact ??? */
-	]
-;
-
-/* 3.3.17 */
-expression(struct expr **expp;)
-	{struct expr *e1;}
-:
-	assignment_expression(expp)
-	[	','
-		assignment_expression(&e1)
-		{
-			ch3bin(expp, ',', e1);
-		}
-	]*
-;
-
-unop(int *oper;) :
-	['*' | '&' | '-' | '+' | '!' | '~' | PLUSPLUS | MINMIN]
-	{   if (DOT == '&') DOT = ADDRESSOF;
-	    *oper = DOT;
-	}
-;
-
-multop:
-	'*' | '/' | '%'
-;
-
-addop:
-	'+' | '-'
-;
-
-shiftop:
-	LEFT | RIGHT
-;
-
-relop:
-	'<' | '>' | LESSEQ | GREATEREQ
-;
-
-eqop:
-	EQUAL | NOTEQUAL
-;
-
-arithop:
-	multop | addop | shiftop
-|
-	'&' | '^' | '|'
-;
-
-binop(int *oper;) :
-	[ arithop | relop | eqop | AND | OR ]
-	{*oper = DOT;}
-;
-
-asgnop(register int *oper;):
-	[ '=' | PLUSAB | MINAB | TIMESAB | DIVAB | MODAB 
-	| LEFTAB | RIGHTAB | ANDAB | XORAB | ORAB ]
-	{ *oper = DOT; }
-
-;
-
-constant(struct expr **expp;) :
-[
-	INTEGER
-|
-	FLOATING
-]	{dot2expr(expp);}
-;
-
-/* 3.4 */
-constant_expression (struct expr **expp;) :
-	conditional_expression(expp)
-	{ chk_cst_expr(expp); }
-;
-
-identifier(struct idf **idfp;) :
-[ IDENTIFIER
-| TYPE_IDENTIFIER
-]
-	{ *idfp = dot.tk_idf; }
-;
+/*
+ * (c) copyright 1987 by the Vrije Universiteit, Amsterdam, The Netherlands.
+ * See the copyright notice in the ACK home directory, in the file "Copyright".
+ */
+/* $Id$ */
+/*	EXPRESSION SYNTAX PARSER	*/
+
+{
+#include	<alloc.h>
+#include	"parameters.h"
+#include	<flt_arith.h>
+#include	"arith.h"
+#include	"LLlex.h"
+#include	"type.h"
+#include	"label.h"
+#include	"expr.h"
+#include	"code.h"
+#include    "error.h"
+#include    "ch3.h"
+#include    "ch3bin.h"
+#include    "ch3mon.h"
+#include    "proto.h"
+#include	"sizes.h"
+
+extern struct expr *intexpr();
+int InSizeof = 0;	/* inside a sizeof- expression */
+int ResultKnown = 0;	/* result of the expression is already known */
+
+/* Since the grammar in the standard is not LL(n), it is modified so that
+ * it accepts basically the same grammar. This means that there is no 1-1
+ * mapping from the grammar in the standard to the grammar given here.
+ * Such is life.
+ */
+}
+
+/* 3.3.1 */
+primary(register struct expr **expp;) :
+	IDENTIFIER
+	{dot2expr(expp);}
+|
+	constant(expp)
+|
+	string(expp)
+|
+	'(' expression(expp) ')'
+	{ (*expp)->ex_flags |= EX_PARENS; }
+;
+
+
+/* Character string literals that are adjacent tokens
+ * are concatenated into a single character string
+ * literal.
+ */
+string(register struct expr **expp;)
+	{	register int i, len;
+		register char *str;
+		register int fund;
+	}
+:
+	STRING
+	{	str = dot.tk_bts;
+		len = dot.tk_len;
+		fund = dot.tk_fund;
+	}
+	[
+		STRING
+		{	/* A pasted string keeps the type of the first
+			 * string literal.
+			 * The pasting of normal strings and wide
+			 * character strings are stated as having an
+			 * undefined behaviour.
+			 */
+			if (dot.tk_fund != fund)
+				warning("illegal pasting of string literals");
+			str = Realloc(str, (unsigned) (--len + dot.tk_len));
+			for (i = 0; i < dot.tk_len; i++)
+				str[len++] = dot.tk_bts[i];
+		}
+	]*
+	{ string2expr(expp, str, len); }
+;
+
+/* 3.3.2 */
+postfix_expression(register struct expr **expp;)
+	{ int oper; 
+	  struct expr *e1 = 0;
+	  struct idf *idf;
+	}
+:
+	primary(expp)
+	[
+		'[' expression(&e1) ']'
+			{ ch3bin(expp, '[', e1); e1 = 0; }
+	|
+		'(' parameter_list(&e1)? ')'
+			{ ch3bin(expp, '(', e1); call_proto(expp); e1 = 0; }
+	|
+		[ '.' | ARROW ]			{ oper = DOT; }
+		identifier(&idf)		{ ch3sel(expp, oper, idf); }
+	|
+		[
+			PLUSPLUS	{ oper = POSTINCR; }
+		|
+			MINMIN		{ oper = POSTDECR; }
+		]
+		    { ch3incr(expp, oper); }
+	]*
+;
+
+parameter_list(struct expr **expp;)
+	{struct expr *e1 = 0;}
+:
+	assignment_expression(expp)
+	{any2opnd(expp, PARCOMMA);}
+	[ %persistent
+		','
+		assignment_expression(&e1)
+		{any2opnd(&e1, PARCOMMA);}
+		{ch3bin(expp, PARCOMMA, e1);}
+	]*
+;
+
+%first	first_of_type_specifier, type_specifier;
+
+/* 3.3.3 & 3.3.4 */
+unary(register struct expr **expp;)
+	{struct type *tp; int oper;}
+:
+%if (first_of_type_specifier(AHEAD) && AHEAD != IDENTIFIER)
+	cast(&tp) unary(expp)
+	{	ch3cast(expp, CAST, tp);
+		(*expp)->ex_flags |= EX_CAST;
+		if (int_size != pointer_size)
+			(*expp)->ex_flags &= ~EX_PTRDIFF;
+	}
+|
+	postfix_expression(expp)
+|
+	unop(&oper) unary(expp)
+	{ch3mon(oper, expp);}
+|
+	size_of(expp)
+;
+
+/* When an identifier is used in a sizeof()-expression, we must stil not
+ * mark it as used.
+ * extern int i;  ....  sizeof(i)  .... need not have a definition for i
+ */
+size_of(register struct expr **expp;)
+	{struct type *tp;}
+:
+	SIZEOF { InSizeof++; }	/* handle (sizeof(sizeof(int))) too */
+	[%if (first_of_type_specifier(AHEAD) && AHEAD != IDENTIFIER)
+		cast(&tp)
+		{
+			*expp = intexpr(size_of_type(tp, "type"), UNSIGNED);
+			(*expp)->ex_flags |= EX_SIZEOF;
+		}
+	|
+		unary(expp)
+		{ch3mon(SIZEOF, expp);}
+	]
+	{ InSizeof--; }
+;
+
+/* 3.3.5-3.3.17 */
+/*	The set of operators in C is stratified in 15 levels, with level
+	N being treated in RM 7.N (although this is not the standard
+	anymore). The standard describes this in phrase-structure-grammar,
+	which we are unable to parse. The description that follows comes
+	from the old C-compiler.
+
+	In principle each operator is assigned a rank, ranging
+	from 1 to 15.  Such an expression can be parsed by a construct
+	like:
+		binary_expression(int maxrank;)
+			{int oper;}
+		:
+			binary_expression(maxrank - 1)
+			[%if (rank_of(DOT) <= maxrank)
+				binop(&oper)
+				binary_expression(rank_of(oper)-1)
+			]?
+		;
+	except that some call of 'unary' is necessary, depending on the
+	grammar.
+	
+	This simple view is marred by three complications:
+	1.	Level 15 (comma operator) is not allowed in many
+		contexts and is different.
+	2.	Level 13 (conditional operator) is a ternary operator,
+		which does not fit this scheme at all.
+	3.	Level 14 (assignment operators) group right-to-left, as
+		opposed to 2-12, which group left-to-right (or are
+		immaterial).
+	4.	The operators in level 14 start with operators in levels
+		2-13 (RM 7.14: The two parts of a compound assignment
+		operator are separate tokens.)  This causes LL1 problems.
+	This forces us to have four rules:
+		binary_expression	for level 2-12
+		conditional_expression	for level 13
+		assignment_expression	for level 14 and
+		expression		for the most general expression
+*/
+
+binary_expression(int maxrank; struct expr **expp;)
+	{int oper, OldResultKnown; struct expr *e1;}
+:
+	unary(expp)
+	[%while (rank_of(DOT) <= maxrank )
+		/*	'?', '=', and ',' are no binops
+		 */
+		binop(&oper)
+		{ OldResultKnown = ResultKnown;
+		  if (oper == OR || oper == AND) {
+			  if (is_cp_cst(*expp) || is_fp_cst(*expp)) {
+				  if (is_zero_cst(*expp)) {
+					  if (oper == AND) ResultKnown++;
+				  } else if (oper == OR) ResultKnown++;
+			  }
+		  }
+		}
+		binary_expression(rank_of(oper)-1, &e1)
+		{
+			ch3bin(expp, oper, e1);
+			ResultKnown = OldResultKnown;
+		}
+	]*
+;
+
+/* 3.3.15 */
+conditional_expression(struct expr **expp;)
+	{struct expr *e1 = 0, *e2 = 0; int OldResultKnown, ConstExpr=0;}
+:
+	/* allow all binary operators */
+	binary_expression(rank_of('?') - 1, expp)
+	[	'?'
+		{ OldResultKnown = ResultKnown;
+		  if (is_cp_cst(*expp) || is_fp_cst(*expp)) {
+			  ConstExpr++;
+			  if (is_zero_cst(*expp)) ResultKnown++;
+		  }
+		}
+		expression(&e1)
+		':'
+		{ if (ConstExpr) {
+			if (OldResultKnown == ResultKnown) ResultKnown++;
+			else ResultKnown = OldResultKnown;
+		  }
+		}
+		conditional_expression(&e2)
+		{	
+			ResultKnown = OldResultKnown;
+			ch3bin(&e1, ':', e2);
+			opnd2test(expp, '?');
+			ch3bin(expp, '?', e1);
+		}
+	]?
+;
+
+/* 3.3.16 */
+assignment_expression(struct expr **expp;)
+	{ int oper;
+	  struct expr *e1 = 0;
+	}
+:
+	conditional_expression(expp)
+	[
+		asgnop(&oper)
+		assignment_expression(&e1)
+		{ch3asgn(expp, oper, e1);}
+	|
+		empty		/* LLgen artefact ??? */
+	]
+;
+
+/* 3.3.17 */
+expression(struct expr **expp;)
+	{struct expr *e1;}
+:
+	assignment_expression(expp)
+	[	','
+		assignment_expression(&e1)
+		{
+			ch3bin(expp, ',', e1);
+		}
+	]*
+;
+
+unop(int *oper;) :
+	['*' | '&' | '-' | '+' | '!' | '~' | PLUSPLUS | MINMIN]
+	{   if (DOT == '&') DOT = ADDRESSOF;
+	    *oper = DOT;
+	}
+;
+
+multop:
+	'*' | '/' | '%'
+;
+
+addop:
+	'+' | '-'
+;
+
+shiftop:
+	LEFT | RIGHT
+;
+
+relop:
+	'<' | '>' | LESSEQ | GREATEREQ
+;
+
+eqop:
+	EQUAL | NOTEQUAL
+;
+
+arithop:
+	multop | addop | shiftop
+|
+	'&' | '^' | '|'
+;
+
+binop(int *oper;) :
+	[ arithop | relop | eqop | AND | OR ]
+	{*oper = DOT;}
+;
+
+asgnop(register int *oper;):
+	[ '=' | PLUSAB | MINAB | TIMESAB | DIVAB | MODAB 
+	| LEFTAB | RIGHTAB | ANDAB | XORAB | ORAB ]
+	{ *oper = DOT; }
+
+;
+
+constant(struct expr **expp;) :
+[
+	INTEGER
+|
+	FLOATING
+]	{dot2expr(expp);}
+;
+
+/* 3.4 */
+constant_expression (struct expr **expp;) :
+	conditional_expression(expp)
+	{ chk_cst_expr(expp); }
+;
+
+identifier(struct idf **idfp;) :
+[ IDENTIFIER
+| TYPE_IDENTIFIER
+]
+	{ *idfp = dot.tk_idf; }
+;
diff --git a/lang/cem/cemcom.ansi/field.c b/lang/cem/cemcom.ansi/field.c
index f5635d1fe..d1b014c01 100644
--- a/lang/cem/cemcom.ansi/field.c
+++ b/lang/cem/cemcom.ansi/field.c
@@ -23,8 +23,11 @@
 #include	"align.h"
 #include	"Lpars.h"
 #include	"field.h"
+#include    "util.h"
+#include    "conversion.h"
+#include    "eval.h"
+
 
-arith NewLocal();		/* util.c	*/
 extern arith full_mask[];	/* cstoper.c	*/
 
 /*	Eval_field() evaluates expressions involving bit fields.
@@ -39,9 +42,9 @@ extern arith full_mask[];	/* cstoper.c	*/
 	[3]	atype: the type in which the bitfield arithmetic is done;
 		and in which bitfields are stored!
 */
-eval_field(expr, code)
-	struct expr *expr;
-	int code;
+void eval_field(
+	struct expr *expr,
+	int code)
 {
 	int op = expr->OP_OPER;
 	register struct expr *leftop = expr->OP_LEFT;
@@ -126,12 +129,12 @@ eval_field(expr, code)
 	}
 }
 
-store_field(fd, uns, code, leftop, tmpvar)
-	register struct field *fd;
-	int uns;
-	int code;
-	register struct expr *leftop;
-	arith tmpvar;
+void store_field(
+	register struct field *fd,
+	int uns,
+	int code,
+	register struct expr *leftop,
+	arith tmpvar)
 {
 	C_loc(fd->fd_mask);
 	C_and(word_size);
diff --git a/lang/cem/cemcom.ansi/field.str b/lang/cem/cemcom.ansi/field.str
index 7b4f219a1..2c8635c43 100644
--- a/lang/cem/cemcom.ansi/field.str
+++ b/lang/cem/cemcom.ansi/field.str
@@ -2,6 +2,11 @@
  * (c) copyright 1987 by the Vrije Universiteit, Amsterdam, The Netherlands.
  * See the copyright notice in the ACK home directory, in the file "Copyright".
  */
+#ifndef FIELD_H_
+#define FIELD_H_
+
+#include "arith.h"
+
 /* $Id$ */
 /* FIELD DESCRIPTOR */
 
@@ -13,3 +18,20 @@ struct field	{	/* for field specifiers	*/
 };
 
 /* ALLOCDEF "field" 10 */
+
+#ifndef	LINT
+
+
+#ifndef NOBITFIELD
+
+struct expr;
+
+void store_field(register struct field *fd, int uns, int code,
+		register struct expr *leftop, arith tmpvar);
+void eval_field(struct expr *expr, int code);
+
+#endif /* NOBITFIELD */
+
+#endif	/* LINT */
+
+#endif /* FIELD_H_ */
\ No newline at end of file
diff --git a/lang/cem/cemcom.ansi/fltcstoper.c b/lang/cem/cemcom.ansi/fltcstoper.c
index 7b48fc725..c33d7a278 100644
--- a/lang/cem/cemcom.ansi/fltcstoper.c
+++ b/lang/cem/cemcom.ansi/fltcstoper.c
@@ -10,18 +10,19 @@
 #include	"parameters.h"
 #include	<alloc.h>
 #include	<flt_arith.h>
+#include    "fltcstoper.h"
 #include	"arith.h"
 #include	"type.h"
 #include	"label.h"
 #include	"expr.h"
 #include	"sizes.h"
 #include	"Lpars.h"
+#include    "error.h"
 
 extern int ResultKnown;
 extern char *symbol2str();
 
-fltcstbin(expp, oper, expr)
-	register struct expr **expp, *expr;
+void fltcstbin(register struct expr **expp, int oper, register struct expr *expr)
 {
 	/*	The operation oper is performed on the constant
 		expressions *expp(ld) and expr(ct), and the result restored in
diff --git a/lang/cem/cemcom.ansi/fltcstoper.h b/lang/cem/cemcom.ansi/fltcstoper.h
new file mode 100644
index 000000000..4b65618f6
--- /dev/null
+++ b/lang/cem/cemcom.ansi/fltcstoper.h
@@ -0,0 +1,15 @@
+/*  Copyright (c) 2019 ACK Project.
+ *  See the copyright notice in the ACK home directory, 
+ *  in the file "Copyright".
+ *
+ *  Created on: 2019-02-07
+ *  
+ */
+#ifndef FLTCSTOPER_H_
+#define FLTCSTOPER_H_
+
+struct expr;
+
+void fltcstbin(register struct expr **expp, int oper, register struct expr *expr);
+
+#endif /* FLTCSTOPER_H_ */
diff --git a/lang/cem/cemcom.ansi/idf.c b/lang/cem/cemcom.ansi/idf.c
index 54727221e..4d3f0fc89 100644
--- a/lang/cem/cemcom.ansi/idf.c
+++ b/lang/cem/cemcom.ansi/idf.c
@@ -25,6 +25,12 @@
 #include	"declar.h"
 #include	"decspecs.h"
 #include	"sizes.h"
+#include    "print.h"
+#include    "util.h"
+#include    "stab.h"
+#include    "code.h"
+#include    "error.h"
+#include    "ch3.h"
 #include	"Lpars.h"
 
 extern char options[];
@@ -37,91 +43,92 @@ extern char *symbol2str();
 
 #include <idf_pkg.body>
 
-void global_redecl();
 
-struct idf *
-gen_idf()
+
+struct idf *gen_idf(void)
 {
 	/*	A new idf is created out of nowhere, to serve as an
-		anonymous name.
-	*/
+	 anonymous name.
+	 */
 	static int name_cnt;
 	char *s = Malloc(strlen(dot.tk_file) + 50);
 
-	sprint(s, "#%d in %s, line %u",
-			++name_cnt, dot.tk_file, dot.tk_line);
-	s = Realloc(s, strlen(s)+1);
+	sprint(s, "#%d in %s, line %u", ++name_cnt, dot.tk_file, dot.tk_line);
+	s = Realloc(s, strlen(s) + 1);
 	return str2idf(s, 0);
 }
 
-int
-is_anon_idf(idf)
-	struct idf *idf;
+int is_anon_idf(struct idf *idf)
 {
 	return idf->id_text[0] == '#';
 }
 
-declare_idf(ds, dc, lvl)
-	struct decspecs *ds;
-	struct declarator *dc;
+void declare_idf(struct decspecs *ds, struct declarator *dc, int lvl)
 {
 	/*	The identifier inside dc is declared on the level lvl, with
-		properties deduced from the decspecs ds and the declarator
-		dc.
-		The level is given explicitly to be able to insert, e.g.,
-		labels on the outermost level inside the function.
-		This routine implements the rich semantics of C
-		declarations.
-	*/
+	 properties deduced from the decspecs ds and the declarator
+	 dc.
+	 The level is given explicitly to be able to insert, e.g.,
+	 labels on the outermost level inside the function.
+	 This routine implements the rich semantics of C
+	 declarations.
+	 */
 	register struct idf *idf = dc->dc_idf;
 	register int sc = ds->ds_sc;
-		/*	This local copy is essential:
-				char b(), c;
-			makes b GLOBAL and c AUTO.
-		*/
-	register struct def *def = idf->id_def;		/* may be NULL */
+	/*	This local copy is essential:
+	 char b(), c;
+	 makes b GLOBAL and c AUTO.
+	 */
+	register struct def *def = idf->id_def; /* may be NULL */
 	register struct type *type;
 	struct stack_level *stl = stack_level_of(lvl);
 	char formal_array = 0;
-	
+
 	/* determine the present type */
-	if (ds->ds_type == 0)	{
+	if (ds->ds_type == 0)
+	{
 		/*	at the L_FORMAL1 level there is no type specified yet
-		*/
+		 */
 		assert(lvl == L_FORMAL1);
-		type = int_type;	/* may change at L_FORMAL2 */
+		type = int_type; /* may change at L_FORMAL2 */
 	}
-	else	{
+	else
+	{
 		/* combine the decspecs and the declarator into one type */
 		type = declare_type(ds->ds_type, dc);
-		if (type->tp_size <= (arith)0 &&
-		    actual_declaration(sc, type))	{
-			if (type->tp_size == (arith) -1) {
+		if (type->tp_size <= (arith) 0 && actual_declaration(sc, type))
+		{
+			if (type->tp_size == (arith) -1)
+			{
 				/* the type is not yet known,
-				   but it has to be:
-				*/
-				if (type->tp_fund != VOID) {
-				    if (level != L_GLOBAL)
-					error("unknown %s-type",
-						symbol2str(type->tp_fund));
-				} else	error("void is not a complete type");
+				 but it has to be:
+				 */
+				if (type->tp_fund != VOID)
+				{
+					if (level != L_GLOBAL)
+						error("unknown %s-type", symbol2str(type->tp_fund));
+				}
+				else
+					error("void is not a complete type");
 			}
-			else strict("%s has size 0", idf->id_text);
+			else
+				strict("%s has size 0", idf->id_text);
 		}
 	}
 
 	/* some additional work for formal definitions */
-	if (lvl == L_FORMAL2)	{
-		switch (type->tp_fund)	{
+	if (lvl == L_FORMAL2)
+	{
+		switch (type->tp_fund)
+		{
 		case FUNCTION:
-			warning("%s is a function; cannot be formal",
-				idf->id_text);
-			type = construct_type(POINTER, type, 0, (arith)0,
-					      NO_PROTO);
+			warning("%s is a function; cannot be formal", idf->id_text);
+			type = construct_type(POINTER, type, 0, (arith) 0,
+			NO_PROTO);
 			break;
-		case ARRAY:	/* 3.7.1 */
-			type = construct_type(POINTER, type->tp_up, 0, (arith)0,
-					      NO_PROTO);
+		case ARRAY: /* 3.7.1 */
+			type = construct_type(POINTER, type->tp_up, 0, (arith) 0,
+			NO_PROTO);
 			formal_array = 1;
 			break;
 		case FLOAT:
@@ -135,72 +142,77 @@ declare_idf(ds, dc, lvl)
 		}
 	}
 	/*	The tests on types, postponed from do_decspecs(), can now
-		be performed.
-	*/
+	 be performed.
+	 */
 	/* update the storage class */
-	if (type && type->tp_fund == FUNCTION)	{
-		if (lvl != L_GLOBAL)  {		/* 3.5.1 */
+	if (type && type->tp_fund == FUNCTION)
+	{
+		if (lvl != L_GLOBAL)
+		{ /* 3.5.1 */
 			if (sc == 0)
 				sc = GLOBAL;
-			else if (sc != EXTERN && sc != TYPEDEF) {
-				error("illegal storage class %s for function with block-scope"
-					, symbol2str(sc));
+			else if (sc != EXTERN && sc != TYPEDEF)
+			{
+				error("illegal storage class %s for function with block-scope",
+						symbol2str(sc));
 				ds->ds_sc = sc = EXTERN;
 			}
 		}
 		else if (sc == 0)
 			sc = GLOBAL;
 	}
-	else	/* non-FUNCTION */
-		if (sc == 0)
-			sc =	lvl == L_GLOBAL ? GLOBAL
-				: lvl == L_FORMAL1 || lvl == L_FORMAL2 ? FORMAL
-				: AUTO;
+	else /* non-FUNCTION */
+	if (sc == 0)
+		sc = lvl == L_GLOBAL ? GLOBAL :
+				lvl == L_FORMAL1 || lvl == L_FORMAL2 ? FORMAL : AUTO;
 
 #ifdef	LINT
-	check_hiding(idf, lvl, sc);	/* of some idf by this idf */
+	check_hiding(idf, lvl, sc); /* of some idf by this idf */
 #endif	/* LINT */
-	if (def && lvl == L_LOCAL && def->df_level == L_FORMAL2) {
+	if (def && lvl == L_LOCAL && def->df_level == L_FORMAL2)
+	{
 		error("%s redeclared", idf->id_text);
 	}
 
-	if (def && 
-	    ( def->df_level == lvl ||
-	      ( lvl != L_GLOBAL && def->df_level > lvl ) ||
-	      (lvl == L_GLOBAL
-	       && def->df_level == L_PROTO
-	       && def->next && def->next->df_level == L_GLOBAL)
-	   ))	{
+	if (def
+			&& (def->df_level == lvl || (lvl != L_GLOBAL && def->df_level > lvl)
+					|| (lvl == L_GLOBAL && def->df_level == L_PROTO && def->next
+							&& def->next->df_level == L_GLOBAL)))
+	{
 		/*	There is already a declaration for idf on this
-			level, or even more inside.
-			The rules differ for different levels.
-		*/
-		switch (lvl)	{
+		 level, or even more inside.
+		 The rules differ for different levels.
+		 */
+		switch (lvl)
+		{
 		case L_GLOBAL:
 			global_redecl(idf, sc, type);
 			def->df_file = idf->id_file;
 			def->df_line = idf->id_line;
 			break;
-		case L_FORMAL1:	/* formal declaration */
+		case L_FORMAL1: /* formal declaration */
 			error("formal %s redeclared", idf->id_text);
 			break;
-		case L_FORMAL2:	/* formal definition */
-		default:	/* local */
-			if (sc != EXTERN) error("%s redeclared", idf->id_text);
+		case L_FORMAL2: /* formal definition */
+		default: /* local */
+			if (sc != EXTERN)
+				error("%s redeclared", idf->id_text);
 			break;
 		}
 	}
-	else	/* the idf is unknown on this level */
-	if (lvl == L_FORMAL2 && sc != ENUM && good_formal(def, idf))	{
+	else /* the idf is unknown on this level */
+	if (lvl == L_FORMAL2 && sc != ENUM && good_formal(def, idf))
+	{
 		/* formal declaration, update only */
 		def->df_type = type;
 		def->df_formal_array = formal_array;
 		def->df_sc = sc;
-		def->df_level = L_FORMAL2;	/* CJ */
+		def->df_level = L_FORMAL2; /* CJ */
 		def->df_file = idf->id_file;
 		def->df_line = idf->id_line;
 	}
-	else	{ /* fill in the def block */
+	else
+	{ /* fill in the def block */
 		register struct def *newdef = new_def();
 
 		newdef->next = def;
@@ -218,28 +230,27 @@ declare_idf(ds, dc, lvl)
 		update_ahead(idf);
 		stack_idf(idf, stl);
 		/*	We now calculate the address.
-			Globals have names and don't get addresses, they
-			get numbers instead (through data_label()).
-			Formals are handled by declare_formals().
-			So here we hand out local addresses only.
-		*/
-		if (lvl >= L_LOCAL)	{
+		 Globals have names and don't get addresses, they
+		 get numbers instead (through data_label()).
+		 Formals are handled by declare_formals().
+		 So here we hand out local addresses only.
+		 */
+		if (lvl >= L_LOCAL)
+		{
 			assert(sc);
-			switch (sc)	{
+			switch (sc)
+			{
 			case REGISTER:
 			case AUTO:
-				if (type->tp_size == (arith)-1
-					&& type->tp_fund != ARRAY) {
-					error("size of local %s unknown",
-						idf->id_text);
-				/** type = idf->id_def->df_type = int_type; **/
+				if (type->tp_size == (arith) -1 && type->tp_fund != ARRAY)
+				{
+					error("size of local %s unknown", idf->id_text);
+					/** type = idf->id_def->df_type = int_type; **/
 				}
-				if (type->tp_size != (arith) -1) {
-				    newdef->df_address =
-					NewLocal(type->tp_size,
-						 type->tp_align,
-						 regtype(type),
-						 sc);
+				if (type->tp_size != (arith) -1)
+				{
+					newdef->df_address = NewLocal(type->tp_size, type->tp_align,
+							regtype(type), sc);
 				}
 				break;
 			case STATIC:
@@ -250,21 +261,19 @@ declare_idf(ds, dc, lvl)
 	}
 }
 
-int
-actual_declaration(sc, tp)
-	int sc;
-	struct type *tp;
+int actual_declaration(int sc, struct type *tp)
 {
 	/*	An actual_declaration needs space, right here and now.
-	*/
+	 */
 	register int fund = tp->tp_fund;
-	
+
 	if (sc == ENUM || sc == TYPEDEF) /* virtual declarations */
 		return 0;
 	if (fund == FUNCTION || fund == ARRAY)
 		/* allocation solved in other ways */
 		return 0;
-	if (sc == EXTERN && fund == VOID) {
+	if (sc == EXTERN && fund == VOID)
+	{
 		/* strange, but should be accepted */
 		return 0;
 	}
@@ -272,51 +281,59 @@ actual_declaration(sc, tp)
 	return 1;
 }
 
-void
-global_redecl(idf, new_sc, tp)
-	register struct idf *idf;
-	struct type *tp;
+void global_redecl(register struct idf *idf, int new_sc, struct type *tp)
 {
 	/*	A global identifier may be declared several times,
-		provided the declarations do not conflict; they might
-		conflict in type (or supplement each other in the case of
-		an array) or they might conflict or supplement each other
-		in storage class.
-	*/
+	 provided the declarations do not conflict; they might
+	 conflict in type (or supplement each other in the case of
+	 an array) or they might conflict or supplement each other
+	 in storage class.
+	 */
 	register struct def *def = idf->id_def;
 
-	while (def->df_level != L_GLOBAL) def = def->next;
-	if (!equal_type(tp, def->df_type, 0, 1)) {
+	while (def->df_level != L_GLOBAL)
+		def = def->next;
+	if (!equal_type(tp, def->df_type, 0, 1))
+	{
 		error("redeclaration of %s with different type", idf->id_text);
 		return;
-	} else	update_proto(tp, def->df_type);
-	if (tp->tp_fund == ARRAY) {
+	}
+	else
+		update_proto(tp, def->df_type);
+	if (tp->tp_fund == ARRAY)
+	{
 		/* Multiple array declaration; this may be interesting */
-		if (tp->tp_size < 0)	{		/* new decl has [] */
+		if (tp->tp_size < 0)
+		{ /* new decl has [] */
 			/* nothing new */
-		} else
-		if (def->df_type->tp_size < 0)	{	/* old decl has [] */
+		}
+		else if (def->df_type->tp_size < 0)
+		{ /* old decl has [] */
 			def->df_type = tp;
 		}
-	} if (tp->tp_fund == FUNCTION && new_sc == GLOBAL) {
+	}
+	if (tp->tp_fund == FUNCTION && new_sc == GLOBAL)
+	{
 		/* see 3.1.2.2 */
 		new_sc = EXTERN;
 	}
 
 	/*	Now we may be able to update the storage class.
-		Clean out this mess as soon as we know all the possibilities
-		for new_sc.
-		For now we have:
-			EXTERN:		we have seen the word "extern"
-			GLOBAL:		the item was declared on the outer
-					level, without either "extern" or
-					"static".
-			STATIC:		we have seen the word "static"
-	*/
+	 Clean out this mess as soon as we know all the possibilities
+	 for new_sc.
+	 For now we have:
+	 EXTERN:		we have seen the word "extern"
+	 GLOBAL:		the item was declared on the outer
+	 level, without either "extern" or
+	 "static".
+	 STATIC:		we have seen the word "static"
+	 */
 
-	switch (def->df_sc)	{	/* the old storage class */
+	switch (def->df_sc)
+	{ /* the old storage class */
 	case EXTERN:
-		switch (new_sc)	{	/* the new storage class */
+		switch (new_sc)
+		{ /* the new storage class */
 		case STATIC:
 			warning("%s redeclared static", idf->id_text);
 			/* fallthrough */
@@ -331,8 +348,9 @@ global_redecl(idf, new_sc, tp)
 		}
 		break;
 	case GLOBAL:
-		switch (new_sc)	{	/* the new storage class */
-		case STATIC:		/* linkage disagreement */
+		switch (new_sc)
+		{ /* the new storage class */
+		case STATIC: /* linkage disagreement */
 			warning("%s redeclared static", idf->id_text);
 			def->df_sc = new_sc;
 			/* fallthrough */
@@ -345,8 +363,9 @@ global_redecl(idf, new_sc, tp)
 		}
 		break;
 	case STATIC:
-		switch (new_sc)	{	/* the new storage class */
-		case GLOBAL:		/* linkage disagreement */
+		switch (new_sc)
+		{ /* the new storage class */
+		case GLOBAL: /* linkage disagreement */
 		case EXTERN:
 			warning("%s is already declared static", idf->id_text);
 			/* fallthrough */
@@ -367,142 +386,147 @@ global_redecl(idf, new_sc, tp)
 	}
 }
 
-int
-good_formal(def, idf)
-	register struct def *def;
-	register struct idf *idf;
+int good_formal(register struct def *def, register struct idf *idf)
 {
 	/*	Succeeds if def is a proper L_FORMAL1 definition and
-		gives an error message otherwise.
-	*/
-	if (!def || def->df_level != L_FORMAL1)	{ /* not in parameter list */
+	 gives an error message otherwise.
+	 */
+	if (!def || def->df_level != L_FORMAL1)
+	{ /* not in parameter list */
 		if (!is_anon_idf(idf))
 			error("%s not in parameter list", idf->id_text);
 		return 0;
 	}
-	assert(def->df_sc == FORMAL);	/* CJ */
+	assert(def->df_sc == FORMAL); /* CJ */
 	return 1;
 }
 
-declare_params(dc)
-	struct declarator *dc;
+void declare_params(struct declarator *dc)
 {
 	/*	Declares the formal parameters if they exist.
-	*/
+	 */
 	register struct formal *fm = dc->dc_formal;
 
-	while (fm)	{
+	while (fm)
+	{
 		declare_parameter(fm->fm_idf);
 		fm = fm->next;
 	}
 }
 
-void
-idf_initialized(idf)
-	register struct idf *idf;
+void idf_initialized(register struct idf *idf)
 {
 	/*	The topmost definition of idf is set to initialized.
-	*/
-	register struct def *def = idf->id_def;	/* the topmost */
-	
-	while (def->df_level <= L_PROTO) def = def->next;
+	 */
+	register struct def *def = idf->id_def; /* the topmost */
+
+	while (def->df_level <= L_PROTO)
+		def = def->next;
 	if (def->df_initialized)
 		error("multiple initialization of %s", idf->id_text);
-	if (def->df_sc == TYPEDEF)	{
+	if (def->df_sc == TYPEDEF)
+	{
 		error("typedef cannot be initialized");
 		return;
 	}
 	def->df_initialized = 1;
 }
 
-declare_parameter(idf)
-	struct idf *idf;
+void declare_parameter(struct idf *idf)
 {
 	/*	idf is declared as a formal.
-	*/
+	 */
 	add_def(idf, FORMAL, int_type, level);
 }
 
-declare_enum(tp, idf, l)
-	struct type *tp;
-	struct idf *idf;
-	arith l;
+void declare_enum(struct type *tp, struct idf *idf, arith l)
 {
 	/*	idf is declared as an enum constant with value l.
-	*/
+	 */
 	add_def(idf, ENUM, tp, level);
 	idf->id_def->df_address = l;
 }
 
-void
-check_formals(idf, dc)
-	struct idf *idf;
-	struct declarator *dc;
+void check_formals(struct idf *idf, struct declarator *dc)
 {
 	register struct formal *fm = dc->dc_formal;
 	register struct proto *pl = idf->id_def->df_type->tp_proto;
 	register struct decl_unary *du = dc->dc_decl_unary;
 
-	if (!du) {	/* error or typdef'ed function */
+	if (!du)
+	{ /* error or typdef'ed function */
 		error("illegal definition of %s", idf->id_text);
 		return;
 	}
 
 	while (du
-		&& (du->du_fund != FUNCTION
-		    || du->next != (struct decl_unary *) 0)) {
+			&& (du->du_fund != FUNCTION || du->next != (struct decl_unary *) 0))
+	{
 		du = du->next;
 	}
-	if (!du) return;	/* terrible error, signalled earlier */
+	if (!du)
+		return; /* terrible error, signalled earlier */
 
-	if (du->du_proto) return;
+	if (du->du_proto)
+		return;
 
-	if (pl) {
+	if (pl)
+	{
 		/* Don't give a warning about an old-style definition,
 		 * since the arguments will be checked anyway.
 		 */
-		if (pl->pl_flag & PL_ELLIPSIS) {
-		    if (!(du->du_proto) && !(pl->pl_flag & PL_ERRGIVEN))
-			error("ellipsis terminator in previous declaration");
-		    pl = pl->next;
+		if (pl->pl_flag & PL_ELLIPSIS)
+		{
+			if (!(du->du_proto) && !(pl->pl_flag & PL_ERRGIVEN))
+				error("ellipsis terminator in previous declaration");
+			pl = pl->next;
 		}
-		else if (pl->pl_flag & PL_VOID) {
-		    pl = pl->next;			/* should be 0 */
+		else if (pl->pl_flag & PL_VOID)
+		{
+			pl = pl->next; /* should be 0 */
 		}
-		while(fm && pl) {
-		    if (!equal_type(promoted_type(fm->fm_idf->id_def->df_type)
-					, pl->pl_type, -1, 1)) {
-			if (!(pl->pl_flag & PL_ERRGIVEN))
-			    error("incorrect type for parameter %s"
-						, fm->fm_idf->id_text);
-			pl->pl_flag |= PL_ERRGIVEN;
-		    }
-		    fm = fm->next;
-		    pl = pl->next;
+		while (fm && pl)
+		{
+			if (!equal_type(promoted_type(fm->fm_idf->id_def->df_type),
+					pl->pl_type, -1, 1))
+			{
+				if (!(pl->pl_flag & PL_ERRGIVEN))
+					error("incorrect type for parameter %s",
+							fm->fm_idf->id_text);
+				pl->pl_flag |= PL_ERRGIVEN;
+			}
+			fm = fm->next;
+			pl = pl->next;
 		}
-		if (pl || fm) {
+		if (pl || fm)
+		{
 			error("incorrect number of parameters");
 		}
-	} else {			/* make a pseudo-prototype */
+	}
+	else
+	{ /* make a pseudo-prototype */
 		register struct proto *lpl = new_proto();
 
 		if (!options['o'])
-			warning("'%s' old-fashioned function definition"
-					, dc->dc_idf->id_text);
+			warning("'%s' old-fashioned function definition",
+					dc->dc_idf->id_text);
 
-		while (fm) {
-			if (pl == 0) pl = lpl;
-			else {
+		while (fm)
+		{
+			if (pl == 0)
+				pl = lpl;
+			else
+			{
 				lpl->next = new_proto();
 				lpl = lpl->next;
 			}
 			lpl->pl_flag = PL_FORMAL;
 			lpl->pl_idf = fm->fm_idf;
-			lpl->pl_type =
-				    promoted_type(fm->fm_idf->id_def->df_type);
+			lpl->pl_type = promoted_type(fm->fm_idf->id_def->df_type);
 			fm = fm->next;
 		}
-		if (pl == 0) {		/* make func(void) */
+		if (pl == 0)
+		{ /* make func(void) */
 			pl = lpl;
 			pl->pl_type = void_type;
 			pl->pl_flag = PL_FORMAL | PL_VOID;
@@ -513,26 +537,26 @@ check_formals(idf, dc)
 	dc->dc_formal = 0;
 }
 
-declare_formals(idf, fp)
-	struct idf *idf;
-	arith *fp;
+void declare_formals(struct idf *idf, arith *fp)
 {
 	/*	Declares those formals as int that haven't been declared
-		by the user.
-		An address is assigned to each formal parameter.
-		The total size of the formals is returned in *fp;
-	*/
+	 by the user.
+	 An address is assigned to each formal parameter.
+	 The total size of the formals is returned in *fp;
+	 */
 	register struct stack_entry *se = stack_level_of(L_FORMAL1)->sl_entry;
-	arith f_offset = (arith)0;
+	arith f_offset = (arith) 0;
 	register int nparams = 0;
 	int hasproto;
 	struct def *df = idf->id_def;
 
 	/* When one of the formals has the same name as the function, 
-	   it hides the function def. Get it.
-	*/
-	while (se) {
-		if (se->se_idf == idf) {
+	 it hides the function def. Get it.
+	 */
+	while (se)
+	{
+		if (se->se_idf == idf)
+		{
 			df = df->next;
 			break;
 		}
@@ -540,49 +564,53 @@ declare_formals(idf, fp)
 	}
 
 	se = stack_level_of(L_FORMAL1)->sl_entry;
-	
+
 	hasproto = df->df_type->tp_proto != 0;
 
 #ifdef	DEBUG
 	if (options['t'])
-		dumpidftab("start declare_formals", 0);
+	dumpidftab("start declare_formals", 0);
 #endif	/* DEBUG */
-	if (is_struct_or_union(df->df_type->tp_up->tp_fund)) {
+	if (is_struct_or_union(df->df_type->tp_up->tp_fund))
+	{
 		/* create space for address of return value */
 		f_offset = pointer_size;
 	}
-	while (se)	{
+	while (se)
+	{
 		df = se->se_idf->id_def;
-		
+
 		/* this stacklevel may also contain tags. ignore them */
-		if (!df || df->df_level < L_FORMAL1 ) {
+		if (!df || df->df_level < L_FORMAL1)
+		{
 			se = se->next;
 			continue;
 		}
 
 		df->df_address = f_offset;
 		/*	the alignment convention for parameters is: align on
-			word boundaries, i.e. take care that the following
-			parameter starts on a new word boundary.
-		*/
-		if (! hasproto 
-		    && df->df_type->tp_fund == FLOAT
-		    && df->df_type->tp_size != double_size) {
+		 word boundaries, i.e. take care that the following
+		 parameter starts on a new word boundary.
+		 */
+		if (!hasproto && df->df_type->tp_fund == FLOAT
+				&& df->df_type->tp_size != double_size)
+		{
 			f_offset = align(f_offset + double_size, (int) word_size);
 		}
-		else f_offset = align(f_offset + df->df_type->tp_size, (int) word_size);
+		else
+			f_offset = align(f_offset + df->df_type->tp_size, (int) word_size);
 		RegisterAccount(df->df_address, df->df_type->tp_size,
-				regtype(df->df_type),
-				df->df_sc);
+				regtype(df->df_type), df->df_sc);
 		/* cvt int to char or short and double to float, if necessary
 		 */
 		formal_cvt(hasproto, df);
 
-		df->df_level = L_FORMAL2;	/* CJ */
+		df->df_level = L_FORMAL2; /* CJ */
 		if (nparams++ >= STDC_NPARAMS)
 			strict("number of formal parameters exceeds ANSI limit");
 #ifdef DBSYMTAB
-		if (options['g']) {
+		if (options['g'])
+		{
 			stb_string(df, FORMAL, se->se_idf->id_text);
 		}
 #endif /* DBSYMTAB */
@@ -591,11 +619,10 @@ declare_formals(idf, fp)
 	*fp = f_offset;
 }
 
-int
-regtype(tp)
-	struct type *tp;
+int regtype(struct type *tp)
 {
-	switch(tp->tp_fund) {
+	switch (tp->tp_fund)
+	{
 	case INT:
 	case LONG:
 		return reg_any;
@@ -609,18 +636,15 @@ regtype(tp)
 	return -1;
 }
 
-add_def(idf, sc, tp, lvl)
-	struct idf *idf;
-	struct type *tp;
-	int lvl;
-	int sc;
+void add_def(struct idf *idf, int sc, struct type *tp, int lvl)
 {
 	/*	The identifier idf is declared on level lvl with storage
-		class sc and type tp, through a faked C declaration.
-		This is probably the wrong way to structure the problem,
-		but it will have to do for the time being.
-	*/
-	struct decspecs Ds; struct declarator Dc;
+	 class sc and type tp, through a faked C declaration.
+	 This is probably the wrong way to structure the problem,
+	 but it will have to do for the time being.
+	 */
+	struct decspecs Ds;
+	struct declarator Dc;
 
 	Ds = null_decspecs;
 	Ds.ds_type = tp;
@@ -630,25 +654,24 @@ add_def(idf, sc, tp, lvl)
 	declare_idf(&Ds, &Dc, lvl);
 }
 
-update_ahead(idf)
-	register struct idf *idf;
+void update_ahead(register struct idf *idf)
 {
 	/*	The tk_symb of the token ahead is updated in the light of new
-		information about the identifier idf.
-	*/
+	 information about the identifier idf.
+	 */
 	register int tk_symb = AHEAD;
 
-	if (	(tk_symb == IDENTIFIER || tk_symb == TYPE_IDENTIFIER) &&
-		ahead.tk_idf == idf
-	)
+	if ((tk_symb == IDENTIFIER || tk_symb == TYPE_IDENTIFIER)
+			&& ahead.tk_idf == idf)
 		AHEAD = idf->id_def && idf->id_def->df_sc == TYPEDEF ?
-				TYPE_IDENTIFIER : IDENTIFIER;
+		TYPE_IDENTIFIER :
+																IDENTIFIER;
 }
 
-free_formals(fm)
-	register struct formal *fm;
+void free_formals(register struct formal *fm)
 {
-	while (fm)	{
+	while (fm)
+	{
 		struct formal *tmp = fm->next;
 
 		free_formal(fm);
diff --git a/lang/cem/cemcom.ansi/idf.str b/lang/cem/cemcom.ansi/idf.str
index 06caa7f3e..d26ebfe56 100644
--- a/lang/cem/cemcom.ansi/idf.str
+++ b/lang/cem/cemcom.ansi/idf.str
@@ -2,10 +2,15 @@
  * (c) copyright 1987 by the Vrije Universiteit, Amsterdam, The Netherlands.
  * See the copyright notice in the ACK home directory, in the file "Copyright".
  */
+#ifndef IDF_H_
+#define IDF_H_
+
+ 
 /* $Id$ */
 /* IDENTIFIER DESCRIPTOR */
 
 #include	"parameters.h"
+#include    "arith.h"
 
 struct id_u {
 	int idd_reserved;	/* non-zero for reserved words		*/
@@ -33,4 +38,28 @@ struct id_u {
 #include <idf_pkg.spec>
 
 extern int level;
-extern struct idf *gen_idf();
+
+struct decspecs;
+struct declarator;
+struct type;
+struct formal;
+
+
+struct idf *gen_idf(void);
+int is_anon_idf(struct idf *idf);
+void declare_idf(struct decspecs *ds, struct declarator *dc, int lvl);
+int actual_declaration(int sc, struct type *tp);
+void global_redecl(register struct idf *idf, int new_sc, struct type *tp);
+int good_formal(register struct def *def, register struct idf *idf);
+void declare_params(struct declarator *dc);
+void idf_initialized(register struct idf *idf);
+void declare_parameter(struct idf *idf);
+void declare_enum(struct type *tp, struct idf *idf, arith l);
+void check_formals(struct idf *idf, struct declarator *dc);
+void declare_formals(struct idf *idf, arith *fp);
+int regtype(struct type *tp);
+void add_def(struct idf *idf, int sc, struct type *tp, int lvl);
+void update_ahead(register struct idf *idf);
+void free_formals(register struct formal *fm);
+
+#endif
\ No newline at end of file
diff --git a/lang/cem/cemcom.ansi/input.c b/lang/cem/cemcom.ansi/input.c
index dea9a4892..e5d019bb4 100644
--- a/lang/cem/cemcom.ansi/input.c
+++ b/lang/cem/cemcom.ansi/input.c
@@ -10,6 +10,7 @@
 #include <string.h>
 #include "file_info.h"
 #include "input.h"
+#include "error.h"
 
 #define INP_PUSHBACK	3
 #define INP_TYPE	struct file_info
@@ -20,14 +21,14 @@ struct file_info	finfo;
 
 int	NoUnstack;
 
-AtEoIT()
+int AtEoIT(void)
 {
 	return 0;
 }
 
 extern char *source;
 
-AtEoIF()
+int AtEoIF(void)
 {
 	if (NoUnstack) lexerror("unexpected EOF");
 	return 0;
diff --git a/lang/cem/cemcom.ansi/input.h b/lang/cem/cemcom.ansi/input.h
index 972eaf2f6..4ffbe0f5c 100644
--- a/lang/cem/cemcom.ansi/input.h
+++ b/lang/cem/cemcom.ansi/input.h
@@ -12,4 +12,4 @@
 #define UnGetChar()	((LexSave != EOI) ? ChPushBack(LexSave) : 0)
 
 extern	int LexSave;	/* last character read by GetChar		*/
-extern 	int GetChar();	/* character input, with trigraph parsing	*/
+
diff --git a/lang/cem/cemcom.ansi/ival.g b/lang/cem/cemcom.ansi/ival.g
index e867aad86..80c6d1d01 100644
--- a/lang/cem/cemcom.ansi/ival.g
+++ b/lang/cem/cemcom.ansi/ival.g
@@ -1,774 +1,759 @@
-/*
- * (c) copyright 1987 by the Vrije Universiteit, Amsterdam, The Netherlands.
- * See the copyright notice in the ACK home directory, in the file "Copyright".
- */
-/* $Id$ */
-/* CODE FOR THE INITIALISATION OF GLOBAL VARIABLES */
-
-{
-#include	<assert.h>
-#include    <stdlib.h>
-#include	"parameters.h"
-#ifndef	LINT
-#include	<em.h>
-#else
-#include	"l_em.h"
-#include	"l_lint.h"
-#endif	/* LINT */
-#include	<ack_string.h>
-#include	<alloc.h>
-#include	<assert.h>
-#include	<flt_arith.h>
-#include    "idf.h"
-#include	"arith.h"
-#include	"label.h"
-#include	"expr.h"
-#include	"type.h"
-#include	"proto.h"
-#include	"struct.h"
-#include	"field.h"
-#include	"Lpars.h"
-#include	"sizes.h"
-#include	"align.h"
-#include	"level.h"
-#include	"def.h"
-#include	"LLlex.h"
-#include	"estack.h"
-#include    "stack.h"
-
-#define con_nullbyte()	C_con_ucon("0", (arith)1)
-#define aggregate_type(tp) ((tp)->tp_fund == ARRAY || (tp)->tp_fund == STRUCT)
-
-char *strncpy();
-extern char options[];
-static int gen_error;
-static int pack_level;
-struct type **gen_tphead(), **gen_tpmiddle();
-struct sdef *gen_align_to_next();
-struct e_stack *p_stack;
-
-void pad();
-void gen_simple_exp();
-void gen_tpcheck();
-
-}
-
-/* initial_value recursively guides the initialisation expression.
- */
-/* 3.5 */
-
-initial_value(register struct type **tpp; register struct expr **expp;) :
-	{ if (tpp) gen_tpcheck(tpp); }
-[
-		{ if (pack_level == 0) gen_error = 0; }
-	assignment_expression(expp)
-		{
-#ifdef	LINT
-			lint_expr(*expp, USED);
-#endif	/* LINT */
-			if ((*expp)->ex_type->tp_fund == ARRAY)
-				array2pointer(*expp);
-			if (tpp) {
-				if (level >= L_LOCAL
-				    || is_ld_cst(*expp)
-				    || is_fp_cst(*expp)
-				    || (*expp)->ex_class == String) {
-					gen_simple_exp(tpp, expp);
-					free_expression(*expp);
-					*expp = 0;
-				} else {
-					expr_error(*expp,"illegal initialization");
-					free_expression(*expp);
-					*expp = 0;
-				}
-			}
-		}
-|
-	initial_value_pack(tpp, expp)
-]
-;
-
-initial_value_pack(struct type **tpp; struct expr **expp;)
-:
-	'{'
-			{ if (pack_level == 0) gen_error = 0; pack_level++; }
-	initial_value_list(tpp, expp)
-			{ pack_level--;
-			  if (!pack_level) {
-				while (p_stack) {
-					struct e_stack *p = p_stack->next;
-
-					free_e_stack(p_stack);
-					p_stack = p;
-				}
-			  }
-			  if (pack_level < gen_error) gen_error = 0;
-			}
-	'}'
-;
-
-initial_value_list(register struct type **tpp; struct expr **expp;)
-	{ struct expr *e1;
-	  register struct type **tpp2 = 0;
-	  int err_flag = gen_error;
-	}
-:
-			{ if (tpp) tpp2 = gen_tphead(tpp, 0); }
-	initial_value(tpp2, &e1)
-			{ if (!tpp) init_expression(&expp, e1); }
-	[%while (AHEAD != '}')		/* >>> conflict on ',' */
-		','
-			{ if (tpp) tpp2 = gen_tpmiddle(); }
-		initial_value(tpp2, &e1)
-			{ if (!tpp) init_expression(&expp, e1); }
-	]*
-			{ if (tpp && ! err_flag) gen_tpend(); }
-	','?				/* optional trailing comma */
-;
-
-{
-void
-gen_tpcheck(tpp)
-	struct type **tpp;
-{
-	register struct type *tp;
-
-	if (gen_error) return;
-	switch((tp = *tpp)->tp_fund) {
-	case ARRAY:
-		if (! valid_type(tp->tp_up, "array element"))
-			gen_error = pack_level;
-		break;
-	case STRUCT:
-		if (! valid_type(tp, "struct"))
-			gen_error = pack_level;
-		break;
-	case UNION:
-		if (! valid_type(tp, "union"))
-			gen_error = pack_level;
-		break;
-	case ERRONEOUS:
-		if (! gen_error) gen_error = pack_level;
-		break;
-	}
-}
-
-void
-gen_simple_exp(tpp, expp)
-	struct type **tpp;
-	struct expr **expp;
-{
-	register struct type *tp;
-
-	if (gen_error) return;
-	tp = *tpp;
-	switch(tp->tp_fund) {
-	case ARRAY:
-		if ((*expp)->ex_class == String && tp->tp_up->tp_fund == CHAR) {
-			ch_array(tpp,*expp);
-			break;
-		}
-		/* Fall through */
-	case UNION:
-	case STRUCT:
-		check_and_pad(expp, tpp);
-		break;
-	case ERRONEOUS:
-	case FUNCTION:
-	case VOID:
-		gen_error = pack_level;
-		break;
-	default:
-		check_ival(expp, tp);
-		break;
-	}
-}
-
-struct type **
-arr_elem(tpp, p)
-	struct type **tpp;
-	struct e_stack *p;
-{
-	register struct type *tp = *tpp;
-
-	if (tp->tp_up->tp_fund == CHAR && AHEAD == STRING && p->elem_count == 1) {
-		p->nelem = 1;
-		return tpp;
-	}
-	if (AHEAD == '{' || (! aggregate_type(tp->tp_up) && tp->tp_up->tp_fund != UNION))
-		return &(tp->tp_up);
-	return gen_tphead(&(tp->tp_up), 1);
-}
-
-struct sdef *
-next_field(sd, p)
-	register struct sdef *sd;
-	register struct e_stack *p;
-{
-	if (sd->sd_sdef)
-		p->bytes_upto_here += zero_bytes(sd);
-	p->bytes_upto_here +=
-		size_of_type(sd->sd_type, "selector");
-	p->last_offset = sd->sd_offset;
-	return sd->sd_sdef;
-}
-
-struct type **
-gen_tphead(tpp, nest)
-	struct type **tpp;
-{
-	register struct type *tp = *tpp;
-	register struct e_stack *p;
-	register struct sdef *sd;
-
-	if (tpp && *tpp == error_type) {
-		gen_error = pack_level;
-		return 0;
-	}
-	if (gen_error) return tpp;
-	if (tp->tp_fund == UNION) {
-		/* Here, we saw a {, which could be the start of a union
-		   initializer. It could, however, also be the start of the
-		   initializer for the first union field ...
-		*/
-		sd = tp->tp_sdef;
-		if (AHEAD != '{' &&
-		    (aggregate_type(sd->sd_type) || 
-		     sd->sd_type->tp_fund == UNION)) {
-			/* In this case, assume that it is the start of the
-			   initializer of the union field, so:
-			*/
-			return gen_tphead(&(tp->tp_sdef->sd_type), nest);
-		}
-	}
-	p = new_e_stack();
-	p->next = p_stack;
-	p_stack = p;
-	p->s_nested = nest;
-	p->s_tpp = tpp;
-	switch(tp->tp_fund) {
-	case UNION:
-		p->s_def = sd = tp->tp_sdef;
-		p->bytes_upto_here = 0;
-		return &(sd->sd_type);
-	case ARRAY:
-		p->nelem = -1;
-		p->elem_count = 1;
-		if (tp->tp_size != (arith) -1) {
-			p->nelem = (tp->tp_size / tp->tp_up->tp_size);
-		}
-		return arr_elem(tpp, p);
-	case STRUCT:
-		p->s_def = sd = tp->tp_sdef;
-		p->bytes_upto_here = 0;
-		p->last_offset = -1;
-#ifndef NOBITFIELD
-		while (sd && is_anon_idf(sd->sd_idf)) {
-			put_bf(sd->sd_type, (arith) 0);
-			sd = next_field(sd, p);
-		}
-#endif
-		if (! sd) {
-			/* something wrong with this struct */
-			gen_error = pack_level;
-			p_stack = p->next;
-			free_e_stack(p);
-			return 0;
-		}
-		p->s_def = sd;
-		if (AHEAD != '{' && aggregate_type(sd->sd_type)) {
-			return gen_tphead(&(sd->sd_type), 1);
-		}
-		return &(sd->sd_type);
-	case ERRONEOUS:
-		if (! gen_error) gen_error = pack_level;
-		/* fall through */
-	default:
-		p->nelem = 1;
-		p->elem_count = 1;
-		return tpp;
-	}
-}
-
-struct type **
-gen_tpmiddle()
-{
-	register struct type *tp;
-	register struct sdef *sd;
-	register struct e_stack *p = p_stack;
-
-	if (gen_error) {
-		if (p) return p->s_tpp;
-		return 0;
-	}
-again:
-	tp = *(p->s_tpp);
-	switch(tp->tp_fund) {
-	case ERRONEOUS:
-		if (! gen_error) gen_error = pack_level;
-		return p->s_tpp;
-	case UNION:
-		sd = p->s_def;
-		p->bytes_upto_here +=
-			size_of_type(sd->sd_type, "selector");
-		return p->s_tpp;
-	default:
-		if (p->elem_count == p->nelem && p->s_nested) {
-			p = p->next;
-			free_e_stack(p_stack);
-			p_stack = p;
-			goto again;
-		}
-		p->elem_count++;
-		if (p->nelem >= 0 && p->elem_count > p->nelem) {
-			too_many_initialisers();
-			return p->s_tpp;
-		}
-		if (tp->tp_fund == ARRAY) {
-			return arr_elem(p->s_tpp, p);
-		}
-		return p->s_tpp;
-	case STRUCT:
-		sd = gen_align_to_next(p);
-		if (! sd) {
-			while (p->bytes_upto_here++ < tp->tp_size)
-				con_nullbyte();
-			if (p->s_nested) {
-				p = p->next;
-				free_e_stack(p_stack);
-				p_stack = p;
-				goto again;
-			}
-			too_many_initialisers();
-			return p->s_tpp;
-		}
-		if (AHEAD != '{' && aggregate_type(sd->sd_type)) {
-			return gen_tphead(&(sd->sd_type), 1);
-		}
-		return &(sd->sd_type);
-	}
-}
-
-struct sdef *
-gen_align_to_next(p)
-	register struct e_stack *p;
-{
-	register struct sdef *sd = p->s_def;
-
-	if (! sd) return sd;
-#ifndef NOBITFIELD
-	do {
-		if (is_anon_idf(sd->sd_idf)) put_bf(sd->sd_type, (arith) 0);
-#endif
-		sd = next_field(sd, p);
-#ifndef NOBITFIELD
-	} while (sd && is_anon_idf(sd->sd_idf));
-#endif
-	p->s_def = sd;
-	return sd;
-}
-
-gen_tpend()
-{
-	register struct e_stack *p = p_stack;
-	register struct type *tp;
-	register struct sdef *sd;
-	int getout = 0;
-
-	while (!getout && p) {
-	    if (!gen_error) {
-		tp = *(p->s_tpp);
-		switch(tp->tp_fund) {
-		case UNION:
-			sd = p->s_def;
-			p->bytes_upto_here +=
-				size_of_type(sd->sd_type, "selector");
-			while (p->bytes_upto_here++ < tp->tp_size)
-				con_nullbyte();
-			break;
-		case ARRAY:
-			if (tp->tp_size == -1) {
-				*(p->s_tpp) = construct_type(ARRAY, tp->tp_up,
-					0, p->elem_count, NO_PROTO);
-			}
-			else {
-				while (p->nelem-- > p->elem_count) {
-					pad(tp->tp_up);
-				}
-			}
-			break;
-		case STRUCT:
-			sd = gen_align_to_next(p);
-			while (sd) {
-				pad(sd->sd_type);
-				if (sd->sd_sdef)
-					p->bytes_upto_here += zero_bytes(sd);
-				p->bytes_upto_here +=
-					size_of_type(sd->sd_type, "selector");
-				sd = sd->sd_sdef;
-			}
-			while (p->bytes_upto_here++ < tp->tp_size)
-				con_nullbyte();
-			break;
-		}
-	    }
-	    if (! p->s_nested) getout = 1;
-	    p = p->next;
-	    free_e_stack(p_stack);
-	    p_stack = p;
-	}
-}
-
-/*	check_and_pad() is given a simple initialisation expression
-	where the type can be either a simple or an aggregate type.
-	In the latter case, only the first member is initialised and
-	the rest is zeroed.
-*/
-check_and_pad(expp, tpp)
-	struct type **tpp;
-	struct expr **expp;
-{
-	register struct type *tp = *tpp;
-
-	if (tp->tp_fund == ARRAY) {
-		check_and_pad(expp, &(tp->tp_up));	/* first member	*/
-		if (tp->tp_size == (arith)-1)
-			/*	no size specified upto here: just
-				set it to the size of one member.
-			*/
-			tp = *tpp = construct_type(ARRAY, tp->tp_up,
-					0, (arith)1, NO_PROTO);
-		else {
-			register int dim = tp->tp_size / tp->tp_up->tp_size;
-			/* pad remaining members with zeroes */
-			while (--dim > 0)
-				pad(tp->tp_up);
-		}
-	}
-	else
-	if (tp->tp_fund == STRUCT) {
-		register struct sdef *sd = tp->tp_sdef;
-
-		check_and_pad(expp, &(sd->sd_type));
-		/* next selector is aligned by adding extra zeroes */
-		if (sd->sd_sdef)
-			zero_bytes(sd);
-		while (sd = sd->sd_sdef) { /* pad remaining selectors	*/
-			pad(sd->sd_type);
-			if (sd->sd_sdef)
-				zero_bytes(sd);
-		}
-	}
-	else if (tp->tp_fund == UNION) {
-		/* only the first selector can be initialized */
-		register struct sdef *sd = tp->tp_sdef;
-
-		check_and_pad(expp, &(sd->sd_type));
-	}
-	else	/* simple type	*/
-		check_ival(expp, tp);
-}
-
-/*	pad() fills an element of type tp with zeroes.
-	If the element is an aggregate, pad() is called recursively.
-*/
-void
-pad(tpx)
-	struct type *tpx;
-{
-	register struct type *tp = tpx;
-	register arith sz = tp->tp_size;
-
-	gen_tpcheck(&tpx);
-	if (gen_error) return;
-#ifndef NOBITFIELD
-	if (tp->tp_fund == FIELD) {
-		put_bf(tp, (arith)0);
-		return;
-	}
-#endif /* NOBITFIELD */
-
-	if (tp->tp_align >= word_align) while (sz >= word_size) {
-		C_con_cst((arith) 0);
-		sz -= word_size;
-	}
-	while (sz) {
-		C_con_icon("0", (arith) 1);
-		sz--;
-	}
-}
-
-/*	check_ival() checks whether the initialisation of an element
-	of a fundamental type is legal and, if so, performs the initialisation
-	by directly generating the necessary code.
-	No further comment is needed to explain the internal structure
-	of this straightforward function.
-*/
-check_ival(expp, tp)
-	register struct type *tp;
-	struct expr **expp;
-{
-	/*	The philosophy here is that ch3cast puts an explicit
-		conversion node in front of the expression if the types
-		are not compatible.  In this case, the initialisation
-		expression is no longer a constant.
-	*/
-	register struct expr *expr = *expp;
-	
-	switch (tp->tp_fund) {
-	case CHAR:
-	case SHORT:
-	case INT:
-	case LONG:
-	case ENUM:
-	case POINTER:
-		ch3cast(expp, '=', tp);
-		expr = *expp;
-#ifdef DEBUG
-		print_expr("init-expr after cast", expr);
-#endif /* DEBUG */
-		if (!is_ld_cst(expr))
-			illegal_init_cst(expr);
-		else
-		if (expr->VL_CLASS == Const)
-			con_int(expr);
-		else
-		if (expr->VL_CLASS == Name) {
-			register struct idf *idf = expr->VL_IDF;
-
-			if (idf->id_def->df_level >= L_LOCAL
-			    && idf->id_def->df_sc != GLOBAL
-			    && idf->id_def->df_sc != EXTERN) {
-				illegal_init_cst(expr);
-			}
-			else	/* e.g., int f(); int p = f; */
-			if (idf->id_def->df_type->tp_fund == FUNCTION)
-				C_con_pnam(idf->id_text);
-			else	/* e.g., int a; int *p = &a; */
-				C_con_dnam(idf->id_text, expr->VL_VALUE);
-		}
-		else {
-			assert(expr->VL_CLASS == Label);
-			C_con_dlb(expr->VL_LBL, expr->VL_VALUE);
-		}
-		break;
-	case FLOAT:
-	case DOUBLE:
-	case LNGDBL:
-		ch3cast(expp, '=', tp);
-		expr = *expp;
-#ifdef DEBUG
-		print_expr("init-expr after cast", expr);
-#endif /* DEBUG */
-		if (expr->ex_class == Float) {
-			char buf[FLT_STRLEN];
-
-			flt_flt2str(&(expr->FL_ARITH), buf, FLT_STRLEN);
-			C_con_fcon(buf, expr->ex_type->tp_size);
-		}
-#ifdef NOTDEF
-
-Coercion from int to float is now always done compile time.
-This, to accept declarations like
-double	x = -(double)1;
-and also to prevent runtime coercions for compile-time constants.
-
-		else
-		if (expr->ex_class == Oper && expr->OP_OPER == INT2FLOAT) {
-			/* float f = 1; */
-			expr = expr->OP_RIGHT;
-			if (is_cp_cst(expr))
-				C_con_fcon(long2str((long)expr->VL_VALUE, 10),
-					tp->tp_size);
-			else 
-				illegal_init_cst(expr);
-		}
-#endif /* NOTDEF */
-		else
-			illegal_init_cst(expr);
-		break;
-
-#ifndef NOBITFIELD
-	case FIELD:
-		ch3cast(expp, '=', tp->tp_up);
-		expr = *expp;
-#ifdef DEBUG
-		print_expr("init-expr after cast", expr);
-#endif /* DEBUG */
-		if (is_cp_cst(expr))
-			put_bf(tp, expr->VL_VALUE);
-		else
-			illegal_init_cst(expr);
-		break;
-#endif /* NOBITFIELD */
-
-	case ERRONEOUS:
-		if (! gen_error) gen_error = pack_level;
-		/* fall through */
-	case VOID:
-		break;
-	default:
-		crash("check_ival");
-		/*NOTREACHED*/
-	}
-}
-
-/*	ch_array() initialises an array of characters when given
-	a string constant.
-	Alignment is taken care of.
-*/
-ch_array(tpp, ex)
-	struct type **tpp;	/* type tp = array of characters	*/
-	struct expr *ex;
-{
-	register struct type *tp = *tpp;
-	register int length = ex->SG_LEN, i;
-	register char *to, *from, *s;
-
-	assert(ex->ex_class == String);
-	if (tp->tp_size == (arith)-1) {
-		/* set the dimension	*/
-		tp = *tpp = construct_type(ARRAY, tp->tp_up, 0, (arith)length, NO_PROTO);
-	}
-	else {
-		arith dim = tp->tp_size / tp->tp_up->tp_size;
-
-#ifdef LINT
-		if (length == dim + 1) {
-			    expr_warning(ex, "array is not null-terminated");
-		} else
-#endif
-		if (length > dim + 1) {
-			expr_strict(ex, "too many initializers");
-		}
-		length = dim;
-	}
-	/* throw out the characters of the already prepared string	*/
-	s = Malloc((unsigned) (length));
-	clear(s, (unsigned)length);
-	i = length <= ex->SG_LEN ? length : ex->SG_LEN;
-	to = s; from = ex->SG_VALUE;
-	while(--i >= 0) {
-		*to++ = *from++;
-	}
-	free(ex->SG_VALUE);
-	str_cst(s, length, 0);		/* a string, but not in rom */
-	free(s);
-}
-
-/*	As long as some parts of the pipeline cannot handle very long string
-	constants, string constants are written out in chunks
-*/
-str_cst(str, len, inrom)
-	register char *str;
-	register int len;
-	int inrom;
-{
-	int chunksize = ((127 + (int) word_size) / (int) word_size) * (int) word_size;
-
-	while (len > chunksize) {
-		if (inrom)
-			C_rom_scon(str, (arith) chunksize);
-		else	C_con_scon(str, (arith) chunksize);
-		len -= chunksize;
-		str += chunksize;
-	}
-	if (inrom)
-		C_rom_scon(str, (arith) len);
-	else	C_con_scon(str, (arith) len);
-}
-
-#ifndef NOBITFIELD
-/*	put_bf() takes care of the initialisation of (bit-)field
-	selectors of a struct: each time such an initialisation takes place,
-	put_bf() is called instead of the normal code generating routines.
-	Put_bf() stores the given integral value into "field" and
-	"throws" the result of "field" out if the current selector
-	is the last of this number of fields stored at the same address.
-*/
-put_bf(tp, val)
-	struct type *tp;
-	arith val;
-{
-	static long field = (arith)0;
-	static arith offset = (arith)-1;
-	register struct field *fd = tp->tp_field;
-	register struct sdef *sd =  fd->fd_sdef;
-	static struct expr exp;
-
-	assert(sd);
-	if (offset == (arith)-1) {
-		/* first bitfield in this field	*/
-		offset = sd->sd_offset;
-		exp.ex_type = tp->tp_up;
-		exp.ex_class = Value;
-		exp.VL_CLASS = Const;
-	}
-	if (val != 0)	/* insert the value into "field"	*/
-		field |= (val & fd->fd_mask) << fd->fd_shift;
-	if (sd->sd_sdef == 0 || sd->sd_sdef->sd_offset != offset) {
-		/* the selector was the last stored at this address	*/
-		exp.VL_VALUE = field;
-		con_int(&exp);
-		field = (arith)0;
-		offset = (arith)-1;
-	}
-}
-#endif /* NOBITFIELD */
-
-int
-zero_bytes(sd)
-	register struct sdef *sd;
-{
-	/*	fills the space between a selector of a struct
-		and the next selector of that struct with zero-bytes.
-	*/
-	register int n = sd->sd_sdef->sd_offset - sd->sd_offset -
-		size_of_type(sd->sd_type, "struct member");
-	int count = n;
-
-	while (n-- > 0)
-		con_nullbyte();
-	return count;
-}
-
-int
-valid_type(tp, str)
-	struct type *tp;
-	char *str;
-{
-	assert(tp!=(struct type *)0);
-	if (tp->tp_size < 0) {
-		error("size of %s unknown", str);
-		return 0;
-	}
-	return 1;
-}
-
-con_int(ex)
-	register struct expr *ex;
-{
-	register struct type *tp = ex->ex_type;
-
-	assert(is_cp_cst(ex));
-	if (tp->tp_unsigned)
-		C_con_ucon(long2str((long)ex->VL_VALUE, -10), tp->tp_size);
-	else if (tp->tp_size == word_size)
-		C_con_cst(ex->VL_VALUE);
-	else
-		C_con_icon(long2str((long)ex->VL_VALUE, 10), tp->tp_size);
-}
-
-illegal_init_cst(ex)
-	struct expr *ex;
-{
-	expr_error(ex, "illegal initialization constant");
-	gen_error = pack_level;
-}
-
-too_many_initialisers()
-{
-	error("too many initializers");
-	gen_error = pack_level;
-}
-}
+/*
+ * (c) copyright 1987 by the Vrije Universiteit, Amsterdam, The Netherlands.
+ * See the copyright notice in the ACK home directory, in the file "Copyright".
+ */
+/* $Id$ */
+/* CODE FOR THE INITIALISATION OF GLOBAL VARIABLES */
+
+{
+#include	<assert.h>
+#include    <stdlib.h>
+#include	"parameters.h"
+#ifndef	LINT
+#include	<em.h>
+#else
+#include	"l_em.h"
+#include	"l_lint.h"
+#endif	/* LINT */
+#include	<ack_string.h>
+#include	<alloc.h>
+#include	<assert.h>
+#include    <string.h> 
+#include	<flt_arith.h>
+#include    "idf.h"
+#include	"arith.h"
+#include	"label.h"
+#include	"expr.h"
+#include	"type.h"
+#include	"proto.h"
+#include	"struct.h"
+#include	"field.h"
+#include	"Lpars.h"
+#include	"sizes.h"
+#include	"align.h"
+#include	"level.h"
+#include    "error.h"
+#include	"def.h"
+#include	"LLlex.h"
+#include	"estack.h"
+#include    "stack.h"
+#include    "ch3.h"
+
+#define con_nullbyte()	C_con_ucon("0", (arith)1)
+#define aggregate_type(tp) ((tp)->tp_fund == ARRAY || (tp)->tp_fund == STRUCT)
+
+extern char options[];
+static int gen_error;
+static int pack_level;
+struct e_stack *p_stack;
+
+void gen_tpcheck(struct type **);
+void gen_simple_exp(struct type **, struct expr **);
+struct type **arr_elem(struct type **, struct e_stack *);
+struct sdef *next_field(register struct sdef *,register struct e_stack *);
+struct type **gen_tphead(struct type **, int);
+struct type **gen_tpmiddle(void);
+struct sdef *gen_align_to_next(register struct e_stack *);
+void gen_tpend(void);
+void check_and_pad(struct expr **, struct type **);
+void pad(struct type *);
+void check_ival(struct expr **, register struct type *);
+void ch_array(struct type **,	/* type tp = array of characters	*/
+	struct expr *);
+void str_cst(register char *, register int, int);
+#ifndef NOBITFIELD
+void put_bf(struct type *, arith );
+#endif /* NOBITFIELD */
+int zero_bytes(register struct sdef *);
+int valid_type(struct type *, char *);
+void con_int(register struct expr *);
+void illegal_init_cst(struct expr *);
+void too_many_initialisers(void);
+
+}
+
+/* initial_value recursively guides the initialisation expression.
+ */
+/* 3.5 */
+
+initial_value(register struct type **tpp; register struct expr **expp;) :
+	{ if (tpp) gen_tpcheck(tpp); }
+[
+		{ if (pack_level == 0) gen_error = 0; }
+	assignment_expression(expp)
+		{
+#ifdef	LINT
+			lint_expr(*expp, USED);
+#endif	/* LINT */
+			if ((*expp)->ex_type->tp_fund == ARRAY)
+				array2pointer(*expp);
+			if (tpp) {
+				if (level >= L_LOCAL
+				    || is_ld_cst(*expp)
+				    || is_fp_cst(*expp)
+				    || (*expp)->ex_class == String) {
+					gen_simple_exp(tpp, expp);
+					free_expression(*expp);
+					*expp = 0;
+				} else {
+					expr_error(*expp,"illegal initialization");
+					free_expression(*expp);
+					*expp = 0;
+				}
+			}
+		}
+|
+	initial_value_pack(tpp, expp)
+]
+;
+
+initial_value_pack(struct type **tpp; struct expr **expp;)
+:
+	'{'
+			{ if (pack_level == 0) gen_error = 0; pack_level++; }
+	initial_value_list(tpp, expp)
+			{ pack_level--;
+			  if (!pack_level) {
+				while (p_stack) {
+					struct e_stack *p = p_stack->next;
+
+					free_e_stack(p_stack);
+					p_stack = p;
+				}
+			  }
+			  if (pack_level < gen_error) gen_error = 0;
+			}
+	'}'
+;
+
+initial_value_list(register struct type **tpp; struct expr **expp;)
+	{ struct expr *e1;
+	  register struct type **tpp2 = 0;
+	  int err_flag = gen_error;
+	}
+:
+			{ if (tpp) tpp2 = gen_tphead(tpp, 0); }
+	initial_value(tpp2, &e1)
+			{ if (!tpp) init_expression(&expp, e1); }
+	[%while (AHEAD != '}')		/* >>> conflict on ',' */
+		','
+			{ if (tpp) tpp2 = gen_tpmiddle(); }
+		initial_value(tpp2, &e1)
+			{ if (!tpp) init_expression(&expp, e1); }
+	]*
+			{ if (tpp && ! err_flag) gen_tpend(); }
+	','?				/* optional trailing comma */
+;
+
+{
+void gen_tpcheck(struct type **tpp)
+{
+	register struct type *tp;
+
+	if (gen_error) return;
+	switch((tp = *tpp)->tp_fund) {
+	case ARRAY:
+		if (! valid_type(tp->tp_up, "array element"))
+			gen_error = pack_level;
+		break;
+	case STRUCT:
+		if (! valid_type(tp, "struct"))
+			gen_error = pack_level;
+		break;
+	case UNION:
+		if (! valid_type(tp, "union"))
+			gen_error = pack_level;
+		break;
+	case ERRONEOUS:
+		if (! gen_error) gen_error = pack_level;
+		break;
+	}
+}
+
+void gen_simple_exp(struct type **tpp, struct expr **expp)
+{
+	register struct type *tp;
+
+	if (gen_error) return;
+	tp = *tpp;
+	switch(tp->tp_fund) {
+	case ARRAY:
+		if ((*expp)->ex_class == String && tp->tp_up->tp_fund == CHAR) {
+			ch_array(tpp,*expp);
+			break;
+		}
+		/* Fall through */
+	case UNION:
+	case STRUCT:
+		check_and_pad(expp, tpp);
+		break;
+	case ERRONEOUS:
+	case FUNCTION:
+	case VOID:
+		gen_error = pack_level;
+		break;
+	default:
+		check_ival(expp, tp);
+		break;
+	}
+}
+
+struct type **arr_elem(struct type **tpp, struct e_stack *p)
+{
+	register struct type *tp = *tpp;
+
+	if (tp->tp_up->tp_fund == CHAR && AHEAD == STRING && p->elem_count == 1) {
+		p->nelem = 1;
+		return tpp;
+	}
+	if (AHEAD == '{' || (! aggregate_type(tp->tp_up) && tp->tp_up->tp_fund != UNION))
+		return &(tp->tp_up);
+	return gen_tphead(&(tp->tp_up), 1);
+}
+
+struct sdef *next_field(register struct sdef *sd,
+	register struct e_stack *p)
+{
+	if (sd->sd_sdef)
+		p->bytes_upto_here += zero_bytes(sd);
+	p->bytes_upto_here +=
+		size_of_type(sd->sd_type, "selector");
+	p->last_offset = sd->sd_offset;
+	return sd->sd_sdef;
+}
+
+struct type **gen_tphead(struct type **tpp, int nest)
+{
+	register struct type *tp = *tpp;
+	register struct e_stack *p;
+	register struct sdef *sd;
+
+	if (tpp && *tpp == error_type) {
+		gen_error = pack_level;
+		return 0;
+	}
+	if (gen_error) return tpp;
+	if (tp->tp_fund == UNION) {
+		/* Here, we saw a {, which could be the start of a union
+		   initializer. It could, however, also be the start of the
+		   initializer for the first union field ...
+		*/
+		sd = tp->tp_sdef;
+		if (AHEAD != '{' &&
+		    (aggregate_type(sd->sd_type) || 
+		     sd->sd_type->tp_fund == UNION)) {
+			/* In this case, assume that it is the start of the
+			   initializer of the union field, so:
+			*/
+			return gen_tphead(&(tp->tp_sdef->sd_type), nest);
+		}
+	}
+	p = new_e_stack();
+	p->next = p_stack;
+	p_stack = p;
+	p->s_nested = nest;
+	p->s_tpp = tpp;
+	switch(tp->tp_fund) {
+	case UNION:
+		p->s_def = sd = tp->tp_sdef;
+		p->bytes_upto_here = 0;
+		return &(sd->sd_type);
+	case ARRAY:
+		p->nelem = -1;
+		p->elem_count = 1;
+		if (tp->tp_size != (arith) -1) {
+			p->nelem = (tp->tp_size / tp->tp_up->tp_size);
+		}
+		return arr_elem(tpp, p);
+	case STRUCT:
+		p->s_def = sd = tp->tp_sdef;
+		p->bytes_upto_here = 0;
+		p->last_offset = -1;
+#ifndef NOBITFIELD
+		while (sd && is_anon_idf(sd->sd_idf)) {
+			put_bf(sd->sd_type, (arith) 0);
+			sd = next_field(sd, p);
+		}
+#endif
+		if (! sd) {
+			/* something wrong with this struct */
+			gen_error = pack_level;
+			p_stack = p->next;
+			free_e_stack(p);
+			return 0;
+		}
+		p->s_def = sd;
+		if (AHEAD != '{' && aggregate_type(sd->sd_type)) {
+			return gen_tphead(&(sd->sd_type), 1);
+		}
+		return &(sd->sd_type);
+	case ERRONEOUS:
+		if (! gen_error) gen_error = pack_level;
+		/* fall through */
+	default:
+		p->nelem = 1;
+		p->elem_count = 1;
+		return tpp;
+	}
+}
+
+struct type **gen_tpmiddle(void)
+{
+	register struct type *tp;
+	register struct sdef *sd;
+	register struct e_stack *p = p_stack;
+
+	if (gen_error) {
+		if (p) return p->s_tpp;
+		return 0;
+	}
+again:
+	tp = *(p->s_tpp);
+	switch(tp->tp_fund) {
+	case ERRONEOUS:
+		if (! gen_error) gen_error = pack_level;
+		return p->s_tpp;
+	case UNION:
+		sd = p->s_def;
+		p->bytes_upto_here +=
+			size_of_type(sd->sd_type, "selector");
+		return p->s_tpp;
+	default:
+		if (p->elem_count == p->nelem && p->s_nested) {
+			p = p->next;
+			free_e_stack(p_stack);
+			p_stack = p;
+			goto again;
+		}
+		p->elem_count++;
+		if (p->nelem >= 0 && p->elem_count > p->nelem) {
+			too_many_initialisers();
+			return p->s_tpp;
+		}
+		if (tp->tp_fund == ARRAY) {
+			return arr_elem(p->s_tpp, p);
+		}
+		return p->s_tpp;
+	case STRUCT:
+		sd = gen_align_to_next(p);
+		if (! sd) {
+			while (p->bytes_upto_here++ < tp->tp_size)
+				con_nullbyte();
+			if (p->s_nested) {
+				p = p->next;
+				free_e_stack(p_stack);
+				p_stack = p;
+				goto again;
+			}
+			too_many_initialisers();
+			return p->s_tpp;
+		}
+		if (AHEAD != '{' && aggregate_type(sd->sd_type)) {
+			return gen_tphead(&(sd->sd_type), 1);
+		}
+		return &(sd->sd_type);
+	}
+}
+
+struct sdef *gen_align_to_next(register struct e_stack *p)
+{
+	register struct sdef *sd = p->s_def;
+
+	if (! sd) return sd;
+#ifndef NOBITFIELD
+	do {
+		if (is_anon_idf(sd->sd_idf)) put_bf(sd->sd_type, (arith) 0);
+#endif
+		sd = next_field(sd, p);
+#ifndef NOBITFIELD
+	} while (sd && is_anon_idf(sd->sd_idf));
+#endif
+	p->s_def = sd;
+	return sd;
+}
+
+void gen_tpend(void)
+{
+	register struct e_stack *p = p_stack;
+	register struct type *tp;
+	register struct sdef *sd;
+	int getout = 0;
+
+	while (!getout && p) {
+	    if (!gen_error) {
+		tp = *(p->s_tpp);
+		switch(tp->tp_fund) {
+		case UNION:
+			sd = p->s_def;
+			p->bytes_upto_here +=
+				size_of_type(sd->sd_type, "selector");
+			while (p->bytes_upto_here++ < tp->tp_size)
+				con_nullbyte();
+			break;
+		case ARRAY:
+			if (tp->tp_size == -1) {
+				*(p->s_tpp) = construct_type(ARRAY, tp->tp_up,
+					0, p->elem_count, NO_PROTO);
+			}
+			else {
+				while (p->nelem-- > p->elem_count) {
+					pad(tp->tp_up);
+				}
+			}
+			break;
+		case STRUCT:
+			sd = gen_align_to_next(p);
+			while (sd) {
+				pad(sd->sd_type);
+				if (sd->sd_sdef)
+					p->bytes_upto_here += zero_bytes(sd);
+				p->bytes_upto_here +=
+					size_of_type(sd->sd_type, "selector");
+				sd = sd->sd_sdef;
+			}
+			while (p->bytes_upto_here++ < tp->tp_size)
+				con_nullbyte();
+			break;
+		}
+	    }
+	    if (! p->s_nested) getout = 1;
+	    p = p->next;
+	    free_e_stack(p_stack);
+	    p_stack = p;
+	}
+}
+
+/*	check_and_pad() is given a simple initialisation expression
+	where the type can be either a simple or an aggregate type.
+	In the latter case, only the first member is initialised and
+	the rest is zeroed.
+*/
+void check_and_pad(struct expr **expp, struct type **tpp)
+{
+	register struct type *tp = *tpp;
+
+	if (tp->tp_fund == ARRAY) {
+		check_and_pad(expp, &(tp->tp_up));	/* first member	*/
+		if (tp->tp_size == (arith)-1)
+			/*	no size specified upto here: just
+				set it to the size of one member.
+			*/
+			tp = *tpp = construct_type(ARRAY, tp->tp_up,
+					0, (arith)1, NO_PROTO);
+		else {
+			register int dim = tp->tp_size / tp->tp_up->tp_size;
+			/* pad remaining members with zeroes */
+			while (--dim > 0)
+				pad(tp->tp_up);
+		}
+	}
+	else
+	if (tp->tp_fund == STRUCT) {
+		register struct sdef *sd = tp->tp_sdef;
+
+		check_and_pad(expp, &(sd->sd_type));
+		/* next selector is aligned by adding extra zeroes */
+		if (sd->sd_sdef)
+			zero_bytes(sd);
+		while (sd = sd->sd_sdef) { /* pad remaining selectors	*/
+			pad(sd->sd_type);
+			if (sd->sd_sdef)
+				zero_bytes(sd);
+		}
+	}
+	else if (tp->tp_fund == UNION) {
+		/* only the first selector can be initialized */
+		register struct sdef *sd = tp->tp_sdef;
+
+		check_and_pad(expp, &(sd->sd_type));
+	}
+	else	/* simple type	*/
+		check_ival(expp, tp);
+}
+
+/*	pad() fills an element of type tp with zeroes.
+	If the element is an aggregate, pad() is called recursively.
+*/
+void pad(struct type *tpx)
+{
+	register struct type *tp = tpx;
+	register arith sz = tp->tp_size;
+
+	gen_tpcheck(&tpx);
+	if (gen_error) return;
+#ifndef NOBITFIELD
+	if (tp->tp_fund == FIELD) {
+		put_bf(tp, (arith)0);
+		return;
+	}
+#endif /* NOBITFIELD */
+
+	if (tp->tp_align >= word_align) while (sz >= word_size) {
+		C_con_cst((arith) 0);
+		sz -= word_size;
+	}
+	while (sz) {
+		C_con_icon("0", (arith) 1);
+		sz--;
+	}
+}
+
+/*	check_ival() checks whether the initialisation of an element
+	of a fundamental type is legal and, if so, performs the initialisation
+	by directly generating the necessary code.
+	No further comment is needed to explain the internal structure
+	of this straightforward function.
+*/
+void check_ival(struct expr **expp, register struct type *tp)
+{
+	/*	The philosophy here is that ch3cast puts an explicit
+		conversion node in front of the expression if the types
+		are not compatible.  In this case, the initialisation
+		expression is no longer a constant.
+	*/
+	register struct expr *expr = *expp;
+	
+	switch (tp->tp_fund) {
+	case CHAR:
+	case SHORT:
+	case INT:
+	case LONG:
+	case ENUM:
+	case POINTER:
+		ch3cast(expp, '=', tp);
+		expr = *expp;
+#ifdef DEBUG
+		print_expr("init-expr after cast", expr);
+#endif /* DEBUG */
+		if (!is_ld_cst(expr))
+			illegal_init_cst(expr);
+		else
+		if (expr->VL_CLASS == Const)
+			con_int(expr);
+		else
+		if (expr->VL_CLASS == Name) {
+			register struct idf *idf = expr->VL_IDF;
+
+			if (idf->id_def->df_level >= L_LOCAL
+			    && idf->id_def->df_sc != GLOBAL
+			    && idf->id_def->df_sc != EXTERN) {
+				illegal_init_cst(expr);
+			}
+			else	/* e.g., int f(); int p = f; */
+			if (idf->id_def->df_type->tp_fund == FUNCTION)
+				C_con_pnam(idf->id_text);
+			else	/* e.g., int a; int *p = &a; */
+				C_con_dnam(idf->id_text, expr->VL_VALUE);
+		}
+		else {
+			assert(expr->VL_CLASS == Label);
+			C_con_dlb(expr->VL_LBL, expr->VL_VALUE);
+		}
+		break;
+	case FLOAT:
+	case DOUBLE:
+	case LNGDBL:
+		ch3cast(expp, '=', tp);
+		expr = *expp;
+#ifdef DEBUG
+		print_expr("init-expr after cast", expr);
+#endif /* DEBUG */
+		if (expr->ex_class == Float) {
+			char buf[FLT_STRLEN];
+
+			flt_flt2str(&(expr->FL_ARITH), buf, FLT_STRLEN);
+			C_con_fcon(buf, expr->ex_type->tp_size);
+		}
+#ifdef NOTDEF
+
+Coercion from int to float is now always done compile time.
+This, to accept declarations like
+double	x = -(double)1;
+and also to prevent runtime coercions for compile-time constants.
+
+		else
+		if (expr->ex_class == Oper && expr->OP_OPER == INT2FLOAT) {
+			/* float f = 1; */
+			expr = expr->OP_RIGHT;
+			if (is_cp_cst(expr))
+				C_con_fcon(long2str((long)expr->VL_VALUE, 10),
+					tp->tp_size);
+			else 
+				illegal_init_cst(expr);
+		}
+#endif /* NOTDEF */
+		else
+			illegal_init_cst(expr);
+		break;
+
+#ifndef NOBITFIELD
+	case FIELD:
+		ch3cast(expp, '=', tp->tp_up);
+		expr = *expp;
+#ifdef DEBUG
+		print_expr("init-expr after cast", expr);
+#endif /* DEBUG */
+		if (is_cp_cst(expr))
+			put_bf(tp, expr->VL_VALUE);
+		else
+			illegal_init_cst(expr);
+		break;
+#endif /* NOBITFIELD */
+
+	case ERRONEOUS:
+		if (! gen_error) gen_error = pack_level;
+		/* fall through */
+	case VOID:
+		break;
+	default:
+		crash("check_ival");
+		/*NOTREACHED*/
+	}
+}
+
+/*	ch_array() initialises an array of characters when given
+	a string constant.
+	Alignment is taken care of.
+*/
+void ch_array(struct type **tpp,	/* type tp = array of characters	*/
+	struct expr *ex)
+{
+	register struct type *tp = *tpp;
+	register int length = ex->SG_LEN, i;
+	register char *to, *from, *s;
+
+	assert(ex->ex_class == String);
+	if (tp->tp_size == (arith)-1) {
+		/* set the dimension	*/
+		tp = *tpp = construct_type(ARRAY, tp->tp_up, 0, (arith)length, NO_PROTO);
+	}
+	else {
+		arith dim = tp->tp_size / tp->tp_up->tp_size;
+
+#ifdef LINT
+		if (length == dim + 1) {
+			    expr_warning(ex, "array is not null-terminated");
+		} else
+#endif
+		if (length > dim + 1) {
+			expr_strict(ex, "too many initializers");
+		}
+		length = dim;
+	}
+	/* throw out the characters of the already prepared string	*/
+	s = Malloc((unsigned) (length));
+	clear(s, (unsigned)length);
+	i = length <= ex->SG_LEN ? length : ex->SG_LEN;
+	to = s; from = ex->SG_VALUE;
+	while(--i >= 0) {
+		*to++ = *from++;
+	}
+	free(ex->SG_VALUE);
+	str_cst(s, length, 0);		/* a string, but not in rom */
+	free(s);
+}
+
+/*	As long as some parts of the pipeline cannot handle very long string
+	constants, string constants are written out in chunks
+*/
+void str_cst(register char *str, register int len, int inrom)
+{
+	int chunksize = ((127 + (int) word_size) / (int) word_size) * (int) word_size;
+
+	while (len > chunksize) {
+		if (inrom)
+			C_rom_scon(str, (arith) chunksize);
+		else	C_con_scon(str, (arith) chunksize);
+		len -= chunksize;
+		str += chunksize;
+	}
+	if (inrom)
+		C_rom_scon(str, (arith) len);
+	else	C_con_scon(str, (arith) len);
+}
+
+#ifndef NOBITFIELD
+/*	put_bf() takes care of the initialisation of (bit-)field
+	selectors of a struct: each time such an initialisation takes place,
+	put_bf() is called instead of the normal code generating routines.
+	Put_bf() stores the given integral value into "field" and
+	"throws" the result of "field" out if the current selector
+	is the last of this number of fields stored at the same address.
+*/
+void put_bf(struct type *tp, arith val)
+{
+	static long field = (arith)0;
+	static arith offset = (arith)-1;
+	register struct field *fd = tp->tp_field;
+	register struct sdef *sd =  fd->fd_sdef;
+	static struct expr exp;
+
+	assert(sd);
+	if (offset == (arith)-1) {
+		/* first bitfield in this field	*/
+		offset = sd->sd_offset;
+		exp.ex_type = tp->tp_up;
+		exp.ex_class = Value;
+		exp.VL_CLASS = Const;
+	}
+	if (val != 0)	/* insert the value into "field"	*/
+		field |= (val & fd->fd_mask) << fd->fd_shift;
+	if (sd->sd_sdef == 0 || sd->sd_sdef->sd_offset != offset) {
+		/* the selector was the last stored at this address	*/
+		exp.VL_VALUE = field;
+		con_int(&exp);
+		field = (arith)0;
+		offset = (arith)-1;
+	}
+}
+#endif /* NOBITFIELD */
+
+int zero_bytes(register struct sdef *sd)
+{
+	/*	fills the space between a selector of a struct
+		and the next selector of that struct with zero-bytes.
+	*/
+	register int n = sd->sd_sdef->sd_offset - sd->sd_offset -
+		size_of_type(sd->sd_type, "struct member");
+	int count = n;
+
+	while (n-- > 0)
+		con_nullbyte();
+	return count;
+}
+
+int valid_type(struct type *tp, char *str)
+{
+	assert(tp!=(struct type *)0);
+	if (tp->tp_size < 0) {
+		error("size of %s unknown", str);
+		return 0;
+	}
+	return 1;
+}
+
+void con_int(register struct expr *ex)
+{
+	register struct type *tp = ex->ex_type;
+
+	assert(is_cp_cst(ex));
+	if (tp->tp_unsigned)
+		C_con_ucon(long2str((long)ex->VL_VALUE, -10), tp->tp_size);
+	else if (tp->tp_size == word_size)
+		C_con_cst(ex->VL_VALUE);
+	else
+		C_con_icon(long2str((long)ex->VL_VALUE, 10), tp->tp_size);
+}
+
+void illegal_init_cst(struct expr *ex)
+{
+	expr_error(ex, "illegal initialization constant");
+	gen_error = pack_level;
+}
+
+void too_many_initialisers(void)
+{
+	error("too many initializers");
+	gen_error = pack_level;
+}
+}
diff --git a/lang/cem/cemcom.ansi/label.c b/lang/cem/cemcom.ansi/label.c
index fb200956e..e4c10f85d 100644
--- a/lang/cem/cemcom.ansi/label.c
+++ b/lang/cem/cemcom.ansi/label.c
@@ -14,11 +14,12 @@
 #include	"def.h"
 #include	"type.h"
 #include	"stack.h"
+#include    "error.h"
+
 
 extern char options[];
 
-enter_label(idf, defining)
-	register struct idf *idf;
+void enter_label(register struct idf *idf, int defining)
 {
 	/*	The identifier idf is entered as a label. If it is new,
 		it is entered into the idf list with the largest possible
@@ -45,8 +46,7 @@ enter_label(idf, defining)
 		def->df_initialized = 1;
 }
 
-unstack_label(idf)
-	register struct idf *idf;
+void unstack_label(register struct idf *idf)
 {
 	/*	The scope in which the label idf occurred is left.
 	*/
diff --git a/lang/cem/cemcom.ansi/label.h b/lang/cem/cemcom.ansi/label.h
index 629577db2..47d6b5bea 100644
--- a/lang/cem/cemcom.ansi/label.h
+++ b/lang/cem/cemcom.ansi/label.h
@@ -4,6 +4,8 @@
  */
 /* $Id$ */
 /*		L A B E L   D E F I N I T I O N				*/
+#ifndef LABEL_H_
+#define LABEL_H_
 
 #include <em_label.h>		/* obtain definition of "label" */
 
@@ -26,3 +28,10 @@ extern label datlab_count;
 		not be there, and if it is there, it may be from a
 		declaration or another application.
 	*/
+
+struct idf;
+
+void enter_label(register struct idf *idf, int defining);
+void unstack_label(register struct idf *idf);
+
+#endif /* LABEL_H_ */
diff --git a/lang/cem/cemcom.ansi/main.c b/lang/cem/cemcom.ansi/main.c
index d8e951af3..9d9f8903f 100644
--- a/lang/cem/cemcom.ansi/main.c
+++ b/lang/cem/cemcom.ansi/main.c
@@ -23,7 +23,13 @@
 #include	"specials.h"
 #include	"sizes.h"
 #include	"align.h"
+#include    "stack.h"
 #include	"macro.h"
+#include    "options.h"
+#include    "error.h"
+#include    "code.h"
+#include    "cstoper.h"
+#include    "tokenname.h"
 
 extern struct tokenname tkidf[];
 extern char *symbol2str();
@@ -34,7 +40,15 @@ struct sp_id special_ids[] =	{
 	{0, 0}
 };
 
-void dependency();
+void compile(int argc, char *argv[]);
+static void init(void);
+static void init_specials(register struct sp_id *si);
+#ifdef DEBUG
+void Info(void);
+#endif
+
+extern void C_program(void); /* program.c */
+
 
 #ifndef NOCROSS
 arith
@@ -63,8 +77,7 @@ int
 
 char *prog_name;
 
-main(argc, argv)
-	char *argv[];
+int main(int argc, char *argv[])
 {
 	/* parse and interpret the command line options	*/
 	prog_name = argv[0];
@@ -104,8 +117,7 @@ char *source = 0;
 char *nmlist = 0;
 #endif /* GEN_NM_LIST */
 
-compile(argc, argv)
-	char *argv[];
+void compile(int argc, char *argv[])
 {
 	char *result;
 #ifndef	LINT
@@ -190,7 +202,7 @@ compile(argc, argv)
 	}
 }
 
-init()
+static void init(void)
 {
 	init_cst();	/* initialize variables of "cstoper.c"		*/
 	reserve(tkidf);		/* mark the C reserved words as such	*/
@@ -255,8 +267,7 @@ init()
 	stack_level();
 }
 
-init_specials(si)
-	register struct sp_id *si;
+static void init_specials(register struct sp_id *si)
 {
 	while (si->si_identifier)	{
 		struct idf *idf = str2idf(si->si_identifier, 0);
@@ -269,7 +280,7 @@ init_specials(si)
 }
 
 #ifdef DEBUG
-Info()
+void Info(void)
 {
 	extern int cnt_string_cst, cnt_formal,
 		    cnt_decl_unary, cnt_def, cnt_expr, cnt_field,
@@ -301,14 +312,12 @@ Info()
 }
 #endif /* DEBUG */
 
-void
-No_Mem()				/* called by alloc package */
+void No_Mem(void)				/* called by alloc package */
 {
 	fatal("out of memory");
 }
 
-void
-C_failed()				/* called by EM_code module */
+void C_failed(void)				/* called by EM_code module */
 {
 	fatal("write failed");
 }
diff --git a/lang/cem/cemcom.ansi/next.str b/lang/cem/cemcom.ansi/next.str
new file mode 100644
index 000000000..5dd79564f
--- /dev/null
+++ b/lang/cem/cemcom.ansi/next.str
@@ -0,0 +1 @@
+#include "parameters.h"
diff --git a/lang/cem/cemcom.ansi/options.c b/lang/cem/cemcom.ansi/options.c
index c0b411934..62864f5b7 100644
--- a/lang/cem/cemcom.ansi/options.c
+++ b/lang/cem/cemcom.ansi/options.c
@@ -9,12 +9,14 @@
 #include	<stdlib.h>
 #include	<string.h>
 #include	<alloc.h>
+#include    "options.h"
 #include	"class.h"
 #include	"macro.h"
 #include	"idf.h"
 #include	"arith.h"
 #include	"sizes.h"
 #include	"align.h"
+#include    "error.h"
 
 char options[128];			/* one for every char	*/
 #ifdef	LINT
@@ -24,10 +26,11 @@ char loptions[128];			/* one for every char	*/
 extern int idfsize;
 extern int density;
 
-static int txt2int();
 
-do_option(text)
-	char *text;
+
+static int txt2int(register char **);
+
+void do_option(char *text)
 {
 	register char opt;
 
@@ -209,9 +212,7 @@ next_option:			/* to allow combined one-char options */
 	}
 }
 
-static int
-txt2int(tp)
-	register char **tp;
+static int txt2int(register char **tp)
 {
 	/*	the integer pointed to by *tp is read, while increasing
 		*tp; the resulting value is yielded.
diff --git a/lang/cem/cemcom.ansi/options.h b/lang/cem/cemcom.ansi/options.h
new file mode 100644
index 000000000..ade29ed88
--- /dev/null
+++ b/lang/cem/cemcom.ansi/options.h
@@ -0,0 +1,13 @@
+/*  Copyright (c) 2019 ACK Project.
+ *  See the copyright notice in the ACK home directory, 
+ *  in the file "Copyright".
+ *
+ *  Created on: 2019-02-07
+ *  
+ */
+#ifndef OPTIONS_H_
+#define OPTIONS_H_
+
+void do_option(char *text);
+
+#endif /* OPTIONS_H_ */
diff --git a/lang/cem/cemcom.ansi/pragma.c b/lang/cem/cemcom.ansi/pragma.c
index b4198d92b..335cb9263 100644
--- a/lang/cem/cemcom.ansi/pragma.c
+++ b/lang/cem/cemcom.ansi/pragma.c
@@ -6,37 +6,43 @@
 /* PREPROCESSOR: PRAGMA INTERPRETER */
 
 #include	"parameters.h"
+#include    "pragma.h"
+#include    "skip.h"
 
 #define P_UNKNOWN	0
 #define NR_PRAGMAS	0
 
-struct pkey {
+struct pkey
+{
 	char *pk_name;
 	int pk_key;
-} pragmas[NR_PRAGMAS + 1] = {
-	{0,		P_UNKNOWN}
-};
+} pragmas[NR_PRAGMAS + 1] =
+{
+{ 0, P_UNKNOWN } };
 
 extern struct idf *GetIdentifier();
 
-do_pragma()
+void do_pragma(void)
 {
 #if	NR_PRAGMAS
 	register struct pkey *pkp = &pragmas[0];
 #endif
 	register struct idf *id = GetIdentifier(1);
 
-	if (id != (struct idf *)0) {
+	if (id != (struct idf *) 0)
+	{
 #if	NR_PRAGMAS
-		while(pkp->pk_name) {
+		while(pkp->pk_name)
+		{
 			if (strcmp(pkp->pk_name, id->id_text) == 0)
-				break;
+			break;
 			pkp++;
 		}
 
-		switch (pkp->pk_key) {
-		case P_UNKNOWN:
-		default:
+		switch (pkp->pk_key)
+		{
+			case P_UNKNOWN:
+			default:
 			break;
 		}
 #endif
diff --git a/lang/cem/cemcom.ansi/pragma.h b/lang/cem/cemcom.ansi/pragma.h
new file mode 100644
index 000000000..df62ad6c0
--- /dev/null
+++ b/lang/cem/cemcom.ansi/pragma.h
@@ -0,0 +1,13 @@
+/*  Copyright (c) 2019 ACK Project.
+ *  See the copyright notice in the ACK home directory, 
+ *  in the file "Copyright".
+ *
+ *  Created on: 2019-02-07
+ *  
+ */
+#ifndef PRAGMA_H_
+#define PRAGMA_H_
+
+void do_pragma(void);
+
+#endif /* PRAGMA_H_ */
diff --git a/lang/cem/cemcom.ansi/program.g b/lang/cem/cemcom.ansi/program.g
index 631603cff..616065da5 100644
--- a/lang/cem/cemcom.ansi/program.g
+++ b/lang/cem/cemcom.ansi/program.g
@@ -1,224 +1,227 @@
-/*
- * (c) copyright 1987 by the Vrije Universiteit, Amsterdam, The Netherlands.
- * See the copyright notice in the ACK home directory, in the file "Copyright".
- */
-/* $Id$ */
-/* PROGRAM PARSER */
-
-/*	The presence of typedef declarations renders it impossible to
-	make a context-free grammar of C. Consequently we need
-	context-sensitive parsing techniques, the simplest one being
-	a subtle cooperation between the parser and the lexical scanner.
-	The lexical scanner has to know whether to return IDENTIFIER
-	or TYPE_IDENTIFIER for a given tag, and it obtains this information
-	from the definition list, as constructed by the parser.
-	The present grammar is essentially LL(2), and is processed by
-	a parser generator which accepts LL(1) with tie breaking rules
-	in C, of the form %if(cond) and %while(cond). To solve the LL(1)
-	ambiguities, the lexical scanner does a one symbol look-ahead.
-	This symbol, however, cannot always be correctly assessed, since
-	the present symbol may cause a change in the definition list
-	which causes the identification of the look-ahead symbol to be
-	invalidated.
-	The lexical scanner relies on the parser (or its routines) to
-	detect this situation and then update the look-ahead symbol.
-	An alternative approach would be to reassess the look-ahead symbol
-	in the lexical scanner when it is promoted to dot symbol. This
-	would be more beautiful but less correct, since then for a short
-	while there would be a discrepancy between the look-ahead symbol
-	and the definition list; I think it would nevertheless work in
-	correct programs.
-	A third solution would be to enter the identifier as soon as it
-	is found; its storage class is then known, although its full type
-	isn't. We would have to fill that in afterwards.
-
-	At block exit the situation is even worse. Upon reading the
-	closing brace, the names declared inside the function are cleared
-	from the name list. This action may expose a type identifier that
-	is the same as the identifier in the look-ahead symbol. This
-	situation certainly invalidates the third solution, and casts
-	doubts upon the second.
-*/
-
-%lexical	LLlex;
-%start		C_program, program;
-%start		If_expr, control_if_expression;
-
-{
-#include	"parameters.h"
-#include	<flt_arith.h>
-#include	"arith.h"
-#include	"LLlex.h"
-#include	"label.h"
-#include	"type.h"
-#include	"declar.h"
-#include	"decspecs.h"
-#include	"code.h"
-#include	"expr.h"
-#include	"def.h"
-#include    "stack.h"
-#ifdef	LINT
-#include	"l_lint.h"
-#endif	/* LINT */
-
-extern error();
-}
-
-control_if_expression
-	{
-		struct expr *exprX;
-	}
-:
-	constant_expression(&exprX)
-		{
-		}
-;
-
-/* 3.7 */
-program:
-	[%persistent external_definition]*
-	{ unstack_world(); }
-;
-
-/*	A C identifier definition is remarkable in that it formulates
-	the declaration in a way different from most other languages:
-	e.g., rather than defining x as a pointer-to-integer, it defines
-	*x as an integer and lets the compiler deduce that x is actually
-	pointer-to-integer.  This has profound consequences, both for the
-	structure of an identifier definition and for the compiler.
-	
-	A definition starts with a decl_specifiers, which contains things
-	like
-		typedef int
-	which is implicitly repeated for every definition in the list, and
-	then for each identifier a declarator is given, of the form
-		*a()
-	or so.  The decl_specifiers is kept in a struct decspecs, to be
-	used again and again, while the declarator is stored in a struct
-	declarator, only to be passed to declare_idf together with the
-	struct decspecs.
-
-	With the introduction of prototypes, extra problems for the scope
-	administration were introduced as well.  We can have, for example,
-	int x(double x);
-	and
-	int x(double x) { ... use(x) ... }
-	In the first case, the parameter name can be forgotten, whereas in
-	the second case, the parameter should have a block scope.  The
-	problem lies in the fact that the parameter's type is known before
-	the type of the function, which causes the def structure to be on
-	the end of the list.  Our solution is as follows:
-	1-  In case of a declaration, throw the parameter identifier away
-	    before the declaration of the outer x.
-	2-  In case of a definition, the function begin_proc() changes the
-	    def list for the identifier.  This means that declare_idf()
-	    contains an extra test in case we already saw a declaration of
-	    such a function, because this function is called before
-	    begin_proc().
-*/
-
-external_definition
-	{	struct decspecs Ds;
-		struct	declarator Dc;
-	}
-:
-	{	Ds = null_decspecs;
-		Dc = null_declarator;
-	}
-	[ %if (DOT != IDENTIFIER || AHEAD == IDENTIFIER)
-		decl_specifiers(&Ds)
-	|
-		{do_decspecs(&Ds);}
-	]
-	[
-		declarator(&Dc)
-		{
-			declare_idf(&Ds, &Dc, level);
-#ifdef	LINT
-			lint_ext_def(Dc.dc_idf, Ds.ds_sc);
-#endif	/* LINT */
-		}
-		[
-			function(&Ds, &Dc)
-		|
-			{	if (! Ds.ds_sc_given && ! Ds.ds_typequal &&
-				    Ds.ds_notypegiven) {
-					strict("declaration specifiers missing");
-				}
-			}
-			non_function(&Ds, &Dc)
-		]
-	|
-		{	if (! Ds.ds_sc_given && ! Ds.ds_typequal &&
-			    Ds.ds_notypegiven) {
-				strict("declaration missing");
-			}
-		}
-		';'
-	]
-	{remove_declarator(&Dc); flush_strings(); }
-;
-
-non_function(register struct decspecs *ds; register struct declarator *dc;)
-:
-	{	reject_params(dc);
-	}
-	[
-		initializer(dc->dc_idf, ds->ds_sc)
-	|
-		{ code_declaration(dc->dc_idf, (struct expr *) 0, level, ds->ds_sc); }
-	]
-	{
-#ifdef	LINT
-		lint_non_function_decl(ds, dc);
-#endif	/* LINT */
-	}
-	[
-		','
-		init_declarator(ds)
-	]*
-	';'
-;
-
-/* 3.7.1 */
-function(struct decspecs *ds; struct declarator *dc;)
-	{
-		arith fbytes;
-		register struct idf *idf = dc->dc_idf;
-	}
-:
-	{
-#ifdef	LINT
-		lint_start_function();
-#endif	/* LINT */
-		idf_initialized(idf);
-		stack_level();		/* L_FORMAL1 declarations */
-		declare_params(dc);
-		begin_proc(ds, idf);	/* sets global function info */
-		stack_level();		/* L_FORMAL2 declarations */
-		declare_protos(dc);
-	}
-	declaration*
-	{
-		check_formals(idf, dc);		/* check style-mixtures */
-		declare_formals(idf, &fbytes);
-#ifdef	LINT
-		lint_formals();
-#endif	/* LINT */
-	}
-	compound_statement
-	{
-		end_proc(fbytes);
-#ifdef	LINT
-		lint_implicit_return();
-#endif	/* LINT */
-		unstack_level();	/* L_FORMAL2 declarations */
-#ifdef	LINT
-		lint_end_formals();
-#endif	/* LINT */
-		unstack_level();	/* L_FORMAL1 declarations */
-#ifdef	LINT
-		lint_end_function();
-#endif	/* LINT */
-	}
-;
+/*
+ * (c) copyright 1987 by the Vrije Universiteit, Amsterdam, The Netherlands.
+ * See the copyright notice in the ACK home directory, in the file "Copyright".
+ */
+/* $Id$ */
+/* PROGRAM PARSER */
+
+/*	The presence of typedef declarations renders it impossible to
+	make a context-free grammar of C. Consequently we need
+	context-sensitive parsing techniques, the simplest one being
+	a subtle cooperation between the parser and the lexical scanner.
+	The lexical scanner has to know whether to return IDENTIFIER
+	or TYPE_IDENTIFIER for a given tag, and it obtains this information
+	from the definition list, as constructed by the parser.
+	The present grammar is essentially LL(2), and is processed by
+	a parser generator which accepts LL(1) with tie breaking rules
+	in C, of the form %if(cond) and %while(cond). To solve the LL(1)
+	ambiguities, the lexical scanner does a one symbol look-ahead.
+	This symbol, however, cannot always be correctly assessed, since
+	the present symbol may cause a change in the definition list
+	which causes the identification of the look-ahead symbol to be
+	invalidated.
+	The lexical scanner relies on the parser (or its routines) to
+	detect this situation and then update the look-ahead symbol.
+	An alternative approach would be to reassess the look-ahead symbol
+	in the lexical scanner when it is promoted to dot symbol. This
+	would be more beautiful but less correct, since then for a short
+	while there would be a discrepancy between the look-ahead symbol
+	and the definition list; I think it would nevertheless work in
+	correct programs.
+	A third solution would be to enter the identifier as soon as it
+	is found; its storage class is then known, although its full type
+	isn't. We would have to fill that in afterwards.
+
+	At block exit the situation is even worse. Upon reading the
+	closing brace, the names declared inside the function are cleared
+	from the name list. This action may expose a type identifier that
+	is the same as the identifier in the look-ahead symbol. This
+	situation certainly invalidates the third solution, and casts
+	doubts upon the second.
+*/
+
+%lexical	LLlex;
+%start		C_program, program;
+%start		If_expr, control_if_expression;
+
+{
+#include	"parameters.h"
+#include	<flt_arith.h>
+#include	"arith.h"
+#include	"LLlex.h"
+#include	"label.h"
+#include	"type.h"
+#include	"declar.h"
+#include	"decspecs.h"
+#include	"code.h"
+#include	"expr.h"
+#include	"def.h"
+#include    "idf.h"
+#include    "declarator.h"
+#include    "stack.h"
+#include    "proto.h"
+#include    "error.h"
+#ifdef	LINT
+#include	"l_lint.h"
+#endif	/* LINT */
+
+}
+
+control_if_expression
+	{
+		struct expr *exprX;
+	}
+:
+	constant_expression(&exprX)
+		{
+		}
+;
+
+/* 3.7 */
+program:
+	[%persistent external_definition]*
+	{ unstack_world(); }
+;
+
+/*	A C identifier definition is remarkable in that it formulates
+	the declaration in a way different from most other languages:
+	e.g., rather than defining x as a pointer-to-integer, it defines
+	*x as an integer and lets the compiler deduce that x is actually
+	pointer-to-integer.  This has profound consequences, both for the
+	structure of an identifier definition and for the compiler.
+	
+	A definition starts with a decl_specifiers, which contains things
+	like
+		typedef int
+	which is implicitly repeated for every definition in the list, and
+	then for each identifier a declarator is given, of the form
+		*a()
+	or so.  The decl_specifiers is kept in a struct decspecs, to be
+	used again and again, while the declarator is stored in a struct
+	declarator, only to be passed to declare_idf together with the
+	struct decspecs.
+
+	With the introduction of prototypes, extra problems for the scope
+	administration were introduced as well.  We can have, for example,
+	int x(double x);
+	and
+	int x(double x) { ... use(x) ... }
+	In the first case, the parameter name can be forgotten, whereas in
+	the second case, the parameter should have a block scope.  The
+	problem lies in the fact that the parameter's type is known before
+	the type of the function, which causes the def structure to be on
+	the end of the list.  Our solution is as follows:
+	1-  In case of a declaration, throw the parameter identifier away
+	    before the declaration of the outer x.
+	2-  In case of a definition, the function begin_proc() changes the
+	    def list for the identifier.  This means that declare_idf()
+	    contains an extra test in case we already saw a declaration of
+	    such a function, because this function is called before
+	    begin_proc().
+*/
+
+external_definition
+	{	struct decspecs Ds;
+		struct	declarator Dc;
+	}
+:
+	{	Ds = null_decspecs;
+		Dc = null_declarator;
+	}
+	[ %if (DOT != IDENTIFIER || AHEAD == IDENTIFIER)
+		decl_specifiers(&Ds)
+	|
+		{do_decspecs(&Ds);}
+	]
+	[
+		declarator(&Dc)
+		{
+			declare_idf(&Ds, &Dc, level);
+#ifdef	LINT
+			lint_ext_def(Dc.dc_idf, Ds.ds_sc);
+#endif	/* LINT */
+		}
+		[
+			function(&Ds, &Dc)
+		|
+			{	if (! Ds.ds_sc_given && ! Ds.ds_typequal &&
+				    Ds.ds_notypegiven) {
+					strict("declaration specifiers missing");
+				}
+			}
+			non_function(&Ds, &Dc)
+		]
+	|
+		{	if (! Ds.ds_sc_given && ! Ds.ds_typequal &&
+			    Ds.ds_notypegiven) {
+				strict("declaration missing");
+			}
+		}
+		';'
+	]
+	{remove_declarator(&Dc); flush_strings(); }
+;
+
+non_function(register struct decspecs *ds; register struct declarator *dc;)
+:
+	{	reject_params(dc);
+	}
+	[
+		initializer(dc->dc_idf, ds->ds_sc)
+	|
+		{ code_declaration(dc->dc_idf, (struct expr *) 0, level, ds->ds_sc); }
+	]
+	{
+#ifdef	LINT
+		lint_non_function_decl(ds, dc);
+#endif	/* LINT */
+	}
+	[
+		','
+		init_declarator(ds)
+	]*
+	';'
+;
+
+/* 3.7.1 */
+function(struct decspecs *ds; struct declarator *dc;)
+	{
+		arith fbytes;
+		register struct idf *idf = dc->dc_idf;
+	}
+:
+	{
+#ifdef	LINT
+		lint_start_function();
+#endif	/* LINT */
+		idf_initialized(idf);
+		stack_level();		/* L_FORMAL1 declarations */
+		declare_params(dc);
+		begin_proc(ds, idf);	/* sets global function info */
+		stack_level();		/* L_FORMAL2 declarations */
+		declare_protos(dc);
+	}
+	declaration*
+	{
+		check_formals(idf, dc);		/* check style-mixtures */
+		declare_formals(idf, &fbytes);
+#ifdef	LINT
+		lint_formals();
+#endif	/* LINT */
+	}
+	compound_statement
+	{
+		end_proc(fbytes);
+#ifdef	LINT
+		lint_implicit_return();
+#endif	/* LINT */
+		unstack_level();	/* L_FORMAL2 declarations */
+#ifdef	LINT
+		lint_end_formals();
+#endif	/* LINT */
+		unstack_level();	/* L_FORMAL1 declarations */
+#ifdef	LINT
+		lint_end_function();
+#endif	/* LINT */
+	}
+;
diff --git a/lang/cem/cemcom.ansi/proto.c b/lang/cem/cemcom.ansi/proto.c
index ff99ba98c..a9812b196 100644
--- a/lang/cem/cemcom.ansi/proto.c
+++ b/lang/cem/cemcom.ansi/proto.c
@@ -23,20 +23,24 @@
 #include	"declar.h"
 #include	"decspecs.h"
 #include	"proto.h"
+#include    "error.h"
+#include    "ch3.h"
 
 extern char options[];
 
-void
-check_for_void(pl)
-	register struct proto *pl;
+void check_for_void(register struct proto *pl)
 {
 	register int errcnt = 0;
 
-	if (!pl) return;
-	if ((pl->pl_flag & PL_VOID) && !(pl->next)) return;
+	if (!pl)
+		return;
+	if ((pl->pl_flag & PL_VOID) && !(pl->next))
+		return;
 
-	while (pl) {
-		if (pl->pl_flag & PL_VOID) {
+	while (pl)
+	{
+		if (pl->pl_flag & PL_VOID)
+		{
 			if (!errcnt && !(pl->pl_flag & PL_ERRGIVEN))
 				error("illegal use of void in argument list");
 			pl->pl_flag |= PL_ERRGIVEN;
@@ -46,37 +50,35 @@ check_for_void(pl)
 	}
 }
 
-add_proto(pl, ds, dc, lvl)
-	struct proto *pl;
-	struct decspecs *ds;
-	struct declarator *dc;
-	int lvl;
+void add_proto(struct proto *pl, struct decspecs *ds, struct declarator *dc,
+		int lvl)
 {
 	/*	The full typed identifier or abstract type, described
-		by the structures decspecs and declarator are turned
-		a into parameter type list structure.
-		The parameters will be declared at level L_FORMAL2,
-		later on it's decided whether they were prototypes
-		or actual declarations.
-	*/
+	 by the structures decspecs and declarator are turned
+	 a into parameter type list structure.
+	 The parameters will be declared at level L_FORMAL2,
+	 later on it's decided whether they were prototypes
+	 or actual declarations.
+	 */
 	register struct idf *idf = dc->dc_idf;
-	register struct def *def = idf ? idf->id_def : (struct def *)0;
+	register struct def *def = idf ? idf->id_def : (struct def *) 0;
 	register int sc = ds->ds_sc;
 	register struct type *type;
 	char formal_array = 0;
 
-	assert(ds->ds_type != (struct type *)0);
+	assert(ds->ds_type != (struct type * )0);
 
 	pl->pl_flag = PL_FORMAL;
 	type = declare_type(ds->ds_type, dc);
-	if (type->tp_size < (arith)0 && actual_declaration(sc, type)) {
+	if (type->tp_size < (arith) 0 && actual_declaration(sc, type))
+	{
 		extern char *symbol2str();
 		if (type->tp_fund != VOID)
 			error("unknown %s-type", symbol2str(type->tp_fund));
-		else {
-			if (idf != (struct idf *)0
-			    || ds->ds_sc_given
-			    || ds->ds_typequal) {
+		else
+		{
+			if (idf != (struct idf *) 0 || ds->ds_sc_given || ds->ds_typequal)
+			{
 				error("illegal use of void in argument list");
 				pl->pl_flag |= PL_ERRGIVEN;
 			}
@@ -84,43 +86,54 @@ add_proto(pl, ds, dc, lvl)
 			pl->pl_flag |= PL_VOID;
 		}
 	}
-	if (ds->ds_sc_given && ds->ds_sc != REGISTER) {
-		if (!(pl->pl_flag & PL_ERRGIVEN)) {
-		    if (ds->ds_sc != AUTO) {
-			error("illegal storage class in parameter declaration");
-		    } else {
-			warning("illegal storage class in parameter declaration");
-		    }
+	if (ds->ds_sc_given && ds->ds_sc != REGISTER)
+	{
+		if (!(pl->pl_flag & PL_ERRGIVEN))
+		{
+			if (ds->ds_sc != AUTO)
+			{
+				error("illegal storage class in parameter declaration");
+			}
+			else
+			{
+				warning("illegal storage class in parameter declaration");
+			}
 		}
 	}
 
 	/*	Perform some special conversions for parameters.
-	*/
-	if (type->tp_fund == FUNCTION) {
+	 */
+	if (type->tp_fund == FUNCTION)
+	{
 		type = construct_type(POINTER, type, 0, (arith) 0, NO_PROTO);
-	} else if (type->tp_fund == ARRAY) {
+	}
+	else if (type->tp_fund == ARRAY)
+	{
 		type = construct_type(POINTER, type->tp_up, 0, (arith) 0, NO_PROTO);
 		formal_array = 1;
 	}
 
 	/*	According to the standard we should ignore the storage
-		class of a parameter, unless it's part of a function
-		definition.
-		However, in the routine declare_protos we don't know decspecs,
-		and therefore we can't complain up there. So we build up the
-		storage class, and keep quiet until we reach declare_protos.
-	*/
-	sc = (ds->ds_sc_given && ds->ds_sc != REGISTER) ?
-				0 : sc == 0 ? FORMAL : REGISTER;
+	 class of a parameter, unless it's part of a function
+	 definition.
+	 However, in the routine declare_protos we don't know decspecs,
+	 and therefore we can't complain up there. So we build up the
+	 storage class, and keep quiet until we reach declare_protos.
+	 */
+	sc = (ds->ds_sc_given && ds->ds_sc != REGISTER) ? 0 :
+			sc == 0 ? FORMAL : REGISTER;
 
-	if (def && (def->df_level == lvl /* || def->df_level < L_PROTO */ )) {
+	if (def && (def->df_level == lvl /* || def->df_level < L_PROTO */))
+	{
 		/* redeclaration at the same level */
 		error("parameter %s redeclared", idf->id_text);
-	} else if (idf != (struct idf *)0) {
+	}
+	else if (idf != (struct idf *) 0)
+	{
 		/*	New definition, redefinition hides earlier one
-		*/
+		 */
 		register struct def *newdef = new_def();
-		
+
 		newdef->next = def;
 		newdef->df_level = lvl;
 		newdef->df_sc = sc;
@@ -133,28 +146,28 @@ add_proto(pl, ds, dc, lvl)
 		/* newdef->df_firstbrace = 0; */
 #endif
 		/*	We can't put the idf onto the stack, since these kinds
-			of declaration may occurs at any level, and the idf
-			does not necessarily go at this level. E.g.
+		 of declaration may occurs at any level, and the idf
+		 does not necessarily go at this level. E.g.
 
-			f() {
-			...
-				{ int func(int a, int b);
-				...
-				}
-			}
+		 f() {
+		 ...
+		 { int func(int a, int b);
+		 ...
+		 }
+		 }
 
-			The idf's a and b declared in the prototype declaration
-			do not go at any level, they are simply ignored.
-			However, in
+		 The idf's a and b declared in the prototype declaration
+		 do not go at any level, they are simply ignored.
+		 However, in
 
-			f(int a, int b) {
-			...
-			}
+		 f(int a, int b) {
+		 ...
+		 }
 
-			They should go at level L_FORMAL2. But at this stage
-			we don't know whether we have a prototype or function
-			definition. So, this process is postponed.
-		*/
+		 They should go at level L_FORMAL2. But at this stage
+		 we don't know whether we have a prototype or function
+		 definition. So, this process is postponed.
+		 */
 		idf->id_def = newdef;
 		update_ahead(idf);
 	}
@@ -163,35 +176,33 @@ add_proto(pl, ds, dc, lvl)
 	pl->pl_type = type;
 }
 
-struct tag *
-gettag(tp, idpp)
-struct type *tp;
-struct idf **idpp;
+static struct tag * gettag(struct type *tp, struct idf **idpp)
 {
-	struct tag *tg = (struct tag *)0;
+	struct tag *tg = (struct tag *) 0;
 	register int fund = tp->tp_fund;
 
-        while (fund == FIELD || fund == POINTER
-                || fund == ARRAY || fund == FUNCTION) {
-                tp = tp->tp_up;
-                fund = tp->tp_fund;
-        }
+	while (fund == FIELD || fund == POINTER || fund == ARRAY || fund == FUNCTION)
+	{
+		tp = tp->tp_up;
+		fund = tp->tp_fund;
+	}
 	*idpp = tp->tp_idf;
-	switch(tp->tp_fund) {
+	switch (tp->tp_fund)
+	{
 	case ENUM:
 	case UNION:
-	case STRUCT: tg = tp->tp_idf->id_tag; break;
+	case STRUCT:
+		tg = tp->tp_idf->id_tag;
+		break;
 	}
 	return tg;
 }
 
-
-declare_protos(dc)
-	register struct declarator *dc;
+void declare_protos(register struct declarator *dc)
 {
 	/*	At this points we know that the idf's in protolist are formal
-		parameters. So it's time to declare them at level L_FORMAL2.
-	*/
+	 parameters. So it's time to declare them at level L_FORMAL2.
+	 */
 	struct stack_level *stl = stack_level_of(L_FORMAL1);
 	register struct decl_unary *du;
 	register struct type *type;
@@ -200,31 +211,39 @@ declare_protos(dc)
 
 #ifdef	DEBUG
 	if (options['t'])
-		dumpidftab("start declare_protos", 0);
+	dumpidftab("start declare_protos", 0);
 #endif	/* DEBUG */
 	du = dc->dc_decl_unary;
-	while (du) {
-		if (du->du_fund == FUNCTION) {
-			if (du->next != (struct decl_unary *) 0) {
+	while (du)
+	{
+		if (du->du_fund == FUNCTION)
+		{
+			if (du->next != (struct decl_unary *) 0)
+			{
 				remove_proto_idfs(du->du_proto);
 				du->du_proto = 0;
-			} else break;
+			}
+			else
+				break;
 		}
 		du = du->next;
 	}
 	pl = du ? du->du_proto : NO_PROTO;
-	if (pl) {
+	if (pl)
+	{
 #if	0 /* the id_proto member is deleted (???) */
 		idf->id_proto = 0;
 #endif	/* 0 */
-		do {
+		do
+		{
 			struct tag *tg;
 			struct idf *idp = 0;
 
 			type = pl->pl_type;
 
 			/* `...' only for type checking */
-			if (pl->pl_flag & PL_ELLIPSIS) {
+			if (pl->pl_flag & PL_ELLIPSIS)
+			{
 				pl = pl->next;
 				continue;
 			}
@@ -233,14 +252,15 @@ declare_protos(dc)
 			if (type->tp_fund == VOID)
 				break;
 
-			if (!pl->pl_idf || !(def = pl->pl_idf->id_def)) {
+			if (!pl->pl_idf || !(def = pl->pl_idf->id_def))
+			{
 				error("no parameter identifier supplied");
 				pl = pl->next;
 				continue;
 			}
 
 			/*	Postponed storage class checking.
-			*/
+			 */
 			if (def->df_sc == 0)
 				error("illegal storage class in parameter declaration");
 
@@ -249,7 +269,8 @@ declare_protos(dc)
 			pl = pl->next;
 
 			tg = gettag(type, &idp);
-			if (tg && tg->tg_level <= L_PROTO) {
+			if (tg && tg->tg_level <= L_PROTO)
+			{
 				tg->tg_level = L_FORMAL2;
 				stack_idf(idp, stl);
 			}
@@ -257,43 +278,47 @@ declare_protos(dc)
 	}
 #ifdef	DEBUG
 	if (options['t'])
-		dumpidftab("end declare_protos", 0);
+	dumpidftab("end declare_protos", 0);
 #endif	/* DEBUG */
 }
 
-
-void
-update_proto(tp, otp)
-	register struct type *tp, *otp;
+void update_proto(register struct type *tp, register struct type *otp)
 {
 	/*	This routine performs the proto type updates.
-		Consider the following code:
+	 Consider the following code:
 
-		int f(double g());
-		int f(double g(int f(), int));
-		int f(double g(int f(long double), int));
+	 int f(double g());
+	 int f(double g(int f(), int));
+	 int f(double g(int f(long double), int));
 
-		The most accurate definition is the third line.
-		This routine will silently update all lists,
-		and removes the redundant occupied space.
-	*/
+	 The most accurate definition is the third line.
+	 This routine will silently update all lists,
+	 and removes the redundant occupied space.
+	 */
 	register struct proto *pl, *opl;
 
-	if (tp == otp) return;
-	if (!tp || !otp) return;
+	if (tp == otp)
+		return;
+	if (!tp || !otp)
+		return;
 
-	while (tp->tp_fund != FUNCTION) {
-		if (tp->tp_fund != POINTER && tp->tp_fund != ARRAY) return;
+	while (tp->tp_fund != FUNCTION)
+	{
+		if (tp->tp_fund != POINTER && tp->tp_fund != ARRAY)
+			return;
 		tp = tp->tp_up;
 		otp = otp->tp_up;
-		if (!tp) return;
+		if (!tp)
+			return;
 	}
 
 	pl = tp->tp_proto;
 	opl = otp->tp_proto;
-	if (pl && opl) {
+	if (pl && opl)
+	{
 		/* both have prototypes */
-		while (pl && opl) {
+		while (pl && opl)
+		{
 			update_proto(pl->pl_type, opl->pl_type);
 			pl = pl->next;
 			opl = opl->next;
@@ -302,9 +327,13 @@ update_proto(tp, otp)
 		 * a typedef.
 		 */
 		otp->tp_proto = tp->tp_proto;
-	} else if (opl) {
+	}
+	else if (opl)
+	{
 		/* old decl has type */
-	} else if (pl) {
+	}
+	else if (pl)
+	{
 		otp->tp_proto = pl;
 	}
 
@@ -314,39 +343,44 @@ update_proto(tp, otp)
 /* struct/union and enum tags can be declared inside prototypes
  * remove them from the symbol-table
  */
-void
-remove_proto_tag(tp)
-struct type *tp;
+static void remove_proto_tag(struct type *tp)
 {
 	register struct idf *ident;
 	register struct tag *tgp, **tgpp;
 	register int fund = tp->tp_fund;
 
-	while (fund == FIELD || fund == POINTER
-		|| fund == ARRAY || fund == FUNCTION) {
+	while (fund == FIELD || fund == POINTER || fund == ARRAY || fund == FUNCTION)
+	{
 		tp = tp->tp_up;
 		fund = tp->tp_fund;
 	}
 
 	ident = tp->tp_idf;
-	switch (tp->tp_fund) {
+	switch (tp->tp_fund)
+	{
 	case ENUM:
 	case STRUCT:
-	case UNION: tgpp = &(ident->id_tag); break;
-	default: return;
+	case UNION:
+		tgpp = &(ident->id_tag);
+		break;
+	default:
+		return;
 	}
 
-	while((*tgpp) && (*tgpp)->tg_type != tp) {
+	while ((*tgpp) && (*tgpp)->tg_type != tp)
+	{
 		tgpp = &((*tgpp)->next);
 	}
-	if (!*tgpp) return;
+	if (!*tgpp)
+		return;
 
 	tgp = *tgpp;
-	if (tgp->tg_level > L_PROTO) return;
+	if (tgp->tg_level > L_PROTO)
+		return;
 
 #ifdef DEBUG
 	if (options['t'])
-		print("Removing idf %s from list\n",
+	print("Removing idf %s from list\n",
 			ident->id_text);
 #endif
 
@@ -354,52 +388,55 @@ struct type *tp;
 	free_tag(tgp);
 }
 
-remove_proto_idfs(pl)
-	register struct proto *pl;
+/*	Remove all the identifier definitions from the
+	 prototype list. */
+void remove_proto_idfs(register struct proto *pl)
 {
-	/*	Remove all the identifier definitions from the
-		prototype list.
-	*/
+
 	register struct def *def;
 
-	while (pl) {
-		if (pl->pl_idf) {
+	while (pl)
+	{
+		if (pl->pl_idf)
+		{
 #ifdef DEBUG
 			if (options['t'])
-				print("Removing idf %s from list\n",
+			print("Removing idf %s from list\n",
 					pl->pl_idf->id_text);
 #endif
 			def = pl->pl_idf->id_def;
-			if (def && def->df_level <= L_PROTO) {
+			if (def && def->df_level <= L_PROTO)
+			{
 				pl->pl_idf->id_def = def->next;
 				free_def(def);
 			}
 			pl->pl_idf = (struct idf *) 0;
 		}
-		if (pl->pl_type) {
+		if (pl->pl_type)
+		{
 			remove_proto_tag(pl->pl_type);
 		}
 		pl = pl->next;
 	}
 }
 
-void
-call_proto(expp)
-	register struct expr **expp;
+void call_proto(register struct expr **expp)
 {
 	/*	If the function specified by (*expp)->OP_LEFT has a prototype,
-		the parameters are converted according the rules specified in
-		par. 3.3.2.2. E.i. the parameters are converted to the prototype
-		counter parts as if by assignment. For the parameters falling
-		under ellipsis clause the old parameters conversion stuff
-		applies.
-	*/
+	 the parameters are converted according the rules specified in
+	 par. 3.3.2.2. E.i. the parameters are converted to the prototype
+	 counter parts as if by assignment. For the parameters falling
+	 under ellipsis clause the old parameters conversion stuff
+	 applies.
+	 */
 	register struct expr *left = (*expp)->OP_LEFT;
 	register struct expr *right = (*expp)->OP_RIGHT;
 	register struct proto *pl = NO_PROTO;
-	static struct proto ellipsis = { 0, 0, 0, PL_ELLIPSIS };
+	static struct proto ellipsis =
+	{ 0, 0, 0, PL_ELLIPSIS };
 
-	if (left != NILEXPR) {		/* in case of an error */
+	if (left != NILEXPR)
+	{ /* in case of an error */
 		register struct type *tp = left->ex_type;
 
 		while (tp && tp->tp_fund != FUNCTION && tp != error_type)
@@ -408,17 +445,20 @@ call_proto(expp)
 			pl = tp->tp_proto;
 	}
 
-	if (right != NILEXPR) {		/* function call with parameters */
+	if (right != NILEXPR)
+	{ /* function call with parameters */
 		register struct expr **ep = &((*expp)->OP_RIGHT);
 		register int ecnt = 0, pcnt = 0;
 		struct expr **estack[NPARAMS];
 		struct proto *pstack[NPARAMS];
 
 		/* stack up the parameter expressions */
-		while (right->ex_class == Oper && right->OP_OPER == PARCOMMA) {
+		while (right->ex_class == Oper && right->OP_OPER == PARCOMMA)
+		{
 			if (ecnt == STDC_NPARAMS)
 				expr_strict(right, "number of parameters exceeds ANSI limit");
-			if (ecnt >= NPARAMS-1) {
+			if (ecnt >= NPARAMS - 1)
+			{
 				expr_error(right, "too many parameters");
 				return;
 			}
@@ -429,45 +469,56 @@ call_proto(expp)
 		estack[ecnt] = ep;
 
 		/*	Declarations like int f(void) do not expect any
-			parameters.
-		*/
-		if (pl && pl->pl_flag & PL_VOID) {
+		 parameters.
+		 */
+		if (pl && pl->pl_flag & PL_VOID)
+		{
 			expr_strict(*expp, "no parameters expected");
 			pl = NO_PROTO;
 		}
 
 		/* stack up the prototypes */
-		if (pl) {
+		if (pl)
+		{
 			pcnt--;
-			do {
+			do
+			{
 				/* stack prototypes */
 				pstack[++pcnt] = pl;
 				pl = pl->next;
 			} while (pl);
 		}
-		else {
+		else
+		{
 			pstack[0] = &ellipsis;
 		}
 
-		for (ecnt; ecnt >= 0; ecnt--) {
+		for (ecnt; ecnt >= 0; ecnt--)
+		{
 			/*	Only the parameters specified in the prototype
-				are checked and converted. The parameters that
-				fall under the ellipsis clause are neither
-				checked nor converted !
-			*/
-			if (pcnt < 0) {
-				expr_error(*expp, "more parameters than specified in prototype");
+			 are checked and converted. The parameters that
+			 fall under the ellipsis clause are neither
+			 checked nor converted !
+			 */
+			if (pcnt < 0)
+			{
+				expr_error(*expp,
+						"more parameters than specified in prototype");
 				break;
 			}
-			else if (!(pstack[pcnt]->pl_flag & PL_ELLIPSIS)) {
-				ch3cast(estack[ecnt],CASTAB,pstack[pcnt]->pl_type);
+			else if (!(pstack[pcnt]->pl_flag & PL_ELLIPSIS))
+			{
+				ch3cast(estack[ecnt], CASTAB, pstack[pcnt]->pl_type);
 				pcnt--;
-			} else
+			}
+			else
 				any2parameter(estack[ecnt]);
 		}
 		if (pcnt > 0 || (pcnt == 0 && !(pstack[0]->pl_flag & PL_ELLIPSIS)))
 			expr_error(*expp, "fewer parameters than specified in prototype");
-	} else {
+	}
+	else
+	{
 		if (pl && !(pl->pl_flag & PL_VOID))
 			expr_error(*expp, "fewer parameters than specified in prototype");
 	}
diff --git a/lang/cem/cemcom.ansi/proto.str b/lang/cem/cemcom.ansi/proto.str
index 03219deee..690588265 100644
--- a/lang/cem/cemcom.ansi/proto.str
+++ b/lang/cem/cemcom.ansi/proto.str
@@ -2,6 +2,9 @@
  * (c) copyright 1987 by the Vrije Universiteit, Amsterdam, The Netherlands.
  * See the copyright notice in the ACK home directory, in the file "Copyright".
  */
+#ifndef PROTO_H
+#define PROTO_H
+
 /* $Id$ */
 /* PARAMETER TYPE LIST DEFINITION */
 
@@ -20,3 +23,20 @@ struct proto {
 #define	PL_ERRGIVEN	0x08
 
 /* ALLOCDEF "proto" 20 */
+
+/* Forward structure declarations */
+struct expr;
+struct type;
+struct declarator;
+struct decspecs;
+
+
+void remove_proto_idfs(register struct proto *pl);
+void call_proto(register struct expr **expp);
+void update_proto(register struct type *tp, register struct type *otp);
+void declare_protos(register struct declarator *dc);
+void add_proto(struct proto *pl, struct decspecs *ds, struct declarator *dc,
+		int lvl);
+void check_for_void(register struct proto *pl);
+
+#endif
diff --git a/lang/cem/cemcom.ansi/skip.c b/lang/cem/cemcom.ansi/skip.c
index b617f08e9..8dd6ee837 100644
--- a/lang/cem/cemcom.ansi/skip.c
+++ b/lang/cem/cemcom.ansi/skip.c
@@ -10,9 +10,10 @@
 #include "LLlex.h"
 #include "class.h"
 #include "input.h"
+#include "skip.h"
 
 
-SkipToNewLine()
+int SkipToNewLine(void)
 {
 	register int ch;
 	register int garbage = 0;
diff --git a/lang/cem/cemcom.ansi/skip.h b/lang/cem/cemcom.ansi/skip.h
new file mode 100644
index 000000000..52ef8cbda
--- /dev/null
+++ b/lang/cem/cemcom.ansi/skip.h
@@ -0,0 +1,13 @@
+/*  Copyright (c) 2019 ACK Project.
+ *  See the copyright notice in the ACK home directory, 
+ *  in the file "Copyright".
+ *
+ *  Created on: 2019-02-07
+ *  
+ */
+#ifndef SKIP_H_
+#define SKIP_H_
+
+int SkipToNewLine(void);
+
+#endif /* SKIP_H_ */
diff --git a/lang/cem/cemcom.ansi/stab.c b/lang/cem/cemcom.ansi/stab.c
index f80b360b4..a7a7928c9 100644
--- a/lang/cem/cemcom.ansi/stab.c
+++ b/lang/cem/cemcom.ansi/stab.c
@@ -20,6 +20,7 @@
 #include	<flt_arith.h>
 #include	<stb.h>
 
+#include    "stab.h"
 #include    "idf.h"
 #include	"LLlex.h"
 #include	"stack.h"
@@ -29,34 +30,34 @@
 #include	"field.h"
 #include	"Lpars.h"
 #include	"level.h"
+#include    "print.h"
 
-extern long	full_mask[];
-extern char	*sprint();
+extern long full_mask[];
 
 #define INCR_SIZE	64
 
-static struct db_str {
-	unsigned	sz;
-	char		*base;
-	char		*currpos;
+static struct db_str
+{
+	unsigned sz;
+	char *base;
+	char *currpos;
 } db_str;
 
-static
-create_db_str()
+static void create_db_str(void)
 {
-	if (! db_str.base) {
+	if (!db_str.base)
+	{
 		db_str.base = Malloc(INCR_SIZE);
 		db_str.sz = INCR_SIZE;
 	}
 	db_str.currpos = db_str.base;
 }
 
-static
-addc_db_str(c)
-	int	c;
+static void addc_db_str(int c)
 {
 	int df = db_str.currpos - db_str.base;
-	if (df >= db_str.sz-1) {
+	if (df >= db_str.sz - 1)
+	{
 		db_str.sz += INCR_SIZE;
 		db_str.base = Realloc(db_str.base, db_str.sz);
 		db_str.currpos = db_str.base + df;
@@ -65,34 +66,35 @@ addc_db_str(c)
 	*db_str.currpos = '\0';
 }
 
-static
-adds_db_str(s)
-	char	*s;
+static void adds_db_str(char *s)
 {
-	while (*s) addc_db_str(*s++);
+	while (*s)
+		addc_db_str(*s++);
 }
 
-static void
-stb_type(tp)
-	register struct type	*tp;
+static void stb_type(register struct type *tp)
 {
-	char		buf[128];
-	static int	stb_count;
-	long		l;
+	char buf[128];
+	static int stb_count;
+	long l;
 
-	if (tp->tp_dbindex > 0) {
+	if (tp->tp_dbindex > 0)
+	{
 		adds_db_str(sprint(buf, "%d", tp->tp_dbindex));
 		return;
 	}
-	if (tp->tp_dbindex < 0 && tp->tp_size < 0) {
+	if (tp->tp_dbindex < 0 && tp->tp_size < 0)
+	{
 		adds_db_str(sprint(buf, "%d", -tp->tp_dbindex));
 		return;
 	}
-	if (tp->tp_dbindex <= 0) {
+	if (tp->tp_dbindex <= 0)
+	{
 		tp->tp_dbindex = ++stb_count;
 	}
 	adds_db_str(sprint(buf, "%d=", tp->tp_dbindex));
-	switch(tp->tp_fund) {
+	switch (tp->tp_fund)
+	{
 	/* simple types ... */
 	case VOID:
 		adds_db_str(sprint(buf, "%d", void_type->tp_dbindex));
@@ -101,49 +103,44 @@ stb_type(tp)
 	case LONG:
 	case CHAR:
 	case SHORT:
-		 l = full_mask[(int)tp->tp_size];
-		if (tp->tp_unsigned) {
-			adds_db_str(sprint(buf,
-				"r%d;0;%ld",
-				tp->tp_dbindex,
-				l));
+		l = full_mask[(int) tp->tp_size];
+		if (tp->tp_unsigned)
+		{
+			adds_db_str(sprint(buf, "r%d;0;%ld", tp->tp_dbindex, l));
 		}
-		else {
-			l &= ~ (1L << ((int)tp->tp_size * 8 - 1));
-			adds_db_str(sprint(buf,
-				"r%d;%ld;%ld",
-				tp->tp_dbindex,
-				-l-1,
-				l));
+		else
+		{
+			l &= ~(1L << ((int) tp->tp_size * 8 - 1));
+			adds_db_str(sprint(buf, "r%d;%ld;%ld", tp->tp_dbindex, -l - 1, l));
 		}
 		break;
 	case FLOAT:
 	case DOUBLE:
 	case LNGDBL:
-		adds_db_str(sprint(buf,
-		       "r%d;%ld;0",
-		       tp->tp_dbindex,
-		       (long)tp->tp_size));
+		adds_db_str(
+				sprint(buf, "r%d;%ld;0", tp->tp_dbindex, (long) tp->tp_size));
 		break;
 
-	/* constructed types ... */
+		/* constructed types ... */
 	case POINTER:
 		addc_db_str('*');
 		stb_type(tp->tp_up);
 		break;
 	case ARRAY:
-		if (tp->tp_size > 0) {
+		if (tp->tp_size > 0)
+		{
 			adds_db_str("ar");
 			stb_type(int_type);
-			adds_db_str(sprint(buf, ";0;%ld;", tp->tp_size / tp->tp_up->tp_size - 1));
+			adds_db_str(
+					sprint(buf, ";0;%ld;",
+							tp->tp_size / tp->tp_up->tp_size - 1));
 			stb_type(tp->tp_up);
 		}
 		break;
 	case ENUM:
-		if (tp->tp_size < 0) {
-			adds_db_str(sprint(buf,
-					   "xe%s:",
-					   tp->tp_idf->id_text));
+		if (tp->tp_size < 0)
+		{
+			adds_db_str(sprint(buf, "xe%s:", tp->tp_idf->id_text));
 			tp->tp_dbindex = -tp->tp_dbindex;
 			break;
 		}
@@ -151,15 +148,16 @@ stb_type(tp)
 		{
 			register struct stack_entry *se = local_level->sl_entry;
 
-			while (se) {
-				register struct def	*edef = se->se_idf->id_def;
-				while (edef) {
-					if (edef->df_type == tp &&
-					    edef->df_sc == ENUM) {
-						adds_db_str(sprint(buf,
-							"%s:%ld,",
-							se->se_idf->id_text,
-							edef->df_address));
+			while (se)
+			{
+				register struct def *edef = se->se_idf->id_def;
+				while (edef)
+				{
+					if (edef->df_type == tp && edef->df_sc == ENUM)
+					{
+						adds_db_str(
+								sprint(buf, "%s:%ld,", se->se_idf->id_text,
+										edef->df_address));
 					}
 					edef = edef->next;
 				}
@@ -170,37 +168,39 @@ stb_type(tp)
 		break;
 	case STRUCT:
 	case UNION:
-		if (tp->tp_size < 0) {
-			adds_db_str(sprint(buf,
-					   "x%c%s:",
-					   tp->tp_fund == STRUCT ? 's' : 'u',
-					   tp->tp_idf->id_text));
+		if (tp->tp_size < 0)
+		{
+			adds_db_str(
+					sprint(buf, "x%c%s:", tp->tp_fund == STRUCT ? 's' : 'u',
+							tp->tp_idf->id_text));
 			tp->tp_dbindex = -tp->tp_dbindex;
 			break;
 		}
-		adds_db_str(sprint(buf,
-				   "%c%ld",
-				   tp->tp_fund == STRUCT ? 's' : 'u',
-				   tp->tp_size));
+		adds_db_str(
+				sprint(buf, "%c%ld", tp->tp_fund == STRUCT ? 's' : 'u',
+						tp->tp_size));
 		{
-			register struct sdef	*sdef = tp->tp_sdef;
+			register struct sdef *sdef = tp->tp_sdef;
 
-			while (sdef) {
+			while (sdef)
+			{
 				adds_db_str(sdef->sd_idf->id_text);
 				addc_db_str(':');
-				if (sdef->sd_type->tp_fund == FIELD) {
+				if (sdef->sd_type->tp_fund == FIELD)
+				{
 					stb_type(sdef->sd_type->tp_up);
-					adds_db_str(sprint(buf,
-						",%ld,%ld;",
-						sdef->sd_offset*8+sdef->sd_type->tp_field->fd_shift,
-						sdef->sd_type->tp_field->fd_width));
+					adds_db_str(
+							sprint(buf, ",%ld,%ld;",
+									sdef->sd_offset * 8
+											+ sdef->sd_type->tp_field->fd_shift,
+									sdef->sd_type->tp_field->fd_width));
 				}
-				else {
+				else
+				{
 					stb_type(sdef->sd_type);
-					adds_db_str(sprint(buf,
-						",%ld,%ld;",
-						sdef->sd_offset*8,
-						sdef->sd_type->tp_size*8));
+					adds_db_str(
+							sprint(buf, ",%ld,%ld;", sdef->sd_offset * 8,
+									sdef->sd_type->tp_size * 8));
 				}
 				sdef = sdef->sd_sdef;
 			}
@@ -213,9 +213,7 @@ stb_type(tp)
 	}
 }
 
-stb_tag(tg, str)
-	register struct tag	*tg;
-	char			*str;
+void stb_tag(register struct tag *tg, char *str)
 {
 	create_db_str();
 	adds_db_str(str);
@@ -223,16 +221,12 @@ stb_tag(tg, str)
 	stb_type(tg->tg_type);
 	addc_db_str(';');
 	C_ms_stb_cst(db_str.base,
-		     N_LSYM,
-		     tg->tg_type == void_type || tg->tg_type->tp_size >= 32767
-		       ? 0
-		       : (int)tg->tg_type->tp_size,
-		     (arith) 0);
+	N_LSYM,
+			tg->tg_type == void_type || tg->tg_type->tp_size >= 32767 ?
+					0 : (int) tg->tg_type->tp_size, (arith) 0);
 }
 
-stb_typedef(tp, str)
-	register struct type	*tp;
-	char			*str;
+void stb_typedef(register struct type *tp, char *str)
 {
 	create_db_str();
 	adds_db_str(str);
@@ -240,23 +234,19 @@ stb_typedef(tp, str)
 	stb_type(tp);
 	addc_db_str(';');
 	C_ms_stb_cst(db_str.base,
-		     N_LSYM,
-		     tp == void_type || tp->tp_size >= 32767
-		       ? 0
-		       : (int)tp->tp_size,
-		     (arith) 0);
+	N_LSYM, tp == void_type || tp->tp_size >= 32767 ? 0 : (int) tp->tp_size,
+			(arith) 0);
 }
 
-stb_string(df, kind, str)
-	register struct def	*df;
-	char			*str;
+void stb_string(register struct def *df, int kind, char* str)
 {
-	register struct type	*tp = df->df_type;
+	register struct type *tp = df->df_type;
 
 	create_db_str();
 	adds_db_str(str);
 	addc_db_str(':');
-	switch(kind) {
+	switch (kind)
+	{
 	case FUNCTION:
 		addc_db_str(df->df_sc == STATIC ? 'f' : 'F');
 		stb_type(tp->tp_up);
@@ -264,40 +254,50 @@ stb_string(df, kind, str)
 		C_ms_stb_pnam(db_str.base, N_FUN, 1 /* proclevel */, str);
 		break;
 	default:
-		if (df->df_sc == FORMAL ||
-		    (df->df_sc == REGISTER && df->df_address >= 0)) {
-						/* value parameter */
+		if (df->df_sc == FORMAL
+				|| (df->df_sc == REGISTER && df->df_address >= 0))
+		{
+			/* value parameter */
 			addc_db_str('p');
 			stb_type(tp);
 			addc_db_str(';');
 			C_ms_stb_cst(db_str.base, N_PSYM, 0, df->df_address);
 		}
-		else if (df->df_sc != AUTO && df->df_sc != REGISTER) {
-						/* global */
+		else if (df->df_sc != AUTO && df->df_sc != REGISTER)
+		{
+			/* global */
 			int stabtp = df->df_initialized ? N_STSYM : N_LCSYM;
-			if (df->df_sc == STATIC) {
-				if (df->df_level >= L_LOCAL) {
+			if (df->df_sc == STATIC)
+			{
+				if (df->df_level >= L_LOCAL)
+				{
 					addc_db_str('V');
 				}
-				else {
+				else
+				{
 					addc_db_str('S');
 				}
 			}
-			else {
+			else
+			{
 				addc_db_str('G');
 			}
 			stb_type(tp);
 			addc_db_str(';');
-			if (df->df_sc == STATIC && df->df_level >= L_LOCAL) {
-				C_ms_stb_dlb(db_str.base, stabtp, 0, (label) df->df_address, (arith) 0);
+			if (df->df_sc == STATIC && df->df_level >= L_LOCAL)
+			{
+				C_ms_stb_dlb(db_str.base, stabtp, 0, (label) df->df_address,
+						(arith) 0);
 			}
-			else {
+			else
+			{
 				C_ms_stb_dnam(db_str.base, stabtp, 0, str, (arith) 0);
 			}
 		}
-		else {	/* local variable */
-			stb_type(tp);	/* assign type num to avoid
-						   difficult to parse string */
+		else
+		{ /* local variable */
+			stb_type(tp); /* assign type num to avoid
+			 difficult to parse string */
 			addc_db_str(';');
 			C_ms_stb_cst(db_str.base, N_LSYM, 0, df->df_address);
 		}
diff --git a/lang/cem/cemcom.ansi/stab.h b/lang/cem/cemcom.ansi/stab.h
new file mode 100644
index 000000000..5f584adf8
--- /dev/null
+++ b/lang/cem/cemcom.ansi/stab.h
@@ -0,0 +1,20 @@
+/*  Copyright (c) 2019 ACK Project.
+ *  See the copyright notice in the ACK home directory, 
+ *  in the file "Copyright".
+ *
+ *  Created on: 2019-02-07
+ *  
+ */
+#ifndef STAB_H_
+#define STAB_H_
+
+
+struct def;
+struct type;
+struct tag;
+
+void stb_tag(register struct tag *tg, char *str);
+void stb_typedef(register struct type *tp, char *str);
+void stb_string(register struct def *df, int kind, char* str);
+
+#endif /* STAB_H_ */
diff --git a/lang/cem/cemcom.ansi/stack.c b/lang/cem/cemcom.ansi/stack.c
index c8616b86e..1d2cd699f 100644
--- a/lang/cem/cemcom.ansi/stack.c
+++ b/lang/cem/cemcom.ansi/stack.c
@@ -22,6 +22,9 @@
 #include	"struct.h"
 #include	"level.h"
 #include	"mes.h"
+#include    "code.h"
+#include    "util.h"
+#include    "error.h"
 
 /* #include	<em_reg.h> */
 
@@ -41,7 +44,7 @@ struct stack_level *local_level = &UniversalLevel;
 
 int level;	/* Always equal to local_level->sl_level. */
 
-stack_level()	{
+void stack_level(void)	{
 	/*	A new level is added on top of the identifier stack.
 	*/
 	register struct stack_level *stl = new_stack_level();
@@ -57,10 +60,9 @@ stack_level()	{
 #endif	/* LINT */
 }
 
-void
-stack_idf(idf, stl)
-	struct idf *idf;
-	register struct stack_level *stl;
+void stack_idf(
+	struct idf *idf,
+	register struct stack_level *stl)
 {
 	/*	The identifier idf is inserted in the stack on level stl,
 		but only if it is not already present at this level.
@@ -81,8 +83,7 @@ stack_idf(idf, stl)
 	stl->sl_entry = se;
 }
 
-struct stack_level *
-stack_level_of(lvl)
+struct stack_level *stack_level_of(int lvl)
 {
 	/*	The stack_level corresponding to level lvl is returned.
 		The stack should probably be an array, to be extended with
@@ -100,7 +101,7 @@ stack_level_of(lvl)
 	return stl;
 }
 
-unstack_level()
+void unstack_level(void)
 {
 	/*	The top level of the identifier stack is removed.
 	*/
@@ -174,7 +175,7 @@ unstack_level()
 #endif	/* DEBUG */
 }
 
-unstack_world()
+void unstack_world(void)
 {
 	/*	The global level of identifiers is scanned, and final
 		decisions are taken about such issues as
@@ -263,14 +264,13 @@ unstack_world()
 extern char *nmlist;	/* BAH! -- main.c	*/
 static File *nfp = 0;
 
-open_name_list()
+void open_name_list(void)
 {
 	if (nmlist && sys_open(nmlist, OP_WRITE, &nfp) == 0)
 		fatal("cannot create namelist %s", nmlist);
 }
 
-namelist(nm)
-	char *nm;
+void namelist(char *nm)
 {
 	if (nmlist)	{
 		sys_write(nfp, nm, strlen(nm));
diff --git a/lang/cem/cemcom.ansi/stack.str b/lang/cem/cemcom.ansi/stack.str
index ddb38c56c..a7f59d1db 100644
--- a/lang/cem/cemcom.ansi/stack.str
+++ b/lang/cem/cemcom.ansi/stack.str
@@ -2,9 +2,14 @@
  * (c) copyright 1987 by the Vrije Universiteit, Amsterdam, The Netherlands.
  * See the copyright notice in the ACK home directory, in the file "Copyright".
  */
+#ifndef STACK_H_
+#define STACK_H_
+
 /* $Id$ */
 /* IDENTIFIER STACK DEFINITIONS */
 
+struct idf;
+
 /*	The identifier stack is implemented as a stack of sets.
 	The stack is implemented by a doubly linked list,
 	the sets by singly linked lists.
@@ -30,5 +35,26 @@ struct stack_entry	{
 /* ALLOCDEF "stack_entry" 50 */
 
 extern struct stack_level *local_level;
-extern struct stack_level *stack_level_of();
 extern int level;
+
+/*	A new level is added on top of the identifier stack. */
+void stack_level(void);
+/*	The identifier idf is inserted in the stack on level stl,
+	but only if it is not already present at this level.
+*/
+void stack_idf(struct idf *idf, register struct stack_level *stl);
+/*The stack_level corresponding to level lvl is returned.
+  The stack should probably be an array, to be extended with
+ realloc where needed.
+*/
+struct stack_level *stack_level_of(int lvl);
+/* The top level of the identifier stack is removed. */
+void unstack_level(void);
+void unstack_world(void);
+
+#ifdef GEN_NM_LIST
+void open_name_list(void);
+void namelist(char *nm);
+#endif /* GEN_NM_LIST */
+
+#endif 
diff --git a/lang/cem/cemcom.ansi/statement.g b/lang/cem/cemcom.ansi/statement.g
index 9eb60d2ed..3d1dcd4f2 100644
--- a/lang/cem/cemcom.ansi/statement.g
+++ b/lang/cem/cemcom.ansi/statement.g
@@ -1,505 +1,506 @@
-/*
- * (c) copyright 1987 by the Vrije Universiteit, Amsterdam, The Netherlands.
- * See the copyright notice in the ACK home directory, in the file "Copyright".
- */
-/* $Id$ */
-/*	STATEMENT SYNTAX PARSER	*/
-
-{
-#include	"parameters.h"
-#ifndef	LINT
-#include	<em.h>
-#else
-#include	"l_em.h"
-#include	"l_lint.h"
-#endif	/* LINT */
-
-#include	<flt_arith.h>
-#include    "idf.h"
-#include	"arith.h"
-#include	"LLlex.h"
-#include	"type.h"
-#include	"label.h"
-#include	"expr.h"
-#include	"code.h"
-#include	"stack.h"
-#include	"def.h"
-#ifdef DBSYMTAB
-#include	<stb.h>
-#endif /* DBSYMTAB */
-
-extern int level;
-extern char options[];
-}
-
-/* Each statement construction is stacked in order to trace a
- * statement to such a construction. Example: a case statement should
- * be recognized as a piece of the most enclosing switch statement.
- */
-
-/* 3.6 */
-statement
-	{
-#ifdef	LINT
-		lint_statement();
-#endif	/* LINT */
-	}
-:
-%if (AHEAD != ':')
-	expression_statement
-|
-	label ':' statement
-|
-	compound_statement
-|
-	if_statement
-|
-	while_statement
-|
-	do_statement
-|
-	for_statement
-|
-	switch_statement
-|
-	case_statement
-|
-	default_statement
-|
-	BREAK
-	{
-		code_break();
-#ifdef	LINT
-		lint_break_stmt();
-#endif	/* LINT */
-	}
-	';'
-|
-	CONTINUE
-	{
-		code_continue();
-#ifdef	LINT
-		lint_continue_stmt();
-#endif	/* LINT */
-	}
-	';'
-|
-	return_statement
-|
-	jump
-|
-	';'
-;
-
-
-expression_statement
-	{	struct expr *expr;
-	}
-:
-	expression(&expr)
-	';'
-		{
-#ifdef	DEBUG
-			print_expr("expression_statement", expr);
-#endif	/* DEBUG */
-			code_expr(expr, RVAL, FALSE, NO_LABEL, NO_LABEL);
-			free_expression(expr);
-		}
-;
-
-/* 3.6.1 (partially) */
-label
-	{ struct idf *idf; }
-:
-	identifier(&idf)
-	{
-		/*	This allows the following absurd case:
-
-				typedef int grz;
-				main()	{
-					grz: printf("A labelled statement\n");
-				}
-		*/
-#ifdef	LINT
-		lint_label();
-#endif	/* LINT */
-		define_label(idf);
-		C_df_ilb((label)idf->id_label->df_address);
-	}
-;
-
-/* 3.6.4.1 */
-if_statement
-	{
-		struct expr *expr;
-		label l_true = text_label();
-		label l_false = text_label();
-		label l_end = text_label();
-	}
-:
-	IF
-	'('
-	expression(&expr)
-		{
-			opnd2test(&expr, IF);
-			if (is_cp_cst(expr))	{
-				/*	The comparison has been optimized
-					to a 0 or 1.
-				*/
-				if (expr->VL_VALUE == (arith)0)	{
-					C_bra(l_false);
-				}
-				/* else fall through */
-#ifdef	LINT
-				start_if_part(1);
-#endif	/* LINT */
-			}
-			else	{
-				code_expr(expr, RVAL, TRUE, l_true, l_false);
-				C_df_ilb(l_true);
-#ifdef	LINT
-				start_if_part(0);
-#endif	/* LINT */
-			}
-			free_expression(expr);
-		}
-	')'
-	statement
-	[%prefer
-		ELSE
-			{
-#ifdef	LINT
-				start_else_part();
-#endif	/* LINT */
-				C_bra(l_end);
-				C_df_ilb(l_false);
-			}
-		statement
-			{	C_df_ilb(l_end);
-#ifdef	LINT
-				end_if_else_stmt();
-#endif	/* LINT */
-			}
-	|
-		empty
-			{	C_df_ilb(l_false);
-#ifdef	LINT
-				end_if_stmt();
-#endif	/* LINT */
-			}
-	]
-;
-
-/* 3.6.5.3 */
-while_statement
-	{
-		struct expr *expr;
-		label l_break = text_label();
-		label l_continue = text_label();
-		label l_body = text_label();
-	}
-:
-	WHILE
-		{
-			stack_stmt(l_break, l_continue);
-			C_df_ilb(l_continue);
-		}
-	'('
-	expression(&expr)
-		{
-			opnd2test(&expr, WHILE);
-			if (is_cp_cst(expr))	{
-				if (expr->VL_VALUE == (arith)0)	{
-					C_bra(l_break);
-				}
-			}
-			else	{
-				code_expr(expr, RVAL, TRUE, l_body, l_break);
-				C_df_ilb(l_body);
-			}
-#ifdef	LINT
-			start_while_stmt(expr);
-#endif	/* LINT */
-		}
-	')'
-	statement
-		{
-			C_bra(l_continue);
-			C_df_ilb(l_break);
-			unstack_stmt();
-			free_expression(expr);
-#ifdef	LINT
-			end_loop_body();
-			end_loop_stmt();
-#endif	/* LINT */
-		}
-;
-
-/* 3.6.5.2 */
-do_statement
-	{	struct expr *expr;
-		label l_break = text_label();
-		label l_continue = text_label();
-		label l_body = text_label();
-	}
-:
-	DO
-		{	C_df_ilb(l_body);
-			stack_stmt(l_break, l_continue);
-#ifdef	LINT
-			start_do_stmt();
-#endif	/* LINT */
-		}
-	statement
-	WHILE
-	'('
-		{
-#ifdef	LINT
-			end_loop_body();
-#endif	/* LINT */
-			C_df_ilb(l_continue);
-		}
-	expression(&expr)
-		{
-			opnd2test(&expr, WHILE);
-			if (is_cp_cst(expr))	{
-				if (expr->VL_VALUE == (arith)1)	{
-					C_bra(l_body);
-				}
-#ifdef	LINT
-				end_do_stmt(1, expr->VL_VALUE != (arith)0);
-#endif	/* LINT */
-			}
-			else	{
-				code_expr(expr, RVAL, TRUE, l_body, l_break);
-#ifdef	LINT
-				end_do_stmt(0, 0);
-#endif	/* LINT */
-			}
-			C_df_ilb(l_break);
-		}
-	')'
-	';'
-		{
-			unstack_stmt();
-			free_expression(expr);
-		}
-;
-
-/* 3.6.5.3 */
-for_statement
-	{	struct expr *e_init = 0, *e_test = 0, *e_incr = 0;
-		label l_break = text_label();
-		label l_continue = text_label();
-		label l_body = text_label();
-		label l_test = text_label();
-	}
-:
-	FOR
-		{	stack_stmt(l_break, l_continue);
-		}
-	'('
-	[
-		expression(&e_init)
-		{	code_expr(e_init, RVAL, FALSE, NO_LABEL, NO_LABEL);
-		}
-	]?
-	';'
-		{	C_df_ilb(l_test);
-		}
-	[
-		expression(&e_test)
-		{
-			opnd2test(&e_test, FOR);
-			if (is_cp_cst(e_test))	{
-				if (e_test->VL_VALUE == (arith)0)	{
-					C_bra(l_break);
-				}
-			}
-			else	{
-				code_expr(e_test, RVAL, TRUE, l_body, l_break);
-				C_df_ilb(l_body);
-			}
-		}
-	]?
-	';'
-	expression(&e_incr)?
-	')'
-		{
-#ifdef	LINT
-			start_for_stmt(e_test);
-#endif	/* LINT */
-		}
-	statement
-		{
-#ifdef	LINT
-			end_loop_body();
-#endif	/* LINT */
-			C_df_ilb(l_continue);
-			if (e_incr)
-				code_expr(e_incr, RVAL, FALSE,
-							NO_LABEL, NO_LABEL);
-			C_bra(l_test);
-			C_df_ilb(l_break);
-			unstack_stmt();
-			free_expression(e_init);
-			free_expression(e_test);
-			free_expression(e_incr);
-#ifdef	LINT
-			end_loop_stmt();
-#endif	/* LINT */
-		}
-;
-
-/* 3.6.4.2 */
-switch_statement
-	{
-		struct expr *expr;
-	}
-:
-	SWITCH
-	'('
-	expression(&expr)
-		{
-			code_startswitch(&expr);
-#ifdef	LINT
-			start_switch_part(is_cp_cst(expr));
-#endif	/* LINT */
-		}
-	')'
-	statement
-		{
-#ifdef	LINT
-			end_switch_stmt();
-#endif	/* LINT */
-			code_endswitch();
-			free_expression(expr);
-		}
-;
-
-/* 3.6.1 (partially) */
-case_statement
-	{
-		struct expr *expr;
-	}
-:
-	CASE
-	constant_expression(&expr)
-		{
-#ifdef	LINT
-			lint_case_stmt(0);
-#endif	/* LINT */
-			code_case(expr);
-			free_expression(expr);
-		}
-	':'
-	statement
-;
-
-/* 3.6.1 (partially) */
-default_statement
-:
-	DEFAULT
-		{
-#ifdef	LINT
-			lint_case_stmt(1);
-#endif	/* LINT */
-			code_default();
-		}
-	':'
-	statement
-;
-
-/* 3.6.6.4 */
-return_statement
-	{	struct expr *expr = 0;
-	}
-:
-	RETURN
-	[
-		expression(&expr)
-		{
-#ifdef	LINT
-			lint_ret_conv(expr);
-#endif	/* LINT */
-
-			do_return_expr(expr);
-			free_expression(expr);
-#ifdef	LINT
-			lint_return_stmt(VALRETURNED);
-#endif	/* LINT */
-		}
-	|
-		empty
-		{
-			do_return();
-#ifdef	LINT
-			lint_return_stmt(NOVALRETURNED);
-#endif	/* LINT */
-		}
-	]
-	';'
-;
-
-/* 3.6.6.1 (partially) */
-jump
-	{	struct idf *idf;
-	}
-:
-	GOTO
-	identifier(&idf)
-	';'
-		{
-			apply_label(idf);
-			C_bra((label)idf->id_label->df_address);
-#ifdef	LINT
-			lint_jump_stmt(idf);
-#endif	/* LINT */
-		}
-;
-
-/* 3.6.2 */
-compound_statement
-	{
-#ifdef DBSYMTAB
-	static int	brc_level = 1;
-	int		decl_seen = brc_level == 1;
-#endif /* DBSYMTAB */
-	}
-:
-	'{'
-		{
-			stack_level();
-		}
-	[%while ((DOT != IDENTIFIER && AHEAD != ':') ||
-		 (DOT == IDENTIFIER && AHEAD == IDENTIFIER))
-			/* >>> conflict on TYPE_IDENTIFIER, IDENTIFIER */
-		declaration
-		{
-#ifdef DBSYMTAB
-			decl_seen++;
-#endif /* DBSYMTAB */
-		}
-	]*
-		{
-#ifdef DBSYMTAB
-			++brc_level;
-			if (options['g'] && decl_seen) {
-				C_ms_std((char *) 0, N_LBRAC, brc_level);
-			}
-#endif /* DBSYMTAB */
-		}
-	[%persistent
-		statement
-	]*
-	'}'
-		{
-			unstack_level();
-#ifdef DBSYMTAB
-			if (options['g'] && decl_seen) {
-				C_ms_std((char *) 0, N_RBRAC, brc_level);
-			}
-			brc_level--;
-#endif /* DBSYMTAB */
-		}
-;
+/*
+ * (c) copyright 1987 by the Vrije Universiteit, Amsterdam, The Netherlands.
+ * See the copyright notice in the ACK home directory, in the file "Copyright".
+ */
+/* $Id$ */
+/*	STATEMENT SYNTAX PARSER	*/
+
+{
+#include	"parameters.h"
+#ifndef	LINT
+#include	<em.h>
+#else
+#include	"l_em.h"
+#include	"l_lint.h"
+#endif	/* LINT */
+
+#include	<flt_arith.h>
+#include    "idf.h"
+#include	"arith.h"
+#include	"LLlex.h"
+#include	"type.h"
+#include	"label.h"
+#include	"expr.h"
+#include	"code.h"
+#include	"stack.h"
+#include	"def.h"
+#include    "switch.h"
+#ifdef DBSYMTAB
+#include	<stb.h>
+#endif /* DBSYMTAB */
+
+extern int level;
+extern char options[];
+}
+
+/* Each statement construction is stacked in order to trace a
+ * statement to such a construction. Example: a case statement should
+ * be recognized as a piece of the most enclosing switch statement.
+ */
+
+/* 3.6 */
+statement
+	{
+#ifdef	LINT
+		lint_statement();
+#endif	/* LINT */
+	}
+:
+%if (AHEAD != ':')
+	expression_statement
+|
+	label ':' statement
+|
+	compound_statement
+|
+	if_statement
+|
+	while_statement
+|
+	do_statement
+|
+	for_statement
+|
+	switch_statement
+|
+	case_statement
+|
+	default_statement
+|
+	BREAK
+	{
+		code_break();
+#ifdef	LINT
+		lint_break_stmt();
+#endif	/* LINT */
+	}
+	';'
+|
+	CONTINUE
+	{
+		code_continue();
+#ifdef	LINT
+		lint_continue_stmt();
+#endif	/* LINT */
+	}
+	';'
+|
+	return_statement
+|
+	jump
+|
+	';'
+;
+
+
+expression_statement
+	{	struct expr *expr;
+	}
+:
+	expression(&expr)
+	';'
+		{
+#ifdef	DEBUG
+			print_expr("expression_statement", expr);
+#endif	/* DEBUG */
+			code_expr(expr, RVAL, FALSE, NO_LABEL, NO_LABEL);
+			free_expression(expr);
+		}
+;
+
+/* 3.6.1 (partially) */
+label
+	{ struct idf *idf; }
+:
+	identifier(&idf)
+	{
+		/*	This allows the following absurd case:
+
+				typedef int grz;
+				main()	{
+					grz: printf("A labelled statement\n");
+				}
+		*/
+#ifdef	LINT
+		lint_label();
+#endif	/* LINT */
+		define_label(idf);
+		C_df_ilb((label)idf->id_label->df_address);
+	}
+;
+
+/* 3.6.4.1 */
+if_statement
+	{
+		struct expr *expr;
+		label l_true = text_label();
+		label l_false = text_label();
+		label l_end = text_label();
+	}
+:
+	IF
+	'('
+	expression(&expr)
+		{
+			opnd2test(&expr, IF);
+			if (is_cp_cst(expr))	{
+				/*	The comparison has been optimized
+					to a 0 or 1.
+				*/
+				if (expr->VL_VALUE == (arith)0)	{
+					C_bra(l_false);
+				}
+				/* else fall through */
+#ifdef	LINT
+				start_if_part(1);
+#endif	/* LINT */
+			}
+			else	{
+				code_expr(expr, RVAL, TRUE, l_true, l_false);
+				C_df_ilb(l_true);
+#ifdef	LINT
+				start_if_part(0);
+#endif	/* LINT */
+			}
+			free_expression(expr);
+		}
+	')'
+	statement
+	[%prefer
+		ELSE
+			{
+#ifdef	LINT
+				start_else_part();
+#endif	/* LINT */
+				C_bra(l_end);
+				C_df_ilb(l_false);
+			}
+		statement
+			{	C_df_ilb(l_end);
+#ifdef	LINT
+				end_if_else_stmt();
+#endif	/* LINT */
+			}
+	|
+		empty
+			{	C_df_ilb(l_false);
+#ifdef	LINT
+				end_if_stmt();
+#endif	/* LINT */
+			}
+	]
+;
+
+/* 3.6.5.3 */
+while_statement
+	{
+		struct expr *expr;
+		label l_break = text_label();
+		label l_continue = text_label();
+		label l_body = text_label();
+	}
+:
+	WHILE
+		{
+			stack_stmt(l_break, l_continue);
+			C_df_ilb(l_continue);
+		}
+	'('
+	expression(&expr)
+		{
+			opnd2test(&expr, WHILE);
+			if (is_cp_cst(expr))	{
+				if (expr->VL_VALUE == (arith)0)	{
+					C_bra(l_break);
+				}
+			}
+			else	{
+				code_expr(expr, RVAL, TRUE, l_body, l_break);
+				C_df_ilb(l_body);
+			}
+#ifdef	LINT
+			start_while_stmt(expr);
+#endif	/* LINT */
+		}
+	')'
+	statement
+		{
+			C_bra(l_continue);
+			C_df_ilb(l_break);
+			unstack_stmt();
+			free_expression(expr);
+#ifdef	LINT
+			end_loop_body();
+			end_loop_stmt();
+#endif	/* LINT */
+		}
+;
+
+/* 3.6.5.2 */
+do_statement
+	{	struct expr *expr;
+		label l_break = text_label();
+		label l_continue = text_label();
+		label l_body = text_label();
+	}
+:
+	DO
+		{	C_df_ilb(l_body);
+			stack_stmt(l_break, l_continue);
+#ifdef	LINT
+			start_do_stmt();
+#endif	/* LINT */
+		}
+	statement
+	WHILE
+	'('
+		{
+#ifdef	LINT
+			end_loop_body();
+#endif	/* LINT */
+			C_df_ilb(l_continue);
+		}
+	expression(&expr)
+		{
+			opnd2test(&expr, WHILE);
+			if (is_cp_cst(expr))	{
+				if (expr->VL_VALUE == (arith)1)	{
+					C_bra(l_body);
+				}
+#ifdef	LINT
+				end_do_stmt(1, expr->VL_VALUE != (arith)0);
+#endif	/* LINT */
+			}
+			else	{
+				code_expr(expr, RVAL, TRUE, l_body, l_break);
+#ifdef	LINT
+				end_do_stmt(0, 0);
+#endif	/* LINT */
+			}
+			C_df_ilb(l_break);
+		}
+	')'
+	';'
+		{
+			unstack_stmt();
+			free_expression(expr);
+		}
+;
+
+/* 3.6.5.3 */
+for_statement
+	{	struct expr *e_init = 0, *e_test = 0, *e_incr = 0;
+		label l_break = text_label();
+		label l_continue = text_label();
+		label l_body = text_label();
+		label l_test = text_label();
+	}
+:
+	FOR
+		{	stack_stmt(l_break, l_continue);
+		}
+	'('
+	[
+		expression(&e_init)
+		{	code_expr(e_init, RVAL, FALSE, NO_LABEL, NO_LABEL);
+		}
+	]?
+	';'
+		{	C_df_ilb(l_test);
+		}
+	[
+		expression(&e_test)
+		{
+			opnd2test(&e_test, FOR);
+			if (is_cp_cst(e_test))	{
+				if (e_test->VL_VALUE == (arith)0)	{
+					C_bra(l_break);
+				}
+			}
+			else	{
+				code_expr(e_test, RVAL, TRUE, l_body, l_break);
+				C_df_ilb(l_body);
+			}
+		}
+	]?
+	';'
+	expression(&e_incr)?
+	')'
+		{
+#ifdef	LINT
+			start_for_stmt(e_test);
+#endif	/* LINT */
+		}
+	statement
+		{
+#ifdef	LINT
+			end_loop_body();
+#endif	/* LINT */
+			C_df_ilb(l_continue);
+			if (e_incr)
+				code_expr(e_incr, RVAL, FALSE,
+							NO_LABEL, NO_LABEL);
+			C_bra(l_test);
+			C_df_ilb(l_break);
+			unstack_stmt();
+			free_expression(e_init);
+			free_expression(e_test);
+			free_expression(e_incr);
+#ifdef	LINT
+			end_loop_stmt();
+#endif	/* LINT */
+		}
+;
+
+/* 3.6.4.2 */
+switch_statement
+	{
+		struct expr *expr;
+	}
+:
+	SWITCH
+	'('
+	expression(&expr)
+		{
+			code_startswitch(&expr);
+#ifdef	LINT
+			start_switch_part(is_cp_cst(expr));
+#endif	/* LINT */
+		}
+	')'
+	statement
+		{
+#ifdef	LINT
+			end_switch_stmt();
+#endif	/* LINT */
+			code_endswitch();
+			free_expression(expr);
+		}
+;
+
+/* 3.6.1 (partially) */
+case_statement
+	{
+		struct expr *expr;
+	}
+:
+	CASE
+	constant_expression(&expr)
+		{
+#ifdef	LINT
+			lint_case_stmt(0);
+#endif	/* LINT */
+			code_case(expr);
+			free_expression(expr);
+		}
+	':'
+	statement
+;
+
+/* 3.6.1 (partially) */
+default_statement
+:
+	DEFAULT
+		{
+#ifdef	LINT
+			lint_case_stmt(1);
+#endif	/* LINT */
+			code_default();
+		}
+	':'
+	statement
+;
+
+/* 3.6.6.4 */
+return_statement
+	{	struct expr *expr = 0;
+	}
+:
+	RETURN
+	[
+		expression(&expr)
+		{
+#ifdef	LINT
+			lint_ret_conv(expr);
+#endif	/* LINT */
+
+			do_return_expr(expr);
+			free_expression(expr);
+#ifdef	LINT
+			lint_return_stmt(VALRETURNED);
+#endif	/* LINT */
+		}
+	|
+		empty
+		{
+			do_return();
+#ifdef	LINT
+			lint_return_stmt(NOVALRETURNED);
+#endif	/* LINT */
+		}
+	]
+	';'
+;
+
+/* 3.6.6.1 (partially) */
+jump
+	{	struct idf *idf;
+	}
+:
+	GOTO
+	identifier(&idf)
+	';'
+		{
+			apply_label(idf);
+			C_bra((label)idf->id_label->df_address);
+#ifdef	LINT
+			lint_jump_stmt(idf);
+#endif	/* LINT */
+		}
+;
+
+/* 3.6.2 */
+compound_statement
+	{
+#ifdef DBSYMTAB
+	static int	brc_level = 1;
+	int		decl_seen = brc_level == 1;
+#endif /* DBSYMTAB */
+	}
+:
+	'{'
+		{
+			stack_level();
+		}
+	[%while ((DOT != IDENTIFIER && AHEAD != ':') ||
+		 (DOT == IDENTIFIER && AHEAD == IDENTIFIER))
+			/* >>> conflict on TYPE_IDENTIFIER, IDENTIFIER */
+		declaration
+		{
+#ifdef DBSYMTAB
+			decl_seen++;
+#endif /* DBSYMTAB */
+		}
+	]*
+		{
+#ifdef DBSYMTAB
+			++brc_level;
+			if (options['g'] && decl_seen) {
+				C_ms_std((char *) 0, N_LBRAC, brc_level);
+			}
+#endif /* DBSYMTAB */
+		}
+	[%persistent
+		statement
+	]*
+	'}'
+		{
+			unstack_level();
+#ifdef DBSYMTAB
+			if (options['g'] && decl_seen) {
+				C_ms_std((char *) 0, N_RBRAC, brc_level);
+			}
+			brc_level--;
+#endif /* DBSYMTAB */
+		}
+;
diff --git a/lang/cem/cemcom.ansi/stb.c b/lang/cem/cemcom.ansi/stb.c
index 0a98e6725..4fcd26258 100644
--- a/lang/cem/cemcom.ansi/stb.c
+++ b/lang/cem/cemcom.ansi/stb.c
@@ -3,10 +3,10 @@
  * See the copyright notice in the ACK home directory, in the file "Copyright".
  */
 /* $Id$ */
-/* library routine for copying structs */
 
-__stb(n, f, t)
-	register char *f, *t; register n;
+
+/* library routine for copying structs */
+void __stb(register int n, register char *f, register char *t)
 {
 	if (n > 0)
 		do
diff --git a/lang/cem/cemcom.ansi/stmt.str b/lang/cem/cemcom.ansi/stmt.str
index feaa82fcd..aea09b36b 100644
--- a/lang/cem/cemcom.ansi/stmt.str
+++ b/lang/cem/cemcom.ansi/stmt.str
@@ -2,6 +2,9 @@
  * (c) copyright 1987 by the Vrije Universiteit, Amsterdam, The Netherlands.
  * See the copyright notice in the ACK home directory, in the file "Copyright".
  */
+#ifndef STMT_H_
+#define STMT_H_
+
 /* $Id$ */
 /*	S T A T E M E N T - B L O C K   D E F I N I T I O N S	*/
 
@@ -12,3 +15,5 @@ struct stmt_block	{
 };
 
 /* ALLOCDEF "stmt_block" 5 */
+
+#endif
\ No newline at end of file
diff --git a/lang/cem/cemcom.ansi/struct.c b/lang/cem/cemcom.ansi/struct.c
index a36b11e20..fbba71a0e 100644
--- a/lang/cem/cemcom.ansi/struct.c
+++ b/lang/cem/cemcom.ansi/struct.c
@@ -19,16 +19,23 @@
 #include	"Lpars.h"
 #include	"align.h"
 #include	"level.h"
+#include    "ch3.h"
 #include	"sizes.h"
+#include    "error.h"
 
 /*	Type of previous selector declared with a field width specified,
 	if any.  If a selector is declared with no field with it is set to 0.
 */
-static field_busy = 0;
+static int field_busy = 0;
 
 extern char options[];
 char *symbol2str();
-int lcm();
+
+static void check_selector(register struct idf *, struct type *);
+/*	Greatest Common Divisor */
+static int gcd(register int , register int );
+/*	Least Common Multiple */
+static int lcm(register int, register int);
 
 /*	The semantics of the identification of structure/union tags is
 	obscure.  Some highly regarded compilers are found out to accept,
@@ -51,13 +58,13 @@ int lcm();
 	as well).
 */
 
-add_sel(stp, tp, idf, sdefpp, szp, fd)	/* this is horrible */
-	register struct type *stp;	/* type of the structure */
-	struct type *tp;		/* type of the selector */
-	register struct idf *idf;	/* idf of the selector */
-	struct sdef ***sdefpp;	/* address of hook to selector definition */
-	arith *szp;		/* pointer to struct size upto here */
-	struct field *fd;
+void add_sel( /* this is horrible */
+	register struct type *stp,	/* type of the structure */
+	struct type *tp,		/* type of the selector */
+	register struct idf *idf,	/* idf of the selector */
+	struct sdef ***sdefpp,	/* address of hook to selector definition */
+	arith *szp,		/* pointer to struct size upto here */
+	struct field *fd)
 {
 	/*	The selector idf with type tp is added to two chains: the
 		selector identification chain starting at idf->id_sdef,
@@ -147,12 +154,11 @@ add_sel(stp, tp, idf, sdefpp, szp, fd)	/* this is horrible */
 	}
 }
 
-check_selector(idf, stp)
-	register struct idf *idf;
-	struct type *stp;	/* the type of the struct */
+static void check_selector(register struct idf *idf, struct type *stp)
 {
 	/*	checks if idf occurs already as a selector in
-		struct or union *stp.
+		struct or union *stp. "stp" indicates the type
+		of the struct.
 	*/
 	register struct sdef *sdef = stp->tp_sdef;
 	
@@ -163,9 +169,7 @@ check_selector(idf, stp)
 	}
 }
 
-declare_struct(fund, idf, tpp)
-	register struct idf *idf;
-	struct type **tpp;
+void declare_struct(int fund, register struct idf *idf, struct type **tpp)
 {
 	/*	A struct, union or enum (depending on fund) with tag (!)
 		idf is declared, and its type (incomplete as it may be) is
@@ -232,9 +236,9 @@ declare_struct(fund, idf, tpp)
 	}
 }
 
-apply_struct(fund, idf, tpp)
-	register struct idf *idf;
-	struct type **tpp;
+void apply_struct(int fund,
+	register struct idf *idf,
+	struct type **tpp)
 {
 	/*	The occurrence of a struct, union or enum (depending on
 		fund) with tag idf is noted. It may or may not have been
@@ -258,10 +262,9 @@ apply_struct(fund, idf, tpp)
 		declare_struct(fund, idf, tpp);
 }
 
-struct sdef *
-idf2sdef(idf, tp)
-	register struct idf *idf;
-	struct type *tp;
+struct sdef *idf2sdef(
+	register struct idf *idf,
+	struct type *tp)
 {
 	/*	The identifier idf is identified as a selector
 		in the struct tp.
@@ -296,9 +299,7 @@ idf2sdef(idf, tp)
 }
 
 #if	0
-int
-uniq_selector(idf_sdef)
-	register struct sdef *idf_sdef;
+int uniq_selector(register struct sdef *idf_sdef)
 {
 	/*	Returns true if idf_sdef (which is guaranteed to exist)
 		is unique for this level, i.e there is no other selector
@@ -324,12 +325,12 @@ uniq_selector(idf_sdef)
 
 #ifndef NOBITFIELD
 arith
-add_field(szp, fd, fdtpp, idf, stp)
-	arith *szp;			/* size of struct upto here	*/
-	register struct field *fd;	/* bitfield, containing width	*/
-	register struct type **fdtpp;	/* type of selector		*/
-	struct idf *idf;		/* name of selector		*/
-	register struct type *stp;	/* current struct descriptor	*/
+add_field(
+	arith *szp,			/* size of struct upto here	*/
+	register struct field *fd,	/* bitfield, containing width	*/
+	register struct type **fdtpp,	/* type of selector		*/
+	struct idf *idf,		/* name of selector		*/
+	register struct type *stp)	/* current struct descriptor	*/
 {
 	/*	The address where this selector is put is returned. If the
 		selector with specified width does not fit in the word, or
@@ -438,18 +439,12 @@ add_field(szp, fd, fdtpp, idf, stp)
 #endif /* NOBITFIELD */
 
 /* some utilities */
-int
-is_struct_or_union(fund)
-	register int fund;
+int is_struct_or_union(register int fund)
 {
 	return fund == STRUCT || fund == UNION;
 }
 
-/*	Greatest Common Divisor
- */
-int
-gcd(m, n)
-	register int m, n;
+static int gcd(register int m, register int n)
 {
 	register int r;
 
@@ -461,11 +456,8 @@ gcd(m, n)
 	return m;
 }
 
-/*	Least Common Multiple
- */
-int
-lcm(m, n)
-	register int m, n;
+
+static int lcm(register int m, register int n)
 {
 	return m * (n / gcd(m, n));
 }
diff --git a/lang/cem/cemcom.ansi/struct.str b/lang/cem/cemcom.ansi/struct.str
index 8dafd856e..c0a95244d 100644
--- a/lang/cem/cemcom.ansi/struct.str
+++ b/lang/cem/cemcom.ansi/struct.str
@@ -2,7 +2,17 @@
  * (c) copyright 1987 by the Vrije Universiteit, Amsterdam, The Netherlands.
  * See the copyright notice in the ACK home directory, in the file "Copyright".
  */
+#ifndef STRUCT_H_
+#define STRUCT_H_
+
 /* $Id$ */
+
+#include "arith.h"
+
+struct type;
+struct idf;
+struct field;
+
 /* SELECTOR DESCRIPTOR */
 
 struct sdef	{		/* for selectors */
@@ -27,4 +37,26 @@ struct tag	{		/* for struct-, union- and enum tags */
 
 /* ALLOCDEF "tag" 10 */
 
-struct sdef *idf2sdef();
+struct sdef *idf2sdef(register struct idf *idf, struct type *tp);
+void add_sel(
+	register struct type *stp,	/* type of the structure */
+	struct type *tp,		/* type of the selector */
+	register struct idf *idf,	/* idf of the selector */
+	struct sdef ***sdefpp,	/* address of hook to selector definition */
+	arith *szp,		/* pointer to struct size upto here */
+	struct field *fd);
+void declare_struct(int fund, register struct idf *idf, struct type **tpp);
+void apply_struct(int fund, register struct idf *idf, struct type **tpp);
+int is_struct_or_union(register int fund);
+
+#ifndef NOBITFIELD
+arith
+add_field(
+	arith *szp,			/* size of struct upto here	*/
+	register struct field *fd,	/* bitfield, containing width	*/
+	register struct type **fdtpp,	/* type of selector		*/
+	struct idf *idf,		/* name of selector		*/
+	register struct type *stp);	/* current struct descriptor	*/
+#endif	
+
+#endif
diff --git a/lang/cem/cemcom.ansi/switch.c b/lang/cem/cemcom.ansi/switch.c
index 77a9dcef3..24cb82c6f 100644
--- a/lang/cem/cemcom.ansi/switch.c
+++ b/lang/cem/cemcom.ansi/switch.c
@@ -23,13 +23,16 @@
 #include	"expr.h"
 #include	"type.h"
 #include	"sizes.h"
+#include    "switch.h"
+#include    "eval.h"
+#include    "ch3.h"
+#include    "error.h"
 
 extern char options[];
 
 int	density = DENSITY;
 
-compact(nr, low, up)
-	arith low, up;
+static int compact(int nr, arith low, arith up)
 {
 	/*	Careful! up - low might not fit in an arith. And then,
 		the test "up-low < 0" might also not work to detect this
@@ -49,8 +52,7 @@ static struct switch_hdr *switch_stack = 0;
 	For simplicity, we suppose int_size == word_size.
 */
 
-code_startswitch(expp)
-	struct expr **expp;
+void code_startswitch(struct expr **expp)
 {
 	/*	Check the expression, stack a new case header and
 		fill in the necessary fields.
@@ -85,7 +87,7 @@ code_startswitch(expp)
 	C_bra(l_table);			/* goto start of switch_table	*/
 }
 
-code_endswitch()
+void code_endswitch(void)
 {
 	register struct switch_hdr *sh = switch_stack;
 	register label tablabel;
@@ -158,9 +160,7 @@ code_endswitch()
 	unstack_stmt();
 }
 
-void
-code_case(expr)
-	struct expr *expr;
+void code_case(struct expr *expr)
 {
 	register arith val;
 	register struct case_entry *ce;
@@ -227,8 +227,7 @@ code_case(expr)
 	}
 }
 
-void
-code_default()
+void code_default(void)
 {
 	register struct switch_hdr *sh = switch_stack;
 
diff --git a/lang/cem/cemcom.ansi/switch.str b/lang/cem/cemcom.ansi/switch.str
index fd2dd455b..94a45ca42 100644
--- a/lang/cem/cemcom.ansi/switch.str
+++ b/lang/cem/cemcom.ansi/switch.str
@@ -2,7 +2,16 @@
  * (c) copyright 1987 by the Vrije Universiteit, Amsterdam, The Netherlands.
  * See the copyright notice in the ACK home directory, in the file "Copyright".
  */
+#ifndef SWITCH_H_
+#define SWITCH_H_
+
 /* $Id$ */
+
+#include "arith.h"
+
+struct type;
+struct expr;
+
 /*		S W I T C H - T A B L E - S T R U C T U R E		*/
 
 struct switch_hdr	{
@@ -27,3 +36,12 @@ struct case_entry	{
 };
 
 /* ALLOCDEF "case_entry" 20 */
+
+void code_startswitch(struct expr **expp);
+void code_endswitch(void);
+void code_case(struct expr *expr);
+void code_default(void);
+
+
+
+#endif
\ No newline at end of file
diff --git a/lang/cem/cemcom.ansi/tokcase.sed b/lang/cem/cemcom.ansi/tokcase.sed
new file mode 100644
index 000000000..25cd5d9d3
--- /dev/null
+++ b/lang/cem/cemcom.ansi/tokcase.sed
@@ -0,0 +1,3 @@
+/{[A-Z]/!d
+s/.*{\(.*\),.*\(".*"\).*$/	case \1 :\
+	return \2;/
diff --git a/lang/cem/cemcom.ansi/tokcasee.in b/lang/cem/cemcom.ansi/tokcasee.in
new file mode 100644
index 000000000..5df07e7c9
--- /dev/null
+++ b/lang/cem/cemcom.ansi/tokcasee.in
@@ -0,0 +1,16 @@
+	default:
+		if (tok <= 0) return "end of file";
+		if (tok < 040 || tok >= 0177) {
+			return "bad token";
+		}
+		/* fall through */
+	case '\n':
+	case '\f':
+	case '\v':
+	case '\r':
+	case '\t':
+		index = (index+2) & (SIZBUF-1);
+		buf[index] = tok;
+		return &buf[index];
+	}
+}
\ No newline at end of file
diff --git a/lang/cem/cemcom.ansi/tokcaseh.in b/lang/cem/cemcom.ansi/tokcaseh.in
new file mode 100644
index 000000000..63b1932cb
--- /dev/null
+++ b/lang/cem/cemcom.ansi/tokcaseh.in
@@ -0,0 +1,12 @@
+/* Generated by make.tokcase */
+/* $Id$ */
+#include "Lpars.h"
+
+char *symbol2str(int tok)
+{
+#define SIZBUF	8
+	/* allow for a few invocations in f.i. an argument list */
+	static char buf[SIZBUF];
+	static int index;
+
+	switch (tok) {
diff --git a/lang/cem/cemcom.ansi/tokenname.c b/lang/cem/cemcom.ansi/tokenname.c
index 8c52b4dcb..b430abbd8 100644
--- a/lang/cem/cemcom.ansi/tokenname.c
+++ b/lang/cem/cemcom.ansi/tokenname.c
@@ -11,6 +11,7 @@
 #include	"LLlex.h"
 #include	"tokenname.h"
 #include	"Lpars.h"
+#include    "error.h"
 
 /*	To centralize the declaration of %tokens, their presence in this
 	file is taken as their declaration. The Makefile will produce
@@ -132,8 +133,7 @@ struct tokenname tkfunny[] =	{	/* internal keywords */
 };
 #endif	/* ____ */
 
-reserve(resv)
-	register struct tokenname resv[];
+void reserve(register struct tokenname resv[])
 {
 	/*	The names of the tokens described in resv are entered
 		as reserved words.
diff --git a/lang/cem/cemcom.ansi/tokenname.h b/lang/cem/cemcom.ansi/tokenname.h
index fdff2fbc2..f3f5edb2e 100644
--- a/lang/cem/cemcom.ansi/tokenname.h
+++ b/lang/cem/cemcom.ansi/tokenname.h
@@ -4,6 +4,8 @@
  */
 /* $Id$ */
 /* TOKENNAME DEFINITION */
+#ifndef TOKENNAME_H_
+#define TOKENNAME_H_
 
 struct tokenname	{	/*	Used for defining the name of a
 					token as identified by its symbol
@@ -11,3 +13,7 @@ struct tokenname	{	/*	Used for defining the name of a
 	int tn_symbol;
 	char *tn_name;
 };
+
+void reserve(register struct tokenname resv[]);
+
+#endif /* TOKENNAME_H_ */
diff --git a/lang/cem/cemcom.ansi/type.c b/lang/cem/cemcom.ansi/type.c
index 2b477a725..ff3a6eab3 100644
--- a/lang/cem/cemcom.ansi/type.c
+++ b/lang/cem/cemcom.ansi/type.c
@@ -16,68 +16,59 @@
 #include	"sizes.h"
 #include	"align.h"
 #include	"decspecs.h"
+#include    "error.h"
+
 
-extern struct type *function_of(), *array_of();
-#ifndef NOBITFIELD
-extern struct type *field_of();
-#endif /* NOBITFIELD */
 
 /*	To be created dynamically in main() from defaults or from command
-	line parameters.
-*/
-struct type
-	*schar_type, *uchar_type,
-	*short_type, *ushort_type,
-	*word_type, *uword_type,
-	*int_type, *uint_type,
-	*long_type, *ulong_type,
-	*float_type, *double_type, *lngdbl_type,
-	*void_type,
-	*string_type, *funint_type, *error_type;
+ line parameters.
+ */
+struct type *schar_type, *uchar_type, *short_type, *ushort_type, *word_type,
+		*uword_type, *int_type, *uint_type, *long_type, *ulong_type,
+		*float_type, *double_type, *lngdbl_type, *void_type, *string_type,
+		*funint_type, *error_type;
 
-struct type *pa_type;	/* Pointer-Arithmetic type	*/
+struct type *pa_type; /* Pointer-Arithmetic type	*/
 
-struct type *
-create_type(fund)
-	int fund;
+struct type *create_type(int fund)
 {
 	/*	A brand new struct type is created, and its tp_fund set
-		to fund.
-	*/
+	 to fund.
+	 */
 	register struct type *ntp = new_type();
 
 	ntp->tp_fund = fund;
-	ntp->tp_size = (arith)-1;
+	ntp->tp_size = (arith) -1;
 
 	return ntp;
 }
 
-struct type *
-promoted_type(tp)
-struct type *tp;
+struct type *promoted_type(struct type *tp)
 {
-	if (tp->tp_fund == CHAR || tp->tp_fund == SHORT) {
+	if (tp->tp_fund == CHAR || tp->tp_fund == SHORT)
+	{
 		if (tp->tp_unsigned && (int) tp->tp_size == (int) int_size)
 			return uint_type;
-		else return int_type;
-	} else if (tp->tp_fund == FLOAT)
+		else
+			return int_type;
+	}
+	else if (tp->tp_fund == FLOAT)
 		return double_type;
-	else return tp;
+	else
+		return tp;
 }
 
-struct type *
-construct_type(fund, tp, qual, count, pl)
-	register struct type *tp;
-	register struct proto *pl;
-	arith count; /* for fund == ARRAY only */
-	int qual;
+struct type *construct_type(int fund, register struct type *tp, int qual,
+arith count, /* for fund == ARRAY only */
+register struct proto *pl)
 {
 	/*	fund must be a type constructor: FIELD, FUNCTION, POINTER or
-		ARRAY. The pointer to the constructed type is returned.
-	*/
+	 ARRAY. The pointer to the constructed type is returned.
+	 */
 	register struct type *dtp;
 
-	switch (fund)	{
+	switch (fund)
+	{
 #ifndef NOBITFIELD
 	case FIELD:
 		dtp = field_of(tp, qual);
@@ -85,11 +76,13 @@ construct_type(fund, tp, qual, count, pl)
 #endif /* NOBITFIELD */
 
 	case FUNCTION:
-		if (tp->tp_fund == FUNCTION)	{
+		if (tp->tp_fund == FUNCTION)
+		{
 			error("function cannot yield function");
 			return error_type;
 		}
-		if (tp->tp_fund == ARRAY)	{
+		if (tp->tp_fund == ARRAY)
+		{
 			error("function cannot yield array");
 			return error_type;
 		}
@@ -100,7 +93,8 @@ construct_type(fund, tp, qual, count, pl)
 		dtp = pointer_to(tp, qual);
 		break;
 	case ARRAY:
-		if (tp->tp_fund == VOID) {
+		if (tp->tp_fund == VOID)
+		{
 			error("cannot construct array of void");
 			count = (arith) -1;
 		}
@@ -113,14 +107,10 @@ construct_type(fund, tp, qual, count, pl)
 	return dtp;
 }
 
-struct type *
-function_of(tp, pl, qual)
-	register struct type *tp;
-	struct proto *pl;
-	int qual;
+struct type *function_of(register struct type *tp, struct proto *pl, int qual)
 {
 #if 0
-/* See comment below */
+	/* See comment below */
 	register struct type *dtp = tp->tp_function;
 #else
 	register struct type *dtp;
@@ -128,30 +118,31 @@ function_of(tp, pl, qual)
 
 	/* look for a type with the right qualifier */
 #if 0
-/* the code doesn't work in the following case:
-	int func();
-	int func(int a, int b) { return q(a); }
-   because updating the type works inside the data-structures for that type
-   thus, a new type is created for very function. This may change in the
-   future, when declarations with empty parameter lists become obsolete.
-   When it does, change type.str, decspecs.c, and this routine. Search for
-   the function_of pattern to find the places.
-*/
+	/* the code doesn't work in the following case:
+	 int func();
+	 int func(int a, int b) { return q(a); }
+	 because updating the type works inside the data-structures for that type
+	 thus, a new type is created for very function. This may change in the
+	 future, when declarations with empty parameter lists become obsolete.
+	 When it does, change type.str, decspecs.c, and this routine. Search for
+	 the function_of pattern to find the places.
+	 */
 	while (dtp && (dtp->tp_typequal != qual || dtp->tp_proto != pl))
-		dtp = dtp->next;
+	dtp = dtp->next;
 #else
 	dtp = 0;
 #endif
 
-	if (!dtp)	{
+	if (!dtp)
+	{
 		dtp = create_type(FUNCTION);
 		dtp->tp_up = tp;
-		dtp->tp_size = -1;	/* function size is not known */
+		dtp->tp_size = -1; /* function size is not known */
 		dtp->tp_align = pointer_align;
 		dtp->tp_typequal = qual;
 		dtp->tp_proto = pl;
 #if 0
-/* See comment above */
+		/* See comment above */
 		dtp->next = tp->tp_function;
 		tp->tp_function = dtp;
 #endif
@@ -159,10 +150,7 @@ function_of(tp, pl, qual)
 	return dtp;
 }
 
-struct type *
-pointer_to(tp, qual)
-	register struct type *tp;
-	int qual;
+struct type *pointer_to(register struct type *tp, int qual)
 {
 	register struct type *dtp = tp->tp_pointer;
 
@@ -170,7 +158,8 @@ pointer_to(tp, qual)
 	while (dtp && dtp->tp_typequal != qual)
 		dtp = dtp->next;
 
-	if (!dtp)	{
+	if (!dtp)
+	{
 		dtp = create_type(POINTER);
 		dtp->tp_unsigned = 1;
 		dtp->tp_up = tp;
@@ -183,11 +172,7 @@ pointer_to(tp, qual)
 	return dtp;
 }
 
-struct type *
-array_of(tp, count, qual)
-	register struct type *tp;
-	arith count;
-	int qual;
+struct type * array_of(register struct type *tp, arith count, int qual)
 {
 	register struct type *dtp = tp->tp_array;
 
@@ -195,7 +180,8 @@ array_of(tp, count, qual)
 	while (dtp && (dtp->tp_nel != count || dtp->tp_typequal != qual))
 		dtp = dtp->next;
 
-	if (!dtp)	{
+	if (!dtp)
+	{
 		dtp = create_type(ARRAY);
 		dtp->tp_up = tp;
 		dtp->tp_nel = count;
@@ -203,19 +189,18 @@ array_of(tp, count, qual)
 		dtp->tp_typequal = qual;
 		dtp->next = tp->tp_array;
 		tp->tp_array = dtp;
-		if (tp->tp_size >= 0 && count >= 0) {
+		if (tp->tp_size >= 0 && count >= 0)
+		{
 			dtp->tp_size = count * tp->tp_size;
 		}
-		else	dtp->tp_size = -1;
+		else
+			dtp->tp_size = -1;
 	}
 	return dtp;
 }
 
 #ifndef NOBITFIELD
-struct type *
-field_of(tp, qual)
-	register struct type *tp;
-	int qual;
+struct type * field_of(register struct type *tp, int qual)
 {
 	register struct type *dtp = create_type(FIELD);
 
@@ -227,53 +212,47 @@ field_of(tp, qual)
 }
 #endif /* NOBITFIELD */
 
-arith
-size_of_type(tp, nm)
-	struct type *tp;
-	char nm[];
+arith size_of_type(struct type *tp, char nm[])
 {
 	arith sz = tp->tp_size;
 
-	if (sz < 0)	{
+	if (sz < 0)
+	{
 		error("size of %s unknown", nm);
-		sz = (arith)1;
+		sz = (arith) 1;
 	}
 	return sz;
 }
 
-idf2type(idf, tpp)
-	struct idf *idf;
-	struct type **tpp;
+void idf2type(struct idf *idf, struct type **tpp)
 {
 	/*	Decoding  a typedef-ed identifier or basic type: if the
-		size is yet unknown we have to make copy of the type
-		descriptor to prevent garbage at the initialisation of
-		arrays with unknown size.
-	*/
+	 size is yet unknown we have to make copy of the type
+	 descriptor to prevent garbage at the initialisation of
+	 arrays with unknown size.
+	 */
 	register struct type *tp = idf->id_def->df_type;
 
-	if (*tpp) error("multiple types in declaration");
-	if (	tp->tp_size < (arith)0 && tp->tp_fund == ARRAY)	{
+	if (*tpp)
+		error("multiple types in declaration");
+	if (tp->tp_size < (arith) 0 && tp->tp_fund == ARRAY)
+	{
 		*tpp = new_type();
 		**tpp = *tp;
-			/* this is really a structure assignment, AAGH!!! */
+		/* this is really a structure assignment, AAGH!!! */
 	}
-	else	{
+	else
+	{
 		*tpp = tp;
 	}
 }
 
-arith
-align(pos, al)
-	arith pos;
-	int al;
+arith align(arith pos, int al)
 {
 	return ((pos + al - 1) / al) * al;
 }
 
-struct type *
-standard_type(fund, sgn, algn, sz)
-	int algn; arith sz;
+struct type * standard_type(int fund, int sgn, int algn, arith sz)
 {
 	register struct type *tp = create_type(fund);
 
@@ -284,25 +263,29 @@ standard_type(fund, sgn, algn, sz)
 	return tp;
 }
 
-completed(tp)
-	struct type *tp;
+void completed(struct type *tp)
 {
 	register struct type *atp = tp->tp_array;
 	register struct type *etp = tp;
 
-	switch(etp->tp_fund) {
+	switch (etp->tp_fund)
+	{
 	case STRUCT:
 	case UNION:
 	case ENUM:
-		while (etp = etp->next) {
-			if (! etp->tp_sdef) etp->tp_sdef = tp->tp_sdef;
+		while (etp = etp->next)
+		{
+			if (!etp->tp_sdef)
+				etp->tp_sdef = tp->tp_sdef;
 			etp->tp_size = tp->tp_size;
 			etp->tp_align = tp->tp_align;
 		}
 		break;
 	}
-	while (atp) {
-		if (atp->tp_nel >= 0) {
+	while (atp)
+	{
+		if (atp->tp_nel >= 0)
+		{
 			atp->tp_size = atp->tp_nel * tp->tp_size;
 		}
 		atp = atp->next;
diff --git a/lang/cem/cemcom.ansi/type.str b/lang/cem/cemcom.ansi/type.str
index 8796d61a4..b98ffbb6c 100644
--- a/lang/cem/cemcom.ansi/type.str
+++ b/lang/cem/cemcom.ansi/type.str
@@ -4,8 +4,13 @@
  */
 /* $Id$ */
 /* TYPE DESCRIPTOR */
+#ifndef TYPE_H_
+#define TYPE_H_
 
 #include	"parameters.h"
+#include    "arith.h"
+
+
 
 struct type	{
 	struct type *next;	/* used for ARRAY and for qualifiers */
@@ -59,13 +64,6 @@ struct type	{
 #define	TQ_VOLATILE	0x01
 #define	TQ_CONST	0x02
 
-extern struct type
-	*create_type(), *standard_type(), *construct_type(), *pointer_to(),
-	*array_of(), *function_of(), *promoted_type();
-
-#ifndef NOBITFIELD
-extern struct type *field_of();
-#endif /* NOBITFIELD */
 
 extern struct type
 	*schar_type, *uchar_type,
@@ -79,6 +77,24 @@ extern struct type
 
 extern struct type *pa_type;	/* type.c	*/
 
-extern arith size_of_type(), align();
+struct type *create_type(int fund);
+struct type *promoted_type(struct type *tp);
+struct type *construct_type(int fund, register struct type *tp, int qual,
+arith count, /* for fund == ARRAY only */
+   register struct proto *pl);
+struct type *function_of(register struct type *tp, struct proto *pl, int qual);
+struct type *pointer_to(register struct type *tp, int qual);
+struct type * array_of(register struct type *tp, arith count, int qual);
+#ifndef NOBITFIELD
+struct type * field_of(register struct type *tp, int qual);
+#endif /* NOBITFIELD */
+arith size_of_type(struct type *tp, char nm[]);
+void idf2type(struct idf *idf, struct type **tpp);
+arith align(arith pos, int al);
+struct type * standard_type(int fund, int sgn, int algn, arith sz);
+void completed(struct type *tp);
+
 
 /* ALLOCDEF "type" 50 */
+
+#endif
\ No newline at end of file
diff --git a/lang/cem/cemcom.ansi/util.c b/lang/cem/cemcom.ansi/util.c
index 273fa8d78..6d3f084bf 100644
--- a/lang/cem/cemcom.ansi/util.c
+++ b/lang/cem/cemcom.ansi/util.c
@@ -41,16 +41,14 @@ static int	loc_id;
 
 extern char options[];
 
-LocalInit()
+void LocalInit(void)
 {
 #ifdef USE_TMP
 	C_insertpart(loc_id = C_getid());
 #endif /* USE_TMP */
 }
 
-arith
-LocalSpace(sz, al)
-	arith sz;
+arith LocalSpace(arith sz, int al)
 {
 	register struct stack_level *stl = local_level;
 
@@ -61,9 +59,7 @@ LocalSpace(sz, al)
 #define TABSIZ 32
 static struct localvar *regs[TABSIZ];
 
-arith
-NewLocal(sz, al, regtype, sc)
-	arith sz;
+arith NewLocal(arith sz, int al, int regtype, int sc)
 {
 	register struct localvar *tmp = FreeTmps;
 	struct localvar *prev = 0;
@@ -98,8 +94,7 @@ NewLocal(sz, al, regtype, sc)
 	return tmp->t_offset;
 }
 
-FreeLocal(off)
-	arith off;
+void FreeLocal(arith off)
 {
 	int index = (int) (off >> 2) & (TABSIZ - 1);
 	register struct localvar *tmp = regs[index];
@@ -117,7 +112,7 @@ FreeLocal(off)
 	}
 }
 
-LocalFinish()
+void LocalFinish(void)
 {
 	register struct localvar *tmp, *tmp1;
 	register int i;
@@ -163,9 +158,7 @@ LocalFinish()
 #endif
 }
 
-void
-RegisterAccount(offset, size, regtype, sc)
-	arith offset, size;
+void RegisterAccount(arith offset, arith size, int regtype, int sc)
 {
 	register struct localvar *p;
 	int index;
@@ -183,9 +176,7 @@ RegisterAccount(offset, size, regtype, sc)
 	regs[index] = p;
 }
 
-static struct localvar *
-find_reg(off)
-	arith off;
+static struct localvar *find_reg(arith off)
 {
 	register struct localvar *p = regs[(int)(off >> 2) & (TABSIZ - 1)];
 
@@ -193,8 +184,7 @@ find_reg(off)
 	return p;
 }
 
-LoadLocal(off, sz)
-	arith off, sz;
+void LoadLocal(arith off, arith sz)
 {
 	register struct localvar *p = find_reg(off);
 
@@ -213,8 +203,7 @@ LoadLocal(off, sz)
 	}
 }
 
-StoreLocal(off, sz)
-	arith off, sz;
+void StoreLocal(arith off, arith sz)
 {
 	register struct localvar *p = find_reg(off);
 
@@ -234,8 +223,7 @@ StoreLocal(off, sz)
 }
 
 #ifndef	LINT
-AddrLocal(off)
-	arith off;
+void AddrLocal(arith off)
 {
 	register struct localvar *p = find_reg(off);
 
diff --git a/lang/cem/cemcom.ansi/util.str b/lang/cem/cemcom.ansi/util.str
index 886432343..1e3855e3c 100644
--- a/lang/cem/cemcom.ansi/util.str
+++ b/lang/cem/cemcom.ansi/util.str
@@ -1,3 +1,8 @@
+#ifndef UTIL_H_
+#define UTIL_H_
+
+#include "arith.h"
+
 struct localvar {
 	struct localvar	*next;
 	arith		t_offset;	/* offset from LocalBase */
@@ -9,3 +14,18 @@ struct localvar {
 };
 
 /* ALLOCDEF "localvar" 10 */
+
+void LocalInit(void);
+arith LocalSpace(arith sz, int al);
+arith NewLocal(arith sz, int al, int regtype, int sc);
+void FreeLocal(arith off);
+void LocalFinish(void);
+void RegisterAccount(arith offset, arith size, int regtype, int sc);
+void LoadLocal(arith off, arith sz);
+void StoreLocal(arith off, arith sz);
+
+#ifndef	LINT
+void AddrLocal(arith off);
+#endif
+
+#endif
\ No newline at end of file