stepcode · mpictor · Dec 26, 2014 · Oct 13, 2013 · Oct 13, 2013 · Oct 13, 2013
diff --git a/AUTHORS b/AUTHORS
@@ -5,21 +5,26 @@ http://brlcad.svn.sourceforge.net/viewvc/brlcad/brlcad/trunk/src/other/step/?vie
 In alphabetical order:
 Bertucat, Roch (rbertucat)
 Bowman, W. Keith (indianlarry)
+da Costa, Raphael Kubo (rakuco)
+DeGraw, Jason (jasondegraw)
 Easterbrook, Zach (lainiwakurax)
 Greenwald, Erik (erikg, erikgreenwald)
+Horler, Chris (cshorler)
 Lanning, Craig (craigl64)
 Loman, David (davidloman)
 McDonald, Rob (ramcdona)
+Mittal, Pulkit (hoiji09)
 Morrison, Christopher Sean (sean, morrison, brlcad)
 Paviot, Thomas (tpaviot)
 Pictor, Mark (mpictor)
 Reed, Nick (nickreed)
-Shah, Kesha (kesha)
+Shah, Kesha (kesha, keshashah)
 Thomas, Dawn (homovulgaris, madant)
 Wouters, Dave (davyw)
 Yapp, Clifford (starseeker)
 
 Special thanks:
+Hunten, Keith (Lockheed Martin)
 Lubbell, Joshua (NIST)
 Stirk, Charlie (CostVision)
 Thurman, Tom (TRThurman)

diff --git a/NEWS b/NEWS
@@ -1,4 +1,25 @@
 STEPcode -- http://github.com/stepcode/stepcode -- http://stepcode.org
+************************************************************************
+Release 0.8 (December, 2014)
+
+New since v0.7:
+* handle diamond inheritance, derived Attributes
+* rename fedex_python, fedex_plus to exp2py, exp2cxx
+* many changes to the pretty printer, due to use in reformatting draft
+    and IS schemas (Thanks Tom!)
+* parser was also changed due to errors caught while pretty printing
+   - we can be much more confident that the parser is correct now
+* fix incorrect quoting of timestamp in p21 header
+* fix various copy constructors and ShallowCopy() members
+* split generated code into many small files
+   - far easier to open generated code in editors
+   - support more compilers
+   - small files are combined (via #include statements) into a few
+     large files for faster "unitary" builds, if the compiler can handle it
+   - unitary builds are faster than the previous builds
+* most compiler warnings fixed
+* finally, all tests pass!
+
 ************************************************************************
 Release 0.7 (April, 2013)
 

diff --git a/README b/README
@@ -1,5 +1,8 @@
+Travis-CI build status:
+[![Build Status](https://travis-ci.org/stepcode/stepcode.svg?branch=master)](https://travis-ci.org/stepcode/stepcode)
+
 ***********************************************************************
-STEPcode v0.7 -- stepcode.org, github.com/stepcode/stepcode
+STEPcode v0.8 -- stepcode.org, github.com/stepcode/stepcode
 
 * What is STEPcode? SC reads ISO10303-11 EXPRESS schemas and generates
   C++ source code that can read and write Part 21 files conforming
@@ -54,4 +57,4 @@ Download astyle from http://sourceforge.net/projects/astyle/files/astyle/
 
 ***********************************************************************
 
-For more info, see the wiki.
+For more info, see the wiki.
diff --git a/SC_VERSION.txt b/SC_VERSION.txt
@@ -1 +1 @@
-0.7
+0.8
diff --git a/cmake/SC_CXX_schema_macros.cmake b/cmake/SC_CXX_schema_macros.cmake
@@ -65,7 +65,7 @@ macro(SCHEMA_TESTS)
       COMMAND ${CMAKE_COMMAND} --build .
       --target lazy_${PROJECT_NAME}
       --config $<CONFIGURATION>)
-    set_tests_properties(build_lazy_cpp_${PROJECT_NAME} PROPERTIES DEPENDS generate_cpp_${PROJECT_NAME} LABELS cpp_schema_build)
+    set_tests_properties(build_lazy_cpp_${PROJECT_NAME} PROPERTIES DEPENDS build_cpp_${PROJECT_NAME} LABELS cpp_schema_build)
   endif(NOT WIN32)
 endmacro(SCHEMA_TESTS)
 

diff --git a/include/express/variable.h b/include/express/variable.h
@@ -76,10 +76,11 @@ typedef struct Variable_ * Variable;
 /***************************/
 
 struct Variable_ {
-    Expression  name;    /**< Symbol is inside of 'name' */
+    Expression  name;        /**< Symbol is inside of 'name' */
     Type        type;
     Expression  initializer; /**< or 'derived' */
-    int         offset; /**< used for attr order in Entitys, and for decl order in LOCAL vars. these two uses should never conflict! */
+    int         offset;      /**< used for attr order in Entitys, and for decl order in LOCAL vars. these two uses should never conflict! */
+    int         idx;         /**< used in exp2cxx to simplify calculation of attrDescriptor names in generated code */
 
     struct {
         unsigned int optional    : 1; /**< OPTIONAL keyword */

diff --git a/src/base/judy/src/judy.c b/src/base/judy/src/judy.c
@@ -903,8 +903,9 @@ JudySlot * judy_last( Judy * judy, JudySlot next, unsigned int off, unsigned int
 JudySlot * judy_end( Judy * judy ) {
     judy->level = 0;
     return judy_last( judy, *judy->root, 0, 0 );
-} //    judy_nxt: return next entry
+}
 
+//    judy_nxt: return next entry
 JudySlot * judy_nxt( Judy * judy ) {
     JudySlot * table, *inner;
     int slot, size, cnt;

diff --git a/src/base/judy/src/judyLArray.h b/src/base/judy/src/judyLArray.h
@@ -29,14 +29,16 @@ struct judylKVpair {
  */
 template< typename JudyKey, typename JudyValue >
 class judyLArray {
+    public:
+        typedef judylKVpair< JudyKey, JudyValue > pair;
     protected:
         Judy * _judyarray;
         unsigned int _maxLevels, _depth;
         JudyValue * _lastSlot;
         JudyKey _buff[1];
         bool _success;
+        pair _kv;
     public:
-        typedef judylKVpair< JudyKey, JudyValue > pair;
         judyLArray(): _maxLevels( sizeof( JudyKey ) ), _depth( 1 ), _lastSlot( 0 ), _success( true ) {
             assert( sizeof( JudyKey ) == JUDY_key_size && "JudyKey *must* be the same size as a pointer!" );
             assert( sizeof( JudyValue ) == JUDY_key_size && "JudyValue *must* be the same size as a pointer!" );
@@ -55,9 +57,12 @@ class judyLArray {
             judy_close( _judyarray );
         }
 
-        void clear() {
+        void clear( bool deleteContents = false ) {
             JudyKey key = 0;
             while( 0 != ( _lastSlot = ( JudyValue * ) judy_strt( _judyarray, ( const unsigned char * ) &key, 0 ) ) ) {
+                if( deleteContents ) {
+                    delete *_lastSlot;
+                }
                 judy_del( _judyarray );
             }
         }
@@ -112,18 +117,17 @@ class judyLArray {
         }
 
         /// retrieve the key-value pair for the most recent judy query.
-        inline const pair mostRecentPair() {
-            pair kv;
+        inline const pair & mostRecentPair() {
             judy_key( _judyarray, ( unsigned char * ) _buff, _depth * JUDY_key_size );
             if( _lastSlot ) {
-                kv.value = *_lastSlot;
+                _kv.value = *_lastSlot;
                 _success = true;
             } else {
-                kv.value = ( JudyValue ) 0;
+                _kv.value = ( JudyValue ) 0;
                 _success = false;
             }
-            kv.key = _buff[0];
-            return kv;
+            _kv.key = _buff[0];
+            return _kv;
         }
 
         /// retrieve the first key-value pair in the array

diff --git a/src/cllazyfile/headerSectionReader.h b/src/cllazyfile/headerSectionReader.h
@@ -27,7 +27,7 @@ class SC_LAZYFILE_EXPORT headerSectionReader: public sectionReader {
             return _headerInstances;
         }
 
-        ~headerSectionReader() {
+        virtual ~headerSectionReader() {
             //FIXME delete each instance?! maybe add to clear, since it iterates over everything already
             //enum clearHow { rawData, deletePointers }
             _headerInstances->clear();

diff --git a/src/cllazyfile/instMgrHelper.h b/src/cllazyfile/instMgrHelper.h
@@ -14,21 +14,21 @@
  * This class is used when creating SDAI_Application_instance's and using a lazyInstMgr. It is returned
  * by instMgrAdapter. SDAI_Application_instance only uses the GetSTEPentity function.
  */
-class mgrNodeHelper: protected MgrNode {
+class mgrNodeHelper: public MgrNodeBase {
     protected:
         lazyInstMgr * _lim;
         instanceID _id;
     public:
         mgrNodeHelper( lazyInstMgr * lim ) {
             _lim = lim;
             _id = 0;
+            prev = next = 0;
         }
         inline void setInstance( instanceID id ) {
             _id = id;
         }
         inline SDAI_Application_instance * GetSTEPentity() {
-//         unsigned int c = _lim->countDataSections();
-            return _lim->loadInstance( _id );
+            return _lim->loadInstance( _id, true );
         }
 };
 
@@ -40,13 +40,14 @@ class mgrNodeHelper: protected MgrNode {
  * when an instance is looked up, this uses lazyInstMgr to load it, and then returns a pointer to it.
  */
 
-class instMgrAdapter: public InstMgr {
+class instMgrAdapter: public InstMgrBase {
     protected:
         mgrNodeHelper _mn;
     public:
-        instMgrAdapter( lazyInstMgr * lim ): InstMgr( 0 ), _mn( lim ) {}
+        instMgrAdapter( lazyInstMgr * lim ): InstMgrBase(), _mn( lim ) {}
 
         inline mgrNodeHelper * FindFileId( int fileId ) {
+            //TODO check if fileId exists. if not, return null
             _mn.setInstance( fileId );
             return &_mn;
         }

diff --git a/src/cllazyfile/lazyInstMgr.cc b/src/cllazyfile/lazyInstMgr.cc
@@ -1,15 +1,18 @@
 #include "lazyTypes.h"
 #include "lazyInstMgr.h"
 #include "Registry.h"
+#include <SubSuperIterators.h>
 #include "SdaiSchemaInit.h"
 #include "instMgrHelper.h"
+#include "lazyRefs.h"
 
 lazyInstMgr::lazyInstMgr() {
     _headerRegistry = new Registry( HeaderSchemaInit );
     _instanceTypes = new instanceTypes_t( 255 ); //NOTE arbitrary max of 255 chars for a type name
     _lazyInstanceCount = 0;
     _loadedInstanceCount = 0;
     _longestTypeNameLen = 0;
+    _mainRegistry = 0;
     _errors = new ErrorDescriptor();
     _ima = new instMgrAdapter( this );
 }
@@ -38,16 +41,20 @@ sectionID lazyInstMgr::registerDataSection( lazyDataSectionReader * sreader ) {
 
 void lazyInstMgr::addLazyInstance( namedLazyInstance inst ) {
     _lazyInstanceCount++;
-    assert( inst.loc.begin > 0 && inst.loc.instance > 0 && inst.loc.section >= 0 );
+    assert( inst.loc.begin > 0 && inst.loc.instance > 0 );
     int len = strlen( inst.name );
     if( len > _longestTypeNameLen ) {
         _longestTypeNameLen = len;
         _longestTypeName = inst.name;
     }
     _instanceTypes->insert( inst.name, inst.loc.instance );
     /* store 16 bits of section id and 48 of instance offset into one 64-bit int
-    * TODO: check and warn if anything is lost (in calling code?)
-    * does 32bit need anything special?
+    ** TODO: check and warn if anything is lost (in calling code?)
+    ** does 32bit need anything special?
+    **
+    ** create conversion class?
+    **  could then initialize conversion object with number of bits
+    **  also a good place to check for data loss
     */
     positionAndSection ps = inst.loc.section;
     ps <<= 48;
@@ -85,18 +92,29 @@ unsigned long lazyInstMgr::getNumTypes() const {
 }
 
 void lazyInstMgr::openFile( std::string fname ) {
-    _files.push_back( new lazyFileReader( fname, this, _files.size() ) );
+    //don't want to hold a lock for the entire time we're reading the file.
+    //create a place in the vector and remember its location, then free lock
+    ///FIXME begin atomic op
+    size_t i = _files.size();
+    _files.push_back( (lazyFileReader * ) 0 );
+    ///FIXME end atomic op
+    lazyFileReader * lfr = new lazyFileReader( fname, this, i );
+    _files[i] = lfr;
+    /// TODO resolve inverse attr references
+    //between instances, or eDesc --> inst????
 }
 
-SDAI_Application_instance * lazyInstMgr::loadInstance( instanceID id ) {
+SDAI_Application_instance * lazyInstMgr::loadInstance( instanceID id, bool reSeek ) {
     assert( _mainRegistry && "Main registry has not been initialized. Do so with initRegistry() or setRegistry()." );
-    SDAI_Application_instance * inst = 0;
+    std::streampos oldPos;
     positionAndSection ps;
     sectionID sid;
-    inst = _instancesLoaded.find( id );
+    SDAI_Application_instance * inst = _instancesLoaded.find( id );
+    if( inst ) {
+        return inst;
+    }
     instanceStreamPos_t::cvector * cv;
-    if( !inst && 0 != ( cv = _instanceStreamPos.find( id ) ) ) {
-        //FIXME _instanceStreamPos.find( id ) can return nonzero for nonexistent key?!
+    if( 0 != ( cv = _instanceStreamPos.find( id ) ) ) {
         switch( cv->size() ) {
             case 0:
                 std::cerr << "Instance #" << id << " not found in any section." << std::endl;
@@ -107,7 +125,13 @@ SDAI_Application_instance * lazyInstMgr::loadInstance( instanceID id ) {
                 off = ps & 0xFFFFFFFFFFFFULL;
                 sid = ps >> 48;
                 assert( _dataSections.size() > sid );
+                if( reSeek ) {
+                    oldPos = _dataSections[sid]->tellg();
+                }
                 inst = _dataSections[sid]->getRealInstance( _mainRegistry, off, id );
+                if( reSeek ) {
+                    _dataSections[sid]->seekg( oldPos );
+                }
                 break;
             default:
                 std::cerr << "Instance #" << id << " exists in multiple sections. This is not yet supported." << std::endl;
@@ -116,6 +140,8 @@ SDAI_Application_instance * lazyInstMgr::loadInstance( instanceID id ) {
         if( ( inst ) && ( inst != & NilSTEPentity ) ) {
             _instancesLoaded.insert( id, inst );
             _loadedInstanceCount++;
+            lazyRefs lr( this, inst );
+            lazyRefs::referentInstances_t insts = lr.result();
         } else {
             std::cerr << "Error loading instance #" << id << "." << std::endl;
         }