Re: [Chicken-users] Re: Win32 maintenance

[Brandon J. Van Every]

felix winkelmann wrote:

> Can you send me your newest CMakeLists.txt?
>  
Attached.  Sorry for the delay.  I wanted to check whether what I have 
is already in the source pool, and I'm not yet facile with darcs.  It 
has been a perceived barrier of tedium + some other stupid things I've 
been doing for the past few days.  Rather than delay further, here is 
what I've got presently.  I believe it works, but I haven't put it 
through testing rituals since before Xmas.  I think I gave it to you 
then also?  That's why I wanted to check if it was in the source pool, 
but it isn't.

Soon it'll probably be adviseable to give me darcs repository access for 
CMakeLists.txt, if you are comfortable with that.  If not, let me know 
what your concerns are. 


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
#