Disable Chicken target language

Clean up to disable target languages that have been neglected/not functional.
Target language be fully deleted in SWIG 4.1 unless a new maintainer brings
it up to an acceptable status (experimental or supported).

Issue #1447

ANNOUNCE

@@ -10,7 +10,7 @@ What is SWIG?
 SWIG is a software development tool that reads C/C++ header files and
 generates the wrapper code needed to make C and C++ code accessible
 from other programming languages including Perl, Python, Tcl, Ruby,
-PHP, C#, Go, Java, Javascript, Lua, Scheme (Guile, MzScheme, CHICKEN),
+PHP, C#, Go, Java, Javascript, Lua, Scheme (Guile, MzScheme),
 D, Ocaml, Octave, R, Scilab, Common Lisp (Allegro CL, CFFI).
 SWIG can also export its parse tree in
 the form of XML.  Major applications of SWIG

CHANGES.current

@@ -7,6 +7,10 @@ the issue number to the end of the URL: https://github.com/swig/swig/issues/
 Version 4.0.0 (in progress)
 ===========================
 
+2019-02-04: wsfulton
+	    [Chicken] #1447 CHICKEN has been disabled as a target language in SWIG as part of a
+            clean up to remove target languages that have been neglected/not functional.
+
 2019-02-04: wsfulton
 	    [CLISP] #1447 GNU Common Lisp has been disabled as a target language in SWIG as part of a
             clean up to remove target languages that have been neglected/not functional.

Doc/Devel/runtime.txt

@@ -57,7 +57,7 @@ Alternatively, if the language supports modules, a module named
 named "type_table" SWIG_TYPE_TABLE_NAME can be created inside it.  The most
 common approach is to store the mod pointer in some global variable in the
 target language, but if the language provides an alternative place to store data
-(like the chicken module), then that is good too.
+then that is good too.
 
 The way the code is set up, SetModule should only be called when GetModule
 returns NULL, and if SetModule is called a second time, the behavior is
@@ -105,7 +105,7 @@ Standard Functions
 These functions are not required and their API is not formalized, but almost all
 language modules implement them for consistency across languages.  Throughout
 this discussion, I will use LangType to represent the underlying language type
-(C_word in chicken, Scheme_Object * in mzscheme, PyObject * in python, etc)
+(Scheme_Object * in mzscheme, PyObject * in python, etc)
 
 
 

Doc/Manual/Preprocessor.html

@@ -111,7 +111,6 @@ SWIG_VERSION                    Hexadecimal (binary-coded decimal) number contai
 
 SWIGALLEGROCL                   Defined when using Allegro CL
 SWIGCFFI                        Defined when using CFFI
-SWIGCHICKEN                     Defined when using CHICKEN
 SWIGCSHARP                      Defined when using C#
 SWIGGUILE                       Defined when using Guile
 SWIGJAVA                        Defined when using Java

Doc/Manual/SWIG.html

@@ -119,7 +119,6 @@ for example, <tt>swig -ruby -help</tt> for Ruby.
 <div class="shell"><pre>
 Supported Target Language Options
      -allegrocl      - Generate ALLEGROCL wrappers
-     -chicken        - Generate CHICKEN wrappers
      -cffi           - Generate CFFI wrappers
      -csharp         - Generate C# wrappers
      -d              - Generate D wrappers

Doc/Manual/Sections.html

@@ -42,7 +42,6 @@ Last update : SWIG-4.0.0 (in progress)
 <li><a href="Allegrocl.html#Allegrocl">Allegro Common Lisp support</a></li>
 <li><a href="Android.html#Android">Android support</a></li>
 <li><a href="CSharp.html#CSharp">C# support</a></li>
-<li><a href="Chicken.html#Chicken">Chicken support</a></li>
 <li><a href="D.html#D">D support</a></li>
 <li><a href="Go.html#Go">Go support</a></li>
 <li><a href="Guile.html#Guile">Guile support</a></li>

Doc/Manual/chapters

@@ -20,7 +20,6 @@ CCache.html
 Allegrocl.html
 Android.html
 CSharp.html
-Chicken.html
 D.html
 Go.html
 Guile.html

Examples/Makefile.in

@@ -1081,122 +1081,6 @@ php_clean:
 	rm -f core @EXTRA_CLEAN@
 	rm -f *.@OBJEXT@ *$(PHP_SO)
 
-##################################################################
-#####                      Chicken                          ######
-##################################################################
-
-CHICKEN = @CHICKEN@
-CHICKEN_CSC = @CHICKEN_CSC@
-CHICKEN_CSI = @CHICKEN_CSI@
-CHICKEN_LIBOPTS = @CHICKENLIB@  $(SYSLIBS)
-CHICKEN_SHAREDLIBOPTS = @CHICKENSHAREDLIB@  $(SYSLIBS)
-CHICKEN_CFLAGS = @CHICKENOPTS@
-CHICKENOPTS = -quiet
-CHICKEN_MAIN =
-CHICKEN_SCRIPT = $(RUNME).scm
-
-# SWIG produces $(ISRCS) (the C wrapper file)
-# and $(CHICKEN_GENERATED_SCHEME) (the Scheme wrapper file):
-CHICKEN_GENERATED_SCHEME = $(INTERFACE:.i=.scm)
-CHICKEN_COMPILED_SCHEME = $(INTERFACE:.i=_chicken.c)
-CHICKEN_COMPILED_OBJECT = $(CHICKEN_COMPILED_SCHEME:.c=.@OBJEXT@)
-
-# flags for the main chicken sources (only used when compiling statically)
-CHICKEN_COMPILED_MAIN = $(CHICKEN_MAIN:.scm=_chicken.c)
-CHICKEN_COMPILED_MAIN_OBJECT = $(CHICKEN_COMPILED_MAIN:.c=.@OBJEXT@)
-
-# -----------------------------------------------------------------
-# Build a CHICKEN dynamically loadable module
-# -----------------------------------------------------------------
-
-# This is the old way to build chicken, but it does not work correctly with exceptions
-chicken_direct: $(SRCDIR_SRCS)
-	$(SWIG) -chicken $(SWIGOPT) $(INCLUDE) $(INTERFACEPATH)
-	$(CHICKEN) $(CHICKEN_GENERATED_SCHEME) $(CHICKENOPTS) \
-		-dynamic -feature chicken-compile-shared \
-		-output-file $(CHICKEN_COMPILED_SCHEME)
-	$(CC) -c $(CCSHARED) $(CPPFLAGS) $(CFLAGS) $(CHICKEN_CFLAGS) \
-		$(INCLUDES) $(CHICKEN_INCLUDE) $(ISRCS) $(SRCDIR_SRCS) $(CHICKEN_COMPILED_SCHEME)
-	$(LDSHARED) $(CFLAGS) $(LDFLAGS) $(CHICKEN_COMPILED_OBJECT) $(OBJS) $(IOBJS) \
-		$(LIBS) $(CHICKEN_SHAREDLIBOPTS) -o $(LIBPREFIX)$(TARGET)$(SO)
-
-chicken_direct_cpp: $(SRCDIR_CXXSRCS) $(CHICKSRCS)
-	$(SWIG) -c++ -chicken $(SWIGOPT) $(INCLUDE) $(INTERFACEPATH)
-	$(CHICKEN) $(CHICKEN_GENERATED_SCHEME) $(CHICKENOPTS) \
-		-dynamic -feature chicken-compile-shared \
-		-output-file $(CHICKEN_COMPILED_SCHEME)
-	$(CXX) -c $(CCSHARED) $(CPPFLAGS) $(CXXFLAGS) $(CHICKEN_CFLAGS) \
-		$(INCLUDES) $(CHICKEN_INCLUDE) $(ICXXSRCS) $(SRCDIR_SRCS) $(SRCDIR_CXXSRCS) $(CHICKEN_COMPILED_SCHEME)
-	$(CXXSHARED) $(CXXFLAGS) $(LDFLAGS) $(CHICKEN_COMPILED_OBJECT) $(OBJS) $(IOBJS) \
-		$(LIBS) $(CPP_DLLIBS) $(CHICKEN_SHAREDLIBOPTS) -o $(LIBPREFIX)$(TARGET)$(SO)
-
-# -----------------------------------------------------------------
-# Build statically linked CHICKEN interpreter
-# -----------------------------------------------------------------
-
-# The following two targets are also used by the test suite
-chicken_static: $(SRCDIR_SRCS) $(CHICKSRCS)
-	$(SWIG) -chicken $(SWIGOPT) $(INCLUDE) $(INTERFACEPATH)
-	$(CHICKEN) $(CHICKEN_GENERATED_SCHEME) $(CHICKENOPTS) \
-		-output-file $(CHICKEN_COMPILED_SCHEME)
-	$(CHICKEN) $(CHICKEN_MAIN) $(CHICKENOPTS) \
-		-output-file $(CHICKEN_MAIN:.scm=_chicken.c)
-	$(CC) -c $(CCSHARED) $(CPPFLAGS) $(CFLAGS) $(CHICKEN_CFLAGS) \
-		$(INCLUDES) $(CHICKEN_INCLUDE) $(ISRCS) $(SRCDIR_SRCS) \
-		$(CHICKEN_COMPILED_SCHEME) $(CHICKEN_COMPILED_MAIN)
-	$(CC) $(CFLAGS) $(LDFLAGS) $(CHICKEN_COMPILED_OBJECT) $(CHICKEN_COMPILED_MAIN_OBJECT) \
-		$(OBJS) $(IOBJS) $(LIBS) $(CHICKEN_SHAREDLIBOPTS) -o $(TARGET)
-
-chicken_static_cpp: $(SRCDIR_CXXSRCS) $(CHICKSRCS)
-	$(SWIG) -c++ -chicken $(SWIGOPT) $(INCLUDE) $(INTERFACEPATH)
-	$(CHICKEN) $(CHICKEN_GENERATED_SCHEME) $(CHICKENOPTS) \
-		-output-file $(CHICKEN_COMPILED_SCHEME)
-	$(CHICKEN) $(CHICKEN_MAIN) $(CHICKENOPTS) \
-		-output-file $(CHICKEN_MAIN:.scm=_chicken.c)
-	$(CXX) -c $(CCSHARED) $(CPPFLAGS) $(CXXFLAGS) $(CHICKEN_CFLAGS) \
-		$(INCLUDES) $(CHICKEN_INCLUDE) $(ICXXSRCS) $(SRCDIR_SRCS) $(SRCDIR_CXXSRCS) \
-		$(CHICKEN_COMPILED_SCHEME) $(CHICKEN_COMPILED_MAIN)
-	$(CXX) $(CXXFLAGS) $(LDFLAGS) $(CHICKEN_COMPILED_OBJECT) $(CHICKEN_COMPILED_MAIN_OBJECT) \
-		$(OBJS) $(IOBJS) $(LIBS) $(CPP_DLLIBS) $(CHICKEN_SHAREDLIBOPTS) -o $(TARGET)
-
-# ----------------------------------------------------------------
-# Build a shared library using csc
-# ----------------------------------------------------------------
-
-chicken:
-	$(SWIG) -chicken $(SWIGOPT) $(INCLUDE) $(INTERFACEPATH)
-	$(COMPILETOOL) $(CHICKEN_CSC) -s `echo $(INCLUDES) | sed 's/-I/-C -I/g'` $(CHICKEN_GENERATED_SCHEME) $(SRCDIR_SRCS) $(ISRCS) -o $(TARGET)$(SO)
-
-chicken_cpp:
-	$(SWIG) -c++ -chicken $(SWIGOPT) $(INCLUDE) $(INTERFACEPATH)
-	$(COMPILETOOL) $(CHICKEN_CSC) -s `echo $(INCLUDES) | sed 's/-I/-C -I/g'` $(CHICKEN_GENERATED_SCHEME) $(SRCDIR_SRCS) $(ICXXSRCS) $(SRCDIR_CXXSRCS) -o $(TARGET)$(SO)
-
-chicken_externalhdr:
-	$(SWIG) -chicken -external-runtime $(TARGET)
-
-# -----------------------------------------------------------------
-# Run CHICKEN example
-# -----------------------------------------------------------------
-
-chicken_run:
-	env LD_LIBRARY_PATH=$$PWD $(RUNTOOL) $(CHICKEN_CSI) $(CHICKEN_SCRIPT) $(RUNPIPE)
-
-# -----------------------------------------------------------------
-# Version display
-# -----------------------------------------------------------------
-
-chicken_version:
-	$(CHICKEN) -version | grep -i version
-
-# -----------------------------------------------------------------
-# Cleaning the CHICKEN examples
-# -----------------------------------------------------------------
-
-chicken_clean:
-	rm -f *_wrap* *~ .~* *_chicken*
-	rm -f core @EXTRA_CLEAN@
-	rm -f *.@OBJEXT@ *@SO@
-
 ##################################################################
 #####                      CSHARP                           ######
 ##################################################################

Lib/allkw.swg

@@ -16,7 +16,6 @@
   
 */
 
-%include <chicken/chickenkw.swg>
 %include <csharp/csharpkw.swg>
 %include <d/dkw.swg>
 %include <go/gokw.swg>

Lib/cdata.i

@@ -21,14 +21,6 @@ typedef struct SWIGCDATA {
 }
 %typemap(in) (const void *indata, int inlen) = (char *STRING, int LENGTH);
 
-#elif SWIGCHICKEN
-
-%typemap(out) SWIGCDATA {
-  C_word *string_space = C_alloc(C_SIZEOF_STRING($1.len));
-  $result = C_string(&string_space, $1.len, $1.data);
-}
-%typemap(in) (const void *indata, int inlen) = (char *STRING, int LENGTH);
-
 #elif SWIGPHP7
 
 %typemap(out) SWIGCDATA {

Lib/exception.i

@@ -138,22 +138,6 @@ SWIGINTERN void SWIG_exception_(int code, const char *msg) {
 #endif
 
 
-#ifdef SWIGCHICKEN
-%{
-SWIGINTERN void SWIG_exception_(int code, const char *msg) {
-  C_word *a;
-  C_word scmmsg;
-  C_word list;
-
-  a = C_alloc (C_SIZEOF_STRING (strlen (msg)) + C_SIZEOF_LIST(2));
-  scmmsg = C_string2 (&a, (char *) msg);
-  list = C_list(&a, 2, C_fix(code), scmmsg);
-  SWIG_ThrowException(list);
-}
-#define SWIG_exception(a,b) SWIG_exception_((a),(b))
-%}
-#endif
-
 #ifdef SWIGCSHARP
 %{
 SWIGINTERN void SWIG_CSharpException(int code, const char *msg) {

Makefile.in

@@ -69,7 +69,6 @@ skip-ruby	= test -n "@SKIP_RUBY@"
 skip-php	= test -n "@SKIP_PHP@"
 skip-ocaml      = test -n "@SKIP_OCAML@"
 skip-octave     = test -n "@SKIP_OCTAVE@"
-skip-chicken	= test -n "@SKIP_CHICKEN@"
 skip-csharp	= test -n "@SKIP_CSHARP@"
 skip-lua    	= test -n "@SKIP_LUA@"
 skip-allegrocl  = test -n "@SKIP_ALLEGROCL@"
@@ -113,7 +112,6 @@ check-aliveness:
 	@$(skip-ocaml)    || ./$(TARGET) -ocaml      -help
 	@$(skip-octave)   || ./$(TARGET) -octave     -help
 	@$(skip-php)      || ./$(TARGET) -php7       -help
-	@$(skip-chicken)  || ./$(TARGET) -chicken    -help
 	@$(skip-csharp)   || ./$(TARGET) -csharp     -help
 	@$(skip-allegrocl)|| ./$(TARGET) -allegrocl  -help
 	@$(skip-cffi)     || ./$(TARGET) -cffi       -help
@@ -141,7 +139,6 @@ check-versions:					\
 	check-ocaml-version			\
 	check-octave-version			\
 	check-php-version			\
-	check-chicken-version			\
 	check-csharp-version			\
 	check-lua-version			\
 	check-allegrocl-version			\
@@ -177,7 +174,6 @@ check-examples:					\
 	check-ocaml-examples			\
 	check-octave-examples			\
 	check-php-examples			\
-	check-chicken-examples                  \
 	check-csharp-examples                   \
 	check-lua-examples			\
 	check-allegrocl-examples		\
@@ -199,7 +195,6 @@ ruby_examples      :=$(shell sed '/^\#/d' $(srcdir)/Examples/ruby/check.list)
 ocaml_examples     :=$(shell sed '/^\#/d' $(srcdir)/Examples/ocaml/check.list)
 octave_examples    :=$(shell sed '/^\#/d' $(srcdir)/Examples/octave/check.list)
 php_examples       :=$(shell sed '/^\#/d' $(srcdir)/Examples/php/check.list)
-chicken_examples   :=$(shell sed '/^\#/d' $(srcdir)/Examples/chicken/check.list)
 csharp_examples    :=$(shell sed '/^\#/d' $(srcdir)/Examples/csharp/check.list)
 lua_examples       :=$(shell sed '/^\#/d' $(srcdir)/Examples/lua/check.list)
 allegrocl_examples :=
@@ -247,7 +242,6 @@ check-test-suite:				\
 	check-lua-test-suite			\
 	check-allegrocl-test-suite		\
 	check-cffi-test-suite			\
-	check-chicken-test-suite		\
 	check-r-test-suite			\
 	check-scilab-test-suite			\
 	check-go-test-suite			\
@@ -297,7 +291,6 @@ all-test-suite:					\
 	all-lua-test-suite			\
 	all-allegrocl-test-suite		\
 	all-cffi-test-suite			\
-	all-chicken-test-suite			\
 	all-r-test-suite			\
 	all-scilab-test-suite   		\
 	all-go-test-suite			\
@@ -323,7 +316,6 @@ broken-test-suite:				\
 	broken-lua-test-suite			\
 	broken-allegrocl-test-suite		\
 	broken-cffi-test-suite			\
-	broken-chicken-test-suite		\
 	broken-r-test-suite			\
 	broken-scilab-test-suite           	\
 	broken-go-test-suite			\
@@ -460,7 +452,7 @@ install-main:
 	@$(INSTALL_PROGRAM) $(TARGET) $(DESTDIR)$(BIN_DIR)/`echo $(TARGET_NOEXE) | sed '$(transform)'`@EXEEXT@
 
 lib-languages = typemaps tcl perl5 python guile java mzscheme ruby php ocaml octave \
-	chicken csharp allegrocl lua cffi r go d javascript javascript/jsc \
+	csharp allegrocl lua cffi r go d javascript javascript/jsc \
 	javascript/v8 scilab xml
 
 lib-modules = std

README

@@ -4,7 +4,7 @@ Version: 4.0.0 (in progress)
 
 Tagline: SWIG is a compiler that integrates C and C++ with languages
          including Perl, Python, Tcl, Ruby, PHP, Java, C#, D, Go, Lua,
-         Octave, R, Scheme (Guile, MzScheme/Racket, CHICKEN), Scilab,
+         Octave, R, Scheme (Guile, MzScheme/Racket), Scilab,
          Ocaml, Common Lisp (Allegro CL, CFFI).
          SWIG can also export its parse tree into XML.
 

Source/Makefile.am

@@ -49,7 +49,6 @@ eswig_SOURCES =	CParse/cscanner.c		\
 		Modules/allocate.cxx		\
 		Modules/browser.cxx		\
 		Modules/cffi.cxx		\
-		Modules/chicken.cxx		\
 		Modules/contract.cxx		\
 		Modules/csharp.cxx		\
 		Modules/d.cxx			\

Source/Modules/swigmain.cxx

@@ -28,7 +28,6 @@
 extern "C" {
   Language *swig_allegrocl(void);
   Language *swig_cffi(void);
-  Language *swig_chicken(void);
   Language *swig_csharp(void);
   Language *swig_d(void);
   Language *swig_go(void);
@@ -57,7 +56,7 @@ extern "C" {
 
 static TargetLanguageModule modules[] = {
   {"-allegrocl", swig_allegrocl, "ALLEGROCL", Supported},
-  {"-chicken", swig_chicken, "CHICKEN", Supported},
+  {"-chicken", NULL, "CHICKEN", Disabled},
   {"-clisp", NULL, "CLISP", Disabled},
   {"-cffi", swig_cffi, "CFFI", Supported},
   {"-csharp", swig_csharp, "C#", Supported},

configure.ac

@@ -2084,108 +2084,6 @@ AC_SUBST(OCAMLFIND)
 AC_SUBST(OCAMLMKTOP)
 AC_SUBST(CAMLP4)
 
-#----------------------------------------------------------------
-# Look for CHICKEN
-#----------------------------------------------------------------
-
-CHICKEN=
-CHICKEN_CONFIG=
-CHICKENHOME=
-CHICKENOPTS=
-CHICKENLIB=
-
-
-AC_ARG_WITH(chicken, AS_HELP_STRING([--without-chicken], [Disable CHICKEN])
-AS_HELP_STRING([--with-chicken=path], [Set location of CHICKEN executable]),[ CHICKENBIN="$withval"], [CHICKENBIN="$alllang_default"])
-
-# First, check for "--without-chicken" or "--with-chicken=no".
-if test x"${CHICKENBIN}" = xno; then
-AC_MSG_NOTICE([Disabling CHICKEN])
-else
-
-if test "x$CHICKENBIN" = xyes; then
-AC_CHECK_PROGS(CHICKEN, chicken)
-else
-CHICKEN="$CHICKENBIN"
-fi
-
-AC_ARG_WITH(chickencsc,[  --with-chickencsc=path  Set location of csc executable],[ CHICKEN_CSC="$withval"], [CHICKEN_CSC=])
-
-if test -z "$CHICKEN_CSC"; then
-  AC_CHECK_PROGS(CHICKEN_CSC, csc)
-  # Both the Microsoft C# compiler and chicken have an executable called csc, so check that this csc is really the chicken one
-  if test -n "$CHICKEN_CSC" ; then
-    AC_MSG_CHECKING(whether csc is the chicken compiler)
-    $CHICKEN_CSC -version 2>/dev/null | grep "chicken" > /dev/null || CHICKEN_CSC=""
-    if test -z "$CHICKEN_CSC"; then
-      AC_MSG_RESULT(no)
-    else
-      AC_MSG_RESULT(yes)
-    fi
-  fi
-fi
-
-AC_ARG_WITH(chickencsi,[  --with-chickencsi=path  Set location of csi executable],[ CHICKEN_CSI="$withval"], [CHICKEN_CSI=])
-
-if test -z "$CHICKEN_CSI"; then
-AC_CHECK_PROGS(CHICKEN_CSI, csi)
-fi
-
-if test -n "$CHICKEN_CSC" ; then
-
-  AC_ARG_WITH(chickenopts,[  --with-chickenopts=args Set compiler options for static CHICKEN generated code],[
-	CHICKENOPTS="$withval"], [CHICKENOPTS=])
-  AC_ARG_WITH(chickensharedlib,[  --with-chickensharedlib=args    Set linker options for shared CHICKEN generated code],[
-	CHICKENSHAREDLIB="$withval"], [CHICKENSHAREDLIB=])
-  AC_ARG_WITH(chickenlib,[  --with-chickenlib=args  Set linker options for static CHICKEN generated code],[
-	CHICKENLIB="$withval"], [CHICKENLIB=])
-
-  AC_MSG_CHECKING(for compiler options for static CHICKEN generated code)
-  if test -z "$CHICKENOPTS"; then
-        CHICKENOPTS="`$CHICKEN_CSC -cflags`"
-  else
-        CHICKENOPTS="`$CHICKEN_CSC -cflags` $CHICKENOPTS"
-  fi
-  if test -z "$CHICKENOPTS"; then
-        AC_MSG_RESULT(not found)
-  else
-        AC_MSG_RESULT($CHICKENOPTS)
-  fi
-
-  AC_MSG_CHECKING(for linker options for shared CHICKEN generated code)
-  if test -z "$CHICKENSHAREDLIB"; then
-        CHICKENSHAREDLIB="`$CHICKEN_CSC -shared -libs`"
-  else
-        CHICKENSHAREDLIB="`$CHICKEN_CSC -shared -libs` $CHICKENSHAREDLIB"
-  fi
-  if test -z "$CHICKENSHAREDLIB"; then
-  	AC_MSG_RESULT(not found)
-  else
-        AC_MSG_RESULT($CHICKENSHAREDLIB)
-  fi
-
-  AC_MSG_CHECKING(for linker options for static CHICKEN generated code)
-  if test -z "$CHICKENLIB"; then
-        CHICKENLIB="`$CHICKEN_CSC -libs`"
-  else
-        CHICKENLIB="`$CHICKEN_CSC -libs` $CHICKENLIB"
-  fi
-  if test -z "$CHICKENLIB"; then
-  	AC_MSG_RESULT(not found)
-  else
-        AC_MSG_RESULT($CHICKENLIB)
-  fi
-
-fi # have CHICKEN_CONFIG
-fi # Check for --without-chicken
-
-AC_SUBST(CHICKEN)
-AC_SUBST(CHICKEN_CSC)
-AC_SUBST(CHICKEN_CSI)
-AC_SUBST(CHICKENOPTS)
-AC_SUBST(CHICKENLIB)
-AC_SUBST(CHICKENSHAREDLIB)
-
 #----------------------------------------------------------------
 # Look for C#
 #----------------------------------------------------------------
@@ -2775,13 +2673,6 @@ fi
 AC_SUBST(SKIP_OCAML)
 
 
-SKIP_CHICKEN=
-if test -z "$CHICKEN_CSC" || test -z "$CHICKEN"; then
-    SKIP_CHICKEN="1"
-fi
-AC_SUBST(SKIP_CHICKEN)
-
-
 SKIP_CSHARP=
 if test -z "$CSHARPCOMPILER" ; then
     SKIP_CSHARP="1"
@@ -2924,7 +2815,6 @@ AC_CONFIG_FILES([
     Examples/d/example.mk
     Examples/xml/Makefile
     Examples/test-suite/errors/Makefile
-    Examples/test-suite/chicken/Makefile
     Examples/test-suite/csharp/Makefile
     Examples/test-suite/d/Makefile
     Examples/test-suite/guile/Makefile
@@ -2991,7 +2881,6 @@ AC_OUTPUT
 langs=""
 test -n "$SKIP_ALLEGROCL"	|| langs="${langs}allegrocl "
 test -n "$SKIP_CFFI"		|| langs="${langs}cffi "
-test -n "$SKIP_CHICKEN"		|| langs="${langs}chicken "
 test -n "$SKIP_CSHARP"		|| langs="${langs}csharp "
 test -n "$SKIP_D"		|| langs="${langs}d "
 test -n "$SKIP_GO"		|| langs="${langs}go "

swig.spec.in

@@ -27,7 +27,7 @@ with a variety of high-level programming languages. SWIG is primarily used with
 common scripting languages such as Perl, Python, Tcl/Tk, and Ruby, however the
 list of supported languages also includes non-scripting languages such as Java,
 OCAML and C#. Also several interpreted and compiled Scheme implementations
-(Guile, MzScheme, Chicken) are supported. SWIG is most commonly used to create
+(Guile, MzScheme) are supported. SWIG is most commonly used to create
 high-level interpreted or compiled programming environments, user interfaces,
 and as a tool for testing and prototyping C/C++ software. SWIG can also export
 its parse tree in the form of XML.