1 files changed, 229 insertions, 0 deletions

diff --git a/src/smlrenderervt100.cpp b/src/smlrenderervt100.cpp
new file mode 100644
index 0000000..2b59d5f
--- /dev/null
+++ b/src/smlrenderervt100.cpp
@@ -0,0 +1,229 @@
+#include "smlrenderervt100.h"
+#include "smlnode.h"
+
+SmlRendererVt100::SmlRendererVt100()
+{
+}
+
+SmlRendererVt100::~SmlRendererVt100()
+{
+}
+
+void SmlRendererVt100::appendToken( Bu::Formatter &f, Bu::String &sCurLine,
+                Bu::String &sNextToken, int &iLineLen, int &iNextLen )
+{
+        if( iLineLen + iNextLen + 1 >= 78 )
+        {
+                f << sCurLine << f.nl;
+                iLineLen = 0;
+                sCurLine = sNextToken;
+        }
+        else
+        {
+                sCurLine += sNextToken;
+        }
+        iLineLen += iNextLen + 1;
+        sCurLine += " ";
+        iNextLen = 0;
+        sNextToken.clear();
+}
+
+Bu::String SmlRendererVt100::getStyle( const StyleStack &sStyle )
+{
+#ifdef WIN32
+        // Windows...we don't do colors for windows...
+        return "";
+#endif
+
+        if( sStyle.isEmpty() )
+        {
+                return "\x1B[0m";
+        }
+
+        int sCurStyle = 0;
+        for( StyleStack::const_iterator i = sStyle.begin(); i; i++ )
+        {
+//              f << "Merging in: " << Fmt::hex() << *i << f.nl;
+                if( ((sCurStyle&stTypeMask) & ((*i)&stTypeMask)) == 0 )
+                {
+                        sCurStyle |= *i;
+//                      f << "  -> curStyle = " << Fmt::hex() << *i << f.nl;
+                }
+        }
+
+        Bu::String sRet;
+
+//      f << "Color: " << Fmt::hex() << sCurStyle << f.nl;
+        switch( sCurStyle&stColor )
+        {
+                case stRed:
+                        sRet += "\x1B[1;31m";
+                        break;
+
+                case stGreen:
+                        sRet += "\x1B[1;32m";
+                        break;
+        }
+
+        return sRet;
+}
+
+void SmlRendererVt100::render( Bu::Formatter &f, const SmlNode *pNode )
+{
+        Bu::String sCurLine;
+        Bu::String sNextToken;
+        int iLineLen = 0;
+        int iNextLen = 0;
+        int iState = 0;
+        typedef Bu::List<SmlNode::SmlNodeList::const_iterator> NodeStack;
+        NodeStack sNode;
+
+        StyleStack sStyle;
+
+        sNode.push( pNode->getChildren().begin() );
+
+        for(;;)
+        {
+                if( !sNode.peek() )
+                {
+                        sNode.pop();
+                        if( sNode.isEmpty() )
+                                break;
+                        if( sNode.peek() )
+                        {
+                        //      f << "Pop'd: " << (*sNode.peek())->getText() << f.nl;
+                                Bu::String sTag = (*sNode.peek())->getText();
+                                if( sTag == "green" || sTag == "red" )
+                                {
+                                        sStyle.pop();
+                                        sNextToken += getStyle( sStyle );
+                                }
+                                sNode.peek()++;
+                                continue;
+                        }
+                }
+                if( sNode.isEmpty() )
+                {
+                        break;
+                }
+                const SmlNode *pNode = (*sNode.peek());
+                switch( pNode->getType() )
+                {
+                        case SmlNode::typeRoot:
+                                throw Bu::ExceptionBase("Invalid root.");
+
+                        case SmlNode::typeText:
+                                {
+                        //              f << "Process text node: " << pNode->getText() <<
+                        //                      f.nl;
+                                        Bu::String::const_iterator iBgn = pNode->getText().begin();
+                                        Bu::String::const_iterator iEnd = iBgn;
+                                        int iTmpLen = 0;
+                                        for(;iBgn;)
+                                        {
+                                                switch( iState )
+                                                {
+                                                        case 0: // begining of paragraph
+                                                                if( iBgn && ( *iBgn == ' ' || *iBgn == '\n' ||
+                                                                        *iBgn == '\r' || *iBgn == '\t' ) )
+                                                                {
+                                                                        iBgn++;
+                                                                }
+                                                                else
+                                                                {
+                                                                        // Here is where you would indent paragraphs
+                                                                        iNextLen += 4;
+                                                                        sNextToken += "    ";
+                                                                        iEnd = iBgn;
+                                                                        iState = 1;
+                                                                }
+                                                                break;
+
+                                                        case 1: // non-whitespace
+                                                                if( !iEnd )
+                                                                {
+                                                                        sNextToken.append( iBgn, iEnd );
+                                                                        iBgn = iEnd;
+                                                                        iNextLen += iTmpLen;
+                                                                        iTmpLen = 0;
+                                                                }
+                                                                else if( *iEnd == ' ' || *iEnd == '\n' ||
+                                                                        *iEnd == '\r' || *iEnd == '\t' )
+                                                                {
+                                                                        sNextToken.append( iBgn, iEnd );
+                                                                        iNextLen += iTmpLen;
+                                                                        iTmpLen = 0;
+                                                                        iState = 2;
+                                                                        iBgn = iEnd;
+                                                                }
+                                                                else
+                                                                {
+                                                                        iEnd++;
+                                                                        iTmpLen++;
+                                                                }
+                                                                break;
+
+                                                        case 2: // Whitespace
+                                                                if( iBgn && (*iBgn == ' ' || *iBgn == '\n' ||
+                                                                        *iBgn == '\r' || *iBgn == '\t') )
+                                                                {
+                                                                        iBgn++;
+                                                                }
+                                                                else
+                                                                {
+                                                                        iEnd = iBgn;
+                                                                        iState = 1;
+                                                                        appendToken( f, sCurLine, sNextToken,
+                                                                                iLineLen, iNextLen );
+                                                                }
+                                                                break;
+                                                }
+                                        }
+                                }
+                                break;
+
+                        case SmlNode::typeTag:
+                                if( pNode->getChildren().isEmpty() )
+                                {
+                                        if( pNode->getText() == "break" )
+                                        {
+                                                appendToken( f, sCurLine, sNextToken, iLineLen, iNextLen );
+                                                if( !sCurLine.isEmpty() )
+                                                        f << sCurLine << f.nl;
+                                                sCurLine.clear();
+                                                iLineLen = 0;
+                                                iState = 0;
+                                        }
+                                }
+                                else
+                                {
+//                                      f << "Push'd: " << pNode->getText() << f.nl;
+                                        Bu::String sTag = pNode->getText();
+                                        if( sTag == "green" )
+                                        {
+                                                sStyle.push( stGreen );
+                                        }
+                                        else if( sTag == "red" )
+                                        {
+                                                sStyle.push( stRed );
+                                        }
+                                        sNextToken += getStyle( sStyle );
+                                        sNode.push( pNode->getChildren().begin() );
+                                        continue;
+/*                                      for( SmlNode::SmlNodeList::const_iterator i =
+                                                 pNode->getChildren().begin(); i; i++ )
+                                        {
+                                                s
+                                                smlToConsole( *i, sCurLine, sNextToken, iLineLen, iState );
+                                        }
+*/                                      
+                                }
+                                break;
+                }
+                sNode.peek()++;
+        }
+        if( !sNextToken.isEmpty() )
+                appendToken( f, sCurLine, sNextToken, iLineLen, iNextLen );
+        f << sCurLine << f.nl;
+}
+