[Chicken-users] draft of INSTALL-MinGW.txt

[Brandon J. Van Every]

Attached is a draft of INSTALL-MinGW.txt.  It explains how to build 
Chicken with MinGW and CMake.  I'm also attaching the current 
CMakeLists.txt that's in Darcs, for convenience.  The version in 
chicken-2.216.tar.gz isn't as recent.

"make install" is bugged.  Things that should be getting installed, 
aren't; things that shouldn't, are. 

"make" works fine, though.  Your output directory should be populated 
with all the Chicken stuff, and you should experience no errors.  Please 
let me know if you can at least do a successful "make" with these 
instructions.


Cheers,
Brandon Van Every

How to build Chicken Scheme using CMake and MinGW
-------------------------------------------------

by Brandon Van Every
Windows buildmaster for Chicken
last updated February 3, 2006

If in trouble, please contact me through the Chicken mailing list.  You can 
subscribe to the list from the Chicken homepage, 
http://call-with-current-continuation.org.



EXECUTIVE SUMMARY
-----------------

- Install MinGW
- Install MSYS
- Install CMake
- Install the Microsoft Platform SDK and set environment variables for MSYS
- Test your installed tools
- unpack a Chicken release or snapshot tarball
- run cmakesetup from a MSYS shell, select "Unix Makefiles" and generate them
- make; make install
- test your Chicken installation


BENEFITS OF CMake
-----------------

In principle, a CMake build is no more difficult than running a GNU Autoconf 
.\configure script.  CMake is designed to replace Autoconf.  It provides the 
same functionality of querying the system and available libraries.  It can 
generate Makefiles, and unlike Autoconf, it can also generate Visual C++ 
project files, Windows nmake files, and even Borland makefiles.  Watcom file 
generation is also in development.  CMake is a true cross-platform build tool, 
not just a Unix build tool.  It's what us Windows guys *wish* GNU Autoconf was, 
so now we can stop wishing!  Unixen may find it convenient as well, if they are 
not too settled in their ways.  Also GCC is supported on the Mac under Darwin, 
although I'm unsure how robust it is.  For full details on CMake and supported 
platforms, look at http://cmake.org.

These instructions can, in principle, be used to build Chicken with any 
compiler on any platform that CMake supports.  In practice, if the combo isn't 
tested you'll likely get a bug, like some missing flag or library.  It is 
probably very little work to resolve, however, and the principal CMake authors 
are willing to help you get it working.  That's how Chicken's CMake build got 
started, actually.  Anyways, if you try the CMake build on a new platform and 
have difficulty, post on the Chicken list and I'll get you in touch with the 
CMake guys.

I build and test the following CMake configurations on Windows:

  MinGW
  Visual Studio .NET 2003 
  Cygwin

For anything else, YMMV.



INSTALL MinGW
-------------

Goto http://mingw.org download section and grab MinGW.  I used the following 
file:

  MinGW-5.0.0.exe

This is an automated downloader / installer.  Using it is straightforward.  You 
will be given an option to select either the "Previous, Current, or Candidate" 
MinGW installations.  I chose "Candidate," which gave me a GCC 3.4.5 
installation and appropriate binutils.



INSTALL MSYS
------------

Goto http://mingw.org download section, grab MSYS, and install it.  I used the 
following file:

  MSYS-1.0.11-2004.04.30-1.exe

During the install, a command shell will pop up and perform a "post install" 
operation to rectify MSYS with your MinGW installation.  This is because the 
Make utility is different for MinGW and MSYS.  When using MSYS, you want to use 
MSYS's version of it.  You will be asked some questions; answer them in a 
straightforward manner, similar to the following:

  "Do you want to continue with the post install?" YES [y]
  "Do you have MinGW installed?" YES [y]
  "Where is your MinGW installation?"  C:/MinGW  [note the forward slash!]
  "Oh joy, you do not have C:/MinGW/bin/make.exe.  Keep it that way."
  "Press any key to continue . . ."  [DO SO]

The command prompt now goes away, you are returned to the MSYS Setup.exe 
installer, and you can Click Finish to exit Setup.



INSTALL CMake
----------------

Goto http://cmake.org, grab CMake, and install it.  I used the following file:

  cmake-2.2.3-win32.exe

After you have installed it, add the CMake binary's path to your Windows 
environment. A typical way to do this: right-click on My Computer, click 
Properties, click Advanced, click Environment Variables, select "Path" under 
System Variables, click Edit..., and add something like

  ;C:\Program Files\CMake 2.2\bin

to the end of your path.  Note the ; separator.



INSTALL The Microsoft Platform SDK
----------------------------------

Goto http://msdn.microsoft.com, grab one of the following Platform SDK 
packages, and install it:

  Windows Server 2003 SP1 Platform SDK ISO Install    [for burning a CD image]
  Windows Server 2003 SP1 Platform SDK Full Download  [a series of 25MB files]
  Windows Server 2003 SP1 Platform SDK Web Install    [for installing over the 
web]

Microsoft changes their website a lot, so there's no point in giving you an 
exact URL.  Who knows, the name of the "Platform SDK" may also change.  As of 
February 2006, this is what you want if you are going to build stuff on Windows 
2000 or XP.

Now you need to set your environment variables properly.  The PSDK provides a 
.Cmd file for this purpose,

  C:\Program Files\Microsoft Platform SDK\SetEnv.Cmd

You need to run this every time you start a MSYS shell.  The easiest way to 
ensure this happens, is to hack

  C:\msys\1.0\msys.bat

so that it calls SetEnv.Cmd as the very first thing it does.  For example, 
change the very beginning of msys.bat to the following:

  @echo off
  call "C:\Program Files\Microsoft Platform SDK\SetEnv.Cmd"
  rem Copyright (C):  2001, 2002, 2003, 2004  Earnie Boyd
  [blah blah blah blah blah the rest is unchanged]

Note that without the PSDK, and without the environment set up properly, 
chicken.exe gets built, then fails immediately with a memory write error the 
first time it is used during the build.  I don't know why; presumably, some 
tool in the toolchain depends on some header file, .dll, .lib, or tool that the 
PSDK provides.  If someone figures out the dependency, then perhaps the PSDK 
can be eliminated.  But until then, it is essential.  You have been warned, 
Your Mileage Won't Vary (YMWV).



TEST YOUR PSDK, MinGW, MSYS, CMake INSTALLATIONS
------------------------------------------------

Open a MSYS shell.  There's probably an icon on your desktop to do this.  Type:

  set

You should see environment variables like:

INCLUDE=C:\Program Files\Microsoft Platform SDK\Include
INETSDK=C:\Program Files\Microsoft Platform SDK
LIB=C:\Program Files\Microsoft Platform SDK\Lib
MSSdk=C:\Program Files\Microsoft Platform SDK
Mstools=C:\Program Files\Microsoft Platform SDK
PATH='.:/usr/local/bin:/mingw/bin:/bin:/c/Program Files/Microsoft Platform 
SDK/Bin:/c/Program Files/Microsoft Platform 
SDK/Bin/WinNT:/c/WINNT/system32:/c/WINNT:/c/WINNT/System32/Wbem:/c/Program 
Files/CMake 2.2/bin'

Now type:

  gcc --version

You should see something like "gcc.exe (GCC) 3.4.5 (mingw special)".  Now type:

  cmake -version

You should see something like "cmake version 2.2-patch 3".



Build Chicken with CMake
------------------------

Grab a Chicken release or snapshot tarball from 
http://www.call-with-current-continuation.org.

These instructions work for Chicken tarball 2.??? [EDIT: PUT FINAL VERSION 
NUMBER HERE] You must use a tarball to get the needed *.c files.  The CMake 
build does not currently support bootstrapping straight from the Darcs source 
control repository, although this support will be added in the future.

Unpack the tarball wherever you like.  These instructions will assume the 
source code is in C:\src\chicken.  You'll be doing an "out of directory" build, 
i.e. nothing in the source directory will ever be changed.  I'll assume you 
want to build everything in C:\dest\chicken.

Open a MSYS shell.  Type:

  cmakesetup

It's important to do this from a MSYS shell.  There's currently a bug in CMake 
regarding MSYS, things don't work properly if you start cmakesetup.exe outside 
of MSYS.  The CMake authors are aware of the bug and will squash it eventually. 
 Meanwhile, be sure to do this from a MSYS shell.

A window pops up.  Fill out the fields as follows:

  "Where is the source code:" C:\src\chicken
  "Where to build the binaries:" C:\dest\chicken

Now hit "Configure".  A dialog box will ask you to Select the Generator.  
Choose "Unix Makefiles" as your generator and hit OK.  You now have the 
opportunity to change various settings if you wish, such as the 
CMAKE_INSTALL_PREFIX.  This is the directory that Chicken will eventually be 
installed in after it is built; the default is something like C:\Program 
Files\Chicken.  Uncommitted settings appear in red.  Once you've changed what 
you like, hit "Configure" again.  Now the settings will change to grey and the 
message "Configuring done" will appear in the status bar.  Hit "OK" to exit 
cmakesetup.

You should now have a bunch of files, including a Makefile, in your 
C:\build\chicken directory.  In your MSYS shell, change to this directory.  
MSYS uses /c to represent the C: drive, so do "cd /c/dest/chicken".  Now type 
"make".  Everything should build; you may receive warnings, but you should 
receive no errors.

Now type "make install".  You should end up with the following files:

  C:/Program Files/Chicken/include/chicken.h
  C:/Program Files/Chicken/man/man1/chicken.1
  C:/Program Files/Chicken/man/man1/csi.1
  C:/Program Files/Chicken/man/man1/csc.1
  C:/Program Files/Chicken/man/man1/chicken-setup.1
  C:/Program Files/Chicken/man/man1/chicken-profile.1
  C:/Program Files/Chicken/bin/chicken.exe
  C:/Program Files/Chicken/bin/libchicken.dll
  C:/Program Files/Chicken/bin/chicken-profile.exe
  C:/Program Files/Chicken/bin/chicken-setup.exe
  C:/Program Files/Chicken/bin/csc.exe
  C:/Program Files/Chicken/bin/csi.exe

Now put Chicken in your PATH.  Right click on "My Computer."  Select 
"Properties... Advanced... Environment Variables...."  Under "System 
Variables," select "Path" and click "Edit...."  Add the following to the end of 
your path:

  ;C:\Program Files\Chicken\bin

Note the ; separator.



TEST YOUR Chicken INSTALLATION
------------------------------

Close your MSYS shell.  Open a new shell; it can be a MSYS shell, or a plain 
old Windows Command Prompt.  Change to any directory other than your 
C:\dest\chicken directory, to make sure that your PATH is set up correctly.  
Type:

  chicken -version

You should see a banner like:

 )   ___
(__/_____) /)   ,    /)
  /       (/      _ (/_   _ __
 /        / )__(_(__/(___(/_/ (_
(______)
Version 2, Build 216 - windows-mingw32-x86 - [ dload ptables ]
(c)2000-2005 Felix L. Winkelmann


[TODO: HOW ABOUT SOME MORE STRINGENT TESTS?]

CMAKE_MINIMUM_REQUIRED (VERSION 2.2)
PROJECT (Chicken)


INCLUDE_DIRECTORIES(${Chicken_SOURCE_DIR} ) 


# I removed some of the -D options you had,
# you may want to add some back, but make sure to use TRY_COMPILE stuff so
# this works on all platforms.   


IF(WIN32 AND NOT CMAKE_COMPILER_IS_GNUCC)
  ADD_DEFINITIONS(-DC_DEFAULT_TARGET_STACK_SIZE=300000)
  ADD_DEFINITIONS(-DHAVE_LOADLIBRARY)
  ADD_DEFINITIONS(-DHAVE_GETPROCADDRESS)
ENDIF(WIN32 AND NOT CMAKE_COMPILER_IS_GNUCC)


# check for socklen_t type
INCLUDE(CheckTypeSize)
SET(CMAKE_EXTRA_INCLUDE_FILES netdb.h)
CHECK_TYPE_SIZE(socklen_t SIZEOF_SOCKLEN_T)
IF(NOT SIZEOF_SOCKLEN_T)
  ADD_DEFINITIONS(-Dsocklen_t=int)
ENDIF(NOT SIZEOF_SOCKLEN_T)


# check for grp.h
INCLUDE(CheckIncludeFile)
CHECK_INCLUDE_FILE(grp.h HAVE_GRP_H)
IF(HAVE_GRP_H)
  ADD_DEFINITIONS(-DHAVE_GRP_H)
ENDIF(HAVE_GRP_H)


# check for pcre.h
CHECK_INCLUDE_FILE(pcre.h HAVE_PCRE_H)
IF(HAVE_PCRE_H)
  ADD_DEFINITIONS(-DHAVE_PCRE_H)
  SET(REGEX_SOURCE pcre.c)
  SET(REGEX_UNSAFE_SOURCE upcre.c)
  SET(EXTRA_LIBS pcre)
ELSE(HAVE_PCRE_H)
  IF(WIN32 AND NOT CYGWIN)
    SET(REGEX_SOURCE pregexp.c)
    SET(REGEX_UNSAFE_SOURCE upregexp.c)
  ELSE(WIN32 AND NOT CYGWIN)
    SET(REGEX_SOURCE regex.c)
    SET(REGEX_UNSAFE_SOURCE uregex.c)
  ENDIF(WIN32 AND NOT CYGWIN)
  SET(EXTRA_LIBS )
ENDIF(HAVE_PCRE_H)


# check for dlfcn.h or dl.h
CHECK_INCLUDE_FILE(dlcfn.h HAVE_DLFCN_H)
IF(HAVE_DLFCN_H)
  ADD_DEFINITIONS(-DHAVE_DLFCN_H)
  SET(EXTRA_LIBS ${EXTRA_LIBS} dl)
ENDIF(HAVE_DLFCN_H)
CHECK_INCLUDE_FILE(dl.h HAVE_DL_H)
IF(HAVE_DL_H)
  ADD_DEFINITIONS(-DHAVE_DL_H)
  SET(EXTRA_LIBS ${EXTRA_LIBS} ldl)
ENDIF(HAVE_DL_H)


# check for ffi.h
CHECK_INCLUDE_FILE(ffi.h HAVE_FFI_H)
IF(HAVE_FFI_H)
  ADD_DEFINITIONS(-DHAVE_FFI_H)
  SET(EXTRA_LIBS ${EXTRA_LIBS} ffi)
ENDIF(HAVE_FFI_H)


# check for windows.h
CHECK_INCLUDE_FILE(windows.h HAVE_WINDOWS_H)
IF(HAVE_WINDOWS_H)
  ADD_DEFINITIONS(-DHAVE_WINDOWS_H)
ENDIF(HAVE_WINDOWS_H)


# give the user an option to build static or shared libraries
OPTION(BUILD_SHARED_LIBS "build shared libs" TRUE)
IF(BUILD_SHARED_LIBS)
  ADD_DEFINITIONS(-DPIC)  # for shared add -DPIC to all compile lines
  IF(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
    ADD_DEFINITIONS(-fno-common -no-cpp-precomp)
  ENDIF(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
ELSE(BUILD_SHARED_LIBS)
  ADD_DEFINITIONS(-DC_NO_PIC_NO_DLL)  # for static add -DC_NO_PIC_NO_DLL 
ENDIF(BUILD_SHARED_LIBS)


# give the user an option to enable support for procedure-serialiazation
OPTION(ENABLE_PROCEDURE_TABLES "enable support for serialization of procedures" 
FALSE)
IF(ENABLE_PROCEDURE_TABLES)
  ADD_DEFINITIONS(-DC_ENABLE_PTABLES)
ENDIF(ENABLE_PROCEDURE_TABLES)


# create a list of all the sources
SET (CHICKEN_LIB_SOURCES    
    runtime.c           library.c 
    eval.c              profiler.c 
    scheduler.c         extras.c
    match-support.c     lolevel.c
    stub.c              tinyclos.c
    ${REGEX_SOURCE}     utils.c
    tcp.c               
    srfi-1.c            srfi-4.c
    srfi-13.c           srfi-14.c
    srfi-18.c)
SET (CHICKEN_UNSAFE_LIB_SOURCES    
    runtime.c           ulibrary.c 
    ueval.c              profiler.c 
    scheduler.c         uextras.c
    umatch-support.c     ulolevel.c
    stub.c              utinyclos.c
    ${REGEX_UNSAFE_SOURCE}     uutils.c
    utcp.c               
    usrfi-1.c            usrfi-4.c
    usrfi-13.c           usrfi-14.c
    usrfi-18.c)
SET (CHICKEN_GUI_LIB_SOURCES    
    runtime.c           gui-library.c 
    eval.c              profiler.c 
    scheduler.c         extras.c
    match-support.c    lolevel.c
    stub.c              tinyclos.c
    ${REGEX_SOURCE}     utils.c
    tcp.c               
    srfi-1.c            srfi-4.c
    srfi-13.c           srfi-14.c
    srfi-18.c)


# add a posix source based on OS
IF(WIN32 AND NOT CYGWIN)
  SET (CHICKEN_LIB_SOURCES    ${CHICKEN_LIB_SOURCES}  posixwin.c)
  SET (CHICKEN_UNSAFE_LIB_SOURCES    ${CHICKEN_UNSAFE_LIB_SOURCES}  uposixwin.c)
ENDIF(WIN32 AND NOT CYGWIN)
IF(UNIX)
  SET (CHICKEN_LIB_SOURCES ${CHICKEN_LIB_SOURCES} posix.c)
  SET (CHICKEN_UNSAFE_LIB_SOURCES ${CHICKEN_UNSAFE_LIB_SOURCES} uposix.c)
ENDIF(UNIX)


# since libchicken has to be the name of the dll or .so to load
# On unix lib is the default prefix added to any library.
# For windows we change the name of the library to be libchicken.
# Note: GCC based compilers, i.e. Cygwin, MinGW, behave like Unix.
# In general, be careful about whether NOT CYGWIN or
# NOT CMAKE_COMPILER_IS_GNUCC is really intended.

# Variable names for libraries are needed because CMake-2.2.3 has
# bugs in the handling of PREFIX and OUTPUT.  The make targets
# don't work with them.  Explicit ADD_DEPENDENCY statements are
# required.  When these bugs are fixed, we'll be able to simplify.

IF(WIN32 AND NOT CMAKE_COMPILER_IS_GNUCC)
  SET(CHICKEN_LIB_NAME libchicken)
  SET(CHICKEN_UNSAFE_LIB_NAME libuchicken)
  SET(CHICKEN_GUI_LIB_NAME libchicken_gui)
ELSE(WIN32 AND NOT CMAKE_COMPILER_IS_GNUCC)
  SET(CHICKEN_LIB_NAME chicken)
  SET(CHICKEN_UNSAFE_LIB_NAME uchicken)
  SET(CHICKEN_GUI_LIB_NAME chicken_gui)
ENDIF(WIN32 AND NOT CMAKE_COMPILER_IS_GNUCC)


# create the chicken library
ADD_LIBRARY(${CHICKEN_LIB_NAME} ${CHICKEN_LIB_SOURCES})
ADD_LIBRARY(${CHICKEN_UNSAFE_LIB_NAME} ${CHICKEN_UNSAFE_LIB_SOURCES})


IF(WIN32 AND NOT CYGWIN)
  ADD_LIBRARY(${CHICKEN_GUI_LIB_NAME} ${CHICKEN_LIB_SOURCES})
ENDIF(WIN32 AND NOT CYGWIN)


# tell it to define C_BUILDING_LIBCHICKEN when building .o files that go in 
chicken_lib
SET_TARGET_PROPERTIES(${CHICKEN_LIB_NAME} PROPERTIES DEFINE_SYMBOL 
C_BUILDING_LIBCHICKEN)
# Huh? only one DEFINE_SYMBOL property allowed?
SET_TARGET_PROPERTIES(${CHICKEN_UNSAFE_LIB_NAME} PROPERTIES DEFINE_SYMBOL 
C_UNSAFE_RUNTIME DEFINE_SYMBOL C_BUILDING_LIBCHICKEN)
# add ws2_32 for windows and -lm for unix
IF(WIN32)
  TARGET_LINK_LIBRARIES(${CHICKEN_LIB_NAME} ${EXTRA_LIBS} ws2_32)
  TARGET_LINK_LIBRARIES(${CHICKEN_UNSAFE_LIB_NAME}
    ${EXTRA_LIBS} ws2_32)
  IF(NOT CYGWIN)
    TARGET_LINK_LIBRARIES(${CHICKEN_GUI_LIB_NAME}
      kernel32 user32 gdi32 ws2_32)
    SET_TARGET_PROPERTIES(${CHICKEN_GUI_LIB_NAME}
      PROPERTIES
      DEFINE_SYMBOL C_WINDOWS_GUI
      DEFINE_SYMBOL C_BUILDING_LIBCHICKEN)
  ENDIF(NOT CYGWIN)
ELSE(WIN32)
  TARGET_LINK_LIBRARIES(${CHICKEN_LIB_NAME} ${EXTRA_LIBS} m)
  TARGET_LINK_LIBRARIES(${CHICKEN_UNSAFE_LIB_NAME} ${EXTRA_LIBS} m)
ENDIF(WIN32)


# source files for chicken.exe 
SET (CHICKEN_EXE_SOURCES 
    chicken.c       support.c
    partition.c     easyffi.c
    compiler.c      optimizer.c
    batch-driver.c  c-platform.c
    c-backend.c     chicken.rc)
# create chicken executable
ADD_EXECUTABLE(chicken_exe ${CHICKEN_EXE_SOURCES})
SET_TARGET_PROPERTIES(chicken_exe PROPERTIES OUTPUT_NAME chicken)
TARGET_LINK_LIBRARIES(chicken_exe ${CHICKEN_LIB_NAME})
# get the path for chicken after it is built to be used in custom commands
GET_TARGET_PROPERTY(CHICKEN_PATH chicken_exe LOCATION)


# create `csc.scm'
#IF(WIN32 AND NOT CYGWIN)
  CONFIGURE_FILE(${Chicken_SOURCE_DIR}/csc.scm.in ${Chicken_BINARY_DIR}/csc.scm)
#ENDIF(WIN32 AND NOT CYGWIN)


MACRO(GENERATE_CHICKEN_FILE input output prologue)
  IF(${prologue})
    SET(PROLOGUE -prologue ${prologue})
  ELSE(${prologue})
    SET(PROLOGUE )
  ENDIF(${prologue})
  IF(${unsafe})
    SET(UNSAFE -unsafe)
  ELSE(${unsafe})
    SET(UNSAFE )
  ENDIF(${unsafe})
  ADD_CUSTOM_COMMAND(OUTPUT ${output}
    COMMAND ${CHICKEN_PATH}
    ARGS ${input}
    -optimize-level 2 -no-trace -quiet
    -include-path ${Chicken_SOURCE_DIR} 
    -output-file ${output}
    ${UNSAFE}
    ${PROLOGUE}
    DEPENDS ${CHICKEN_PATH}
    )
  SET_SOURCE_FILES_PROPERTIES( ${output} PROPERTIES GENERATED true)    
ENDMACRO(GENERATE_CHICKEN_FILE)


# create csi.c with chicken 
GENERATE_CHICKEN_FILE(
  ${Chicken_SOURCE_DIR}/csi.scm
  ${Chicken_BINARY_DIR}/csi.c
  ${Chicken_SOURCE_DIR}/build.scm)
ADD_EXECUTABLE(csi ${Chicken_BINARY_DIR}/csi.c)
ADD_DEPENDENCIES(csi chicken_exe)
TARGET_LINK_LIBRARIES(csi ${CHICKEN_LIB_NAME})


# create csc.c with chicken
GENERATE_CHICKEN_FILE(
  ${Chicken_BINARY_DIR}/csc.scm
  ${Chicken_BINARY_DIR}/csc.c
  0)
ADD_EXECUTABLE(csc ${Chicken_BINARY_DIR}/csc.c)
ADD_DEPENDENCIES(csc chicken_exe)
TARGET_LINK_LIBRARIES(csc ${CHICKEN_LIB_NAME})


# create chicken-profile.c with chicken
GENERATE_CHICKEN_FILE(
  ${Chicken_SOURCE_DIR}/chicken-profile.scm 
  ${Chicken_BINARY_DIR}/chicken-profile.c
  0)
ADD_EXECUTABLE(chicken-profile ${Chicken_BINARY_DIR}/chicken-profile.c)
ADD_DEPENDENCIES(chicken-profile chicken_exe)
TARGET_LINK_LIBRARIES(chicken-profile ${CHICKEN_LIB_NAME})


# create chicken-setup.c with chicken
GENERATE_CHICKEN_FILE(
  ${Chicken_SOURCE_DIR}/chicken-setup.scm 
  ${Chicken_BINARY_DIR}/chicken-setup.c
  0)
ADD_EXECUTABLE(chicken-setup ${Chicken_BINARY_DIR}/chicken-setup.c)
ADD_DEPENDENCIES(chicken-setup chicken_exe)
TARGET_LINK_LIBRARIES(chicken-setup ${CHICKEN_LIB_NAME})


# installation targets
# TODO: make chicken-config executable
INSTALL_TARGETS(/bin chicken chicken-setup csi chicken-profile csc 
chicken-config)
INSTALL_FILES(/include .h chicken chicken-config)
INSTALL_FILES(/man/man1 .1 chicken chicken-config csi csc chicken-setup 
chicken-profile)


#
# TODO: 
#
# - nsample + nursery benchmarking
# - patching of csc and chicken-config
# - patching and general use of chicken-config.h
#