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.
IF(WIN32 AND NOT CMAKE_COMPILER_IS_GNUCC)
  SET(CHICKEN_LIB_NAME libchicken)
  SET(CHICKEN_UNSAFE_LIB_NAME libuchicken)
ELSE(WIN32 AND NOT CMAKE_COMPILER_IS_GNUCC)
  SET(CHICKEN_LIB_NAME chicken)
  SET(CHICKEN_UNSAFE_LIB_NAME uchicken)
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(libchicken_gui ${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_BUIDLING_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(libchicken_gui kernel32 user32 gdi32 ws2_32)
    SET_TARGET_PROPERTIES(libchicken_gui 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)
# line to chicken_lib
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)
TARGET_LINK_LIBRARIES(csi ${CHICKEN_LIB_NAME})

# create csc.c with chicken
GENERATE_CHICKEN_FILE(
  ${Chicken_SOURCE_DIR}/csc.scm
  ${Chicken_BINARY_DIR}/csc.c
  0)
ADD_EXECUTABLE(csc ${Chicken_BINARY_DIR}/csc.c)
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)
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)
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
#