diff --git a/msvc/c/Makefile b/msvc/c/Makefile
index de3879027..1166dd645 100755
--- a/msvc/c/Makefile
+++ b/msvc/c/Makefile
@@ -67,7 +67,7 @@ HFILES	= ..\ecl\config.h ..\ecl\atomic_ops.h $(HDIR)\ecl.h $(HDIR)\ecl-cmp.h\
 	$(HDIR)\internal.h $(HDIR)\ecl-inl.h $(HDIR)\bytecodes.h \
 	$(HDIR)\impl\math_dispatch.h
 
-OBJS	= main.obj symbol.obj package.obj list.obj\
+OBJS	= main.obj symbol.obj package.obj cons.obj list.obj\
 	apply.obj eval.obj interpreter.obj compiler.obj disassembler.obj \
 	instance.obj gfun.obj reference.obj character.obj\
 	file.obj read.obj print.obj error.obj string.obj cfun.obj\
diff --git a/src/c/Makefile.in b/src/c/Makefile.in
index 4ca20e98d..fb091a1df 100644
--- a/src/c/Makefile.in
+++ b/src/c/Makefile.in
@@ -38,7 +38,7 @@ HFILES	= $(HDIR)/config.h $(HDIR)/ecl.h $(HDIR)/ecl-cmp.h\
 	$(HDIR)/object.h $(HDIR)/cs.h $(HDIR)/stacks.h\
 	$(HDIR)/external.h $(HDIR)/eval.h\
 	$(HDIR)/number.h $(HDIR)/page.h $(HDIR)/unify.h
-OBJS	= main.o symbol.o package.o list.o\
+OBJS	= main.o symbol.o package.o cons.o list.o\
 	apply.o eval.o interpreter.o compiler.o disassembler.o \
 	instance.o gfun.o reference.o character.o\
 	file.o read.o print.o error.o string.o cfun.o\
diff --git a/src/c/cons.d b/src/c/cons.d
new file mode 100644
index 000000000..f693d89ea
--- /dev/null
+++ b/src/c/cons.d
@@ -0,0 +1,965 @@
+/* -*- mode: c; c-basic-offset: 8 -*- */
+/*
+    cons.d -- list manipulation macros & functions
+*/
+/*
+    Copyright (c) 2011, Juan Jose Garcia-Ripoll
+
+    ECL is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    See file '../Copyright' for full details.
+*/
+
+#include <ecl/ecl.h>
+#include <ecl/cons.h>
+
+/* BEGIN-GENERATED (gen-cons-d) */
+
+#if !ECL_CAN_INLINE
+cl_object _ecl_car(cl_object x)
+{
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  return x;
+}
+
+cl_object _ecl_cdr(cl_object x)
+{
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  return x;
+}
+
+cl_object _ecl_caar(cl_object x)
+{
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  return x;
+}
+
+cl_object _ecl_cdar(cl_object x)
+{
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  return x;
+}
+
+cl_object _ecl_cadr(cl_object x)
+{
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  return x;
+}
+
+cl_object _ecl_cddr(cl_object x)
+{
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  return x;
+}
+
+cl_object _ecl_caaar(cl_object x)
+{
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  return x;
+}
+
+cl_object _ecl_cdaar(cl_object x)
+{
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  return x;
+}
+
+cl_object _ecl_cadar(cl_object x)
+{
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  return x;
+}
+
+cl_object _ecl_cddar(cl_object x)
+{
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  return x;
+}
+
+cl_object _ecl_caadr(cl_object x)
+{
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  return x;
+}
+
+cl_object _ecl_cdadr(cl_object x)
+{
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  return x;
+}
+
+cl_object _ecl_caddr(cl_object x)
+{
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  return x;
+}
+
+cl_object _ecl_cdddr(cl_object x)
+{
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  return x;
+}
+
+cl_object _ecl_caaaar(cl_object x)
+{
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  return x;
+}
+
+cl_object _ecl_cdaaar(cl_object x)
+{
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  return x;
+}
+
+cl_object _ecl_cadaar(cl_object x)
+{
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  return x;
+}
+
+cl_object _ecl_cddaar(cl_object x)
+{
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  return x;
+}
+
+cl_object _ecl_caadar(cl_object x)
+{
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  return x;
+}
+
+cl_object _ecl_cdadar(cl_object x)
+{
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  return x;
+}
+
+cl_object _ecl_caddar(cl_object x)
+{
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  return x;
+}
+
+cl_object _ecl_cdddar(cl_object x)
+{
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  return x;
+}
+
+cl_object _ecl_caaadr(cl_object x)
+{
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  return x;
+}
+
+cl_object _ecl_cdaadr(cl_object x)
+{
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  return x;
+}
+
+cl_object _ecl_cadadr(cl_object x)
+{
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  return x;
+}
+
+cl_object _ecl_cddadr(cl_object x)
+{
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  return x;
+}
+
+cl_object _ecl_caaddr(cl_object x)
+{
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  return x;
+}
+
+cl_object _ecl_cdaddr(cl_object x)
+{
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  return x;
+}
+
+cl_object _ecl_cadddr(cl_object x)
+{
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  return x;
+}
+
+cl_object _ecl_cddddr(cl_object x)
+{
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  return x;
+}
+
+#endif /* !ECL_CAN_INLINE */
+
+cl_object ecl_car(cl_object x)
+{
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  return x;
+}
+
+cl_object ecl_cdr(cl_object x)
+{
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  return x;
+}
+
+cl_object ecl_caar(cl_object x)
+{
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  return x;
+}
+
+cl_object ecl_cdar(cl_object x)
+{
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  return x;
+}
+
+cl_object ecl_cadr(cl_object x)
+{
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  return x;
+}
+
+cl_object ecl_cddr(cl_object x)
+{
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  return x;
+}
+
+cl_object ecl_caaar(cl_object x)
+{
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  return x;
+}
+
+cl_object ecl_cdaar(cl_object x)
+{
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  return x;
+}
+
+cl_object ecl_cadar(cl_object x)
+{
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  return x;
+}
+
+cl_object ecl_cddar(cl_object x)
+{
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  return x;
+}
+
+cl_object ecl_caadr(cl_object x)
+{
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  return x;
+}
+
+cl_object ecl_cdadr(cl_object x)
+{
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  return x;
+}
+
+cl_object ecl_caddr(cl_object x)
+{
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  return x;
+}
+
+cl_object ecl_cdddr(cl_object x)
+{
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  return x;
+}
+
+cl_object ecl_caaaar(cl_object x)
+{
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  return x;
+}
+
+cl_object ecl_cdaaar(cl_object x)
+{
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  return x;
+}
+
+cl_object ecl_cadaar(cl_object x)
+{
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  return x;
+}
+
+cl_object ecl_cddaar(cl_object x)
+{
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  return x;
+}
+
+cl_object ecl_caadar(cl_object x)
+{
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  return x;
+}
+
+cl_object ecl_cdadar(cl_object x)
+{
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  return x;
+}
+
+cl_object ecl_caddar(cl_object x)
+{
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  return x;
+}
+
+cl_object ecl_cdddar(cl_object x)
+{
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  return x;
+}
+
+cl_object ecl_caaadr(cl_object x)
+{
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  return x;
+}
+
+cl_object ecl_cdaadr(cl_object x)
+{
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  return x;
+}
+
+cl_object ecl_cadadr(cl_object x)
+{
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  return x;
+}
+
+cl_object ecl_cddadr(cl_object x)
+{
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  return x;
+}
+
+cl_object ecl_caaddr(cl_object x)
+{
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  return x;
+}
+
+cl_object ecl_cdaddr(cl_object x)
+{
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  return x;
+}
+
+cl_object ecl_cadddr(cl_object x)
+{
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  return x;
+}
+
+cl_object ecl_cddddr(cl_object x)
+{
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  return x;
+}
+
+
+cl_object cl_car(cl_object x)
+{
+  return1(ecl_car(x));
+}
+
+cl_object cl_cdr(cl_object x)
+{
+  return1(ecl_cdr(x));
+}
+
+cl_object cl_caar(cl_object x)
+{
+  return1(ecl_caar(x));
+}
+
+cl_object cl_cdar(cl_object x)
+{
+  return1(ecl_cdar(x));
+}
+
+cl_object cl_cadr(cl_object x)
+{
+  return1(ecl_cadr(x));
+}
+
+cl_object cl_cddr(cl_object x)
+{
+  return1(ecl_cddr(x));
+}
+
+cl_object cl_caaar(cl_object x)
+{
+  return1(ecl_caaar(x));
+}
+
+cl_object cl_cdaar(cl_object x)
+{
+  return1(ecl_cdaar(x));
+}
+
+cl_object cl_cadar(cl_object x)
+{
+  return1(ecl_cadar(x));
+}
+
+cl_object cl_cddar(cl_object x)
+{
+  return1(ecl_cddar(x));
+}
+
+cl_object cl_caadr(cl_object x)
+{
+  return1(ecl_caadr(x));
+}
+
+cl_object cl_cdadr(cl_object x)
+{
+  return1(ecl_cdadr(x));
+}
+
+cl_object cl_caddr(cl_object x)
+{
+  return1(ecl_caddr(x));
+}
+
+cl_object cl_cdddr(cl_object x)
+{
+  return1(ecl_cdddr(x));
+}
+
+cl_object cl_caaaar(cl_object x)
+{
+  return1(ecl_caaaar(x));
+}
+
+cl_object cl_cdaaar(cl_object x)
+{
+  return1(ecl_cdaaar(x));
+}
+
+cl_object cl_cadaar(cl_object x)
+{
+  return1(ecl_cadaar(x));
+}
+
+cl_object cl_cddaar(cl_object x)
+{
+  return1(ecl_cddaar(x));
+}
+
+cl_object cl_caadar(cl_object x)
+{
+  return1(ecl_caadar(x));
+}
+
+cl_object cl_cdadar(cl_object x)
+{
+  return1(ecl_cdadar(x));
+}
+
+cl_object cl_caddar(cl_object x)
+{
+  return1(ecl_caddar(x));
+}
+
+cl_object cl_cdddar(cl_object x)
+{
+  return1(ecl_cdddar(x));
+}
+
+cl_object cl_caaadr(cl_object x)
+{
+  return1(ecl_caaadr(x));
+}
+
+cl_object cl_cdaadr(cl_object x)
+{
+  return1(ecl_cdaadr(x));
+}
+
+cl_object cl_cadadr(cl_object x)
+{
+  return1(ecl_cadadr(x));
+}
+
+cl_object cl_cddadr(cl_object x)
+{
+  return1(ecl_cddadr(x));
+}
+
+cl_object cl_caaddr(cl_object x)
+{
+  return1(ecl_caaddr(x));
+}
+
+cl_object cl_cdaddr(cl_object x)
+{
+  return1(ecl_cdaddr(x));
+}
+
+cl_object cl_cadddr(cl_object x)
+{
+  return1(ecl_cadddr(x));
+}
+
+cl_object cl_cddddr(cl_object x)
+{
+  return1(ecl_cddddr(x));
+}
+
+/* END-GENERATED */
diff --git a/src/c/list.d b/src/c/list.d
index 2c20fd3c3..efb006434 100644
--- a/src/c/list.d
+++ b/src/c/list.d
@@ -133,22 +133,6 @@ setup_test(struct cl_test *t, cl_object item, cl_object test,
 	}
 }
 
-cl_object
-cl_car(cl_object x)
-{
-	if (ecl_unlikely(!LISTP(x)))
-                FEwrong_type_only_arg(@[car], x, @[list]);
-	return1(Null(x)? x : ECL_CONS_CAR(x));
-}
-
-cl_object
-cl_cdr(cl_object x)
-{
-	if (ecl_unlikely(!LISTP(x)))
-                FEwrong_type_only_arg(@[car], x, @[list]);
-	return1(Null(x)? x : ECL_CONS_CDR(x));
-}
-
 @(defun list (&rest args)
 	cl_object head = Cnil;
 @
@@ -231,52 +215,6 @@ ecl_append(cl_object x, cl_object y)
 	return head;
 }
 
-/* Open coded CARs and CDRs */
-#define car(foo)                                \
-	foo;                                    \
-	if (ecl_unlikely(!LISTP(x))) goto E;    \
-	if (!Null(x)) x = ECL_CONS_CAR(x);
-#define cdr(foo)                                \
-	foo;                                    \
-	if (ecl_unlikely(!LISTP(x))) goto E;    \
-	if (!Null(x)) x = ECL_CONS_CDR(x);
-#define defcxr(name, arg, code)                                 \
-        cl_object cl_##name(cl_object foo) {                    \
-                register cl_object arg = foo;                   \
-                code; return1(arg);                             \
-        E:	FEwrong_type_only_arg(@[car],arg,@[list]);}
-
-defcxr(caar, x, car(car(x)))
-defcxr(cadr, x, car(cdr(x)))
-defcxr(cdar, x, cdr(car(x)))
-defcxr(cddr, x, cdr(cdr(x)))
-defcxr(caaar, x, car(car(car(x))))
-defcxr(caadr, x, car(car(cdr(x))))
-defcxr(cadar, x, car(cdr(car(x))))
-defcxr(caddr, x, car(cdr(cdr(x))))
-defcxr(cdaar, x, cdr(car(car(x))))
-defcxr(cdadr, x, cdr(car(cdr(x))))
-defcxr(cddar, x, cdr(cdr(car(x))))
-defcxr(cdddr, x, cdr(cdr(cdr(x))))
-defcxr(caaaar, x, car(car(car(car(x)))))
-defcxr(caaadr, x, car(car(car(cdr(x)))))
-defcxr(caadar, x, car(car(cdr(car(x)))))
-defcxr(caaddr, x, car(car(cdr(cdr(x)))))
-defcxr(cadaar, x, car(cdr(car(car(x)))))
-defcxr(cadadr, x, car(cdr(car(cdr(x)))))
-defcxr(caddar, x, car(cdr(cdr(car(x)))))
-defcxr(cadddr, x, car(cdr(cdr(cdr(x)))))
-defcxr(cdaaar, x, cdr(car(car(car(x)))))
-defcxr(cdaadr, x, cdr(car(car(cdr(x)))))
-defcxr(cdadar, x, cdr(car(cdr(car(x)))))
-defcxr(cdaddr, x, cdr(car(cdr(cdr(x)))))
-defcxr(cddaar, x, cdr(cdr(car(car(x)))))
-defcxr(cddadr, x, cdr(cdr(car(cdr(x)))))
-defcxr(cdddar, x, cdr(cdr(cdr(car(x)))))
-defcxr(cddddr, x, cdr(cdr(cdr(cdr(x)))))
-#undef car
-#undef cdr
-
 #define LENTH(n) (cl_object x) {\
 	return1(ecl_nth(n, x));\
 }
diff --git a/src/h/config.h.in b/src/h/config.h.in
index ee562dfd0..93b9a8248 100644
--- a/src/h/config.h.in
+++ b/src/h/config.h.in
@@ -226,8 +226,10 @@ typedef unsigned char ecl_base_char;
  */
 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
 #define ECL_INLINE inline
+#define ECL_CAN_INLINE 1
 #else
 #define ECL_INLINE
+#define ECL_CAN_INLINE 0
 #endif
 
 #if !defined(__GNUC__)
diff --git a/src/h/cons.h b/src/h/cons.h
new file mode 100644
index 000000000..d63128410
--- /dev/null
+++ b/src/h/cons.h
@@ -0,0 +1,474 @@
+/* -*- mode: c; c-basic-offset: 8 -*- */
+/*
+    cons.h -- list manipulation macros & functions
+*/
+/*
+    Copyright (c) 2011, Juan Jose Garcia-Ripoll
+
+    ECL is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    See file '../Copyright' for full details.
+*/
+
+#ifndef ECL_CONS_H
+#define ECL_CONS_H
+
+#include <ecl/ecl.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* BEGIN-GENERATED (gen-cons-h) */
+
+#if ECL_CAN_INLINE
+static ECL_INLINE cl_object _ecl_car(cl_object x)
+{
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  return x;
+}
+
+static ECL_INLINE cl_object _ecl_cdr(cl_object x)
+{
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  return x;
+}
+
+static ECL_INLINE cl_object _ecl_caar(cl_object x)
+{
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  return x;
+}
+
+static ECL_INLINE cl_object _ecl_cdar(cl_object x)
+{
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  return x;
+}
+
+static ECL_INLINE cl_object _ecl_cadr(cl_object x)
+{
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  return x;
+}
+
+static ECL_INLINE cl_object _ecl_cddr(cl_object x)
+{
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  return x;
+}
+
+static ECL_INLINE cl_object _ecl_caaar(cl_object x)
+{
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  return x;
+}
+
+static ECL_INLINE cl_object _ecl_cdaar(cl_object x)
+{
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  return x;
+}
+
+static ECL_INLINE cl_object _ecl_cadar(cl_object x)
+{
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  return x;
+}
+
+static ECL_INLINE cl_object _ecl_cddar(cl_object x)
+{
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  return x;
+}
+
+static ECL_INLINE cl_object _ecl_caadr(cl_object x)
+{
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  return x;
+}
+
+static ECL_INLINE cl_object _ecl_cdadr(cl_object x)
+{
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  return x;
+}
+
+static ECL_INLINE cl_object _ecl_caddr(cl_object x)
+{
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  return x;
+}
+
+static ECL_INLINE cl_object _ecl_cdddr(cl_object x)
+{
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  return x;
+}
+
+static ECL_INLINE cl_object _ecl_caaaar(cl_object x)
+{
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  return x;
+}
+
+static ECL_INLINE cl_object _ecl_cdaaar(cl_object x)
+{
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  return x;
+}
+
+static ECL_INLINE cl_object _ecl_cadaar(cl_object x)
+{
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  return x;
+}
+
+static ECL_INLINE cl_object _ecl_cddaar(cl_object x)
+{
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  return x;
+}
+
+static ECL_INLINE cl_object _ecl_caadar(cl_object x)
+{
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  return x;
+}
+
+static ECL_INLINE cl_object _ecl_cdadar(cl_object x)
+{
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  return x;
+}
+
+static ECL_INLINE cl_object _ecl_caddar(cl_object x)
+{
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  return x;
+}
+
+static ECL_INLINE cl_object _ecl_cdddar(cl_object x)
+{
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  return x;
+}
+
+static ECL_INLINE cl_object _ecl_caaadr(cl_object x)
+{
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  return x;
+}
+
+static ECL_INLINE cl_object _ecl_cdaadr(cl_object x)
+{
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  return x;
+}
+
+static ECL_INLINE cl_object _ecl_cadadr(cl_object x)
+{
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  return x;
+}
+
+static ECL_INLINE cl_object _ecl_cddadr(cl_object x)
+{
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  return x;
+}
+
+static ECL_INLINE cl_object _ecl_caaddr(cl_object x)
+{
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  return x;
+}
+
+static ECL_INLINE cl_object _ecl_cdaddr(cl_object x)
+{
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  return x;
+}
+
+static ECL_INLINE cl_object _ecl_cadddr(cl_object x)
+{
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CAR(x);
+  return x;
+}
+
+static ECL_INLINE cl_object _ecl_cddddr(cl_object x)
+{
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  if (Null(x)) return x;
+  x = ECL_CONS_CDR(x);
+  return x;
+}
+
+#else
+extern ECL_API cl_object _ecl_car(cl_object);
+extern ECL_API cl_object _ecl_cdr(cl_object);
+extern ECL_API cl_object _ecl_caar(cl_object);
+extern ECL_API cl_object _ecl_cdar(cl_object);
+extern ECL_API cl_object _ecl_cadr(cl_object);
+extern ECL_API cl_object _ecl_cddr(cl_object);
+extern ECL_API cl_object _ecl_caaar(cl_object);
+extern ECL_API cl_object _ecl_cdaar(cl_object);
+extern ECL_API cl_object _ecl_cadar(cl_object);
+extern ECL_API cl_object _ecl_cddar(cl_object);
+extern ECL_API cl_object _ecl_caadr(cl_object);
+extern ECL_API cl_object _ecl_cdadr(cl_object);
+extern ECL_API cl_object _ecl_caddr(cl_object);
+extern ECL_API cl_object _ecl_cdddr(cl_object);
+extern ECL_API cl_object _ecl_caaaar(cl_object);
+extern ECL_API cl_object _ecl_cdaaar(cl_object);
+extern ECL_API cl_object _ecl_cadaar(cl_object);
+extern ECL_API cl_object _ecl_cddaar(cl_object);
+extern ECL_API cl_object _ecl_caadar(cl_object);
+extern ECL_API cl_object _ecl_cdadar(cl_object);
+extern ECL_API cl_object _ecl_caddar(cl_object);
+extern ECL_API cl_object _ecl_cdddar(cl_object);
+extern ECL_API cl_object _ecl_caaadr(cl_object);
+extern ECL_API cl_object _ecl_cdaadr(cl_object);
+extern ECL_API cl_object _ecl_cadadr(cl_object);
+extern ECL_API cl_object _ecl_cddadr(cl_object);
+extern ECL_API cl_object _ecl_caaddr(cl_object);
+extern ECL_API cl_object _ecl_cdaddr(cl_object);
+extern ECL_API cl_object _ecl_cadddr(cl_object);
+extern ECL_API cl_object _ecl_cddddr(cl_object);
+#endif /* !ECL_CAN_INLINE */
+
+extern ECL_API cl_object ecl_car(cl_object);
+extern ECL_API cl_object ecl_cdr(cl_object);
+extern ECL_API cl_object ecl_caar(cl_object);
+extern ECL_API cl_object ecl_cdar(cl_object);
+extern ECL_API cl_object ecl_cadr(cl_object);
+extern ECL_API cl_object ecl_cddr(cl_object);
+extern ECL_API cl_object ecl_caaar(cl_object);
+extern ECL_API cl_object ecl_cdaar(cl_object);
+extern ECL_API cl_object ecl_cadar(cl_object);
+extern ECL_API cl_object ecl_cddar(cl_object);
+extern ECL_API cl_object ecl_caadr(cl_object);
+extern ECL_API cl_object ecl_cdadr(cl_object);
+extern ECL_API cl_object ecl_caddr(cl_object);
+extern ECL_API cl_object ecl_cdddr(cl_object);
+extern ECL_API cl_object ecl_caaaar(cl_object);
+extern ECL_API cl_object ecl_cdaaar(cl_object);
+extern ECL_API cl_object ecl_cadaar(cl_object);
+extern ECL_API cl_object ecl_cddaar(cl_object);
+extern ECL_API cl_object ecl_caadar(cl_object);
+extern ECL_API cl_object ecl_cdadar(cl_object);
+extern ECL_API cl_object ecl_caddar(cl_object);
+extern ECL_API cl_object ecl_cdddar(cl_object);
+extern ECL_API cl_object ecl_caaadr(cl_object);
+extern ECL_API cl_object ecl_cdaadr(cl_object);
+extern ECL_API cl_object ecl_cadadr(cl_object);
+extern ECL_API cl_object ecl_cddadr(cl_object);
+extern ECL_API cl_object ecl_caaddr(cl_object);
+extern ECL_API cl_object ecl_cdaddr(cl_object);
+extern ECL_API cl_object ecl_cadddr(cl_object);
+extern ECL_API cl_object ecl_cddddr(cl_object);
+
+extern ECL_API cl_object cl_car(cl_object);
+extern ECL_API cl_object cl_cdr(cl_object);
+extern ECL_API cl_object cl_caar(cl_object);
+extern ECL_API cl_object cl_cdar(cl_object);
+extern ECL_API cl_object cl_cadr(cl_object);
+extern ECL_API cl_object cl_cddr(cl_object);
+extern ECL_API cl_object cl_caaar(cl_object);
+extern ECL_API cl_object cl_cdaar(cl_object);
+extern ECL_API cl_object cl_cadar(cl_object);
+extern ECL_API cl_object cl_cddar(cl_object);
+extern ECL_API cl_object cl_caadr(cl_object);
+extern ECL_API cl_object cl_cdadr(cl_object);
+extern ECL_API cl_object cl_caddr(cl_object);
+extern ECL_API cl_object cl_cdddr(cl_object);
+extern ECL_API cl_object cl_caaaar(cl_object);
+extern ECL_API cl_object cl_cdaaar(cl_object);
+extern ECL_API cl_object cl_cadaar(cl_object);
+extern ECL_API cl_object cl_cddaar(cl_object);
+extern ECL_API cl_object cl_caadar(cl_object);
+extern ECL_API cl_object cl_cdadar(cl_object);
+extern ECL_API cl_object cl_caddar(cl_object);
+extern ECL_API cl_object cl_cdddar(cl_object);
+extern ECL_API cl_object cl_caaadr(cl_object);
+extern ECL_API cl_object cl_cdaadr(cl_object);
+extern ECL_API cl_object cl_cadadr(cl_object);
+extern ECL_API cl_object cl_cddadr(cl_object);
+extern ECL_API cl_object cl_caaddr(cl_object);
+extern ECL_API cl_object cl_cdaddr(cl_object);
+extern ECL_API cl_object cl_cadddr(cl_object);
+extern ECL_API cl_object cl_cddddr(cl_object);
+/* END-GENERATED */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* !ECL_CONS_H */
diff --git a/src/h/ecl-inl.h b/src/h/ecl-inl.h
index 2d079f355..aa37e79e6 100644
--- a/src/h/ecl-inl.h
+++ b/src/h/ecl-inl.h
@@ -1,4 +1,8 @@
 /* -*- mode: c; c-basic-offset: 8 -*- */
+
+#ifndef ECL_ECL_INL_H
+#define ECL_ECL_INL_H
+
 /*
  * Loops over a proper list. Complains on circularity
  */
@@ -170,3 +174,4 @@ _mm_castsi128_pd(__m128i __A) { return (__m128d) __A; }
 
 #endif /* ECL_SSE2 */
 
+#endif /* !ECL_ECL_INL_H */
diff --git a/src/h/ecl.h b/src/h/ecl.h
index 8ef745819..1055977f4 100644
--- a/src/h/ecl.h
+++ b/src/h/ecl.h
@@ -14,8 +14,8 @@
     See file '../Copyright' for full details.
 */
 
-#ifndef ECL_H
-#define ECL_H
+#ifndef ECL_ECL_H
+#define ECL_ECL_H
 
 #include <sys/types.h>		/* size_t, pthread_t, pthread_mutex_t */
 #ifdef __OpenBSD__		/* same, but for OpenBSD (bug in OpenBSD!) */
@@ -79,6 +79,7 @@
 
 #include <ecl/object.h>
 #include <ecl/external.h>
+#include <ecl/cons.h>
 #include <ecl/stacks.h>
 #include <ecl/eval.h>
 #include <ecl/number.h>
diff --git a/src/h/external.h b/src/h/external.h
index 1a04e5de3..443d021bb 100755
--- a/src/h/external.h
+++ b/src/h/external.h
@@ -1,4 +1,7 @@
 /* -*- mode: c; c-basic-offset: 8 -*- */
+#ifndef ECL_EXTERNAL_H
+#define ECL_EXTERNAL_H
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -836,36 +839,6 @@ extern ECL_API cl_object ecl_slot_value_set(cl_object x, const char *slot, cl_ob
 
 /* list.c */
 
-extern ECL_API cl_object cl_car(cl_object x);
-extern ECL_API cl_object cl_cdr(cl_object x);
-extern ECL_API cl_object cl_caar(cl_object x);
-extern ECL_API cl_object cl_cadr(cl_object x);
-extern ECL_API cl_object cl_cdar(cl_object x);
-extern ECL_API cl_object cl_cddr(cl_object x);
-extern ECL_API cl_object cl_caaar(cl_object x);
-extern ECL_API cl_object cl_caadr(cl_object x);
-extern ECL_API cl_object cl_cadar(cl_object x);
-extern ECL_API cl_object cl_caddr(cl_object x);
-extern ECL_API cl_object cl_cdaar(cl_object x);
-extern ECL_API cl_object cl_cdadr(cl_object x);
-extern ECL_API cl_object cl_cddar(cl_object x);
-extern ECL_API cl_object cl_cdddr(cl_object x);
-extern ECL_API cl_object cl_caaaar(cl_object x);
-extern ECL_API cl_object cl_caaadr(cl_object x);
-extern ECL_API cl_object cl_caadar(cl_object x);
-extern ECL_API cl_object cl_caaddr(cl_object x);
-extern ECL_API cl_object cl_cadaar(cl_object x);
-extern ECL_API cl_object cl_cadadr(cl_object x);
-extern ECL_API cl_object cl_caddar(cl_object x);
-extern ECL_API cl_object cl_cadddr(cl_object x);
-extern ECL_API cl_object cl_cdaaar(cl_object x);
-extern ECL_API cl_object cl_cdaadr(cl_object x);
-extern ECL_API cl_object cl_cdadar(cl_object x);
-extern ECL_API cl_object cl_cdaddr(cl_object x);
-extern ECL_API cl_object cl_cddaar(cl_object x);
-extern ECL_API cl_object cl_cddadr(cl_object x);
-extern ECL_API cl_object cl_cdddar(cl_object x);
-extern ECL_API cl_object cl_cddddr(cl_object x);
 #define cl_rest cl_cdr
 #define cl_first cl_car
 #define cl_second cl_cadr
@@ -2227,3 +2200,5 @@ extern ECL_API cl_object si_positive_long_float_p(cl_object);
 #ifdef __cplusplus
 }
 #endif
+
+#endif /* !ECL_EXTERNAL_H */
diff --git a/src/util/gen-code.lisp b/src/util/gen-code.lisp
new file mode 100644
index 000000000..903e6a31e
--- /dev/null
+++ b/src/util/gen-code.lisp
@@ -0,0 +1,106 @@
+;;;
+;;; Writing src/h/cons.h and src/c/cons.d
+;;;
+
+(defun process-file (filename)
+  (let* ((filename (merge-pathnames filename))
+	 (name (pathname-name filename))
+	 (input (make-pathname :name (concatenate 'string "bak-" name)
+			       :type (pathname-type filename)
+			       :directory (pathname-directory filename)))
+	 (output filename))
+    (cond ((not (probe-file filename))
+	   (error "Unable to find ~a" filename))
+	  ((probe-file input)
+	   (error "Backup already exists" input))
+	  (t
+	   (format t "~%;;; Renaming ~a -> ~a" filename input)
+	   (rename-file filename input)))
+    (with-open-file (in input :direction :input)
+      (with-open-file (out output :direction :output :if-exists :supersede)
+	(format t "~%;;; Transforming ~a -> ~a" input output)
+	(loop with skip = nil
+	      for l = (read-line in nil nil nil)
+	      while l
+	      do (cond (skip
+			(when (search "END-GENERATED" l)
+			  (write-line l out)
+			  (setf skip nil)))
+		       (t
+			(write-line l out)
+			(let ((ndx (search "BEGIN-GENERATED" l)))
+			  (when ndx
+			    (let* ((*standard-output* out)
+				   (form-text (subseq l (+ ndx 15)
+						      (- (length l) 2)))
+				   (form (read-from-string form-text)))
+			      (eval form)
+			      (setf skip t)))))))))
+    (format t "~%;;; Deleting the file ~a" input)
+    (delete-file input)))
+
+(defun write-rec (depth list flag &optional (prefix ""))
+  (when (plusp depth)
+    (write-rec (1- depth) (cons 'a list) flag)
+    (write-rec (1- depth) (cons 'd list) flag)
+    (return-from write-rec))
+  (let* ((string (apply #'concatenate 'string (mapcar #'string-downcase list))))
+    (case flag
+      (:inline
+       (write-rec depth list :unsafe "static ECL_INLINE "))
+      (:unsafe
+       (format t "~%~acl_object _ecl_c~ar(cl_object x)~%{" prefix string)
+       (loop for what in (reverse list)
+	     for op = (if (eq what 'a) "ECL_CONS_CAR" "ECL_CONS_CDR")
+	     do (format t "~%  if (Null(x)) return x;~%  x = ~A(x);" op))
+       (format t "~%  return x;~%}~%"))
+      (:safe
+       (format t "~%cl_object ecl_c~ar(cl_object x)~%{" string)
+       (loop for what in (reverse list)
+	     for op = (if (eq what 'a) "ECL_CONS_CAR" "ECL_CONS_CDR")
+	     do (format t "~%  if (ecl_unlikely(!ECL_LISTP(x))) FEwrong_type_nth_arg(@[car], 1, x, @[list]);")
+	     do (format t "~%  if (Null(x)) return x;~%  x = ~A(x);" op))
+       (format t "~%  return x;~%}~%"))
+      (:common-lisp
+       (format t "~%cl_object cl_c~ar(cl_object x)~%{~%  return1(ecl_c~ar(x));~%}~%"
+	       string string))
+      (:declare-unsafe
+       (format t "~%extern ECL_API cl_object _ecl_c~ar(cl_object);" string))
+      (:declare-safe
+       (format t "~%extern ECL_API cl_object ecl_c~ar(cl_object);" string))
+      (:declare-common-lisp
+       (format t "~%extern ECL_API cl_object cl_c~ar(cl_object);" string))
+      )))
+
+(defun gen-cons-h ()
+  (format t "~%#if ECL_CAN_INLINE")
+  (loop for depth from 1 below 5
+	do (write-rec depth nil :inline))
+  (format t "~%#else")
+  (loop for depth from 1 below 5
+	do (write-rec depth nil :declare-unsafe))
+  (format t "~%#endif /* !ECL_CAN_INLINE */~%")
+  (loop for depth from 1 below 5
+	do (write-rec depth nil :declare-safe))
+  (terpri)
+  (loop for depth from 1 below 5
+	do (write-rec depth nil :declare-common-lisp))
+  (terpri))
+
+(defun gen-cons-d ()
+  (format t "~%#if !ECL_CAN_INLINE")
+  (loop for depth from 1 below 5
+	do (write-rec depth nil :unsafe))
+  (format t "~%#endif /* !ECL_CAN_INLINE */~%")
+  (loop for depth from 1 below 5
+	do (write-rec depth nil :safe))
+  (terpri)
+  (loop for depth from 1 below 5
+	do (write-rec depth nil :common-lisp))
+  (terpri))
+
+
+(process-file "src/c/cons.d")
+(process-file "src/h/cons.h")
+(terpri)
+(ext:quit)