Code is all reorganized. We're about ready to release. I should write up a

little explenation of the arrangement.

1 files changed, 142 insertions, 0 deletions

diff --git a/src/experimental/regexengine.h b/src/experimental/regexengine.h
new file mode 100644
index 0000000..ec181c1
--- /dev/null
+++ b/src/experimental/regexengine.h
@@ -0,0 +1,142 @@
+#ifndef BU_REG_EX_ENGINE_H
+#define BU_REG_EX_ENGINE_H
+
+#include "bu/sharedcore.h"
+#include "bu/array.h"
+#include "bu/sio.h"
+
+namespace Bu
+{
+        template<typename chr> class RegExEngine;
+
+        template<typename chr>
+        class RegExEngineCore
+        {
+        friend class RegExEngine<chr>;
+        friend class SharedCore<RegExEngine<chr>, RegExEngineCore<chr> >;
+        private:
+                RegExEngineCore()
+                {
+                }
+
+                virtual ~RegExEngineCore()
+                {
+                }
+
+                class Range
+                {
+                public:
+                        Range( chr cLower, chr cUpper, int iTrgState ) :
+                                cLower( cLower ), cUpper( cUpper ), iTrgState( iTrgState )
+                        {
+                        }
+                
+                        chr cLower;
+                        chr cUpper;
+                        int iTrgState;
+                };
+
+                class State
+                {
+                public:
+                        Bu::Array<Range> aRange;
+                };
+
+                int addState()
+                {
+                        aState.append( State() );
+                        return aState.getSize()-1;
+                }
+
+                void addCompletion( int iState, chr cLower, chr cUpper, int iTrgState )
+                {
+                        aState[iState].aRange.append( Range( cLower, cUpper, iTrgState ) );
+                }
+
+                template<typename str>
+                bool match( const str &sIn, int &iSize, int &iCompletion )
+                {
+                        bool bMatch;
+                        int iState = 0;
+                        iSize = 0;
+                        for( typename str::const_iterator i = sIn.begin(); i; i++ )
+                        {
+                                Bu::sio << "Finding char " << *i << " in state " << iState
+                                        << ":" << Bu::sio.nl;
+                                bMatch = false;
+                                for( typename Bu::Array<Range>::iterator j =
+                                         aState[iState].aRange.begin(); j; j++ )
+                                {
+                                        Bu::sio << "    Testing range " << (*j).cLower << " - " << (*j).cUpper << Bu::sio.nl;
+                                        if( *i >= (*j).cLower && *i <= (*j).cUpper )
+                                        {
+                                                iState = (*j).iTrgState;
+                                                bMatch = true;
+                                                iSize++;
+                                                if( iState < 0 )
+                                                {
+                                                        iCompletion = iState;
+                                                        return true;
+                                                }
+                                        }
+                                }
+                                if( bMatch == false )
+                                {
+                                        return false;
+                                }
+                        }
+
+                        iCompletion = 0;
+                        return true;
+                }
+
+                typedef Bu::Array<State> StateArray;
+                StateArray aState;
+        };
+
+        template<typename chr>
+        class RegExEngine : public SharedCore<RegExEngine<chr>,
+                                                RegExEngineCore<chr> >
+        {
+        private:
+                typedef class RegExEngine<chr> MyType;
+                typedef class RegExEngineCore<chr> Core;
+                typedef class Core::Range Range;
+                typedef class Core::State State;
+        
+        protected:
+                using SharedCore<MyType, Core>::core;
+                using SharedCore<MyType, Core>::_hardCopy;
+                using SharedCore<MyType, Core>::_resetCore;
+                using SharedCore<MyType, Core>::_allocateCore;
+
+        public:
+                RegExEngine()
+                {
+                }
+
+                virtual ~RegExEngine()
+                {
+                }
+
+                int addState()
+                {
+                        return core->addState();
+                }
+
+                void addCompletion( int iState, chr cLower, chr cUpper, int iTrgState )
+                {
+                        core->addCompletion( iState, cLower, cUpper, iTrgState );
+                }
+
+                template<typename str>
+                bool match( const str &sIn, int &iSize, int &iCompletion )
+                {
+                        return core->match( sIn, iSize, iCompletion );
+                }
+
+        private:
+        };
+};
+
+#endif