Merged in the core branch. This is a major update that fixes many things, and

changes many others, including source files that were deleted and renamed.

Before doing this update, I reccomend a full clean, or even a fresh checkout.

Things to note, most outstanding about this update:
 - Bu::Socket was changed to Bu::TcpSocket and the default mode is blocking.
 - All templatized container classes are SharedCore now, which is good, but
   SharedCore is inherently non-reentrant safe.  However, all SharedCore classes
   have a "clone" function that return a non-shared copy of the object, safe for
   passing into a reentrant safe function accessing shared memory.

3 files changed, 528 insertions, 9 deletions

diff --git a/src/tools/bnfcompile.cpp b/src/tools/bnfcompile.cpp
new file mode 100644
index 0000000..16e75a5
--- /dev/null
+++ b/src/tools/bnfcompile.cpp
@@ -0,0 +1,410 @@
+#include <bu/sio.h>
+#include <bu/lexer.h>
+#include <bu/parser.h>
+#include <bu/file.h>
+#include <bu/queuebuf.h>
+
+using namespace Bu;
+
+enum TokenType
+{
+        tokIdentifier,
+        tokColon,
+        tokOr,
+        tokSemiColon,
+        tokTokens,
+        tokEquals,
+        tokOpenCurly,
+        tokCloseCurly,
+        tokOpenSquare,
+        tokCloseSquare,
+
+        tokEos=-1
+};
+
+class BnfLexer : public Lexer
+{
+public:
+        BnfLexer( Stream &rSrc ) :
+                rSrc( rSrc )
+        {
+        }
+
+        virtual ~BnfLexer()
+        {
+        }
+
+        virtual Token *nextToken()
+        {
+                char cBuf;
+
+                for(;;)
+                {
+                        if( qbIn.getSize() == 0 )
+                        {
+                                char buf[4096];
+                                qbIn.write( buf, rSrc.read( buf, 4096 ) );
+
+                                if( rSrc.isEos() && qbIn.getSize() == 0 )
+                                        return new Token( tokEos );
+                        }
+                        qbIn.peek( &cBuf, 1 );
+                        if( (cBuf >= 'a' && cBuf <= 'z') ||
+                                (cBuf >= 'A' && cBuf <= 'Z') ||
+                                (cBuf >= '0' && cBuf <= '9') ||
+                                cBuf == '_' )
+                        {
+                                sBuf.append( cBuf );
+                                qbIn.seek( 1 );
+                        }
+                        else if( sBuf.isSet() )
+                        {
+                                if( sBuf == "tokens" )
+                                {
+                                        sBuf.clear();
+                                        return new Token( tokTokens );
+                                }
+                                else
+                                {
+                                        Token *pRet = new Token( tokIdentifier, sBuf );
+                                        sBuf.clear();
+                                        return pRet;
+                                }
+                        }
+                        else
+                        {
+                                switch( cBuf )
+                                {
+                                        case ' ':
+                                        case '\t':
+                                        case '\n':
+                                        case '\r':
+                                                qbIn.seek( 1 );
+                                                continue;
+
+                                        case ':':
+                                                qbIn.seek( 1 );
+                                                return new Token( tokColon );
+
+                                        case ';':
+                                                qbIn.seek( 1 );
+                                                return new Token( tokSemiColon );
+
+                                        case '|':
+                                                qbIn.seek( 1 );
+                                                return new Token( tokOr );
+
+                                        case '=':
+                                                qbIn.seek( 1 );
+                                                return new Token( tokEquals );
+
+                                        case '[':
+                                                qbIn.seek( 1 );
+                                                return new Token( tokOpenSquare );
+
+                                        case ']':
+                                                qbIn.seek( 1 );
+                                                return new Token( tokCloseSquare );
+
+                                        case '{':
+                                                qbIn.seek( 1 );
+                                                return new Token( tokOpenCurly );
+
+                                        case '}':
+                                                qbIn.seek( 1 );
+                                                return new Token( tokCloseCurly );
+
+                                        default:
+                                                throw ExceptionBase("Unexpected character '%c'.",
+                                                        cBuf );
+                                                break;
+                                }
+                        }
+                }
+        }
+
+        virtual FString tokenToString( const Token &t )
+        {
+                switch( (TokenType)t.iToken )
+                {
+                        case tokIdentifier:             return "tokIdentifier";
+                        case tokColon:                  return "tokColon";
+                        case tokOr:                             return "tokOr";
+                        case tokSemiColon:              return "tokSemiColon";
+                        case tokTokens:                 return "tokTokens";
+                        case tokEquals:                 return "tokEquals";
+                        case tokOpenCurly:              return "tokOpenCurly";
+                        case tokCloseCurly:             return "tokCloseCurly";
+                        case tokOpenSquare:             return "tokOpenSquare";
+                        case tokCloseSquare:    return "tokCloseSquare";
+                        case tokEos:                    return "tokEos";
+                }
+
+                return "???";
+        }
+
+private:
+        Stream &rSrc;
+        QueueBuf qbIn;
+        FString sBuf;
+};
+
+class BnfParser
+{
+public:
+        BnfParser( BnfLexer &l ) :
+                l( l ),
+                pCur( NULL ),
+                iLastToken( 0 )
+        {
+        }
+
+        virtual ~BnfParser()
+        {
+                delete pCur;
+                pCur = NULL;
+        }
+
+        void parse()
+        {
+                for(;;)
+                {
+                        next();
+                        switch( pCur->iToken )
+                        {
+                                case tokTokens:
+                                        tokens();
+                                        break;
+
+                                case tokIdentifier:
+                                        nonTerminal();
+                                        break;
+
+                                case tokEos:
+                                        return;
+                                        break;
+
+                                default:
+                                        tokenError("tokTokens, tokIdentifier, or tokEos");
+                        }
+                }
+        }
+
+private:
+        void tokens()
+        {
+                next();
+                if( pCur->iToken != tokEquals )
+                        tokenError("tokEquals");
+                for(;;)
+                {
+                        next();
+                        if( pCur->iToken == tokIdentifier )
+                        {
+                                hTokens.insert( pCur->vExtra.get<Bu::FString>(), ++iLastToken );
+                                sio << "Added token[" << iLastToken << "]: "
+                                        << pCur->vExtra.get<Bu::FString>() << sio.nl;
+                        }
+                        else if( pCur->iToken == tokSemiColon )
+                                break;
+                        else
+                                tokenError("tokIdentifier or tokSemiColon");
+                }
+        }
+
+        void nonTerminal()
+        {
+                Bu::FString sNtName = pCur->vExtra.get<Bu::FString>();
+                Parser::NonTerminal nt;
+                p.addNonTerminal( sNtName );
+                sio.incIndent();
+                sio << "Created non-terminal: " << sNtName << sio.nl;
+
+                next();
+                if( pCur->iToken != tokColon )
+                        tokenError("tokColon");
+                production( nt );
+                for(;;)
+                {
+                        switch( pCur->iToken )
+                        {
+                                case tokOr:
+                                        production( nt );
+                                        break;
+
+                                case tokSemiColon:
+                                        p.setNonTerminal( sNtName, nt );
+                                        sio.decIndent();
+                                        sio << "Closing non-terminal." << sio.nl;
+                                        return;
+
+                                default:
+                                        tokenError("tkOr or tokSemiColon");
+                                        break;
+                        }
+                }
+        }
+
+        void production( Parser::NonTerminal &nt )
+        {
+                sio.incIndent();
+                sio << "Adding new production:" << sio.nl;
+                Parser::Production pr;
+                bool bAnything = false;
+                for(;;)
+                {
+                        next();
+                        switch( pCur->iToken )
+                        {
+                                case tokIdentifier:
+                                        {
+                                                const Bu::FString &sName =
+                                                        pCur->vExtra.get<Bu::FString>();
+                                                if( hTokens.has( sName ) )
+                                                {
+                                                        pr.append(
+                                                                Parser::State(
+                                                                        Parser::State::typeTerminal,
+                                                                        hTokens.get( sName )
+                                                                        )
+                                                                );
+                                                        sio << "Added terminal " << sName << sio.nl;
+                                                }
+                                                else
+                                                {
+                                                        if( !p.hasNonTerminal( sName ) )
+                                                        {
+                                                                p.addNonTerminal( sName );
+                                                        }
+                                                        pr.append(
+                                                                Parser::State(
+                                                                        Parser::State::typeNonTerminal,
+                                                                        p.getNonTerminalId( sName )
+                                                                        )
+                                                                );
+                                                        sio << "Added non-terminal " << sName << sio.nl;
+                                                }
+                                        }
+                                        break;
+
+                                case tokOpenSquare:
+                                        {
+                                                next();
+                                                if( pCur->iToken != tokIdentifier )
+                                                        tokenError("tokIdentifier");
+                                                Bu::FString sName =
+                                                        pCur->vExtra.get<Bu::FString>();
+                                                next();
+                                                if( pCur->iToken != tokCloseSquare )
+                                                        tokenError("tokCloseSquare");
+
+                                                if( !hTokens.has( sName ) )
+                                                        throw ExceptionBase("Only token names may be "
+                                                                "enclosed in square brackets.");
+
+                                                pr.append(
+                                                        Parser::State(
+                                                                Parser::State::typeTerminalPush,
+                                                                hTokens.get( sName )
+                                                                )
+                                                        );
+                                                sio << "Added terminal-push " << sName << sio.nl;
+                                        }
+                                        break;
+
+                                case tokOpenCurly:
+                                        {
+                                                next();
+                                                if( pCur->iToken != tokIdentifier )
+                                                        tokenError("tokIdentifier");
+                                                Bu::FString sName =
+                                                        pCur->vExtra.get<Bu::FString>();
+                                                next();
+                                                if( pCur->iToken != tokCloseCurly )
+                                                        tokenError("tokCloseCurly");
+
+                                                if( !p.hasReduction( sName ) )
+                                                        p.addReduction( sName );
+
+                                                pr.append(
+                                                        Parser::State(
+                                                                Parser::State::typeReduction,
+                                                                p.getReductionId( sName )
+                                                                )
+                                                        );
+                                                sio << "Added reduction " << sName << sio.nl;
+                                        }
+                                        break;
+
+                                case tokOr:
+                                case tokSemiColon:
+                                        if( bAnything )
+                                        {
+                                                nt.addProduction( pr );
+                                                sio.decIndent();
+                                                sio << "Closing production." << sio.nl;
+                                        }
+                                        else
+                                        {
+                                                nt.setCanSkip();
+                                                sio.decIndent();
+                                                sio << "Closing empty production." << sio.nl;
+                                        }
+                                        return;
+
+                                default:
+                                        tokenError("tokIdentifier, tokOpenSquare, tokOr, "
+                                                        "tokOpenCurly, or tokSemiColon");
+                        }
+                }
+        }
+
+private:
+        void next()
+        {
+                delete pCur;
+                pCur = l.nextToken();
+        }
+
+        void tokenError( const FString &s )
+        {
+                throw ExceptionBase( ("Expected " + s + " but found "
+                                + l.tokenToString( *pCur ) + ".").getStr() );
+        }
+
+private:
+        typedef Bu::Hash<Bu::FString, int> TokenHash;
+        TokenHash hTokens;
+        BnfLexer &l;
+        BnfLexer::Token *pCur;
+        int iLastToken;
+        Parser p;
+};
+
+int main( int argc, char *argv[] )
+{
+        File fIn( argv[1], File::Read );
+
+        BnfLexer bl( fIn );
+        BnfParser parser( bl );
+
+        parser.parse();
+
+/*
+        for(;;)
+        {
+                Lexer::Token *pTok = bl.nextToken();
+                sio << bl.tokenToString(*pTok);
+                if( pTok->vExtra.isSet() )
+                {
+                        sio << " - " << pTok->vExtra;
+                }
+                sio << sio.nl;
+                if( pTok->iToken == tokEos )
+                        break;
+        }
+*/
+
+        return 0;
+}
+
diff --git a/src/tools/myriadfs.cpp b/src/tools/myriadfs.cpp
new file mode 100644
index 0000000..66955a5
--- /dev/null
+++ b/src/tools/myriadfs.cpp
@@ -0,0 +1,38 @@
+#define FUSE_USE_VERSION 26
+
+#include <fuse.h>
+
+#include <string.h>
+
+extern "C" {
+        static int myriadfs_getattr( const char *sPath, struct stat *stbuf )
+        {
+
+        }
+
+        static int myriadfs_readdir( const char *sPath, void *buf,
+                        fuse_fill_dir_t filler, off_t offset, struct fuse_file_info *fi )
+        {
+        }
+
+        static int myriadfs_open( const char *sPath, struct fuse_file_info *fi )
+        {
+        }
+
+        static int myriadfs_read( const char *sPath, char *buf, size_t iSize,
+                        off_t iOffset, struct fuse_file_info *fi )
+        {
+        }
+
+        static struct fuse_operations myriadfs_oper;
+
+        int main( int argc, char *argv[] )
+        {
+                memset( &myriadfs_oper, sizeof(myriadfs_oper), 0 );
+                myriadfs_oper.getattr    = myriadfs_getattr;
+                myriadfs_oper.readdir    = myriadfs_readdir;
+                myriadfs_oper.open       = myriadfs_open;
+                myriadfs_oper.read       = myriadfs_read;
+                return fuse_main( argc, argv, &myriadfs_oper, NULL );
+        }
+}
diff --git a/src/tools/parser.cpp b/src/tools/parser.cpp
index 76d4a72..7933f31 100644
--- a/src/tools/parser.cpp
+++ b/src/tools/parser.cpp
@@ -151,10 +151,43 @@ private:
 
 void redAdd( Bu::Parser &p )
 {
+        Lexer::Token *a = p.popToken();
+        Lexer::Token *b = p.popToken();
+
+        sio << "Add!  " << b->vExtra.get<double>() << " + "
+                << a->vExtra.get<double>() << sio.nl;
+
+        Lexer::Token *c = new Lexer::Token( tokNumber, 
+                b->vExtra.get<double>() + a->vExtra.get<double>()
+                );
+        p.pushToken( c );
+
+        delete a;
+        delete b;
+}
+
+void redSubtract( Bu::Parser &p )
+{
+        Lexer::Token *a = p.popToken();
+        Lexer::Token *b = p.popToken();
+
+        sio << "Subtract!  " << b->vExtra.get<double>() << " - "
+                << a->vExtra.get<double>() << sio.nl;
+
+        Lexer::Token *c = new Lexer::Token( tokNumber, 
+                b->vExtra.get<double>() - a->vExtra.get<double>()
+                );
+        p.pushToken( c );
+
+        delete a;
+        delete b;
 }
 
 void redPrint( Bu::Parser &p )
 {
+        Lexer::Token *a = p.popToken();
+        sio << "Print! = " << a->vExtra.get<double>() << sio.nl;
+        delete a;
 }
 
 /* Basic grammer example:
@@ -170,14 +203,15 @@ void redPrint( Bu::Parser &p )
  * The problem is, that we can't actually make something left hand recursive,
  * so we break it into two exprs:
  *
- * expr': '(' expr ')'
+ * expr-sub1: '(' expr ')'
  *      | NUMBER
  *      ;
  *
- * expr: expr' expr''
+ * expr: expr-sub1 expr-sub2
  *     ;
  *
- * expr'': '+' expr
+ * expr-sub2: '+' expr
+ *       | '-' expr
  *       |
  *       ;
  *
@@ -191,8 +225,8 @@ int main( int argc, char *argv[] )
         Parser p;
 
         p.addNonTerminal("expr");
-        p.addNonTerminal("expr'");
-        p.addNonTerminal("expr''");
+        p.addNonTerminal("expr-sub1");
+        p.addNonTerminal("expr-sub2");
         {
                 Parser::NonTerminal nt;
                 nt.addProduction(
@@ -215,10 +249,28 @@ int main( int argc, char *argv[] )
                         );
                 nt.addProduction(
                         Parser::Production(
+                                Parser::State(
+                                        Parser::State::typeTerminal,
+                                        tokMinus
+                                        )
+                                ).append(
+                                Parser::State(
+                                        Parser::State::typeNonTerminal,
+                                        p.getNonTerminalId("expr")
+                                        )
+                                ).append(
+                                Parser::State(
+                                        Parser::State::typeReduction,
+                                        p.addReduction("subtract")
+                                        )
+                                )
+                        );
+                nt.addProduction(
+                        Parser::Production(
                                 )
                         );
                 nt.setCanSkip();
-                p.setNonTerminal("expr''", nt );
+                p.setNonTerminal("expr-sub2", nt );
         }
         {
                 Parser::NonTerminal nt;
@@ -230,7 +282,25 @@ int main( int argc, char *argv[] )
                                         )
                                 )
                         );
-                p.setNonTerminal("expr'", nt );
+                nt.addProduction(
+                        Parser::Production(
+                                Parser::State(
+                                        Parser::State::typeTerminal,
+                                        tokOpenParen
+                                        )
+                                ).append(
+                                Parser::State(
+                                        Parser::State::typeNonTerminal,
+                                        p.getNonTerminalId("expr")
+                                        )
+                                ).append(
+                                Parser::State(
+                                        Parser::State::typeTerminal,
+                                        tokCloseParen
+                                        )
+                                )
+                        );
+                p.setNonTerminal("expr-sub1", nt );
         }
         {
                 Parser::NonTerminal nt;
@@ -238,12 +308,12 @@ int main( int argc, char *argv[] )
                         Parser::Production(
                                 Parser::State(
                                         Parser::State::typeNonTerminal,
-                                        p.getNonTerminalId("expr'")
+                                        p.getNonTerminalId("expr-sub1")
                                         )
                                 ).append(
                                 Parser::State(
                                         Parser::State::typeNonTerminal,
-                                        p.getNonTerminalId("expr''")
+                                        p.getNonTerminalId("expr-sub2")
                                         )
                                 )
                         );
@@ -275,6 +345,7 @@ int main( int argc, char *argv[] )
         p.setRootNonTerminal("input");
 
         p.setReduction("add", Bu::slot( &redAdd ) );
+        p.setReduction("subtract", Bu::slot( &redSubtract ) );
         p.setReduction("print", Bu::slot( &redPrint ) );
 
         p.pushLexer( new MathLexer( fIn ) );