On 12/12/05, Brandon J. Van Every <[EMAIL PROTECTED]> wrote:
> Sometimes a test is given like
>
> IF(WIN32 AND NOT CYGWIN)
>
> when really what is warranted is
>
> IF(WIN32 AND NOT CMAKE_COMPILER_IS_GNUCC)
>
Applied.
>
> Or at least, this fixes a problem in library output names. Without it,
> CMake generates liblibchicken.dll, and later stuff fails because
> libchicken.dll can't be found. I'm not entirely sure if this is due to
> MinGW's behavior, or if CMake is generating stuff erroneously, but the
> above seems reasonable. Similarly, I will hazard a guess that we really
> want:
>
> 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)
>
> but I am not actually sure of this. Is this a VC++ specific issue, or a
> non-GCC issue? If it's VC++ specific, then VC++ should be explicitly
> tested for. I'm not sure what the best test variable is for this. The
> CMake documentation is decidedly mediocre as far as documenting the test
> variables. There's a list of stuff on the CMake wiki, kinda buried amid
> other things, and doesn't seem to be complete either.
>
I think this is a non-Cygwin issue. On Mingw32 the LoadLibrary stuff
is used, since we have no dlopen wrapper (or do we?).
Attached is the current CMakeLists.txt.
cheers,
felix
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
#
_______________________________________________
Chicken-users mailing list
[email protected]
http://lists.nongnu.org/mailman/listinfo/chicken-users
