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.

1 files changed, 410 insertions, 0 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;
+}
+