[Chicken-users] CMakeLists.txt still not in Darcs

[Brandon J. Van Every]

I just did a diff of CMakeLists.txt in Darcs against my own version of
it, which I submitted on this mailing list several weeks ago.  My
version hasn't gone into Darcs.  Perhaps this is a loose end that hasn't
been tidied up because no new tarball has been made recently - and I
haven't made any binaries for such a tarball, and I haven't documented
the build, so I'm guilty of my own laziness.  But, I don't control
Darcs, and I think it is somewhat useful for my version of
CMakeLists.txt to be committed to Darcs.  So that, for instance, I can
tell people how to retrieve the canonical version in the interim.  If
there is anything I can do to assist the source control of
CMakeLists.txt, please let me know.  Meanwhile, I attach it again here.


Cheers,
Brandon Van Every


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
#