Merge branch 'develop' into test_master_release

CMakeLists.txt

@@ -48,7 +48,7 @@ endif (POLICY CMP0077)
 
 # SC version
 set(SC_VERSION_MAJOR 0)
-set(SC_VERSION_MINOR 8)
+set(SC_VERSION_MINOR 9)
 set(SC_VERSION_PATCH 1)
 set(SC_VERSION ${SC_VERSION_MAJOR}.${SC_VERSION_MINOR}.${SC_VERSION_PATCH})
 

cmake/FindLEMON.cmake

@@ -141,7 +141,7 @@ if (LEMON_EXECUTABLE)
 
       # execute lemon
       add_custom_command(
-	OUTPUT ${_out_src_file} ${_basename}.h
+	OUTPUT ${_out_src_file}
 	COMMAND ${LEMON_EXECUTABLE} -T${LEMON_TEMPLATE} ${LEMON_EXECUTABLE_opts} ${_in_y_file}
 	DEPENDS ${Name}_input_cpy
 	WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
@@ -152,7 +152,7 @@ if (LEMON_EXECUTABLE)
       add_custom_command(
 	OUTPUT ${_out_hdr_file}
 	COMMAND ${CMAKE_COMMAND} ARGS -E rename ${_basename}.h ${_out_hdr_file}
-	DEPENDS ${_out_src_file} ${_basename}.h
+	DEPENDS ${_out_src_file}
 	WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
 	)
 

example/ap203min/CMakeLists.txt

@@ -58,6 +58,10 @@ add_subdirectory(${STEPCODE_ROOT_DIR} "${CMAKE_CURRENT_BINARY_DIR}/sc" EXCLUDE_F
 
 # Set up STEPcode include directories.
 set(STEPCODE_INCLUDE_DIR
+  ${STEPCODE_ROOT_DIR}/src/clstepcore
+  ${STEPCODE_ROOT_DIR}/src/cldai
+  ${STEPCODE_ROOT_DIR}/src/clutils
+  ${STEPCODE_ROOT_DIR}/src/cleditor
   ${STEPCODE_BUILD_DIR}/include
   ${STEPCODE_ROOT_DIR}/include
   ${CMAKE_BINARY_DIR}

example/ap203min/ap203min.cpp

@@ -49,15 +49,15 @@
 //  $./AP203Minimum
 //  AP203Minimum    outfile.stp
 
-#include <cleditor/STEPfile.h>
-#include <clstepcore/sdai.h>
-#include <clstepcore/STEPattribute.h>
-#include <clstepcore/ExpDict.h>
-#include <clstepcore/Registry.h>
-#include <clutils/errordesc.h>
+#include <STEPfile.h>
+#include <sdai.h>
+#include <STEPattribute.h>
+#include <ExpDict.h>
+#include <Registry.h>
+#include <errordesc.h>
 
-#include <clstepcore/STEPcomplex.h>
-#include <cleditor/SdaiHeaderSchema.h>
+#include <STEPcomplex.h>
+#include <SdaiHeaderSchema.h>
 
 #include "schema.h"
 

include/CMakeLists.txt

@@ -37,12 +37,6 @@ install(FILES ordered_attrs.h
 install(FILES ${SC_BINARY_DIR}/${INCLUDE_DIR}/config.h
   DESTINATION ${INCLUDE_DIR}/stepcode)
 
-add_subdirectory(cldai)
-add_subdirectory(cleditor)
-add_subdirectory(cllazyfile)
-add_subdirectory(clstepcore)
-add_subdirectory(clutils)
-
 # Local Variables:
 # tab-width: 8
 # mode: cmake

include/cldai/CMakeLists.txt

@@ -1,24 +0,0 @@
-set(DAI_HDRS
-  sdaiApplication_instance_set.h
-  sdaiBinary.h
-  sdaiDaObject.h
-  sdaiEntity_extent.h
-  sdaiEntity_extent_set.h
-  sdaiEnum.h
-  sdaiModel_contents.h
-  sdaiModel_contents_list.h
-  sdaiObject.h
-  sdaiSession_instance.h
-  sdaiString.h
-  )
-
-install(FILES ${DAI_HDRS}
-  DESTINATION ${INCLUDE_DIR}/stepcode/cldai)
-
-# Local Variables:
-# tab-width: 8
-# mode: cmake
-# indent-tabs-mode: t
-# End:
-# ex: shiftwidth=2 tabstop=8
-

include/cleditor/CMakeLists.txt

@@ -1,20 +0,0 @@
-set(EDITOR_HDRS
-  STEPfile.h
-  cmdmgr.h
-  editordefines.h
-  SdaiHeaderSchema.h
-  SdaiHeaderSchemaClasses.h
-  SdaiSchemaInit.h
-  seeinfodefault.h
-  )
-
-install(FILES ${EDITOR_HDRS}
-  DESTINATION ${INCLUDE_DIR}/stepcode/cleditor)
-
-# Local Variables:
-# tab-width: 8
-# mode: cmake
-# indent-tabs-mode: t
-# End:
-# ex: shiftwidth=2 tabstop=8
-

include/cllazyfile/CMakeLists.txt

@@ -1,27 +0,0 @@
-set(LAZY_HDRS
-  headerSectionReader.h
-  lazyFileReader.h
-  lazyP21DataSectionReader.h
-  p21HeaderSectionReader.h
-  lazyDataSectionReader.h
-  lazyInstMgr.h
-  lazyTypes.h
-  sectionReader.h
-  instMgrHelper.h
-  judy.h
-  judyL2Array.h
-  judyLArray.h
-  judyS2Array.h
-  judySArray.h
-  )
-
-install(FILES ${LAZY_HDRS}
-  DESTINATION ${INCLUDE_DIR}/stepcode/cllazyfile)
-
-# Local Variables:
-# tab-width: 8
-# mode: cmake
-# indent-tabs-mode: t
-# End:
-# ex: shiftwidth=2 tabstop=8
-

include/clstepcore/CMakeLists.txt

@@ -1,71 +0,0 @@
-set(CORE_HDRS
-  aggrTypeDescriptor.h
-  attrDescriptor.h
-  attrDescriptorList.h
-  baseType.h
-  complexSupport.h
-  create_Aggr.h
-  derivedAttribute.h
-  dictSchema.h
-  dictdefs.h
-  dictionaryInstance.h
-  dispnode.h
-  dispnodelist.h
-  entityDescriptor.h
-  entityDescriptorList.h
-  enumTypeDescriptor.h
-  ExpDict.h
-  explicitItemId.h
-  globalRule.h
-  implicitItemId.h
-  instmgr.h
-  interfaceSpec.h
-  interfacedItem.h
-  inverseAttribute.h
-  inverseAttributeList.h
-  mgrnode.h
-  mgrnodearray.h
-  mgrnodelist.h
-  needFunc.h
-  read_func.h
-  realTypeDescriptor.h
-  Registry.h
-  schRename.h
-  sdai.h
-  sdaiApplication_instance.h
-  sdaiSelect.h
-  selectTypeDescriptor.h
-  SingleLinkList.h
-  STEPaggregate.h
-  STEPaggrBinary.h
-  STEPaggrEntity.h
-  STEPaggrEnum.h
-  STEPaggrGeneric.h
-  STEPaggrInt.h
-  STEPaggrReal.h
-  STEPaggrSelect.h
-  STEPaggrString.h
-  STEPattribute.h
-  STEPattributeList.h
-  STEPcomplex.h
-  STEPinvAttrList.h
-  STEPundefined.h
-  stringTypeDescriptor.h
-  SubSuperIterators.h
-  typeDescriptor.h
-  typeDescriptorList.h
-  typeOrRuleVar.h
-  uniquenessRule.h
-  whereRule.h
-)
-
-install(FILES ${CORE_HDRS}
-  DESTINATION ${INCLUDE_DIR}/stepcode/clstepcore)
-
-# Local Variables:
-# tab-width: 8
-# mode: cmake
-# indent-tabs-mode: t
-# End:
-# ex: shiftwidth=2 tabstop=8
-

include/clutils/CMakeLists.txt

@@ -1,20 +0,0 @@
-set(UTILS_HDRS
-  dirobj.h
-  errordesc.h
-  gennodearray.h
-  gennode.h
-  gennodelist.h
-  sc_hash.h
-  Str.h
-  )
-
-install(FILES ${UTILS_HDRS}
-  DESTINATION ${INCLUDE_DIR}/stepcode/clutils)
-
-# Local Variables:
-# tab-width: 8
-# mode: cmake
-# indent-tabs-mode: t
-# End:
-# ex: shiftwidth=2 tabstop=8
-

include/express/object.h

@@ -68,7 +68,7 @@
 /***************************/
 
 struct Object {
-    struct Symbol_ * ( *get_symbol )( void * );
+    struct Symbol_ * ( *get_symbol )();
     char * type; /**< should complete the phrase "X is ..." - i.e., "an entity", "a type", "of unknown type" */
     int bits;   /**< a bitwise selector of a type, i.e. OBJ_XX_BITS */
 };

misc/header_mv.sh

@@ -1,10 +0,0 @@
-#!/bin/bash
-find . -type f -path "*/cl*" -not -path "*.git/*" -not -path "*/exp*" -regex '.*\(c\|cc\|cpp\|cxx\|h\|hpp\)$' -exec perl -0777 -pi -e "s/include \"$1\"/include \"utils\/$1\"/g" {} \;
-find . -type f -path "*/cl*" -not -path "*.git/*" -not -path "*/exp*" -regex '.*\(c\|cc\|cpp\|cxx\|h\|hpp\)$' -exec perl -0777 -pi -e "s/include <$1>/include \"utils\/$1\"/g" {} \;
-
-find . -type f -path "*/include*" -not -path "*.git/*" -regex '.*\(c\|cc\|cpp\|cxx\|h\|hpp\)$' -exec perl -0777 -pi -e "s/include \"$1\"/include \"utils\/$1\"/g" {} \;
-find . -type f -path "*/include*" -not -path "*.git/*" -regex '.*\(c\|cc\|cpp\|cxx\|h\|hpp\)$' -exec perl -0777 -pi -e "s/include <$1>/include \"utils\/$1\"/g" {} \;
-
-find . -type f -path "*/test*" -not -path "*.git/*" -regex '.*\(c\|cc\|cpp\|cxx\|h\|hpp\)$' -exec perl -0777 -pi -e "s/include \"$1\"/include \"utils\/$1\"/g" {} \;
-find . -type f -path "*/test*" -not -path "*.git/*" -regex '.*\(c\|cc\|cpp\|cxx\|h\|hpp\)$' -exec perl -0777 -pi -e "s/include <$1>/include \"utils\/$1\"/g" {} \;
-

src/cldai/CMakeLists.txt

@@ -1,4 +1,5 @@
-set(DAI_SRCS
+
+set(LIBSTEPDAI_SRCS
   sdaiApplication_instance_set.cc
   sdaiBinary.cc
   sdaiDaObject.cc
@@ -12,24 +13,42 @@ set(DAI_SRCS
   sdaiString.cc
   )
 
+SET(SC_CLDAI_HDRS
+  sdaiApplication_instance_set.h
+  sdaiBinary.h
+  sdaiDaObject.h
+  sdaiEntity_extent.h
+  sdaiEntity_extent_set.h
+  sdaiEnum.h
+  sdaiModel_contents.h
+  sdaiModel_contents_list.h
+  sdaiObject.h
+  sdaiSession_instance.h
+  sdaiString.h
+  )
+
 include_directories(
   ${CMAKE_CURRENT_SOURCE_DIR}
-  ${CMAKE_SOURCE_DIR}/include/stepcode
+  ${SC_SOURCE_DIR}/src/clstepcore
+  ${SC_SOURCE_DIR}/src/clutils
   )
 
 set(_libdeps steputils)
 
 if(BUILD_SHARED_LIBS)
-  SC_ADDLIB(stepdai SHARED SOURCES ${DAI_SRCS} LINK_LIBRARIES ${_libdeps})
+  SC_ADDLIB(stepdai SHARED SOURCES ${LIBSTEPDAI_SRCS} LINK_LIBRARIES ${_libdeps})
   if(WIN32)
     target_compile_definitions(stepdai PRIVATE SC_DAI_DLL_EXPORTS)
   endif()
 endif()
 
 if(BUILD_STATIC_LIBS)
-  SC_ADDLIB(stepdai-static STATIC SOURCES ${DAI_SRCS} LINK_LIBRARIES $<JOIN:${_libdeps},-static >-static)
+  SC_ADDLIB(stepdai-static STATIC SOURCES ${LIBSTEPDAI_SRCS} LINK_LIBRARIES $<JOIN:${_libdeps},-static >-static)
 endif()
 
+install(FILES ${SC_CLDAI_HDRS}
+  DESTINATION ${INCLUDE_DIR}/stepcode/cldai)
+
 # Local Variables:
 # tab-width: 8
 # mode: cmake

src/cldai/sdaiApplication_instance_set.cc

@@ -24,13 +24,13 @@
  * UArray implementation.
  */
 
-//#include "cldai/sdaiApplication_instance_set.h"
-#include "clstepcore/sdai.h"
+//#include <sdaiApplication_instance_set.h>
+#include <sdai.h>
 
 #include <memory.h>
 #include <math.h>
 
-#include "clstepcore/sdaiApplication_instance.h"
+#include "sdaiApplication_instance.h"
 
 // to help ObjectCenter
 #ifndef HAVE_MEMMOVE

src/cldai/sdaiBinary.cc

@@ -10,7 +10,7 @@
 */
 
 #include <sstream>
-#include "clstepcore/sdai.h"
+#include <sdai.h>
 
 SDAI_Binary::SDAI_Binary( const char * str, int max ) {
     content = std::string( str, max );

src/cldai/sdaiDaObject.cc

@@ -2,7 +2,7 @@
 #include <memory.h>
 #include <math.h>
 
-#include "clstepcore/sdai.h"
+#include <sdai.h>
 
 // to help ObjectCenter
 #ifndef HAVE_MEMMOVE

src/cldai/sdaiDaObject.h

@@ -1,9 +1,9 @@
 #ifndef SDAIDAOBJECT_H
 #define SDAIDAOBJECT_H 1
 
-#include "cldai/sdaiObject.h"
-#include "cldai/sdaiString.h"
-#include "cldai/sdaiEnum.h"
+#include <sdaiObject.h>
+#include <sdaiString.h>
+#include <sdaiEnum.h>
 
 #include <sc_export.h>
 

src/cldai/sdaiEntity_extent.cc

@@ -2,7 +2,7 @@
 
 //#include <EntityExtent.h>
 
-#include "clstepcore/sdai.h"
+#include <sdai.h>
 
 SDAI_Entity_extent::SDAI_Entity_extent( )
     : _definition( 0 ), _definition_name( 0 ), _owned_by( 0 ) {

src/cldai/sdaiEntity_extent_set.cc

@@ -26,7 +26,7 @@
 #include <memory.h>
 #include <math.h>
 
-#include "clstepcore/sdai.h"
+#include <sdai.h>
 
 /*
 #include <EntityExtent.h>

src/cldai/sdaiEnum.cc

@@ -1,5 +1,5 @@
 
-#include "clstepcore/sdai.h"
+#include <sdai.h>
 
 /*
 * NIST STEP Core Class Library

src/cldai/sdaiModel_contents.cc

@@ -1,5 +1,5 @@
 
-#include "clstepcore/sdai.h"
+#include <sdai.h>
 
 /////////    SDAI_Model_contents_instances
 

src/cldai/sdaiModel_contents_list.cc

@@ -23,7 +23,7 @@
 /*
  * UArray implementation.
  */
-#include "clstepcore/sdai.h"
+#include <sdai.h>
 
 // to help ObjectCenter
 #ifndef HAVE_MEMMOVE

src/cldai/sdaiObject.cc

@@ -1,4 +1,4 @@
-#include "clstepcore/sdai.h"
+#include <sdai.h>
 
 SDAI_sdaiObject::SDAI_sdaiObject() {
 }

src/cldai/sdaiSession_instance.cc

@@ -1,4 +1,4 @@
-#include "clstepcore/sdai.h"
+#include <sdai.h>
 
 SDAI_Session_instance::SDAI_Session_instance() {
 }

src/cldai/sdaiSession_instance.h

@@ -3,7 +3,7 @@
 #define SESSION_INSTANCE_H 1
 
 #include <sc_export.h>
-//#include "clstepcore/sdai.h"
+//#include <sdai.h>
 
 class SC_DAI_EXPORT SDAI_Session_instance : public SDAI_sdaiObject {
 

src/cldai/sdaiString.cc

@@ -9,7 +9,7 @@
 * and is not subject to copyright.
 */
 
-#include "clstepcore/sdai.h"
+#include <sdai.h>
 #include <sstream>
 
 SDAI_String::SDAI_String( const char * str, size_t max ) {

src/cleditor/CMakeLists.txt

@@ -1,4 +1,5 @@
-set(EDITOR_SRCS
+
+set(LIBSTEPEDITOR_SRCS
   STEPfile.cc
   STEPfile.inline.cc
   cmdmgr.cc
@@ -8,22 +9,37 @@ set(EDITOR_SRCS
   SdaiSchemaInit.cc
   )
 
+SET(SC_CLEDITOR_HDRS
+  STEPfile.h
+  cmdmgr.h
+  editordefines.h
+  SdaiHeaderSchema.h
+  SdaiHeaderSchemaClasses.h
+  SdaiSchemaInit.h
+  seeinfodefault.h
+  )
+
 include_directories(
   ${CMAKE_CURRENT_SOURCE_DIR}
-  ${CMAKE_SOURCE_DIR}/include/stepcode
+  ${SC_SOURCE_DIR}/src/cldai
+  ${SC_SOURCE_DIR}/src/clstepcore
+  ${SC_SOURCE_DIR}/src/clutils
   )
 
 if(BUILD_SHARED_LIBS)
-  SC_ADDLIB(stepeditor SHARED SOURCES ${EDITOR_SRCS} LINK_LIBRARIES stepcore stepdai steputils)
+  SC_ADDLIB(stepeditor SHARED SOURCES ${LIBSTEPEDITOR_SRCS} LINK_LIBRARIES stepcore stepdai steputils)
   if(WIN32)
     target_compile_definitions(stepeditor PRIVATE SC_EDITOR_DLL_EXPORTS)
   endif()
 endif()
 
 if(BUILD_STATIC_LIBS)
-  SC_ADDLIB(stepeditor-static STATIC SOURCES ${EDITOR_SRCS} LINK_LIBRARIES stepcore-static stepdai-static steputils-static)
+  SC_ADDLIB(stepeditor-static STATIC SOURCES ${LIBSTEPEDITOR_SRCS} LINK_LIBRARIES stepcore-static stepdai-static steputils-static)
 endif()
 
+install(FILES ${SC_CLEDITOR_HDRS}
+  DESTINATION ${INCLUDE_DIR}/stepcode/cleditor)
+
 # Local Variables:
 # tab-width: 8
 # mode: cmake

src/cleditor/STEPfile.cc

@@ -24,15 +24,15 @@
 #include <algorithm>
 #include <vector>
 
-#include "cleditor/STEPfile.h"
-#include "clstepcore/sdai.h"
-#include "clstepcore/STEPcomplex.h"
-#include "clstepcore/STEPattribute.h"
-#include "cleditor/SdaiHeaderSchema.h"
+#include <STEPfile.h>
+#include <sdai.h>
+#include <STEPcomplex.h>
+#include <STEPattribute.h>
+#include <SdaiHeaderSchema.h>
 
 // STEPundefined contains
 // void PushPastString (istream& in, std::string &s, ErrorDescriptor *err)
-#include "clstepcore/STEPundefined.h"
+#include <STEPundefined.h>
 
 /**
  * \returns The new file name for the class.

src/cleditor/STEPfile.h

@@ -15,14 +15,14 @@
 
 #include <sc_export.h>
 #include <string>
-#include "clstepcore/instmgr.h"
-#include "clstepcore/Registry.h"
+#include <instmgr.h>
+#include <Registry.h>
 #include <fstream>
-#include "clutils/dirobj.h"
-#include "clutils/errordesc.h"
+#include <dirobj.h>
+#include <errordesc.h>
 #include <time.h>
 
-#include "clstepcore/read_func.h"
+#include <read_func.h>
 
 //error reporting level
 #define READ_COMPLETE    10

src/cleditor/STEPfile.inline.cc

@@ -11,9 +11,9 @@
 * and is not subject to copyright.
 */
 
-#include "cleditor/STEPfile.h"
-#include "cleditor/SdaiHeaderSchema.h"
-#include "clstepcore/STEPaggregate.h"
+#include <STEPfile.h>
+#include <SdaiHeaderSchema.h>
+#include <STEPaggregate.h>
 #include <cmath>
 
 #include <cstring>

src/cleditor/SdaiHeaderSchema.cc

@@ -10,9 +10,9 @@ extern ofstream * logStream;
 #define SCLLOGFILE "scl.log"
 #endif
 
-#include "clstepcore/ExpDict.h"
-#include "clstepcore/STEPattribute.h"
-#include "cleditor/SdaiHeaderSchema.h"
+#include <ExpDict.h>
+#include <STEPattribute.h>
+#include <SdaiHeaderSchema.h>
 
 Schema * s_header_section_schema = 0;
 

src/cleditor/SdaiHeaderSchema.h

@@ -5,11 +5,11 @@
 // regenerate it.
 
 #include <sc_export.h>
-#include "clstepcore/sdai.h"
-#include "clstepcore/Registry.h"
-#include "clstepcore/STEPaggregate.h"
-#include "cleditor/SdaiHeaderSchemaClasses.h"
-#include "cleditor/SdaiSchemaInit.h"
+#include <sdai.h>
+#include <Registry.h>
+#include <STEPaggregate.h>
+#include <SdaiHeaderSchemaClasses.h>
+#include <SdaiSchemaInit.h>
 
 /////////         ENTITY section_language
 

src/cleditor/SdaiHeaderSchemaAll.cc

@@ -4,7 +4,7 @@
 // it since your modifications will be lost if exp2cxx is used to
 // regenerate it.
 
-#include "cleditor/SdaiHeaderSchema.h"
+#include <SdaiHeaderSchema.h>
 
 void HeaderInitSchemasAndEnts( Registry & reg ) {
     Uniqueness_rule_ptr ur;

src/cleditor/SdaiHeaderSchemaInit.cc

@@ -4,10 +4,10 @@
 // it since your modifications will be lost if exp2cxx is used to
 // regenerate it.
 
-#include "clstepcore/Registry.h"
-#include "clstepcore/ExpDict.h"
-#include "clstepcore/STEPattribute.h"
-#include "cleditor/SdaiHeaderSchema.h"
+#include <Registry.h>
+#include <ExpDict.h>
+#include <STEPattribute.h>
+#include <SdaiHeaderSchema.h>
 
 void SdaiHEADER_SECTION_SCHEMAInit( Registry & reg ) {
     header_section_schemat_time_stamp_text->ReferentType( t_sdaiSTRING );

src/cleditor/SdaiSchemaInit.cc

@@ -4,7 +4,7 @@
 // it since your modifications will be lost if exp2cxx is used to
 // regenerate it.
 
-#include "cleditor/SdaiSchemaInit.h"
+#include <SdaiSchemaInit.h>
 
 void HeaderSchemaInit( Registry & reg ) {
     HeaderInitSchemasAndEnts( reg );

src/cleditor/SdaiSchemaInit.h

@@ -9,16 +9,16 @@
 #endif
 
 #include <sc_export.h>
-#include "clstepcore/sdai.h"
-#include "clstepcore/Registry.h"
-#include "clstepcore/STEPaggregate.h"
-#include "clstepcore/STEPundefined.h"
-#include "clstepcore/ExpDict.h"
-#include "clstepcore/STEPattribute.h"
-#include "clstepcore/complexSupport.h"
+#include <sdai.h>
+#include <Registry.h>
+#include <STEPaggregate.h>
+#include <STEPundefined.h>
+#include <ExpDict.h>
+#include <STEPattribute.h>
+#include <complexSupport.h>
 
-#include "cleditor/SdaiHeaderSchemaClasses.h"
-#include "cleditor/SdaiHeaderSchema.h"
+#include <SdaiHeaderSchemaClasses.h>
+#include <SdaiHeaderSchema.h>
 
 SC_EDITOR_EXPORT void HeaderSchemaInit( Registry & );
 SC_EDITOR_EXPORT void HeaderInitSchemasAndEnts( Registry & );

src/cleditor/cmdmgr.cc

@@ -10,7 +10,7 @@
 * and is not subject to copyright.
 */
 
-#include "cleditor/cmdmgr.h"
+#include <cmdmgr.h>
 
 ReplicateLinkNode * ReplicateList::FindNode( MgrNode * mn ) {
     ReplicateLinkNode * rln = ( ReplicateLinkNode * )GetHead();

src/cleditor/cmdmgr.h

@@ -13,16 +13,16 @@
 */
 
 #include <sc_export.h>
-#include "clutils/gennode.h"
-#include "clutils/gennodelist.h"
-#include "clutils/gennodearray.h"
+#include <gennode.h>
+#include <gennodelist.h>
+#include <gennodearray.h>
 
-#include "cleditor/editordefines.h"
-#include "clstepcore/mgrnode.h"
-#include "clstepcore/mgrnodelist.h"
-#include "clstepcore/dispnode.h"
-#include "clstepcore/dispnodelist.h"
-#include "clstepcore/SingleLinkList.h"
+#include <editordefines.h>
+#include <mgrnode.h>
+#include <mgrnodelist.h>
+#include <dispnode.h>
+#include <dispnodelist.h>
+#include <SingleLinkList.h>
 
 //#define NUM_CMDMGR_CMDS 9
 // this is the number of columns that contain cmds (as opposed

src/cleditor/seeinfodefault.h

@@ -20,10 +20,10 @@
 class MgrNode;
 class DisplayNode;
 class DisplayNodelist;
-#include "clstepcore/sdai.h"
+#include <sdai.h>
 //class SDAI_Application_instance;
 
-#include "cleditor/editordefines.h"
+#include <editordefines.h>
 
 class SC_EDITOR_EXPORT seeInfo : public DisplayNode {
     public:

src/cllazyfile/CMakeLists.txt

@@ -1,22 +1,45 @@
-set(LAZY_SRCS
+
+set( clLazyFile_SRCS
   lazyDataSectionReader.cc
   lazyFileReader.cc
   lazyInstMgr.cc
   p21HeaderSectionReader.cc
   sectionReader.cc
   lazyP21DataSectionReader.cc
-  judy.c
+  judy/src/judy.c
+  )
+
+set( SC_CLLAZYFILE_HDRS
+  headerSectionReader.h
+  lazyFileReader.h
+  lazyP21DataSectionReader.h
+  p21HeaderSectionReader.h
+  lazyDataSectionReader.h
+  lazyInstMgr.h
+  lazyTypes.h
+  sectionReader.h
+  sectionReader.h
+  instMgrHelper.h
+  judy/src/judy.h
+  judy/src/judyLArray.h
+  judy/src/judyL2Array.h
+  judy/src/judySArray.h
+  judy/src/judyS2Array.h
   )
 
 include_directories(
   ${CMAKE_CURRENT_SOURCE_DIR}
-  ${CMAKE_SOURCE_DIR}/include/stepcode
+  ${SC_SOURCE_DIR}/src/cleditor
+  ${SC_SOURCE_DIR}/src/cldai
+  ${SC_SOURCE_DIR}/src/clstepcore
+  ${SC_SOURCE_DIR}/src/clutils
+  ${CMAKE_CURRENT_SOURCE_DIR}/judy/src
   )
 
 set(_libdeps stepcore stepdai steputils stepeditor)
 
 if(BUILD_SHARED_LIBS)
-  SC_ADDLIB(steplazyfile SHARED SOURCES ${LAZY_SRCS} LINK_LIBRARIES ${_libdeps})
+  SC_ADDLIB(steplazyfile SHARED SOURCES ${clLazyFile_SRCS} LINK_LIBRARIES ${_libdeps})
   if(WIN32)
     target_compile_definitions(steplazyfile PRIVATE SC_LAZYFILE_DLL_EXPORTS)
   endif()
@@ -24,12 +47,15 @@ endif()
 
 if(BUILD_STATIC_LIBS)
   set(_libdeps stepcore-static stepdai-static steputils-static stepeditor-static)
-  SC_ADDLIB(steplazyfile-static STATIC SOURCES ${LAZY_SRCS} LINK_LIBRARIES ${_libdeps})
+  SC_ADDLIB(steplazyfile-static STATIC SOURCES ${clLazyFile_SRCS} LINK_LIBRARIES ${_libdeps})
 endif()
 
 SC_ADDEXEC(lazy_test SOURCES "lazy_test.cc;sc_benchmark.cc" LINK_LIBRARIES steplazyfile stepeditor NO_INSTALL)
 target_compile_definitions(lazy_test PRIVATE NO_REGISTRY)
 
+install(FILES ${SC_CLLAZYFILE_HDRS}
+  DESTINATION ${INCLUDE_DIR}/stepcode/cllazyfile)
+
 # Local Variables:
 # tab-width: 8
 # mode: cmake

src/cllazyfile/headerSectionReader.h

@@ -5,9 +5,9 @@
 #include <fstream>
 
 #include "judyL2Array.h"
-#include "cllazyfile/lazyFileReader.h"
-#include "cllazyfile/sectionReader.h"
-#include "cllazyfile/lazyTypes.h"
+#include "lazyFileReader.h"
+#include "sectionReader.h"
+#include "lazyTypes.h"
 
 #include "sc_export.h"
 

src/cllazyfile/instMgrHelper.h

@@ -3,9 +3,9 @@
 
 #include <sc_export.h>
 
-#include "clstepcore/mgrnode.h"
-#include "cllazyfile/lazyInstMgr.h"
-#include "clstepcore/instmgr.h"
+#include <mgrnode.h>
+#include <lazyInstMgr.h>
+#include <instmgr.h>
 
 /**
  * \file instMgrHelper.h helper classes for the lazyInstMgr. Allows use of SDAI_Application_instance class

src/cllazyfile/judy/CMakeLists.txt

@@ -0,0 +1,78 @@
+
+cmake_minimum_required(VERSION 3.12)
+project( JudyTemplates )
+
+if( NOT DEFINED CMAKE_BUILD_TYPE )
+  # set( CMAKE_BUILD_TYPE "RelWithDebInfo" ) #optimize, but include debug info
+  set( CMAKE_BUILD_TYPE "Release" )
+endif( NOT DEFINED CMAKE_BUILD_TYPE )
+
+SET(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib )
+SET(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib )
+SET(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin )
+
+if( NOT DEFINED JUDY_OPTIMIZE_FLAGS )
+  if( CMAKE_COMPILER_IS_GNUCC )
+    set( JUDY_OPTIMIZE_FLAGS "-march=native" )
+
+    #test for LTO; this uses an internal variable so it may break
+    if( DEFINED CMAKE_C_COMPILER_VERSION )
+      if( ${CMAKE_C_COMPILER_VERSION} VERSION_GREATER 4.7.0 )
+	set( JUDY_OPTIMIZE_FLAGS "${JUDY_OPTIMIZE_FLAGS} -flto" )
+	message( "  --  GCC version: ${CMAKE_C_COMPILER_VERSION}. Enabling link-time optimization." )
+      endif( ${CMAKE_C_COMPILER_VERSION} VERSION_GREATER 4.7.0 )
+    endif( DEFINED CMAKE_C_COMPILER_VERSION )
+    #elseif( MSVC )
+    #  set( JUDY_OPTIMIZE_FLAGS "..." ) # <--- set MSVC flags here <---
+  else()
+    message( "Unrecognized compiler - no optimization flags set. Edit CMakeLists.txt or set JUDY_OPTIMIZE_FLAGS." )
+    set( JUDY_OPTIMIZE_FLAGS "" )
+  endif( CMAKE_COMPILER_IS_GNUCC )
+endif( NOT DEFINED JUDY_OPTIMIZE_FLAGS )
+add_definitions( ${JUDY_OPTIMIZE_FLAGS} )
+
+set( JUDYS_SOURCES src/judy.c src/judy.h )
+
+if( CMAKE_COMPILER_IS_GNUCC )
+  add_definitions( -pedantic -W -Wall -Wundef -Wfloat-equal -Wshadow -Winline -Wno-long-long )
+endif( CMAKE_COMPILER_IS_GNUCC )
+
+add_library( judy_lib STATIC ${JUDYS_SOURCES} )
+
+include_directories( src )
+
+if( ENABLE_TESTING )
+  include( CTest )
+  include_directories( test )
+  enable_testing()
+
+  add_executable( pennysort test/pennySort.c test/sort.c ${JUDYS_SOURCES} )
+  add_executable( hexsort test/hexSort.c test/sort.c ${JUDYS_SOURCES} )
+  set_target_properties( pennysort hexsort PROPERTIES COMPILE_FLAGS "-DSTANDALONE" )
+
+
+  add_executable( judyLtest test/judyLtest.cc )
+  target_link_libraries( judyLtest judy_lib )
+  add_test( judyLtest judyLtest )
+
+  add_executable( judyL2test test/judyL2test.cc )
+  target_link_libraries( judyL2test judy_lib )
+  add_test( judyL2test judyL2test )
+
+  add_executable( judyStest test/judyStest.cc )
+  target_link_libraries( judyStest judy_lib )
+  add_test( judyStest judyStest )
+
+  add_executable( judyS2test test/judyS2test.cc )
+  target_link_libraries( judyS2test judy_lib )
+  add_test( judyS2test judyS2test )
+
+endif( ENABLE_TESTING )
+
+# Local Variables:
+# tab-width: 8
+# mode: cmake
+# indent-tabs-mode: t
+# End:
+# ex: shiftwidth=2 tabstop=8
+

src/cllazyfile/judy/README.md

@@ -0,0 +1,43 @@
+# Judy Array Templates
+The Judy Array is a sparse dynamic array. It is a particular kind of trie that is highly efficient in space and time, and does not require tuning.
+
+This uses [Karl Malbrain's implementation](http://code.google.com/p/judyarray/) of the Judy Array. Additional information can be found with Doug Baskins' [original implementation](http://judy.sourceforge.net/) on sourceforge, or on [Wikipedia](http://en.wikipedia.org/wiki/Judy_array).
+## The templates
+* `judyLArray` - a C++ template wrapper for an int-int Judy Array. JudyKey and JudyValue must be integer types and the same size as a pointer (i.e. 32- or 64-bit)
+* `judySArray` - Same as judyLArray, but with string-int mapping. The above restrictions on JudyValue apply here as well.
+* **TODO** - single-key, multi-value versions of the above
+* **TODO** - single-key, n-value versions of the above *(?)*
+
+## Comparison between this and the versions Karl and Doug wrote
+* Doug Baskins' code is licenced under the LGPL. While more permissive than the GPL, it's still not always acceptable. His code is very fast but weighs in at ~20k lines.
+* Karl Malbrain's code is ~1250 lines, in a single file containing the judy array and the test code; use requires creating a header.
+* Both of the above are written in C, so they don't fit neatly into object-oriented C++.
+* Unlike Doug's code, this is ~1250 lines. Unlike Karl's, this is split into several files.
+
+## Files
+* `CMakeLists.txt` - CMake build logic. If you don't have CMake, it should be quite easy to write a file for the build system of your choice.
+* **src/**
+ * `judy.c`, `judy.h` - implementation of the Judy Array
+ * `judyLArray.h` - the judyLArray template
+ * `judySArray.h` - the judySArray template
+* **test/**
+ * `hexSort.c` - Sorts a file where each line contains 32 hex chars. Compiles to `hexsort`, which is the same executable as compiling Karl's code with `-DHEXSORT -DSTANDALONE`
+ * `pennySort.c` - Sorts strings; compiles to `pennysort`. Same as compiling Karl's code with `-DSTANDALONE`.
+ * `sort.c`, `sort.h` - Karl's sorting functions. Only used by `hexsort` and `pennysort`.
+ * `judyLtest.cc` - an incomplete test of the judyLArray template.
+ * `judyStest.cc` - an incomplete test of the judySArray template.
+
+
+## Compiling
+* requires C and C++ compilers, CMake.
+* from the command line:
+ *  `mkdir build; cd build`
+ *  `cmake .. -DENABLE_TESTING=TRUE`
+ *  `make`
+
+## License
+
+Karl Malbrain's judy array code is public domain; what I've added is public domain as well.
+
+## Contact
+mpictor -a-t- gmail

src/cllazyfile/judy/misc/astyle.cfg

@@ -0,0 +1,29 @@
+#astyle config file
+
+#run astyle on one or a few files: use
+# astyle --options=misc/astyle.cfg path/to/file
+
+#run astyle on all files: from the root dir, use
+# astyle --options=misc/astyle.cfg --recursive "src/*.c" "src/*.h" "test/*.c" "test/*.h"
+# in the above line, the double quotes *are* necessary
+
+
+suffix=none   #don't create backup files
+
+style=java    #compact bracket style
+
+indent=spaces=4
+
+indent-preprocessor
+indent-classes
+indent-switches
+indent-namespaces
+pad-oper                #pad (space) around operators
+pad-paren-in            #pad inside parenthesis
+unpad-paren             #remove parenthesis padding other than requested above
+
+add-brackets            #add brackets on one-line conditionals
+convert-tabs            #convert all tabs to spaces
+align-pointer=middle    #char * foo
+
+lineend=linux           #lines end with LF (linux), not CRLF (windows)

src/cllazyfile/judy/misc/hextest.sh

@@ -0,0 +1,8 @@
+#!/bin/sh
+
+#generates a file of hex keys and runs hexsort on it. No verification is done.
+#hex data comes from /dev/urandom, so it isn't all that random.
+
+hexdump -v -e '2/8 "%08x"' -e '"\n"' /dev/urandom |head -n 1000000 >ukeys
+#a.out [in-file] [out-file] [keysize] [recordlen] [keyoffset] [mergerecs]
+time bin/hexsort ukeys skeys

src/cllazyfile/judy/src/judy.c

@@ -60,7 +60,7 @@
 #  endif
 #endif
 
-#include "cllazyfile/judy.h"
+#include "judy.h"
 
 #include <string.h>
 #include <stdio.h>

src/cllazyfile/judy/test/hexSort.c

@@ -0,0 +1,124 @@
+//  Judy arrays 13 DEC 2012 (judy64n.c from http://code.google.com/p/judyarray/ )
+//  This code is public domain.
+
+//  Author Karl Malbrain, malbrain AT yahoo.com
+//  with assistance from Jan Weiss.
+//  modifications (and any bugs) by Mark Pictor, mpictor at gmail
+
+//  Simplified judy arrays for strings and integers
+//  Adapted from the ideas of Douglas Baskins of HP.
+
+//  Map a set of keys to corresponding memory cells (uints).
+//  Each cell must be set to a non-zero value by the caller.
+
+
+//  Integer mappings are denoted by calling judy_open with the
+//  Integer depth of the Judy Trie as the second argument.
+
+#ifndef STANDALONE
+#  error must define STANDALONE while compiling this file and judy64.c
+#endif
+
+#include "judy.h"
+#include "sort.h"
+
+unsigned int MaxMem = 0;
+/**
+   usage:
+   a.out [in-file] [out-file]
+   where all lines of in-file are 32 chars, hexadecimal
+   On linux, a 1M-line file can be created with the following:
+   hexdump -v -e '2/8 "%08x"' -e '"\n"' /dev/urandom |head -n 1000000 >in-file
+*/
+int main( int argc, char ** argv ) {
+    unsigned char buff[1024];
+    JudySlot max = 0;
+    JudySlot * cell;
+    FILE * in, *out;
+    void * judy;
+    unsigned int len;
+    unsigned int idx;
+
+    if( argc > 1 ) {
+        in = fopen( argv[1], "rb" );
+    } else {
+        in = stdin;
+    }
+
+    if( argc > 2 ) {
+        out = fopen( argv[2], "wb" );
+    } else {
+        out = stdout;
+    }
+
+    setvbuf( out, NULL, _IOFBF, 4096 * 1024 );
+
+    if( !in ) {
+        fprintf( stderr, "unable to open input file\n" );
+    }
+
+    if( !out ) {
+        fprintf( stderr, "unable to open output file\n" );
+    }
+
+    PennyMerge = ( unsigned long long )PennyLine * PennyRecs;
+
+    judy = judy_open( 1024, 16 / JUDY_key_size );
+
+    while( fgets( ( char * )buff, sizeof( buff ), in ) ) {
+        judyvalue key[16 / JUDY_key_size];
+        if( len = strlen( ( const char * )buff ) ) {
+            buff[--len] = 0;    // remove LF
+        }
+#if JUDY_key_size == 4
+        key[3] = strtoul( buff + 24, NULL, 16 );
+        buff[24] = 0;
+        key[2] = strtoul( buff + 16, NULL, 16 );
+        buff[16] = 0;
+        key[1] = strtoul( buff + 8, NULL, 16 );
+        buff[8] = 0;
+        key[0] = strtoul( buff, NULL, 16 );
+#else
+        key[1] = strtoull( buff + 16, NULL, 16 );
+        buff[16] = 0;
+        key[0] = strtoull( buff, NULL, 16 );
+#endif
+        *( judy_cell( judy, ( void * )key, 0 ) ) += 1;   // count instances of string
+        max++;
+    }
+
+    fprintf( stderr, "%" PRIuint " memory used\n", MaxMem );
+
+    cell = judy_strt( judy, NULL, 0 );
+
+    if( cell ) do {
+            judyvalue key[16 / JUDY_key_size];
+            len = judy_key( judy, ( void * )key, 0 );
+            for( idx = 0; idx < *cell; idx++ ) {       // spit out duplicates
+#if JUDY_key_size == 4
+                fprintf( out, "%.8X", key[0] );
+                fprintf( out, "%.8X", key[1] );
+                fprintf( out, "%.8X", key[2] );
+                fprintf( out, "%.8X", key[3] );
+#else
+                fprintf( out, "%.16llX", key[0] );
+                fprintf( out, "%.16llX", key[1] );
+#endif
+                fputc( '\n', out );
+            }
+        } while( cell = judy_nxt( judy ) );
+
+#if 0
+    // test deletion all the way to an empty tree
+
+    if( cell = judy_prv( judy ) )
+        do {
+            max -= *cell;
+        } while( cell = judy_del( judy ) );
+
+    assert( max == 0 );
+#endif
+    judy_close( judy );
+    return 0;
+}
+

src/cllazyfile/judy/test/judyL2test.cc

@@ -0,0 +1,72 @@
+#include <iostream>
+#include <stdint.h>
+#include <stdlib.h>
+
+#include "judyL2Array.h"
+typedef judyL2Array< uint64_t, uint64_t > jl2a;
+
+bool testFind( jl2a & j, uint64_t key, unsigned int count ) {
+    jl2a::cvector * v = j.find( key );
+    std::cout << "find: key " << key << " ..." << std::endl;
+    if( count > 0 ) {
+        if( !v || !j.success() || ( v->size() != count ) ) {
+            std::cout << "    false negative - v: " << v << " success: " << j.success();
+            if( v ) {
+                std::cout << "    expected count: " << count << " actual: " << v->size();
+            }
+            std::cout << std::endl;
+            return false;
+        } else {
+            // note - this doesn't verify that the right keys are returned, just the right number!
+            jl2a::vector::const_iterator it = v->begin();
+            std::cout << "    correct number of values -";
+            for( ; it != v->end(); it++ ) {
+                std::cout << " " << *it;
+            }
+            std::cout << std::endl;
+        }
+    } else {
+        if( v || j.success() ) {
+            std::cout << "    false positive - v: " << v << " success: " << j.success() << std::endl;
+            return false;
+        } else {
+            std::cout << "    not found, as expected." << std::endl;
+        }
+    }
+    return true;
+}
+
+int main() {
+    bool pass = true;
+    jl2a jl;
+    std::cout.setf( std::ios::boolalpha );
+//     std::cout << "size of judyL2Array: " << sizeof( jl ) << std::endl;
+    jl.insert( 5,  12 );
+    jl.insert( 6,  2 );
+    jl.insert( 7,  312 );
+    jl.insert( 11, 412 );
+    jl.insert( 7,  313 );
+    jl2a::cpair kv = jl.atOrAfter( 4 );
+    std::cout << "atOrAfter test ..." << std::endl;
+    if( kv.value != 0 && jl.success() ) {
+        std::cout << "    key " << kv.key << "    value " << kv.value->at( 0 ) << std::endl;
+    } else {
+        std::cout << "    failed" << std::endl;
+        pass = false;
+    }
+
+    pass &= testFind( jl, 8,  0 );
+    pass &= testFind( jl, 11, 1 );
+    pass &= testFind( jl, 7,  2 );
+
+    jl.clear();
+
+    //TODO test all of judyL2Array
+    if( pass ) {
+        std::cout << "All tests passed." << std::endl;
+        exit( EXIT_SUCCESS );
+    } else {
+        std::cout << "At least one test failed." << std::endl;
+        exit( EXIT_FAILURE );
+    }
+}

src/cllazyfile/judy/test/judyLtest.cc

@@ -0,0 +1,33 @@
+#include <iostream>
+#include <stdint.h>
+#include <stdlib.h>
+
+#include "judyLArray.h"
+
+int main() {
+    std::cout.setf( std::ios::boolalpha );
+    judyLArray< uint64_t, uint64_t > jl;
+    std::cout << "size of judyLArray: " << sizeof( jl ) << std::endl;
+    jl.insert( 5, 12 );
+    jl.insert( 6, 2 );
+    jl.insert( 7, 312 );
+    jl.insert( 8, 412 );
+    judyLArray< uint64_t, uint64_t >::pair kv = jl.atOrAfter( 4 );
+    std::cout << "k " << kv.key << " v " << kv.value << std::endl;
+
+    long v = jl.find( 11 );
+    if( v != 0 || jl.success() ) {
+        std::cout << "find: false positive - v: " << v << " success: " << jl.success() << std::endl;
+        exit( EXIT_FAILURE );
+    }
+    v = jl.find( 7 );
+    if( v != 312 || !jl.success() ) {
+        std::cout << "find: false negative - v: " << v << " success: " << jl.success() << std::endl;
+        exit( EXIT_FAILURE );
+    }
+
+    jl.clear();
+
+    //TODO test all of judyLArray
+    exit( EXIT_SUCCESS );
+}

src/cllazyfile/judy/test/judyS2test.cc

@@ -0,0 +1,75 @@
+#include <iostream>
+#include <stdint.h>
+#include <stdlib.h>
+
+#include "judyS2Array.h"
+
+typedef judyS2Array< uint64_t > js2a;
+
+bool testFind( js2a & j, const char * key, unsigned int count ) {
+    js2a::cvector * v = j.find( key );
+    std::cout << "find: key " << key << " ..." << std::endl;
+    if( count > 0 ) {
+        if( !v || !j.success() || ( v->size() != count ) ) {
+            std::cout << "    false negative - v: " << v << " success: " << j.success();
+            if( v ) {
+                std::cout << "    expected count: " << count << " actual: " << v->size();
+            }
+            std::cout << std::endl;
+            return false;
+        } else {
+            // note - this doesn't verify that the right keys are returned, just the right number!
+            js2a::vector::const_iterator it = v->begin();
+            std::cout << "    correct number of values -";
+            for( ; it != v->end(); it++ ) {
+                std::cout << " " << *it;
+            }
+            std::cout << std::endl;
+        }
+    } else {
+        if( v || j.success() ) {
+            std::cout << "    false positive - v: " << v << " success: " << j.success() << std::endl;
+            return false;
+        } else {
+            std::cout << "    not found, as expected." << std::endl;
+        }
+    }
+    return true;
+}
+
+int main() {
+    bool pass = true;
+    std::cout.setf( std::ios::boolalpha );
+
+    js2a js( 255 );
+    js.insert( "blah", 1234 );
+    js.insert( "bah",   124 );
+    js.insert( "blh",   123 );
+    js.insert( "blh",  4123 );
+    js.insert( "bla",   134 );
+    js.insert( "bh",    234 );
+
+    js2a::cpair kv = js.atOrAfter( "ab" );
+    std::cout << "atOrAfter test ..." << std::endl;
+    if( kv.value != 0 && js.success() ) {
+        std::cout << "    key " << kv.key << "    value " << kv.value->at( 0 ) << std::endl;
+    } else {
+        std::cout << "    failed" << std::endl;
+        pass = false;
+    }
+
+    pass &= testFind( js, "sdafsd",  0 );
+    pass &= testFind( js, "bah",  1 );
+    pass &= testFind( js, "blh",  2 );
+
+    js.clear();
+
+    //TODO test all of judyS2Array
+    if( pass ) {
+        std::cout << "All tests passed." << std::endl;
+        exit( EXIT_SUCCESS );
+    } else {
+        std::cout << "At least one test failed." << std::endl;
+        exit( EXIT_FAILURE );
+    }
+}

src/cllazyfile/judy/test/judyStest.cc

@@ -0,0 +1,43 @@
+#include <iostream>
+#include <stdint.h>
+#include <stdlib.h>
+
+#include "judySArray.h"
+
+int main() {
+    bool pass = true;
+    std::cout.setf( std::ios::boolalpha );
+
+    judySArray< uint64_t > js( 255 );
+    js.insert( "blah", 1234 );
+    js.insert( "bah",   124 );
+    js.insert( "blh",   123 );
+    js.insert( "bla",   134 );
+    js.insert( "bh",    234 );
+
+
+    judySArray< uint64_t >::pair kv = js.atOrAfter( "ab" );
+    //TODO if()...
+    std::cout << "k " << kv.key << " v " << kv.value << std::endl;
+
+    long v = js.find( "sdafsd" );
+    if( v != 0 || js.success() ) {
+        std::cout << "find: false positive - v: " << v << " success: " << js.success() << std::endl;
+        pass = false;
+    }
+    v = js.find( "bah" );
+    if( v != 124 || !js.success() ) {
+        std::cout << "find: false negative - v: " << v << " success: " << js.success() << std::endl;
+        pass = false;
+    }
+
+
+    //TODO test all of judySArray
+    if( pass ) {
+        std::cout << "All tests passed." << std::endl;
+        exit( EXIT_SUCCESS );
+    } else {
+        std::cout << "At least one test failed." << std::endl;
+        exit( EXIT_FAILURE );
+    }
+}

src/cllazyfile/judy/test/pennySort.c

@@ -0,0 +1,236 @@
+//  Judy arrays 13 DEC 2012 (judy64n.c from http://code.google.com/p/judyarray/ )
+//  This code is public domain.
+
+//  Author Karl Malbrain, malbrain AT yahoo.com
+//  with assistance from Jan Weiss.
+//  modifications (and any bugs) by Mark Pictor, mpictor at gmail
+
+//  Simplified judy arrays for strings and integers
+//  Adapted from the ideas of Douglas Baskins of HP.
+
+//  Map a set of keys to corresponding memory cells (uints).
+//  Each cell must be set to a non-zero value by the caller.
+
+//  STANDALONE is defined to compile into a string sorter.
+
+//  String mappings are denoted by calling judy_open with zero as
+//  the second argument.
+
+#ifndef STANDALONE
+#  error must define STANDALONE while compiling this file and judy64.c
+#endif
+
+#include "judy.h"
+#include "sort.h"
+
+unsigned int MaxMem = 0;
+
+//    usage:
+//    a.out [in-file] [out-file] [keysize] [recordlen] [keyoffset] [mergerecs]
+//    where keysize is 10 to indicate pennysort files
+
+//    ASKITIS compilation:
+//    g++ -O3 -fpermissive -fomit-frame-pointer -w -D STANDALONE -D ASKITIS -o judy64n judy64n.c
+//    ./judy64n [input-file-to-build-judy] e.g. distinct_1 or skew1_1
+
+//    note:  the judy array is an in-memory data structure. As such, make sure you
+//    have enough memory to hold the entire input file + data structure, otherwise
+//    you'll have to break the input file into smaller pieces and load them in
+//    on-by-one.
+
+//    Also, the file to search judy is hardcoded to skew1_1.
+
+int main( int argc, char ** argv ) {
+    unsigned char buff[1024];
+    JudySlot max = 0;
+    JudySlot * cell;
+    FILE * in, *out;
+    void * judy;
+    unsigned int len;
+    unsigned int idx;
+#ifdef ASKITIS
+    char * askitis;
+    int prev, off;
+    float insert_real_time = 0.0;
+    float search_real_time = 0.0;
+    int size;
+#if !defined(_WIN32)
+    timer start, stop;
+#else
+    time_t start[1], stop[1];
+#endif
+#endif
+
+    if( argc > 1 ) {
+        in = fopen( argv[1], "rb" );
+    } else {
+        in = stdin;
+    }
+
+    if( argc > 2 ) {
+        out = fopen( argv[2], "wb" );
+    } else {
+        out = stdout;
+    }
+
+    setvbuf( out, NULL, _IOFBF, 4096 * 1024 );
+
+    if( !in ) {
+        fprintf( stderr, "unable to open input file\n" );
+    }
+
+    if( !out ) {
+        fprintf( stderr, "unable to open output file\n" );
+    }
+
+    if( argc > 6 ) {
+        PennyRecs = atoi( argv[6] );
+    }
+
+    if( argc > 5 ) {
+        PennyOff = atoi( argv[5] );
+    }
+
+    if( argc > 4 ) {
+        PennyLine = atoi( argv[4] );
+    }
+
+    PennyMerge = ( unsigned long long )PennyLine * PennyRecs;
+
+    if( argc > 3 ) {
+        PennyKey = atoi( argv[3] );
+        sort( in, argv[2] );
+        return merge( out, argv[2] );
+    }
+
+#ifdef ASKITIS
+    judy = judy_open( 1024, 0 );
+
+//    build judy array
+    size = lseek( fileno( in ), 0L, 2 );
+    askitis = malloc( size );
+    lseek( fileno( in ), 0L, 0 );
+    read( fileno( in ), askitis, size );
+    prev = 0;
+//    naskitis.com:
+//    Start the timer.
+
+#if !defined(_WIN32)
+    gettimeofday( &start, NULL );
+#else
+    time( start );
+#endif
+
+    for( off = 0; off < size; off++ )
+        if( askitis[off] == '\n' ) {
+            *( judy_cell( judy, askitis + prev, off - prev ) ) += 1;   // count instances of string
+            prev = off + 1;
+        }
+//    naskitis.com:
+//    Stop the timer and do some math to compute the time required to insert the strings into the judy array.
+
+#if !defined(_WIN32)
+    gettimeofday( &stop, NULL );
+
+    insert_real_time = 1000.0 * ( stop.tv_sec - start.tv_sec ) + 0.001 * ( stop.tv_usec - start.tv_usec );
+    insert_real_time = insert_real_time / 1000.0;
+#else
+    time( stop );
+    insert_real_time = *stop - *start;
+#endif
+
+//    naskitis.com:
+//    Free the input buffer used to store the first file.  We must do this before we get the process size below.
+    free( askitis );
+    fprintf( stderr, "JudyArray@Karl_Malbrain\nDASKITIS option enabled\n-------------------------------\n%-20s %.2f MB\n%-20s %.2f sec\n",
+             "Judy Array size:", MaxMem / 1000000., "Time to insert:", insert_real_time );
+    fprintf( stderr, "%-20s %d\n", "Words:", Words );
+    fprintf( stderr, "%-20s %d\n", "Inserts:", Inserts );
+    fprintf( stderr, "%-20s %d\n", "Found:", Found );
+
+    Words = 0;
+    Inserts = 0;
+    Found = 0;
+
+//    search judy array
+    if( in = freopen( "skew1_1", "rb", in ) ) {
+        size = lseek( fileno( in ), 0L, 2 );
+    } else {
+        exit( 0 );
+    }
+    askitis = malloc( size );
+    lseek( fileno( in ), 0L, 0 );
+    read( fileno( in ), askitis, size );
+    prev = 0;
+
+#if !defined(_WIN32)
+    gettimeofday( &start, NULL );
+#else
+    time( start );
+#endif
+
+    for( off = 0; off < size; off++ )
+        if( askitis[off] == '\n' ) {
+            *judy_cell( judy, askitis + prev, off - prev ) += 1;
+            prev = off + 1;
+        }
+//    naskitis.com:
+//    Stop the timer and do some math to compute the time required to search the judy array.
+
+#if !defined(_WIN32)
+    gettimeofday( &stop, NULL );
+    search_real_time = 1000.0 * ( stop.tv_sec - start.tv_sec ) + 0.001
+                       * ( stop.tv_usec - start.tv_usec );
+    search_real_time = search_real_time / 1000.0;
+#else
+    time( stop );
+    search_real_time = *stop - *start;
+#endif
+
+//    naskitis.com:
+//    To do: report a count on the number of strings found.
+
+    fprintf( stderr, "\n%-20s %.2f MB\n%-20s %.2f sec\n",
+             "Judy Array size:", MaxMem / 1000000., "Time to search:", search_real_time );
+    fprintf( stderr, "%-20s %d\n", "Words:", Words );
+    fprintf( stderr, "%-20s %d\n", "Inserts:", Inserts );
+    fprintf( stderr, "%-20s %d\n", "Found:", Found );
+    exit( 0 );
+#endif
+
+    judy = judy_open( 1024, 0 );
+
+    while( fgets( ( char * )buff, sizeof( buff ), in ) ) {
+        if( len = strlen( ( const char * )buff ) ) {
+            buff[--len] = 0;    // remove LF
+        }
+        *( judy_cell( judy, buff, len ) ) += 1;     // count instances of string
+        max++;
+    }
+
+    fprintf( stderr, "%" PRIuint " memory used\n", MaxMem );
+
+    cell = judy_strt( judy, NULL, 0 );
+
+    if( cell ) do {
+            len = judy_key( judy, buff, sizeof( buff ) );
+            for( idx = 0; idx < *cell; idx++ ) {       // spit out duplicates
+                fwrite( buff, len, 1, out );
+                fputc( '\n', out );
+            }
+        } while( cell = judy_nxt( judy ) );
+
+#if 0
+    // test deletion all the way to an empty tree
+
+    if( cell = judy_prv( judy ) )
+        do {
+            max -= *cell;
+        } while( cell = judy_del( judy ) );
+
+    assert( max == 0 );
+#endif
+    judy_close( judy );
+    return 0;
+}
+

src/cllazyfile/judy/test/sort.c

@@ -0,0 +1,233 @@
+//  Judy arrays 13 DEC 2012 (judy64n.c from http://code.google.com/p/judyarray/ )
+//  This code is public domain.
+
+//  Author Karl Malbrain, malbrain AT yahoo.com
+//  with assistance from Jan Weiss.
+//  modifications (and any bugs) by Mark Pictor, mpictor at gmail
+
+//  Simplified judy arrays for strings and integers
+//  Adapted from the ideas of Douglas Baskins of HP.
+
+//  Map a set of keys to corresponding memory cells (uints).
+//  Each cell must be set to a non-zero value by the caller.
+
+//  STANDALONE is defined to compile into a string sorter.
+
+//  String mappings are denoted by calling judy_open with zero as
+//  the second argument.  Integer mappings are denoted by calling
+//  judy_open with the Integer depth of the Judy Trie as the second
+//  argument.
+
+#include "judy.h"
+#include "sort.h"
+
+//    memory map input file and sort
+
+//    define pennysort parameters
+unsigned int PennyRecs = ( 4096 * 400 );  // records to sort to temp files
+unsigned int PennyLine = 100;            // length of input record
+unsigned int PennyKey = 10;                // length of input key
+unsigned int PennyOff = 0;                // key offset in input record
+
+unsigned long long PennyMerge;    // PennyRecs * PennyLine = file map length
+unsigned int PennyPasses;                // number of intermediate files created
+unsigned int PennySortTime;                // cpu time to run sort
+unsigned int PennyMergeTime;            // cpu time to run merge
+
+void sort( FILE * infile, char * outname ) {
+    unsigned long long size, off, offset, part;
+    int ifd = fileno( infile );
+    char filename[512];
+    PennySort * line;
+    JudySlot * cell;
+    unsigned char * inbuff;
+    void * judy;
+    FILE * out;
+#if defined(_WIN32)
+    HANDLE hndl, fm;
+    DWORD hiword;
+    FILETIME dummy[1];
+    FILETIME user[1];
+#else
+    struct tms buff[1];
+#endif
+    time_t start = time( NULL );
+
+    if( PennyOff + PennyKey > PennyLine ) {
+        fprintf( stderr, "Key Offset + Key Length > Record Length\n" ), exit( 1 );
+    }
+
+    offset = 0;
+    PennyPasses = 0;
+
+#if defined(_WIN32)
+    hndl = ( HANDLE )_get_osfhandle( ifd );
+    size = GetFileSize( hndl, &hiword );
+    fm = CreateFileMapping( hndl, NULL, PAGE_READONLY, hiword, ( DWORD )size, NULL );
+    if( !fm ) {
+        fprintf( stderr, "CreateFileMapping error %d\n", GetLastError() ), exit( 1 );
+    }
+    size |= ( unsigned long long )hiword << 32;
+#else
+    size = lseek( ifd, 0L, 2 );
+#endif
+
+    while( offset < size ) {
+#if defined(_WIN32)
+        part = offset + PennyMerge > size ? size - offset : PennyMerge;
+        inbuff = MapViewOfFile( fm, FILE_MAP_READ, offset >> 32, offset, part );
+        if( !inbuff ) {
+            fprintf( stderr, "MapViewOfFile error %d\n", GetLastError() ), exit( 1 );
+        }
+#else
+        inbuff = mmap( NULL, PennyMerge, PROT_READ,  MAP_SHARED, ifd, offset );
+
+        if( inbuff == MAP_FAILED ) {
+            fprintf( stderr, "mmap error %d\n", errno ), exit( 1 );
+        }
+
+        if( madvise( inbuff, PennyMerge, MADV_WILLNEED | MADV_SEQUENTIAL ) < 0 ) {
+            fprintf( stderr, "madvise error %d\n", errno );
+        }
+#endif
+        judy = judy_open( PennyKey, 0 );
+
+        off = 0;
+
+        //    build judy array from mapped input chunk
+
+        while( offset + off < size && off < PennyMerge ) {
+            line = judy_data( judy, sizeof( PennySort ) );
+            cell = judy_cell( judy, inbuff + off + PennyOff, PennyKey );
+            line->next = *( void ** )cell;
+            line->buff = inbuff + off;
+
+            *( PennySort ** )cell = line;
+            off += PennyLine;
+        }
+
+        sprintf( filename, "%s.%d", outname, PennyPasses );
+        out = fopen( filename, "wb" );
+        setvbuf( out, NULL, _IOFBF, 4096 * 1024 );
+
+#ifndef _WIN32
+        if( madvise( inbuff, PennyMerge, MADV_WILLNEED | MADV_RANDOM ) < 0 ) {
+            fprintf( stderr, "madvise error %d\n", errno );
+        }
+#endif
+
+        //    write judy array in sorted order to temporary file
+
+        cell = judy_strt( judy, NULL, 0 );
+
+        if( cell ) do {
+                line = *( PennySort ** )cell;
+                do {
+                    fwrite( line->buff, PennyLine, 1, out );
+                } while( line = line->next );
+            } while( cell = judy_nxt( judy ) );
+
+#if defined(_WIN32)
+        UnmapViewOfFile( inbuff );
+#else
+        munmap( inbuff, PennyMerge );
+#endif
+        judy_close( judy );
+        offset += off;
+        fflush( out );
+        fclose( out );
+        PennyPasses++;
+    }
+    fprintf( stderr, "End Sort %llu secs", ( unsigned long long ) time( NULL ) - start );
+#if defined(_WIN32)
+    CloseHandle( fm );
+    GetProcessTimes( GetCurrentProcess(), dummy, dummy, dummy, user );
+    PennySortTime = *( unsigned long long * )user / 10000000;
+#else
+    times( buff );
+    PennySortTime = buff->tms_utime / 100;
+#endif
+    fprintf( stderr, " Cpu %d\n", PennySortTime );
+}
+
+int merge( FILE * out, char * outname ) {
+    time_t start = time( NULL );
+    char filename[512];
+    JudySlot * cell;
+    unsigned int nxt, idx;
+    unsigned char ** line;
+    unsigned int * next;
+    void * judy;
+    FILE ** in;
+
+    next = calloc( PennyPasses + 1, sizeof( unsigned int ) );
+    line = calloc( PennyPasses, sizeof( void * ) );
+    in = calloc( PennyPasses, sizeof( void * ) );
+
+    judy = judy_open( PennyKey, 0 );
+
+    // initialize merge with one record from each temp file
+
+    for( idx = 0; idx < PennyPasses; idx++ ) {
+        sprintf( filename, "%s.%d", outname, idx );
+        in[idx] = fopen( filename, "rb" );
+        line[idx] = malloc( PennyLine );
+        setvbuf( in[idx], NULL, _IOFBF, 4096 * 1024 );
+        fread( line[idx], PennyLine, 1, in[idx] );
+        cell = judy_cell( judy, line[idx] + PennyOff, PennyKey );
+        next[idx + 1] = *( unsigned int * )cell;
+        *cell = idx + 1;
+    }
+
+    //    output records, replacing smallest each time
+
+    while( cell = judy_strt( judy, NULL, 0 ) ) {
+        nxt = *( unsigned int * )cell;
+        judy_del( judy );
+
+        // process duplicates
+
+        while( idx = nxt ) {
+            nxt = next[idx--];
+            fwrite( line[idx], PennyLine, 1, out );
+
+            if( fread( line[idx], PennyLine, 1, in[idx] ) ) {
+                cell = judy_cell( judy, line[idx] + PennyOff, PennyKey );
+                next[idx + 1] = *( unsigned int * )cell;
+                *cell = idx + 1;
+            } else {
+                next[idx + 1] = 0;
+            }
+        }
+    }
+
+    for( idx = 0; idx < PennyPasses; idx++ ) {
+        fclose( in[idx] );
+        free( line[idx] );
+    }
+
+    free( line );
+    free( next );
+    free( in );
+
+    fprintf( stderr, "End Merge %llu secs", ( unsigned long long ) time( NULL ) - start );
+#ifdef _WIN32
+    {
+        FILETIME dummy[1];
+        FILETIME user[1];
+        GetProcessTimes( GetCurrentProcess(), dummy, dummy, dummy, user );
+        PennyMergeTime = *( unsigned long long * )user / 10000000;
+    }
+#else
+    {
+        struct tms buff[1];
+        times( buff );
+        PennyMergeTime = buff->tms_utime / 100;
+    }
+#endif
+    fprintf( stderr, " Cpu %d\n", PennyMergeTime - PennySortTime );
+    judy_close( judy );
+    fflush( out );
+    fclose( out );
+    return 0;
+}

src/cllazyfile/judy/test/sort.h

@@ -0,0 +1,58 @@
+#ifndef SORT_H
+#define SORT_H
+
+//  Judy arrays 13 DEC 2012 (judy64n.c from http://code.google.com/p/judyarray/ )
+//  This code is public domain.
+
+//  Author Karl Malbrain, malbrain AT yahoo.com
+//  with assistance from Jan Weiss.
+//  modifications (and any bugs) by Mark Pictor, mpictor at gmail
+
+//  Simplified judy arrays for strings and integers
+//  Adapted from the ideas of Douglas Baskins of HP.
+
+//  Map a set of keys to corresponding memory cells (uints).
+//  Each cell must be set to a non-zero value by the caller.
+
+//  STANDALONE is defined to compile into a string sorter.
+
+//  String mappings are denoted by calling judy_open with zero as
+//  the second argument.  Integer mappings are denoted by calling
+//  judy_open with the Integer depth of the Judy Trie as the second
+//  argument.
+
+#include <string.h>
+#include <stdlib.h>
+#include <assert.h>
+#include <stdio.h>
+#include "judy.h"
+
+#ifdef linux
+#  include <fcntl.h>
+#  include <unistd.h>
+#  include <errno.h>
+#  include <sys/mman.h>
+#  include <sys/times.h>
+#else
+#  include <windows.h>
+#  include <io.h>
+#endif
+
+#include <time.h>
+
+#define PRIuint "u"
+
+
+//these are initialized in penny.c
+extern unsigned int PennyRecs;
+extern unsigned int PennyLine;
+extern unsigned int PennyKey;
+extern unsigned int PennyOff;
+extern unsigned long long PennyMerge;
+
+typedef struct {
+    void * buff;       // record pointer in input file map
+    void * next;       // duplicate chain
+} PennySort;
+
+#endif //SORT_H

src/cllazyfile/lazyDataSectionReader.cc

@@ -1,6 +1,6 @@
-#include "cllazyfile/lazyDataSectionReader.h"
-#include "cllazyfile/lazyFileReader.h"
-#include "cllazyfile/lazyInstMgr.h"
+#include "lazyDataSectionReader.h"
+#include "lazyFileReader.h"
+#include "lazyInstMgr.h"
 #include <iostream>
 
 lazyDataSectionReader::lazyDataSectionReader( lazyFileReader * parent, std::ifstream & file,

src/cllazyfile/lazyDataSectionReader.h

@@ -3,8 +3,8 @@
 
 #include <map>
 #include <iostream>
-#include "cllazyfile/sectionReader.h"
-#include "cllazyfile/lazyTypes.h"
+#include "sectionReader.h"
+#include "lazyTypes.h"
 
 #include "sc_export.h"
 

src/cllazyfile/lazyFileReader.cc

@@ -1,10 +1,10 @@
 #include <assert.h>
 
 
-#include "cllazyfile/lazyFileReader.h"
-#include "cllazyfile/lazyDataSectionReader.h"
-#include "cllazyfile/headerSectionReader.h"
-#include "cllazyfile/lazyInstMgr.h"
+#include "lazyFileReader.h"
+#include "lazyDataSectionReader.h"
+#include "headerSectionReader.h"
+#include "lazyInstMgr.h"
 
 void lazyFileReader::initP21() {
     _header = new p21HeaderSectionReader( this, _file, 0, -1 );

src/cllazyfile/lazyFileReader.h

@@ -8,9 +8,9 @@
 #include "sc_export.h"
 
 // PART 21
-#include "cllazyfile/lazyP21DataSectionReader.h"
-#include "cllazyfile/p21HeaderSectionReader.h"
-#include "cllazyfile/headerSectionReader.h"
+#include "lazyP21DataSectionReader.h"
+#include "p21HeaderSectionReader.h"
+#include "headerSectionReader.h"
 
 /* // PART 28
  * #include "lazyP28DataSectionReader.h"

src/cllazyfile/lazyInstMgr.cc

@@ -1,12 +1,12 @@
-#include "cllazyfile/lazyTypes.h"
-#include "cllazyfile/lazyInstMgr.h"
-#include "clstepcore/Registry.h"
-#include "clstepcore/SubSuperIterators.h"
-#include "cleditor/SdaiSchemaInit.h"
-#include "cllazyfile/instMgrHelper.h"
+#include "lazyTypes.h"
+#include "lazyInstMgr.h"
+#include "Registry.h"
+#include <SubSuperIterators.h>
+#include "SdaiSchemaInit.h"
+#include "instMgrHelper.h"
 #include "lazyRefs.h"
 
-#include "clstepcore/sdaiApplication_instance.h"
+#include "sdaiApplication_instance.h"
 
 lazyInstMgr::lazyInstMgr() {
     _headerRegistry = new Registry( HeaderSchemaInit );

src/cllazyfile/lazyInstMgr.h

@@ -5,11 +5,11 @@
 #include <string>
 #include <assert.h>
 
-#include "cllazyfile/lazyDataSectionReader.h"
-#include "cllazyfile/lazyFileReader.h"
-#include "cllazyfile/lazyTypes.h"
+#include "lazyDataSectionReader.h"
+#include "lazyFileReader.h"
+#include "lazyTypes.h"
 
-#include "clstepcore/Registry.h"
+#include "Registry.h"
 #include "sc_export.h"
 
 #include "judyLArray.h"

src/cllazyfile/lazyP21DataSectionReader.cc

@@ -1,7 +1,7 @@
 #include <assert.h>
 #include <set>
-#include "cllazyfile/lazyP21DataSectionReader.h"
-#include "cllazyfile/lazyInstMgr.h"
+#include "lazyP21DataSectionReader.h"
+#include "lazyInstMgr.h"
 
 lazyP21DataSectionReader::lazyP21DataSectionReader( lazyFileReader * parent, std::ifstream & file,
         std::streampos start, sectionID sid ):

src/cllazyfile/lazyP21DataSectionReader.h

@@ -1,8 +1,8 @@
 #ifndef LAZYP21DATASECTIONREADER_H
 #define LAZYP21DATASECTIONREADER_H
 
-#include "cllazyfile/lazyDataSectionReader.h"
-#include "cllazyfile/lazyFileReader.h"
+#include "lazyDataSectionReader.h"
+#include "lazyFileReader.h"
 #include "sc_export.h"
 
 class SC_LAZYFILE_EXPORT lazyP21DataSectionReader: public lazyDataSectionReader {

src/cllazyfile/lazyRefs.h

@@ -7,12 +7,12 @@
 #include <vector>
 
 #include "sc_export.h"
-#include "cllazyfile/lazyTypes.h"
-#include "cllazyfile/lazyInstMgr.h"
-#include "clstepcore/ExpDict.h"
-#include "clstepcore/SubSuperIterators.h"
-#include "clstepcore/STEPattribute.h"
-#include "clstepcore/STEPaggregate.h"
+#include "lazyTypes.h"
+#include "lazyInstMgr.h"
+#include "ExpDict.h"
+#include "SubSuperIterators.h"
+#include <STEPattribute.h>
+#include <STEPaggregate.h>
 
 #ifdef _WIN32
 #define strcasecmp _strcmpi

src/cllazyfile/lazy_test.cc

@@ -1,6 +1,6 @@
-#include "cllazyfile/lazyInstMgr.h"
+#include "lazyInstMgr.h"
 #include "./sc_benchmark.h"
-#include "cleditor/SdaiSchemaInit.h"
+#include "SdaiSchemaInit.h"
 #include "config.h"
 
 #ifndef NO_REGISTRY

src/cllazyfile/p21HeaderSectionReader.cc

@@ -1,11 +1,11 @@
 #include <assert.h>
 #include <string.h>
 
-#include "cllazyfile/p21HeaderSectionReader.h"
-#include "cllazyfile/headerSectionReader.h"
-#include "cllazyfile/sectionReader.h"
-#include "cllazyfile/lazyInstMgr.h"
-#include "cllazyfile/judyL2Array.h"
+#include "p21HeaderSectionReader.h"
+#include "headerSectionReader.h"
+#include "sectionReader.h"
+#include "lazyInstMgr.h"
+#include "judyL2Array.h"
 
 
 void p21HeaderSectionReader::findSectionStart() {

src/cllazyfile/p21HeaderSectionReader.h

@@ -1,7 +1,7 @@
 #ifndef P21HEADERSECTIONREADER_H
 #define P21HEADERSECTIONREADER_H
 
-#include "cllazyfile/headerSectionReader.h"
+#include "headerSectionReader.h"
 #include "sc_export.h"
 
 class SC_LAZYFILE_EXPORT p21HeaderSectionReader: public headerSectionReader {

src/cllazyfile/sectionReader.cc

@@ -12,16 +12,16 @@
 #  define ULLONG_MAX _UI64_MAX
 #endif
 
-#include "clstepcore/Registry.h"
-#include "clstepcore/sdaiApplication_instance.h"
-#include "clstepcore/read_func.h"
-#include "cleditor/SdaiSchemaInit.h"
-#include "clstepcore/STEPcomplex.h"
+#include "Registry.h"
+#include "sdaiApplication_instance.h"
+#include "read_func.h"
+#include "SdaiSchemaInit.h"
+#include "STEPcomplex.h"
 
-#include "cllazyfile/sectionReader.h"
-#include "cllazyfile/lazyFileReader.h"
-#include "cllazyfile/lazyInstMgr.h"
-#include "cllazyfile/lazyTypes.h"
+#include "sectionReader.h"
+#include "lazyFileReader.h"
+#include "lazyInstMgr.h"
+#include "lazyTypes.h"
 
 #include "current_function.hpp"
 

src/cllazyfile/sectionReader.h

@@ -3,10 +3,10 @@
 
 #include <fstream>
 #include <set>
-#include "cllazyfile/lazyTypes.h"
+#include "lazyTypes.h"
 #include "sc_export.h"
-#include "clutils/errordesc.h"
-#include "clstepcore/STEPcomplex.h"
+#include "errordesc.h"
+#include "STEPcomplex.h"
 
 class SDAI_Application_instance;
 class lazyFileReader;

src/clstepcore/CMakeLists.txt

@@ -1,4 +1,5 @@
-set(CORE_SRCS
+
+set(LIBSTEPCORE_SRCS
   aggrTypeDescriptor.cc
   attrDescriptor.cc
   attrDescriptorList.cc
@@ -61,24 +62,90 @@ set(CORE_SRCS
   whereRule.cc
 )
 
+set(SC_CLSTEPCORE_HDRS
+  aggrTypeDescriptor.h
+  attrDescriptor.h
+  attrDescriptorList.h
+  baseType.h
+  complexSupport.h
+  create_Aggr.h
+  derivedAttribute.h
+  dictSchema.h
+  dictdefs.h
+  dictionaryInstance.h
+  dispnode.h
+  dispnodelist.h
+  entityDescriptor.h
+  entityDescriptorList.h
+  enumTypeDescriptor.h
+  ExpDict.h
+  explicitItemId.h
+  globalRule.h
+  implicitItemId.h
+  instmgr.h
+  interfaceSpec.h
+  interfacedItem.h
+  inverseAttribute.h
+  inverseAttributeList.h
+  mgrnode.h
+  mgrnodearray.h
+  mgrnodelist.h
+  needFunc.h
+  read_func.h
+  realTypeDescriptor.h
+  Registry.h
+  schRename.h
+  sdai.h
+  sdaiApplication_instance.h
+  sdaiSelect.h
+  selectTypeDescriptor.h
+  SingleLinkList.h
+  STEPaggregate.h
+  STEPaggrBinary.h
+  STEPaggrEntity.h
+  STEPaggrEnum.h
+  STEPaggrGeneric.h
+  STEPaggrInt.h
+  STEPaggrReal.h
+  STEPaggrSelect.h
+  STEPaggrString.h
+  STEPattribute.h
+  STEPattributeList.h
+  STEPcomplex.h
+  STEPinvAttrList.h
+  STEPundefined.h
+  stringTypeDescriptor.h
+  SubSuperIterators.h
+  typeDescriptor.h
+  typeDescriptorList.h
+  typeOrRuleVar.h
+  uniquenessRule.h
+  whereRule.h
+)
+
 include_directories(
   ${CMAKE_CURRENT_SOURCE_DIR}
-  ${CMAKE_SOURCE_DIR}/include/stepcode
+  ${SC_SOURCE_DIR}/src/cldai
+  ${SC_SOURCE_DIR}/src/cleditor
+  ${SC_SOURCE_DIR}/src/clutils
   )
 
 set(_libdeps steputils stepdai)
 
 if(BUILD_SHARED_LIBS)
-  SC_ADDLIB(stepcore SHARED SOURCES ${CORE_SRCS} LINK_LIBRARIES ${_libdeps})
+  SC_ADDLIB(stepcore SHARED SOURCES ${LIBSTEPCORE_SRCS} LINK_LIBRARIES ${_libdeps})
   if(WIN32)
     target_compile_definitions(stepcore PRIVATE SC_CORE_DLL_EXPORTS)
   endif()
 endif()
 
 if(BUILD_STATIC_LIBS)
-  SC_ADDLIB(stepcore-static STATIC SOURCES ${CORE_SRCS} LINK_LIBRARIES $<JOIN:${_libdeps},-static>-static)
+  SC_ADDLIB(stepcore-static STATIC SOURCES ${LIBSTEPCORE_SRCS} LINK_LIBRARIES $<JOIN:${_libdeps},-static>-static)
 endif()
 
+install(FILES ${SC_CLSTEPCORE_HDRS}
+  DESTINATION ${INCLUDE_DIR}/stepcode/clstepcore)
+
 if(SC_ENABLE_TESTING)
   add_subdirectory(test)
 endif(SC_ENABLE_TESTING)

src/clstepcore/ExpDict.h

@@ -15,20 +15,20 @@
  */
 
 #include <sc_export.h>
-#include "clstepcore/sdai.h"
+#include <sdai.h>
 
 #include <vector>
 #include <string>
 #include <assert.h>
 
-#include "clstepcore/SingleLinkList.h"
+#include <SingleLinkList.h>
 
-#include "clstepcore/baseType.h"
-#include "clstepcore/dictdefs.h"
-#include "clutils/Str.h"
+#include <baseType.h>
+#include <dictdefs.h>
+#include <Str.h>
 
 // each of these contains linked list, list node, iterator
-#include "clstepcore/attrDescriptorList.h"
+#include "attrDescriptorList.h"
 #include "inverseAttributeList.h"
 #include "typeDescriptorList.h"
 #include "entityDescriptorList.h"
@@ -37,12 +37,12 @@
 #include "typeDescriptor.h"
 #include "entityDescriptor.h"
 #include "enumTypeDescriptor.h"
-#include "clstepcore/attrDescriptor.h"
-#include "clstepcore/derivedAttribute.h"
+#include "attrDescriptor.h"
+#include "derivedAttribute.h"
 #include "inverseAttribute.h"
 
-#include "clstepcore/create_Aggr.h"
-#include "clstepcore/dictionaryInstance.h"
+#include "create_Aggr.h"
+#include "dictionaryInstance.h"
 
 #include "uniquenessRule.h"
 #include "whereRule.h"
@@ -53,10 +53,10 @@
 #include "interfaceSpec.h"
 #include "typeOrRuleVar.h"
 #include "globalRule.h"
-#include "clstepcore/dictSchema.h"
+#include "dictSchema.h"
 #include "schRename.h"
 
-#include "clstepcore/aggrTypeDescriptor.h"
+#include "aggrTypeDescriptor.h"
 #include "selectTypeDescriptor.h"
 #include "stringTypeDescriptor.h"
 #include "realTypeDescriptor.h"

src/clstepcore/Registry.cc

@@ -9,8 +9,8 @@
 * and is not subject to copyright.
 */
 
-#include "clstepcore/ExpDict.h"
-#include "clstepcore/Registry.h"
+#include <ExpDict.h>
+#include <Registry.h>
 
 /* these may be shared between multiple Registry instances, so don't create/destroy in Registry ctor/dtor
  *                                                        Name, FundamentalType, Originating Schema, Description */

src/clstepcore/Registry.h

@@ -13,11 +13,11 @@
 */
 
 #include <sc_export.h>
-#include "clstepcore/sdai.h"
-#include "clutils/errordesc.h"
-#include "clutils/sc_hash.h"
-#include "clutils/Str.h"
-#include "clstepcore/complexSupport.h"
+#include <sdai.h>
+#include <errordesc.h>
+#include <sc_hash.h>
+#include <Str.h>
+#include <complexSupport.h>
 
 
 // defined and created in Registry.cc

src/clstepcore/STEPaggrBinary.cc

@@ -1,4 +1,4 @@
-#include "clstepcore/STEPaggrBinary.h"
+#include "STEPaggrBinary.h"
 #include <sstream>
 
 /** \file STEPaggrBinary.cc

src/clstepcore/STEPaggrBinary.h

@@ -1,7 +1,7 @@
 #ifndef STEPAGGRBINARY_H
 #define STEPAGGRBINARY_H
 
-#include "clstepcore/STEPaggregate.h"
+#include "STEPaggregate.h"
 #include <sc_export.h>
 
 /** \file STEPaggrBinary.h

src/clstepcore/STEPaggrEntity.cc

@@ -1,6 +1,6 @@
-#include "clstepcore/STEPaggrEntity.h"
-#include "clstepcore/STEPattribute.h"
-#include "clstepcore/typeDescriptor.h"
+#include "STEPaggrEntity.h"
+#include "STEPattribute.h"
+#include "typeDescriptor.h"
 #include <sstream>
 
 /** \file STEPaggrEntity.cc

src/clstepcore/STEPaggrEntity.h

@@ -5,7 +5,7 @@
  * classes EntityAggregate, EntityNode
  */
 
-#include "clstepcore/STEPaggregate.h"
+#include "STEPaggregate.h"
 #include <sc_export.h>
 
 class SC_CORE_EXPORT EntityAggregate  :  public  STEPaggregate {

src/clstepcore/STEPaggrEnum.cc

@@ -1,4 +1,4 @@
-#include "clstepcore/STEPaggrEnum.h"
+#include "STEPaggrEnum.h"
 #include <sstream>
 
 /** \file StepaggrEnum.cc

src/clstepcore/STEPaggrEnum.h

@@ -1,7 +1,7 @@
 #ifndef STEPAGGRENUM_H
 #define STEPAGGRENUM_H
 
-#include "clstepcore/STEPaggregate.h"
+#include "STEPaggregate.h"
 #include "sc_export.h"
 /** \file StepaggrEnum.h
  * classes EnumAggregate, LOGICALS, BOOLEANS, EnumNode

src/clstepcore/STEPaggrGeneric.cc

@@ -1,4 +1,4 @@
-#include "clstepcore/STEPaggrGeneric.h"
+#include "STEPaggrGeneric.h"
 #include <sstream>
 
 /** \file STEPaggrGeneric.cc

src/clstepcore/STEPaggrGeneric.h

@@ -1,7 +1,7 @@
 #ifndef STEPAGGRGENERIC_H
 #define STEPAGGRGENERIC_H
 
-#include "clstepcore/STEPaggregate.h"
+#include "STEPaggregate.h"
 #include <sc_export.h>
 
 /** \file STEPaggrGeneric.h

src/clstepcore/STEPaggrInt.cc

@@ -1,4 +1,4 @@
-#include "clstepcore/STEPaggrInt.h"
+#include "STEPaggrInt.h"
 
 
 IntAggregate::IntAggregate() {