Syntax Highlighter for TEditor sub classes

[paule32]

Hello,
I toying a little bit witht the source code file source/tvision/edits.cpp, and include/tvision/editors.h.
The result is a little Syntax Highlighter for Pascal keywords.
It is a very simple parser, so it can be proof - it is nothing, just for fun Project:

I added 3 members to the TEditor class in include/tvvison/editors.h:

• std::map< std::string, TColorAttr > EditorSyntaxToken;
  the first Argument is the keyword name, and the second Argument of the map container is the BIOS color code
• TColorAttr EditorTextColor; // which is 0x1e by default (blue on yellow)
• TColorAttr EditorCommentColor; // which is for comment's one liner text color.
  Here the code, that I used in source/edits.cpp:

void
TEditor::formatLine(
    TScreenCell *DrawBuf,
    uint P,
    int Width,
    TAttrPair
    ) { 
    
    TSpan<TScreenCell> Cells(DrawBuf, Width);
    TStringView chars;
    TColorAttr  Color;
    std::string token;
    
    int  pos;
    char Ch;
    
    int X = 0;
    Color = EditorTextColor;
    token = "";
    
    while (1) {
        if (P >= bufLen || X >= Width) break;
        tokenIsComment = false;
        chars = bufChars(P);
        Color = EditorTextColor;
        Ch    = chars[0];
        
        // ----------------------------
        // parse white space's ...
        // ----------------------------
        if (Ch == ' ') {
            Color = EditorTextColor;
            while (X < Width) {
                ::setCell(Cells[X], Ch, Color);
                X++;
                P++;
                chars = bufChars(P);
                Ch = chars[0];
                if (Ch != ' ') break;
            }
        }
        
        // ----------------------------
        // parse token for Pascal DSL
        // ----------------------------
        if (((Ch >= 'A') && (Ch <= 'Z'))
        ||  ((Ch >= 'a') && (Ch <= 'z'))) {
            pos = X;
            ::setCell(Cells[X++], Ch, EditorTextColor);
            token.push_back(Ch);
            while (1) {
                if ((P >= bufLen) || (X >= Width)) break;
                P++;
                chars = bufChars(P);
                Ch = chars[0];
                if (((Ch >= 'A') && (Ch <= 'Z'))
                ||  ((Ch >= 'a') && (Ch <= 'z'))
                ||  ((Ch >= '0') && (Ch <= '9'))
                ||  (Ch == '_')) {
                    ::setCell(Cells[X++], Ch, EditorTextColor);
                    token.push_back(Ch);
                }   else break;
            }
            if (X >= Width) break;
            
            // ---------------------------------------------
            // convert token letter's to lower case letter's
            // ---------------------------------------------
            for (char &c : token)
            c = std::tolower(c);
            X = pos;
        
            auto it = EditorSyntaxToken.find(token);
            if (it != EditorSyntaxToken.end()) {
                for (char &c: token) {
                    if (X >= Width) break;
                    ::setCell(Cells[X++], c, it->second);
                }
            }   else {
                for (char &c: token) {
                    if (X >= Width) break;
                    ::setCell(Cells[X++], c, EditorTextColor);
                }
            }
            token = "";
        }
        
        // ----------------------------
        // parse comment's ...
        // ----------------------------
        if (Ch == '&') {
            Color = EditorTextColor;
            ::setCell(Cells[X], '&', Color);
            X++;
            P++;
            chars = bufChars(P);
            Ch = chars[0];
            if (P >= bufLen || X >= Width) break;
            
            // ----------------------------
            // dBase comment &&
            // ----------------------------
            if (Ch == '&') {
                tokenIsComment = true;
                ::setCell(Cells[X-1], Ch, EditorCommentColor);
                if (X < Width) {
                    do  {
                        ::setCell(Cells[X++], Ch, EditorCommentColor);
                        P++;
                        chars = bufChars(P);
                        Ch = chars[0];
                        if (Ch == '\r' || Ch == '\n') {
                            while (X < Width)
                            ::setCell(Cells[X++], ' ', Color);
                            P++;
                            break;
                        }
                    }   while (X < Width);
                    ++P;
                }   else break;
            }   else
            if (Ch == '\r' || Ch == '\n') {
                while (X < Width)
                ::setCell(Cells[X++], ' ', Color);
                P++;
                break;
            }   else {
                ::setCell(Cells[X], Ch, Color);
                X++;
                P++;
                if (P >= bufLen || X >= Width) break;
            }
        }   else
        if (Ch == '/') {
            ::setCell(Cells[X], '/', Color);
            X++;
            P++;
            chars = bufChars(P);
            Ch = chars[0];
            if (P >= bufLen || X >= Width) break;
            
            // ----------------------------
            // c++ comment
            // ----------------------------
            if (Ch == '/') {
                tokenIsComment = true;
                ::setCell(Cells[X-1], Ch, EditorCommentColor);
                if (X < Width) {
                    do  {
                        ::setCell(Cells[X++], Ch, EditorCommentColor);
                        P++;
                        chars = bufChars(P);
                        Ch = chars[0];
                        if (Ch == '\r' || Ch == '\n') {
                            while (X < Width)
                            ::setCell(Cells[X++], ' ', Color);
                            P++;
                            break;
                        }
                    }   while (X < Width);
                    ++P;
                }   else break;
            }   else
                
            // ----------------------------
            // c comment
            // ----------------------------
            if (Ch == '*') {
                tokenIsComment = true;
                Color = EditorCommentColor;
                ::setCell(Cells[X-1], '/', Color);
                ::setCell(Cells[X  ], '*', Color);
                X++;
                P++;
                while (1) {
                    if (P >= bufLen || X >= Width) break;
                    chars = bufChars(P);
                    Ch = chars[0];
                    if (Ch == '*') {
                        ::setCell(Cells[X], '*', Color);
                        X++;
                        P++;
                        if (P >= bufLen || X >= Width) break;
                        chars = bufChars(P);
                        Ch = chars[0];
                        if (Ch == '/') {
                            ::setCell(Cells[X], Ch, Color);
                            tokenIsComment = false;
                            Color = EditorTextColor;
                            X++;
                            P++;
                            break;
                        }   else
                        if (Ch == '\r' || Ch == '\n') {
                            while (X < Width)
                            ::setCell(Cells[X++], ' ', Color);
                            P++;
                            break;
                        }   else {
                            ::setCell(Cells[X], Ch, Color);
                            X++;
                            P++;
                            if (P >= bufLen || X >= Width) break;
                        }
                    }   else
                    if (Ch == '\r' || Ch == '\n') {
                        while (X < Width)
                        ::setCell(Cells[X++], ' ', EditorCommentColor);
                        P++;
                        if (P >= bufLen || X >= Width) break;
                    }   else {
                        ::setCell(Cells[X], Ch, EditorCommentColor);
                        X++;
                        P++;
                        if (P >= bufLen || X >= Width) break;
                    }
                }
            }   else {
                ::setCell(Cells[X], Ch, EditorTextColor);
                X++;
                P++;
                if (P >= bufLen || X >= Width) break;
            }
        }   else
        if (Ch == '(') {
            ::setCell(Cells[X], '(', EditorTextColor);
            X++;
            P++;
            chars = bufChars(P);
            Ch = chars[0];
            if (P >= bufLen || X >= Width) break;
            
            // ----------------------------
            // old style pascal comment
            // ----------------------------
            if (Ch == '*') {
                tokenIsComment = true;
                Color = EditorCommentColor;
                ::setCell(Cells[X-1], '(', Color);
                ::setCell(Cells[X  ], '*', Color);
                X++;
                P++;
                while (1) {
                    if (P >= bufLen || X >= Width) break;
                    chars = bufChars(P);
                    Ch = chars[0];
                    if (Ch == '*') {
                        ::setCell(Cells[X], '*', Color);
                        X++;
                        P++;
                        if (P >= bufLen || X >= Width) break;
                        chars = bufChars(P);
                        Ch = chars[0];
                        if (Ch == ')') {
                            ::setCell(Cells[X], Ch, Color);
                            tokenIsComment = false;
                            Color = EditorTextColor;
                            X++;
                            P++;
                            break;
                        }   else
                        if (Ch == '\r' || Ch == '\n') {
                            while (X < Width)
                            ::setCell(Cells[X++], ' ', Color);
                            P++;
                            break;
                        }   else {
                            ::setCell(Cells[X], Ch, Color);
                            X++;
                            P++;
                            if (P >= bufLen || X >= Width) break;
                        }
                    }   else
                    if (Ch == '\r' || Ch == '\n') {
                        while (X < Width)
                        ::setCell(Cells[X++], ' ', EditorCommentColor);
                        P++;
                        if (P >= bufLen || X >= Width) break;
                    }   else {
                        ::setCell(Cells[X], Ch, EditorCommentColor);
                        X++;
                        P++;
                        if (P >= bufLen || X >= Width) break;
                    }
                }
            }   else {
                ::setCell(Cells[X], Ch, EditorTextColor);
                X++;
                P++;
                if (P >= bufLen || X >= Width) break;
            }
        }   else
        if (Ch == '*') {
            if (tokenIsComment)
            Color = EditorCommentColor; else
            Color = EditorTextColor;
            ::setCell(Cells[X], '*', Color);
            X++;
            P++;
            if (P >= bufLen || X >= Width) break;
            chars = bufChars(P);
            Ch = chars[0];
            
            // ----------------------------
            // dBase comment **
            // ----------------------------
            if (Ch == '*') {
                tokenIsComment = true;
                ::setCell(Cells[X-1], Ch, EditorCommentColor);
                if (X < Width) {
                    do  {
                        ::setCell(Cells[X++], Ch, EditorCommentColor);
                        P++;
                        chars = bufChars(P);
                        Ch = chars[0];
                        if (Ch == '\r' || Ch == '\n') {
                            while (X < Width)
                            ::setCell(Cells[X++], ' ', Color);
                            P++;
                            break;
                        }
                    }   while (X < Width);
                    ++P;
                }   else break;
            }   else
                
            // ----------------------------
            // end of c comment
            // ----------------------------
            if (Ch == '/') {
                tokenIsComment = false;
                Color = EditorTextColor;
                ::setCell(Cells[X], '/', EditorCommentColor);
                X++;
                P++;
                if (P >= bufLen || X >= Width) break;
            }   else
                
            // ----------------------------
            // end of pascal comment
            // ----------------------------
            if (Ch == ')') {
                tokenIsComment = false;
                Color = EditorTextColor;
                ::setCell(Cells[X], ')', EditorCommentColor);
                X++;
                P++;
                if (P >= bufLen || X >= Width) break;
            }   else {
                Color = EditorCommentColor;
                ::setCell(Cells[X], '*', EditorCommentColor);
                X++;
                P++;
                if (P >= bufLen || X >= Width) break;
            }
        }   else
        if (Ch == '\r' || Ch == '\n') {
            tokenIsComment = false;
            //Color = EditorTextColor;
            //::setCell(Cells[X-1], ' ', Color);
            while (X < Width)
            ::setCell(Cells[X++], ' ', Color);
            P++;
            break;
        }   else
        if (Ch == '\t') {
            if (tokenIsComment)
            Color = EditorCommentColor; else
            Color = EditorTextColor;
            if (X < Width) {
                do {
                    ::setCell(Cells[X++], ' ', Color);
                } while (X%8 != 0 && X < Width);
                ++P;
            }   else break;
        }   else {
            if (tokenIsComment)
            Color = EditorCommentColor; else
            Color = EditorTextColor;
            if (!formatCell(Cells, (uint&) X, chars, P, Color))
            break;
        }
    }
    while (X < Width)
    ::setCell(Cells[X++], ' ', Color);
}

Here is a example on using the features:

class MyEditorChild: public TEditor {
public:
    MyEditorChild(
    const TRect& bounds,
    TScrollBar * hScrollBar,
    TScrollBar * vScrollBar,
    TIndicator * indicator,
    TStringView  filename):
    TEditor( bounds,hScrollBar,vScrollBar,indicator,999999999),
    owner(parent) {
    std::map< std::string, TColorAttr > PascalToken =
    {
        { "program", 0x2f },    // 0x2f = green on white
        { "begin",   0x2f },
        { "end",     0x2f }
    };
    EditorSyntaxToken  = PascalToken;   // use Pascal Highlighter
    
    EditorTextColor    = 0x20;          // green on black
    EditorCommentColor = 0x21;          // green on blze
}

Let me know, if this helpfull .
Thanks, paule32