replace all references to SCL with SC in CMake files and code
This commit is contained in:
Mark Pictor
parent
dba82e5e6f
commit
5fa4b17513
211 changed files with 1724 additions and 1724 deletions
234
CMakeLists.txt
234
CMakeLists.txt
|
|
@ -32,23 +32,23 @@
|
|||
# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
# *******************************************************************
|
||||
# *** SCL's CMakeLists.txt ***
|
||||
# *** SC's CMakeLists.txt ***
|
||||
# *******************************************************************
|
||||
|
||||
# This file contains the top level CMakeLists.txt logic for the
|
||||
# SCL software package.
|
||||
# SC software package.
|
||||
|
||||
PROJECT(SCL)
|
||||
PROJECT(SC)
|
||||
|
||||
# SCL version
|
||||
SET(SCL_VERSION_MAJOR 0)
|
||||
SET(SCL_VERSION_MINOR 5-dev)
|
||||
SET(SCL_VERSION ${SCL_VERSION_MAJOR}.${SCL_VERSION_MINOR})
|
||||
# SC version
|
||||
SET(SC_VERSION_MAJOR 0)
|
||||
SET(SC_VERSION_MINOR 5-dev)
|
||||
SET(SC_VERSION ${SC_VERSION_MAJOR}.${SC_VERSION_MINOR})
|
||||
|
||||
# SCL ABI version. SCL_ABI_SOVERSION should be incremented
|
||||
# SC ABI version. SC_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)
|
||||
SET(SC_ABI_SOVERSION 2)
|
||||
SET(SC_ABI_VERSION ${SC_ABI_SOVERSION}.0.0)
|
||||
|
||||
# Minimum required version of CMake
|
||||
CMAKE_MINIMUM_REQUIRED(VERSION 2.8.7)
|
||||
|
|
@ -56,14 +56,14 @@ IF(COMMAND CMAKE_POLICY)
|
|||
CMAKE_POLICY(SET CMP0003 NEW)
|
||||
ENDIF(COMMAND CMAKE_POLICY)
|
||||
|
||||
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( NOT DEFINED SC_BUILD_TYPE )
|
||||
SET( SC_BUILD_TYPE "Debug" CACHE STRING "Build type" ) # By default set debug build
|
||||
ENDIF( NOT DEFINED SC_BUILD_TYPE )
|
||||
IF(NOT SC_IS_SUBBUILD)
|
||||
SET(CMAKE_BUILD_TYPE ${SC_BUILD_TYPE} CACHE INTERNAL "Build type, immutable" FORCE )
|
||||
ELSE(NOT SC_IS_SUBBUILD)
|
||||
SET(CMAKE_BUILD_TYPE ${SC_BUILD_TYPE} )
|
||||
ENDIF(NOT SC_IS_SUBBUILD)
|
||||
|
||||
# Define helper macro OPTION_WITH_DEFAULT
|
||||
MACRO( OPTION_WITH_DEFAULT OPTION_NAME OPTION_STRING OPTION_DEFAULT )
|
||||
|
|
@ -74,36 +74,36 @@ MACRO( OPTION_WITH_DEFAULT OPTION_NAME OPTION_STRING OPTION_DEFAULT )
|
|||
ENDMACRO( OPTION_WITH_DEFAULT OPTION_NAME OPTION_STRING OPTION_DEFAULT )
|
||||
|
||||
# build shared libs by default
|
||||
OPTION_WITH_DEFAULT(SCL_BUILD_SHARED_LIBS "Build shared libs" ON )
|
||||
OPTION_WITH_DEFAULT(SC_BUILD_SHARED_LIBS "Build shared libs" ON )
|
||||
|
||||
# don't build static libs by default
|
||||
OPTION_WITH_DEFAULT(SCL_BUILD_STATIC_LIBS "Build static libs" OFF)
|
||||
OPTION_WITH_DEFAULT(SC_BUILD_STATIC_LIBS "Build static libs" OFF)
|
||||
|
||||
OPTION_WITH_DEFAULT(SCL_PYTHON_GENERATOR "Compile fedex_python" ON)
|
||||
OPTION_WITH_DEFAULT(SCL_CPP_GENERATOR "Compile fedex_plus" ON)
|
||||
OPTION_WITH_DEFAULT(SC_PYTHON_GENERATOR "Compile fedex_python" ON)
|
||||
OPTION_WITH_DEFAULT(SC_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)
|
||||
OPTION_WITH_DEFAULT(SC_MEMMGR_ENABLE_CHECKS "Enable sc_memmgr's memory leak detection" OFF)
|
||||
OPTION_WITH_DEFAULT(SC_TRACE_FPRINTF "Enable extra comments in generated code so the code's source in fedex_plus may be located" OFF)
|
||||
|
||||
if(NOT DEFINED SC_SDAI_ADDITIONAL_EXES_SRCS )
|
||||
set( SC_SDAI_ADDITIONAL_EXES_SRCS "" CACHE STRING "Source files for additional executables to be linked with SDAI libs" )
|
||||
endif(NOT DEFINED SC_SDAI_ADDITIONAL_EXES_SRCS )
|
||||
|
||||
#this makes SCL_BUILD_SCHEMAS show up in cmake-gui
|
||||
if( NOT DEFINED SCL_BUILD_SCHEMAS )
|
||||
SET(SCL_BUILD_SCHEMAS "ALL" CACHE string "Semicolon-separated list of paths to EXPRESS schemas to be built" )
|
||||
endif( NOT DEFINED SCL_BUILD_SCHEMAS )
|
||||
#this makes SC_BUILD_SCHEMAS show up in cmake-gui
|
||||
if( NOT DEFINED SC_BUILD_SCHEMAS )
|
||||
SET(SC_BUILD_SCHEMAS "ALL" CACHE string "Semicolon-separated list of paths to EXPRESS schemas to be built" )
|
||||
endif( NOT DEFINED SC_BUILD_SCHEMAS )
|
||||
|
||||
# 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(SC_CMAKE_DIR "${SC_SOURCE_DIR}/cmake")
|
||||
if(NOT IS_SUBBUILD)
|
||||
SET(CMAKE_MODULE_PATH "${SCL_CMAKE_DIR};${CMAKE_MODULE_PATH}")
|
||||
SET(CMAKE_MODULE_PATH "${SC_CMAKE_DIR};${CMAKE_MODULE_PATH}")
|
||||
else(NOT IS_SUBBUILD)
|
||||
SET(CMAKE_MODULE_PATH "${CMAKE_MODULE_PATH};${SCL_CMAKE_DIR}")
|
||||
SET(CMAKE_MODULE_PATH "${CMAKE_MODULE_PATH};${SC_CMAKE_DIR}")
|
||||
endif(NOT IS_SUBBUILD)
|
||||
|
||||
INCLUDE(${SCL_CMAKE_DIR}/SCL_Utils.cmake)
|
||||
INCLUDE(${SC_CMAKE_DIR}/SC_Utils.cmake)
|
||||
|
||||
# Save the current LC_ALL, LC_MESSAGES, and LANG environment variables and set them
|
||||
# to "C" so things like date output are as expected
|
||||
|
|
@ -123,29 +123,29 @@ ENDIF(_orig_lang)
|
|||
|
||||
#---------------------------------------------------------------------
|
||||
# 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)
|
||||
OPTION_WITH_DEFAULT( SC_ENABLE_COVERAGE "Enable code coverage test" OFF )
|
||||
IF(SC_ENABLE_COVERAGE)
|
||||
SET(SC_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(SC_BUILD_SHARED_LIBS OFF CACHE BOOL "Build shared libs" FORCE )
|
||||
SET(SC_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)
|
||||
SET( SCL_PYTHON_GENERATOR OFF ) #won't build with static libs
|
||||
ENDIF(SCL_ENABLE_COVERAGE)
|
||||
SET(SC_BUILD_TYPE "Debug" CACHE STRING "Build type required by testing framework" FORCE)
|
||||
SET( SC_PYTHON_GENERATOR OFF ) #won't build with static libs
|
||||
ENDIF(SC_ENABLE_COVERAGE)
|
||||
|
||||
#---------------------------------------------------------------------
|
||||
# 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
|
||||
OPTION_WITH_DEFAULT( SC_ENABLE_TESTING "Enable unittesting framework" OFF )
|
||||
IF(SC_ENABLE_TESTING)
|
||||
if( NOT DEFINED SC_BUILD_SCHEMAS )
|
||||
set( SC_BUILD_SCHEMAS "ALL" ) #test all schemas, unless otherwise specified
|
||||
endif()
|
||||
INCLUDE(CTest)
|
||||
ENABLE_TESTING()
|
||||
ENDIF(SCL_ENABLE_TESTING)
|
||||
ENDIF(SC_ENABLE_TESTING)
|
||||
|
||||
#---------------------------------------------------------------------
|
||||
# The following logic is what allows binaries to run successfully in
|
||||
|
|
@ -176,25 +176,25 @@ set(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)
|
|||
#-----------------------------------------------------------------------------
|
||||
# Output directories.
|
||||
IF(NOT DEFINED CMAKE_LIBRARY_OUTPUT_DIRECTORY)
|
||||
SET(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${SCL_BINARY_DIR}/lib CACHE INTERNAL "Single output directory for building all libraries.")
|
||||
SET(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${SC_BINARY_DIR}/lib CACHE INTERNAL "Single output directory for building all libraries.")
|
||||
ENDIF(NOT DEFINED CMAKE_LIBRARY_OUTPUT_DIRECTORY)
|
||||
IF(NOT DEFINED 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 ${SC_BINARY_DIR}/lib CACHE INTERNAL "Single output directory for building all archives.")
|
||||
ENDIF(NOT DEFINED CMAKE_ARCHIVE_OUTPUT_DIRECTORY)
|
||||
IF(NOT DEFINED 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 ${SC_BINARY_DIR}/bin CACHE INTERNAL "Single output directory for building all executables.")
|
||||
ENDIF(NOT DEFINED CMAKE_RUNTIME_OUTPUT_DIRECTORY)
|
||||
|
||||
FOREACH(CFG_TYPE ${CMAKE_CONFIGURATION_TYPES})
|
||||
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.")
|
||||
SET("CMAKE_LIBRARY_OUTPUT_DIRECTORY_${CFG_TYPE}" ${SC_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.")
|
||||
SET("CMAKE_ARCHIVE_OUTPUT_DIRECTORY_${CFG_TYPE}" ${SC_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.")
|
||||
SET("CMAKE_RUNTIME_OUTPUT_DIRECTORY_${CFG_TYPE}" ${SC_BINARY_DIR}/bin CACHE INTERNAL "Single output directory for building all executables.")
|
||||
ENDIF(NOT "CMAKE_RUNTIME_OUTPUT_DIRECTORY_${CFG_TYPE}")
|
||||
ENDFOREACH()
|
||||
|
||||
|
|
@ -202,32 +202,32 @@ ENDFOREACH()
|
|||
#-----------------------------------------------------------------------------
|
||||
# Configure install locations.
|
||||
|
||||
# The location in which to install SCL. Need a good Debug location
|
||||
# The location in which to install SC. 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(NOT SCL_IS_SUBBUILD)
|
||||
if(NOT SC_IS_SUBBUILD)
|
||||
IF(NOT WIN32)
|
||||
IF (${CMAKE_BUILD_TYPE} MATCHES "Debug")
|
||||
SET(SCL_INSTALL_PREFIX "${SCL_SOURCE_DIR}/../scl-install")
|
||||
SET(SC_INSTALL_PREFIX "${SC_SOURCE_DIR}/../sc-install")
|
||||
ELSE()
|
||||
SET(SCL_INSTALL_PREFIX "/usr/local")
|
||||
SET(SC_INSTALL_PREFIX "/usr/local")
|
||||
ENDIF()
|
||||
ENDIF(NOT WIN32)
|
||||
SET( SCL_INSTALL_PREFIX ${SCL_INSTALL_PREFIX} CACHE
|
||||
SET( SC_INSTALL_PREFIX ${SC_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)
|
||||
SET( CMAKE_INSTALL_PREFIX ${SC_INSTALL_PREFIX} CACHE INTERNAL "Prefix prepended to install directories if target destination is not absolute, immutable" FORCE )
|
||||
endif(NOT SC_IS_SUBBUILD)
|
||||
|
||||
OPTION(SCL_BUILD_EXPRESS_ONLY "Only build express parser." OFF)
|
||||
MARK_AS_ADVANCED(SCL_BUILD_EXPRESS_ONLY)
|
||||
OPTION(SC_BUILD_EXPRESS_ONLY "Only build express parser." OFF)
|
||||
MARK_AS_ADVANCED(SC_BUILD_EXPRESS_ONLY)
|
||||
|
||||
# Take the scl config file template as the starting point for
|
||||
# scl_cf.h.in - scripts may need to append to the template, so
|
||||
# Take the sc config file template as the starting point for
|
||||
# sc_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(CONFIG_H_FILE ${SC_BINARY_DIR}/include/sc_cf.h.in)
|
||||
set_source_files_properties(${CONFIG_H_FILE} PROPERTIES GENERATED TRUE)
|
||||
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")
|
||||
set(CMAKE_CURRENT_PROJECT SC)
|
||||
define_property(GLOBAL PROPERTY SC_CONFIG_H_CONTENTS BRIEF_DOCS "config.h.in contents" FULL_DOCS "config.h.in contents for SC project")
|
||||
if(NOT COMMAND CONFIG_H_APPEND)
|
||||
macro(CONFIG_H_APPEND PROJECT_NAME NEW_CONTENTS)
|
||||
if(PROJECT_NAME)
|
||||
|
|
@ -237,35 +237,35 @@ if(NOT COMMAND CONFIG_H_APPEND)
|
|||
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}")
|
||||
file(READ ${SC_SOURCE_DIR}/include/sc_cf_cmake.h.in CONFIG_H_FILE_CONTENTS)
|
||||
CONFIG_H_APPEND(SC "${CONFIG_H_FILE_CONTENTS}")
|
||||
|
||||
# The Express parser uses the tools Perplex, RE2C and Lemon to generate code
|
||||
# from higher level inputs. Depending on available tools and options, the
|
||||
# SCL build can either re-generate code as part of the build, or use cached
|
||||
# SC build can either re-generate code as part of the build, or use cached
|
||||
# files that are ready for compilation.
|
||||
#
|
||||
# SCL_GENERATE_LEXER_PARSER is the "high level" control a user sets to determine
|
||||
# how the SCL build will interact (or not) with these tools. AUTO (the
|
||||
# SC_GENERATE_LEXER_PARSER is the "high level" control a user sets to determine
|
||||
# how the SC build will interact (or not) with these tools. AUTO (the
|
||||
# default) means it will search for the necessary tools, and use them only if
|
||||
# everything is found. If not, it will fall back to the cached versions. If
|
||||
# this option is set to ON and the necessary tools are not found, the
|
||||
# configure step will fail. If it is set to OFF, SCL will not even try to use
|
||||
# configure step will fail. If it is set to OFF, SC will not even try to use
|
||||
# the generators and will instead use the cached sources.
|
||||
if(NOT SCL_GENERATE_LEXER_PARSER)
|
||||
set(SCL_GENERATE_LEXER_PARSER "AUTO" CACHE STRING "Use Perplex, RE2C and Lemon to generate C source code.")
|
||||
else(NOT SCL_GENERATE_LEXER_PARSER)
|
||||
string(TOUPPER "${SCL_GENERATE_LEXER_PARSER}" SCL_GENERATE_LEXER_PARSER)
|
||||
endif(NOT SCL_GENERATE_LEXER_PARSER)
|
||||
set_property(CACHE SCL_GENERATE_LEXER_PARSER PROPERTY STRINGS AUTO ON OFF)
|
||||
if (NOT "${SCL_GENERATE_LEXER_PARSER}" STREQUAL "AUTO" AND NOT "${SCL_GENERATE_LEXER_PARSER}" STREQUAL "ON" AND NOT "${SCL_GENERATE_LEXER_PARSER}" STREQUAL "OFF")
|
||||
message(WARNING "Unknown value ${SCL_GENERATE_LEXER_PARSER} supplied for BRLCAD_WORD_SIZE - defaulting to AUTO")
|
||||
if(NOT SC_GENERATE_LEXER_PARSER)
|
||||
set(SC_GENERATE_LEXER_PARSER "AUTO" CACHE STRING "Use Perplex, RE2C and Lemon to generate C source code.")
|
||||
else(NOT SC_GENERATE_LEXER_PARSER)
|
||||
string(TOUPPER "${SC_GENERATE_LEXER_PARSER}" SC_GENERATE_LEXER_PARSER)
|
||||
endif(NOT SC_GENERATE_LEXER_PARSER)
|
||||
set_property(CACHE SC_GENERATE_LEXER_PARSER PROPERTY STRINGS AUTO ON OFF)
|
||||
if (NOT "${SC_GENERATE_LEXER_PARSER}" STREQUAL "AUTO" AND NOT "${SC_GENERATE_LEXER_PARSER}" STREQUAL "ON" AND NOT "${SC_GENERATE_LEXER_PARSER}" STREQUAL "OFF")
|
||||
message(WARNING "Unknown value ${SC_GENERATE_LEXER_PARSER} supplied for BRLCAD_WORD_SIZE - defaulting to AUTO")
|
||||
message(WARNING "Valid options are AUTO, ON and OFF")
|
||||
set(SCL_GENERATE_LEXER_PARSER "AUTO" CACHE STRING "Use Perplex, RE2C and Lemon to generate C source code.")
|
||||
endif (NOT "${SCL_GENERATE_LEXER_PARSER}" STREQUAL "AUTO" AND NOT "${SCL_GENERATE_LEXER_PARSER}" STREQUAL "ON" AND NOT "${SCL_GENERATE_LEXER_PARSER}" STREQUAL "OFF")
|
||||
set(SC_GENERATE_LEXER_PARSER "AUTO" CACHE STRING "Use Perplex, RE2C and Lemon to generate C source code.")
|
||||
endif (NOT "${SC_GENERATE_LEXER_PARSER}" STREQUAL "AUTO" AND NOT "${SC_GENERATE_LEXER_PARSER}" STREQUAL "ON" AND NOT "${SC_GENERATE_LEXER_PARSER}" STREQUAL "OFF")
|
||||
|
||||
# If the generators have not been turned off, we need to check for them
|
||||
if(NOT "${SCL_GENERATE_LEXER_PARSER}" STREQUAL "OFF")
|
||||
if(NOT "${SC_GENERATE_LEXER_PARSER}" STREQUAL "OFF")
|
||||
find_package(LEMON)
|
||||
find_package(RE2C)
|
||||
find_package(PERPLEX)
|
||||
|
|
@ -282,22 +282,22 @@ if(NOT "${SCL_GENERATE_LEXER_PARSER}" STREQUAL "OFF")
|
|||
endif(NOT "${perplex_template_fpath}" STREQUAL "${PERPLEX_TEMPLATE}")
|
||||
|
||||
if(NOT COMMAND LEMON_TARGET)
|
||||
include(${SCL_CMAKE_DIR}/LEMON_Util.cmake)
|
||||
include(${SC_CMAKE_DIR}/LEMON_Util.cmake)
|
||||
endif(NOT COMMAND LEMON_TARGET)
|
||||
if(NOT COMMAND PERPLEX_TARGET)
|
||||
include(${SCL_CMAKE_DIR}/PERPLEX_Util.cmake)
|
||||
include(${SC_CMAKE_DIR}/PERPLEX_Util.cmake)
|
||||
endif(NOT COMMAND PERPLEX_TARGET)
|
||||
set(SCL_GENERATE_LP_SOURCES 1)
|
||||
set(SC_GENERATE_LP_SOURCES 1)
|
||||
else(LEMON_EXECUTABLE AND LEMON_TEMPLATE AND PERPLEX_EXECUTABLE AND PERPLEX_TEMPLATE AND RE2C_EXECUTABLE)
|
||||
if("${SCL_GENERATE_LEXER_PARSER}" STREQUAL "ON")
|
||||
message(FATAL_ERROR "\nSCL_GENERATE_LEXER_PARSER set to ON, but one or more components of the Perplex/RE2C/Lemon toolchain were not found.\n")
|
||||
else("${SCL_GENERATE_LEXER_PARSER}" STREQUAL "ON")
|
||||
set(SCL_GENERATE_LP_SOURCES 0)
|
||||
endif("${SCL_GENERATE_LEXER_PARSER}" STREQUAL "ON")
|
||||
if("${SC_GENERATE_LEXER_PARSER}" STREQUAL "ON")
|
||||
message(FATAL_ERROR "\nSC_GENERATE_LEXER_PARSER set to ON, but one or more components of the Perplex/RE2C/Lemon toolchain were not found.\n")
|
||||
else("${SC_GENERATE_LEXER_PARSER}" STREQUAL "ON")
|
||||
set(SC_GENERATE_LP_SOURCES 0)
|
||||
endif("${SC_GENERATE_LEXER_PARSER}" STREQUAL "ON")
|
||||
endif(LEMON_EXECUTABLE AND LEMON_TEMPLATE AND PERPLEX_EXECUTABLE AND PERPLEX_TEMPLATE AND RE2C_EXECUTABLE)
|
||||
else(NOT "${SCL_GENERATE_LEXER_PARSER}" STREQUAL "OFF")
|
||||
set(SCL_GENERATE_LP_SOURCES 0)
|
||||
endif(NOT "${SCL_GENERATE_LEXER_PARSER}" STREQUAL "OFF")
|
||||
else(NOT "${SC_GENERATE_LEXER_PARSER}" STREQUAL "OFF")
|
||||
set(SC_GENERATE_LP_SOURCES 0)
|
||||
endif(NOT "${SC_GENERATE_LEXER_PARSER}" STREQUAL "OFF")
|
||||
|
||||
INCLUDE(CheckLibraryExists)
|
||||
INCLUDE(CheckIncludeFile)
|
||||
|
|
@ -344,24 +344,24 @@ cmake_push_check_state()
|
|||
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:
|
||||
get_property(CONFIG_H_FILE_CONTENTS GLOBAL PROPERTY SCL_CONFIG_H_CONTENTS)
|
||||
# Now that all the tests are done, configure the sc_cf.h file:
|
||||
get_property(CONFIG_H_FILE_CONTENTS GLOBAL PROPERTY SC_CONFIG_H_CONTENTS)
|
||||
file(WRITE ${CONFIG_H_FILE} "${CONFIG_H_FILE_CONTENTS}")
|
||||
configure_file(${CONFIG_H_FILE} ${SCL_BINARY_DIR}/include/scl_cf.h)
|
||||
configure_file(${CONFIG_H_FILE} ${SC_BINARY_DIR}/include/sc_cf.h)
|
||||
|
||||
################ 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
|
||||
################ create sc_version_string.h, http://stackoverflow.com/questions/3780667
|
||||
# Using 'ver_string' instead of 'sc_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)
|
||||
configure_file(${SC_CMAKE_DIR}/sc_version_string.cmake ${SC_BINARY_DIR}/sc_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
|
||||
# creates sc_version_string.h using cmake script
|
||||
add_custom_command(OUTPUT ver_string ${CMAKE_CURRENT_BINARY_DIR}/include/sc_version_string.h
|
||||
COMMAND ${CMAKE_COMMAND} -DSOURCE_DIR=${SC_SOURCE_DIR}
|
||||
-DBINARY_DIR=${SC_BINARY_DIR}
|
||||
-P ${SC_BINARY_DIR}/sc_version_string.cmake)
|
||||
# sc_version_string.h is a generated file
|
||||
set_source_files_properties(${CMAKE_CURRENT_BINARY_DIR}/include/sc_version_string.h
|
||||
PROPERTIES GENERATED TRUE
|
||||
HEADER_FILE_ONLY TRUE )
|
||||
################
|
||||
|
|
@ -378,8 +378,8 @@ else()
|
|||
endif()
|
||||
|
||||
include_directories(
|
||||
${SCL_SOURCE_DIR}/include
|
||||
${SCL_BINARY_DIR}/include
|
||||
${SC_SOURCE_DIR}/include
|
||||
${SC_BINARY_DIR}/include
|
||||
)
|
||||
|
||||
ADD_SUBDIRECTORY(src/base)
|
||||
|
|
@ -396,29 +396,29 @@ if(NOT WIN32)
|
|||
endif(NOT WIN32)
|
||||
ADD_SUBDIRECTORY(include)
|
||||
ADD_SUBDIRECTORY(data)
|
||||
IF(SCL_ENABLE_TESTING)
|
||||
IF(SC_ENABLE_TESTING)
|
||||
ADD_SUBDIRECTORY( test )
|
||||
ENDIF(SCL_ENABLE_TESTING)
|
||||
ENDIF(SC_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)
|
||||
if(NOT SC_IS_SUBBUILD)
|
||||
###############################################################################
|
||||
# SCL Packaging #
|
||||
# SC Packaging #
|
||||
# $make package #
|
||||
###############################################################################
|
||||
|
||||
SET(CPACK_PACKAGE_DESCRIPTION_SUMMARY "STEPcode")
|
||||
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_VERSION_MAJOR ${SC_VERSION_MAJOR})
|
||||
SET(CPACK_PACKAGE_VERSION_MINOR ${SC_VERSION_MINOR})
|
||||
SET(CPACK_PACKAGE_NAME SC )
|
||||
|
||||
SET(CPACK_PACKAGE_CONTACT "SCL Developers <scl-dev@googlegroups.com>")
|
||||
SET(CPACK_PACKAGE_CONTACT "SC Developers <scl-dev@googlegroups.com>")
|
||||
INCLUDE(CPack)
|
||||
|
||||
########################################################################################
|
||||
|
|
@ -433,4 +433,4 @@ if(NOT SCL_IS_SUBBUILD)
|
|||
add_custom_target(uninstall
|
||||
COMMAND ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake)
|
||||
|
||||
endif(NOT SCL_IS_SUBBUILD)
|
||||
endif(NOT SC_IS_SUBBUILD)
|
||||
|
|
|
|||
|
|
@ -3,12 +3,12 @@
|
|||
MACRO(DEFINE_DLL_EXPORTS libname)
|
||||
IF( MSVC OR BORLAND )
|
||||
if( ${libname} MATCHES "sdai_.*" )
|
||||
set( export "SCL_SCHEMA_DLL_EXPORTS" )
|
||||
set( export "SC_SCHEMA_DLL_EXPORTS" )
|
||||
else()
|
||||
STRING(REGEX REPLACE "lib" "" shortname "${libname}")
|
||||
STRING(REGEX REPLACE "step" "" LOWERCORE "${shortname}")
|
||||
STRING(TOUPPER ${LOWERCORE} UPPER_CORE)
|
||||
set( export "SCL_${UPPER_CORE}_DLL_EXPORTS" )
|
||||
set( export "SC_${UPPER_CORE}_DLL_EXPORTS" )
|
||||
endif()
|
||||
get_target_property(defs ${libname} COMPILE_DEFINITIONS )
|
||||
if( defs ) #if no properties, ${defs} will be defs-NOTFOUND which CMake interprets as false
|
||||
|
|
@ -31,7 +31,7 @@ MACRO( DEFINE_DLL_IMPORTS tgt libs )
|
|||
STRING(REGEX REPLACE "lib" "" shortname "${lib}")
|
||||
STRING(REGEX REPLACE "step" "" LOWERCORE "${shortname}")
|
||||
STRING(TOUPPER ${LOWERCORE} UPPER_CORE)
|
||||
list( APPEND defs "SCL_${UPPER_CORE}_DLL_IMPORTS" )
|
||||
list( APPEND defs "SC_${UPPER_CORE}_DLL_IMPORTS" )
|
||||
endforeach( lib ${libs} )
|
||||
if( DEFINED defs )
|
||||
if( defs )
|
||||
|
|
@ -47,18 +47,18 @@ ENDMACRO( DEFINE_DLL_IMPORTS tgt libs )
|
|||
# EXCLUDE_FROM_ALL cannot be set on targets that are to be installed,
|
||||
# so either test the target or install it - but not both
|
||||
MACRO(EXCLUDE_OR_INSTALL target dest arg_3 )
|
||||
if( NOT ( ( SCL_ENABLE_TESTING ) AND ( "${arg_3}" STREQUAL "TESTABLE" ) ) )
|
||||
if( NOT ( ( SC_ENABLE_TESTING ) AND ( "${arg_3}" STREQUAL "TESTABLE" ) ) )
|
||||
INSTALL(TARGETS ${target} DESTINATION ${dest})
|
||||
else( NOT ( ( SCL_ENABLE_TESTING ) AND ( "${arg_3}" STREQUAL "TESTABLE" ) ) )
|
||||
else( NOT ( ( SC_ENABLE_TESTING ) AND ( "${arg_3}" STREQUAL "TESTABLE" ) ) )
|
||||
set_target_properties( ${target} PROPERTIES EXCLUDE_FROM_ALL ON )
|
||||
endif( NOT ( ( SCL_ENABLE_TESTING ) AND ( "${arg_3}" STREQUAL "TESTABLE" ) ) )
|
||||
endif( NOT ( ( SC_ENABLE_TESTING ) AND ( "${arg_3}" STREQUAL "TESTABLE" ) ) )
|
||||
ENDMACRO(EXCLUDE_OR_INSTALL target dest arg_3 )
|
||||
|
||||
#SCL_ADDEXEC( execname "source files" "linked libs" ["TESTABLE"] ["MSVC flag" ...])
|
||||
#SC_ADDEXEC( execname "source files" "linked libs" ["TESTABLE"] ["MSVC flag" ...])
|
||||
# optional 4th argument of "TESTABLE", passed to EXCLUDE_OR_INSTALL macro
|
||||
# optional args can also be used by MSVC-specific code, but it looks like these two uses
|
||||
# will not conflict because the MSVC args must contain "STRICT"
|
||||
MACRO(SCL_ADDEXEC execname srcslist libslist)
|
||||
MACRO(SC_ADDEXEC execname srcslist libslist)
|
||||
add_executable(${execname} ${srcslist})
|
||||
target_link_libraries(${execname} ${libslist})
|
||||
DEFINE_DLL_IMPORTS(${execname} "${libslist}") #add import definitions for all libs that the executable is linked to
|
||||
|
|
@ -66,35 +66,35 @@ MACRO(SCL_ADDEXEC execname srcslist libslist)
|
|||
# Enable extra compiler flags if local executables and/or global options dictate
|
||||
SET(LOCAL_COMPILE_FLAGS "")
|
||||
FOREACH(extraarg ${ARGN})
|
||||
IF(${extraarg} MATCHES "STRICT" AND SCL-ENABLE_STRICT)
|
||||
IF(${extraarg} MATCHES "STRICT" AND SC-ENABLE_STRICT)
|
||||
SET(LOCAL_COMPILE_FLAGS "${LOCAL_COMPILE_FLAGS} ${STRICT_FLAGS}")
|
||||
ENDIF(${extraarg} MATCHES "STRICT" AND SCL-ENABLE_STRICT)
|
||||
ENDIF(${extraarg} MATCHES "STRICT" AND SC-ENABLE_STRICT)
|
||||
ENDFOREACH(extraarg ${ARGN})
|
||||
IF(LOCAL_COMPILE_FLAGS)
|
||||
SET_TARGET_PROPERTIES(${execname} PROPERTIES COMPILE_FLAGS ${LOCAL_COMPILE_FLAGS})
|
||||
ENDIF(LOCAL_COMPILE_FLAGS)
|
||||
ENDMACRO(SCL_ADDEXEC execname srcslist libslist)
|
||||
ENDMACRO(SC_ADDEXEC execname srcslist libslist)
|
||||
|
||||
#SCL_ADDLIB( libname "source files" "linked libs" ["TESTABLE"] ["MSVC flag" ...])
|
||||
#SC_ADDLIB( libname "source files" "linked libs" ["TESTABLE"] ["MSVC flag" ...])
|
||||
# optional 4th argument of "TESTABLE", passed to EXCLUDE_OR_INSTALL macro
|
||||
# optional args can also be used by MSVC-specific code, but it looks like these two uses
|
||||
# will not conflict because the MSVC args must contain "STRICT"
|
||||
MACRO(SCL_ADDLIB libname srcslist libslist)
|
||||
MACRO(SC_ADDLIB libname srcslist libslist)
|
||||
STRING(REGEX REPLACE "-framework;" "-framework " libslist "${libslist1}")
|
||||
IF(SCL_BUILD_SHARED_LIBS)
|
||||
IF(SC_BUILD_SHARED_LIBS)
|
||||
add_library(${libname} SHARED ${srcslist})
|
||||
DEFINE_DLL_EXPORTS(${libname})
|
||||
if(NOT "${libs}" MATCHES "NONE")
|
||||
target_link_libraries(${libname} ${libslist})
|
||||
DEFINE_DLL_IMPORTS(${libname} "${libslist}" )
|
||||
endif(NOT "${libs}" MATCHES "NONE")
|
||||
SET_TARGET_PROPERTIES(${libname} PROPERTIES VERSION ${SCL_ABI_VERSION} SOVERSION ${SCL_ABI_SOVERSION} )
|
||||
SET_TARGET_PROPERTIES(${libname} PROPERTIES VERSION ${SC_ABI_VERSION} SOVERSION ${SC_ABI_SOVERSION} )
|
||||
EXCLUDE_OR_INSTALL( ${libname} "lib" "${ARGV3}" )
|
||||
if(APPLE)
|
||||
set_target_properties(${libname} PROPERTIES LINK_FLAGS "-flat_namespace -undefined suppress")
|
||||
endif(APPLE)
|
||||
ENDIF(SCL_BUILD_SHARED_LIBS)
|
||||
IF(SCL_BUILD_STATIC_LIBS AND NOT MSVC)
|
||||
ENDIF(SC_BUILD_SHARED_LIBS)
|
||||
IF(SC_BUILD_STATIC_LIBS AND NOT MSVC)
|
||||
add_library(${libname}-static STATIC ${srcslist})
|
||||
DEFINE_DLL_EXPORTS(${libname}-static)
|
||||
if(NOT ${libs} MATCHES "NONE")
|
||||
|
|
@ -114,13 +114,13 @@ MACRO(SCL_ADDLIB libname srcslist libslist)
|
|||
if(APPLE)
|
||||
set_target_properties(${libname}-static PROPERTIES LINK_FLAGS "-flat_namespace -undefined suppress")
|
||||
endif(APPLE)
|
||||
ENDIF(SCL_BUILD_STATIC_LIBS AND NOT MSVC)
|
||||
ENDIF(SC_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})
|
||||
IF(${extraarg} MATCHES "STRICT" AND SCL-ENABLE_STRICT)
|
||||
IF(${extraarg} MATCHES "STRICT" AND SC-ENABLE_STRICT)
|
||||
SET(LOCAL_COMPILE_FLAGS "${LOCAL_COMPILE_FLAGS} ${STRICT_FLAGS}")
|
||||
ENDIF(${extraarg} MATCHES "STRICT" AND SCL-ENABLE_STRICT)
|
||||
ENDIF(${extraarg} MATCHES "STRICT" AND SC-ENABLE_STRICT)
|
||||
ENDFOREACH(extraarg ${ARGN})
|
||||
IF(LOCAL_COMPILE_FLAGS)
|
||||
IF(BUILD_SHARED_LIBS)
|
||||
|
|
@ -130,4 +130,4 @@ MACRO(SCL_ADDLIB libname srcslist libslist)
|
|||
SET_TARGET_PROPERTIES(${libname}-static PROPERTIES COMPILE_FLAGS ${LOCAL_COMPILE_FLAGS})
|
||||
ENDIF(BUILD_STATIC_LIBS AND NOT MSVC)
|
||||
ENDIF(LOCAL_COMPILE_FLAGS)
|
||||
ENDMACRO(SCL_ADDLIB libname srcslist libslist)
|
||||
ENDMACRO(SC_ADDLIB libname srcslist libslist)
|
||||
|
|
@ -5,54 +5,54 @@
|
|||
# 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.
|
||||
#sc_version_string.h defines sc_version() which returns a pretty commit description and a build timestamp.
|
||||
|
||||
set(SCL_IS_SUBBUILD "@SCL_IS_SUBBUILD@")
|
||||
set(SC_IS_SUBBUILD "@SC_IS_SUBBUILD@")
|
||||
|
||||
set(VERS_FILE ${SOURCE_DIR}/SCL_VERSION.txt )
|
||||
set(VERS_FILE ${SOURCE_DIR}/SC_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)
|
||||
if(NOT SC_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(NOT SC_IS_SUBBUILD)
|
||||
endif()
|
||||
else(GIT_FOUND)
|
||||
file( READ ${VERS_FILE} GIT_COMMIT_ID LIMIT 255 )
|
||||
if(NOT SCL_IS_SUBBUILD)
|
||||
if(NOT SC_IS_SUBBUILD)
|
||||
message( WARNING "Git not found. Build will contain revision info from ${VERS_FILE}." )
|
||||
endif(NOT SCL_IS_SUBBUILD)
|
||||
endif(NOT SC_IS_SUBBUILD)
|
||||
endif(GIT_FOUND)
|
||||
else()
|
||||
file( READ ${VERS_FILE} GIT_COMMIT_ID LIMIT 255 )
|
||||
if(NOT SCL_IS_SUBBUILD)
|
||||
if(NOT SC_IS_SUBBUILD)
|
||||
message( WARNING "Git failed ('.git' not found). Build will contain revision info from ${VERS_FILE}." )
|
||||
endif(NOT SCL_IS_SUBBUILD)
|
||||
endif(NOT SC_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"
|
||||
set( vstring "//sc_version_string.h - written by cmake. Changes will be lost!\n"
|
||||
"#ifndef SC_VERSION_STRING\n"
|
||||
"#define SC_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"
|
||||
"const char* sc_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} )
|
||||
file(WRITE sc_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)
|
||||
sc_version_string.h.txt ${BINARY_DIR}/include/sc_version_string.h)
|
||||
if(NOT SC_IS_SUBBUILD)
|
||||
message("-- sc_version_string.h is up-to-date.")
|
||||
endif(NOT SC_IS_SUBBUILD)
|
||||
|
|
@ -8,14 +8,14 @@ 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
|
||||
SC_ENABLE_TESTING:BOOL=ON
|
||||
SC_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_configure( BUILD "${CTEST_BINARY_DIRECTORY}" OPTIONS -DSC_ENABLE_TESTING=ON )
|
||||
ctest_build( BUILD "${CTEST_BINARY_DIRECTORY}" )
|
||||
message("running tests")
|
||||
ctest_test( BUILD "${CTEST_BINARY_DIRECTORY}" INCLUDE_LABEL "cpp_schema_....*" )
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
# To build one or more schemas, configure with
|
||||
# 'cmake -DSCL_BUILD_SCHEMAS="path/to/schema.exp;path/to/schema2.exp"
|
||||
# 'cmake -DSC_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
|
||||
|
|
@ -7,10 +7,10 @@
|
|||
FUNCTION(BUILD_A_SCHEMA SCHEMA_FILE)
|
||||
if( EXISTS "${CMAKE_BINARY_DIR}/${SCHEMA_FILE}" ) #is it a path relative to build dir?
|
||||
set( SCHEMA_FILE "${CMAKE_BINARY_DIR}/${SCHEMA_FILE}" )
|
||||
elseif( EXISTS "${SCL_SOURCE_DIR}/data/${SCHEMA_FILE}" ) # path relative to STEPcode/data?
|
||||
set( SCHEMA_FILE "${SCL_SOURCE_DIR}/data/${SCHEMA_FILE}" )
|
||||
elseif( EXISTS "${SC_SOURCE_DIR}/data/${SCHEMA_FILE}" ) # path relative to STEPcode/data?
|
||||
set( SCHEMA_FILE "${SC_SOURCE_DIR}/data/${SCHEMA_FILE}" )
|
||||
elseif( NOT EXISTS ${SCHEMA_FILE} ) # absolute path
|
||||
message( FATAL_ERROR "Cannot find ${CMAKE_BINARY_DIR}/${SCHEMA_FILE} or ${SCL_SOURCE_DIR}/data/${SCHEMA_FILE} or ${SCHEMA_FILE}" )
|
||||
message( FATAL_ERROR "Cannot find ${CMAKE_BINARY_DIR}/${SCHEMA_FILE} or ${SC_SOURCE_DIR}/data/${SCHEMA_FILE} or ${SCHEMA_FILE}" )
|
||||
endif()
|
||||
|
||||
if( IS_DIRECTORY ${SCHEMA_FILE} ) #if it is a dir, look for one .exp file inside
|
||||
|
|
@ -42,7 +42,7 @@ FUNCTION(BUILD_A_SCHEMA SCHEMA_FILE)
|
|||
# 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_OUTPUT_DIR} -I${SCL_SOURCE_DIR}/src/clstepcore -I${SCL_SOURCE_DIR}/src/base" )
|
||||
set( ${PROJECT_NAME}_COMPILE_FLAGS "-I${CMAKE_CURRENT_SOURCE_DIR} -I${SC_SOURCE_DIR}/src/cldai -I${SC_SOURCE_DIR}/src/cleditor -I${SC_SOURCE_DIR}/src/clutils -I${SCHEMA_OUTPUT_DIR} -I${SC_SOURCE_DIR}/src/clstepcore -I${SC_SOURCE_DIR}/src/base" )
|
||||
|
||||
add_custom_target( generate_cpp_${SCHEMA_SHORT_NAME} SOURCES ${FEDEX_OUT} )
|
||||
add_custom_command( OUTPUT ${SCHEMA_OUTPUT_DIR}
|
||||
|
|
@ -55,22 +55,22 @@ FUNCTION(BUILD_A_SCHEMA SCHEMA_FILE)
|
|||
COMMENT "Running fedex_plus for ${SCHEMA_SHORT_NAME}..."
|
||||
VERBATIM )
|
||||
|
||||
if( SCL_ENABLE_COVERAGE AND NOT SC_COVER_SCHEMAS )
|
||||
if( SC_ENABLE_COVERAGE AND NOT SC_COVER_SCHEMAS )
|
||||
# Coverage will always be sparse on schema libs. Compiling the libs with the -fprofile-arcs and
|
||||
# -ftest-coverage is extremely slow. We can avoid that by temporarily changing build type to release.
|
||||
set( PREV_BUILD_TYPE ${CMAKE_BUILD_TYPE} )
|
||||
set( CMAKE_BUILD_TYPE "Release" )
|
||||
endif( SCL_ENABLE_COVERAGE AND NOT SC_COVER_SCHEMAS )
|
||||
endif( SC_ENABLE_COVERAGE AND NOT SC_COVER_SCHEMAS )
|
||||
|
||||
# if testing is enabled, "TESTABLE" sets property EXCLUDE_FROM_ALL and prevents installation
|
||||
SCL_ADDLIB( ${PROJECT_NAME} "${FEDEX_OUT}" "stepdai;stepcore;express;stepeditor;steputils;base" "TESTABLE" )
|
||||
SC_ADDLIB( ${PROJECT_NAME} "${FEDEX_OUT}" "stepdai;stepcore;express;stepeditor;steputils;base" "TESTABLE" )
|
||||
add_dependencies( ${PROJECT_NAME} generate_cpp_${SCHEMA_SHORT_NAME} )
|
||||
set_target_properties( ${PROJECT_NAME} PROPERTIES COMPILE_FLAGS
|
||||
${${PROJECT_NAME}_COMPILE_FLAGS} )
|
||||
|
||||
if( SCL_ENABLE_COVERAGE AND NOT SC_COVER_SCHEMAS )
|
||||
if( SC_ENABLE_COVERAGE AND NOT SC_COVER_SCHEMAS )
|
||||
set( CMAKE_BUILD_TYPE ${PREV_BUILD_TYPE} )
|
||||
endif( SCL_ENABLE_COVERAGE AND NOT SC_COVER_SCHEMAS )
|
||||
endif( SC_ENABLE_COVERAGE AND NOT SC_COVER_SCHEMAS )
|
||||
|
||||
add_test( NAME generate_cpp_${SCHEMA_SHORT_NAME}
|
||||
WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
|
||||
|
|
@ -96,10 +96,10 @@ FUNCTION(BUILD_A_SCHEMA SCHEMA_FILE)
|
|||
set_tests_properties( build_lazy_cpp_${PROJECT_NAME} build_cpp_${PROJECT_NAME} PROPERTIES DEPENDS generate_cpp_${SCHEMA_SHORT_NAME} LABELS cpp_schema_build )
|
||||
endif(NOT WIN32)
|
||||
|
||||
SCL_ADDEXEC( p21read_${PROJECT_NAME} "${SCL_SOURCE_DIR}/src/test/p21read/p21read.cc" "${PROJECT_NAME};base" "TESTABLE" )
|
||||
if(NOT WIN32)
|
||||
SCL_ADDEXEC( lazy_${PROJECT_NAME} "${SCL_SOURCE_DIR}/src/cllazyfile/lazy_test.cc" "${PROJECT_NAME};steplazyfile;stepeditor" "TESTABLE" )
|
||||
endif(NOT WIN32)
|
||||
SC_ADDEXEC( p21read_${PROJECT_NAME} "${SC_SOURCE_DIR}/src/test/p21read/p21read.cc" "${PROJECT_NAME};base" "TESTABLE" )
|
||||
if(NOT WIN32)
|
||||
SC_ADDEXEC( lazy_${PROJECT_NAME} "${SC_SOURCE_DIR}/src/cllazyfile/lazy_test.cc" "${PROJECT_NAME};steplazyfile;stepeditor" "TESTABLE" )
|
||||
endif(NOT WIN32)
|
||||
add_dependencies( p21read_${PROJECT_NAME} version_string )
|
||||
if(NOT WIN32)
|
||||
add_dependencies( lazy_${PROJECT_NAME} version_string )
|
||||
|
|
@ -107,7 +107,7 @@ FUNCTION(BUILD_A_SCHEMA SCHEMA_FILE)
|
|||
set_target_properties( p21read_${PROJECT_NAME} PROPERTIES COMPILE_FLAGS
|
||||
${${PROJECT_NAME}_COMPILE_FLAGS} )
|
||||
if(NOT WIN32)
|
||||
set_target_properties( lazy_${PROJECT_NAME} PROPERTIES COMPILE_FLAGS "${${PROJECT_NAME}_COMPILE_FLAGS} -I${SCL_SOURCE_DIR}/src/base/judy/src" )
|
||||
set_target_properties( lazy_${PROJECT_NAME} PROPERTIES COMPILE_FLAGS "${${PROJECT_NAME}_COMPILE_FLAGS} -I${SC_SOURCE_DIR}/src/base/judy/src" )
|
||||
endif(NOT WIN32)
|
||||
|
||||
|
||||
|
|
@ -115,7 +115,7 @@ FUNCTION(BUILD_A_SCHEMA SCHEMA_FILE)
|
|||
foreach( src ${SC_SDAI_ADDITIONAL_EXES_SRCS} )
|
||||
get_filename_component( name ${src} NAME_WE )
|
||||
get_filename_component( path ${src} ABSOLUTE )
|
||||
SCL_ADDEXEC( ${name}_${PROJECT_NAME} "${src}" "${PROJECT_NAME};base" "TESTABLE" )
|
||||
SC_ADDEXEC( ${name}_${PROJECT_NAME} "${src}" "${PROJECT_NAME};base" "TESTABLE" )
|
||||
add_dependencies( ${name}_${PROJECT_NAME} version_string )
|
||||
set_target_properties( ${name}_${PROJECT_NAME} PROPERTIES COMPILE_FLAGS
|
||||
"${${PROJECT_NAME}_COMPILE_FLAGS} -I${path}" )
|
||||
|
|
@ -142,16 +142,16 @@ ENDFUNCTION(BUILD_A_SCHEMA)
|
|||
|
||||
#----------------------------------------------------------------------------------------------------
|
||||
|
||||
if( DEFINED SCL_BUILD_SCHEMAS )
|
||||
if( DEFINED SC_BUILD_SCHEMAS )
|
||||
foreach( src ${SC_SDAI_ADDITIONAL_EXES_SRCS} )
|
||||
get_filename_component( name ${src} NAME_WE )
|
||||
message( STATUS "Additional SDAI executable: ${name}" )
|
||||
endforeach( src ${SC_SDAI_ADDITIONAL_EXES_SRCS} )
|
||||
|
||||
if( SCL_BUILD_SCHEMAS STREQUAL "ALL" )
|
||||
file( GLOB_RECURSE SCL_BUILD_SCHEMAS ${SCL_SOURCE_DIR}/data/*.exp )
|
||||
if( SC_BUILD_SCHEMAS STREQUAL "ALL" )
|
||||
file( GLOB_RECURSE SC_BUILD_SCHEMAS ${SC_SOURCE_DIR}/data/*.exp )
|
||||
endif()
|
||||
foreach( ap ${SCL_BUILD_SCHEMAS} )
|
||||
foreach( ap ${SC_BUILD_SCHEMAS} )
|
||||
BUILD_A_SCHEMA( ${ap} )
|
||||
endforeach()
|
||||
endif()
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
SET(scl_MANS
|
||||
SET(sc_MANS
|
||||
man/man1/dataprobe.1
|
||||
man/man1/fedex.1
|
||||
man/man1/fedex_plus.1
|
||||
|
|
@ -10,5 +10,5 @@ if(NOT DEFINED MAN_DIR)
|
|||
endif(NOT DEFINED MAN_DIR)
|
||||
|
||||
IF(NOT WIN32)
|
||||
INSTALL(FILES ${scl_MANS} DESTINATION ${MAN_DIR}/man1)
|
||||
INSTALL(FILES ${sc_MANS} DESTINATION ${MAN_DIR}/man1)
|
||||
ENDIF(NOT WIN32)
|
||||
|
|
|
|||
|
|
@ -1,66 +1,66 @@
|
|||
#ifndef EXPPP_H
|
||||
#define EXPPP_H
|
||||
#include <scl_export.h>
|
||||
#include <sc_export.h>
|
||||
|
||||
extern SCL_EXPPP_EXPORT int exppp_nesting_indent; /* default nesting indent */
|
||||
extern SCL_EXPPP_EXPORT int exppp_continuation_indent; /* default nesting indent for */
|
||||
extern SC_EXPPP_EXPORT int exppp_nesting_indent; /* default nesting indent */
|
||||
extern SC_EXPPP_EXPORT int exppp_continuation_indent; /* default nesting indent for */
|
||||
/* continuation lines */
|
||||
extern SCL_EXPPP_EXPORT int exppp_linelength; /* leave some slop for closing */
|
||||
extern SC_EXPPP_EXPORT int exppp_linelength; /* leave some slop for closing */
|
||||
/* parens. \n is not included in */
|
||||
/* this count either */
|
||||
extern SCL_EXPPP_EXPORT bool exppp_rmpp; /* if true, create rmpp */
|
||||
extern SCL_EXPPP_EXPORT bool exppp_alphabetize; /* if true, alphabetize */
|
||||
extern SCL_EXPPP_EXPORT bool exppp_terse; /* don't describe action to stdout */
|
||||
extern SCL_EXPPP_EXPORT bool exppp_reference_info; /* if true, add commentary */
|
||||
extern SC_EXPPP_EXPORT bool exppp_rmpp; /* if true, create rmpp */
|
||||
extern SC_EXPPP_EXPORT bool exppp_alphabetize; /* if true, alphabetize */
|
||||
extern SC_EXPPP_EXPORT bool exppp_terse; /* don't describe action to stdout */
|
||||
extern SC_EXPPP_EXPORT bool exppp_reference_info; /* if true, add commentary */
|
||||
/* about where things came from */
|
||||
extern SCL_EXPPP_EXPORT bool exppp_preserve_comments; /* if true, preserve comments where */
|
||||
extern SC_EXPPP_EXPORT bool exppp_preserve_comments; /* if true, preserve comments where */
|
||||
/* possible */
|
||||
extern SCL_EXPPP_EXPORT char * exppp_output_filename; /* force output filename */
|
||||
extern SCL_EXPPP_EXPORT bool exppp_output_filename_reset; /* if true, force output filename */
|
||||
extern SC_EXPPP_EXPORT char * exppp_output_filename; /* force output filename */
|
||||
extern SC_EXPPP_EXPORT bool exppp_output_filename_reset; /* if true, force output filename */
|
||||
|
||||
SCL_EXPPP_EXPORT void EXPRESSout( Express e );
|
||||
SC_EXPPP_EXPORT void EXPRESSout( Express e );
|
||||
|
||||
SCL_EXPPP_EXPORT void ENTITYout( Entity e );
|
||||
SCL_EXPPP_EXPORT void EXPRout( Expression expr );
|
||||
SCL_EXPPP_EXPORT void FUNCout( Function f );
|
||||
SCL_EXPPP_EXPORT void PROCout( Procedure p );
|
||||
SCL_EXPPP_EXPORT void RULEout( Rule r );
|
||||
SCL_EXPPP_EXPORT char * SCHEMAout( Schema s );
|
||||
SCL_EXPPP_EXPORT void SCHEMAref_out( Schema s );
|
||||
SCL_EXPPP_EXPORT void STMTout( Statement s );
|
||||
SCL_EXPPP_EXPORT void TYPEout( Type t );
|
||||
SCL_EXPPP_EXPORT void TYPEhead_out( Type t );
|
||||
SCL_EXPPP_EXPORT void TYPEbody_out( Type t );
|
||||
SCL_EXPPP_EXPORT void WHEREout( Linked_List w );
|
||||
SC_EXPPP_EXPORT void ENTITYout( Entity e );
|
||||
SC_EXPPP_EXPORT void EXPRout( Expression expr );
|
||||
SC_EXPPP_EXPORT void FUNCout( Function f );
|
||||
SC_EXPPP_EXPORT void PROCout( Procedure p );
|
||||
SC_EXPPP_EXPORT void RULEout( Rule r );
|
||||
SC_EXPPP_EXPORT char * SCHEMAout( Schema s );
|
||||
SC_EXPPP_EXPORT void SCHEMAref_out( Schema s );
|
||||
SC_EXPPP_EXPORT void STMTout( Statement s );
|
||||
SC_EXPPP_EXPORT void TYPEout( Type t );
|
||||
SC_EXPPP_EXPORT void TYPEhead_out( Type t );
|
||||
SC_EXPPP_EXPORT void TYPEbody_out( Type t );
|
||||
SC_EXPPP_EXPORT void WHEREout( Linked_List w );
|
||||
|
||||
SCL_EXPPP_EXPORT char * REFto_string( Dictionary refdict, Linked_List reflist, char * type, int level );
|
||||
SCL_EXPPP_EXPORT char * ENTITYto_string( Entity e );
|
||||
SCL_EXPPP_EXPORT char * SUBTYPEto_string( Expression e );
|
||||
SCL_EXPPP_EXPORT char * EXPRto_string( Expression expr );
|
||||
SCL_EXPPP_EXPORT char * FUNCto_string( Function f );
|
||||
SCL_EXPPP_EXPORT char * PROCto_string( Procedure p );
|
||||
SCL_EXPPP_EXPORT char * RULEto_string( Rule r );
|
||||
SCL_EXPPP_EXPORT char * SCHEMAref_to_string( Schema s );
|
||||
SCL_EXPPP_EXPORT char * STMTto_string( Statement s );
|
||||
SCL_EXPPP_EXPORT char * TYPEto_string( Type t );
|
||||
SCL_EXPPP_EXPORT char * TYPEhead_to_string( Type t );
|
||||
SCL_EXPPP_EXPORT char * TYPEbody_to_string( Type t );
|
||||
SCL_EXPPP_EXPORT char * WHEREto_string( Linked_List w );
|
||||
SC_EXPPP_EXPORT char * REFto_string( Dictionary refdict, Linked_List reflist, char * type, int level );
|
||||
SC_EXPPP_EXPORT char * ENTITYto_string( Entity e );
|
||||
SC_EXPPP_EXPORT char * SUBTYPEto_string( Expression e );
|
||||
SC_EXPPP_EXPORT char * EXPRto_string( Expression expr );
|
||||
SC_EXPPP_EXPORT char * FUNCto_string( Function f );
|
||||
SC_EXPPP_EXPORT char * PROCto_string( Procedure p );
|
||||
SC_EXPPP_EXPORT char * RULEto_string( Rule r );
|
||||
SC_EXPPP_EXPORT char * SCHEMAref_to_string( Schema s );
|
||||
SC_EXPPP_EXPORT char * STMTto_string( Statement s );
|
||||
SC_EXPPP_EXPORT char * TYPEto_string( Type t );
|
||||
SC_EXPPP_EXPORT char * TYPEhead_to_string( Type t );
|
||||
SC_EXPPP_EXPORT char * TYPEbody_to_string( Type t );
|
||||
SC_EXPPP_EXPORT char * WHEREto_string( Linked_List w );
|
||||
|
||||
SCL_EXPPP_EXPORT int REFto_buffer( Dictionary refdict, Linked_List reflist, char * type, int level, char * buffer, int length );
|
||||
SCL_EXPPP_EXPORT int ENTITYto_buffer( Entity e, char * buffer, int length );
|
||||
SCL_EXPPP_EXPORT int EXPRto_buffer( Expression e, char * buffer, int length );
|
||||
SCL_EXPPP_EXPORT int FUNCto_buffer( Function e, char * buffer, int length );
|
||||
SCL_EXPPP_EXPORT int PROCto_buffer( Procedure e, char * buffer, int length );
|
||||
SCL_EXPPP_EXPORT int RULEto_buffer( Rule e, char * buffer, int length );
|
||||
SCL_EXPPP_EXPORT int SCHEMAref_to_buffer( Schema s, char * buffer, int length );
|
||||
SCL_EXPPP_EXPORT int STMTto_buffer( Statement s, char * buffer, int length );
|
||||
SCL_EXPPP_EXPORT int TYPEto_buffer( Type t, char * buffer, int length );
|
||||
SCL_EXPPP_EXPORT int TYPEhead_to_buffer( Type t, char * buffer, int length );
|
||||
SCL_EXPPP_EXPORT int TYPEbody_to_buffer( Type t, char * buffer, int length );
|
||||
SCL_EXPPP_EXPORT int WHEREto_buffer( Linked_List w, char * buffer, int length );
|
||||
SC_EXPPP_EXPORT int REFto_buffer( Dictionary refdict, Linked_List reflist, char * type, int level, char * buffer, int length );
|
||||
SC_EXPPP_EXPORT int ENTITYto_buffer( Entity e, char * buffer, int length );
|
||||
SC_EXPPP_EXPORT int EXPRto_buffer( Expression e, char * buffer, int length );
|
||||
SC_EXPPP_EXPORT int FUNCto_buffer( Function e, char * buffer, int length );
|
||||
SC_EXPPP_EXPORT int PROCto_buffer( Procedure e, char * buffer, int length );
|
||||
SC_EXPPP_EXPORT int RULEto_buffer( Rule e, char * buffer, int length );
|
||||
SC_EXPPP_EXPORT int SCHEMAref_to_buffer( Schema s, char * buffer, int length );
|
||||
SC_EXPPP_EXPORT int STMTto_buffer( Statement s, char * buffer, int length );
|
||||
SC_EXPPP_EXPORT int TYPEto_buffer( Type t, char * buffer, int length );
|
||||
SC_EXPPP_EXPORT int TYPEhead_to_buffer( Type t, char * buffer, int length );
|
||||
SC_EXPPP_EXPORT int TYPEbody_to_buffer( Type t, char * buffer, int length );
|
||||
SC_EXPPP_EXPORT int WHEREto_buffer( Linked_List w, char * buffer, int length );
|
||||
|
||||
SCL_EXPPP_EXPORT int EXPRlength( Expression e );
|
||||
SCL_EXPPP_EXPORT int count_newlines( char * s );
|
||||
SC_EXPPP_EXPORT int EXPRlength( Expression e );
|
||||
SC_EXPPP_EXPORT int count_newlines( char * s );
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -109,11 +109,11 @@ struct Where_ {
|
|||
/* global variables */
|
||||
/********************/
|
||||
|
||||
extern SCL_EXPRESS_EXPORT struct freelist_head ALG_fl;
|
||||
extern SCL_EXPRESS_EXPORT struct freelist_head FUNC_fl;
|
||||
extern SCL_EXPRESS_EXPORT struct freelist_head RULE_fl;
|
||||
extern SCL_EXPRESS_EXPORT struct freelist_head PROC_fl;
|
||||
extern SCL_EXPRESS_EXPORT struct freelist_head WHERE_fl;
|
||||
extern SC_EXPRESS_EXPORT struct freelist_head ALG_fl;
|
||||
extern SC_EXPRESS_EXPORT struct freelist_head FUNC_fl;
|
||||
extern SC_EXPRESS_EXPORT struct freelist_head RULE_fl;
|
||||
extern SC_EXPRESS_EXPORT struct freelist_head PROC_fl;
|
||||
extern SC_EXPRESS_EXPORT struct freelist_head WHERE_fl;
|
||||
|
||||
/******************************/
|
||||
/* macro function definitions */
|
||||
|
|
@ -161,8 +161,8 @@ extern SCL_EXPRESS_EXPORT struct freelist_head WHERE_fl;
|
|||
/* function prototypes */
|
||||
/***********************/
|
||||
|
||||
extern SCL_EXPRESS_EXPORT Scope ALGcreate PROTO( ( char ) );
|
||||
extern SCL_EXPRESS_EXPORT void ALGinitialize PROTO( ( void ) );
|
||||
extern SCL_EXPRESS_EXPORT void ALGput_full_text PROTO( ( Scope, int, int ) );
|
||||
extern SC_EXPRESS_EXPORT Scope ALGcreate PROTO( ( char ) );
|
||||
extern SC_EXPRESS_EXPORT void ALGinitialize PROTO( ( void ) );
|
||||
extern SC_EXPRESS_EXPORT void ALGput_full_text PROTO( ( Scope, int, int ) );
|
||||
|
||||
#endif /* ALGORITHM_H */
|
||||
|
|
|
|||
|
|
@ -71,8 +71,8 @@
|
|||
*
|
||||
*/
|
||||
|
||||
#include <scl_cf.h>
|
||||
#include <scl_export.h>
|
||||
#include <sc_cf.h>
|
||||
#include <sc_export.h>
|
||||
#include <stdio.h>
|
||||
|
||||
/******************************/
|
||||
|
|
@ -82,7 +82,7 @@
|
|||
#ifdef HAVE_STDBOOL_H
|
||||
# include <stdbool.h>
|
||||
#else
|
||||
# include <scl_stdbool.h>
|
||||
# include <sc_stdbool.h>
|
||||
#endif
|
||||
|
||||
/************************/
|
||||
|
|
|
|||
|
|
@ -70,7 +70,7 @@ struct Case_Item_ {
|
|||
/* global variables */
|
||||
/********************/
|
||||
|
||||
extern SCL_EXPRESS_EXPORT struct freelist_head CASE_IT_fl;
|
||||
extern SC_EXPRESS_EXPORT struct freelist_head CASE_IT_fl;
|
||||
|
||||
/******************************/
|
||||
/* macro function definitions */
|
||||
|
|
@ -86,7 +86,7 @@ extern SCL_EXPRESS_EXPORT struct freelist_head CASE_IT_fl;
|
|||
#define CASE_IT_new() (struct Case_Item_ *)MEM_new(&CASE_IT_fl)
|
||||
#define CASE_IT_destroy(x) MEM_destroy(&CASE_IT_fl,(Freelist *)(Generic)x)
|
||||
|
||||
extern SCL_EXPRESS_EXPORT Case_Item CASE_ITcreate PROTO( ( Linked_List, struct Statement_ * ) );
|
||||
extern SCL_EXPRESS_EXPORT void CASE_ITinitialize PROTO( ( void ) );
|
||||
extern SC_EXPRESS_EXPORT Case_Item CASE_ITcreate PROTO( ( Linked_List, struct Statement_ * ) );
|
||||
extern SC_EXPRESS_EXPORT void CASE_ITinitialize PROTO( ( void ) );
|
||||
|
||||
#endif /*CASE_ITEM_H*/
|
||||
|
|
|
|||
|
|
@ -72,7 +72,7 @@ typedef HashEntry DictionaryEntry;
|
|||
/* global variables */
|
||||
/********************/
|
||||
|
||||
extern SCL_EXPRESS_EXPORT char DICT_type; /**< set as a side-effect of DICT lookup routines to type of object found */
|
||||
extern SC_EXPRESS_EXPORT char DICT_type; /**< set as a side-effect of DICT lookup routines to type of object found */
|
||||
|
||||
/*******************************/
|
||||
/* macro function definitions */
|
||||
|
|
@ -97,14 +97,14 @@ extern SCL_EXPRESS_EXPORT char DICT_type; /**< set as a side-effect of DICT loo
|
|||
/* function prototypes */
|
||||
/***********************/
|
||||
|
||||
extern SCL_EXPRESS_EXPORT void DICTinitialize PROTO( ( void ) );
|
||||
extern SCL_EXPRESS_EXPORT void DICTcleanup PROTO( ( void ) );
|
||||
extern SCL_EXPRESS_EXPORT int DICTdefine PROTO( ( Dictionary, char *, Generic, Symbol *, char ) );
|
||||
extern SCL_EXPRESS_EXPORT int DICT_define PROTO( ( Dictionary, char *, Generic, Symbol *, char ) );
|
||||
extern SCL_EXPRESS_EXPORT void DICTundefine PROTO( ( Dictionary, char * ) );
|
||||
extern SCL_EXPRESS_EXPORT Generic DICTlookup PROTO( ( Dictionary, char * ) );
|
||||
extern SCL_EXPRESS_EXPORT Generic DICTlookup_symbol PROTO( ( Dictionary, char *, Symbol ** ) );
|
||||
extern SCL_EXPRESS_EXPORT Generic DICTdo PROTO( ( DictionaryEntry * ) );
|
||||
extern SCL_EXPRESS_EXPORT void DICTprint PROTO( ( Dictionary ) );
|
||||
extern SC_EXPRESS_EXPORT void DICTinitialize PROTO( ( void ) );
|
||||
extern SC_EXPRESS_EXPORT void DICTcleanup PROTO( ( void ) );
|
||||
extern SC_EXPRESS_EXPORT int DICTdefine PROTO( ( Dictionary, char *, Generic, Symbol *, char ) );
|
||||
extern SC_EXPRESS_EXPORT int DICT_define PROTO( ( Dictionary, char *, Generic, Symbol *, char ) );
|
||||
extern SC_EXPRESS_EXPORT void DICTundefine PROTO( ( Dictionary, char * ) );
|
||||
extern SC_EXPRESS_EXPORT Generic DICTlookup PROTO( ( Dictionary, char * ) );
|
||||
extern SC_EXPRESS_EXPORT Generic DICTlookup_symbol PROTO( ( Dictionary, char *, Symbol ** ) );
|
||||
extern SC_EXPRESS_EXPORT Generic DICTdo PROTO( ( DictionaryEntry * ) );
|
||||
extern SC_EXPRESS_EXPORT void DICTprint PROTO( ( Dictionary ) );
|
||||
|
||||
#endif /*DICTIONARY_H*/
|
||||
|
|
|
|||
|
|
@ -60,7 +60,7 @@
|
|||
/* packages used */
|
||||
/*****************/
|
||||
|
||||
#include <scl_export.h>
|
||||
#include <sc_export.h>
|
||||
#include "expbasic.h" /* get basic definitions */
|
||||
#include "symbol.h"
|
||||
#include "scope.h"
|
||||
|
|
@ -102,8 +102,8 @@ struct Entity_ {
|
|||
/* global variables */
|
||||
/********************/
|
||||
|
||||
extern SCL_EXPRESS_EXPORT struct freelist_head ENTITY_fl;
|
||||
extern SCL_EXPRESS_EXPORT int ENTITY_MARK;
|
||||
extern SC_EXPRESS_EXPORT struct freelist_head ENTITY_fl;
|
||||
extern SC_EXPRESS_EXPORT int ENTITY_MARK;
|
||||
|
||||
/******************************/
|
||||
/* macro function definitions */
|
||||
|
|
@ -140,19 +140,19 @@ extern SCL_EXPRESS_EXPORT int ENTITY_MARK;
|
|||
/* function prototypes */
|
||||
/***********************/
|
||||
|
||||
extern SCL_EXPRESS_EXPORT struct Scope_ * ENTITYcreate PROTO( ( struct Symbol_ * ) );
|
||||
extern SCL_EXPRESS_EXPORT void ENTITYinitialize PROTO( ( void ) );
|
||||
extern SCL_EXPRESS_EXPORT void ENTITYadd_attribute PROTO( ( struct Scope_ *, struct Variable_ * ) );
|
||||
extern SCL_EXPRESS_EXPORT struct Scope_ * ENTITYcopy PROTO( ( struct Scope_ * ) );
|
||||
extern SCL_EXPRESS_EXPORT Entity ENTITYfind_inherited_entity PROTO( ( struct Scope_ *, char *, int ) );
|
||||
extern SCL_EXPRESS_EXPORT Variable ENTITYfind_inherited_attribute PROTO( ( struct Scope_ *, char *, struct Symbol_ ** ) );
|
||||
extern SCL_EXPRESS_EXPORT Variable ENTITYresolve_attr_ref PROTO( ( Entity, Symbol *, Symbol * ) );
|
||||
extern SCL_EXPRESS_EXPORT bool ENTITYhas_immediate_supertype PROTO( ( Entity, Entity ) );
|
||||
extern SCL_EXPRESS_EXPORT Variable ENTITYget_named_attribute PROTO( ( Entity, char * ) );
|
||||
extern SCL_EXPRESS_EXPORT Linked_List ENTITYget_all_attributes PROTO( ( Entity ) );
|
||||
extern SCL_EXPRESS_EXPORT bool ENTITYhas_supertype PROTO( ( Entity, Entity ) );
|
||||
extern SCL_EXPRESS_EXPORT void ENTITYadd_instance PROTO( ( Entity, Generic ) );
|
||||
extern SCL_EXPRESS_EXPORT int ENTITYget_initial_offset PROTO( ( Entity ) );
|
||||
extern SCL_EXPRESS_EXPORT int ENTITYdeclares_variable PROTO( ( Entity, struct Variable_ * ) );
|
||||
extern SC_EXPRESS_EXPORT struct Scope_ * ENTITYcreate PROTO( ( struct Symbol_ * ) );
|
||||
extern SC_EXPRESS_EXPORT void ENTITYinitialize PROTO( ( void ) );
|
||||
extern SC_EXPRESS_EXPORT void ENTITYadd_attribute PROTO( ( struct Scope_ *, struct Variable_ * ) );
|
||||
extern SC_EXPRESS_EXPORT struct Scope_ * ENTITYcopy PROTO( ( struct Scope_ * ) );
|
||||
extern SC_EXPRESS_EXPORT Entity ENTITYfind_inherited_entity PROTO( ( struct Scope_ *, char *, int ) );
|
||||
extern SC_EXPRESS_EXPORT Variable ENTITYfind_inherited_attribute PROTO( ( struct Scope_ *, char *, struct Symbol_ ** ) );
|
||||
extern SC_EXPRESS_EXPORT Variable ENTITYresolve_attr_ref PROTO( ( Entity, Symbol *, Symbol * ) );
|
||||
extern SC_EXPRESS_EXPORT bool ENTITYhas_immediate_supertype PROTO( ( Entity, Entity ) );
|
||||
extern SC_EXPRESS_EXPORT Variable ENTITYget_named_attribute PROTO( ( Entity, char * ) );
|
||||
extern SC_EXPRESS_EXPORT Linked_List ENTITYget_all_attributes PROTO( ( Entity ) );
|
||||
extern SC_EXPRESS_EXPORT bool ENTITYhas_supertype PROTO( ( Entity, Entity ) );
|
||||
extern SC_EXPRESS_EXPORT void ENTITYadd_instance PROTO( ( Entity, Generic ) );
|
||||
extern SC_EXPRESS_EXPORT int ENTITYget_initial_offset PROTO( ( Entity ) );
|
||||
extern SC_EXPRESS_EXPORT int ENTITYdeclares_variable PROTO( ( Entity, struct Variable_ * ) );
|
||||
|
||||
#endif /* ENTITY_H */
|
||||
|
|
|
|||
|
|
@ -28,7 +28,7 @@
|
|||
* prettied up interface to print_objects_when_running
|
||||
*/
|
||||
|
||||
#include <scl_export.h>
|
||||
#include <sc_export.h>
|
||||
#include "basic.h" /* get basic definitions */
|
||||
#include <setjmp.h>
|
||||
|
||||
|
|
@ -81,29 +81,29 @@ typedef struct Error_Warning_ {
|
|||
/* global variables */
|
||||
/********************/
|
||||
|
||||
extern SCL_EXPRESS_EXPORT bool __ERROR_buffer_errors;
|
||||
extern SCL_EXPRESS_EXPORT char * current_filename;
|
||||
extern SC_EXPRESS_EXPORT bool __ERROR_buffer_errors;
|
||||
extern SC_EXPRESS_EXPORT char * current_filename;
|
||||
|
||||
/* flag to remember whether non-warning errors have occurred */
|
||||
extern SCL_EXPRESS_EXPORT bool ERRORoccurred;
|
||||
extern SC_EXPRESS_EXPORT bool ERRORoccurred;
|
||||
|
||||
|
||||
extern SCL_EXPRESS_EXPORT Error experrc;
|
||||
extern SCL_EXPRESS_EXPORT Error ERROR_subordinate_failed;
|
||||
extern SCL_EXPRESS_EXPORT Error ERROR_syntax_expecting;
|
||||
extern SC_EXPRESS_EXPORT Error experrc;
|
||||
extern SC_EXPRESS_EXPORT Error ERROR_subordinate_failed;
|
||||
extern SC_EXPRESS_EXPORT Error ERROR_syntax_expecting;
|
||||
|
||||
/* all of these are 1 if true, 0 if false switches */
|
||||
/* for debugging fedex */
|
||||
extern SCL_EXPRESS_EXPORT int ERRORdebugging;
|
||||
extern SC_EXPRESS_EXPORT int ERRORdebugging;
|
||||
/* for debugging malloc during resolution */
|
||||
extern SCL_EXPRESS_EXPORT int malloc_debug_resolve;
|
||||
extern SC_EXPRESS_EXPORT int malloc_debug_resolve;
|
||||
/* for debugging yacc/lex */
|
||||
extern SCL_EXPRESS_EXPORT int debug;
|
||||
extern SC_EXPRESS_EXPORT int debug;
|
||||
|
||||
extern SCL_EXPRESS_EXPORT struct Linked_List_ * ERRORwarnings;
|
||||
extern SCL_EXPRESS_EXPORT struct freelist_head ERROR_OPT_fl;
|
||||
extern SC_EXPRESS_EXPORT struct Linked_List_ * ERRORwarnings;
|
||||
extern SC_EXPRESS_EXPORT struct freelist_head ERROR_OPT_fl;
|
||||
|
||||
extern SCL_EXPRESS_EXPORT void ( *ERRORusage_function )( void );
|
||||
extern SC_EXPRESS_EXPORT void ( *ERRORusage_function )( void );
|
||||
|
||||
/******************************/
|
||||
/* macro function definitions */
|
||||
|
|
@ -117,8 +117,8 @@ extern SCL_EXPRESS_EXPORT void ( *ERRORusage_function )( void );
|
|||
/***********************/
|
||||
|
||||
#if defined(__MSVC__) || defined(__BORLAND__)
|
||||
extern SCL_EXPRESS_EXPORT void ERROR_start_message_buffer PROTO( ( void ) );
|
||||
extern SCL_EXPRESS_EXPORT void ERROR_flush_message_buffer PROTO( ( void ) );
|
||||
extern SC_EXPRESS_EXPORT void ERROR_start_message_buffer PROTO( ( void ) );
|
||||
extern SC_EXPRESS_EXPORT void ERROR_flush_message_buffer PROTO( ( void ) );
|
||||
#endif
|
||||
|
||||
/********************/
|
||||
|
|
@ -170,28 +170,28 @@ static_inline void ERRORflush_messages( void ) {
|
|||
/* function prototypes */
|
||||
/***********************/
|
||||
|
||||
extern SCL_EXPRESS_EXPORT void ERRORinitialize PROTO( ( void ) );
|
||||
extern SCL_EXPRESS_EXPORT void ERRORinitialize_after_LIST PROTO( ( void ) );
|
||||
extern SCL_EXPRESS_EXPORT void ERRORcleanup PROTO( ( void ) );
|
||||
extern SCL_EXPRESS_EXPORT void ERRORnospace PROTO( ( void ) );
|
||||
extern SCL_EXPRESS_EXPORT void ERRORabort PROTO( ( int ) );
|
||||
extern SCL_EXPRESS_EXPORT Error ERRORcreate PROTO( ( char *, Severity ) );
|
||||
extern SCL_EXPRESS_EXPORT void ERRORreport PROTO( ( Error, ... ) );
|
||||
extern SCL_EXPRESS_EXPORT void ERRORdestroy PROTO( ( Error ) );
|
||||
extern SC_EXPRESS_EXPORT void ERRORinitialize PROTO( ( void ) );
|
||||
extern SC_EXPRESS_EXPORT void ERRORinitialize_after_LIST PROTO( ( void ) );
|
||||
extern SC_EXPRESS_EXPORT void ERRORcleanup PROTO( ( void ) );
|
||||
extern SC_EXPRESS_EXPORT void ERRORnospace PROTO( ( void ) );
|
||||
extern SC_EXPRESS_EXPORT void ERRORabort PROTO( ( int ) );
|
||||
extern SC_EXPRESS_EXPORT Error ERRORcreate PROTO( ( char *, Severity ) );
|
||||
extern SC_EXPRESS_EXPORT void ERRORreport PROTO( ( Error, ... ) );
|
||||
extern SC_EXPRESS_EXPORT void ERRORdestroy PROTO( ( Error ) );
|
||||
|
||||
struct Symbol_; /* mention Symbol to avoid warning on following line */
|
||||
extern SCL_EXPRESS_EXPORT void ERRORreport_with_symbol PROTO( ( Error, struct Symbol_ *, ... ) );
|
||||
extern SCL_EXPRESS_EXPORT void ERRORreport_with_line PROTO( ( Error, int, ... ) );
|
||||
extern SC_EXPRESS_EXPORT void ERRORreport_with_symbol PROTO( ( Error, struct Symbol_ *, ... ) );
|
||||
extern SC_EXPRESS_EXPORT void ERRORreport_with_line PROTO( ( Error, int, ... ) );
|
||||
|
||||
#if !defined(__MSVC__) && !defined(__BORLAND__)
|
||||
extern SCL_EXPRESS_EXPORT void ERROR_start_message_buffer PROTO( ( void ) );
|
||||
extern SCL_EXPRESS_EXPORT void ERROR_flush_message_buffer PROTO( ( void ) );
|
||||
extern SC_EXPRESS_EXPORT void ERROR_start_message_buffer PROTO( ( void ) );
|
||||
extern SC_EXPRESS_EXPORT void ERROR_flush_message_buffer PROTO( ( void ) );
|
||||
#endif
|
||||
|
||||
extern SCL_EXPRESS_EXPORT void ERRORcreate_warning PROTO( ( char *, Error ) );
|
||||
extern SCL_EXPRESS_EXPORT void ERRORset_warning PROTO( ( char *, int ) );
|
||||
extern SCL_EXPRESS_EXPORT void ERRORset_all_warnings PROTO( ( int ) );
|
||||
extern SCL_EXPRESS_EXPORT void ERRORsafe PROTO( ( jmp_buf env ) );
|
||||
extern SCL_EXPRESS_EXPORT void ERRORunsafe PROTO( ( void ) );
|
||||
extern SC_EXPRESS_EXPORT void ERRORcreate_warning PROTO( ( char *, Error ) );
|
||||
extern SC_EXPRESS_EXPORT void ERRORset_warning PROTO( ( char *, int ) );
|
||||
extern SC_EXPRESS_EXPORT void ERRORset_all_warnings PROTO( ( int ) );
|
||||
extern SC_EXPRESS_EXPORT void ERRORsafe PROTO( ( jmp_buf env ) );
|
||||
extern SC_EXPRESS_EXPORT void ERRORunsafe PROTO( ( void ) );
|
||||
|
||||
#endif /* ERROR_H */
|
||||
|
|
|
|||
|
|
@ -60,7 +60,7 @@
|
|||
/* packages used */
|
||||
/*****************/
|
||||
|
||||
#include <scl_export.h>
|
||||
#include <sc_export.h>
|
||||
#include <math.h>
|
||||
#include "expbasic.h" /* get basic definitions */
|
||||
|
||||
|
|
@ -185,23 +185,23 @@ struct EXPop_entry {
|
|||
/* global variables */
|
||||
/********************/
|
||||
|
||||
extern SCL_EXPRESS_EXPORT struct EXPop_entry EXPop_table[OP_LAST];
|
||||
extern SC_EXPRESS_EXPORT struct EXPop_entry EXPop_table[OP_LAST];
|
||||
|
||||
extern SCL_EXPRESS_EXPORT Expression LITERAL_E;
|
||||
extern SCL_EXPRESS_EXPORT Expression LITERAL_INFINITY;
|
||||
extern SCL_EXPRESS_EXPORT Expression LITERAL_PI;
|
||||
extern SCL_EXPRESS_EXPORT Expression LITERAL_ZERO;
|
||||
extern SCL_EXPRESS_EXPORT Expression LITERAL_ONE;
|
||||
extern SC_EXPRESS_EXPORT Expression LITERAL_E;
|
||||
extern SC_EXPRESS_EXPORT Expression LITERAL_INFINITY;
|
||||
extern SC_EXPRESS_EXPORT Expression LITERAL_PI;
|
||||
extern SC_EXPRESS_EXPORT Expression LITERAL_ZERO;
|
||||
extern SC_EXPRESS_EXPORT Expression LITERAL_ONE;
|
||||
|
||||
extern SCL_EXPRESS_EXPORT Error ERROR_bad_qualification;
|
||||
extern SCL_EXPRESS_EXPORT Error ERROR_integer_expression_expected;
|
||||
extern SCL_EXPRESS_EXPORT Error ERROR_implicit_downcast;
|
||||
extern SCL_EXPRESS_EXPORT Error ERROR_ambig_implicit_downcast;
|
||||
extern SC_EXPRESS_EXPORT Error ERROR_bad_qualification;
|
||||
extern SC_EXPRESS_EXPORT Error ERROR_integer_expression_expected;
|
||||
extern SC_EXPRESS_EXPORT Error ERROR_implicit_downcast;
|
||||
extern SC_EXPRESS_EXPORT Error ERROR_ambig_implicit_downcast;
|
||||
|
||||
extern SCL_EXPRESS_EXPORT struct freelist_head EXP_fl;
|
||||
extern SCL_EXPRESS_EXPORT struct freelist_head OP_fl;
|
||||
extern SCL_EXPRESS_EXPORT struct freelist_head QUERY_fl;
|
||||
extern SCL_EXPRESS_EXPORT struct freelist_head QUAL_ATTR_fl;
|
||||
extern SC_EXPRESS_EXPORT struct freelist_head EXP_fl;
|
||||
extern SC_EXPRESS_EXPORT struct freelist_head OP_fl;
|
||||
extern SC_EXPRESS_EXPORT struct freelist_head QUERY_fl;
|
||||
extern SC_EXPRESS_EXPORT struct freelist_head QUAL_ATTR_fl;
|
||||
|
||||
/******************************/
|
||||
/* macro function definitions */
|
||||
|
|
@ -254,16 +254,16 @@ extern SCL_EXPRESS_EXPORT struct freelist_head QUAL_ATTR_fl;
|
|||
/* function prototypes */
|
||||
/***********************/
|
||||
|
||||
extern SCL_EXPRESS_EXPORT Expression EXPcreate PROTO( ( Type ) );
|
||||
extern SCL_EXPRESS_EXPORT Expression EXPcreate_simple PROTO( ( Type ) );
|
||||
extern SCL_EXPRESS_EXPORT Expression EXPcreate_from_symbol PROTO( ( Type, Symbol * ) );
|
||||
extern SCL_EXPRESS_EXPORT Expression UN_EXPcreate PROTO( ( Op_Code, Expression ) );
|
||||
extern SCL_EXPRESS_EXPORT Expression BIN_EXPcreate PROTO( ( Op_Code, Expression, Expression ) );
|
||||
extern SCL_EXPRESS_EXPORT Expression TERN_EXPcreate PROTO( ( Op_Code, Expression, Expression, Expression ) );
|
||||
extern SCL_EXPRESS_EXPORT Expression QUERYcreate PROTO( ( Symbol *, Expression ) );
|
||||
extern SCL_EXPRESS_EXPORT void EXPinitialize PROTO( ( void ) );
|
||||
extern SCL_EXPRESS_EXPORT void EXPcleanup PROTO( ( void ) );
|
||||
extern SCL_EXPRESS_EXPORT Type EXPtype PROTO( ( Expression, struct Scope_ * ) );
|
||||
extern SCL_EXPRESS_EXPORT int EXPget_integer_value PROTO( ( Expression ) );
|
||||
extern SC_EXPRESS_EXPORT Expression EXPcreate PROTO( ( Type ) );
|
||||
extern SC_EXPRESS_EXPORT Expression EXPcreate_simple PROTO( ( Type ) );
|
||||
extern SC_EXPRESS_EXPORT Expression EXPcreate_from_symbol PROTO( ( Type, Symbol * ) );
|
||||
extern SC_EXPRESS_EXPORT Expression UN_EXPcreate PROTO( ( Op_Code, Expression ) );
|
||||
extern SC_EXPRESS_EXPORT Expression BIN_EXPcreate PROTO( ( Op_Code, Expression, Expression ) );
|
||||
extern SC_EXPRESS_EXPORT Expression TERN_EXPcreate PROTO( ( Op_Code, Expression, Expression, Expression ) );
|
||||
extern SC_EXPRESS_EXPORT Expression QUERYcreate PROTO( ( Symbol *, Expression ) );
|
||||
extern SC_EXPRESS_EXPORT void EXPinitialize PROTO( ( void ) );
|
||||
extern SC_EXPRESS_EXPORT void EXPcleanup PROTO( ( void ) );
|
||||
extern SC_EXPRESS_EXPORT Type EXPtype PROTO( ( Expression, struct Scope_ * ) );
|
||||
extern SC_EXPRESS_EXPORT int EXPget_integer_value PROTO( ( Expression ) );
|
||||
|
||||
#endif /*EXPRESSION_H*/
|
||||
|
|
|
|||
|
|
@ -88,151 +88,151 @@ struct Express_ {
|
|||
/* global variables */
|
||||
/********************/
|
||||
|
||||
extern SCL_EXPRESS_EXPORT Linked_List EXPRESS_path;
|
||||
extern SCL_EXPRESS_EXPORT int EXPRESSpass;
|
||||
extern SC_EXPRESS_EXPORT Linked_List EXPRESS_path;
|
||||
extern SC_EXPRESS_EXPORT int EXPRESSpass;
|
||||
|
||||
extern SCL_EXPRESS_EXPORT void ( *EXPRESSinit_args ) PROTO( ( int, char ** ) );
|
||||
extern SCL_EXPRESS_EXPORT void ( *EXPRESSinit_parse ) PROTO( ( void ) );
|
||||
extern SCL_EXPRESS_EXPORT int ( *EXPRESSfail ) PROTO( ( Express ) );
|
||||
extern SCL_EXPRESS_EXPORT int ( *EXPRESSsucceed ) PROTO( ( Express ) );
|
||||
extern SCL_EXPRESS_EXPORT void ( *EXPRESSbackend ) PROTO( ( Express ) );
|
||||
extern SCL_EXPRESS_EXPORT char * EXPRESSprogram_name;
|
||||
extern SC_EXPRESS_EXPORT void ( *EXPRESSinit_args ) PROTO( ( int, char ** ) );
|
||||
extern SC_EXPRESS_EXPORT void ( *EXPRESSinit_parse ) PROTO( ( void ) );
|
||||
extern SC_EXPRESS_EXPORT int ( *EXPRESSfail ) PROTO( ( Express ) );
|
||||
extern SC_EXPRESS_EXPORT int ( *EXPRESSsucceed ) PROTO( ( Express ) );
|
||||
extern SC_EXPRESS_EXPORT void ( *EXPRESSbackend ) PROTO( ( Express ) );
|
||||
extern SC_EXPRESS_EXPORT char * EXPRESSprogram_name;
|
||||
extern char EXPRESSgetopt_options[]; /* initialized elsewhere */
|
||||
extern SCL_EXPRESS_EXPORT int ( *EXPRESSgetopt ) PROTO( ( int, char * ) );
|
||||
extern SCL_EXPRESS_EXPORT bool EXPRESSignore_duplicate_schemas;
|
||||
extern SC_EXPRESS_EXPORT int ( *EXPRESSgetopt ) PROTO( ( int, char * ) );
|
||||
extern SC_EXPRESS_EXPORT bool EXPRESSignore_duplicate_schemas;
|
||||
|
||||
extern SCL_EXPRESS_EXPORT Dictionary EXPRESSbuiltins; /* procedures/functions */
|
||||
extern SC_EXPRESS_EXPORT Dictionary EXPRESSbuiltins; /* procedures/functions */
|
||||
|
||||
extern SCL_EXPRESS_EXPORT Error ERROR_bail_out;
|
||||
extern SCL_EXPRESS_EXPORT Error ERROR_syntax;
|
||||
extern SCL_EXPRESS_EXPORT Error ERROR_unlabelled_param_type;
|
||||
extern SCL_EXPRESS_EXPORT Error ERROR_file_unreadable;
|
||||
extern SCL_EXPRESS_EXPORT Error ERROR_file_unwriteable;
|
||||
extern SCL_EXPRESS_EXPORT Error ERROR_warn_unsupported_lang_feat;
|
||||
extern SC_EXPRESS_EXPORT Error ERROR_bail_out;
|
||||
extern SC_EXPRESS_EXPORT Error ERROR_syntax;
|
||||
extern SC_EXPRESS_EXPORT Error ERROR_unlabelled_param_type;
|
||||
extern SC_EXPRESS_EXPORT Error ERROR_file_unreadable;
|
||||
extern SC_EXPRESS_EXPORT Error ERROR_file_unwriteable;
|
||||
extern SC_EXPRESS_EXPORT Error ERROR_warn_unsupported_lang_feat;
|
||||
|
||||
extern SCL_EXPRESS_EXPORT struct Scope_ * FUNC_NVL;
|
||||
extern SCL_EXPRESS_EXPORT struct Scope_ * FUNC_USEDIN;
|
||||
extern SC_EXPRESS_EXPORT struct Scope_ * FUNC_NVL;
|
||||
extern SC_EXPRESS_EXPORT struct Scope_ * FUNC_USEDIN;
|
||||
|
||||
extern SCL_EXPRESS_EXPORT char * KW_ABS;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_ABSTRACT;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_ACOS;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_AGGREGATE;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_ALIAS;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_AND;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_ANDOR;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_ARRAY;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_AS;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_ASIN;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_ATAN;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_BAG;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_BEGIN;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_BINARY;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_BLENGTH;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_BOOLEAN;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_BY;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_CASE;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_CONST_E;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_CONSTANT;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_CONTEXT;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_COS;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_DERIVE;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_DIV;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_ELSE;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_END;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_END_ALIAS;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_END_CASE;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_END_CONSTANT;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_END_CONTEXT;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_END_ENTITY;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_END_FUNCTION;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_END_IF;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_END_LOCAL;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_END_MODEL;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_END_PROCEDURE;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_END_REPEAT;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_END_RULE;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_END_SCHEMA;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_END_TYPE;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_ENTITY;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_ENUMERATION;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_ESCAPE;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_EXISTS;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_EXP;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_FALSE;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_FIXED;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_FOR;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_FORMAT;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_FROM;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_FUNCTION;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_GENERIC;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_HIBOUND;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_HIINDEX;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_IF;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_IN;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_INCLUDE;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_INSERT;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_INTEGER;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_INVERSE;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_LENGTH;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_LIKE;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_LIST;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_LOBOUND;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_LOCAL;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_LOG;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_LOG10;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_LOG2;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_LOGICAL;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_LOINDEX;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_MOD;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_MODEL;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_NOT;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_NUMBER;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_NVL;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_ODD;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_OF;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_ONEOF;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_OPTIONAL;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_OR;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_OTHERWISE;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_PI;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_PROCEDURE;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_QUERY;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_REAL;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_REFERENCE;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_REMOVE;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_REPEAT;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_RETURN;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_ROLESOF;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_RULE;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_SCHEMA;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_SELECT;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_SELF;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_SET;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_SIN;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_SIZEOF;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_SKIP;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_SQRT;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_STRING;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_SUBTYPE;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_SUPERTYPE;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_TAN;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_THEN;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_TO;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_TRUE;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_TYPE;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_TYPEOF;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_UNIQUE;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_UNKNOWN;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_UNTIL;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_USE;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_USEDIN;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_VALUE;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_VALUE_IN;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_VALUE_UNIQUE;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_VAR;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_WHERE;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_WHILE;
|
||||
extern SCL_EXPRESS_EXPORT char * KW_XOR;
|
||||
extern SC_EXPRESS_EXPORT char * KW_ABS;
|
||||
extern SC_EXPRESS_EXPORT char * KW_ABSTRACT;
|
||||
extern SC_EXPRESS_EXPORT char * KW_ACOS;
|
||||
extern SC_EXPRESS_EXPORT char * KW_AGGREGATE;
|
||||
extern SC_EXPRESS_EXPORT char * KW_ALIAS;
|
||||
extern SC_EXPRESS_EXPORT char * KW_AND;
|
||||
extern SC_EXPRESS_EXPORT char * KW_ANDOR;
|
||||
extern SC_EXPRESS_EXPORT char * KW_ARRAY;
|
||||
extern SC_EXPRESS_EXPORT char * KW_AS;
|
||||
extern SC_EXPRESS_EXPORT char * KW_ASIN;
|
||||
extern SC_EXPRESS_EXPORT char * KW_ATAN;
|
||||
extern SC_EXPRESS_EXPORT char * KW_BAG;
|
||||
extern SC_EXPRESS_EXPORT char * KW_BEGIN;
|
||||
extern SC_EXPRESS_EXPORT char * KW_BINARY;
|
||||
extern SC_EXPRESS_EXPORT char * KW_BLENGTH;
|
||||
extern SC_EXPRESS_EXPORT char * KW_BOOLEAN;
|
||||
extern SC_EXPRESS_EXPORT char * KW_BY;
|
||||
extern SC_EXPRESS_EXPORT char * KW_CASE;
|
||||
extern SC_EXPRESS_EXPORT char * KW_CONST_E;
|
||||
extern SC_EXPRESS_EXPORT char * KW_CONSTANT;
|
||||
extern SC_EXPRESS_EXPORT char * KW_CONTEXT;
|
||||
extern SC_EXPRESS_EXPORT char * KW_COS;
|
||||
extern SC_EXPRESS_EXPORT char * KW_DERIVE;
|
||||
extern SC_EXPRESS_EXPORT char * KW_DIV;
|
||||
extern SC_EXPRESS_EXPORT char * KW_ELSE;
|
||||
extern SC_EXPRESS_EXPORT char * KW_END;
|
||||
extern SC_EXPRESS_EXPORT char * KW_END_ALIAS;
|
||||
extern SC_EXPRESS_EXPORT char * KW_END_CASE;
|
||||
extern SC_EXPRESS_EXPORT char * KW_END_CONSTANT;
|
||||
extern SC_EXPRESS_EXPORT char * KW_END_CONTEXT;
|
||||
extern SC_EXPRESS_EXPORT char * KW_END_ENTITY;
|
||||
extern SC_EXPRESS_EXPORT char * KW_END_FUNCTION;
|
||||
extern SC_EXPRESS_EXPORT char * KW_END_IF;
|
||||
extern SC_EXPRESS_EXPORT char * KW_END_LOCAL;
|
||||
extern SC_EXPRESS_EXPORT char * KW_END_MODEL;
|
||||
extern SC_EXPRESS_EXPORT char * KW_END_PROCEDURE;
|
||||
extern SC_EXPRESS_EXPORT char * KW_END_REPEAT;
|
||||
extern SC_EXPRESS_EXPORT char * KW_END_RULE;
|
||||
extern SC_EXPRESS_EXPORT char * KW_END_SCHEMA;
|
||||
extern SC_EXPRESS_EXPORT char * KW_END_TYPE;
|
||||
extern SC_EXPRESS_EXPORT char * KW_ENTITY;
|
||||
extern SC_EXPRESS_EXPORT char * KW_ENUMERATION;
|
||||
extern SC_EXPRESS_EXPORT char * KW_ESCAPE;
|
||||
extern SC_EXPRESS_EXPORT char * KW_EXISTS;
|
||||
extern SC_EXPRESS_EXPORT char * KW_EXP;
|
||||
extern SC_EXPRESS_EXPORT char * KW_FALSE;
|
||||
extern SC_EXPRESS_EXPORT char * KW_FIXED;
|
||||
extern SC_EXPRESS_EXPORT char * KW_FOR;
|
||||
extern SC_EXPRESS_EXPORT char * KW_FORMAT;
|
||||
extern SC_EXPRESS_EXPORT char * KW_FROM;
|
||||
extern SC_EXPRESS_EXPORT char * KW_FUNCTION;
|
||||
extern SC_EXPRESS_EXPORT char * KW_GENERIC;
|
||||
extern SC_EXPRESS_EXPORT char * KW_HIBOUND;
|
||||
extern SC_EXPRESS_EXPORT char * KW_HIINDEX;
|
||||
extern SC_EXPRESS_EXPORT char * KW_IF;
|
||||
extern SC_EXPRESS_EXPORT char * KW_IN;
|
||||
extern SC_EXPRESS_EXPORT char * KW_INCLUDE;
|
||||
extern SC_EXPRESS_EXPORT char * KW_INSERT;
|
||||
extern SC_EXPRESS_EXPORT char * KW_INTEGER;
|
||||
extern SC_EXPRESS_EXPORT char * KW_INVERSE;
|
||||
extern SC_EXPRESS_EXPORT char * KW_LENGTH;
|
||||
extern SC_EXPRESS_EXPORT char * KW_LIKE;
|
||||
extern SC_EXPRESS_EXPORT char * KW_LIST;
|
||||
extern SC_EXPRESS_EXPORT char * KW_LOBOUND;
|
||||
extern SC_EXPRESS_EXPORT char * KW_LOCAL;
|
||||
extern SC_EXPRESS_EXPORT char * KW_LOG;
|
||||
extern SC_EXPRESS_EXPORT char * KW_LOG10;
|
||||
extern SC_EXPRESS_EXPORT char * KW_LOG2;
|
||||
extern SC_EXPRESS_EXPORT char * KW_LOGICAL;
|
||||
extern SC_EXPRESS_EXPORT char * KW_LOINDEX;
|
||||
extern SC_EXPRESS_EXPORT char * KW_MOD;
|
||||
extern SC_EXPRESS_EXPORT char * KW_MODEL;
|
||||
extern SC_EXPRESS_EXPORT char * KW_NOT;
|
||||
extern SC_EXPRESS_EXPORT char * KW_NUMBER;
|
||||
extern SC_EXPRESS_EXPORT char * KW_NVL;
|
||||
extern SC_EXPRESS_EXPORT char * KW_ODD;
|
||||
extern SC_EXPRESS_EXPORT char * KW_OF;
|
||||
extern SC_EXPRESS_EXPORT char * KW_ONEOF;
|
||||
extern SC_EXPRESS_EXPORT char * KW_OPTIONAL;
|
||||
extern SC_EXPRESS_EXPORT char * KW_OR;
|
||||
extern SC_EXPRESS_EXPORT char * KW_OTHERWISE;
|
||||
extern SC_EXPRESS_EXPORT char * KW_PI;
|
||||
extern SC_EXPRESS_EXPORT char * KW_PROCEDURE;
|
||||
extern SC_EXPRESS_EXPORT char * KW_QUERY;
|
||||
extern SC_EXPRESS_EXPORT char * KW_REAL;
|
||||
extern SC_EXPRESS_EXPORT char * KW_REFERENCE;
|
||||
extern SC_EXPRESS_EXPORT char * KW_REMOVE;
|
||||
extern SC_EXPRESS_EXPORT char * KW_REPEAT;
|
||||
extern SC_EXPRESS_EXPORT char * KW_RETURN;
|
||||
extern SC_EXPRESS_EXPORT char * KW_ROLESOF;
|
||||
extern SC_EXPRESS_EXPORT char * KW_RULE;
|
||||
extern SC_EXPRESS_EXPORT char * KW_SCHEMA;
|
||||
extern SC_EXPRESS_EXPORT char * KW_SELECT;
|
||||
extern SC_EXPRESS_EXPORT char * KW_SELF;
|
||||
extern SC_EXPRESS_EXPORT char * KW_SET;
|
||||
extern SC_EXPRESS_EXPORT char * KW_SIN;
|
||||
extern SC_EXPRESS_EXPORT char * KW_SIZEOF;
|
||||
extern SC_EXPRESS_EXPORT char * KW_SKIP;
|
||||
extern SC_EXPRESS_EXPORT char * KW_SQRT;
|
||||
extern SC_EXPRESS_EXPORT char * KW_STRING;
|
||||
extern SC_EXPRESS_EXPORT char * KW_SUBTYPE;
|
||||
extern SC_EXPRESS_EXPORT char * KW_SUPERTYPE;
|
||||
extern SC_EXPRESS_EXPORT char * KW_TAN;
|
||||
extern SC_EXPRESS_EXPORT char * KW_THEN;
|
||||
extern SC_EXPRESS_EXPORT char * KW_TO;
|
||||
extern SC_EXPRESS_EXPORT char * KW_TRUE;
|
||||
extern SC_EXPRESS_EXPORT char * KW_TYPE;
|
||||
extern SC_EXPRESS_EXPORT char * KW_TYPEOF;
|
||||
extern SC_EXPRESS_EXPORT char * KW_UNIQUE;
|
||||
extern SC_EXPRESS_EXPORT char * KW_UNKNOWN;
|
||||
extern SC_EXPRESS_EXPORT char * KW_UNTIL;
|
||||
extern SC_EXPRESS_EXPORT char * KW_USE;
|
||||
extern SC_EXPRESS_EXPORT char * KW_USEDIN;
|
||||
extern SC_EXPRESS_EXPORT char * KW_VALUE;
|
||||
extern SC_EXPRESS_EXPORT char * KW_VALUE_IN;
|
||||
extern SC_EXPRESS_EXPORT char * KW_VALUE_UNIQUE;
|
||||
extern SC_EXPRESS_EXPORT char * KW_VAR;
|
||||
extern SC_EXPRESS_EXPORT char * KW_WHERE;
|
||||
extern SC_EXPRESS_EXPORT char * KW_WHILE;
|
||||
extern SC_EXPRESS_EXPORT char * KW_XOR;
|
||||
|
||||
/******************************/
|
||||
/* macro function definitions */
|
||||
|
|
@ -247,16 +247,16 @@ extern SCL_EXPRESS_EXPORT char * KW_XOR;
|
|||
/* function prototypes */
|
||||
/***********************/
|
||||
|
||||
extern SCL_EXPRESS_EXPORT Express EXPRESScreate PROTO( ( void ) );
|
||||
extern SCL_EXPRESS_EXPORT void EXPRESSdestroy PROTO( ( Express ) );
|
||||
extern SCL_EXPRESS_EXPORT void EXPRESSparse PROTO( ( Express, FILE *, char * ) );
|
||||
extern SCL_EXPRESS_EXPORT void EXPRESSinitialize PROTO( ( void ) );
|
||||
extern SCL_EXPRESS_EXPORT void EXPRESScleanup PROTO( ( void ) );
|
||||
extern SCL_EXPRESS_EXPORT void EXPRESSresolve PROTO( ( Express ) );
|
||||
extern SCL_EXPRESS_EXPORT char * EXPRESSversion PROTO( ( void ) );
|
||||
extern SCL_EXPRESS_EXPORT int EXPRESS_fail PROTO( ( Express ) );
|
||||
extern SCL_EXPRESS_EXPORT int EXPRESS_succeed PROTO( ( Express ) );
|
||||
extern SC_EXPRESS_EXPORT Express EXPRESScreate PROTO( ( void ) );
|
||||
extern SC_EXPRESS_EXPORT void EXPRESSdestroy PROTO( ( Express ) );
|
||||
extern SC_EXPRESS_EXPORT void EXPRESSparse PROTO( ( Express, FILE *, char * ) );
|
||||
extern SC_EXPRESS_EXPORT void EXPRESSinitialize PROTO( ( void ) );
|
||||
extern SC_EXPRESS_EXPORT void EXPRESScleanup PROTO( ( void ) );
|
||||
extern SC_EXPRESS_EXPORT void EXPRESSresolve PROTO( ( Express ) );
|
||||
extern SC_EXPRESS_EXPORT char * EXPRESSversion PROTO( ( void ) );
|
||||
extern SC_EXPRESS_EXPORT int EXPRESS_fail PROTO( ( Express ) );
|
||||
extern SC_EXPRESS_EXPORT int EXPRESS_succeed PROTO( ( Express ) );
|
||||
extern void EXPRESSinit_init PROTO( ( void ) );
|
||||
extern SCL_EXPRESS_EXPORT void build_complex( Express );
|
||||
extern SC_EXPRESS_EXPORT void build_complex( Express );
|
||||
|
||||
#endif /*EXPRESS_H*/
|
||||
|
|
|
|||
|
|
@ -100,7 +100,7 @@
|
|||
/* packages used */
|
||||
/*****************/
|
||||
|
||||
#include <scl_export.h>
|
||||
#include <sc_export.h>
|
||||
#include "memory.h"
|
||||
|
||||
/************/
|
||||
|
|
@ -156,8 +156,8 @@ typedef struct {
|
|||
/* global variables */
|
||||
/********************/
|
||||
|
||||
extern SCL_EXPRESS_EXPORT struct freelist_head HASH_Table_fl;
|
||||
extern SCL_EXPRESS_EXPORT struct freelist_head HASH_Element_fl;
|
||||
extern SC_EXPRESS_EXPORT struct freelist_head HASH_Table_fl;
|
||||
extern SC_EXPRESS_EXPORT struct freelist_head HASH_Element_fl;
|
||||
|
||||
/******************************/
|
||||
/* macro function definitions */
|
||||
|
|
@ -193,13 +193,13 @@ This change only seems to have affected hash.h and hash.c
|
|||
/* function prototypes */
|
||||
/***********************/
|
||||
|
||||
extern SCL_EXPRESS_EXPORT void HASHinitialize PROTO( ( void ) );
|
||||
extern SCL_EXPRESS_EXPORT Hash_Table HASHcreate PROTO( ( unsigned ) );
|
||||
extern SCL_EXPRESS_EXPORT Hash_Table HASHcopy PROTO( ( Hash_Table ) );
|
||||
extern SCL_EXPRESS_EXPORT void HASHdestroy PROTO( ( Hash_Table ) );
|
||||
extern SCL_EXPRESS_EXPORT Element HASHsearch PROTO( ( Hash_Table, Element, Action ) );
|
||||
extern SCL_EXPRESS_EXPORT void HASHlistinit PROTO( ( Hash_Table, HashEntry * ) );
|
||||
extern SCL_EXPRESS_EXPORT void HASHlistinit_by_type PROTO( ( Hash_Table, HashEntry *, char ) );
|
||||
extern SCL_EXPRESS_EXPORT Element HASHlist PROTO( ( HashEntry * ) );
|
||||
extern SC_EXPRESS_EXPORT void HASHinitialize PROTO( ( void ) );
|
||||
extern SC_EXPRESS_EXPORT Hash_Table HASHcreate PROTO( ( unsigned ) );
|
||||
extern SC_EXPRESS_EXPORT Hash_Table HASHcopy PROTO( ( Hash_Table ) );
|
||||
extern SC_EXPRESS_EXPORT void HASHdestroy PROTO( ( Hash_Table ) );
|
||||
extern SC_EXPRESS_EXPORT Element HASHsearch PROTO( ( Hash_Table, Element, Action ) );
|
||||
extern SC_EXPRESS_EXPORT void HASHlistinit PROTO( ( Hash_Table, HashEntry * ) );
|
||||
extern SC_EXPRESS_EXPORT void HASHlistinit_by_type PROTO( ( Hash_Table, HashEntry *, char ) );
|
||||
extern SC_EXPRESS_EXPORT Element HASHlist PROTO( ( HashEntry * ) );
|
||||
|
||||
#endif /*HASH_H*/
|
||||
|
|
|
|||
|
|
@ -38,7 +38,7 @@
|
|||
/* packages used */
|
||||
/*****************/
|
||||
|
||||
#include <scl_export.h>
|
||||
#include <sc_export.h>
|
||||
#include <ctype.h>
|
||||
#include "basic.h"
|
||||
#include "error.h"
|
||||
|
|
@ -68,19 +68,19 @@ typedef struct Scan_Buffer {
|
|||
/* global variables */
|
||||
/********************/
|
||||
|
||||
extern SCL_EXPRESS_EXPORT Scan_Buffer SCAN_buffers[SCAN_NESTING_DEPTH];
|
||||
extern SCL_EXPRESS_EXPORT int SCAN_current_buffer;
|
||||
extern SCL_EXPRESS_EXPORT char * SCANcurrent;
|
||||
extern SC_EXPRESS_EXPORT Scan_Buffer SCAN_buffers[SCAN_NESTING_DEPTH];
|
||||
extern SC_EXPRESS_EXPORT int SCAN_current_buffer;
|
||||
extern SC_EXPRESS_EXPORT char * SCANcurrent;
|
||||
|
||||
extern SCL_EXPRESS_EXPORT Error ERROR_include_file;
|
||||
extern SCL_EXPRESS_EXPORT Error ERROR_unmatched_close_comment;
|
||||
extern SCL_EXPRESS_EXPORT Error ERROR_unmatched_open_comment;
|
||||
extern SCL_EXPRESS_EXPORT Error ERROR_unterminated_string;
|
||||
extern SCL_EXPRESS_EXPORT Error ERROR_encoded_string_bad_digit;
|
||||
extern SCL_EXPRESS_EXPORT Error ERROR_encoded_string_bad_count;
|
||||
extern SCL_EXPRESS_EXPORT Error ERROR_bad_identifier;
|
||||
extern SCL_EXPRESS_EXPORT Error ERROR_unexpected_character;
|
||||
extern SCL_EXPRESS_EXPORT Error ERROR_nonascii_char;
|
||||
extern SC_EXPRESS_EXPORT Error ERROR_include_file;
|
||||
extern SC_EXPRESS_EXPORT Error ERROR_unmatched_close_comment;
|
||||
extern SC_EXPRESS_EXPORT Error ERROR_unmatched_open_comment;
|
||||
extern SC_EXPRESS_EXPORT Error ERROR_unterminated_string;
|
||||
extern SC_EXPRESS_EXPORT Error ERROR_encoded_string_bad_digit;
|
||||
extern SC_EXPRESS_EXPORT Error ERROR_encoded_string_bad_count;
|
||||
extern SC_EXPRESS_EXPORT Error ERROR_bad_identifier;
|
||||
extern SC_EXPRESS_EXPORT Error ERROR_unexpected_character;
|
||||
extern SC_EXPRESS_EXPORT Error ERROR_nonascii_char;
|
||||
|
||||
/******************************/
|
||||
/* macro function definitions */
|
||||
|
|
@ -99,24 +99,24 @@ extern SCL_EXPRESS_EXPORT Error ERROR_nonascii_char;
|
|||
/* function prototypes */
|
||||
/***********************/
|
||||
|
||||
extern SCL_EXPRESS_EXPORT void SCANinitialize PROTO( ( void ) );
|
||||
extern SCL_EXPRESS_EXPORT int SCANprocess_real_literal PROTO( ( const char * ) );
|
||||
extern SCL_EXPRESS_EXPORT int SCANprocess_integer_literal PROTO( ( const char * ) );
|
||||
extern SCL_EXPRESS_EXPORT int SCANprocess_binary_literal PROTO( ( const char * ) );
|
||||
extern SCL_EXPRESS_EXPORT int SCANprocess_logical_literal PROTO( ( char * ) );
|
||||
extern SCL_EXPRESS_EXPORT int SCANprocess_identifier_or_keyword PROTO( ( const char * ) );
|
||||
extern SCL_EXPRESS_EXPORT int SCANprocess_string PROTO( ( const char * ) );
|
||||
extern SCL_EXPRESS_EXPORT int SCANprocess_encoded_string PROTO( ( const char * ) );
|
||||
extern SCL_EXPRESS_EXPORT int SCANprocess_semicolon PROTO( ( const char *, int ) );
|
||||
extern SCL_EXPRESS_EXPORT void SCANsave_comment PROTO( ( const char * ) );
|
||||
extern SCL_EXPRESS_EXPORT bool SCANread PROTO( ( void ) );
|
||||
extern SC_EXPRESS_EXPORT void SCANinitialize PROTO( ( void ) );
|
||||
extern SC_EXPRESS_EXPORT int SCANprocess_real_literal PROTO( ( const char * ) );
|
||||
extern SC_EXPRESS_EXPORT int SCANprocess_integer_literal PROTO( ( const char * ) );
|
||||
extern SC_EXPRESS_EXPORT int SCANprocess_binary_literal PROTO( ( const char * ) );
|
||||
extern SC_EXPRESS_EXPORT int SCANprocess_logical_literal PROTO( ( char * ) );
|
||||
extern SC_EXPRESS_EXPORT int SCANprocess_identifier_or_keyword PROTO( ( const char * ) );
|
||||
extern SC_EXPRESS_EXPORT int SCANprocess_string PROTO( ( const char * ) );
|
||||
extern SC_EXPRESS_EXPORT int SCANprocess_encoded_string PROTO( ( const char * ) );
|
||||
extern SC_EXPRESS_EXPORT int SCANprocess_semicolon PROTO( ( const char *, int ) );
|
||||
extern SC_EXPRESS_EXPORT void SCANsave_comment PROTO( ( const char * ) );
|
||||
extern SC_EXPRESS_EXPORT bool SCANread PROTO( ( void ) );
|
||||
#if macros_bit_the_dust
|
||||
extern SCL_EXPRESS_EXPORT void SCANdefine_macro PROTO( ( char *, char * ) );
|
||||
extern SC_EXPRESS_EXPORT void SCANdefine_macro PROTO( ( char *, char * ) );
|
||||
#endif
|
||||
extern SCL_EXPRESS_EXPORT void SCANinclude_file PROTO( ( char * ) );
|
||||
SCL_EXPRESS_EXPORT void SCANlowerize PROTO( ( char * ) );
|
||||
SCL_EXPRESS_EXPORT void SCANupperize PROTO( ( char * ) );
|
||||
extern SCL_EXPRESS_EXPORT char * SCANstrdup PROTO( ( char * ) );
|
||||
extern SCL_EXPRESS_EXPORT long SCANtell PROTO( ( void ) );
|
||||
extern SC_EXPRESS_EXPORT void SCANinclude_file PROTO( ( char * ) );
|
||||
SC_EXPRESS_EXPORT void SCANlowerize PROTO( ( char * ) );
|
||||
SC_EXPRESS_EXPORT void SCANupperize PROTO( ( char * ) );
|
||||
extern SC_EXPRESS_EXPORT char * SCANstrdup PROTO( ( char * ) );
|
||||
extern SC_EXPRESS_EXPORT long SCANtell PROTO( ( void ) );
|
||||
|
||||
#endif /* LEX_ACTIONS_H */
|
||||
|
|
|
|||
|
|
@ -36,7 +36,7 @@
|
|||
/* packages used */
|
||||
/*****************/
|
||||
|
||||
#include <scl_export.h>
|
||||
#include <sc_export.h>
|
||||
#include "basic.h"
|
||||
#include "memory.h"
|
||||
|
||||
|
|
@ -70,10 +70,10 @@ struct Linked_List_ {
|
|||
/* global variables */
|
||||
/********************/
|
||||
|
||||
extern SCL_EXPRESS_EXPORT Error ERROR_empty_list;
|
||||
extern SCL_EXPRESS_EXPORT struct freelist_head LINK_fl;
|
||||
extern SCL_EXPRESS_EXPORT struct freelist_head LIST_fl;
|
||||
extern SCL_EXPRESS_EXPORT Linked_List LINK__l; /* for LISTcreate_with macro - ugh */
|
||||
extern SC_EXPRESS_EXPORT Error ERROR_empty_list;
|
||||
extern SC_EXPRESS_EXPORT struct freelist_head LINK_fl;
|
||||
extern SC_EXPRESS_EXPORT struct freelist_head LIST_fl;
|
||||
extern SC_EXPRESS_EXPORT Linked_List LINK__l; /* for LISTcreate_with macro - ugh */
|
||||
|
||||
/******************************/
|
||||
/* macro function definitions */
|
||||
|
|
@ -126,21 +126,21 @@ extern SCL_EXPRESS_EXPORT Linked_List LINK__l; /* for LISTcreate_with macro - u
|
|||
/* function prototypes */
|
||||
/***********************/
|
||||
|
||||
extern SCL_EXPRESS_EXPORT void LISTinitialize PROTO( ( void ) );
|
||||
extern SCL_EXPRESS_EXPORT void LISTcleanup PROTO( ( void ) );
|
||||
extern SCL_EXPRESS_EXPORT Linked_List LISTcreate PROTO( ( void ) );
|
||||
extern SCL_EXPRESS_EXPORT Linked_List LISTcopy PROTO( ( Linked_List ) );
|
||||
extern SCL_EXPRESS_EXPORT Generic LISTadd_first PROTO( ( Linked_List, Generic ) );
|
||||
extern SCL_EXPRESS_EXPORT Generic LISTadd_last PROTO( ( Linked_List, Generic ) );
|
||||
extern SCL_EXPRESS_EXPORT Generic LISTadd_after PROTO( ( Linked_List, Link, Generic ) );
|
||||
extern SCL_EXPRESS_EXPORT Generic LISTadd_before PROTO( ( Linked_List, Link, Generic ) );
|
||||
extern SCL_EXPRESS_EXPORT Generic LISTremove_first PROTO( ( Linked_List ) );
|
||||
extern SCL_EXPRESS_EXPORT Generic LISTremove PROTO( ( Linked_List, Link ) );
|
||||
extern SCL_EXPRESS_EXPORT Generic LISTget_first PROTO( ( Linked_List ) );
|
||||
extern SCL_EXPRESS_EXPORT Generic LISTget_second PROTO( ( Linked_List ) );
|
||||
extern SCL_EXPRESS_EXPORT Generic LISTget_nth PROTO( ( Linked_List, int ) );
|
||||
extern SCL_EXPRESS_EXPORT void LISTfree PROTO( ( Linked_List ) );
|
||||
extern SCL_EXPRESS_EXPORT int LISTget_length PROTO( ( Linked_List ) );
|
||||
extern SCL_EXPRESS_EXPORT bool LISTempty( Linked_List list );
|
||||
extern SC_EXPRESS_EXPORT void LISTinitialize PROTO( ( void ) );
|
||||
extern SC_EXPRESS_EXPORT void LISTcleanup PROTO( ( void ) );
|
||||
extern SC_EXPRESS_EXPORT Linked_List LISTcreate PROTO( ( void ) );
|
||||
extern SC_EXPRESS_EXPORT Linked_List LISTcopy PROTO( ( Linked_List ) );
|
||||
extern SC_EXPRESS_EXPORT Generic LISTadd_first PROTO( ( Linked_List, Generic ) );
|
||||
extern SC_EXPRESS_EXPORT Generic LISTadd_last PROTO( ( Linked_List, Generic ) );
|
||||
extern SC_EXPRESS_EXPORT Generic LISTadd_after PROTO( ( Linked_List, Link, Generic ) );
|
||||
extern SC_EXPRESS_EXPORT Generic LISTadd_before PROTO( ( Linked_List, Link, Generic ) );
|
||||
extern SC_EXPRESS_EXPORT Generic LISTremove_first PROTO( ( Linked_List ) );
|
||||
extern SC_EXPRESS_EXPORT Generic LISTremove PROTO( ( Linked_List, Link ) );
|
||||
extern SC_EXPRESS_EXPORT Generic LISTget_first PROTO( ( Linked_List ) );
|
||||
extern SC_EXPRESS_EXPORT Generic LISTget_second PROTO( ( Linked_List ) );
|
||||
extern SC_EXPRESS_EXPORT Generic LISTget_nth PROTO( ( Linked_List, int ) );
|
||||
extern SC_EXPRESS_EXPORT void LISTfree PROTO( ( Linked_List ) );
|
||||
extern SC_EXPRESS_EXPORT int LISTget_length PROTO( ( Linked_List ) );
|
||||
extern SC_EXPRESS_EXPORT bool LISTempty( Linked_List list );
|
||||
|
||||
#endif /*LINKED_LIST_H*/
|
||||
|
|
|
|||
|
|
@ -28,7 +28,7 @@
|
|||
/* packages used */
|
||||
/*****************/
|
||||
|
||||
#include <scl_export.h>
|
||||
#include <sc_export.h>
|
||||
|
||||
/** \file memory.h - defs for fixed size block memory allocator */
|
||||
|
||||
|
|
@ -66,7 +66,7 @@ char * nnew();
|
|||
/* space allocation macros with error package: */
|
||||
/***********************************************/
|
||||
|
||||
extern SCL_EXPRESS_EXPORT int yylineno;
|
||||
extern SC_EXPRESS_EXPORT int yylineno;
|
||||
|
||||
/** CALLOC grabs and initializes to all 0s space for the indicated
|
||||
* number of instances of the indicated type */
|
||||
|
|
@ -75,10 +75,10 @@ extern SCL_EXPRESS_EXPORT int yylineno;
|
|||
fprintf(stderr,"fedex: out of space");\
|
||||
} else {}
|
||||
|
||||
SCL_EXPRESS_EXPORT void _MEMinitialize PROTO( ( void ) );
|
||||
SCL_EXPRESS_EXPORT void MEMinitialize PROTO( ( struct freelist_head *, int, int, int ) );
|
||||
SCL_EXPRESS_EXPORT void MEM_destroy PROTO( ( struct freelist_head *, Freelist * ) );
|
||||
SCL_EXPRESS_EXPORT Generic MEM_new PROTO( ( struct freelist_head * ) );
|
||||
SC_EXPRESS_EXPORT void _MEMinitialize PROTO( ( void ) );
|
||||
SC_EXPRESS_EXPORT void MEMinitialize PROTO( ( struct freelist_head *, int, int, int ) );
|
||||
SC_EXPRESS_EXPORT void MEM_destroy PROTO( ( struct freelist_head *, Freelist * ) );
|
||||
SC_EXPRESS_EXPORT Generic MEM_new PROTO( ( struct freelist_head * ) );
|
||||
|
||||
#endif /* MEMORY_H */
|
||||
|
||||
|
|
|
|||
|
|
@ -55,7 +55,7 @@
|
|||
/* packages used */
|
||||
/*****************/
|
||||
|
||||
#include <scl_export.h>
|
||||
#include <sc_export.h>
|
||||
#include "basic.h" /* get basic definitions */
|
||||
#include "symbol.h"
|
||||
|
||||
|
|
@ -81,7 +81,7 @@ struct Object {
|
|||
/* global variables */
|
||||
/********************/
|
||||
|
||||
extern SCL_EXPRESS_EXPORT struct Object * OBJ;
|
||||
extern SC_EXPRESS_EXPORT struct Object * OBJ;
|
||||
|
||||
/******************************/
|
||||
/* macro function definitions */
|
||||
|
|
@ -97,9 +97,9 @@ extern SCL_EXPRESS_EXPORT struct Object * OBJ;
|
|||
/* function prototypes */
|
||||
/***********************/
|
||||
|
||||
extern SCL_EXPRESS_EXPORT void OBJinitialize PROTO( ( void ) );
|
||||
extern SCL_EXPRESS_EXPORT void OBJcleanup PROTO( ( void ) );
|
||||
extern SCL_EXPRESS_EXPORT void OBJcreate PROTO( ( char, struct Symbol_ * ( * )( Generic ), char *, int ) );
|
||||
extern SCL_EXPRESS_EXPORT Symbol * UNK_get_symbol PROTO( ( Generic x ) );
|
||||
extern SC_EXPRESS_EXPORT void OBJinitialize PROTO( ( void ) );
|
||||
extern SC_EXPRESS_EXPORT void OBJcleanup PROTO( ( void ) );
|
||||
extern SC_EXPRESS_EXPORT void OBJcreate PROTO( ( char, struct Symbol_ * ( * )( Generic ), char *, int ) );
|
||||
extern SC_EXPRESS_EXPORT Symbol * UNK_get_symbol PROTO( ( Generic x ) );
|
||||
|
||||
#endif /*OBJECT_H*/
|
||||
|
|
|
|||
|
|
@ -28,7 +28,7 @@
|
|||
* Initial revision
|
||||
*/
|
||||
|
||||
#include <scl_export.h>
|
||||
#include <sc_export.h>
|
||||
#include "expbasic.h" /* get basic definitions */
|
||||
#include "type.h"
|
||||
#include "variable.h"
|
||||
|
|
@ -45,20 +45,20 @@
|
|||
/* global variables */
|
||||
/********************/
|
||||
|
||||
extern SCL_EXPRESS_EXPORT int print_objects_while_running;
|
||||
extern SC_EXPRESS_EXPORT int print_objects_while_running;
|
||||
|
||||
extern SCL_EXPRESS_EXPORT Error ERROR_undefined_attribute;
|
||||
extern SCL_EXPRESS_EXPORT Error ERROR_undefined_type;
|
||||
extern SCL_EXPRESS_EXPORT Error ERROR_undefined_schema;
|
||||
extern SCL_EXPRESS_EXPORT Error ERROR_unknown_attr_in_entity;
|
||||
extern SCL_EXPRESS_EXPORT Error ERROR_unknown_subtype;
|
||||
extern SCL_EXPRESS_EXPORT Error ERROR_unknown_supertype;
|
||||
extern SCL_EXPRESS_EXPORT Error ERROR_circular_reference;
|
||||
extern SCL_EXPRESS_EXPORT Error ERROR_ambiguous_attribute;
|
||||
extern SCL_EXPRESS_EXPORT Error ERROR_ambiguous_group;
|
||||
extern SC_EXPRESS_EXPORT Error ERROR_undefined_attribute;
|
||||
extern SC_EXPRESS_EXPORT Error ERROR_undefined_type;
|
||||
extern SC_EXPRESS_EXPORT Error ERROR_undefined_schema;
|
||||
extern SC_EXPRESS_EXPORT Error ERROR_unknown_attr_in_entity;
|
||||
extern SC_EXPRESS_EXPORT Error ERROR_unknown_subtype;
|
||||
extern SC_EXPRESS_EXPORT Error ERROR_unknown_supertype;
|
||||
extern SC_EXPRESS_EXPORT Error ERROR_circular_reference;
|
||||
extern SC_EXPRESS_EXPORT Error ERROR_ambiguous_attribute;
|
||||
extern SC_EXPRESS_EXPORT Error ERROR_ambiguous_group;
|
||||
|
||||
extern SCL_EXPRESS_EXPORT Error WARNING_case_skip_label;
|
||||
extern SCL_EXPRESS_EXPORT Error WARNING_fn_skip_branch;
|
||||
extern SC_EXPRESS_EXPORT Error WARNING_case_skip_label;
|
||||
extern SC_EXPRESS_EXPORT Error WARNING_fn_skip_branch;
|
||||
|
||||
/* macros */
|
||||
|
||||
|
|
@ -73,14 +73,14 @@ extern SCL_EXPRESS_EXPORT Error WARNING_fn_skip_branch;
|
|||
/* function prototypes */
|
||||
/***********************/
|
||||
|
||||
extern SCL_EXPRESS_EXPORT void RESOLVEinitialize PROTO( ( void ) );
|
||||
extern SCL_EXPRESS_EXPORT void RESOLVEcleanup PROTO( ( void ) );
|
||||
extern SCL_EXPRESS_EXPORT void SCOPEresolve_expressions_statements PROTO( ( Scope ) );
|
||||
extern SCL_EXPRESS_EXPORT void SCOPEresolve_subsupers PROTO( ( Scope ) );
|
||||
extern SCL_EXPRESS_EXPORT void SCOPEresolve_types PROTO( ( Scope ) );
|
||||
extern SCL_EXPRESS_EXPORT void TYPE_resolve PROTO( ( Type * ) );
|
||||
extern SCL_EXPRESS_EXPORT void EXP_resolve PROTO( ( Expression, Scope, Type ) );
|
||||
extern SCL_EXPRESS_EXPORT void ALGresolve PROTO( ( Scope ) );
|
||||
extern SCL_EXPRESS_EXPORT void SCHEMAresolve PROTO( ( Scope ) );
|
||||
extern SC_EXPRESS_EXPORT void RESOLVEinitialize PROTO( ( void ) );
|
||||
extern SC_EXPRESS_EXPORT void RESOLVEcleanup PROTO( ( void ) );
|
||||
extern SC_EXPRESS_EXPORT void SCOPEresolve_expressions_statements PROTO( ( Scope ) );
|
||||
extern SC_EXPRESS_EXPORT void SCOPEresolve_subsupers PROTO( ( Scope ) );
|
||||
extern SC_EXPRESS_EXPORT void SCOPEresolve_types PROTO( ( Scope ) );
|
||||
extern SC_EXPRESS_EXPORT void TYPE_resolve PROTO( ( Type * ) );
|
||||
extern SC_EXPRESS_EXPORT void EXP_resolve PROTO( ( Expression, Scope, Type ) );
|
||||
extern SC_EXPRESS_EXPORT void ALGresolve PROTO( ( Scope ) );
|
||||
extern SC_EXPRESS_EXPORT void SCHEMAresolve PROTO( ( Scope ) );
|
||||
|
||||
#endif /*RESOLVE_H*/
|
||||
|
|
|
|||
|
|
@ -50,7 +50,7 @@
|
|||
/* packages used */
|
||||
/*****************/
|
||||
|
||||
#include <scl_export.h>
|
||||
#include <sc_export.h>
|
||||
#include "expbasic.h" /* get basic definitions */
|
||||
#include "symbol.h"
|
||||
#include "scope.h"
|
||||
|
|
@ -104,11 +104,11 @@ struct Schema_ {
|
|||
/* global variables */
|
||||
/********************/
|
||||
|
||||
extern SCL_EXPRESS_EXPORT struct freelist_head REN_fl;
|
||||
extern SCL_EXPRESS_EXPORT struct freelist_head SCOPE_fl;
|
||||
extern SCL_EXPRESS_EXPORT struct freelist_head SCHEMA_fl;
|
||||
extern SC_EXPRESS_EXPORT struct freelist_head REN_fl;
|
||||
extern SC_EXPRESS_EXPORT struct freelist_head SCOPE_fl;
|
||||
extern SC_EXPRESS_EXPORT struct freelist_head SCHEMA_fl;
|
||||
|
||||
extern SCL_EXPRESS_EXPORT int __SCOPE_search_id;
|
||||
extern SC_EXPRESS_EXPORT int __SCOPE_search_id;
|
||||
|
||||
/******************************/
|
||||
/* macro function definitions */
|
||||
|
|
@ -133,20 +133,20 @@ extern SCL_EXPRESS_EXPORT int __SCOPE_search_id;
|
|||
/* function prototypes */
|
||||
/***********************/
|
||||
|
||||
extern SCL_EXPRESS_EXPORT Variable VARfind PROTO( ( Scope, char *, int ) );
|
||||
extern SCL_EXPRESS_EXPORT Schema SCHEMAcreate PROTO( ( void ) );
|
||||
extern SCL_EXPRESS_EXPORT void SCHEMAinitialize PROTO( ( void ) );
|
||||
extern SCL_EXPRESS_EXPORT void SCHEMAadd_use PROTO( ( Schema, Symbol *, Symbol *, Symbol * ) );
|
||||
extern SCL_EXPRESS_EXPORT void SCHEMAadd_reference PROTO( ( Schema, Symbol *, Symbol *, Symbol * ) );
|
||||
extern SCL_EXPRESS_EXPORT void SCHEMAdefine_use PROTO( ( Schema, Rename * ) );
|
||||
extern SCL_EXPRESS_EXPORT void SCHEMAdefine_reference PROTO( ( Schema, Rename * ) );
|
||||
extern SCL_EXPRESS_EXPORT Generic SCHEMAfind PROTO( ( Schema, char * name, int search_refs ) );
|
||||
extern SCL_EXPRESS_EXPORT Scope SCOPEcreate PROTO( ( char ) );
|
||||
extern SCL_EXPRESS_EXPORT Scope SCOPEcreate_tiny PROTO( ( char ) );
|
||||
extern SCL_EXPRESS_EXPORT Scope SCOPEcreate_nostab PROTO( ( char ) );
|
||||
extern SCL_EXPRESS_EXPORT void SCOPEdestroy PROTO( ( Scope ) );
|
||||
extern SCL_EXPRESS_EXPORT Linked_List SCHEMAget_entities_use PROTO( ( Scope ) );
|
||||
extern SCL_EXPRESS_EXPORT Linked_List SCHEMAget_entities_ref PROTO( ( Scope ) );
|
||||
extern SC_EXPRESS_EXPORT Variable VARfind PROTO( ( Scope, char *, int ) );
|
||||
extern SC_EXPRESS_EXPORT Schema SCHEMAcreate PROTO( ( void ) );
|
||||
extern SC_EXPRESS_EXPORT void SCHEMAinitialize PROTO( ( void ) );
|
||||
extern SC_EXPRESS_EXPORT void SCHEMAadd_use PROTO( ( Schema, Symbol *, Symbol *, Symbol * ) );
|
||||
extern SC_EXPRESS_EXPORT void SCHEMAadd_reference PROTO( ( Schema, Symbol *, Symbol *, Symbol * ) );
|
||||
extern SC_EXPRESS_EXPORT void SCHEMAdefine_use PROTO( ( Schema, Rename * ) );
|
||||
extern SC_EXPRESS_EXPORT void SCHEMAdefine_reference PROTO( ( Schema, Rename * ) );
|
||||
extern SC_EXPRESS_EXPORT Generic SCHEMAfind PROTO( ( Schema, char * name, int search_refs ) );
|
||||
extern SC_EXPRESS_EXPORT Scope SCOPEcreate PROTO( ( char ) );
|
||||
extern SC_EXPRESS_EXPORT Scope SCOPEcreate_tiny PROTO( ( char ) );
|
||||
extern SC_EXPRESS_EXPORT Scope SCOPEcreate_nostab PROTO( ( char ) );
|
||||
extern SC_EXPRESS_EXPORT void SCOPEdestroy PROTO( ( Scope ) );
|
||||
extern SC_EXPRESS_EXPORT Linked_List SCHEMAget_entities_use PROTO( ( Scope ) );
|
||||
extern SC_EXPRESS_EXPORT Linked_List SCHEMAget_entities_ref PROTO( ( Scope ) );
|
||||
|
||||
#endif /* SCHEMA_H */
|
||||
|
||||
|
|
|
|||
|
|
@ -49,7 +49,7 @@
|
|||
/* modules used */
|
||||
/****************/
|
||||
|
||||
#include <scl_export.h>
|
||||
#include <sc_export.h>
|
||||
#include "type.h"
|
||||
#include "variable.h"
|
||||
#include "entity.h"
|
||||
|
|
@ -134,14 +134,14 @@ struct Scope_ {
|
|||
/* function prototypes */
|
||||
/***********************/
|
||||
|
||||
extern SCL_EXPRESS_EXPORT struct Symbol_ * SCOPE_get_symbol PROTO( ( Generic ) );
|
||||
extern SCL_EXPRESS_EXPORT void SCOPE_get_entities PROTO( ( Scope, Linked_List ) );
|
||||
extern SCL_EXPRESS_EXPORT Linked_List SCOPEget_entities PROTO( ( Scope ) );
|
||||
extern SCL_EXPRESS_EXPORT Linked_List SCOPEget_entities_superclass_order PROTO( ( Scope ) );
|
||||
extern SCL_EXPRESS_EXPORT Generic SCOPEfind PROTO( ( Scope, char *, int ) );
|
||||
extern SCL_EXPRESS_EXPORT void SCOPE_get_functions PROTO( ( Scope, Linked_List ) );
|
||||
extern SCL_EXPRESS_EXPORT Linked_List SCOPEget_functions PROTO( ( Scope ) );
|
||||
extern SCL_EXPRESS_EXPORT void SCOPE_get_rules PROTO( ( Scope, Linked_List ) );
|
||||
extern SCL_EXPRESS_EXPORT Linked_List SCOPEget_rules PROTO( ( Scope ) );
|
||||
extern SC_EXPRESS_EXPORT struct Symbol_ * SCOPE_get_symbol PROTO( ( Generic ) );
|
||||
extern SC_EXPRESS_EXPORT void SCOPE_get_entities PROTO( ( Scope, Linked_List ) );
|
||||
extern SC_EXPRESS_EXPORT Linked_List SCOPEget_entities PROTO( ( Scope ) );
|
||||
extern SC_EXPRESS_EXPORT Linked_List SCOPEget_entities_superclass_order PROTO( ( Scope ) );
|
||||
extern SC_EXPRESS_EXPORT Generic SCOPEfind PROTO( ( Scope, char *, int ) );
|
||||
extern SC_EXPRESS_EXPORT void SCOPE_get_functions PROTO( ( Scope, Linked_List ) );
|
||||
extern SC_EXPRESS_EXPORT Linked_List SCOPEget_functions PROTO( ( Scope ) );
|
||||
extern SC_EXPRESS_EXPORT void SCOPE_get_rules PROTO( ( Scope, Linked_List ) );
|
||||
extern SC_EXPRESS_EXPORT Linked_List SCOPEget_rules PROTO( ( Scope ) );
|
||||
|
||||
#endif /* SCOPE_H */
|
||||
|
|
|
|||
|
|
@ -48,7 +48,7 @@
|
|||
/* packages used */
|
||||
/*****************/
|
||||
|
||||
#include <scl_export.h>
|
||||
#include <sc_export.h>
|
||||
#include "expbasic.h" /* get basic definitions */
|
||||
#include "scope.h"
|
||||
|
||||
|
|
@ -164,20 +164,20 @@ struct Return_Statement_ {
|
|||
/* global variables */
|
||||
/********************/
|
||||
|
||||
extern SCL_EXPRESS_EXPORT struct freelist_head STMT_fl;
|
||||
extern SC_EXPRESS_EXPORT struct freelist_head STMT_fl;
|
||||
|
||||
extern SCL_EXPRESS_EXPORT struct freelist_head ALIAS_fl;
|
||||
extern SCL_EXPRESS_EXPORT struct freelist_head ASSIGN_fl;
|
||||
extern SCL_EXPRESS_EXPORT struct freelist_head CASE_fl;
|
||||
extern SCL_EXPRESS_EXPORT struct freelist_head COMP_STMT_fl;
|
||||
extern SCL_EXPRESS_EXPORT struct freelist_head COND_fl;
|
||||
extern SCL_EXPRESS_EXPORT struct freelist_head LOOP_fl;
|
||||
extern SCL_EXPRESS_EXPORT struct freelist_head PCALL_fl;
|
||||
extern SCL_EXPRESS_EXPORT struct freelist_head RET_fl;
|
||||
extern SCL_EXPRESS_EXPORT struct freelist_head INCR_fl;
|
||||
extern SC_EXPRESS_EXPORT struct freelist_head ALIAS_fl;
|
||||
extern SC_EXPRESS_EXPORT struct freelist_head ASSIGN_fl;
|
||||
extern SC_EXPRESS_EXPORT struct freelist_head CASE_fl;
|
||||
extern SC_EXPRESS_EXPORT struct freelist_head COMP_STMT_fl;
|
||||
extern SC_EXPRESS_EXPORT struct freelist_head COND_fl;
|
||||
extern SC_EXPRESS_EXPORT struct freelist_head LOOP_fl;
|
||||
extern SC_EXPRESS_EXPORT struct freelist_head PCALL_fl;
|
||||
extern SC_EXPRESS_EXPORT struct freelist_head RET_fl;
|
||||
extern SC_EXPRESS_EXPORT struct freelist_head INCR_fl;
|
||||
|
||||
extern SCL_EXPRESS_EXPORT Statement STATEMENT_ESCAPE;
|
||||
extern SCL_EXPRESS_EXPORT Statement STATEMENT_SKIP;
|
||||
extern SC_EXPRESS_EXPORT Statement STATEMENT_ESCAPE;
|
||||
extern SC_EXPRESS_EXPORT Statement STATEMENT_SKIP;
|
||||
|
||||
/******************************/
|
||||
/* macro function definitions */
|
||||
|
|
@ -225,17 +225,17 @@ extern SCL_EXPRESS_EXPORT Statement STATEMENT_SKIP;
|
|||
/* function prototypes */
|
||||
/***********************/
|
||||
|
||||
extern SCL_EXPRESS_EXPORT Statement STMTcreate PROTO( ( int ) );
|
||||
extern SCL_EXPRESS_EXPORT Statement ALIAScreate PROTO( ( struct Scope_ *, Variable, Linked_List ) );
|
||||
extern SCL_EXPRESS_EXPORT Statement CASEcreate PROTO( ( Expression , Linked_List ) );
|
||||
extern SCL_EXPRESS_EXPORT Statement ASSIGNcreate PROTO( ( Expression , Expression ) );
|
||||
extern SCL_EXPRESS_EXPORT Statement COMP_STMTcreate PROTO( ( Linked_List ) );
|
||||
extern SCL_EXPRESS_EXPORT Statement CONDcreate PROTO( ( Expression, Linked_List, Linked_List ) );
|
||||
extern SCL_EXPRESS_EXPORT Statement LOOPcreate PROTO( ( struct Scope_ *, Expression, Expression, Linked_List ) );
|
||||
extern SCL_EXPRESS_EXPORT Statement PCALLcreate PROTO( ( Linked_List ) );
|
||||
extern SCL_EXPRESS_EXPORT Statement RETcreate PROTO( ( Expression ) );
|
||||
extern SCL_EXPRESS_EXPORT void STMTinitialize PROTO( ( void ) );
|
||||
extern SCL_EXPRESS_EXPORT struct Scope_ * INCR_CTLcreate PROTO( ( Symbol *, Expression start,
|
||||
extern SC_EXPRESS_EXPORT Statement STMTcreate PROTO( ( int ) );
|
||||
extern SC_EXPRESS_EXPORT Statement ALIAScreate PROTO( ( struct Scope_ *, Variable, Linked_List ) );
|
||||
extern SC_EXPRESS_EXPORT Statement CASEcreate PROTO( ( Expression , Linked_List ) );
|
||||
extern SC_EXPRESS_EXPORT Statement ASSIGNcreate PROTO( ( Expression , Expression ) );
|
||||
extern SC_EXPRESS_EXPORT Statement COMP_STMTcreate PROTO( ( Linked_List ) );
|
||||
extern SC_EXPRESS_EXPORT Statement CONDcreate PROTO( ( Expression, Linked_List, Linked_List ) );
|
||||
extern SC_EXPRESS_EXPORT Statement LOOPcreate PROTO( ( struct Scope_ *, Expression, Expression, Linked_List ) );
|
||||
extern SC_EXPRESS_EXPORT Statement PCALLcreate PROTO( ( Linked_List ) );
|
||||
extern SC_EXPRESS_EXPORT Statement RETcreate PROTO( ( Expression ) );
|
||||
extern SC_EXPRESS_EXPORT void STMTinitialize PROTO( ( void ) );
|
||||
extern SC_EXPRESS_EXPORT struct Scope_ * INCR_CTLcreate PROTO( ( Symbol *, Expression start,
|
||||
Expression end, Expression increment ) );
|
||||
|
||||
#endif /*STATEMENT_H*/
|
||||
|
|
|
|||
|
|
@ -43,7 +43,7 @@
|
|||
/* packages used */
|
||||
/*****************/
|
||||
|
||||
#include <scl_export.h>
|
||||
#include <sc_export.h>
|
||||
#include "basic.h" /* get basic definitions */
|
||||
#include "memory.h"
|
||||
|
||||
|
|
@ -72,7 +72,7 @@ struct Symbol_ {
|
|||
/* global variables */
|
||||
/********************/
|
||||
|
||||
extern SCL_EXPRESS_EXPORT struct freelist_head SYMBOL_fl;
|
||||
extern SC_EXPRESS_EXPORT struct freelist_head SYMBOL_fl;
|
||||
|
||||
/******************************/
|
||||
/* macro function definitions */
|
||||
|
|
@ -88,7 +88,7 @@ extern SCL_EXPRESS_EXPORT struct freelist_head SYMBOL_fl;
|
|||
/* function prototypes */
|
||||
/***********************/
|
||||
|
||||
extern SCL_EXPRESS_EXPORT void SYMBOLinitialize PROTO( ( void ) );
|
||||
SCL_EXPRESS_EXPORT Symbol * SYMBOLcreate( char * name, int line, char * filename );
|
||||
extern SC_EXPRESS_EXPORT void SYMBOLinitialize PROTO( ( void ) );
|
||||
SC_EXPRESS_EXPORT Symbol * SYMBOLcreate( char * name, int line, char * filename );
|
||||
|
||||
#endif /* SYMBOL_H */
|
||||
|
|
|
|||
|
|
@ -106,7 +106,7 @@ enum type_enum {
|
|||
/* packages used */
|
||||
/*****************/
|
||||
|
||||
#include <scl_export.h>
|
||||
#include <sc_export.h>
|
||||
#include "expbasic.h" /* get basic definitions */
|
||||
#include "symbol.h"
|
||||
#include "object.h"
|
||||
|
|
@ -178,41 +178,41 @@ struct TypeBody_ {
|
|||
|
||||
/* Very commonly-used read-only types */
|
||||
/* non-constant versions probably aren't necessary? */
|
||||
extern SCL_EXPRESS_EXPORT Type Type_Bad;
|
||||
extern SCL_EXPRESS_EXPORT Type Type_Unknown;
|
||||
extern SCL_EXPRESS_EXPORT Type Type_Dont_Care;
|
||||
extern SCL_EXPRESS_EXPORT Type Type_Runtime; /**< indicates that this object can't be
|
||||
extern SC_EXPRESS_EXPORT Type Type_Bad;
|
||||
extern SC_EXPRESS_EXPORT Type Type_Unknown;
|
||||
extern SC_EXPRESS_EXPORT Type Type_Dont_Care;
|
||||
extern SC_EXPRESS_EXPORT Type Type_Runtime; /**< indicates that this object can't be
|
||||
calculated now but must be deferred
|
||||
until (the mythical) runtime */
|
||||
extern SCL_EXPRESS_EXPORT Type Type_Binary;
|
||||
extern SCL_EXPRESS_EXPORT Type Type_Boolean;
|
||||
extern SCL_EXPRESS_EXPORT Type Type_Enumeration;
|
||||
extern SCL_EXPRESS_EXPORT Type Type_Expression;
|
||||
extern SCL_EXPRESS_EXPORT Type Type_Aggregate;
|
||||
extern SCL_EXPRESS_EXPORT Type Type_Integer;
|
||||
extern SCL_EXPRESS_EXPORT Type Type_Integer;
|
||||
extern SCL_EXPRESS_EXPORT Type Type_Number;
|
||||
extern SCL_EXPRESS_EXPORT Type Type_Real;
|
||||
extern SCL_EXPRESS_EXPORT Type Type_String;
|
||||
extern SCL_EXPRESS_EXPORT Type Type_String_Encoded;
|
||||
extern SCL_EXPRESS_EXPORT Type Type_Logical;
|
||||
extern SCL_EXPRESS_EXPORT Type Type_Set;
|
||||
extern SCL_EXPRESS_EXPORT Type Type_Attribute;
|
||||
extern SCL_EXPRESS_EXPORT Type Type_Entity;
|
||||
extern SCL_EXPRESS_EXPORT Type Type_Funcall;
|
||||
extern SCL_EXPRESS_EXPORT Type Type_Generic;
|
||||
extern SCL_EXPRESS_EXPORT Type Type_Identifier;
|
||||
extern SCL_EXPRESS_EXPORT Type Type_Oneof;
|
||||
extern SCL_EXPRESS_EXPORT Type Type_Query;
|
||||
extern SCL_EXPRESS_EXPORT Type Type_Self;
|
||||
extern SCL_EXPRESS_EXPORT Type Type_Set_Of_String;
|
||||
extern SCL_EXPRESS_EXPORT Type Type_Set_Of_Generic;
|
||||
extern SCL_EXPRESS_EXPORT Type Type_Bag_Of_Generic;
|
||||
extern SC_EXPRESS_EXPORT Type Type_Binary;
|
||||
extern SC_EXPRESS_EXPORT Type Type_Boolean;
|
||||
extern SC_EXPRESS_EXPORT Type Type_Enumeration;
|
||||
extern SC_EXPRESS_EXPORT Type Type_Expression;
|
||||
extern SC_EXPRESS_EXPORT Type Type_Aggregate;
|
||||
extern SC_EXPRESS_EXPORT Type Type_Integer;
|
||||
extern SC_EXPRESS_EXPORT Type Type_Integer;
|
||||
extern SC_EXPRESS_EXPORT Type Type_Number;
|
||||
extern SC_EXPRESS_EXPORT Type Type_Real;
|
||||
extern SC_EXPRESS_EXPORT Type Type_String;
|
||||
extern SC_EXPRESS_EXPORT Type Type_String_Encoded;
|
||||
extern SC_EXPRESS_EXPORT Type Type_Logical;
|
||||
extern SC_EXPRESS_EXPORT Type Type_Set;
|
||||
extern SC_EXPRESS_EXPORT Type Type_Attribute;
|
||||
extern SC_EXPRESS_EXPORT Type Type_Entity;
|
||||
extern SC_EXPRESS_EXPORT Type Type_Funcall;
|
||||
extern SC_EXPRESS_EXPORT Type Type_Generic;
|
||||
extern SC_EXPRESS_EXPORT Type Type_Identifier;
|
||||
extern SC_EXPRESS_EXPORT Type Type_Oneof;
|
||||
extern SC_EXPRESS_EXPORT Type Type_Query;
|
||||
extern SC_EXPRESS_EXPORT Type Type_Self;
|
||||
extern SC_EXPRESS_EXPORT Type Type_Set_Of_String;
|
||||
extern SC_EXPRESS_EXPORT Type Type_Set_Of_Generic;
|
||||
extern SC_EXPRESS_EXPORT Type Type_Bag_Of_Generic;
|
||||
|
||||
extern SCL_EXPRESS_EXPORT struct freelist_head TYPEHEAD_fl;
|
||||
extern SCL_EXPRESS_EXPORT struct freelist_head TYPEBODY_fl;
|
||||
extern SC_EXPRESS_EXPORT struct freelist_head TYPEHEAD_fl;
|
||||
extern SC_EXPRESS_EXPORT struct freelist_head TYPEBODY_fl;
|
||||
|
||||
extern SCL_EXPRESS_EXPORT Error ERROR_corrupted_type;
|
||||
extern SC_EXPRESS_EXPORT Error ERROR_corrupted_type;
|
||||
|
||||
/******************************/
|
||||
/* macro function definitions */
|
||||
|
|
@ -288,20 +288,20 @@ extern SCL_EXPRESS_EXPORT Error ERROR_corrupted_type;
|
|||
/* function prototypes */
|
||||
/***********************/
|
||||
|
||||
extern SCL_EXPRESS_EXPORT Type TYPEcreate_partial PROTO( ( struct Symbol_ *, Scope ) );
|
||||
extern SC_EXPRESS_EXPORT Type TYPEcreate_partial PROTO( ( struct Symbol_ *, Scope ) );
|
||||
|
||||
extern SCL_EXPRESS_EXPORT Type TYPEcreate PROTO( ( enum type_enum ) );
|
||||
extern SCL_EXPRESS_EXPORT Type TYPEcreate_from_body_anonymously PROTO( ( TypeBody ) );
|
||||
extern SCL_EXPRESS_EXPORT Type TYPEcreate_name PROTO( ( struct Symbol_ * ) );
|
||||
extern SCL_EXPRESS_EXPORT Type TYPEcreate_nostab PROTO( ( struct Symbol_ *, Scope, char ) );
|
||||
extern SCL_EXPRESS_EXPORT TypeBody TYPEBODYcreate PROTO( ( enum type_enum ) );
|
||||
extern SCL_EXPRESS_EXPORT void TYPEinitialize PROTO( ( void ) );
|
||||
extern SCL_EXPRESS_EXPORT void TYPEcleanup PROTO( ( void ) );
|
||||
extern SC_EXPRESS_EXPORT Type TYPEcreate PROTO( ( enum type_enum ) );
|
||||
extern SC_EXPRESS_EXPORT Type TYPEcreate_from_body_anonymously PROTO( ( TypeBody ) );
|
||||
extern SC_EXPRESS_EXPORT Type TYPEcreate_name PROTO( ( struct Symbol_ * ) );
|
||||
extern SC_EXPRESS_EXPORT Type TYPEcreate_nostab PROTO( ( struct Symbol_ *, Scope, char ) );
|
||||
extern SC_EXPRESS_EXPORT TypeBody TYPEBODYcreate PROTO( ( enum type_enum ) );
|
||||
extern SC_EXPRESS_EXPORT void TYPEinitialize PROTO( ( void ) );
|
||||
extern SC_EXPRESS_EXPORT void TYPEcleanup PROTO( ( void ) );
|
||||
|
||||
extern SCL_EXPRESS_EXPORT bool TYPEinherits_from PROTO( ( Type, enum type_enum ) );
|
||||
extern SCL_EXPRESS_EXPORT Type TYPEget_nonaggregate_base_type PROTO( ( Type ) );
|
||||
extern SC_EXPRESS_EXPORT bool TYPEinherits_from PROTO( ( Type, enum type_enum ) );
|
||||
extern SC_EXPRESS_EXPORT Type TYPEget_nonaggregate_base_type PROTO( ( Type ) );
|
||||
|
||||
extern SCL_EXPRESS_EXPORT Type TYPEcreate_user_defined_type PROTO( ( Type, Scope, struct Symbol_ * ) );
|
||||
extern SCL_EXPRESS_EXPORT Type TYPEcreate_user_defined_tag PROTO( ( Type, Scope, struct Symbol_ * ) );
|
||||
extern SC_EXPRESS_EXPORT Type TYPEcreate_user_defined_type PROTO( ( Type, Scope, struct Symbol_ * ) );
|
||||
extern SC_EXPRESS_EXPORT Type TYPEcreate_user_defined_tag PROTO( ( Type, Scope, struct Symbol_ * ) );
|
||||
|
||||
#endif /* TYPE_H */
|
||||
|
|
|
|||
|
|
@ -99,7 +99,7 @@ struct Variable_ {
|
|||
/* global variables */
|
||||
/********************/
|
||||
|
||||
extern SCL_EXPRESS_EXPORT struct freelist_head VAR_fl;
|
||||
extern SC_EXPRESS_EXPORT struct freelist_head VAR_fl;
|
||||
|
||||
/******************************/
|
||||
/* macro function definitions */
|
||||
|
|
@ -125,8 +125,8 @@ extern SCL_EXPRESS_EXPORT struct freelist_head VAR_fl;
|
|||
/* function prototypes */
|
||||
/***********************/
|
||||
|
||||
extern SCL_EXPRESS_EXPORT Variable VARcreate PROTO( ( Expression, Type ) );
|
||||
extern SCL_EXPRESS_EXPORT void VARinitialize PROTO( ( void ) );
|
||||
extern SCL_EXPRESS_EXPORT char * VARget_simple_name PROTO( ( Variable ) );
|
||||
extern SC_EXPRESS_EXPORT Variable VARcreate PROTO( ( Expression, Type ) );
|
||||
extern SC_EXPRESS_EXPORT void VARinitialize PROTO( ( void ) );
|
||||
extern SC_EXPRESS_EXPORT char * VARget_simple_name PROTO( ( Variable ) );
|
||||
|
||||
#endif /* VARIABLE_H */
|
||||
|
|
|
|||
108
include/sc_export.h
Normal file
108
include/sc_export.h
Normal file
|
|
@ -0,0 +1,108 @@
|
|||
#ifndef SC_EXPORT_H
|
||||
#define SC_EXPORT_H
|
||||
|
||||
/* Import/Export flags for base. */
|
||||
#ifndef SC_BASE_EXPORT
|
||||
# if defined(SC_BASE_DLL_EXPORTS) && defined(SC_BASE_DLL_IMPORTS)
|
||||
# error "Only SC_BASE_DLL_EXPORTS or SC_BASE_DLL_IMPORTS can be defined, not both."
|
||||
# elif defined(SC_BASE_DLL_EXPORTS)
|
||||
# define SC_BASE_EXPORT __declspec(dllexport)
|
||||
# elif defined(SC_BASE_DLL_IMPORTS)
|
||||
# define SC_BASE_EXPORT __declspec(dllimport)
|
||||
# else
|
||||
# define SC_BASE_EXPORT
|
||||
# endif
|
||||
#endif
|
||||
|
||||
/* Import/Export flags for express. */
|
||||
#ifndef SC_EXPRESS_EXPORT
|
||||
# if defined(SC_EXPRESS_DLL_EXPORTS) && defined(SC_EXPRESS_DLL_IMPORTS)
|
||||
# error "Only SC_EXPRESS_DLL_EXPORTS or SC_EXPRESS_DLL_IMPORTS can be defined, not both."
|
||||
# elif defined(SC_EXPRESS_DLL_EXPORTS)
|
||||
# define SC_EXPRESS_EXPORT __declspec(dllexport)
|
||||
# elif defined(SC_EXPRESS_DLL_IMPORTS)
|
||||
# define SC_EXPRESS_EXPORT __declspec(dllimport)
|
||||
# else
|
||||
# define SC_EXPRESS_EXPORT
|
||||
# endif
|
||||
#endif
|
||||
|
||||
/* Import/Export flags for exppp. */
|
||||
#ifndef SC_EXPPP_EXPORT
|
||||
# if defined(SC_EXPPP_DLL_EXPORTS) && defined(SC_EXPPP_DLL_IMPORTS)
|
||||
# error "Only SC_EXPPP_DLL_EXPORTS or SC_EXPPP_DLL_IMPORTS can be defined, not both."
|
||||
# elif defined(SC_EXPPP_DLL_EXPORTS)
|
||||
# define SC_EXPPP_EXPORT __declspec(dllexport)
|
||||
# elif defined(SC_EXPPP_DLL_IMPORTS)
|
||||
# define SC_EXPPP_EXPORT __declspec(dllimport)
|
||||
# else
|
||||
# define SC_EXPPP_EXPORT
|
||||
# endif
|
||||
#endif
|
||||
|
||||
/* Import/Export flags for utils. */
|
||||
#ifndef SC_UTILS_EXPORT
|
||||
# if defined(SC_UTILS_DLL_EXPORTS) && defined(SC_UTILS_DLL_IMPORTS)
|
||||
# error "Only SC_UTILS_DLL_EXPORTS or SC_UTILS_DLL_IMPORTS can be defined, not both."
|
||||
# elif defined(SC_UTILS_DLL_EXPORTS)
|
||||
# define SC_UTILS_EXPORT __declspec(dllexport)
|
||||
# elif defined(SC_UTILS_DLL_IMPORTS)
|
||||
# define SC_UTILS_EXPORT __declspec(dllimport)
|
||||
# else
|
||||
# define SC_UTILS_EXPORT
|
||||
# endif
|
||||
#endif
|
||||
|
||||
/* Import/Export flags for dai. */
|
||||
#ifndef SC_DAI_EXPORT
|
||||
# if defined(SC_DAI_DLL_EXPORTS) && defined(SC_DAI_DLL_IMPORTS)
|
||||
# error "Only SC_DAI_DLL_EXPORTS or SC_DAI_DLL_IMPORTS can be defined, not both."
|
||||
# elif defined(SC_DAI_DLL_EXPORTS)
|
||||
# define SC_DAI_EXPORT __declspec(dllexport)
|
||||
# elif defined(SC_DAI_DLL_IMPORTS)
|
||||
# define SC_DAI_EXPORT __declspec(dllimport)
|
||||
# else
|
||||
# define SC_DAI_EXPORT
|
||||
# endif
|
||||
#endif
|
||||
|
||||
/* Import/Export flags for core. */
|
||||
#ifndef SC_CORE_EXPORT
|
||||
# if defined(SC_CORE_DLL_EXPORTS) && defined(SC_CORE_DLL_IMPORTS)
|
||||
# error "Only SC_CORE_DLL_EXPORTS or SC_CORE_DLL_IMPORTS can be defined, not both."
|
||||
# elif defined(SC_CORE_DLL_EXPORTS)
|
||||
# define SC_CORE_EXPORT __declspec(dllexport)
|
||||
# elif defined(SC_CORE_DLL_IMPORTS)
|
||||
# define SC_CORE_EXPORT __declspec(dllimport)
|
||||
# else
|
||||
# define SC_CORE_EXPORT
|
||||
# endif
|
||||
#endif
|
||||
|
||||
/* Import/Export flags for editor. */
|
||||
#ifndef SC_EDITOR_EXPORT
|
||||
# if defined(SC_EDITOR_DLL_EXPORTS) && defined(SC_EDITOR_DLL_IMPORTS)
|
||||
# error "Only SC_EDITOR_DLL_EXPORTS or SC_EDITOR_DLL_IMPORTS can be defined, not both."
|
||||
# elif defined(SC_EDITOR_DLL_EXPORTS)
|
||||
# define SC_EDITOR_EXPORT __declspec(dllexport)
|
||||
# elif defined(SC_EDITOR_DLL_IMPORTS)
|
||||
# define SC_EDITOR_EXPORT __declspec(dllimport)
|
||||
# else
|
||||
# define SC_EDITOR_EXPORT
|
||||
# endif
|
||||
#endif
|
||||
|
||||
/* Import/Export flags for lazyfile. */
|
||||
#ifndef SC_LAZYFILE_EXPORT
|
||||
# if defined(SC_LAZYFILE_DLL_EXPORTS) && defined(SC_LAZYFILE_DLL_IMPORTS)
|
||||
# error "Only SC_LAZYFILE_DLL_EXPORTS or SC_LAZYFILE_DLL_IMPORTS can be defined, not both."
|
||||
# elif defined(SC_LAZYFILE_DLL_EXPORTS)
|
||||
# define SC_LAZYFILE_EXPORT __declspec(dllexport)
|
||||
# elif defined(SC_LAZYFILE_DLL_IMPORTS)
|
||||
# define SC_LAZYFILE_EXPORT __declspec(dllimport)
|
||||
# else
|
||||
# define SC_LAZYFILE_EXPORT
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#endif /* SC_EXPORT_H */
|
||||
|
|
@ -1,108 +0,0 @@
|
|||
#ifndef SCL_EXPORT_H
|
||||
#define SCL_EXPORT_H
|
||||
|
||||
/* Import/Export flags for base. */
|
||||
#ifndef SCL_BASE_EXPORT
|
||||
# if defined(SCL_BASE_DLL_EXPORTS) && defined(SCL_BASE_DLL_IMPORTS)
|
||||
# error "Only SCL_BASE_DLL_EXPORTS or SCL_BASE_DLL_IMPORTS can be defined, not both."
|
||||
# elif defined(SCL_BASE_DLL_EXPORTS)
|
||||
# define SCL_BASE_EXPORT __declspec(dllexport)
|
||||
# elif defined(SCL_BASE_DLL_IMPORTS)
|
||||
# define SCL_BASE_EXPORT __declspec(dllimport)
|
||||
# else
|
||||
# define SCL_BASE_EXPORT
|
||||
# endif
|
||||
#endif
|
||||
|
||||
/* Import/Export flags for express. */
|
||||
#ifndef SCL_EXPRESS_EXPORT
|
||||
# if defined(SCL_EXPRESS_DLL_EXPORTS) && defined(SCL_EXPRESS_DLL_IMPORTS)
|
||||
# error "Only SCL_EXPRESS_DLL_EXPORTS or SCL_EXPRESS_DLL_IMPORTS can be defined, not both."
|
||||
# elif defined(SCL_EXPRESS_DLL_EXPORTS)
|
||||
# define SCL_EXPRESS_EXPORT __declspec(dllexport)
|
||||
# elif defined(SCL_EXPRESS_DLL_IMPORTS)
|
||||
# define SCL_EXPRESS_EXPORT __declspec(dllimport)
|
||||
# else
|
||||
# define SCL_EXPRESS_EXPORT
|
||||
# endif
|
||||
#endif
|
||||
|
||||
/* Import/Export flags for exppp. */
|
||||
#ifndef SCL_EXPPP_EXPORT
|
||||
# if defined(SCL_EXPPP_DLL_EXPORTS) && defined(SCL_EXPPP_DLL_IMPORTS)
|
||||
# error "Only SCL_EXPPP_DLL_EXPORTS or SCL_EXPPP_DLL_IMPORTS can be defined, not both."
|
||||
# elif defined(SCL_EXPPP_DLL_EXPORTS)
|
||||
# define SCL_EXPPP_EXPORT __declspec(dllexport)
|
||||
# elif defined(SCL_EXPPP_DLL_IMPORTS)
|
||||
# define SCL_EXPPP_EXPORT __declspec(dllimport)
|
||||
# else
|
||||
# define SCL_EXPPP_EXPORT
|
||||
# endif
|
||||
#endif
|
||||
|
||||
/* Import/Export flags for utils. */
|
||||
#ifndef SCL_UTILS_EXPORT
|
||||
# if defined(SCL_UTILS_DLL_EXPORTS) && defined(SCL_UTILS_DLL_IMPORTS)
|
||||
# error "Only SCL_UTILS_DLL_EXPORTS or SCL_UTILS_DLL_IMPORTS can be defined, not both."
|
||||
# elif defined(SCL_UTILS_DLL_EXPORTS)
|
||||
# define SCL_UTILS_EXPORT __declspec(dllexport)
|
||||
# elif defined(SCL_UTILS_DLL_IMPORTS)
|
||||
# define SCL_UTILS_EXPORT __declspec(dllimport)
|
||||
# else
|
||||
# define SCL_UTILS_EXPORT
|
||||
# endif
|
||||
#endif
|
||||
|
||||
/* Import/Export flags for dai. */
|
||||
#ifndef SCL_DAI_EXPORT
|
||||
# if defined(SCL_DAI_DLL_EXPORTS) && defined(SCL_DAI_DLL_IMPORTS)
|
||||
# error "Only SCL_DAI_DLL_EXPORTS or SCL_DAI_DLL_IMPORTS can be defined, not both."
|
||||
# elif defined(SCL_DAI_DLL_EXPORTS)
|
||||
# define SCL_DAI_EXPORT __declspec(dllexport)
|
||||
# elif defined(SCL_DAI_DLL_IMPORTS)
|
||||
# define SCL_DAI_EXPORT __declspec(dllimport)
|
||||
# else
|
||||
# define SCL_DAI_EXPORT
|
||||
# endif
|
||||
#endif
|
||||
|
||||
/* Import/Export flags for core. */
|
||||
#ifndef SCL_CORE_EXPORT
|
||||
# if defined(SCL_CORE_DLL_EXPORTS) && defined(SCL_CORE_DLL_IMPORTS)
|
||||
# error "Only SCL_CORE_DLL_EXPORTS or SCL_CORE_DLL_IMPORTS can be defined, not both."
|
||||
# elif defined(SCL_CORE_DLL_EXPORTS)
|
||||
# define SCL_CORE_EXPORT __declspec(dllexport)
|
||||
# elif defined(SCL_CORE_DLL_IMPORTS)
|
||||
# define SCL_CORE_EXPORT __declspec(dllimport)
|
||||
# else
|
||||
# define SCL_CORE_EXPORT
|
||||
# endif
|
||||
#endif
|
||||
|
||||
/* Import/Export flags for editor. */
|
||||
#ifndef SCL_EDITOR_EXPORT
|
||||
# if defined(SCL_EDITOR_DLL_EXPORTS) && defined(SCL_EDITOR_DLL_IMPORTS)
|
||||
# error "Only SCL_EDITOR_DLL_EXPORTS or SCL_EDITOR_DLL_IMPORTS can be defined, not both."
|
||||
# elif defined(SCL_EDITOR_DLL_EXPORTS)
|
||||
# define SCL_EDITOR_EXPORT __declspec(dllexport)
|
||||
# elif defined(SCL_EDITOR_DLL_IMPORTS)
|
||||
# define SCL_EDITOR_EXPORT __declspec(dllimport)
|
||||
# else
|
||||
# define SCL_EDITOR_EXPORT
|
||||
# endif
|
||||
#endif
|
||||
|
||||
/* Import/Export flags for lazyfile. */
|
||||
#ifndef SCL_LAZYFILE_EXPORT
|
||||
# if defined(SCL_LAZYFILE_DLL_EXPORTS) && defined(SCL_LAZYFILE_DLL_IMPORTS)
|
||||
# error "Only SCL_LAZYFILE_DLL_EXPORTS or SCL_LAZYFILE_DLL_IMPORTS can be defined, not both."
|
||||
# elif defined(SCL_LAZYFILE_DLL_EXPORTS)
|
||||
# define SCL_LAZYFILE_EXPORT __declspec(dllexport)
|
||||
# elif defined(SCL_LAZYFILE_DLL_IMPORTS)
|
||||
# define SCL_LAZYFILE_EXPORT __declspec(dllimport)
|
||||
# else
|
||||
# define SCL_LAZYFILE_EXPORT
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#endif /* SCL_EXPORT_H */
|
||||
10
lcov.cmake
10
lcov.cmake
|
|
@ -12,10 +12,10 @@ 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_ENABLE_COVERAGE:BOOL=ON
|
||||
SCL_BUILD_SCHEMAS:STRING=ALL
|
||||
SCL_BUILD_TYPE:STRING=Debug
|
||||
SC_ENABLE_TESTING:BOOL=ON
|
||||
SC_ENABLE_COVERAGE:BOOL=ON
|
||||
SC_BUILD_SCHEMAS:STRING=ALL
|
||||
SC_BUILD_TYPE:STRING=Debug
|
||||
")
|
||||
|
||||
set( LCOV_OUT "${CTEST_BINARY_DIRECTORY}/lcov_html" )
|
||||
|
|
@ -23,7 +23,7 @@ set( LCOV_OUT "${CTEST_BINARY_DIRECTORY}/lcov_html" )
|
|||
ctest_start(lcov)
|
||||
ctest_empty_binary_directory(${CTEST_BINARY_DIRECTORY})
|
||||
message("configuring...")
|
||||
ctest_configure( BUILD "${CTEST_BINARY_DIRECTORY}" OPTIONS "-DSCL_BUILD_SCHEMAS=ALL;-DSCL_ENABLE_COVERAGE=ON;-SCL_PYTHON_GENERATOR=OFF" )
|
||||
ctest_configure( BUILD "${CTEST_BINARY_DIRECTORY}" OPTIONS "-DSC_BUILD_SCHEMAS=ALL;-DSC_ENABLE_COVERAGE=ON;-SC_PYTHON_GENERATOR=OFF" )
|
||||
message("lcov: resetting counters...")
|
||||
execute_process( COMMAND lcov -z -d .
|
||||
WORKING_DIRECTORY ${CTEST_BINARY_DIRECTORY} OUTPUT_QUIET )
|
||||
|
|
|
|||
|
|
@ -8,23 +8,23 @@ 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
|
||||
SC_ENABLE_TESTING:BOOL=ON
|
||||
SC_BUILD_TYPE:STRING=Debug
|
||||
")
|
||||
|
||||
|
||||
|
||||
if( EXISTS "../.SCL_CTEST_PREFS.cmake" )
|
||||
include( "../.SCL_CTEST_PREFS.cmake" )
|
||||
if( EXISTS "../.SC_CTEST_PREFS.cmake" )
|
||||
include( "../.SC_CTEST_PREFS.cmake" )
|
||||
else()
|
||||
message( WARNING "Did not find ../.SCL_CTEST_PREFS.cmake, containing config variables - result submission disabled" )
|
||||
message( WARNING "Did not find ../.SC_CTEST_PREFS.cmake, containing config variables - result submission disabled" )
|
||||
set( SKIP_SUBMISSION TRUE )
|
||||
endif()
|
||||
|
||||
######################################################
|
||||
######################################################
|
||||
# use config variables such as these in
|
||||
# ../.SCL_CTEST_PREFS.cmake
|
||||
# ../.SC_CTEST_PREFS.cmake
|
||||
#
|
||||
#set( CTEST_SITE "username")
|
||||
#set( CTEST_BUILD_NAME "build type, os, arch")
|
||||
|
|
@ -66,7 +66,7 @@ file(WRITE "${CTEST_BINARY_DIRECTORY}/CTestCustom.cmake" "
|
|||
set( CTEST_CUSTOM_ERROR_EXCEPTION \"{standard input}:[0-9][0-9]*: WARNING: \")
|
||||
")
|
||||
|
||||
ctest_configure( BUILD "${CTEST_BINARY_DIRECTORY}" APPEND OPTIONS -DSCL_ENABLE_TESTING=ON )
|
||||
ctest_configure( BUILD "${CTEST_BINARY_DIRECTORY}" APPEND OPTIONS -DSC_ENABLE_TESTING=ON )
|
||||
SUBMIT_TEST( Configure )
|
||||
ctest_build( BUILD "${CTEST_BINARY_DIRECTORY}" APPEND )
|
||||
SUBMIT_TEST( Build )
|
||||
|
|
|
|||
|
|
@ -1,20 +1,20 @@
|
|||
|
||||
set(SCL_BASE_SOURCES
|
||||
scl_memmgr.cc
|
||||
scl_trace_fprintf.c
|
||||
set(SC_BASE_SOURCES
|
||||
sc_memmgr.cc
|
||||
sc_trace_fprintf.c
|
||||
sc_getopt.cc
|
||||
sc_benchmark.cc
|
||||
)
|
||||
|
||||
if(MINGW OR MSVC OR BORLAND)
|
||||
add_definitions( -DSCL_BASE_DLL_EXPORTS )
|
||||
add_definitions( -DSC_BASE_DLL_EXPORTS )
|
||||
endif()
|
||||
|
||||
if (${SCL_MEMMGR_ENABLE_CHECKS})
|
||||
add_definitions( -DSCL_MEMMGR_ENABLE_CHECKS )
|
||||
if (${SC_MEMMGR_ENABLE_CHECKS})
|
||||
add_definitions( -DSC_MEMMGR_ENABLE_CHECKS )
|
||||
endif()
|
||||
|
||||
SCL_ADDLIB(base "${SCL_BASE_SOURCES}" "")
|
||||
SC_ADDLIB(base "${SC_BASE_SOURCES}" "")
|
||||
|
||||
if(MINGW OR MSVC OR BORLAND)
|
||||
target_link_libraries(base psapi.lib)
|
||||
|
|
|
|||
|
|
@ -33,15 +33,15 @@
|
|||
// judy_del: delete the key and cell for the current stack entry.
|
||||
|
||||
/* Import/Export flags for base. */
|
||||
#ifndef SCL_BASE_EXPORT
|
||||
# if defined(SCL_BASE_DLL_EXPORTS) && defined(SCL_BASE_DLL_IMPORTS)
|
||||
# error "Only SCL_BASE_DLL_EXPORTS or SCL_BASE_DLL_IMPORTS can be defined, not both."
|
||||
# elif defined(SCL_BASE_DLL_EXPORTS)
|
||||
# define SCL_BASE_EXPORT __declspec(dllexport)
|
||||
# elif defined(SCL_BASE_DLL_IMPORTS)
|
||||
# define SCL_BASE_EXPORT __declspec(dllimport)
|
||||
#ifndef SC_BASE_EXPORT
|
||||
# if defined(SC_BASE_DLL_EXPORTS) && defined(SC_BASE_DLL_IMPORTS)
|
||||
# error "Only SC_BASE_DLL_EXPORTS or SC_BASE_DLL_IMPORTS can be defined, not both."
|
||||
# elif defined(SC_BASE_DLL_EXPORTS)
|
||||
# define SC_BASE_EXPORT __declspec(dllexport)
|
||||
# elif defined(SC_BASE_DLL_IMPORTS)
|
||||
# define SC_BASE_EXPORT __declspec(dllimport)
|
||||
# else
|
||||
# define SCL_BASE_EXPORT
|
||||
# define SC_BASE_EXPORT
|
||||
# endif
|
||||
#endif
|
||||
|
||||
|
|
@ -145,40 +145,40 @@ extern "C" {
|
|||
#endif
|
||||
|
||||
/// open a new judy array returning a judy object.
|
||||
SCL_BASE_EXPORT Judy * judy_open( unsigned int max, unsigned int depth );
|
||||
SC_BASE_EXPORT Judy * judy_open( unsigned int max, unsigned int depth );
|
||||
|
||||
/// close an open judy array, freeing all memory.
|
||||
SCL_BASE_EXPORT void judy_close( Judy * judy );
|
||||
SC_BASE_EXPORT void judy_close( Judy * judy );
|
||||
|
||||
/// clone an open judy array, duplicating the stack.
|
||||
SCL_BASE_EXPORT Judy * judy_clone( Judy * judy );
|
||||
SC_BASE_EXPORT Judy * judy_clone( Judy * judy );
|
||||
|
||||
/// allocate data memory within judy array for external use.
|
||||
SCL_BASE_EXPORT void * judy_data( Judy * judy, unsigned int amt );
|
||||
SC_BASE_EXPORT void * judy_data( Judy * judy, unsigned int amt );
|
||||
|
||||
/// insert a key into the judy array, return cell pointer.
|
||||
SCL_BASE_EXPORT JudySlot * judy_cell( Judy * judy, const unsigned char * buff, unsigned int max );
|
||||
SC_BASE_EXPORT JudySlot * judy_cell( Judy * judy, const unsigned char * buff, unsigned int max );
|
||||
|
||||
/// retrieve the cell pointer greater than or equal to given key
|
||||
SCL_BASE_EXPORT JudySlot * judy_strt( Judy * judy, const unsigned char * buff, unsigned int max );
|
||||
SC_BASE_EXPORT JudySlot * judy_strt( Judy * judy, const unsigned char * buff, unsigned int max );
|
||||
|
||||
/// retrieve the cell pointer, or return NULL for a given key.
|
||||
SCL_BASE_EXPORT JudySlot * judy_slot( Judy * judy, const unsigned char * buff, unsigned int max );
|
||||
SC_BASE_EXPORT JudySlot * judy_slot( Judy * judy, const unsigned char * buff, unsigned int max );
|
||||
|
||||
/// retrieve the string value for the most recent judy query.
|
||||
SCL_BASE_EXPORT unsigned int judy_key( Judy * judy, unsigned char * buff, unsigned int max );
|
||||
SC_BASE_EXPORT unsigned int judy_key( Judy * judy, unsigned char * buff, unsigned int max );
|
||||
|
||||
/// retrieve the cell pointer for the last string in the array.
|
||||
SCL_BASE_EXPORT JudySlot * judy_end( Judy * judy );
|
||||
SC_BASE_EXPORT JudySlot * judy_end( Judy * judy );
|
||||
|
||||
/// retrieve the cell pointer for the next string in the array.
|
||||
SCL_BASE_EXPORT JudySlot * judy_nxt( Judy * judy );
|
||||
SC_BASE_EXPORT JudySlot * judy_nxt( Judy * judy );
|
||||
|
||||
/// retrieve the cell pointer for the prev string in the array.
|
||||
SCL_BASE_EXPORT JudySlot * judy_prv( Judy * judy );
|
||||
SC_BASE_EXPORT JudySlot * judy_prv( Judy * judy );
|
||||
|
||||
/// delete the key and cell for the current stack entry.
|
||||
SCL_BASE_EXPORT JudySlot * judy_del( Judy * judy );
|
||||
SC_BASE_EXPORT JudySlot * judy_del( Judy * judy );
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
/// \file sc_benchmark.cc memory info, timers, etc for benchmarking
|
||||
|
||||
#include "sc_benchmark.h"
|
||||
#include "scl_memmgr.h"
|
||||
#include "sc_memmgr.h"
|
||||
|
||||
#ifdef __WIN32__
|
||||
#include <Windows.h>
|
||||
|
|
|
|||
|
|
@ -2,13 +2,13 @@
|
|||
#define SC_BENCHMARK_H
|
||||
/// \file sc_benchmark.h memory info, timers, etc for benchmarking
|
||||
|
||||
#include "scl_export.h"
|
||||
#include "sc_export.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
#include <iostream>
|
||||
#include <string>
|
||||
|
||||
#include "scl_memmgr.h"
|
||||
#include "sc_memmgr.h"
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
|
|
@ -22,7 +22,7 @@ extern "C" {
|
|||
*
|
||||
* not yet implemented for OSX or Windows.
|
||||
*/
|
||||
SCL_BASE_EXPORT benchVals getMemAndTime( );
|
||||
SC_BASE_EXPORT benchVals getMemAndTime( );
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
|
@ -37,7 +37,7 @@ extern "C" {
|
|||
*
|
||||
* depends on getMemAndTime() above - may not work on all platforms.
|
||||
*/
|
||||
class SCL_BASE_EXPORT benchmark {
|
||||
class SC_BASE_EXPORT benchmark {
|
||||
protected:
|
||||
benchVals initialVals, laterVals;
|
||||
std::ostream & ostr;
|
||||
|
|
|
|||
|
|
@ -15,16 +15,16 @@
|
|||
|
||||
#ifndef XGETOPT_H
|
||||
#define XGETOPT_H
|
||||
#include "scl_export.h"
|
||||
#include "sc_export.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern SCL_BASE_EXPORT int optind, opterr;
|
||||
extern SCL_BASE_EXPORT char * optarg;
|
||||
extern SC_BASE_EXPORT int optind, opterr;
|
||||
extern SC_BASE_EXPORT char * optarg;
|
||||
|
||||
int SCL_BASE_EXPORT sc_getopt( int argc, char * argv[], char * optstring );
|
||||
int SC_BASE_EXPORT sc_getopt( int argc, char * argv[], char * optstring );
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,8 +1,8 @@
|
|||
|
||||
#define SCL_MEMMGR_CC
|
||||
#define SC_MEMMGR_CC
|
||||
|
||||
#include <scl_cf.h>
|
||||
#include "scl_memmgr.h"
|
||||
#include <sc_cf.h>
|
||||
#include "sc_memmgr.h"
|
||||
|
||||
#if __APPLE__
|
||||
# include <malloc/malloc.h>
|
||||
|
|
@ -14,47 +14,47 @@
|
|||
#include <string>
|
||||
#include <set>
|
||||
|
||||
#ifdef SCL_MEMMGR_ENABLE_CHECKS
|
||||
#ifdef SC_MEMMGR_ENABLE_CHECKS
|
||||
|
||||
/**
|
||||
scl_memmgr_error definition
|
||||
sc_memmgr_error definition
|
||||
*/
|
||||
class scl_memmgr_error {
|
||||
class sc_memmgr_error {
|
||||
private:
|
||||
std::string _srcfile;
|
||||
unsigned int _srcline;
|
||||
unsigned int _occurences;
|
||||
public:
|
||||
scl_memmgr_error( const std::string & file, const unsigned int line );
|
||||
scl_memmgr_error( const scl_memmgr_error & rhs );
|
||||
~scl_memmgr_error( void );
|
||||
sc_memmgr_error( const std::string & file, const unsigned int line );
|
||||
sc_memmgr_error( const sc_memmgr_error & rhs );
|
||||
~sc_memmgr_error( void );
|
||||
|
||||
bool operator<( const scl_memmgr_error & rhs ) const;
|
||||
bool operator<( const sc_memmgr_error & rhs ) const;
|
||||
|
||||
std::string getsrcfile( void ) const;
|
||||
unsigned int getsrcline( void ) const;
|
||||
unsigned int getoccurences( void ) const;
|
||||
};
|
||||
|
||||
typedef std::set<scl_memmgr_error> scl_memmgr_errors;
|
||||
typedef std::set<scl_memmgr_error>::iterator scl_memmgr_error_iterator;
|
||||
typedef std::set<sc_memmgr_error> sc_memmgr_errors;
|
||||
typedef std::set<sc_memmgr_error>::iterator sc_memmgr_error_iterator;
|
||||
|
||||
/**
|
||||
scl_memmgr_record definition
|
||||
sc_memmgr_record definition
|
||||
*/
|
||||
class scl_memmgr_record {
|
||||
class sc_memmgr_record {
|
||||
private:
|
||||
void * _addr;
|
||||
size_t _size;
|
||||
std::string _srcfile;
|
||||
unsigned int _srcline;
|
||||
public:
|
||||
scl_memmgr_record( void * addr, size_t size, const char * file, const unsigned int line );
|
||||
scl_memmgr_record( void * addr );
|
||||
scl_memmgr_record( const scl_memmgr_record & rhs );
|
||||
~scl_memmgr_record( void );
|
||||
sc_memmgr_record( void * addr, size_t size, const char * file, const unsigned int line );
|
||||
sc_memmgr_record( void * addr );
|
||||
sc_memmgr_record( const sc_memmgr_record & rhs );
|
||||
~sc_memmgr_record( void );
|
||||
|
||||
bool operator<( const scl_memmgr_record & rhs ) const;
|
||||
bool operator<( const sc_memmgr_record & rhs ) const;
|
||||
|
||||
void * getaddr( void ) const;
|
||||
size_t getsize( void ) const;
|
||||
|
|
@ -62,31 +62,31 @@ class scl_memmgr_record {
|
|||
unsigned int getsrcline( void ) const;
|
||||
};
|
||||
|
||||
typedef std::set<scl_memmgr_record> scl_memmgr_records;
|
||||
typedef std::set<scl_memmgr_record>::iterator scl_memmgr_record_iterator;
|
||||
typedef std::set<sc_memmgr_record> sc_memmgr_records;
|
||||
typedef std::set<sc_memmgr_record>::iterator sc_memmgr_record_iterator;
|
||||
|
||||
#endif /* SCL_MEMMGR_ENABLE_CHECKS */
|
||||
#endif /* SC_MEMMGR_ENABLE_CHECKS */
|
||||
|
||||
/**
|
||||
scl_memmgr definition
|
||||
sc_memmgr definition
|
||||
*/
|
||||
class scl_memmgr {
|
||||
class sc_memmgr {
|
||||
private:
|
||||
#ifdef SCL_MEMMGR_ENABLE_CHECKS
|
||||
#ifdef SC_MEMMGR_ENABLE_CHECKS
|
||||
bool _record_insert_busy, _record_erase_busy;
|
||||
// memory allocation/reallocation records, inserted at allocation, erased at deallocation.
|
||||
scl_memmgr_records _records;
|
||||
sc_memmgr_records _records;
|
||||
// memory stats
|
||||
unsigned int _allocated; // amount of memory allocated simultaniously
|
||||
unsigned int _maximum_allocated; // maximum amount of memory allocated simultaniously
|
||||
unsigned int _allocated_total; // total amount of memory allocated in bytes
|
||||
unsigned int _reallocated_total; // total amount of memory reallocated in bytes
|
||||
unsigned int _deallocated_total; // total amount of memory deallocated in bytes
|
||||
#endif /* SCL_MEMMGR_ENABLE_CHECKS */
|
||||
#endif /* SC_MEMMGR_ENABLE_CHECKS */
|
||||
protected:
|
||||
public:
|
||||
scl_memmgr( void );
|
||||
~scl_memmgr( void );
|
||||
sc_memmgr( void );
|
||||
~sc_memmgr( void );
|
||||
|
||||
void * allocate( size_t size, const char * file, const int line );
|
||||
void * reallocate( void * addr, size_t size, const char * file, const int line );
|
||||
|
|
@ -94,31 +94,31 @@ class scl_memmgr {
|
|||
};
|
||||
|
||||
/**
|
||||
scl_memmgr instance.
|
||||
sc_memmgr instance.
|
||||
There should be one static instance of memmgr.
|
||||
This instance is automatically destroyed when application exits, so this allows us to add
|
||||
memory leak detection in it's destructor.
|
||||
*/
|
||||
scl_memmgr memmgr;
|
||||
sc_memmgr memmgr;
|
||||
|
||||
/**
|
||||
c memory functions implementation
|
||||
*/
|
||||
extern "C" {
|
||||
|
||||
void * scl_malloc_fn( unsigned int size, const char * file, const int line ) {
|
||||
void * sc_malloc_fn( unsigned int size, const char * file, const int line ) {
|
||||
return memmgr.allocate( size, file, line );
|
||||
}
|
||||
|
||||
void * scl_calloc_fn( unsigned int count, unsigned int size, const char * file, const int line ) {
|
||||
void * sc_calloc_fn( unsigned int count, unsigned int size, const char * file, const int line ) {
|
||||
return memmgr.allocate( count * size, file, line );
|
||||
}
|
||||
|
||||
void * scl_realloc_fn( void * addr, unsigned int size, const char * file, const int line ) {
|
||||
void * sc_realloc_fn( void * addr, unsigned int size, const char * file, const int line ) {
|
||||
return memmgr.reallocate( addr, size, file, line );
|
||||
}
|
||||
|
||||
void scl_free_fn( void * addr ) {
|
||||
void sc_free_fn( void * addr ) {
|
||||
memmgr.deallocate( addr, "", 0 );
|
||||
}
|
||||
|
||||
|
|
@ -127,23 +127,23 @@ extern "C" {
|
|||
/**
|
||||
c++ memory operators implementation
|
||||
*/
|
||||
void * scl_operator_new( size_t size, const char * file, const int line ) {
|
||||
void * sc_operator_new( size_t size, const char * file, const int line ) {
|
||||
return memmgr.allocate( size, file, line );
|
||||
}
|
||||
|
||||
void scl_operator_delete( void * addr, const char * file, const int line ) {
|
||||
void sc_operator_delete( void * addr, const char * file, const int line ) {
|
||||
memmgr.deallocate( addr, file, line );
|
||||
}
|
||||
|
||||
void scl_operator_delete( void * addr ) {
|
||||
void sc_operator_delete( void * addr ) {
|
||||
memmgr.deallocate( addr, "", 0 );
|
||||
}
|
||||
|
||||
/**
|
||||
scl_memmgr implementation
|
||||
sc_memmgr implementation
|
||||
*/
|
||||
scl_memmgr::scl_memmgr( void ) {
|
||||
#ifdef SCL_MEMMGR_ENABLE_CHECKS
|
||||
sc_memmgr::sc_memmgr( void ) {
|
||||
#ifdef SC_MEMMGR_ENABLE_CHECKS
|
||||
_record_insert_busy = false;
|
||||
_record_erase_busy = false;
|
||||
|
||||
|
|
@ -152,27 +152,27 @@ scl_memmgr::scl_memmgr( void ) {
|
|||
_allocated_total = 0;
|
||||
_reallocated_total = 0;
|
||||
_deallocated_total = 0;
|
||||
#endif /* SCL_MEMMGR_ENABLE_CHECKS */
|
||||
#endif /* SC_MEMMGR_ENABLE_CHECKS */
|
||||
}
|
||||
|
||||
/**
|
||||
Destructor:
|
||||
scl_memmgr::~scl_memmgr(void)
|
||||
sc_memmgr::~sc_memmgr(void)
|
||||
Description:
|
||||
The scl_memmgr destructor is used to check for memory leaks when enabled.
|
||||
All records still present when scl_memmgr instance is destroyed can be considered as
|
||||
The sc_memmgr destructor is used to check for memory leaks when enabled.
|
||||
All records still present when sc_memmgr instance is destroyed can be considered as
|
||||
memory leaks.
|
||||
*/
|
||||
scl_memmgr::~scl_memmgr( void ) {
|
||||
#ifdef SCL_MEMMGR_ENABLE_CHECKS
|
||||
scl_memmgr_record_iterator irecord;
|
||||
scl_memmgr_errors errors;
|
||||
scl_memmgr_error_iterator ierror;
|
||||
sc_memmgr::~sc_memmgr( void ) {
|
||||
#ifdef SC_MEMMGR_ENABLE_CHECKS
|
||||
sc_memmgr_record_iterator irecord;
|
||||
sc_memmgr_errors errors;
|
||||
sc_memmgr_error_iterator ierror;
|
||||
|
||||
// Check if total allocated equals total deallocated
|
||||
if( _allocated_total != _deallocated_total ) {
|
||||
// todo: generate warning for possible memory leaks, enable full memory leak checking
|
||||
printf( "scl_memmgr warning: Possible memory leaks detected (%d of %d bytes)\n", _allocated_total - _deallocated_total, _allocated_total );
|
||||
printf( "sc_memmgr warning: Possible memory leaks detected (%d of %d bytes)\n", _allocated_total - _deallocated_total, _allocated_total );
|
||||
}
|
||||
|
||||
// Compact leaks into an error list to prevent same leak being reported multiple times.
|
||||
|
|
@ -181,7 +181,7 @@ scl_memmgr::~scl_memmgr( void ) {
|
|||
for( irecord = _records.begin();
|
||||
irecord != _records.end();
|
||||
irecord ++ ) {
|
||||
scl_memmgr_error error( irecord->getsrcfile(), irecord->getsrcline() );
|
||||
sc_memmgr_error error( irecord->getsrcfile(), irecord->getsrcline() );
|
||||
ierror = errors.find( error );
|
||||
if( ierror == errors.end() ) {
|
||||
errors.insert( error );
|
||||
|
|
@ -197,7 +197,7 @@ scl_memmgr::~scl_memmgr( void ) {
|
|||
ierror != errors.end();
|
||||
ierror ++ ) {
|
||||
// todo: generate error for memory leak
|
||||
printf( "scl_memmgr warning: Possible memory leak in %s line %d\n", ierror->getsrcfile().c_str(), ierror->getsrcline() );
|
||||
printf( "sc_memmgr warning: Possible memory leak in %s line %d\n", ierror->getsrcfile().c_str(), ierror->getsrcline() );
|
||||
}
|
||||
|
||||
// Clear remaining records
|
||||
|
|
@ -205,28 +205,28 @@ scl_memmgr::~scl_memmgr( void ) {
|
|||
_records.clear();
|
||||
errors.clear();
|
||||
_record_erase_busy = false;
|
||||
#endif /* SCL_MEMMGR_ENABLE_CHECKS */
|
||||
#endif /* SC_MEMMGR_ENABLE_CHECKS */
|
||||
}
|
||||
|
||||
void * scl_memmgr::allocate( size_t size, const char * file, const int line ) {
|
||||
void * sc_memmgr::allocate( size_t size, const char * file, const int line ) {
|
||||
void * addr;
|
||||
|
||||
// Allocate
|
||||
addr = malloc( size );
|
||||
if( addr == NULL ) {
|
||||
// todo: error allocation failed
|
||||
printf( "scl_memmgr error: Memory allocation failed in %s line %d\n", file, line );
|
||||
printf( "sc_memmgr error: Memory allocation failed in %s line %d\n", file, line );
|
||||
}
|
||||
|
||||
// Some stl implementations (for example debian gcc) use the new operator to construct
|
||||
// new elements when inserting scl_memmgr_record. When this our new operator gets used
|
||||
// new elements when inserting sc_memmgr_record. When this our new operator gets used
|
||||
// for this operation, this would result in an infinite loop. This is fixed by the
|
||||
// _record_insert_busy flag.
|
||||
#ifdef SCL_MEMMGR_ENABLE_CHECKS
|
||||
#ifdef SC_MEMMGR_ENABLE_CHECKS
|
||||
if( !_record_insert_busy ) {
|
||||
// Store record for this allocation
|
||||
_record_insert_busy = true;
|
||||
_records.insert( scl_memmgr_record( addr, size, file, line ) );
|
||||
_records.insert( sc_memmgr_record( addr, size, file, line ) );
|
||||
_record_insert_busy = false;
|
||||
|
||||
// Update stats
|
||||
|
|
@ -236,21 +236,21 @@ void * scl_memmgr::allocate( size_t size, const char * file, const int line ) {
|
|||
}
|
||||
_allocated_total += size;
|
||||
}
|
||||
#endif /* SCL_MEMMGR_ENABLE_CHECKS */
|
||||
#endif /* SC_MEMMGR_ENABLE_CHECKS */
|
||||
|
||||
return addr;
|
||||
}
|
||||
|
||||
void * scl_memmgr::reallocate( void * addr, size_t size, const char * file, const int line ) {
|
||||
#ifdef SCL_MEMMGR_ENABLE_CHECKS
|
||||
scl_memmgr_record_iterator record;
|
||||
void * sc_memmgr::reallocate( void * addr, size_t size, const char * file, const int line ) {
|
||||
#ifdef SC_MEMMGR_ENABLE_CHECKS
|
||||
sc_memmgr_record_iterator record;
|
||||
|
||||
if( !_record_insert_busy ) {
|
||||
// Find record of previous allocation/reallocation
|
||||
record = _records.find( scl_memmgr_record( addr ) );
|
||||
record = _records.find( sc_memmgr_record( addr ) );
|
||||
if( record == _records.end() ) {
|
||||
// todo: error reallocating memory not allocated?
|
||||
printf( "scl_memmgr warning: Reallocation of not allocated memory at %s line %d\n", file, line );
|
||||
printf( "sc_memmgr warning: Reallocation of not allocated memory at %s line %d\n", file, line );
|
||||
} else {
|
||||
// Update stats
|
||||
_allocated -= record->getsize();
|
||||
|
|
@ -262,20 +262,20 @@ void * scl_memmgr::reallocate( void * addr, size_t size, const char * file, cons
|
|||
_record_erase_busy = false;
|
||||
}
|
||||
}
|
||||
#endif /* SCL_MEMMGR_ENABLE_CHECKS */
|
||||
#endif /* SC_MEMMGR_ENABLE_CHECKS */
|
||||
|
||||
// Reallocate
|
||||
addr = realloc( addr, size );
|
||||
if( addr == NULL ) {
|
||||
// todo: error reallocation failed
|
||||
printf( "scl_memmgr error: Reallocation failed at %s line %d\n", file, line );
|
||||
printf( "sc_memmgr error: Reallocation failed at %s line %d\n", file, line );
|
||||
}
|
||||
|
||||
#ifdef SCL_MEMMGR_ENABLE_CHECKS
|
||||
#ifdef SC_MEMMGR_ENABLE_CHECKS
|
||||
if( !_record_insert_busy ) {
|
||||
// Store record for this reallocation
|
||||
_record_insert_busy = true;
|
||||
_records.insert( scl_memmgr_record( addr, size, file, line ) );
|
||||
_records.insert( sc_memmgr_record( addr, size, file, line ) );
|
||||
_record_insert_busy = false;
|
||||
|
||||
// Update stats
|
||||
|
|
@ -286,21 +286,21 @@ void * scl_memmgr::reallocate( void * addr, size_t size, const char * file, cons
|
|||
_allocated_total += size;
|
||||
_reallocated_total += size;
|
||||
}
|
||||
#endif /* SCL_MEMMGR_ENABLE_CHECKS */
|
||||
#endif /* SC_MEMMGR_ENABLE_CHECKS */
|
||||
|
||||
return addr;
|
||||
}
|
||||
|
||||
void scl_memmgr::deallocate( void * addr, const char * file, const int line ) {
|
||||
#ifdef SCL_MEMMGR_ENABLE_CHECKS
|
||||
scl_memmgr_record_iterator record;
|
||||
void sc_memmgr::deallocate( void * addr, const char * file, const int line ) {
|
||||
#ifdef SC_MEMMGR_ENABLE_CHECKS
|
||||
sc_memmgr_record_iterator record;
|
||||
|
||||
if( !_record_erase_busy ) {
|
||||
// Find record of previous allocation/reallocation
|
||||
record = _records.find( scl_memmgr_record( addr ) );
|
||||
record = _records.find( sc_memmgr_record( addr ) );
|
||||
if( record == _records.end() ) {
|
||||
// todo: error free called for not allocated memory?
|
||||
printf( "scl_memmgr warning: Deallocate of not allocated memory at %s line %d\n", file, line );
|
||||
printf( "sc_memmgr warning: Deallocate of not allocated memory at %s line %d\n", file, line );
|
||||
} else {
|
||||
// Update stats
|
||||
_allocated -= record->getsize();
|
||||
|
|
@ -312,95 +312,95 @@ void scl_memmgr::deallocate( void * addr, const char * file, const int line ) {
|
|||
_record_erase_busy = false;
|
||||
}
|
||||
}
|
||||
#endif /* SCL_MEMMGR_ENABLE_CHECKS */
|
||||
#endif /* SC_MEMMGR_ENABLE_CHECKS */
|
||||
|
||||
// Deallocate
|
||||
free( addr );
|
||||
}
|
||||
|
||||
#ifdef SCL_MEMMGR_ENABLE_CHECKS
|
||||
#ifdef SC_MEMMGR_ENABLE_CHECKS
|
||||
/**
|
||||
scl_memmgr_error implementation
|
||||
sc_memmgr_error implementation
|
||||
*/
|
||||
scl_memmgr_error::scl_memmgr_error( const std::string & file, const unsigned int line ) {
|
||||
sc_memmgr_error::sc_memmgr_error( const std::string & file, const unsigned int line ) {
|
||||
_srcfile = file;
|
||||
_srcline = line;
|
||||
_occurences = 1;
|
||||
}
|
||||
|
||||
scl_memmgr_error::scl_memmgr_error( const scl_memmgr_error & rhs ) {
|
||||
sc_memmgr_error::sc_memmgr_error( const sc_memmgr_error & rhs ) {
|
||||
_srcfile = rhs._srcfile;
|
||||
_srcline = rhs._srcline;
|
||||
_occurences = rhs._occurences;
|
||||
}
|
||||
|
||||
scl_memmgr_error::~scl_memmgr_error( void ) {
|
||||
sc_memmgr_error::~sc_memmgr_error( void ) {
|
||||
}
|
||||
|
||||
bool scl_memmgr_error::operator<( const scl_memmgr_error & rhs ) const {
|
||||
bool sc_memmgr_error::operator<( const sc_memmgr_error & rhs ) const {
|
||||
if( _srcfile == rhs._srcfile ) {
|
||||
return _srcline < rhs._srcline;
|
||||
}
|
||||
return _srcfile < rhs._srcfile;
|
||||
}
|
||||
|
||||
std::string scl_memmgr_error::getsrcfile( void ) const {
|
||||
std::string sc_memmgr_error::getsrcfile( void ) const {
|
||||
return _srcfile;
|
||||
}
|
||||
|
||||
unsigned int scl_memmgr_error::getsrcline( void ) const {
|
||||
unsigned int sc_memmgr_error::getsrcline( void ) const {
|
||||
return _srcline;
|
||||
}
|
||||
|
||||
unsigned int scl_memmgr_error::getoccurences( void ) const {
|
||||
unsigned int sc_memmgr_error::getoccurences( void ) const {
|
||||
return _occurences;
|
||||
}
|
||||
|
||||
/**
|
||||
scl_memmgr_record implementation
|
||||
sc_memmgr_record implementation
|
||||
*/
|
||||
scl_memmgr_record::scl_memmgr_record( void * addr, size_t size, const char * file, const unsigned int line ) {
|
||||
sc_memmgr_record::sc_memmgr_record( void * addr, size_t size, const char * file, const unsigned int line ) {
|
||||
_addr = addr;
|
||||
_size = size;
|
||||
_srcfile = file;
|
||||
_srcline = line;
|
||||
}
|
||||
|
||||
scl_memmgr_record::scl_memmgr_record( void * addr ) {
|
||||
sc_memmgr_record::sc_memmgr_record( void * addr ) {
|
||||
_addr = addr;
|
||||
_size = 0;
|
||||
_srcfile = "";
|
||||
_srcline = -1;
|
||||
}
|
||||
|
||||
scl_memmgr_record::scl_memmgr_record( const scl_memmgr_record & rhs ) {
|
||||
sc_memmgr_record::sc_memmgr_record( const sc_memmgr_record & rhs ) {
|
||||
_addr = rhs._addr;
|
||||
_size = rhs._size;
|
||||
_srcfile = rhs._srcfile;
|
||||
_srcline = rhs._srcline;
|
||||
}
|
||||
|
||||
scl_memmgr_record::~scl_memmgr_record( void ) {
|
||||
sc_memmgr_record::~sc_memmgr_record( void ) {
|
||||
}
|
||||
|
||||
bool scl_memmgr_record::operator<( const scl_memmgr_record & rhs ) const {
|
||||
bool sc_memmgr_record::operator<( const sc_memmgr_record & rhs ) const {
|
||||
return _addr < rhs._addr;
|
||||
}
|
||||
|
||||
void * scl_memmgr_record::getaddr( void ) const {
|
||||
void * sc_memmgr_record::getaddr( void ) const {
|
||||
return _addr;
|
||||
}
|
||||
|
||||
size_t scl_memmgr_record::getsize( void ) const {
|
||||
size_t sc_memmgr_record::getsize( void ) const {
|
||||
return _size;
|
||||
}
|
||||
|
||||
std::string scl_memmgr_record::getsrcfile( void ) const {
|
||||
std::string sc_memmgr_record::getsrcfile( void ) const {
|
||||
return _srcfile;
|
||||
}
|
||||
|
||||
unsigned int scl_memmgr_record::getsrcline( void ) const {
|
||||
unsigned int sc_memmgr_record::getsrcline( void ) const {
|
||||
return _srcline;
|
||||
}
|
||||
|
||||
#endif /* SCL_MEMMGR_ENABLE_CHECKS */
|
||||
#endif /* SC_MEMMGR_ENABLE_CHECKS */
|
||||
90
src/base/sc_memmgr.h
Normal file
90
src/base/sc_memmgr.h
Normal file
|
|
@ -0,0 +1,90 @@
|
|||
#ifndef SC_MEMMGR_H
|
||||
#define SC_MEMMGR_H
|
||||
|
||||
#include <sc_export.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#if defined(SC_MEMMGR_ENABLE_CHECKS)
|
||||
|
||||
/**
|
||||
Platform specific defines
|
||||
*/
|
||||
#if defined(__MSVC__) || defined(__BORLAND__)
|
||||
#define THROW_STD_BAD_ALLOC
|
||||
#define THROW_EMPTY
|
||||
#else
|
||||
#define THROW_STD_BAD_ALLOC throw (std::bad_alloc)
|
||||
#define THROW_EMPTY throw ()
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
#include <stddef.h>
|
||||
extern "C" {
|
||||
#endif /* __cplusplus */
|
||||
|
||||
SC_BASE_EXPORT void * sc_malloc_fn( unsigned int size, const char * file, const int line );
|
||||
SC_BASE_EXPORT void * sc_calloc_fn( unsigned int count, unsigned int size, const char * file, const int line );
|
||||
SC_BASE_EXPORT void * sc_realloc_fn( void * addr, unsigned int size, const char * file, const int line );
|
||||
SC_BASE_EXPORT void sc_free_fn( void * addr );
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif /* __cplusplus */
|
||||
|
||||
#ifdef __cplusplus
|
||||
|
||||
SC_BASE_EXPORT void * sc_operator_new( size_t size, const char * file, const int line );
|
||||
SC_BASE_EXPORT void sc_operator_delete( void * addr, const char * file, const int line );
|
||||
SC_BASE_EXPORT void sc_operator_delete( void * addr );
|
||||
|
||||
#endif /* __cplusplus */
|
||||
|
||||
#ifndef SC_MEMMGR_CC
|
||||
|
||||
#define sc_malloc(size) sc_malloc_fn(size, __FILE__, __LINE__)
|
||||
#define sc_calloc(count, size) sc_calloc_fn(count, size, __FILE__, __LINE__)
|
||||
#define sc_realloc(addr, size) sc_realloc_fn(addr, size, __FILE__, __LINE__)
|
||||
#define sc_free(addr) sc_free_fn(addr)
|
||||
|
||||
#ifdef __cplusplus
|
||||
|
||||
#include <new>
|
||||
|
||||
inline void * operator new( size_t size, const char * file, const int line ) THROW_STD_BAD_ALLOC {
|
||||
return sc_operator_new( size, file, line );
|
||||
}
|
||||
|
||||
inline void * operator new[]( size_t size, const char * file, const int line ) THROW_STD_BAD_ALLOC {
|
||||
return sc_operator_new( size, file, line );
|
||||
}
|
||||
|
||||
inline void operator delete( void * addr, const char * file, const int line ) THROW_STD_BAD_ALLOC {
|
||||
sc_operator_delete( addr, file, line );
|
||||
}
|
||||
|
||||
inline void operator delete[]( void * addr, const char * file, const int line ) THROW_STD_BAD_ALLOC {
|
||||
sc_operator_delete( addr, file, line );
|
||||
}
|
||||
|
||||
inline void operator delete( void * addr ) THROW_EMPTY {
|
||||
sc_operator_delete( addr );
|
||||
}
|
||||
|
||||
inline void operator delete[]( void * addr ) THROW_EMPTY {
|
||||
sc_operator_delete( addr );
|
||||
}
|
||||
|
||||
#define new new(__FILE__, __LINE__)
|
||||
|
||||
#endif /* __cplusplus */
|
||||
|
||||
#endif /* SC_MEMMGR_CC */
|
||||
|
||||
#else
|
||||
#define sc_malloc(size) malloc(size)
|
||||
#define sc_calloc(count, size) calloc(count, size)
|
||||
#define sc_realloc(addr, size) realloc(addr, size)
|
||||
#define sc_free(addr) free(addr)
|
||||
#endif /* SC_MEMMGR_ENABLE_CHECKS */
|
||||
|
||||
#endif /* SC_MEMMGR_H */
|
||||
|
|
@ -2,7 +2,7 @@
|
|||
#include <stdarg.h>
|
||||
#include <stdio.h>
|
||||
|
||||
#include "scl_trace_fprintf.h"
|
||||
#include "sc_trace_fprintf.h"
|
||||
|
||||
void trace_fprintf (char const *sourcefile, int line, FILE* file, const char *format, ...) {
|
||||
va_list args;
|
||||
|
|
@ -1,32 +1,32 @@
|
|||
#ifndef SCL_TRACE_FPRINTF_H
|
||||
#define SCL_TRACE_FPRINTF_H
|
||||
#ifndef SC_TRACE_FPRINTF_H
|
||||
#define SC_TRACE_FPRINTF_H
|
||||
|
||||
/** \file scl_trace_fprintf.h
|
||||
/** \file sc_trace_fprintf.h
|
||||
* Used to track the source file and line where generated code is printed from
|
||||
* When enabled, comments are printed into the generated files for every 'fprintf':
|
||||
* / * source: scl/src/fedex_plus/selects.c:1375 * /
|
||||
* To enable, configure with 'cmake .. -DSCL_TRACE_FPRINTF=ON'
|
||||
* To enable, configure with 'cmake .. -DSC_TRACE_FPRINTF=ON'
|
||||
*
|
||||
* This header must be included *after* all other headers, otherwise the compiler will
|
||||
* report errors in system headers.
|
||||
* \sa trace_fprintf
|
||||
**/
|
||||
|
||||
#include "scl_export.h"
|
||||
#include "sc_export.h"
|
||||
|
||||
/** used to find where generated c++ originates from in fedex_plus
|
||||
* To enable, configure with 'cmake .. -DSCL_TRACE_FPRINTF=ON'
|
||||
* To enable, configure with 'cmake .. -DSC_TRACE_FPRINTF=ON'
|
||||
*/
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
SCL_BASE_EXPORT void trace_fprintf( char const * sourcefile, int line, FILE * file, const char * format, ... );
|
||||
SC_BASE_EXPORT void trace_fprintf( char const * sourcefile, int line, FILE * file, const char * format, ... );
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef SCL_TRACE_FPRINTF
|
||||
#ifdef SC_TRACE_FPRINTF
|
||||
# define fprintf(...) trace_fprintf(__FILE__, __LINE__, __VA_ARGS__)
|
||||
#endif /* SCL_TRACE_FPRINTF */
|
||||
#endif /* SC_TRACE_FPRINTF */
|
||||
|
||||
#endif /* SCL_TRACE_FPRINTF_H */
|
||||
#endif /* SC_TRACE_FPRINTF_H */
|
||||
|
|
@ -1,90 +0,0 @@
|
|||
#ifndef SCL_MEMMGR_H
|
||||
#define SCL_MEMMGR_H
|
||||
|
||||
#include <scl_export.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#if defined(SCL_MEMMGR_ENABLE_CHECKS)
|
||||
|
||||
/**
|
||||
Platform specific defines
|
||||
*/
|
||||
#if defined(__MSVC__) || defined(__BORLAND__)
|
||||
#define THROW_STD_BAD_ALLOC
|
||||
#define THROW_EMPTY
|
||||
#else
|
||||
#define THROW_STD_BAD_ALLOC throw (std::bad_alloc)
|
||||
#define THROW_EMPTY throw ()
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
#include <stddef.h>
|
||||
extern "C" {
|
||||
#endif /* __cplusplus */
|
||||
|
||||
SCL_BASE_EXPORT void * scl_malloc_fn( unsigned int size, const char * file, const int line );
|
||||
SCL_BASE_EXPORT void * scl_calloc_fn( unsigned int count, unsigned int size, const char * file, const int line );
|
||||
SCL_BASE_EXPORT void * scl_realloc_fn( void * addr, unsigned int size, const char * file, const int line );
|
||||
SCL_BASE_EXPORT void scl_free_fn( void * addr );
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif /* __cplusplus */
|
||||
|
||||
#ifdef __cplusplus
|
||||
|
||||
SCL_BASE_EXPORT void * scl_operator_new( size_t size, const char * file, const int line );
|
||||
SCL_BASE_EXPORT void scl_operator_delete( void * addr, const char * file, const int line );
|
||||
SCL_BASE_EXPORT void scl_operator_delete( void * addr );
|
||||
|
||||
#endif /* __cplusplus */
|
||||
|
||||
#ifndef SCL_MEMMGR_CC
|
||||
|
||||
#define scl_malloc(size) scl_malloc_fn(size, __FILE__, __LINE__)
|
||||
#define scl_calloc(count, size) scl_calloc_fn(count, size, __FILE__, __LINE__)
|
||||
#define scl_realloc(addr, size) scl_realloc_fn(addr, size, __FILE__, __LINE__)
|
||||
#define scl_free(addr) scl_free_fn(addr)
|
||||
|
||||
#ifdef __cplusplus
|
||||
|
||||
#include <new>
|
||||
|
||||
inline void * operator new( size_t size, const char * file, const int line ) THROW_STD_BAD_ALLOC {
|
||||
return scl_operator_new( size, file, line );
|
||||
}
|
||||
|
||||
inline void * operator new[]( size_t size, const char * file, const int line ) THROW_STD_BAD_ALLOC {
|
||||
return scl_operator_new( size, file, line );
|
||||
}
|
||||
|
||||
inline void operator delete( void * addr, const char * file, const int line ) THROW_STD_BAD_ALLOC {
|
||||
scl_operator_delete( addr, file, line );
|
||||
}
|
||||
|
||||
inline void operator delete[]( void * addr, const char * file, const int line ) THROW_STD_BAD_ALLOC {
|
||||
scl_operator_delete( addr, file, line );
|
||||
}
|
||||
|
||||
inline void operator delete( void * addr ) THROW_EMPTY {
|
||||
scl_operator_delete( addr );
|
||||
}
|
||||
|
||||
inline void operator delete[]( void * addr ) THROW_EMPTY {
|
||||
scl_operator_delete( addr );
|
||||
}
|
||||
|
||||
#define new new(__FILE__, __LINE__)
|
||||
|
||||
#endif /* __cplusplus */
|
||||
|
||||
#endif /* SCL_MEMMGR_CC */
|
||||
|
||||
#else
|
||||
#define scl_malloc(size) malloc(size)
|
||||
#define scl_calloc(count, size) calloc(count, size)
|
||||
#define scl_realloc(addr, size) realloc(addr, size)
|
||||
#define scl_free(addr) free(addr)
|
||||
#endif /* SCL_MEMMGR_ENABLE_CHECKS */
|
||||
|
||||
#endif /* SCL_MEMMGR_H */
|
||||
|
|
@ -30,9 +30,9 @@ SET(LIBSTEPDAI_PRIVATE_HDRS
|
|||
|
||||
include_directories(
|
||||
${CMAKE_CURRENT_SOURCE_DIR}
|
||||
${SCL_SOURCE_DIR}/src/base
|
||||
${SCL_SOURCE_DIR}/src/clstepcore
|
||||
${SCL_SOURCE_DIR}/src/clutils
|
||||
${SC_SOURCE_DIR}/src/base
|
||||
${SC_SOURCE_DIR}/src/clstepcore
|
||||
${SC_SOURCE_DIR}/src/clutils
|
||||
)
|
||||
|
||||
SCL_ADDLIB(stepdai "${LIBSTEPDAI_SRCS}" "steputils;base")
|
||||
SC_ADDLIB(stepdai "${LIBSTEPDAI_SRCS}" "steputils;base")
|
||||
|
|
|
|||
|
|
@ -29,7 +29,7 @@
|
|||
|
||||
#include <memory.h>
|
||||
#include <math.h>
|
||||
#include "scl_memmgr.h"
|
||||
#include "sc_memmgr.h"
|
||||
|
||||
// to help ObjectCenter
|
||||
#ifndef HAVE_MEMMOVE
|
||||
|
|
|
|||
|
|
@ -30,14 +30,14 @@
|
|||
#ifndef SDAI_APPLICATION_INSTANCE_SET_h
|
||||
#define SDAI_APPLICATION_INSTANCE_SET_h
|
||||
|
||||
#include <scl_export.h>
|
||||
#include <sc_export.h>
|
||||
|
||||
class SDAI_Application_instance;
|
||||
class SDAI_Application_instance__set;
|
||||
typedef SDAI_Application_instance__set * SDAI_Application_instance__set_ptr;
|
||||
typedef SDAI_Application_instance__set_ptr SDAI_Application_instance__set_var;
|
||||
|
||||
class SCL_DAI_EXPORT SDAI_Application_instance__set {
|
||||
class SC_DAI_EXPORT SDAI_Application_instance__set {
|
||||
public:
|
||||
SDAI_Application_instance__set( int = 16 );
|
||||
~SDAI_Application_instance__set();
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@
|
|||
|
||||
#include <sstream>
|
||||
#include <sdai.h>
|
||||
#include "scl_memmgr.h"
|
||||
#include "sc_memmgr.h"
|
||||
|
||||
SDAI_Binary::SDAI_Binary( const char * str, int max ) {
|
||||
content = std::string( str, max );
|
||||
|
|
|
|||
|
|
@ -13,7 +13,7 @@
|
|||
* and is not subject to copyright.
|
||||
*/
|
||||
|
||||
class SCL_DAI_EXPORT SDAI_Binary {
|
||||
class SC_DAI_EXPORT SDAI_Binary {
|
||||
private:
|
||||
std::string content;
|
||||
public:
|
||||
|
|
|
|||
|
|
@ -3,7 +3,7 @@
|
|||
#include <math.h>
|
||||
|
||||
#include <sdai.h>
|
||||
#include "scl_memmgr.h"
|
||||
#include "sc_memmgr.h"
|
||||
|
||||
// to help ObjectCenter
|
||||
#ifndef HAVE_MEMMOVE
|
||||
|
|
|
|||
|
|
@ -5,7 +5,7 @@
|
|||
#include <sdaiString.h>
|
||||
#include <sdaiEnum.h>
|
||||
|
||||
#include <scl_export.h>
|
||||
#include <sc_export.h>
|
||||
|
||||
typedef char * SDAI_DAObjectID;
|
||||
|
||||
|
|
@ -30,7 +30,7 @@ typedef char * SDAI_DAObjectID;
|
|||
SDAI_DAObjectID as follows:
|
||||
*/
|
||||
|
||||
class SCL_DAI_EXPORT SDAI_PID : public SDAI_sdaiObject {
|
||||
class SC_DAI_EXPORT SDAI_PID : public SDAI_sdaiObject {
|
||||
public:
|
||||
|
||||
// These are in the IDL generated code for Part 26. I will have to think about
|
||||
|
|
@ -89,7 +89,7 @@ typedef SDAI_PID_ptr SDAI_PID_var;
|
|||
// interface.
|
||||
//
|
||||
|
||||
class SCL_DAI_EXPORT SDAI_PID_DA: public SDAI_PID {
|
||||
class SC_DAI_EXPORT SDAI_PID_DA: public SDAI_PID {
|
||||
public:
|
||||
|
||||
SDAI_String _oid;
|
||||
|
|
@ -125,7 +125,7 @@ typedef SDAI_PID_DA_ptr SDAI_PID_DA_var;
|
|||
// The PID_SDAI class maintains the persistent object identifier for
|
||||
// a Model_contents object.
|
||||
//
|
||||
class SCL_DAI_EXPORT SDAI_PID_SDAI : public SDAI_PID {
|
||||
class SC_DAI_EXPORT SDAI_PID_SDAI : public SDAI_PID {
|
||||
public:
|
||||
SDAI_String _modelid;
|
||||
|
||||
|
|
@ -166,7 +166,7 @@ class SDAI_DAObject;
|
|||
typedef SDAI_DAObject * SDAI_DAObject_ptr;
|
||||
typedef SDAI_DAObject_ptr SDAI_DAObject_var;
|
||||
|
||||
class SCL_DAI_EXPORT SDAI_DAObject : public SDAI_sdaiObject {
|
||||
class SC_DAI_EXPORT SDAI_DAObject : public SDAI_sdaiObject {
|
||||
public:
|
||||
|
||||
SDAI_String _dado_oid;
|
||||
|
|
@ -265,7 +265,7 @@ class SCL_DAI_EXPORT SDAI_DAObject : public SDAI_sdaiObject {
|
|||
5.3.10.1 DAObject_SDAI
|
||||
*/
|
||||
|
||||
class SCL_DAI_EXPORT SDAI_DAObject_SDAI : public SDAI_DAObject {
|
||||
class SC_DAI_EXPORT SDAI_DAObject_SDAI : public SDAI_DAObject {
|
||||
|
||||
public:
|
||||
SDAI_DAObject_SDAI();
|
||||
|
|
@ -488,7 +488,7 @@ class SCL_DAI_EXPORT SDAI_DAObject_SDAI : public SDAI_DAObject {
|
|||
typedef SDAI_DAObject_SDAI * SDAI_DAObject_SDAI_ptr;
|
||||
typedef SDAI_DAObject_SDAI_ptr SDAI_DAObject_SDAI_var;
|
||||
|
||||
class SCL_DAI_EXPORT SDAI_DAObject__set {
|
||||
class SC_DAI_EXPORT SDAI_DAObject__set {
|
||||
public:
|
||||
SDAI_DAObject__set( int = 16 );
|
||||
~SDAI_DAObject__set();
|
||||
|
|
|
|||
|
|
@ -3,7 +3,7 @@
|
|||
//#include <EntityExtent.h>
|
||||
|
||||
#include <sdai.h>
|
||||
#include "scl_memmgr.h"
|
||||
#include "sc_memmgr.h"
|
||||
|
||||
SDAI_Entity_extent::SDAI_Entity_extent( )
|
||||
: _definition( 0 ), _definition_name( 0 ), _owned_by( 0 ) {
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
#ifndef ENTITYEXTENT_H
|
||||
#define ENTITYEXTENT_H 1
|
||||
|
||||
#include <scl_export.h>
|
||||
#include <sc_export.h>
|
||||
|
||||
/*
|
||||
//#include <sdaiDefs.h>
|
||||
|
|
@ -18,7 +18,7 @@ class SDAI_Entity_extent;
|
|||
typedef SDAI_Entity_extent * SDAI_Entity_extent_ptr;
|
||||
typedef SDAI_Entity_extent_ptr SDAI_Entity_extent_var;
|
||||
|
||||
class SCL_DAI_EXPORT SDAI_Entity_extent : public SDAI_Session_instance {
|
||||
class SC_DAI_EXPORT SDAI_Entity_extent : public SDAI_Session_instance {
|
||||
|
||||
friend class SDAI_Model_contents;
|
||||
/*
|
||||
|
|
|
|||
|
|
@ -27,7 +27,7 @@
|
|||
#include <math.h>
|
||||
|
||||
#include <sdai.h>
|
||||
#include "scl_memmgr.h"
|
||||
#include "sc_memmgr.h"
|
||||
|
||||
/*
|
||||
#include <EntityExtent.h>
|
||||
|
|
|
|||
|
|
@ -27,7 +27,7 @@
|
|||
* UArray - dynamic array object.
|
||||
*/
|
||||
|
||||
#include <scl_export.h>
|
||||
#include <sc_export.h>
|
||||
|
||||
#ifndef SDAIENTITY_EXTENT_SET_h
|
||||
#define SDAIENTITY_EXTENT_SET_h
|
||||
|
|
@ -37,7 +37,7 @@
|
|||
//#include <EntityExtent.h>
|
||||
*/
|
||||
|
||||
class SCL_DAI_EXPORT SDAI_Entity_extent__set {
|
||||
class SC_DAI_EXPORT SDAI_Entity_extent__set {
|
||||
public:
|
||||
|
||||
SDAI_Entity_extent__set( int = 16 );
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
|
||||
#include <sdai.h>
|
||||
#include "scl_memmgr.h"
|
||||
#include "sc_memmgr.h"
|
||||
|
||||
/*
|
||||
* NIST STEP Core Class Library
|
||||
|
|
|
|||
|
|
@ -12,9 +12,9 @@
|
|||
* and is not subject to copyright.
|
||||
*/
|
||||
|
||||
#include <scl_export.h>
|
||||
#include <sc_export.h>
|
||||
|
||||
class SCL_DAI_EXPORT SDAI_Enum {
|
||||
class SC_DAI_EXPORT SDAI_Enum {
|
||||
friend ostream & operator<< ( ostream &, const SDAI_Enum & );
|
||||
protected:
|
||||
int v; // integer value of enumeration instance
|
||||
|
|
@ -86,7 +86,7 @@ class SDAI_BOOLEAN;
|
|||
enum Boolean { BFalse, BTrue, BUnset };
|
||||
enum Logical { LFalse, LTrue, LUnset, LUnknown };
|
||||
|
||||
class SCL_DAI_EXPORT SDAI_LOGICAL :
|
||||
class SC_DAI_EXPORT SDAI_LOGICAL :
|
||||
public SDAI_Enum {
|
||||
public:
|
||||
const char * Name() const;
|
||||
|
|
@ -118,7 +118,7 @@ class SCL_DAI_EXPORT SDAI_LOGICAL :
|
|||
|
||||
};
|
||||
|
||||
class SCL_DAI_EXPORT SDAI_BOOLEAN :
|
||||
class SC_DAI_EXPORT SDAI_BOOLEAN :
|
||||
public SDAI_Enum {
|
||||
public:
|
||||
const char * Name() const;
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
|
||||
#include <sdai.h>
|
||||
#include "scl_memmgr.h"
|
||||
#include "sc_memmgr.h"
|
||||
|
||||
///////// SDAI_Model_contents_instances
|
||||
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
#ifndef SDAIMODEL_CONTENTS_H
|
||||
#define SDAIMODEL_CONTENTS_H 1
|
||||
|
||||
#include <scl_export.h>
|
||||
#include <sc_export.h>
|
||||
//SDAI_Model_contents
|
||||
|
||||
/*
|
||||
|
|
@ -26,7 +26,7 @@
|
|||
// The class SDAI_Model_contents_instances shall implement convenience functions by
|
||||
// SDAI_Model_contents in this part of ISO 10303
|
||||
|
||||
class SCL_DAI_EXPORT SDAI_Model_contents_instances : public SDAI_DAObject {
|
||||
class SC_DAI_EXPORT SDAI_Model_contents_instances : public SDAI_DAObject {
|
||||
public:
|
||||
|
||||
SDAI_DAObject__set _instances;
|
||||
|
|
@ -52,7 +52,7 @@ SDAI_Model_contents_instances_var;
|
|||
|
||||
// Model_contents_ptr def pushed ahead of #include for Entity_extent
|
||||
|
||||
class SCL_DAI_EXPORT SDAI_Model_contents : public SDAI_Session_instance {
|
||||
class SC_DAI_EXPORT SDAI_Model_contents : public SDAI_Session_instance {
|
||||
|
||||
//friend class SDAI_Model;
|
||||
|
||||
|
|
|
|||
|
|
@ -24,7 +24,7 @@
|
|||
* UArray implementation.
|
||||
*/
|
||||
#include <sdai.h>
|
||||
#include "scl_memmgr.h"
|
||||
#include "sc_memmgr.h"
|
||||
|
||||
// to help ObjectCenter
|
||||
#ifndef HAVE_MEMMOVE
|
||||
|
|
|
|||
|
|
@ -1,9 +1,9 @@
|
|||
#ifndef SDAIMODEL_CONTENTS_LIST_H
|
||||
#define SDAIMODEL_CONTENTS_LIST_H 1
|
||||
|
||||
#include <scl_export.h>
|
||||
#include <sc_export.h>
|
||||
|
||||
class SCL_DAI_EXPORT SDAI_Model_contents__list {
|
||||
class SC_DAI_EXPORT SDAI_Model_contents__list {
|
||||
public:
|
||||
SDAI_Model_contents__list( int = 16 );
|
||||
~SDAI_Model_contents__list();
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
#include <sdai.h>
|
||||
#include "scl_memmgr.h"
|
||||
#include "sc_memmgr.h"
|
||||
|
||||
SDAI_sdaiObject::SDAI_sdaiObject() {
|
||||
}
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
#ifndef SDAIOBJECT_H
|
||||
#define SDAIOBJECT_H 1
|
||||
|
||||
#include <scl_export.h>
|
||||
#include <sc_export.h>
|
||||
|
||||
/*
|
||||
|
||||
|
|
@ -13,7 +13,7 @@
|
|||
The class Entity_instance shall be a subtype of the C++ class Object:
|
||||
*/
|
||||
|
||||
class SCL_DAI_EXPORT SDAI_sdaiObject {
|
||||
class SC_DAI_EXPORT SDAI_sdaiObject {
|
||||
public:
|
||||
SDAI_sdaiObject();
|
||||
virtual ~SDAI_sdaiObject();
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
#include <sdai.h>
|
||||
#include "scl_memmgr.h"
|
||||
#include "sc_memmgr.h"
|
||||
|
||||
SDAI_Session_instance::SDAI_Session_instance() {
|
||||
}
|
||||
|
|
|
|||
|
|
@ -2,10 +2,10 @@
|
|||
#ifndef SESSION_INSTANCE_H
|
||||
#define SESSION_INSTANCE_H 1
|
||||
|
||||
#include <scl_export.h>
|
||||
#include <sc_export.h>
|
||||
//#include <sdai.h>
|
||||
|
||||
class SCL_DAI_EXPORT SDAI_Session_instance : public SDAI_sdaiObject {
|
||||
class SC_DAI_EXPORT SDAI_Session_instance : public SDAI_sdaiObject {
|
||||
|
||||
public:
|
||||
int x;
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@
|
|||
|
||||
#include <sdai.h>
|
||||
#include <sstream>
|
||||
#include "scl_memmgr.h"
|
||||
#include "sc_memmgr.h"
|
||||
|
||||
SDAI_String::SDAI_String( const char * str, size_t max ) {
|
||||
if( !str ) {
|
||||
|
|
|
|||
|
|
@ -11,11 +11,11 @@
|
|||
* and is not subject to copyright.
|
||||
*/
|
||||
|
||||
#include <scl_export.h>
|
||||
#include <sc_export.h>
|
||||
#include <limits>
|
||||
|
||||
|
||||
class SCL_DAI_EXPORT SDAI_String {
|
||||
class SC_DAI_EXPORT SDAI_String {
|
||||
private:
|
||||
std::string content;
|
||||
public:
|
||||
|
|
|
|||
|
|
@ -21,10 +21,10 @@ SET(LIBSTEPEDITOR_PRIVATE_HDRS
|
|||
|
||||
include_directories(
|
||||
${CMAKE_CURRENT_SOURCE_DIR}
|
||||
${SCL_SOURCE_DIR}/src/base
|
||||
${SCL_SOURCE_DIR}/src/cldai
|
||||
${SCL_SOURCE_DIR}/src/clstepcore
|
||||
${SCL_SOURCE_DIR}/src/clutils
|
||||
${SC_SOURCE_DIR}/src/base
|
||||
${SC_SOURCE_DIR}/src/cldai
|
||||
${SC_SOURCE_DIR}/src/clstepcore
|
||||
${SC_SOURCE_DIR}/src/clutils
|
||||
)
|
||||
|
||||
SCL_ADDLIB(stepeditor "${LIBSTEPEDITOR_SRCS}" "stepcore;stepdai;steputils;base")
|
||||
SC_ADDLIB(stepeditor "${LIBSTEPEDITOR_SRCS}" "stepcore;stepdai;steputils;base")
|
||||
|
|
|
|||
|
|
@ -34,7 +34,7 @@
|
|||
// void PushPastString (istream& in, std::string &s, ErrorDescriptor *err)
|
||||
#include <STEPundefined.h>
|
||||
|
||||
#include "scl_memmgr.h"
|
||||
#include "sc_memmgr.h"
|
||||
|
||||
/**
|
||||
* \returns The new file name for the class.
|
||||
|
|
|
|||
|
|
@ -13,7 +13,7 @@
|
|||
* and is not subject to copyright.
|
||||
*/
|
||||
|
||||
#include <scl_export.h>
|
||||
#include <sc_export.h>
|
||||
#include <string>
|
||||
#include <instmgr.h>
|
||||
#include <Registry.h>
|
||||
|
|
@ -35,7 +35,7 @@ enum FileTypeCode {
|
|||
WORKING_SESSION = 2
|
||||
};
|
||||
|
||||
class SCL_EDITOR_EXPORT STEPfile {
|
||||
class SC_EDITOR_EXPORT STEPfile {
|
||||
protected:
|
||||
//data members
|
||||
|
||||
|
|
|
|||
|
|
@ -17,7 +17,7 @@
|
|||
#include <cmath>
|
||||
|
||||
#include <cstring>
|
||||
#include "scl_memmgr.h"
|
||||
#include "sc_memmgr.h"
|
||||
|
||||
extern void HeaderSchemaInit( Registry & reg );
|
||||
|
||||
|
|
|
|||
|
|
@ -4,7 +4,7 @@
|
|||
// it since your modifications will be lost if fedex_plus is used to
|
||||
// regenerate it.
|
||||
|
||||
#ifdef SCL_LOGGING
|
||||
#ifdef SC_LOGGING
|
||||
#include <fstream.h>
|
||||
extern ofstream * logStream;
|
||||
#define SCLLOGFILE "scl.log"
|
||||
|
|
@ -13,7 +13,7 @@ extern ofstream * logStream;
|
|||
#include <ExpDict.h>
|
||||
#include <STEPattribute.h>
|
||||
#include <SdaiHeaderSchema.h>
|
||||
#include "scl_memmgr.h"
|
||||
#include "sc_memmgr.h"
|
||||
|
||||
Schema * s_header_section_schema = 0;
|
||||
|
||||
|
|
|
|||
|
|
@ -4,7 +4,7 @@
|
|||
// it since your modifications will be lost if fedex_plus is used to
|
||||
// regenerate it.
|
||||
|
||||
#include <scl_export.h>
|
||||
#include <sc_export.h>
|
||||
#include <sdai.h>
|
||||
#include <Registry.h>
|
||||
#include <STEPaggregate.h>
|
||||
|
|
@ -13,10 +13,10 @@
|
|||
|
||||
///////// ENTITY section_language
|
||||
|
||||
extern SCL_EDITOR_EXPORT AttrDescriptor * a_0section;
|
||||
extern SCL_EDITOR_EXPORT AttrDescriptor * a_1default_language;
|
||||
extern SC_EDITOR_EXPORT AttrDescriptor * a_0section;
|
||||
extern SC_EDITOR_EXPORT AttrDescriptor * a_1default_language;
|
||||
|
||||
class SCL_EDITOR_EXPORT SdaiSection_language : public SDAI_Application_instance {
|
||||
class SC_EDITOR_EXPORT SdaiSection_language : public SDAI_Application_instance {
|
||||
protected:
|
||||
SDAI_String _section ; // OPTIONAL
|
||||
SDAI_String _default_language ;
|
||||
|
|
@ -48,11 +48,11 @@ create_SdaiSection_language() {
|
|||
|
||||
///////// ENTITY file_population
|
||||
|
||||
extern SCL_EDITOR_EXPORT AttrDescriptor * a_2governing_schema;
|
||||
extern SCL_EDITOR_EXPORT AttrDescriptor * a_3determination_method;
|
||||
extern SCL_EDITOR_EXPORT AttrDescriptor * a_4governed_sections;
|
||||
extern SC_EDITOR_EXPORT AttrDescriptor * a_2governing_schema;
|
||||
extern SC_EDITOR_EXPORT AttrDescriptor * a_3determination_method;
|
||||
extern SC_EDITOR_EXPORT AttrDescriptor * a_4governed_sections;
|
||||
|
||||
class SCL_EDITOR_EXPORT SdaiFile_population : public SDAI_Application_instance {
|
||||
class SC_EDITOR_EXPORT SdaiFile_population : public SDAI_Application_instance {
|
||||
protected:
|
||||
SDAI_String _governing_schema ;
|
||||
SDAI_String _determination_method ;
|
||||
|
|
@ -97,7 +97,7 @@ extern AttrDescriptor * a_9preprocessor_version;
|
|||
extern AttrDescriptor * a_10originating_system;
|
||||
extern AttrDescriptor * a_11authorization;
|
||||
|
||||
class SCL_EDITOR_EXPORT SdaiFile_name : public SDAI_Application_instance {
|
||||
class SC_EDITOR_EXPORT SdaiFile_name : public SDAI_Application_instance {
|
||||
protected:
|
||||
SDAI_String _name ;
|
||||
SDAI_String _time_stamp ;
|
||||
|
|
@ -149,10 +149,10 @@ create_SdaiFile_name() {
|
|||
|
||||
///////// ENTITY section_context
|
||||
|
||||
extern SCL_EDITOR_EXPORT AttrDescriptor * a_12section;
|
||||
extern SCL_EDITOR_EXPORT AttrDescriptor * a_13context_identifiers;
|
||||
extern SC_EDITOR_EXPORT AttrDescriptor * a_12section;
|
||||
extern SC_EDITOR_EXPORT AttrDescriptor * a_13context_identifiers;
|
||||
|
||||
class SCL_EDITOR_EXPORT SdaiSection_context : public SDAI_Application_instance {
|
||||
class SC_EDITOR_EXPORT SdaiSection_context : public SDAI_Application_instance {
|
||||
protected:
|
||||
SDAI_String _section ; // OPTIONAL
|
||||
StringAggregate _context_identifiers ; // of context_name
|
||||
|
|
@ -185,10 +185,10 @@ create_SdaiSection_context() {
|
|||
|
||||
///////// ENTITY file_description
|
||||
|
||||
extern SCL_EDITOR_EXPORT AttrDescriptor * a_14description;
|
||||
extern SCL_EDITOR_EXPORT AttrDescriptor * a_15implementation_level;
|
||||
extern SC_EDITOR_EXPORT AttrDescriptor * a_14description;
|
||||
extern SC_EDITOR_EXPORT AttrDescriptor * a_15implementation_level;
|
||||
|
||||
class SCL_EDITOR_EXPORT SdaiFile_description : public SDAI_Application_instance {
|
||||
class SC_EDITOR_EXPORT SdaiFile_description : public SDAI_Application_instance {
|
||||
protected:
|
||||
StringAggregate _description ;
|
||||
SDAI_String _implementation_level ;
|
||||
|
|
@ -220,9 +220,9 @@ create_SdaiFile_description() {
|
|||
|
||||
///////// ENTITY file_schema
|
||||
|
||||
extern SCL_EDITOR_EXPORT AttrDescriptor * a_16schema_identifiers;
|
||||
extern SC_EDITOR_EXPORT AttrDescriptor * a_16schema_identifiers;
|
||||
|
||||
class SCL_EDITOR_EXPORT SdaiFile_schema : public SDAI_Application_instance {
|
||||
class SC_EDITOR_EXPORT SdaiFile_schema : public SDAI_Application_instance {
|
||||
protected:
|
||||
StringAggregate _schema_identifiers ; // of schema_name
|
||||
|
||||
|
|
@ -251,7 +251,7 @@ create_SdaiFile_schema() {
|
|||
|
||||
// ***** generate Model related pieces
|
||||
|
||||
class SCL_EDITOR_EXPORT SdaiModel_contents_header_section_schema : public SDAI_Model_contents {
|
||||
class SC_EDITOR_EXPORT SdaiModel_contents_header_section_schema : public SDAI_Model_contents {
|
||||
|
||||
public:
|
||||
SdaiModel_contents_header_section_schema();
|
||||
|
|
@ -273,5 +273,5 @@ class SCL_EDITOR_EXPORT SdaiModel_contents_header_section_schema : public SDAI_M
|
|||
|
||||
typedef SdaiModel_contents_header_section_schema * SdaiModel_contents_header_section_schema_ptr;
|
||||
typedef SdaiModel_contents_header_section_schema_ptr SdaiModel_contents_header_section_schema_var;
|
||||
SCL_EDITOR_EXPORT SDAI_Model_contents_ptr create_SdaiModel_contents_header_section_schema();
|
||||
SC_EDITOR_EXPORT SDAI_Model_contents_ptr create_SdaiModel_contents_header_section_schema();
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -5,7 +5,7 @@
|
|||
// regenerate it.
|
||||
|
||||
#include <SdaiHeaderSchema.h>
|
||||
#include "scl_memmgr.h"
|
||||
#include "sc_memmgr.h"
|
||||
|
||||
void HeaderInitSchemasAndEnts( Registry & reg ) {
|
||||
Uniqueness_rule_ptr ur;
|
||||
|
|
|
|||
|
|
@ -4,24 +4,24 @@
|
|||
// it since your modifications will be lost if fedex_plus is used to
|
||||
// regenerate it.
|
||||
|
||||
#include <scl_export.h>
|
||||
#include <sc_export.h>
|
||||
|
||||
// Schema: SdaiHEADER_SECTION_SCHEMA
|
||||
extern Schema * s_header_section_schema;
|
||||
|
||||
// Types:
|
||||
typedef SDAI_String SdaiTime_stamp_text;
|
||||
extern SCL_EDITOR_EXPORT TypeDescriptor * header_section_schemat_time_stamp_text;
|
||||
extern SC_EDITOR_EXPORT TypeDescriptor * header_section_schemat_time_stamp_text;
|
||||
typedef SDAI_String SdaiSection_name;
|
||||
extern SCL_EDITOR_EXPORT TypeDescriptor * header_section_schemat_section_name;
|
||||
extern SC_EDITOR_EXPORT TypeDescriptor * header_section_schemat_section_name;
|
||||
typedef SDAI_String SdaiContext_name;
|
||||
extern SCL_EDITOR_EXPORT TypeDescriptor * header_section_schemat_context_name;
|
||||
extern SC_EDITOR_EXPORT TypeDescriptor * header_section_schemat_context_name;
|
||||
typedef SDAI_String SdaiSchema_name;
|
||||
extern SCL_EDITOR_EXPORT TypeDescriptor * header_section_schemat_schema_name;
|
||||
extern SC_EDITOR_EXPORT TypeDescriptor * header_section_schemat_schema_name;
|
||||
typedef SDAI_String SdaiLanguage_name;
|
||||
extern SCL_EDITOR_EXPORT TypeDescriptor * header_section_schemat_language_name;
|
||||
extern SC_EDITOR_EXPORT TypeDescriptor * header_section_schemat_language_name;
|
||||
typedef SDAI_String SdaiExchange_structure_identifier;
|
||||
extern SCL_EDITOR_EXPORT TypeDescriptor * header_section_schemat_exchange_structure_identifier;
|
||||
extern SC_EDITOR_EXPORT TypeDescriptor * header_section_schemat_exchange_structure_identifier;
|
||||
|
||||
// Entities:
|
||||
class SdaiSection_language;
|
||||
|
|
@ -32,7 +32,7 @@ typedef const SdaiSection_language * const_SdaiSection_languageH;
|
|||
typedef const SdaiSection_language * const_SdaiSection_language_ptr;
|
||||
#define SdaiSection_language__set SDAI_DAObject__set
|
||||
#define SdaiSection_language__set_var SDAI_DAObject__set_var
|
||||
extern SCL_EDITOR_EXPORT EntityDescriptor * header_section_schemae_section_language;
|
||||
extern SC_EDITOR_EXPORT EntityDescriptor * header_section_schemae_section_language;
|
||||
|
||||
class SdaiFile_population;
|
||||
typedef SdaiFile_population * SdaiFile_populationH;
|
||||
|
|
@ -42,7 +42,7 @@ typedef const SdaiFile_population * const_SdaiFile_populationH;
|
|||
typedef const SdaiFile_population * const_SdaiFile_population_ptr;
|
||||
#define SdaiFile_population__set SDAI_DAObject__set
|
||||
#define SdaiFile_population__set_var SDAI_DAObject__set_var
|
||||
extern SCL_EDITOR_EXPORT EntityDescriptor * header_section_schemae_file_population;
|
||||
extern SC_EDITOR_EXPORT EntityDescriptor * header_section_schemae_file_population;
|
||||
|
||||
class SdaiFile_name;
|
||||
typedef SdaiFile_name * SdaiFile_nameH;
|
||||
|
|
@ -52,7 +52,7 @@ typedef const SdaiFile_name * const_SdaiFile_nameH;
|
|||
typedef const SdaiFile_name * const_SdaiFile_name_ptr;
|
||||
#define SdaiFile_name__set SDAI_DAObject__set
|
||||
#define SdaiFile_name__set_var SDAI_DAObject__set_var
|
||||
extern SCL_EDITOR_EXPORT EntityDescriptor * header_section_schemae_file_name;
|
||||
extern SC_EDITOR_EXPORT EntityDescriptor * header_section_schemae_file_name;
|
||||
|
||||
class SdaiSection_context;
|
||||
typedef SdaiSection_context * SdaiSection_contextH;
|
||||
|
|
@ -62,7 +62,7 @@ typedef const SdaiSection_context * const_SdaiSection_contextH;
|
|||
typedef const SdaiSection_context * const_SdaiSection_context_ptr;
|
||||
#define SdaiSection_context__set SDAI_DAObject__set
|
||||
#define SdaiSection_context__set_var SDAI_DAObject__set_var
|
||||
extern SCL_EDITOR_EXPORT EntityDescriptor * header_section_schemae_section_context;
|
||||
extern SC_EDITOR_EXPORT EntityDescriptor * header_section_schemae_section_context;
|
||||
|
||||
class SdaiFile_description;
|
||||
typedef SdaiFile_description * SdaiFile_descriptionH;
|
||||
|
|
@ -72,7 +72,7 @@ typedef const SdaiFile_description * const_SdaiFile_descriptionH;
|
|||
typedef const SdaiFile_description * const_SdaiFile_description_ptr;
|
||||
#define SdaiFile_description__set SDAI_DAObject__set
|
||||
#define SdaiFile_description__set_var SDAI_DAObject__set_var
|
||||
extern SCL_EDITOR_EXPORT EntityDescriptor * header_section_schemae_file_description;
|
||||
extern SC_EDITOR_EXPORT EntityDescriptor * header_section_schemae_file_description;
|
||||
|
||||
class SdaiFile_schema;
|
||||
typedef SdaiFile_schema * SdaiFile_schemaH;
|
||||
|
|
@ -82,6 +82,6 @@ typedef const SdaiFile_schema * const_SdaiFile_schemaH;
|
|||
typedef const SdaiFile_schema * const_SdaiFile_schema_ptr;
|
||||
#define SdaiFile_schema__set SDAI_DAObject__set
|
||||
#define SdaiFile_schema__set_var SDAI_DAObject__set_var
|
||||
extern SCL_EDITOR_EXPORT EntityDescriptor * header_section_schemae_file_schema;
|
||||
extern SC_EDITOR_EXPORT EntityDescriptor * header_section_schemae_file_schema;
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@
|
|||
#include <ExpDict.h>
|
||||
#include <STEPattribute.h>
|
||||
#include <SdaiHeaderSchema.h>
|
||||
#include "scl_memmgr.h"
|
||||
#include "sc_memmgr.h"
|
||||
|
||||
void SdaiHEADER_SECTION_SCHEMAInit( Registry & reg ) {
|
||||
header_section_schemat_time_stamp_text->ReferentType( t_sdaiSTRING );
|
||||
|
|
|
|||
|
|
@ -5,7 +5,7 @@
|
|||
// regenerate it.
|
||||
|
||||
#include <SdaiSchemaInit.h>
|
||||
#include "scl_memmgr.h"
|
||||
#include "sc_memmgr.h"
|
||||
|
||||
void HeaderSchemaInit( Registry & reg ) {
|
||||
HeaderInitSchemasAndEnts( reg );
|
||||
|
|
|
|||
|
|
@ -4,11 +4,11 @@
|
|||
// it since your modifications will be lost if fedex_plus is used to
|
||||
// regenerate it.
|
||||
|
||||
#ifdef SCL_LOGGING
|
||||
#ifdef SC_LOGGING
|
||||
#include <sys/time.h>
|
||||
#endif
|
||||
|
||||
#include <scl_export.h>
|
||||
#include <sc_export.h>
|
||||
#include <sdai.h>
|
||||
#include <Registry.h>
|
||||
#include <STEPaggregate.h>
|
||||
|
|
@ -20,8 +20,8 @@
|
|||
#include <SdaiHeaderSchemaClasses.h>
|
||||
#include <SdaiHeaderSchema.h>
|
||||
|
||||
SCL_EDITOR_EXPORT void HeaderSchemaInit( Registry & );
|
||||
SCL_EDITOR_EXPORT void HeaderInitSchemasAndEnts( Registry & );
|
||||
SCL_EDITOR_EXPORT void SdaiHEADER_SECTION_SCHEMAInit( Registry & r );
|
||||
SC_EDITOR_EXPORT void HeaderSchemaInit( Registry & );
|
||||
SC_EDITOR_EXPORT void HeaderInitSchemasAndEnts( Registry & );
|
||||
SC_EDITOR_EXPORT void SdaiHEADER_SECTION_SCHEMAInit( Registry & r );
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@
|
|||
*/
|
||||
|
||||
#include <cmdmgr.h>
|
||||
#include "scl_memmgr.h"
|
||||
#include "sc_memmgr.h"
|
||||
|
||||
ReplicateLinkNode * ReplicateList::FindNode( MgrNode * mn ) {
|
||||
ReplicateLinkNode * rln = ( ReplicateLinkNode * )GetHead();
|
||||
|
|
|
|||
|
|
@ -12,7 +12,7 @@
|
|||
* and is not subject to copyright.
|
||||
*/
|
||||
|
||||
#include <scl_export.h>
|
||||
#include <sc_export.h>
|
||||
#include <gennode.h>
|
||||
#include <gennodelist.h>
|
||||
#include <gennodearray.h>
|
||||
|
|
@ -77,7 +77,7 @@
|
|||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
class SCL_EDITOR_EXPORT ReplicateLinkNode : public SingleLinkNode {
|
||||
class SC_EDITOR_EXPORT ReplicateLinkNode : public SingleLinkNode {
|
||||
private:
|
||||
protected:
|
||||
MgrNode * _repNode;
|
||||
|
|
@ -99,7 +99,7 @@ class SCL_EDITOR_EXPORT ReplicateLinkNode : public SingleLinkNode {
|
|||
}
|
||||
};
|
||||
|
||||
class SCL_EDITOR_EXPORT ReplicateList : public SingleLinkList {
|
||||
class SC_EDITOR_EXPORT ReplicateList : public SingleLinkList {
|
||||
private:
|
||||
protected:
|
||||
public:
|
||||
|
|
@ -130,7 +130,7 @@ class SCL_EDITOR_EXPORT ReplicateList : public SingleLinkList {
|
|||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
class SCL_EDITOR_EXPORT CmdMgr {
|
||||
class SC_EDITOR_EXPORT CmdMgr {
|
||||
protected:
|
||||
MgrNodeList * completeList;
|
||||
MgrNodeList * incompleteList;
|
||||
|
|
|
|||
|
|
@ -15,7 +15,7 @@
|
|||
// this is a default seeinfo that does nothing... thus it is not
|
||||
// dependent on a user interface toolkit
|
||||
|
||||
#include <scl_export.h>
|
||||
#include <sc_export.h>
|
||||
|
||||
class MgrNode;
|
||||
class DisplayNode;
|
||||
|
|
@ -25,7 +25,7 @@ class DisplayNodelist;
|
|||
|
||||
#include <editordefines.h>
|
||||
|
||||
class SCL_EDITOR_EXPORT seeInfo : public DisplayNode {
|
||||
class SC_EDITOR_EXPORT seeInfo : public DisplayNode {
|
||||
public:
|
||||
seeInfo( MgrNode * node,
|
||||
SDAI_Application_instance * se,
|
||||
|
|
|
|||
|
|
@ -6,14 +6,14 @@ lazyDataSectionReader.h lazyInstMgr.h lazyTypes.h sectionReader.h )
|
|||
|
||||
include_directories(
|
||||
${CMAKE_CURRENT_SOURCE_DIR}
|
||||
${SCL_SOURCE_DIR}/src/cleditor
|
||||
${SCL_SOURCE_DIR}/src/cldai
|
||||
${SCL_SOURCE_DIR}/src/clstepcore
|
||||
${SCL_SOURCE_DIR}/src/clutils
|
||||
${SCL_SOURCE_DIR}/src/base
|
||||
${SCL_SOURCE_DIR}/src/base/judy/src
|
||||
${SC_SOURCE_DIR}/src/cleditor
|
||||
${SC_SOURCE_DIR}/src/cldai
|
||||
${SC_SOURCE_DIR}/src/clstepcore
|
||||
${SC_SOURCE_DIR}/src/clutils
|
||||
${SC_SOURCE_DIR}/src/base
|
||||
${SC_SOURCE_DIR}/src/base/judy/src
|
||||
)
|
||||
|
||||
SCL_ADDLIB(steplazyfile "${clLazyFile_SRCS};${clLazyFile_HDRS}" "stepcore;stepdai;steputils;base")
|
||||
SCL_ADDEXEC(lazy_test "lazy_test.cc" "steplazyfile;stepeditor" )
|
||||
SC_ADDLIB(steplazyfile "${clLazyFile_SRCS};${clLazyFile_HDRS}" "stepcore;stepdai;steputils;base")
|
||||
SC_ADDEXEC(lazy_test "lazy_test.cc" "steplazyfile;stepeditor" )
|
||||
set_target_properties(lazy_test PROPERTIES COMPILE_FLAGS "-DNO_REGISTRY" )
|
||||
|
|
|
|||
|
|
@ -9,7 +9,7 @@
|
|||
|
||||
// Local copy of Boost's BOOST_CURRENT_FUNCTION wrapper
|
||||
//
|
||||
// current_function.hpp - SCL_CURRENT_FUNCTION
|
||||
// current_function.hpp - SC_CURRENT_FUNCTION
|
||||
//
|
||||
// Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
|
||||
//
|
||||
|
|
@ -22,31 +22,31 @@
|
|||
|
||||
#if defined(__GNUC__) || (defined(__MWERKS__) && (__MWERKS__ >= 0x3000)) || (defined(__ICC) && (__ICC >= 600)) || defined(__ghs__)
|
||||
|
||||
# define SCL_CURRENT_FUNCTION __PRETTY_FUNCTION__
|
||||
# define SC_CURRENT_FUNCTION __PRETTY_FUNCTION__
|
||||
|
||||
#elif defined(__DMC__) && (__DMC__ >= 0x810)
|
||||
|
||||
# define SCL_CURRENT_FUNCTION __PRETTY_FUNCTION__
|
||||
# define SC_CURRENT_FUNCTION __PRETTY_FUNCTION__
|
||||
|
||||
#elif defined(__FUNCSIG__)
|
||||
|
||||
# define SCL_CURRENT_FUNCTION __FUNCSIG__
|
||||
# define SC_CURRENT_FUNCTION __FUNCSIG__
|
||||
|
||||
#elif (defined(__INTEL_COMPILER) && (__INTEL_COMPILER >= 600)) || (defined(__IBMCPP__) && (__IBMCPP__ >= 500))
|
||||
|
||||
# define SCL_CURRENT_FUNCTION __FUNCTION__
|
||||
# define SC_CURRENT_FUNCTION __FUNCTION__
|
||||
|
||||
#elif defined(__BORLANDC__) && (__BORLANDC__ >= 0x550)
|
||||
|
||||
# define SCL_CURRENT_FUNCTION __FUNC__
|
||||
# define SC_CURRENT_FUNCTION __FUNC__
|
||||
|
||||
#elif defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901)
|
||||
|
||||
# define SCL_CURRENT_FUNCTION __func__
|
||||
# define SC_CURRENT_FUNCTION __func__
|
||||
|
||||
#else
|
||||
|
||||
# define SCL_CURRENT_FUNCTION "(unknown)"
|
||||
# define SC_CURRENT_FUNCTION "(unknown)"
|
||||
|
||||
#endif
|
||||
|
||||
|
|
|
|||
|
|
@ -8,12 +8,12 @@
|
|||
#include "lazyFileReader.h"
|
||||
#include "sectionReader.h"
|
||||
#include "lazyTypes.h"
|
||||
#include "scl_memmgr.h"
|
||||
#include "sc_memmgr.h"
|
||||
|
||||
#include "scl_export.h"
|
||||
#include "sc_export.h"
|
||||
|
||||
///differs from the lazyDataSectionReader in that all instances are always loaded
|
||||
class SCL_LAZYFILE_EXPORT headerSectionReader: public sectionReader {
|
||||
class SC_LAZYFILE_EXPORT headerSectionReader: public sectionReader {
|
||||
protected:
|
||||
instancesLoaded_t * _headerInstances;
|
||||
|
||||
|
|
|
|||
|
|
@ -5,9 +5,9 @@
|
|||
#include <iostream>
|
||||
#include "sectionReader.h"
|
||||
#include "lazyTypes.h"
|
||||
#include "scl_memmgr.h"
|
||||
#include "sc_memmgr.h"
|
||||
|
||||
#include "scl_export.h"
|
||||
#include "sc_export.h"
|
||||
|
||||
/** base class for data section readers
|
||||
* \sa lazyP21DataSectionReader
|
||||
|
|
|
|||
|
|
@ -5,7 +5,7 @@
|
|||
#include <string>
|
||||
#include <cstdlib>
|
||||
|
||||
#include "scl_export.h"
|
||||
#include "sc_export.h"
|
||||
|
||||
// PART 21
|
||||
#include "lazyP21DataSectionReader.h"
|
||||
|
|
@ -16,7 +16,7 @@
|
|||
* #include "lazyP28DataSectionReader.h"
|
||||
* #include "p28HeaderSectionReader.h"
|
||||
*/
|
||||
#include "scl_memmgr.h"
|
||||
#include "sc_memmgr.h"
|
||||
|
||||
class lazyInstMgr;
|
||||
class Registry;
|
||||
|
|
@ -24,7 +24,7 @@ class headerSectionReader;
|
|||
|
||||
///read an exchange file of any supported type (currently only p21)
|
||||
///for use only from within lazyInstMgr
|
||||
class SCL_LAZYFILE_EXPORT lazyFileReader {
|
||||
class SC_LAZYFILE_EXPORT lazyFileReader {
|
||||
protected:
|
||||
std::string _fileName;
|
||||
lazyInstMgr * _parent;
|
||||
|
|
|
|||
|
|
@ -10,7 +10,7 @@
|
|||
#include "lazyTypes.h"
|
||||
|
||||
#include "Registry.h"
|
||||
#include "scl_memmgr.h"
|
||||
#include "sc_memmgr.h"
|
||||
|
||||
#include "judyLArray.h"
|
||||
#include "judySArray.h"
|
||||
|
|
|
|||
|
|
@ -3,10 +3,10 @@
|
|||
|
||||
#include "lazyDataSectionReader.h"
|
||||
#include "lazyFileReader.h"
|
||||
#include "scl_memmgr.h"
|
||||
#include "scl_export.h"
|
||||
#include "sc_memmgr.h"
|
||||
#include "sc_export.h"
|
||||
|
||||
class SCL_LAZYFILE_EXPORT lazyP21DataSectionReader: public lazyDataSectionReader {
|
||||
class SC_LAZYFILE_EXPORT lazyP21DataSectionReader: public lazyDataSectionReader {
|
||||
protected:
|
||||
public:
|
||||
lazyP21DataSectionReader( lazyFileReader * parent, std::ifstream & file, std::streampos start, sectionID sid );
|
||||
|
|
|
|||
|
|
@ -1,8 +1,8 @@
|
|||
#include "lazyInstMgr.h"
|
||||
#include <sc_benchmark.h>
|
||||
#include "SdaiSchemaInit.h"
|
||||
#include "scl_memmgr.h"
|
||||
#include <scl_cf.h>
|
||||
#include "sc_memmgr.h"
|
||||
#include <sc_cf.h>
|
||||
|
||||
#ifndef NO_REGISTRY
|
||||
# include "schema.h"
|
||||
|
|
|
|||
|
|
@ -2,10 +2,10 @@
|
|||
#define P21HEADERSECTIONREADER_H
|
||||
|
||||
#include "headerSectionReader.h"
|
||||
#include "scl_memmgr.h"
|
||||
#include "scl_export.h"
|
||||
#include "sc_memmgr.h"
|
||||
#include "sc_export.h"
|
||||
|
||||
class SCL_LAZYFILE_EXPORT p21HeaderSectionReader: public headerSectionReader {
|
||||
class SC_LAZYFILE_EXPORT p21HeaderSectionReader: public headerSectionReader {
|
||||
public:
|
||||
p21HeaderSectionReader( lazyFileReader * parent, std::ifstream & file, std::streampos start, sectionID sid );
|
||||
void findSectionStart();
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
#define SCL_CORE_EXPORT
|
||||
#define SCL_DAI_EXPORT
|
||||
#define SC_CORE_EXPORT
|
||||
#define SC_DAI_EXPORT
|
||||
|
||||
#include <algorithm>
|
||||
#include <set>
|
||||
|
|
@ -101,7 +101,7 @@ const char * sectionReader::getDelimitedKeyword( const char * delimiters ) {
|
|||
}
|
||||
c = _file.peek();
|
||||
if( !strchr( delimiters, c ) ) {
|
||||
std::cerr << SCL_CURRENT_FUNCTION << ": missing delimiter. Found " << c << ", expected one of " << delimiters << " at end of keyword " << str << ". File offset: " << _file.tellg() << std::endl;
|
||||
std::cerr << SC_CURRENT_FUNCTION << ": missing delimiter. Found " << c << ", expected one of " << delimiters << " at end of keyword " << str << ". File offset: " << _file.tellg() << std::endl;
|
||||
abort();
|
||||
}
|
||||
return str.c_str();
|
||||
|
|
|
|||
|
|
@ -4,15 +4,15 @@
|
|||
#include <fstream>
|
||||
#include <set>
|
||||
#include "lazyTypes.h"
|
||||
#include "scl_memmgr.h"
|
||||
#include "scl_export.h"
|
||||
#include "sc_memmgr.h"
|
||||
#include "sc_export.h"
|
||||
|
||||
class SDAI_Application_instance;
|
||||
class lazyFileReader;
|
||||
class ErrorDescriptor;
|
||||
class Registry;
|
||||
|
||||
class SCL_LAZYFILE_EXPORT sectionReader {
|
||||
class SC_LAZYFILE_EXPORT sectionReader {
|
||||
protected:
|
||||
//protected data members
|
||||
lazyFileReader * _lazyFile;
|
||||
|
|
|
|||
|
|
@ -61,10 +61,10 @@ SET(LIBSTEPCORE_PRIVATE_HDRS
|
|||
|
||||
include_directories(
|
||||
${CMAKE_CURRENT_SOURCE_DIR}
|
||||
${SCL_SOURCE_DIR}/src/base
|
||||
${SCL_SOURCE_DIR}/src/cldai
|
||||
${SCL_SOURCE_DIR}/src/cleditor
|
||||
${SCL_SOURCE_DIR}/src/clutils
|
||||
${SC_SOURCE_DIR}/src/base
|
||||
${SC_SOURCE_DIR}/src/cldai
|
||||
${SC_SOURCE_DIR}/src/cleditor
|
||||
${SC_SOURCE_DIR}/src/clutils
|
||||
)
|
||||
|
||||
SCL_ADDLIB(stepcore "${LIBSTEPCORE_SRCS}" "express;steputils;stepdai;base")
|
||||
SC_ADDLIB(stepcore "${LIBSTEPCORE_SRCS}" "express;steputils;stepdai;base")
|
||||
|
|
|
|||
|
|
@ -10,7 +10,7 @@
|
|||
* and is not subject to copyright.
|
||||
*/
|
||||
|
||||
#include <scl_cf.h>
|
||||
#include <sc_cf.h>
|
||||
|
||||
#include <memory.h>
|
||||
#include <math.h>
|
||||
|
|
@ -18,7 +18,7 @@
|
|||
|
||||
#include <ExpDict.h>
|
||||
#include <STEPaggregate.h>
|
||||
#include "scl_memmgr.h"
|
||||
#include "sc_memmgr.h"
|
||||
|
||||
|
||||
Explicit_item_id__set::Explicit_item_id__set( int defaultSize ) {
|
||||
|
|
|
|||
|
|
@ -12,7 +12,7 @@
|
|||
* and is not subject to copyright.
|
||||
*/
|
||||
|
||||
#include <scl_export.h>
|
||||
#include <sc_export.h>
|
||||
#include <sdai.h>
|
||||
|
||||
#include <vector>
|
||||
|
|
@ -42,19 +42,19 @@ enum AggrBoundTypeEnum {
|
|||
#include <Str.h>
|
||||
|
||||
// defined and created in Registry.inline.cc
|
||||
extern SCL_CORE_EXPORT const TypeDescriptor * t_sdaiINTEGER;
|
||||
extern SCL_CORE_EXPORT const TypeDescriptor * t_sdaiREAL;
|
||||
extern SCL_CORE_EXPORT const TypeDescriptor * t_sdaiNUMBER;
|
||||
extern SCL_CORE_EXPORT const TypeDescriptor * t_sdaiSTRING;
|
||||
extern SCL_CORE_EXPORT const TypeDescriptor * t_sdaiBINARY;
|
||||
extern SCL_CORE_EXPORT const TypeDescriptor * t_sdaiBOOLEAN;
|
||||
extern SCL_CORE_EXPORT const TypeDescriptor * t_sdaiLOGICAL;
|
||||
extern SC_CORE_EXPORT const TypeDescriptor * t_sdaiINTEGER;
|
||||
extern SC_CORE_EXPORT const TypeDescriptor * t_sdaiREAL;
|
||||
extern SC_CORE_EXPORT const TypeDescriptor * t_sdaiNUMBER;
|
||||
extern SC_CORE_EXPORT const TypeDescriptor * t_sdaiSTRING;
|
||||
extern SC_CORE_EXPORT const TypeDescriptor * t_sdaiBINARY;
|
||||
extern SC_CORE_EXPORT const TypeDescriptor * t_sdaiBOOLEAN;
|
||||
extern SC_CORE_EXPORT const TypeDescriptor * t_sdaiLOGICAL;
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// Dictionary_instance
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
class SCL_CORE_EXPORT Dictionary_instance {
|
||||
class SC_CORE_EXPORT Dictionary_instance {
|
||||
|
||||
protected:
|
||||
Dictionary_instance() {}
|
||||
|
|
@ -65,7 +65,7 @@ class SCL_CORE_EXPORT Dictionary_instance {
|
|||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
class SCL_CORE_EXPORT TypeDescLinkNode : public SingleLinkNode {
|
||||
class SC_CORE_EXPORT TypeDescLinkNode : public SingleLinkNode {
|
||||
private:
|
||||
protected:
|
||||
TypeDescriptor * _typeDesc;
|
||||
|
|
@ -81,7 +81,7 @@ class SCL_CORE_EXPORT TypeDescLinkNode : public SingleLinkNode {
|
|||
}
|
||||
};
|
||||
|
||||
class SCL_CORE_EXPORT TypeDescriptorList : public SingleLinkList {
|
||||
class SC_CORE_EXPORT TypeDescriptorList : public SingleLinkList {
|
||||
private:
|
||||
protected:
|
||||
public:
|
||||
|
|
@ -100,7 +100,7 @@ class SCL_CORE_EXPORT TypeDescriptorList : public SingleLinkList {
|
|||
}
|
||||
};
|
||||
|
||||
class SCL_CORE_EXPORT TypeDescItr {
|
||||
class SC_CORE_EXPORT TypeDescItr {
|
||||
protected:
|
||||
const TypeDescriptorList & tdl;
|
||||
const TypeDescLinkNode * cur;
|
||||
|
|
@ -118,7 +118,7 @@ class SCL_CORE_EXPORT TypeDescItr {
|
|||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
class SCL_CORE_EXPORT EntityDescLinkNode : public SingleLinkNode {
|
||||
class SC_CORE_EXPORT EntityDescLinkNode : public SingleLinkNode {
|
||||
|
||||
private:
|
||||
protected:
|
||||
|
|
@ -136,7 +136,7 @@ class SCL_CORE_EXPORT EntityDescLinkNode : public SingleLinkNode {
|
|||
}
|
||||
};
|
||||
|
||||
class SCL_CORE_EXPORT EntityDescriptorList : public SingleLinkList {
|
||||
class SC_CORE_EXPORT EntityDescriptorList : public SingleLinkList {
|
||||
|
||||
private:
|
||||
protected:
|
||||
|
|
@ -159,7 +159,7 @@ class SCL_CORE_EXPORT EntityDescriptorList : public SingleLinkList {
|
|||
typedef EntityDescriptorList * Entity__set_ptr;
|
||||
typedef Entity__set_ptr Entity__set_var;
|
||||
|
||||
class SCL_CORE_EXPORT EntityDescItr {
|
||||
class SC_CORE_EXPORT EntityDescItr {
|
||||
protected:
|
||||
const EntityDescriptorList & edl;
|
||||
const EntityDescLinkNode * cur;
|
||||
|
|
@ -183,7 +183,7 @@ class SCL_CORE_EXPORT EntityDescItr {
|
|||
// Interfaced_item
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
class SCL_CORE_EXPORT Interfaced_item : public Dictionary_instance {
|
||||
class SC_CORE_EXPORT Interfaced_item : public Dictionary_instance {
|
||||
protected:
|
||||
Interfaced_item();
|
||||
Interfaced_item( const Interfaced_item & );
|
||||
|
|
@ -201,7 +201,7 @@ class SCL_CORE_EXPORT Interfaced_item : public Dictionary_instance {
|
|||
// Explicit_item_id
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
class SCL_CORE_EXPORT Explicit_item_id : public Interfaced_item {
|
||||
class SC_CORE_EXPORT Explicit_item_id : public Interfaced_item {
|
||||
protected:
|
||||
Explicit_item_id();
|
||||
Explicit_item_id( const Explicit_item_id & );
|
||||
|
|
@ -256,7 +256,7 @@ class SCL_CORE_EXPORT Explicit_item_id : public Interfaced_item {
|
|||
|
||||
typedef Explicit_item_id * Explicit_item_id_ptr;
|
||||
|
||||
class SCL_CORE_EXPORT Used_item : public Explicit_item_id {
|
||||
class SC_CORE_EXPORT Used_item : public Explicit_item_id {
|
||||
public:
|
||||
Used_item() {}
|
||||
Used_item( const char * foreign_schema, TypeDescriptor * ld,
|
||||
|
|
@ -271,7 +271,7 @@ class SCL_CORE_EXPORT Used_item : public Explicit_item_id {
|
|||
|
||||
typedef Used_item * Used_item_ptr;
|
||||
|
||||
class SCL_CORE_EXPORT Referenced_item : public Explicit_item_id {
|
||||
class SC_CORE_EXPORT Referenced_item : public Explicit_item_id {
|
||||
public:
|
||||
Referenced_item() {}
|
||||
Referenced_item( const char * foreign_schema, TypeDescriptor * ld,
|
||||
|
|
@ -286,7 +286,7 @@ class SCL_CORE_EXPORT Referenced_item : public Explicit_item_id {
|
|||
|
||||
typedef Referenced_item * Referenced_item_ptr;
|
||||
|
||||
class SCL_CORE_EXPORT Explicit_item_id__set {
|
||||
class SC_CORE_EXPORT Explicit_item_id__set {
|
||||
public:
|
||||
Explicit_item_id__set( int = 16 );
|
||||
~Explicit_item_id__set();
|
||||
|
|
@ -314,7 +314,7 @@ typedef Explicit_item_id__set_ptr Explicit_item_id__set_var;
|
|||
// Implicit_item_id
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
class SCL_CORE_EXPORT Implicit_item_id : public Interfaced_item {
|
||||
class SC_CORE_EXPORT Implicit_item_id : public Interfaced_item {
|
||||
protected:
|
||||
Implicit_item_id();
|
||||
Implicit_item_id( Implicit_item_id & );
|
||||
|
|
@ -338,7 +338,7 @@ typedef Implicit_item_id * Implicit_item_id_ptr;
|
|||
// Implicit_item_id__set
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
class SCL_CORE_EXPORT Implicit_item_id__set {
|
||||
class SC_CORE_EXPORT Implicit_item_id__set {
|
||||
public:
|
||||
Implicit_item_id__set( int = 16 );
|
||||
~Implicit_item_id__set();
|
||||
|
|
@ -366,7 +366,7 @@ typedef Implicit_item_id__set_ptr Implicit_item_id__set_var;
|
|||
// Interface_spec
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
class SCL_CORE_EXPORT Interface_spec : public Dictionary_instance {
|
||||
class SC_CORE_EXPORT Interface_spec : public Dictionary_instance {
|
||||
public:
|
||||
Express_id _current_schema_id; // schema containing the USE/REF stmt
|
||||
// set of objects from USE/REFERENCE stmt(s)
|
||||
|
|
@ -423,7 +423,7 @@ class SCL_CORE_EXPORT Interface_spec : public Dictionary_instance {
|
|||
|
||||
typedef Interface_spec * Interface_spec_ptr;
|
||||
|
||||
class SCL_CORE_EXPORT Interface_spec__set {
|
||||
class SC_CORE_EXPORT Interface_spec__set {
|
||||
public:
|
||||
Interface_spec__set( int = 16 );
|
||||
~Interface_spec__set();
|
||||
|
|
@ -448,7 +448,7 @@ typedef Interface_spec__set * Interface_spec__set_ptr;
|
|||
typedef Interface_spec__set_ptr Interface_spec__set_var;
|
||||
|
||||
|
||||
class SCL_CORE_EXPORT Type_or_rule : public Dictionary_instance {
|
||||
class SC_CORE_EXPORT Type_or_rule : public Dictionary_instance {
|
||||
public:
|
||||
Type_or_rule();
|
||||
Type_or_rule( const Type_or_rule & );
|
||||
|
|
@ -458,7 +458,7 @@ class SCL_CORE_EXPORT Type_or_rule : public Dictionary_instance {
|
|||
typedef Type_or_rule * Type_or_rule_ptr;
|
||||
typedef Type_or_rule_ptr Type_or_rule_var;
|
||||
|
||||
class SCL_CORE_EXPORT Where_rule : public Dictionary_instance {
|
||||
class SC_CORE_EXPORT Where_rule : public Dictionary_instance {
|
||||
public:
|
||||
Express_id _label;
|
||||
Type_or_rule_var _type_or_rule;
|
||||
|
|
@ -497,7 +497,7 @@ class SCL_CORE_EXPORT Where_rule : public Dictionary_instance {
|
|||
|
||||
typedef Where_rule * Where_rule_ptr;
|
||||
|
||||
class SCL_CORE_EXPORT Where_rule__list {
|
||||
class SC_CORE_EXPORT Where_rule__list {
|
||||
public:
|
||||
Where_rule__list( int = 16 );
|
||||
~Where_rule__list();
|
||||
|
|
@ -521,7 +521,7 @@ class SCL_CORE_EXPORT Where_rule__list {
|
|||
typedef Where_rule__list * Where_rule__list_ptr;
|
||||
typedef Where_rule__list_ptr Where_rule__list_var;
|
||||
|
||||
class SCL_CORE_EXPORT Global_rule : public Dictionary_instance {
|
||||
class SC_CORE_EXPORT Global_rule : public Dictionary_instance {
|
||||
public:
|
||||
Express_id _name;
|
||||
Entity__set_var _entities; // not implemented
|
||||
|
|
@ -566,7 +566,7 @@ class SCL_CORE_EXPORT Global_rule : public Dictionary_instance {
|
|||
|
||||
typedef Global_rule * Global_rule_ptr;
|
||||
|
||||
class SCL_CORE_EXPORT Global_rule__set {
|
||||
class SC_CORE_EXPORT Global_rule__set {
|
||||
public:
|
||||
Global_rule__set( int = 16 );
|
||||
~Global_rule__set();
|
||||
|
|
@ -590,7 +590,7 @@ class SCL_CORE_EXPORT Global_rule__set {
|
|||
typedef Global_rule__set * Global_rule__set_ptr;
|
||||
typedef Global_rule__set_ptr Global_rule__set_var;
|
||||
|
||||
class SCL_CORE_EXPORT Uniqueness_rule : public Dictionary_instance {
|
||||
class SC_CORE_EXPORT Uniqueness_rule : public Dictionary_instance {
|
||||
public:
|
||||
Express_id _label;
|
||||
const EntityDescriptor * _parent_entity;
|
||||
|
|
@ -630,7 +630,7 @@ class SCL_CORE_EXPORT Uniqueness_rule : public Dictionary_instance {
|
|||
|
||||
typedef Uniqueness_rule * Uniqueness_rule_ptr;
|
||||
|
||||
class SCL_CORE_EXPORT Uniqueness_rule__set {
|
||||
class SC_CORE_EXPORT Uniqueness_rule__set {
|
||||
public:
|
||||
Uniqueness_rule__set( int = 16 );
|
||||
~Uniqueness_rule__set();
|
||||
|
|
@ -659,7 +659,7 @@ typedef SDAI_Model_contents_ptr( * ModelContentsCreator )();
|
|||
/**
|
||||
* \class Schema (was SchemaDescriptor) - a class of this type is generated and contains schema info.
|
||||
*/
|
||||
class SCL_CORE_EXPORT Schema : public Dictionary_instance {
|
||||
class SC_CORE_EXPORT Schema : public Dictionary_instance {
|
||||
|
||||
protected:
|
||||
const char * _name;
|
||||
|
|
@ -755,7 +755,7 @@ typedef Schema SchemaDescriptor;
|
|||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
class SCL_CORE_EXPORT AttrDescLinkNode : public SingleLinkNode {
|
||||
class SC_CORE_EXPORT AttrDescLinkNode : public SingleLinkNode {
|
||||
private:
|
||||
protected:
|
||||
AttrDescriptor * _attrDesc;
|
||||
|
|
@ -771,7 +771,7 @@ class SCL_CORE_EXPORT AttrDescLinkNode : public SingleLinkNode {
|
|||
}
|
||||
};
|
||||
|
||||
class SCL_CORE_EXPORT AttrDescriptorList : public SingleLinkList {
|
||||
class SC_CORE_EXPORT AttrDescriptorList : public SingleLinkList {
|
||||
private:
|
||||
protected:
|
||||
public:
|
||||
|
|
@ -785,7 +785,7 @@ class SCL_CORE_EXPORT AttrDescriptorList : public SingleLinkList {
|
|||
AttrDescLinkNode * AddNode( AttrDescriptor * ad );
|
||||
};
|
||||
|
||||
class SCL_CORE_EXPORT AttrDescItr {
|
||||
class SC_CORE_EXPORT AttrDescItr {
|
||||
protected:
|
||||
const AttrDescriptorList & adl;
|
||||
const AttrDescLinkNode * cur;
|
||||
|
|
@ -803,7 +803,7 @@ class SCL_CORE_EXPORT AttrDescItr {
|
|||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
class SCL_CORE_EXPORT Inverse_attributeLinkNode : public SingleLinkNode {
|
||||
class SC_CORE_EXPORT Inverse_attributeLinkNode : public SingleLinkNode {
|
||||
private:
|
||||
protected:
|
||||
Inverse_attribute * _invAttr;
|
||||
|
|
@ -819,7 +819,7 @@ class SCL_CORE_EXPORT Inverse_attributeLinkNode : public SingleLinkNode {
|
|||
}
|
||||
};
|
||||
|
||||
class SCL_CORE_EXPORT Inverse_attributeList : public SingleLinkList {
|
||||
class SC_CORE_EXPORT Inverse_attributeList : public SingleLinkList {
|
||||
private:
|
||||
protected:
|
||||
public:
|
||||
|
|
@ -832,7 +832,7 @@ class SCL_CORE_EXPORT Inverse_attributeList : public SingleLinkList {
|
|||
Inverse_attributeLinkNode * AddNode( Inverse_attribute * ia );
|
||||
};
|
||||
|
||||
class SCL_CORE_EXPORT InverseAItr {
|
||||
class SC_CORE_EXPORT InverseAItr {
|
||||
protected:
|
||||
const Inverse_attributeList & ial;
|
||||
const Inverse_attributeLinkNode * cur;
|
||||
|
|
@ -853,7 +853,7 @@ class SCL_CORE_EXPORT InverseAItr {
|
|||
* An instance of this class will be generated for each attribute for
|
||||
* an Entity. They will be pointed to by the EntityTypeDescriptors.
|
||||
*/
|
||||
class SCL_CORE_EXPORT AttrDescriptor {
|
||||
class SC_CORE_EXPORT AttrDescriptor {
|
||||
|
||||
protected:
|
||||
const char * _name; // the attributes name
|
||||
|
|
@ -1029,7 +1029,7 @@ class SCL_CORE_EXPORT AttrDescriptor {
|
|||
// Derived_attribute
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
class SCL_CORE_EXPORT Derived_attribute : public AttrDescriptor {
|
||||
class SC_CORE_EXPORT Derived_attribute : public AttrDescriptor {
|
||||
public:
|
||||
const char * _initializer;
|
||||
|
||||
|
|
@ -1057,7 +1057,7 @@ class SCL_CORE_EXPORT Derived_attribute : public AttrDescriptor {
|
|||
// Inverse_attribute
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
class SCL_CORE_EXPORT Inverse_attribute : public AttrDescriptor {
|
||||
class SC_CORE_EXPORT Inverse_attribute : public AttrDescriptor {
|
||||
|
||||
public:
|
||||
const char * _inverted_attr_id;
|
||||
|
|
@ -1127,7 +1127,7 @@ class SCL_CORE_EXPORT Inverse_attribute : public AttrDescriptor {
|
|||
* schema is determined by the file schema section of the header section of a
|
||||
* part21 file (the _headerInstances of STEPfile).
|
||||
*/
|
||||
class SCL_CORE_EXPORT SchRename {
|
||||
class SC_CORE_EXPORT SchRename {
|
||||
public:
|
||||
SchRename( const char * sch = "\0", const char * newnm = "\0" ) : next( 0 ) {
|
||||
strcpy( schName, sch );
|
||||
|
|
@ -1239,7 +1239,7 @@ class SCL_CORE_EXPORT SchRename {
|
|||
* It is the same as _name for EXPRESS base types TypeDescriptors (with
|
||||
* the possible exception of upper or lower case differences).
|
||||
*/
|
||||
class SCL_CORE_EXPORT TypeDescriptor {
|
||||
class SC_CORE_EXPORT TypeDescriptor {
|
||||
|
||||
protected:
|
||||
|
||||
|
|
@ -1433,7 +1433,7 @@ class SCL_CORE_EXPORT TypeDescriptor {
|
|||
|
||||
typedef SDAI_Enum * ( * EnumCreator )();
|
||||
|
||||
class SCL_CORE_EXPORT EnumTypeDescriptor : public TypeDescriptor {
|
||||
class SC_CORE_EXPORT EnumTypeDescriptor : public TypeDescriptor {
|
||||
public:
|
||||
EnumCreator CreateNewEnum;
|
||||
|
||||
|
|
@ -1464,7 +1464,7 @@ class SCL_CORE_EXPORT EnumTypeDescriptor : public TypeDescriptor {
|
|||
* will be building the same thing but using the new schema info.
|
||||
* nodes (i.e. EntityDesc nodes) for each entity.
|
||||
*/
|
||||
class SCL_CORE_EXPORT EntityDescriptor : public TypeDescriptor {
|
||||
class SC_CORE_EXPORT EntityDescriptor : public TypeDescriptor {
|
||||
|
||||
protected:
|
||||
SDAI_LOGICAL _abstractEntity;
|
||||
|
|
@ -1591,7 +1591,7 @@ class SCL_CORE_EXPORT EntityDescriptor : public TypeDescriptor {
|
|||
* FIXME not implemented
|
||||
*/
|
||||
#ifdef NOT_YET
|
||||
class SCL_CORE_EXPORT EnumerationTypeDescriptor : public TypeDescriptor {
|
||||
class SC_CORE_EXPORT EnumerationTypeDescriptor : public TypeDescriptor {
|
||||
|
||||
protected:
|
||||
StringAggregate * _elements; // of (null)
|
||||
|
|
@ -1628,21 +1628,21 @@ typedef BinaryAggregate * ( * BinaryAggregateCreator )();
|
|||
typedef RealAggregate * ( * RealAggregateCreator )();
|
||||
typedef IntAggregate * ( * IntAggregateCreator )();
|
||||
|
||||
SCL_CORE_EXPORT EnumAggregate * create_EnumAggregate();
|
||||
SC_CORE_EXPORT EnumAggregate * create_EnumAggregate();
|
||||
|
||||
SCL_CORE_EXPORT GenericAggregate * create_GenericAggregate();
|
||||
SC_CORE_EXPORT GenericAggregate * create_GenericAggregate();
|
||||
|
||||
SCL_CORE_EXPORT EntityAggregate * create_EntityAggregate();
|
||||
SC_CORE_EXPORT EntityAggregate * create_EntityAggregate();
|
||||
|
||||
SCL_CORE_EXPORT SelectAggregate * create_SelectAggregate();
|
||||
SC_CORE_EXPORT SelectAggregate * create_SelectAggregate();
|
||||
|
||||
SCL_CORE_EXPORT StringAggregate * create_StringAggregate();
|
||||
SC_CORE_EXPORT StringAggregate * create_StringAggregate();
|
||||
|
||||
SCL_CORE_EXPORT BinaryAggregate * create_BinaryAggregate();
|
||||
SC_CORE_EXPORT BinaryAggregate * create_BinaryAggregate();
|
||||
|
||||
SCL_CORE_EXPORT RealAggregate * create_RealAggregate();
|
||||
SC_CORE_EXPORT RealAggregate * create_RealAggregate();
|
||||
|
||||
SCL_CORE_EXPORT IntAggregate * create_IntAggregate();
|
||||
SC_CORE_EXPORT IntAggregate * create_IntAggregate();
|
||||
|
||||
typedef SDAI_Integer( *boundCallbackFn )( SDAI_Application_instance * );
|
||||
|
||||
|
|
@ -1657,7 +1657,7 @@ typedef SDAI_Integer( *boundCallbackFn )( SDAI_Application_instance * );
|
|||
* together by the _aggrDomainType variables. If you can make this
|
||||
* work then go for it.
|
||||
*/
|
||||
class SCL_CORE_EXPORT AggrTypeDescriptor : public TypeDescriptor {
|
||||
class SC_CORE_EXPORT AggrTypeDescriptor : public TypeDescriptor {
|
||||
|
||||
protected:
|
||||
|
||||
|
|
@ -1779,7 +1779,7 @@ class SCL_CORE_EXPORT AggrTypeDescriptor : public TypeDescriptor {
|
|||
///////////////////////////////////////////////////////////////////////////////
|
||||
// ArrayTypeDescriptor
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
class SCL_CORE_EXPORT ArrayTypeDescriptor : public AggrTypeDescriptor {
|
||||
class SC_CORE_EXPORT ArrayTypeDescriptor : public AggrTypeDescriptor {
|
||||
|
||||
protected:
|
||||
SDAI_LOGICAL _optionalElements;
|
||||
|
|
@ -1812,7 +1812,7 @@ class SCL_CORE_EXPORT ArrayTypeDescriptor : public AggrTypeDescriptor {
|
|||
}
|
||||
};
|
||||
|
||||
class SCL_CORE_EXPORT ListTypeDescriptor : public AggrTypeDescriptor {
|
||||
class SC_CORE_EXPORT ListTypeDescriptor : public AggrTypeDescriptor {
|
||||
|
||||
protected:
|
||||
public:
|
||||
|
|
@ -1825,7 +1825,7 @@ class SCL_CORE_EXPORT ListTypeDescriptor : public AggrTypeDescriptor {
|
|||
|
||||
};
|
||||
|
||||
class SCL_CORE_EXPORT SetTypeDescriptor : public AggrTypeDescriptor {
|
||||
class SC_CORE_EXPORT SetTypeDescriptor : public AggrTypeDescriptor {
|
||||
|
||||
protected:
|
||||
public:
|
||||
|
|
@ -1839,7 +1839,7 @@ class SCL_CORE_EXPORT SetTypeDescriptor : public AggrTypeDescriptor {
|
|||
|
||||
};
|
||||
|
||||
class SCL_CORE_EXPORT BagTypeDescriptor : public AggrTypeDescriptor {
|
||||
class SC_CORE_EXPORT BagTypeDescriptor : public AggrTypeDescriptor {
|
||||
|
||||
protected:
|
||||
public:
|
||||
|
|
@ -1855,7 +1855,7 @@ class SCL_CORE_EXPORT BagTypeDescriptor : public AggrTypeDescriptor {
|
|||
|
||||
typedef SDAI_Select * ( * SelectCreator )();
|
||||
|
||||
class SCL_CORE_EXPORT SelectTypeDescriptor : public TypeDescriptor {
|
||||
class SC_CORE_EXPORT SelectTypeDescriptor : public TypeDescriptor {
|
||||
|
||||
protected:
|
||||
TypeDescriptorList _elements; // of TYPE_DESCRIPTOR
|
||||
|
|
@ -1898,7 +1898,7 @@ class SCL_CORE_EXPORT SelectTypeDescriptor : public TypeDescriptor {
|
|||
const;
|
||||
};
|
||||
|
||||
class SCL_CORE_EXPORT StringTypeDescriptor : public TypeDescriptor {
|
||||
class SC_CORE_EXPORT StringTypeDescriptor : public TypeDescriptor {
|
||||
|
||||
protected:
|
||||
SDAI_Integer _width; // OPTIONAL
|
||||
|
|
@ -1929,7 +1929,7 @@ class SCL_CORE_EXPORT StringTypeDescriptor : public TypeDescriptor {
|
|||
}
|
||||
};
|
||||
|
||||
class SCL_CORE_EXPORT RealTypeDescriptor : public TypeDescriptor {
|
||||
class SC_CORE_EXPORT RealTypeDescriptor : public TypeDescriptor {
|
||||
|
||||
protected:
|
||||
SDAI_Integer _precisionSpec; // OPTIONAL
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@
|
|||
*/
|
||||
|
||||
#include <ExpDict.h>
|
||||
#include "scl_memmgr.h"
|
||||
#include "sc_memmgr.h"
|
||||
|
||||
Dictionary_instance::~Dictionary_instance() {
|
||||
}
|
||||
|
|
|
|||
|
|
@ -12,10 +12,10 @@
|
|||
* and is not subject to copyright.
|
||||
*/
|
||||
|
||||
#include <scl_export.h>
|
||||
#include <sc_export.h>
|
||||
#include <sdai.h>
|
||||
#include <errordesc.h>
|
||||
#include <scl_hash.h>
|
||||
#include <sc_hash.h>
|
||||
#include <Str.h>
|
||||
#include <complexSupport.h>
|
||||
|
||||
|
|
@ -24,7 +24,7 @@ typedef struct Hash_Table * HashTable;
|
|||
class Registry;
|
||||
typedef void ( * CF_init )( Registry & ); // pointer to creation initialization
|
||||
|
||||
class SCL_CORE_EXPORT Registry {
|
||||
class SC_CORE_EXPORT Registry {
|
||||
protected:
|
||||
HashTable primordialSwamp; // dictionary of EntityDescriptors
|
||||
HashTable active_schemas; // dictionary of Schemas
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@
|
|||
|
||||
#include <ExpDict.h>
|
||||
#include <Registry.h>
|
||||
#include "scl_memmgr.h"
|
||||
#include "sc_memmgr.h"
|
||||
|
||||
const TypeDescriptor * t_sdaiINTEGER = NULL;
|
||||
const TypeDescriptor * t_sdaiREAL = NULL;
|
||||
|
|
@ -26,9 +26,9 @@ static int uniqueNames( const char *, const SchRename * );
|
|||
Registry::Registry( CF_init initFunct )
|
||||
: col( 0 ), entity_cnt( 0 ), all_ents_cnt( 0 ) {
|
||||
|
||||
primordialSwamp = SCL_HASHcreate( 1000 );
|
||||
active_schemas = SCL_HASHcreate( 10 );
|
||||
active_types = SCL_HASHcreate( 100 );
|
||||
primordialSwamp = SC_HASHcreate( 1000 );
|
||||
active_schemas = SC_HASHcreate( 10 );
|
||||
active_types = SC_HASHcreate( 100 );
|
||||
|
||||
if( !t_sdaiINTEGER ) {
|
||||
t_sdaiINTEGER = new TypeDescriptor( "INTEGER", // Name
|
||||
|
|
@ -68,17 +68,17 @@ Registry::Registry( CF_init initFunct )
|
|||
}
|
||||
|
||||
initFunct( *this );
|
||||
SCL_HASHlistinit( active_types, &cur_type );
|
||||
SCL_HASHlistinit( primordialSwamp, &cur_entity ); // initialize cur's
|
||||
SCL_HASHlistinit( active_schemas, &cur_schema );
|
||||
SC_HASHlistinit( active_types, &cur_type );
|
||||
SC_HASHlistinit( primordialSwamp, &cur_entity ); // initialize cur's
|
||||
SC_HASHlistinit( active_schemas, &cur_schema );
|
||||
}
|
||||
|
||||
Registry::~Registry() {
|
||||
DeleteContents();
|
||||
|
||||
SCL_HASHdestroy( primordialSwamp );
|
||||
SCL_HASHdestroy( active_schemas );
|
||||
SCL_HASHdestroy( active_types );
|
||||
SC_HASHdestroy( primordialSwamp );
|
||||
SC_HASHdestroy( active_schemas );
|
||||
SC_HASHdestroy( active_types );
|
||||
delete col;
|
||||
|
||||
if( t_sdaiINTEGER ) {
|
||||
|
|
@ -113,20 +113,20 @@ Registry::~Registry() {
|
|||
|
||||
void Registry::DeleteContents() {
|
||||
// entities first
|
||||
SCL_HASHlistinit( primordialSwamp, &cur_entity );
|
||||
while( SCL_HASHlist( &cur_entity ) ) {
|
||||
SC_HASHlistinit( primordialSwamp, &cur_entity );
|
||||
while( SC_HASHlist( &cur_entity ) ) {
|
||||
delete( EntityDescriptor * ) cur_entity.e->data;
|
||||
}
|
||||
|
||||
// schemas
|
||||
SCL_HASHlistinit( active_schemas, &cur_schema );
|
||||
while( SCL_HASHlist( &cur_schema ) ) {
|
||||
SC_HASHlistinit( active_schemas, &cur_schema );
|
||||
while( SC_HASHlist( &cur_schema ) ) {
|
||||
delete( Schema * ) cur_schema.e->data;
|
||||
}
|
||||
|
||||
// types
|
||||
SCL_HASHlistinit( active_types, &cur_type );
|
||||
while( SCL_HASHlist( &cur_type ) ) {
|
||||
SC_HASHlistinit( active_types, &cur_type );
|
||||
while( SC_HASHlist( &cur_type ) ) {
|
||||
delete( TypeDescriptor * ) cur_type.e->data;
|
||||
}
|
||||
}
|
||||
|
|
@ -146,9 +146,9 @@ const EntityDescriptor * Registry::FindEntity( const char * e, const char * schN
|
|||
char schformat[BUFSIZ], altName[BUFSIZ];
|
||||
|
||||
if( check_case ) {
|
||||
entd = ( EntityDescriptor * )SCL_HASHfind( primordialSwamp, ( char * )e );
|
||||
entd = ( EntityDescriptor * )SC_HASHfind( primordialSwamp, ( char * )e );
|
||||
} else {
|
||||
entd = ( EntityDescriptor * )SCL_HASHfind( primordialSwamp,
|
||||
entd = ( EntityDescriptor * )SC_HASHfind( primordialSwamp,
|
||||
( char * )PrettyTmpName( e ) );
|
||||
}
|
||||
if( entd && schNm ) {
|
||||
|
|
@ -182,34 +182,34 @@ const EntityDescriptor * Registry::FindEntity( const char * e, const char * schN
|
|||
|
||||
const Schema * Registry::FindSchema( const char * n, int check_case ) const {
|
||||
if( check_case ) {
|
||||
return ( const Schema * ) SCL_HASHfind( active_schemas, ( char * ) n );
|
||||
return ( const Schema * ) SC_HASHfind( active_schemas, ( char * ) n );
|
||||
}
|
||||
|
||||
return ( const Schema * ) SCL_HASHfind( active_schemas,
|
||||
return ( const Schema * ) SC_HASHfind( active_schemas,
|
||||
( char * )PrettyTmpName( n ) );
|
||||
}
|
||||
|
||||
const TypeDescriptor * Registry::FindType( const char * n, int check_case ) const {
|
||||
if( check_case ) {
|
||||
return ( const TypeDescriptor * ) SCL_HASHfind( active_types, ( char * ) n );
|
||||
return ( const TypeDescriptor * ) SC_HASHfind( active_types, ( char * ) n );
|
||||
}
|
||||
return ( const TypeDescriptor * ) SCL_HASHfind( active_types,
|
||||
return ( const TypeDescriptor * ) SC_HASHfind( active_types,
|
||||
( char * )PrettyTmpName( n ) );
|
||||
}
|
||||
|
||||
void Registry::ResetTypes() {
|
||||
SCL_HASHlistinit( active_types, &cur_type );
|
||||
SC_HASHlistinit( active_types, &cur_type );
|
||||
}
|
||||
|
||||
const TypeDescriptor * Registry::NextType() {
|
||||
if( 0 == SCL_HASHlist( &cur_type ) ) {
|
||||
if( 0 == SC_HASHlist( &cur_type ) ) {
|
||||
return 0;
|
||||
}
|
||||
return ( const TypeDescriptor * ) cur_type.e->data;
|
||||
}
|
||||
|
||||
void Registry::AddEntity( const EntityDescriptor & e ) {
|
||||
SCL_HASHinsert( primordialSwamp, ( char * ) e.Name(), ( EntityDescriptor * ) &e );
|
||||
SC_HASHinsert( primordialSwamp, ( char * ) e.Name(), ( EntityDescriptor * ) &e );
|
||||
++entity_cnt;
|
||||
++all_ents_cnt;
|
||||
AddClones( e );
|
||||
|
|
@ -217,11 +217,11 @@ void Registry::AddEntity( const EntityDescriptor & e ) {
|
|||
|
||||
|
||||
void Registry::AddSchema( const Schema & d ) {
|
||||
SCL_HASHinsert( active_schemas, ( char * ) d.Name(), ( Schema * ) &d );
|
||||
SC_HASHinsert( active_schemas, ( char * ) d.Name(), ( Schema * ) &d );
|
||||
}
|
||||
|
||||
void Registry::AddType( const TypeDescriptor & d ) {
|
||||
SCL_HASHinsert( active_types, ( char * ) d.Name(), ( TypeDescriptor * ) &d );
|
||||
SC_HASHinsert( active_types, ( char * ) d.Name(), ( TypeDescriptor * ) &d );
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -235,7 +235,7 @@ void Registry::AddClones( const EntityDescriptor & e ) {
|
|||
const SchRename * alts = e.AltNameList();
|
||||
|
||||
while( alts ) {
|
||||
SCL_HASHinsert( primordialSwamp, ( char * )alts->objName(),
|
||||
SC_HASHinsert( primordialSwamp, ( char * )alts->objName(),
|
||||
( EntityDescriptor * )&e );
|
||||
alts = alts->next;
|
||||
}
|
||||
|
|
@ -278,20 +278,20 @@ void Registry::RemoveEntity( const char * n ) {
|
|||
RemoveClones( *e );
|
||||
}
|
||||
tmp.key = ( char * ) n;
|
||||
SCL_HASHsearch( primordialSwamp, &tmp, HASH_DELETE ) ? --entity_cnt : 0;
|
||||
SC_HASHsearch( primordialSwamp, &tmp, HASH_DELETE ) ? --entity_cnt : 0;
|
||||
|
||||
}
|
||||
|
||||
void Registry::RemoveSchema( const char * n ) {
|
||||
struct Element tmp;
|
||||
tmp.key = ( char * ) n;
|
||||
SCL_HASHsearch( active_schemas, &tmp, HASH_DELETE );
|
||||
SC_HASHsearch( active_schemas, &tmp, HASH_DELETE );
|
||||
}
|
||||
|
||||
void Registry::RemoveType( const char * n ) {
|
||||
struct Element tmp;
|
||||
tmp.key = ( char * ) n;
|
||||
SCL_HASHsearch( active_types, &tmp, HASH_DELETE );
|
||||
SC_HASHsearch( active_types, &tmp, HASH_DELETE );
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -304,7 +304,7 @@ void Registry::RemoveClones( const EntityDescriptor & e ) {
|
|||
while( alts ) {
|
||||
tmp = new Element;
|
||||
tmp->key = ( char * ) alts->objName();
|
||||
SCL_HASHsearch( primordialSwamp, tmp, HASH_DELETE );
|
||||
SC_HASHsearch( primordialSwamp, tmp, HASH_DELETE );
|
||||
alts = alts->next;
|
||||
}
|
||||
}
|
||||
|
|
@ -336,23 +336,23 @@ int Registry::GetEntityCnt() {
|
|||
}
|
||||
|
||||
void Registry::ResetEntities() {
|
||||
SCL_HASHlistinit( primordialSwamp, &cur_entity );
|
||||
SC_HASHlistinit( primordialSwamp, &cur_entity );
|
||||
|
||||
}
|
||||
|
||||
const EntityDescriptor * Registry::NextEntity() {
|
||||
if( 0 == SCL_HASHlist( &cur_entity ) ) {
|
||||
if( 0 == SC_HASHlist( &cur_entity ) ) {
|
||||
return 0;
|
||||
}
|
||||
return ( const EntityDescriptor * ) cur_entity.e->data;
|
||||
}
|
||||
|
||||
void Registry::ResetSchemas() {
|
||||
SCL_HASHlistinit( active_schemas, &cur_schema );
|
||||
SC_HASHlistinit( active_schemas, &cur_schema );
|
||||
}
|
||||
|
||||
const Schema * Registry::NextSchema() {
|
||||
if( 0 == SCL_HASHlist( &cur_schema ) ) {
|
||||
if( 0 == SC_HASHlist( &cur_schema ) ) {
|
||||
return 0;
|
||||
}
|
||||
return ( const Schema * ) cur_schema.e->data;
|
||||
|
|
|
|||
|
|
@ -17,7 +17,7 @@
|
|||
#include <STEPattribute.h>
|
||||
#include <instmgr.h>
|
||||
#include <ExpDict.h>
|
||||
#include "scl_memmgr.h"
|
||||
#include "sc_memmgr.h"
|
||||
|
||||
const int Real_Num_Precision = REAL_NUM_PRECISION; // from STEPattribute.h
|
||||
|
||||
|
|
|
|||
|
|
@ -16,7 +16,7 @@ class InstMgr;
|
|||
class STEPaggregate;
|
||||
class TypeDescriptor;
|
||||
|
||||
#include <scl_export.h>
|
||||
#include <sc_export.h>
|
||||
#include <errordesc.h>
|
||||
#include <SingleLinkList.h>
|
||||
#include <baseType.h>
|
||||
|
|
@ -34,7 +34,7 @@ typedef STEPaggregate * STEPaggregateH;
|
|||
typedef STEPaggregate * STEPaggregate_ptr;
|
||||
typedef STEPaggregate_ptr STEPaggregate_var;
|
||||
|
||||
class SCL_CORE_EXPORT STEPaggregate : public SingleLinkList {
|
||||
class SC_CORE_EXPORT STEPaggregate : public SingleLinkList {
|
||||
protected:
|
||||
int _null;
|
||||
|
||||
|
|
@ -89,7 +89,7 @@ class SCL_CORE_EXPORT STEPaggregate : public SingleLinkList {
|
|||
** This class supports LIST OF:
|
||||
** SELECT_TYPE, BINARY_TYPE, GENERIC_TYPE, ENUM_TYPE, UNKNOWN_TYPE type
|
||||
******************************************************************/
|
||||
class SCL_CORE_EXPORT GenericAggregate : public STEPaggregate {
|
||||
class SC_CORE_EXPORT GenericAggregate : public STEPaggregate {
|
||||
public:
|
||||
virtual SingleLinkNode * NewNode();
|
||||
virtual STEPaggregate & ShallowCopy( const STEPaggregate & );
|
||||
|
|
@ -105,7 +105,7 @@ typedef GenericAggregate_ptr GenericAggregate_var;
|
|||
**
|
||||
*****************************************************************************/
|
||||
|
||||
class SCL_CORE_EXPORT EntityAggregate : public STEPaggregate {
|
||||
class SC_CORE_EXPORT EntityAggregate : public STEPaggregate {
|
||||
public:
|
||||
virtual Severity ReadValue( istream & in, ErrorDescriptor * err,
|
||||
const TypeDescriptor * elem_type,
|
||||
|
|
@ -127,7 +127,7 @@ typedef EntityAggregate_ptr EntityAggregate_var;
|
|||
** \class SelectAggregate
|
||||
** This is a minimal represention for a collection of SDAI_Select
|
||||
******************************************************************/
|
||||
class SCL_CORE_EXPORT SelectAggregate : public STEPaggregate {
|
||||
class SC_CORE_EXPORT SelectAggregate : public STEPaggregate {
|
||||
public:
|
||||
virtual Severity ReadValue( istream & in, ErrorDescriptor * err,
|
||||
const TypeDescriptor * elem_type,
|
||||
|
|
@ -149,7 +149,7 @@ typedef SelectAggregate_ptr SelectAggregate_var;
|
|||
** \class StringAggregate
|
||||
** This class supports LIST OF STRING type
|
||||
******************************************************************/
|
||||
class SCL_CORE_EXPORT StringAggregate : public STEPaggregate {
|
||||
class SC_CORE_EXPORT StringAggregate : public STEPaggregate {
|
||||
public:
|
||||
virtual SingleLinkNode * NewNode();
|
||||
virtual STEPaggregate & ShallowCopy( const STEPaggregate & );
|
||||
|
|
@ -166,7 +166,7 @@ typedef StringAggregate_ptr StringAggregate_var;
|
|||
** \class BinaryAggregate
|
||||
** This class supports LIST OF BINARY type
|
||||
******************************************************************/
|
||||
class SCL_CORE_EXPORT BinaryAggregate : public STEPaggregate {
|
||||
class SC_CORE_EXPORT BinaryAggregate : public STEPaggregate {
|
||||
public:
|
||||
virtual SingleLinkNode * NewNode();
|
||||
virtual STEPaggregate & ShallowCopy( const STEPaggregate & );
|
||||
|
|
@ -182,7 +182,7 @@ typedef BinaryAggregate_ptr BinaryAggregate_var;
|
|||
** \class EnumAggregate
|
||||
** This is a minimal representions for a collection ofSDAI_Enum
|
||||
******************************************************************/
|
||||
class SCL_CORE_EXPORT EnumAggregate : public STEPaggregate {
|
||||
class SC_CORE_EXPORT EnumAggregate : public STEPaggregate {
|
||||
public:
|
||||
virtual SingleLinkNode * NewNode();
|
||||
virtual STEPaggregate & ShallowCopy( const STEPaggregate & );
|
||||
|
|
@ -194,7 +194,7 @@ typedef EnumAggregate * EnumAggregateH;
|
|||
typedef EnumAggregate * EnumAggregate_ptr;
|
||||
typedef EnumAggregate_ptr EnumAggregate_var;
|
||||
|
||||
class SCL_CORE_EXPORT LOGICALS : public EnumAggregate {
|
||||
class SC_CORE_EXPORT LOGICALS : public EnumAggregate {
|
||||
public:
|
||||
virtual SingleLinkNode * NewNode();
|
||||
|
||||
|
|
@ -204,10 +204,10 @@ class SCL_CORE_EXPORT LOGICALS : public EnumAggregate {
|
|||
typedef LOGICALS * LogicalsH;
|
||||
typedef LOGICALS * LOGICALS_ptr;
|
||||
typedef LOGICALS_ptr LOGICALS_var;
|
||||
SCL_CORE_EXPORT LOGICALS * create_LOGICALS();
|
||||
SC_CORE_EXPORT LOGICALS * create_LOGICALS();
|
||||
|
||||
|
||||
class SCL_CORE_EXPORT BOOLEANS : public EnumAggregate {
|
||||
class SC_CORE_EXPORT BOOLEANS : public EnumAggregate {
|
||||
public:
|
||||
virtual SingleLinkNode * NewNode();
|
||||
|
||||
|
|
@ -218,9 +218,9 @@ class SCL_CORE_EXPORT BOOLEANS : public EnumAggregate {
|
|||
typedef BOOLEANS * BOOLEANS_ptr;
|
||||
typedef BOOLEANS_ptr BOOLEANS_var;
|
||||
|
||||
SCL_CORE_EXPORT BOOLEANS * create_BOOLEANS();
|
||||
SC_CORE_EXPORT BOOLEANS * create_BOOLEANS();
|
||||
|
||||
class SCL_CORE_EXPORT RealAggregate : public STEPaggregate {
|
||||
class SC_CORE_EXPORT RealAggregate : public STEPaggregate {
|
||||
|
||||
public:
|
||||
virtual SingleLinkNode * NewNode();
|
||||
|
|
@ -233,7 +233,7 @@ typedef RealAggregate * RealAggregateH;
|
|||
typedef RealAggregate * RealAggregate_ptr;
|
||||
typedef RealAggregate_ptr RealAggregate_var;
|
||||
|
||||
class SCL_CORE_EXPORT IntAggregate : public STEPaggregate {
|
||||
class SC_CORE_EXPORT IntAggregate : public STEPaggregate {
|
||||
|
||||
public:
|
||||
virtual SingleLinkNode * NewNode();
|
||||
|
|
@ -248,7 +248,7 @@ typedef IntAggregate_ptr IntAggregate_var;
|
|||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
class SCL_CORE_EXPORT STEPnode : public SingleLinkNode {
|
||||
class SC_CORE_EXPORT STEPnode : public SingleLinkNode {
|
||||
protected:
|
||||
int _null;
|
||||
|
||||
|
|
@ -278,7 +278,7 @@ class SCL_CORE_EXPORT STEPnode : public SingleLinkNode {
|
|||
** This class is for the Nodes of GenericAggregates
|
||||
******************************************************************/
|
||||
typedef STEPnode * STEPnodeH;
|
||||
class SCL_CORE_EXPORT GenericAggrNode : public STEPnode {
|
||||
class SC_CORE_EXPORT GenericAggrNode : public STEPnode {
|
||||
public:
|
||||
SCLundefined value;
|
||||
// INPUT
|
||||
|
|
@ -304,7 +304,7 @@ class SCL_CORE_EXPORT GenericAggrNode : public STEPnode {
|
|||
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
class SCL_CORE_EXPORT EntityNode : public STEPnode {
|
||||
class SC_CORE_EXPORT EntityNode : public STEPnode {
|
||||
public:
|
||||
SDAI_Application_instance * node;
|
||||
|
||||
|
|
@ -364,7 +364,7 @@ class SCL_CORE_EXPORT EntityNode : public STEPnode {
|
|||
** \class SelectNode
|
||||
** This is a minimal representions for node in lists of SDAI_Select
|
||||
******************************************************************/
|
||||
class SCL_CORE_EXPORT SelectNode : public STEPnode {
|
||||
class SC_CORE_EXPORT SelectNode : public STEPnode {
|
||||
public:
|
||||
SDAI_Select * node;
|
||||
// INPUT
|
||||
|
|
@ -423,7 +423,7 @@ class SCL_CORE_EXPORT SelectNode : public STEPnode {
|
|||
** \class StringNode
|
||||
** This class is for the Nodes of StringAggregates
|
||||
******************************************************************/
|
||||
class SCL_CORE_EXPORT StringNode : public STEPnode {
|
||||
class SC_CORE_EXPORT StringNode : public STEPnode {
|
||||
public:
|
||||
SDAI_String value;
|
||||
// INPUT
|
||||
|
|
@ -453,7 +453,7 @@ class SCL_CORE_EXPORT StringNode : public STEPnode {
|
|||
** \class BinaryNode
|
||||
** This class is for the Nodes of BinaryAggregates
|
||||
******************************************************************/
|
||||
class SCL_CORE_EXPORT BinaryNode : public STEPnode {
|
||||
class SC_CORE_EXPORT BinaryNode : public STEPnode {
|
||||
public:
|
||||
SDAI_Binary value;
|
||||
// INPUT
|
||||
|
|
@ -481,7 +481,7 @@ class SCL_CORE_EXPORT BinaryNode : public STEPnode {
|
|||
** \class EnumNode
|
||||
** This is a minimal representions for node in lists of SDAI_Enum
|
||||
******************************************************************/
|
||||
class SCL_CORE_EXPORT EnumNode : public STEPnode {
|
||||
class SC_CORE_EXPORT EnumNode : public STEPnode {
|
||||
public:
|
||||
SDAI_Enum * node;
|
||||
// INPUT
|
||||
|
|
@ -504,7 +504,7 @@ class SCL_CORE_EXPORT EnumNode : public STEPnode {
|
|||
virtual SingleLinkNode * NewNode();
|
||||
};
|
||||
|
||||
class SCL_CORE_EXPORT RealNode : public STEPnode {
|
||||
class SC_CORE_EXPORT RealNode : public STEPnode {
|
||||
public:
|
||||
SDAI_Real value; // double
|
||||
// INPUT
|
||||
|
|
@ -526,7 +526,7 @@ class SCL_CORE_EXPORT RealNode : public STEPnode {
|
|||
virtual SingleLinkNode * NewNode();
|
||||
};
|
||||
|
||||
class SCL_CORE_EXPORT IntNode : public STEPnode {
|
||||
class SC_CORE_EXPORT IntNode : public STEPnode {
|
||||
public:
|
||||
SDAI_Integer value; // long int
|
||||
// INPUT
|
||||
|
|
|
|||
Some files were not shown because too many files have changed in this diff Show more
Loading…
Reference in a new issue