p21read shouldn't quit for errors

If an instance has too few attributes and the missing attributes are strings, add them
Merge pull request #175 from mpictor/review/select_segfault
2012-04-14 21:08:59 -04:00 · 2012-04-14 21:08:59 -04:00 · 2012-04-12 15:34:59 -07:00 · 2012-04-12 15:34:38 -07:00 · 2012-04-09 09:07:31 -07:00 · 2012-04-08 14:50:02 -07:00
405 changed files with 660312 additions and 131539 deletions
@@ -13,6 +13,7 @@ Morrison, Christopher Sean (sean, morrison, brlcad)
 Paviot, Thomas (tpaviot)
 Pictor, Mark (mpictor)
 Thomas, Dawn (homovulgaris, madant)
+Wouters, Dave (davyw)
 Yapp, Clifford (starseeker)

 Special thanks:
@@ -38,36 +38,61 @@
 # This file contains the top level CMakeLists.txt logic for the 
 # SCL software package.

+PROJECT(SCL)
+
+# SCL version
+SET(SCL_VERSION_MAJOR 0)
+SET(SCL_VERSION_MINOR 5-dev)
+SET(SCL_VERSION ${SCL_VERSION_MAJOR}.${SCL_VERSION_MINOR})
+
+# SCL ABI version. SCL_ABI_SOVERSION should be incremented
+# for each release introducing API incompatibilities
+SET(SCL_ABI_SOVERSION 2)
+SET(SCL_ABI_VERSION ${SCL_ABI_SOVERSION}.0.0)
+
 # Minimum required version of CMake
 CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
 IF(COMMAND CMAKE_POLICY)
-    CMAKE_POLICY(SET CMP0003 NEW)
+  CMAKE_POLICY(SET CMP0003 NEW)
 ENDIF(COMMAND CMAKE_POLICY)

-# set CMake project name
-PROJECT(SCL)
+IF( NOT DEFINED SCL_BUILD_TYPE )
+  SET( SCL_BUILD_TYPE "Debug" CACHE STRING "Build type" ) # By default set debug build
+ENDIF( NOT DEFINED SCL_BUILD_TYPE )
+IF(NOT SCL_IS_SUBBUILD)
+  SET(CMAKE_BUILD_TYPE ${SCL_BUILD_TYPE} CACHE INTERNAL "Build type, immutable" FORCE )
+ELSE(NOT SCL_IS_SUBBUILD)
+  SET(CMAKE_BUILD_TYPE ${SCL_BUILD_TYPE} )
+ENDIF(NOT SCL_IS_SUBBUILD)

-if( CMAKE_BUILD_TYPE STREQUAL "" )
-  message( "Debug build - to override, rerun cmake with '-DCMAKE_BUILD_TYPE=Release'." )
-  set( CMAKE_BUILD_TYPE Debug )
-endif()
+# Define helper macro OPTION_WITH_DEFAULT
+MACRO( OPTION_WITH_DEFAULT OPTION_NAME OPTION_STRING OPTION_DEFAULT )
+  IF( NOT DEFINED ${OPTION_NAME} )
+    SET( ${OPTION_NAME} ${OPTION_DEFAULT} )
+  ENDIF( NOT DEFINED ${OPTION_NAME} )
+  OPTION( ${OPTION_NAME} "${OPTION_STRING}" ${${OPTION_NAME}} )
+ENDMACRO( OPTION_WITH_DEFAULT OPTION_NAME OPTION_STRING OPTION_DEFAULT )

 # build shared libs by default
-OPTION(BUILD_SHARED_LIBS "Build shared libraries" ON)
+OPTION_WITH_DEFAULT(SCL_BUILD_SHARED_LIBS "Build shared libs" ON )

-# build static libs by default
-OPTION(BUILD_STATIC_LIBS "Build static libraries" OFF)
+# don't build static libs by default
+OPTION_WITH_DEFAULT(SCL_BUILD_STATIC_LIBS "Build static libs" OFF)

-# Set version
-SET(SCL_VERSION_MAJOR "3")
-SET(SCL_VERSION_MINOR "2")
-SET(SCL_VERSION_PATCH "0")
-SET(SCL_VERSION "${SCL_VERSION_MAJOR}.${SCL_VERSION_MINOR}.${SCL_VERSION_PATCH}")
+OPTION_WITH_DEFAULT(SCL_PYTHON_GENERATOR "Compile fedex_python" ON)
+OPTION_WITH_DEFAULT(SCL_CPP_GENERATOR "Compile fedex_plus" ON)
+
+OPTION_WITH_DEFAULT(SCL_MEMMGR_ENABLE_CHECKS "Enable scl_memmgr's memory leak detection" OFF)
+OPTION_WITH_DEFAULT(SCL_TRACE_FPRINTF "Enable extra comments in generated code so the code's source in fedex_plus may be located" OFF)

 # CMake derives much of its functionality from modules, typically
 # stored in one directory - let CMake know where to find them.
 SET(SCL_CMAKE_DIR "${SCL_SOURCE_DIR}/cmake")
-SET(CMAKE_MODULE_PATH "${SCL_CMAKE_DIR};${CMAKE_MODULE_PATH}")
+if(NOT IS_SUBBUILD)
+  SET(CMAKE_MODULE_PATH "${SCL_CMAKE_DIR};${CMAKE_MODULE_PATH}")
+else(NOT IS_SUBBUILD)
+  SET(CMAKE_MODULE_PATH "${CMAKE_MODULE_PATH};${SCL_CMAKE_DIR}")
+endif(NOT IS_SUBBUILD)

 INCLUDE(${SCL_CMAKE_DIR}/SCL_Utils.cmake)

@@ -77,78 +102,89 @@ SET(_orig_lc_all      $ENV{LC_ALL})
 SET(_orig_lc_messages $ENV{LC_MESSAGES})
 SET(_orig_lang        $ENV{LANG})
 IF(_orig_lc_all)
-    SET(ENV{LC_ALL}      C)
+  SET(ENV{LC_ALL}      C)
 ENDIF(_orig_lc_all)
 IF(_orig_lc_messages)
-    SET(ENV{LC_MESSAGES} C)
+  SET(ENV{LC_MESSAGES} C)
 ENDIF(_orig_lc_messages)
 IF(_orig_lang)
-    SET(ENV{LANG}        C)
+  SET(ENV{LANG}        C)
 ENDIF(_orig_lang)

-# For NFS volumes, to ensure proper file creation.
-IF(NOT WIN32)
-    IF(NOT UMASK)
-        EXEC_PROGRAM(umask ARGS 022 OUTPUT_VARIABLE exec_out)
-    ELSE(NOT UMASK)
-        EXEC_PROGRAM(umask ARGS ${UMASK} OUTPUT_VARIABLE exec_out)
-    ENDIF(NOT UMASK)
-ENDIF(NOT WIN32)
+#---------------------------------------------------------------------
+# Testing option
+OPTION_WITH_DEFAULT( SCL_ENABLE_TESTING "Enable unittesting framework" OFF )
+IF(SCL_ENABLE_TESTING)
+  if( NOT DEFINED SCL_BUILD_SCHEMAS )
+    set( SCL_BUILD_SCHEMAS "ALL" ) #test all schemas, unless otherwise specified
+  endif()
+  INCLUDE(CTest)
+  ENABLE_TESTING()
+ENDIF(SCL_ENABLE_TESTING)

 #---------------------------------------------------------------------
-# The following logic is what allows binaries to run successfully in 
-# the build directory AND install directory.  Thanks to plplot for 
+# Coverage option
+OPTION_WITH_DEFAULT( SCL_ENABLE_COVERAGE "Enable code coverage test" OFF )
+IF(SCL_ENABLE_COVERAGE)
+  SET(SCL_ENABLE_TESTING ON CACHE BOOL "Testing enabled by coverage option" FORCE)
+  # build static libs, better coverage report
+  SET(SCL_BUILD_SHARED_LIBS OFF CACHE BOOL "Build shared libs" FORCE )
+  SET(SCL_BUILD_STATIC_LIBS ON CACHE BOOL "Build static libs" FORCE )
+  SET(CMAKE_CXX_FLAGS_DEBUG "-O0 -g -fprofile-arcs -ftest-coverage" CACHE STRING "Extra compile flags required by code coverage" FORCE)
+  SET(CMAKE_C_FLAGS_DEBUG "-O0 -g -fprofile-arcs -ftest-coverage" CACHE STRING "Extra compile flags required by code coverage" FORCE)
+  SET(CMAKE_MODULE_LINKER_FLAGS_DEBUG "-fprofile-arcs -ftest-coverage" CACHE STRING "Extra linker flags required by code coverage" FORCE)
+  SET(SCL_BUILD_TYPE "Debug" CACHE STRING "Build type required by testing framework" FORCE)
+ENDIF(SCL_ENABLE_COVERAGE)
+
+#---------------------------------------------------------------------
+# The following logic is what allows binaries to run successfully in
+# the build directory AND install directory.  Thanks to plplot for
 # identifying the necessity of setting CMAKE_INSTALL_NAME_DIR on OSX.
+# Documentation of these options is available at
+# http://www.cmake.org/Wiki/CMake_RPATH_handling

 # use, i.e. don't skip the full RPATH for the build tree
-SET(CMAKE_SKIP_BUILD_RPATH  FALSE)
+set(CMAKE_SKIP_BUILD_RPATH  FALSE)

 # when building, don't use the install RPATH already
 # (but later on when installing)
-SET(CMAKE_BUILD_WITH_INSTALL_RPATH FALSE)
+set(CMAKE_BUILD_WITH_INSTALL_RPATH FALSE)

 # the RPATH/INSTALL_NAME_DIR to be used when installing
 if (NOT APPLE)
-    SET(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/lib")
+  set(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/lib:\$ORIGIN/../lib")
 endif(NOT APPLE)
-SET(CMAKE_INSTALL_NAME_DIR "${CMAKE_INSTALL_PREFIX}/lib")
+# On OSX, we need to set INSTALL_NAME_DIR instead of RPATH
+# http://www.cmake.org/cmake/help/cmake-2-8-docs.html#variable:CMAKE_INSTALL_NAME_DIR
+set(CMAKE_INSTALL_NAME_DIR "${CMAKE_INSTALL_PREFIX}/lib")

-# add the automatically determined parts of the RPATH which point to 
+# add the automatically determined parts of the RPATH which point to
 # directories outside the build tree to the install RPATH
-SET(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)
-
+set(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)

 #-----------------------------------------------------------------------------
 # Output directories.
 IF(NOT CMAKE_LIBRARY_OUTPUT_DIRECTORY)
-    IF(WIN32)
-        SET(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${SCL_BINARY_DIR}/bin CACHE INTERNAL "Single output directory for building all libraries.")
-    ELSE(WIN32)
-        SET(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${SCL_BINARY_DIR}/lib CACHE INTERNAL "Single output directory for building all libraries.")
-    ENDIF(WIN32)
+  SET(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${SCL_BINARY_DIR}/lib CACHE INTERNAL "Single output directory for building all libraries.")
 ENDIF(NOT CMAKE_LIBRARY_OUTPUT_DIRECTORY)
 IF(NOT CMAKE_ARCHIVE_OUTPUT_DIRECTORY)
-    SET(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${SCL_BINARY_DIR}/lib CACHE INTERNAL "Single output directory for building all archives.")
+  SET(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${SCL_BINARY_DIR}/lib CACHE INTERNAL "Single output directory for building all archives.")
 ENDIF(NOT CMAKE_ARCHIVE_OUTPUT_DIRECTORY)
 IF(NOT CMAKE_RUNTIME_OUTPUT_DIRECTORY)
-    SET(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${SCL_BINARY_DIR}/bin CACHE INTERNAL "Single output directory for building all executables.")
+  SET(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${SCL_BINARY_DIR}/bin CACHE INTERNAL "Single output directory for building all executables.")
 ENDIF(NOT CMAKE_RUNTIME_OUTPUT_DIRECTORY)

 FOREACH(CFG_TYPE ${CMAKE_CONFIGURATION_TYPES})
-    STRING(TOUPPER "${CFG_TYPE}" CFG_TYPE)
-    IF(NOT "CMAKE_LIBRARY_OUTPUT_DIRECTORY_${CFG_TYPE}")
-        IF(WIN32)
-            SET("CMAKE_LIBRARY_OUTPUT_DIRECTORY_${CFG_TYPE}" ${SCL_BINARY_DIR}/bin CACHE INTERNAL "Single output directory for building all libraries.")
-        ELSE(WIN32)
-            SET("CMAKE_LIBRARY_OUTPUT_DIRECTORY_${CFG_TYPE}" ${SCL_BINARY_DIR}/lib CACHE INTERNAL "Single output directory for building all libraries.")
-        ENDIF(WIN32)
-    ENDIF(NOT "CMAKE_LIBRARY_OUTPUT_DIRECTORY_${CFG_TYPE}")
-    IF(NOT "CMAKE_ARCHIVE_OUTPUT_DIRECTORY_${CFG_TYPE}")
-        SET("CMAKE_ARCHIVE_OUTPUT_DIRECTORY_${CFG_TYPE}" ${SCL_BINARY_DIR}/lib CACHE INTERNAL "Single output directory for building all archives.")
-    ENDIF(NOT "CMAKE_ARCHIVE_OUTPUT_DIRECTORY_${CFG_TYPE}")
-    IF(NOT "CMAKE_RUNTIME_OUTPUT_DIRECTORY_${CFG_TYPE}")
-        SET("CMAKE_RUNTIME_OUTPUT_DIRECTORY_${CFG_TYPE}" ${SCL_BINARY_DIR}/bin CACHE INTERNAL "Single output directory for building all executables.")
-    ENDIF(NOT "CMAKE_RUNTIME_OUTPUT_DIRECTORY_${CFG_TYPE}")
+  STRING(TOUPPER "${CFG_TYPE}" CFG_TYPE)
+  IF(NOT "CMAKE_LIBRARY_OUTPUT_DIRECTORY_${CFG_TYPE}")
+    SET("CMAKE_LIBRARY_OUTPUT_DIRECTORY_${CFG_TYPE}" ${SCL_BINARY_DIR}/lib CACHE INTERNAL "Single output directory for building all libraries.")
+  ENDIF(NOT "CMAKE_LIBRARY_OUTPUT_DIRECTORY_${CFG_TYPE}")
+  IF(NOT "CMAKE_ARCHIVE_OUTPUT_DIRECTORY_${CFG_TYPE}")
+    SET("CMAKE_ARCHIVE_OUTPUT_DIRECTORY_${CFG_TYPE}" ${SCL_BINARY_DIR}/lib CACHE INTERNAL "Single output directory for building all archives.")
+  ENDIF(NOT "CMAKE_ARCHIVE_OUTPUT_DIRECTORY_${CFG_TYPE}")
+  IF(NOT "CMAKE_RUNTIME_OUTPUT_DIRECTORY_${CFG_TYPE}")
+    SET("CMAKE_RUNTIME_OUTPUT_DIRECTORY_${CFG_TYPE}" ${SCL_BINARY_DIR}/bin CACHE INTERNAL "Single output directory for building all executables.")
+  ENDIF(NOT "CMAKE_RUNTIME_OUTPUT_DIRECTORY_${CFG_TYPE}")
 ENDFOREACH()


@@ -158,81 +194,171 @@ ENDFOREACH()
 # The location in which to install SCL. Need a good Debug location 
 # for Windows.  Only do this if CMAKE_INSTALL_PREFIX hasn't been set
 # already, to try and allow parent builds (if any) some control.
-IF(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT)
-    IF(NOT WIN32)
-        IF ("${CMAKE_BUILD_TYPE}" MATCHES "Release")
-            SET(CMAKE_INSTALL_PREFIX "/usr")
-        ELSEIF ("${CMAKE_BUILD_TYPE}" MATCHES "Debug")
-            MESSAGE("setting debug output dir")
-            SET(CMAKE_INSTALL_PREFIX "${SCL_SOURCE_DIR}/../scl-install")
-        ELSE("${CMAKE_BUILD_TYPE}" MATCHES "Release")
-            SET(CMAKE_INSTALL_PREFIX "/usr/local")
-        ENDIF ("${CMAKE_BUILD_TYPE}" MATCHES "Release")
-    ENDIF(NOT WIN32)
-    SET(CMAKE_INSTALL_PREFIX ${CMAKE_INSTALL_PREFIX} CACHE STRING "SCL install prefix" FORCE)
-    SET(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT 0)
-ENDIF(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT)
+if(NOT SCL_IS_SUBBUILD)
+  IF(NOT WIN32)
+    IF (${CMAKE_BUILD_TYPE} MATCHES "Debug")
+      SET(SCL_INSTALL_PREFIX "${SCL_SOURCE_DIR}/../scl-install")
+    ELSE()
+      SET(SCL_INSTALL_PREFIX "/usr/local")
+    ENDIF()
+  ENDIF(NOT WIN32)
+  SET( SCL_INSTALL_PREFIX ${SCL_INSTALL_PREFIX} CACHE
+    PATH "Install prefix prepended to target to create install location" )
+  SET( CMAKE_INSTALL_PREFIX ${SCL_INSTALL_PREFIX} CACHE INTERNAL "Prefix prepended to install directories if target destination is not absolute, immutable" FORCE )
+endif(NOT SCL_IS_SUBBUILD)

-OPTION(SCL-BUILD_EXPRESS_ONLY "Only build express parser." OFF)
-MARK_AS_ADVANCED(SCL-BUILD_EXPRESS_ONLY)
+OPTION(SCL_BUILD_EXPRESS_ONLY "Only build express parser." OFF)
+MARK_AS_ADVANCED(SCL_BUILD_EXPRESS_ONLY)

-# Take the scl config file template and copy it to the build directory so CMake
-# scripts can append to it if need be
-configure_file(${SCL_SOURCE_DIR}/include/scl_cf_cmake.h.in ${SCL_BINARY_DIR}/include/scl_cf.h.in COPYONLY)
+# Take the scl config file template as the starting point for 
+# scl_cf.h.in - scripts may need to append to the template, so
+# it is read into memory initially.
 SET(CONFIG_H_FILE ${SCL_BINARY_DIR}/include/scl_cf.h.in)
+set(CMAKE_CURRENT_PROJECT SCL)
+define_property(GLOBAL PROPERTY SCL_CONFIG_H_CONTENTS BRIEF_DOCS "config.h.in contents" FULL_DOCS "config.h.in contents for SCL project")
+if(NOT COMMAND CONFIG_H_APPEND)
+  macro(CONFIG_H_APPEND PROJECT_NAME NEW_CONTENTS)
+    if(PROJECT_NAME)
+      get_property(${PROJECT_NAME}_CONFIG_H_CONTENTS GLOBAL PROPERTY ${PROJECT_NAME}_CONFIG_H_CONTENTS)
+      set(${PROJECT_NAME}_CONFIG_H_FILE_CONTENTS "${${PROJECT_NAME}_CONFIG_H_CONTENTS}${NEW_CONTENTS}")
+      set_property(GLOBAL PROPERTY ${PROJECT_NAME}_CONFIG_H_CONTENTS "${${PROJECT_NAME}_CONFIG_H_FILE_CONTENTS}")
+    endif(PROJECT_NAME)
+  endmacro(CONFIG_H_APPEND NEW_CONTENTS)
+endif(NOT COMMAND CONFIG_H_APPEND)
+file(READ ${SCL_SOURCE_DIR}/include/scl_cf_cmake.h.in CONFIG_H_FILE_CONTENTS)
+CONFIG_H_APPEND(SCL "${CONFIG_H_FILE_CONTENTS}")

 INCLUDE(CheckLibraryExists)
 INCLUDE(CheckIncludeFile)
 INCLUDE(CheckFunctionExists)
 INCLUDE(CheckTypeSize)
+INCLUDE(CMakePushCheckState)
+INCLUDE(CheckCXXSourceRuns)
 INCLUDE(${SCL_CMAKE_DIR}/FindLEX.cmake)
 INCLUDE(${SCL_CMAKE_DIR}/FindYACC.cmake)

 CHECK_INCLUDE_FILE(ndir.h HAVE_NDIR_H)
 CHECK_INCLUDE_FILE(stdarg.h HAVE_STDARG_H)
 CHECK_INCLUDE_FILE(sys/stat.h HAVE_SYS_STAT_H)
+CHECK_INCLUDE_FILE(sys/param.h HAVE_SYS_PARAM_H)
 CHECK_INCLUDE_FILE(sysent.h HAVE_SYSENT_H)
 CHECK_INCLUDE_FILE(unistd.h HAVE_UNISTD_H)
+CHECK_INCLUDE_FILE(dirent.h HAVE_DIRENT_H)
+CHECK_INCLUDE_FILE(stdbool.h HAVE_STDBOOL_H)
+CHECK_INCLUDE_FILE(process.h HAVE_PROCESS_H)
+CHECK_INCLUDE_FILE(io.h HAVE_IO_H)

 CHECK_FUNCTION_EXISTS(abs HAVE_ABS)
 CHECK_FUNCTION_EXISTS(memcpy HAVE_MEMCPY)
 CHECK_FUNCTION_EXISTS(memmove HAVE_MEMMOVE)
+CHECK_FUNCTION_EXISTS(getopt HAVE_GETOPT)

 CHECK_TYPE_SIZE("ssize_t" SSIZE_T)

-#set GIT_COMMIT_ID to the output of `git describe`
-find_package(Git)
-if(GIT_FOUND)
-    execute_process(COMMAND ${GIT_EXECUTABLE} describe --tags RESULT_VARIABLE res_var OUTPUT_VARIABLE GIT_COM_ID )
-    if( NOT ${res_var} EQUAL 0 )
-        set( GIT_COMMIT_ID "unknown (git failed!)")
-        message( WARNING "Git failed (not a repo?). Build will not contain git revision info." )
-    endif()
-    string( REPLACE "\n" "" GIT_COMMIT_ID ${GIT_COM_ID} )
-else()
-    set( GIT_COMMIT_ID "unknown (git not found!)")
-    message( WARNING "Git not found. Build will not contain git revision info." )
-endif()
+set( TEST_STD_THREAD "
+#include <iostream>
+#include <thread>
+void do_work() {
+        std::cout << \"thread\" << std::endl;
+}
+int main() {
+        std::thread t(do_work);
+        t.join();
+}
+" )
+cmake_push_check_state()
+  if( UNIX )
+    set( CMAKE_REQUIRED_FLAGS "-pthread -std=c++0x" )
+  else( UNIX )
+    # vars probably need set for MSVC11, embarcadero, etc
+  endif( UNIX )
+  CHECK_CXX_SOURCE_RUNS( "${TEST_STD_THREAD}" HAVE_STD_THREAD )   #quotes are *required*!
+cmake_pop_check_state()

 # Now that all the tests are done, configure the scl_cf.h file:
-configure_file(${SCL_BINARY_DIR}/include/scl_cf.h.in ${SCL_BINARY_DIR}/include/scl_cf.h)
+get_property(CONFIG_H_FILE_CONTENTS GLOBAL PROPERTY SCL_CONFIG_H_CONTENTS)
+file(WRITE ${CONFIG_H_FILE} "${CONFIG_H_FILE_CONTENTS}")
+configure_file(${CONFIG_H_FILE} ${SCL_BINARY_DIR}/include/scl_cf.h)

-add_definitions(
-    -DHAVE_CONFIG_H -Wall
-    )
+################ create scl_version_string.h, http://stackoverflow.com/questions/3780667
+# Using 'ver_string' instead of 'scl_version_string.h' is a trick to force the
+# command to always execute when the custom target is built. It works because
+# a file by that name never exists.
+configure_file(${SCL_CMAKE_DIR}/scl_version_string.cmake ${SCL_BINARY_DIR}/scl_version_string.cmake @ONLY)
+add_custom_target(version_string ALL DEPENDS ver_string )
+# creates scl_version_string.h using cmake script
+add_custom_command(OUTPUT ver_string ${CMAKE_CURRENT_BINARY_DIR}/include/scl_version_string.h
+                   COMMAND ${CMAKE_COMMAND} -DSOURCE_DIR=${SCL_SOURCE_DIR}
+                                            -DBINARY_DIR=${SCL_BINARY_DIR}
+                                            -P ${SCL_BINARY_DIR}/scl_version_string.cmake)
+# scl_version_string.h is a generated file
+set_source_files_properties(${CMAKE_CURRENT_BINARY_DIR}/include/scl_version_string.h
+  PROPERTIES GENERATED TRUE
+  HEADER_FILE_ONLY TRUE )
+################
+
+if(MSVC)
+  # add_definitions( -Wall )
+  add_definitions( -D__MSVC__ -D__WIN32__ )
+  # Disable warning for preferred usage of secure functions (example strcpy should be strcpy_s, ...)
+  add_definitions( -D_CRT_SECURE_NO_WARNINGS -D_CRT_NONSTDC_NO_WARNINGS )
+elseif(BORLAND)
+  add_definitions( -D__BORLAND__ -D__WIN32__ )
+else()
+  add_definitions( -pedantic -W -Wall -Wundef -Wfloat-equal -Wshadow -Winline -Wno-long-long )
+endif()

 include_directories(
-    ${SCL_SOURCE_DIR}/include
-    ${SCL_BINARY_DIR}/include
-    )
+  ${SCL_SOURCE_DIR}/include
+  ${SCL_BINARY_DIR}/include
+  )

+ADD_SUBDIRECTORY(src/base)
 ADD_SUBDIRECTORY(src/express)
 ADD_SUBDIRECTORY(src/exppp)
 ADD_SUBDIRECTORY(src/fedex_plus)
+ADD_SUBDIRECTORY(src/fedex_python)
 ADD_SUBDIRECTORY(src/clstepcore)
 ADD_SUBDIRECTORY(src/cleditor)
 ADD_SUBDIRECTORY(src/cldai)
 ADD_SUBDIRECTORY(src/clutils)
 ADD_SUBDIRECTORY(include)
 ADD_SUBDIRECTORY(data)
+IF(SCL_ENABLE_TESTING)
+  ADD_SUBDIRECTORY( test )
+ENDIF(SCL_ENABLE_TESTING)
 ADD_SUBDIRECTORY(doc)
+
+# this is for testing - 'make core' builds everything that isn't generated
+add_custom_target( core )
+add_dependencies( core stepdai check-express stepeditor fedex_plus )
+
+if(NOT SCL_IS_SUBBUILD)
+  ###############################################################################
+  # SCL Packaging                                                               #
+  # $make package                                                               #
+  ###############################################################################
+
+  SET(CPACK_PACKAGE_DESCRIPTION_SUMMARY "STEP Class Library")
+  SET(CPACK_SET_DESTDIR "ON")
+
+  SET(CPACK_PACKAGE_VERSION_MAJOR ${SCL_VERSION_MAJOR})
+  SET(CPACK_PACKAGE_VERSION_MINOR ${SCL_VERSION_MINOR})
+  SET(CPACK_PACKAGE_NAME SCL )
+
+  SET(CPACK_PACKAGE_CONTACT "SCL Developers <scl-dev@googlegroups.com>")
+  INCLUDE(CPack)
+
+  ########################################################################################
+  # Uninstall code                                                                       #
+  # From http://www.cmake.org/Wiki/CMake_FAQ#Can_I_do_.22make_uninstall.22_with_CMake.3F #
+  # ######################################################################################
+  configure_file(
+    "${CMAKE_CURRENT_SOURCE_DIR}/cmake/cmake_uninstall.cmake.in"
+    "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake"
+    IMMEDIATE @ONLY)
+
+  add_custom_target(uninstall
+    COMMAND ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake)
+
+endif(NOT SCL_IS_SUBBUILD)
@@ -0,0 +1,10 @@
+set(CTEST_CUSTOM_WARNING_MATCH ${CTEST_CUSTOM_WARNING_MATCH} "{standard input}:[0-9][0-9]*: WARNING: ")
+set(CTEST_CUSTOM_ERROR_MATCH ${CTEST_CUSTOM_ERROR_MATCH} "{standard input}:[0-9][0-9]*: ERROR  : ")
+
+set(CTEST_PROJECT_NAME "StepClassLibrary")
+set(CTEST_NIGHTLY_START_TIME "00:00:00 EST")
+
+set(CTEST_DROP_METHOD "http")
+set(CTEST_DROP_SITE "my.cdash.org")
+set(CTEST_DROP_LOCATION "/submit.php?project=StepClassLibrary")
+set(CTEST_DROP_SITE_CDASH TRUE)
@@ -6,7 +6,7 @@ STEP Class Library.
 These installation requires that you have the following software
 available:

- C and C++ compilers    (only gcc has been tested recently)
+- C and C++ compilers    (Tested with GCC, MSVC, Embarcadero)
 - bison, byacc, or yacc  (only bison has been tested recently)
 - flex or lex            (only flex has been tested recently)
 - CMake
@@ -21,12 +21,22 @@ Installation
 * Build system uses CMake now: configure, Makefile, and all
  autotools files have been removed, as has mkProbe.

-* To build:
-  cd scl
-  mkdir build
-  cd build
-  cmake ..
-  make
+* Building SCL from the command prompt:
+  - cd scl
+  - mkdir build
+  - cd build
+  - cmake ..
+  - make
+  - make install       #  optional
+
+* Building SCL from the GUI:
+  - Run cmake-gui, set it to build in scl/build
+  - Select the correct build file generator
+  - Press Configure
+  - Change options as necessary, configuring again afterwards
+      -  If there are errors, some options may not be visible until the error is resolved
+  - Press Generate
+  - Open the main build file using your preferred build tool

 * Build options (append to the 'cmake ..' line):
  -DBUILD_SCHEMAS="path/to/schema.exp;path/to/schema2.exp"
@@ -39,8 +49,22 @@ Installation
      otherwise, the input and output files should be identical. If
      they are not identical, either the file does not match the
      schema, or SCL generated incorrect source code.
-  -DDISABLE_P21READ=TRUE
-    - disable p21read. probably not a useful option.
+  -DBUILD_SCHEMAS=ALL
+    - Added to make use of ctest easier. If BUILD_SCHEMAS == ALL,
+      then CMake adds each *.exp file found in data/.
  -DCMAKE_BUILD_TYPE=Release
    - this causes binaries to be built without debugging information
    - without this, cmake defaults to a Debug build
+
+* Using CTest to test SCL:
+  - Read the comments in run_ctest.cmake
+  - (OPTIONAL) Create scl/../.SCL_CTEST_PREFS.cmake, and set variables
+    in it (this file is required for CDash submission to be enabled)
+  - Run tests with `ctest -S run_ctest.cmake`
+
+* Using CTest to regenerate the schema matrix on the github SCL wiki:
+  - Requires:
+     - git
+     - python
+     - a clone of the git repo for the wiki at scl/../wiki-scl
+  - run `ctest -S ctest_matrix.cmake`
@@ -1,5 +1,48 @@
-STEP Class Library  ------  https://github.com/mpictor/StepClassLibrary
+STEP Class Library  ------  http://github.com/mpictor/StepClassLibrary
 ************************************************************************
+Release 0.5 (Feb 23, 2012)
+
+New since v0.4:
+* MSVC and Embarcadero support, along with many warning fixes
+* Experimental Python support
+* Now handles most features of EXPRESS - all included schemas,
+  with the exception of AP209 CD, are parsed without error. Enums are
+  now in their own dictionary. Allow indexing on aggregates, generics,
+  and binaries. 
+* Changes to fedex_plus that improve the generated c++ - use a
+  namespace, break up large static strings, make EXPRESS multiple
+  inheritance work by not printing multiple copies of inherited members.
+  All schemas now compile without error, but there are numerous warnings.
+* Exchange files: handle all comments, fill in some missing attributes.
+* More cleanup of source code, more documentation in scl/doc
+* Special thanks to @davyw and @tpaviot for their large contributions
+  (MSVC and Python, respectively)
+************************************************************************
+Release 0.4 (Nov 13, 2011)
+
+New since v0.3:
+* Improve p21read performance by ~30%
+* Improve fedex_plus performance by ~4300% (!)
+* A variable defined in a LOCAL is not required to have a type label
+  (affected ap242,210e3,209)
+* Enums and entities are allowed to have the same names
+  (affected ap242,210e3,209)
+* Remove the SCLP23 macro
+http://github.com/mpictor/StepClassLibrary/wiki/changelog-v0.4
+************************************************************************
+
+Release 0.3 (Oct 29, 2011)
+
+What's new since v0.2?
+
+* Start using CTest
+* Add a number of schemas, update IFC2X4 to RC3, update AP235 to TC
+* Update the exchange file header schema to edition two; drop support
+  for N279 files
+* In p21read, check that the schema name for the file and library match
+* Fix bug with exchange files that contain strings ending in 'S'
+************************************************************************
+
 Release 0.2 (Oct 1, 2011)

 What's new since v0.1?
@@ -1,12 +1,10 @@
 ***********************************************************************
-Step Class Library v0.1 -- https://github.com/mpictor/StepClassLibrary
+Step Class Library v0.5 -- http://github.com/mpictor/StepClassLibrary

 * What is SCL? SCL reads ISO10303-11 EXPRESS schemas and generates
-  C++ source code that can read and write Part 21 files conforming 
-  to that schema. SCL could also work with ObjectStore, CORBA IDL, 
-  and C - but to my knowledge, that code has not been exercised in 
-  a very long time. Some of the ObjectStore code has been removed,
-  and CORBA may follow it if there is no interest.
+  C++ source code that can read and write Part 21 files conforming
+  to that schema. In addition to C++, v0.5 includes experimental
+  support for Python.
 
 * SCL is packaged along with some other tools. See 
  "THE NIST STEP TOOLSET", below. In particular, Data Probe
@@ -21,29 +19,7 @@ Step Class Library v0.1 -- https://github.com/mpictor/StepClassLibrary
 * Build system uses only CMake now: configure, Makefile, and all
  autotools files have been removed, as has mkProbe.
  
-* To build:
-  cd scl
-  mkdir build
-  cd build
-  cmake ..
-  make
-  
-* Build options (append to the 'cmake ..' line):
-  -DBUILD_SCHEMAS="path/to/schema.exp;path/to/schema2.exp" 
-    - this generates c++ for the schema, and compiles it into a
-      library. Also works with directories, as long as each dir only
-      has one express file.
-    - multiple files/directories are separated by semicolons
-    - this also builds a 'p21read' program, which reads one step file
-      and writes another. It may change whitespace or remove comments;
-      otherwise, the input and output files should be identical. If
-      they are not identical, either the file does not match the
-      schema, or SCL generated incorrect source code.
-  -DDISABLE_P21READ=TRUE
-    - disable p21read. probably not a useful option.
-  -DCMAKE_BUILD_TYPE=Release
-    - this causes binaries to be built without debugging information
-    - without this, cmake defaults to a Debug build
+* Building and testing SCL - see the INSTALL file

 ***********************************************************************

@@ -0,0 +1 @@
+0.5
@@ -151,9 +151,6 @@ IF(LEX_EXECUTABLE)
  SET(FILE_RUN_DEFINITIONS "-DYYTEXT_POINTER=1")
  CHECK_C_FILE_RUNS(${CMAKE_CURRENT_SOURCE_DIR}/cmake/test_srcs/sys_wait_test.c YYTEXT_POINTER)
  SET(FILE_RUN_DEFINITIONS)
-  IF(CONFIG_H_FILE)
-	  FILE(APPEND ${CONFIG_H_FILE} "#cmakedefine YYTEXT_POINTER 1\n")
-  ENDIF(CONFIG_H_FILE)
  

 ENDIF(LEX_EXECUTABLE)
@@ -33,15 +33,15 @@ MACRO(SCL_ADDLIB libname srcs libs)
  STRING(REGEX REPLACE " " ";" libslist1 "${libs}")
  STRING(REGEX REPLACE "-framework;" "-framework " libslist "${libslist1}")
  DLL_DEFINE(${libname})
-  IF(BUILD_SHARED_LIBS)
+  IF(SCL_BUILD_SHARED_LIBS)
 	  add_library(${libname} SHARED ${srcslist})
 	  if(NOT ${libs} MATCHES "NONE")
 		  target_link_libraries(${libname} ${libslist})
 	  endif(NOT ${libs} MATCHES "NONE")
-	  SET_TARGET_PROPERTIES(${libname} PROPERTIES VERSION ${SCL_VERSION_MAJOR}.${SCL_VERSION_MINOR} SOVERSION ${SCL_VERSION_MAJOR} )
+	  SET_TARGET_PROPERTIES(${libname} PROPERTIES VERSION ${SCL_ABI_VERSION} SOVERSION ${SCL_ABI_SOVERSION} )
 	  INSTALL(TARGETS ${libname} DESTINATION lib)
-  ENDIF(BUILD_SHARED_LIBS)
-  IF(BUILD_STATIC_LIBS AND NOT MSVC)
+  ENDIF(SCL_BUILD_SHARED_LIBS)
+  IF(SCL_BUILD_STATIC_LIBS AND NOT MSVC)
 	  add_library(${libname}-static STATIC ${srcslist})
 	  if(NOT ${libs} MATCHES "NONE")
 		  target_link_libraries(${libname}-static ${libslist})
@@ -56,7 +56,7 @@ MACRO(SCL_ADDLIB libname srcs libs)
 		  SET_TARGET_PROPERTIES(${libname}-static PROPERTIES PREFIX "lib")
 	  ENDIF(WIN32)
 	  INSTALL(TARGETS ${libname}-static DESTINATION lib)
-  ENDIF(BUILD_STATIC_LIBS AND NOT MSVC)
+  ENDIF(SCL_BUILD_STATIC_LIBS AND NOT MSVC)
  # Enable extra compiler flags if local libraries and/or global options dictate
  SET(LOCAL_COMPILE_FLAGS "")
  FOREACH(extraarg ${ARGN})
@@ -0,0 +1,22 @@
+if (NOT EXISTS "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt")
+    message(FATAL_ERROR "Cannot find install manifest: \"@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt\"")
+endif(NOT EXISTS "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt")
+
+file(READ "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt" files)
+string(REGEX REPLACE "\n" ";" files "${files}")
+list(REVERSE files)
+foreach (file ${files})
+    message(STATUS "Uninstalling \"$ENV{DESTDIR}${file}\"")
+    if (EXISTS "$ENV{DESTDIR}${file}")
+        execute_process(
+            COMMAND ${CMAKE_COMMAND} -E remove "$ENV{DESTDIR}${file}"
+            OUTPUT_VARIABLE rm_out
+            RESULT_VARIABLE rm_retval
+        )
+        if(NOT ${rm_retval} EQUAL 0)
+            message(FATAL_ERROR "Problem when removing \"$ENV{DESTDIR}${file}\"")
+        endif (NOT ${rm_retval} EQUAL 0)
+    else (EXISTS "$ENV{DESTDIR}${file}")
+        message(STATUS "File \"$ENV{DESTDIR}${file}\" does not exist.")
+    endif (EXISTS "$ENV{DESTDIR}${file}")
+endforeach(file)
@@ -0,0 +1,58 @@
+#use git for a pretty commit id
+#uses 'git describe --tags', so tags are required in the repo
+#create a tag with 'git tag <name>' and 'git push --tags'
+
+# http://stackoverflow.com/questions/3780667
+# http://www.cmake.org/pipermail/cmake/2009-February/027014.html
+
+#scl_version_string.h defines scl_version() which returns a pretty commit description and a build timestamp.
+
+set(SCL_IS_SUBBUILD "@SCL_IS_SUBBUILD@")
+
+set(VERS_FILE ${SOURCE_DIR}/SCL_VERSION.txt )
+if( EXISTS ${SOURCE_DIR}/.git )
+    find_package(Git QUIET)
+    if(GIT_FOUND)
+        execute_process(COMMAND ${GIT_EXECUTABLE} describe --tags RESULT_VARIABLE res_var OUTPUT_VARIABLE GIT_COMMIT_ID )
+        if( NOT ${res_var} EQUAL 0 )
+            file( READ ${VERS_FILE} GIT_COMMIT_ID LIMIT 255 )
+	    if(NOT SCL_IS_SUBBUILD)
+              message( WARNING "Git failed (probably no tags in repo). Build will contain revision info from ${VERS_FILE}." )
+	    endif(NOT SCL_IS_SUBBUILD)
+        endif()
+    else(GIT_FOUND)
+        file( READ ${VERS_FILE} GIT_COMMIT_ID LIMIT 255 )
+	if(NOT SCL_IS_SUBBUILD)
+          message( WARNING "Git not found. Build will contain revision info from ${VERS_FILE}." )
+	endif(NOT SCL_IS_SUBBUILD)
+    endif(GIT_FOUND)
+else()
+    file( READ ${VERS_FILE} GIT_COMMIT_ID LIMIT 255 )
+    if(NOT SCL_IS_SUBBUILD)
+      message( WARNING "Git failed ('.git' not found). Build will contain revision info from ${VERS_FILE}." )
+    endif(NOT SCL_IS_SUBBUILD)
+endif()
+
+string( REPLACE "\n" "" GIT_COMMIT_ID ${GIT_COMMIT_ID} )
+
+set( vstring "//scl_version_string.h - written by cmake. Changes will be lost!\n"
+             "#ifndef SCL_VERSION_STRING\n"
+             "#define SCL_VERSION_STRING\n\n"
+             "/*\n** Returns a string like \"test-1-g5e1fb47, built at TIME on DATE\", where test is the\n"
+             "** name of the last tagged git revision, 1 is the number of commits since that tag,\n"
+             "** 'g' is unknown, 5e1fb47 is the first 7 chars of the git sha1 commit id, and TIME\n"
+             "** and DATE are substituted by the compiler.\n*/\n\n"
+             "const char* scl_version() {\n"
+             "    return \"git commit id ${GIT_COMMIT_ID}, built at \"__TIME__\" on \"__DATE__\;\n"
+             "}\n\n"
+             "#endif\n"
+   )
+
+file(WRITE scl_version_string.h.txt ${vstring} )
+# copy the file to the final header only if the version changes
+# reduces needless rebuilds
+execute_process(COMMAND ${CMAKE_COMMAND} -E copy_if_different
+                        scl_version_string.h.txt ${BINARY_DIR}/include/scl_version_string.h)
+if(NOT SCL_IS_SUBBUILD)
+  message("-- scl_version_string.h is up-to-date.")
+endif(NOT SCL_IS_SUBBUILD)
@@ -0,0 +1,25 @@
+# run_ctest.cmake
+# `ctest -S run_ctest.cmake`
+
+set( CTEST_SOURCE_DIRECTORY . )
+set( CTEST_BINARY_DIRECTORY build_matrix )
+set( CTEST_CMAKE_GENERATOR "Unix Makefiles" )
+set( CTEST_MEMORYCHECK_COMMAND /usr/bin/valgrind )
+set( CTEST_INITIAL_CACHE "
+SITE:STRING=${CTEST_SITE}
+BUILDNAME:STRING=${CTEST_BUILD_NAME}
+SCL_ENABLE_TESTING:BOOL=ON
+SCL_BUILD_TYPE:STRING=Debug
+")
+
+
+ctest_start(matrix)
+ctest_empty_binary_directory(${CTEST_BINARY_DIRECTORY})
+ctest_configure( BUILD "${CTEST_BINARY_DIRECTORY}" OPTIONS -DSCL_ENABLE_TESTING=ON )
+ctest_build( BUILD "${CTEST_BINARY_DIRECTORY}" )
+message("running tests")
+ctest_test( BUILD "${CTEST_BINARY_DIRECTORY}" INCLUDE_LABEL "cpp_schema_....*" )
+
+message("running python script")
+execute_process( COMMAND python ../misc/wiki-scripts/update-matrix.py
+                 WORKING_DIRECTORY ${CTEST_BINARY_DIRECTORY} )
@@ -1,44 +1,18 @@
-SET(ap203_data
-  ap203/203wseds.exp
-  ap203/cube1.p21
-  ap203/cube2.p21
-  ap203/g_r_assembly1.p21
-  ap203/gasket1.p21
-  ap203/gasket2.p21
-  ap203/gasket3.p21
-  ap203/hex_prism1.p21
-  ap203/rod_aspect1.p21
-  ap203/star1.p21
-)
-INSTALL(FILES ${ap203_data} DESTINATION ${DATA_DIR}/data/ap203)

-SET(ap227_data
-  ap227/ap227.exp
-  ap227/mitre.p21
-  ap227/mitre.step.txt
-)
-INSTALL(FILES ${ap227_data} DESTINATION ${DATA_DIR}/data/ap227)
-
-SET(step_example_data
-  example/example.exp
-)
-INSTALL(FILES ${step_example_data} DESTINATION ${DATA_DIR}/data/example)
-
-
-
-SET(step_datafiles
-  pdmnet.exp
-  select.exp 
-)
-INSTALL(FILES ${step_datafiles} DESTINATION ${DATA_DIR}/data)
+#this sets a property so that the target doesn't get built by 'make' or 'make all'
+#useful when testing generation of schema code/compiling schem libs/etc
+FUNCTION( TESTABLE_TARGET target )
+    if(SCL_ENABLE_TESTING)
+        set_target_properties( ${target} PROPERTIES EXCLUDE_FROM_ALL ON )
+    endif()
+ENDFUNCTION( TESTABLE_TARGET )

 # To build one or more schemas, configure with 
-# 'cmake -DBUILD_SCHEMAS="path/to/schema.exp;path/to/schema2.exp"
+# 'cmake -DSCL_BUILD_SCHEMAS="path/to/schema.exp;path/to/schema2.exp"

 # This function runs fedex on one express file. The generated source goes in a dir 
 # in the build dir, and it is compiled into a library. A p21read executable is 
-# compiled and linked to the lib, unless DISABLE_P21READ is true. p21read is used
-# to test the lib.
+# compiled and linked to the lib. p21read is used to test the lib.
 FUNCTION(BUILD_A_SCHEMA SCHEMA_FILE)
    if( EXISTS "${CMAKE_BINARY_DIR}/${SCHEMA_FILE}" )  #try absolute path. if that fails, must already be absolute.
        set( SCHEMA_FILE "${CMAKE_BINARY_DIR}/${SCHEMA_FILE}" )
@@ -57,51 +31,101 @@ FUNCTION(BUILD_A_SCHEMA SCHEMA_FILE)
    endif()

    # read the schema name from a line like 'SCHEMA AUTOMOTIVE_DESIGN;'
-    file(STRINGS ${SCHEMA_FILE} SCHEMA_STATEMENT LIMIT_COUNT 1 REGEX "SCHEMA .*")
+    file(STRINGS ${SCHEMA_FILE} SCHEMA_STATEMENT LIMIT_COUNT 1 REGEX "^SCHEMA .*")
    string(REGEX REPLACE "^SCHEMA \(.*\)\;$" "\\1" SCHEMA_N ${SCHEMA_STATEMENT} )
-    string(TOUPPER ${SCHEMA_N} SCHEMA_NAME) #fedex_plus always uses upper case for file names
+    string(TOUPPER ${SCHEMA_N} SCHEMA_LONG_NAME) #fedex_plus always uses upper case for file names
+    get_filename_component( SCHEMA_SN ${SCHEMA_FILE} NAME )
+    string( REGEX REPLACE "\(.*\).[Ee][Xx][Pp]" "\\1" SCHEMA_SHORT_NAME ${SCHEMA_SN} )
    
-    project( sdai_${SCHEMA_NAME} )
-    message( STATUS "Generating code for ${SCHEMA_NAME}.")
-    set( SCHEMA_DIR ${CMAKE_BINARY_DIR}/${SCHEMA_NAME} )
+    project( sdai_${SCHEMA_SHORT_NAME} )
+    message( STATUS "Generating code for ${SCHEMA_SHORT_NAME}.")
+    set( SCHEMA_OUTPUT_DIR ${CMAKE_BINARY_DIR}/${SCHEMA_SHORT_NAME} )

    #the names of the files that will be generated
-    set( FEDEX_OUT ${SCHEMA_DIR}/compstructs.cc ${SCHEMA_DIR}/Sdaiclasses.h 
-                   ${SCHEMA_DIR}/schema.cc ${SCHEMA_DIR}/Sdai${SCHEMA_NAME}.cc
-                   ${SCHEMA_DIR}/schema.h ${SCHEMA_DIR}/Sdai${SCHEMA_NAME}.h
-                   ${SCHEMA_DIR}/SdaiAll.cc ${SCHEMA_DIR}/Sdai${SCHEMA_NAME}.init.cc )
+    set( FEDEX_OUT ${SCHEMA_OUTPUT_DIR}/compstructs.cc ${SCHEMA_OUTPUT_DIR}/Sdaiclasses.h
+                   ${SCHEMA_OUTPUT_DIR}/schema.cc ${SCHEMA_OUTPUT_DIR}/Sdai${SCHEMA_LONG_NAME}.cc
+                   ${SCHEMA_OUTPUT_DIR}/schema.h ${SCHEMA_OUTPUT_DIR}/Sdai${SCHEMA_LONG_NAME}.h
+                   ${SCHEMA_OUTPUT_DIR}/SdaiAll.cc ${SCHEMA_OUTPUT_DIR}/Sdai${SCHEMA_LONG_NAME}.init.cc )

    # *cannot* use include_directories() because the includes keep piling up - if building
    # multiple schemas, each one will use the include dirs from all previous schemas. Since
    # one header (schema.h) is always named the same, this will not work. only workaround
    # seems to be set_target_properties( <target> PROPERTIES COMPILE_FLAGS <flags> )
-    set( ${PROJECT_NAME}_COMPILE_FLAGS "-I${CMAKE_CURRENT_SOURCE_DIR} -I${SCL_SOURCE_DIR}/src/cldai -I${SCL_SOURCE_DIR}/src/cleditor -I${SCL_SOURCE_DIR}/src/clutils -I${SCHEMA_DIR} -I${SCL_SOURCE_DIR}/src/clstepcore -DHAVE_CONFIG_H" )
+    set( ${PROJECT_NAME}_COMPILE_FLAGS "-I${CMAKE_CURRENT_SOURCE_DIR} -I${SCL_SOURCE_DIR}/src/cldai -I${SCL_SOURCE_DIR}/src/cleditor -I${SCL_SOURCE_DIR}/src/clutils -I${SCHEMA_OUTPUT_DIR} -I${SCL_SOURCE_DIR}/src/clstepcore -I${SCL_SOURCE_DIR}/src/base" )

-    add_custom_command( OUTPUT ${SCHEMA_DIR}
-                        COMMAND cmake ARGS -E make_directory ${SCHEMA_DIR} 
-                        COMMENT "Creating ${SCHEMA_DIR} for schema ${SCHEMA_NAME}")
+    add_custom_target( generate_cpp_${SCHEMA_SHORT_NAME} SOURCES ${FEDEX_OUT} )
+    add_custom_command( OUTPUT ${SCHEMA_OUTPUT_DIR}
+                        COMMAND cmake ARGS -E make_directory ${SCHEMA_OUTPUT_DIR}
+                        COMMENT "Creating ${SCHEMA_OUTPUT_DIR} for schema ${SCHEMA_SHORT_NAME}")
    add_custom_command( OUTPUT ${FEDEX_OUT}
                        COMMAND fedex_plus ARGS ${SCHEMA_FILE}
-                        DEPENDS ${SCHEMA_FILE} ${SCHEMA_DIR}
-                        WORKING_DIRECTORY ${SCHEMA_DIR}
-                        COMMENT "Running fedex_plus for ${SCHEMA_NAME}..."
+                        DEPENDS ${SCHEMA_FILE} ${SCHEMA_OUTPUT_DIR}
+                        WORKING_DIRECTORY ${SCHEMA_OUTPUT_DIR}
+                        COMMENT "Running fedex_plus for ${SCHEMA_SHORT_NAME}..."
                        VERBATIM )
+    if(MSVC OR BORLAND)
+        add_definitions( -DSCL_SCHEMA_DLL_EXPORTS )
+        add_definitions( -DSCL_BASE_DLL_IMPORTS )
+        add_definitions( -DSCL_EXPRESS_DLL_IMPORTS )
+        add_definitions( -DSCL_UTILS_DLL_IMPORTS )
+        add_definitions( -DSCL_DAI_DLL_IMPORTS )
+        add_definitions( -DSCL_CORE_DLL_IMPORTS )
+        add_definitions( -DSCL_EDITOR_DLL_IMPORTS )
+    endif()
    add_library( ${PROJECT_NAME} SHARED ${FEDEX_OUT} )
-    target_link_libraries(${PROJECT_NAME} stepdai stepcore express stepeditor )
+    target_link_libraries(${PROJECT_NAME} stepdai stepcore express stepeditor steputils base )
+    add_dependencies( ${PROJECT_NAME} generate_cpp_${SCHEMA_SHORT_NAME} )
    set_target_properties( ${PROJECT_NAME} PROPERTIES COMPILE_FLAGS
                           ${${PROJECT_NAME}_COMPILE_FLAGS} )
-    
-    if( NOT DEFINED ${DISABLE_P21READ} )
-        add_executable( "p21read_${PROJECT_NAME}" ${SCL_SOURCE_DIR}/src/test/p21read/p21read.cc )
-        target_link_libraries( p21read_${PROJECT_NAME} ${PROJECT_NAME} )
-        set_target_properties( "p21read_${PROJECT_NAME}" PROPERTIES COMPILE_FLAGS
-                               ${${PROJECT_NAME}_COMPILE_FLAGS} )
+    if(APPLE)
+        set_target_properties(${PROJECT_NAME} PROPERTIES LINK_FLAGS "-flat_namespace -undefined suppress")
+    endif(APPLE)
+    TESTABLE_TARGET( ${PROJECT_NAME} )
+
+    add_test( NAME generate_cpp_${SCHEMA_SHORT_NAME}
+              WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
+              COMMAND ${CMAKE_COMMAND} --build .
+                                       --target generate_cpp_${SCHEMA_SHORT_NAME}
+                                       --config $<CONFIGURATION> )
+    add_test( NAME build_cpp_${PROJECT_NAME}
+              WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
+              COMMAND ${CMAKE_COMMAND} --build .
+                                       --target p21read_${PROJECT_NAME}
+                                       --config $<CONFIGURATION> )
+
+    # label the tests and set dependencies
+    set_tests_properties( generate_cpp_${SCHEMA_SHORT_NAME} PROPERTIES LABELS cpp_schema_gen )
+    set_tests_properties( build_cpp_${PROJECT_NAME} PROPERTIES DEPENDS generate_cpp_${SCHEMA_SHORT_NAME} LABELS cpp_schema_build )
+
+    if(MSVC OR BORLAND)
+        add_executable( p21read_${PROJECT_NAME} ${SCL_SOURCE_DIR}/src/test/p21read/p21read.cc ${SCL_SOURCE_DIR}/src/fedex_plus/xgetopt.cc )
+    else()
+        add_executable( p21read_${PROJECT_NAME} ${SCL_SOURCE_DIR}/src/test/p21read/p21read.cc )
    endif()
+    add_dependencies( p21read_${PROJECT_NAME} version_string )
+    target_link_libraries( p21read_${PROJECT_NAME} ${PROJECT_NAME} )
+    set_target_properties( p21read_${PROJECT_NAME} PROPERTIES COMPILE_FLAGS
+                           ${${PROJECT_NAME}_COMPILE_FLAGS} )
+    TESTABLE_TARGET( p21read_${PROJECT_NAME} )
+
+    #find all part 21 files in schema dir, add a test for each one
+    get_filename_component( SCHEMA_DIR ${SCHEMA_FILE} PATH )
+    file( GLOB_RECURSE P21_FILES ${SCHEMA_DIR}/*.stp ${SCHEMA_DIR}/*.step ${SCHEMA_DIR}/*.p21 )
+    foreach( TEST_FILE ${P21_FILES} )
+    get_filename_component( FNAME ${TEST_FILE} NAME_WE )
+        add_test( NAME read_write_cpp_${SCHEMA_SHORT_NAME}_${FNAME}
+                  WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
+                  COMMAND p21read_${PROJECT_NAME} ${TEST_FILE} )
+        set_tests_properties( read_write_cpp_${SCHEMA_SHORT_NAME}_${FNAME} PROPERTIES DEPENDS build_cpp_${PROJECT_NAME} LABELS cpp_schema_rw )
+    endforeach()

 ENDFUNCTION(BUILD_A_SCHEMA)

-if(NOT BUILD_SCHEMAS STREQUAL "" )
-  foreach( ap ${BUILD_SCHEMAS} )
-    BUILD_A_SCHEMA( ${ap} )
-  endforeach()
+if( DEFINED SCL_BUILD_SCHEMAS )
+    if( SCL_BUILD_SCHEMAS STREQUAL "ALL" )
+        file( GLOB_RECURSE SCL_BUILD_SCHEMAS ${SCL_SOURCE_DIR}/data/*.exp )
+    endif()
+    foreach( ap ${SCL_BUILD_SCHEMAS} )
+        BUILD_A_SCHEMA( ${ap} )
+    endforeach()
 endif()
@@ -0,0 +1,13 @@
+data/ directory README
+
+Layout
+------
+Each directory
+ - must contain exactly one EXPRESS schema
+     -- this schema must be useful to end users - i.e. not a schema crafted to test SCL
+ - must be named after the numeric designation of the schema *if and only if*
+   it is an IS STEP schema
+     -- examples: ap214e3, AP235, etc (case insensitive)
+     -- directories for schemas that are not STEP IS must be named differently
+ - may contain part 21 files
+     -- these files must be compatible with the schema
@@ -1,7 +1,14 @@
 SET(scl_MANS
-	man/man1/dataprobe.1 
-	man/man1/fedex.1 
-	man/man1/fedex_plus.1 
-	man/man1/mkProbe.1
+    man/man1/dataprobe.1
+    man/man1/fedex.1
+    man/man1/fedex_plus.1
+    man/man1/mkProbe.1
 )
-INSTALL(FILES ${scl_MANS} DESTINATION ${MAN_DIR}/man1)
+
+if(NOT DEFINED MAN_DIR)
+  set(MAN_DIR share/man)
+endif(NOT DEFINED MAN_DIR)
+
+IF(NOT WIN32)
+  INSTALL(FILES ${scl_MANS} DESTINATION ${CMAKE_INSTALL_PREFIX}/${MAN_DIR}/man1)
+ENDIF(NOT WIN32)
--- a/Show More
+++ b/Show More