WebSVN – Kolibri OS – Diff – /programs/develop/cedit/SRC/Text.ob07


﻿(*
    Copyright 2021 Anton Krotov
 
    This file is part of CEdit.
 
    CEdit is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
 
    CEdit is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with CEdit. If not, see .
*)
 
MODULE Text;
 
IMPORT
    List, Lines,
    G := Graph,
    U := Utils,
    RW, Search,
    E := Encodings,
    CB := Clipboard,
    K := KolibriOS,
    ChangeLog, File,
    Lang := Languages;
 
 
CONST
 
    SPACE = Lines.SPACE;
    TAB = Lines.TAB;
    TAB1 = Lines.TAB1;
    lenEOL = CB.lenEOL;
 
    mark_width = 2;
    pad_left = mark_width + 3;
    pad_top = 0;
    inter = 2;
 
 
TYPE
 
    tPoint = RECORD
        X, Y: INTEGER
    END;
 
    pPoint = POINTER TO tPoint;
 
    tString* = ARRAY 1000 OF WCHAR;
 
    tLine = Lines.tLine;
 
    tGuard = POINTER TO RECORD (ChangeLog.tGuard)
        selected: BOOLEAN;
        cursor, select2, scroll: tPoint;
        CurX: INTEGER
    END;
 
    tText* = POINTER TO RECORD (List.tList)
        cursor, select, select2: pPoint;
        scroll: tPoint;
        CurX: INTEGER;
        modified*: BOOLEAN;
 
        edition*: tGuard;
        comments, numbers*, guard,
        search, cs, whole: BOOLEAN;
        curLine: tLine;
        fileName*: RW.tFileName;
        lang*: INTEGER;
        enc*: INTEGER;
        eol*: INTEGER;
        table: Search.IdxTable;
        foundList: List.tList;
        idxData: Search.tBuffer;
        foundSel: INTEGER;
        searchText: tString;
        chLog*: ChangeLog.tLog;
        maxLength*: INTEGER
    END;
 
    tProcedure = PROCEDURE;
 
 
VAR
 
    pdelete: PROCEDURE (text: tText);
    ShowCursor: PROCEDURE;
 
    colors*: RECORD
                text, back, seltext, selback, modified, saved, curline, numtext, numback: INTEGER;
                comment, string, num, delim, key1, key2, key3: INTEGER
             END;
    canvas: G.tCanvas;
    drawCursor: BOOLEAN;
    padding: RECORD left, top: INTEGER END;
    size, textsize: tPoint;
    charWidth, charHeight: INTEGER;
 
 
PROCEDURE setName* (text: tText; name: RW.tFileName);
VAR
    ext: RW.tFileName;
BEGIN
    text.fileName := name;
    U.getFileName(text.fileName, ext, ".");
    U.upcase(ext);
    IF ext = "OB07" THEN
        text.lang := Lang.langOberon
    ELSIF (ext = "C") OR (ext = "H") OR (ext = "CPP") THEN
        text.lang := Lang.langC
    ELSIF (ext = "PAS") OR (ext = "PP") THEN
        text.lang := Lang.langPascal
    ELSIF ext = "ASM" THEN
        text.lang := Lang.langFasm
    ELSIF ext = "LUA" THEN
        text.lang := Lang.langLua
    ELSIF ext = "INI" THEN
        text.lang := Lang.langIni
    ELSIF ext = "JSON" THEN
        text.lang := Lang.langJSON
    ELSE
        text.lang := Lang.langText
    END
END setName;
 
 
PROCEDURE setLang* (text: tText; lang: INTEGER);
BEGIN
    text.lang := lang;
    text.comments := TRUE
END setLang;
 
 
PROCEDURE getPos* (text: tText; VAR x, y: INTEGER);
BEGIN
    x := text.cursor.X + 1;
    y := text.cursor.Y + 1
END getPos;
 
 
PROCEDURE getScroll* (text: tText; VAR x, y: INTEGER);
BEGIN
    x := text.scroll.X;
    y := text.scroll.Y
END getScroll;
 
 
PROCEDURE getTextSize* (VAR x, y: INTEGER);
BEGIN
    x := textsize.X;
    y := textsize.Y
END getTextSize;
 
 
PROCEDURE getTextRect* (VAR left, top, rigth, bottom: INTEGER);
BEGIN
    left := padding.left - 1;
    top := padding.top - 1;
    rigth := size.X - 1;
    bottom := top + size.Y - 1;
END getTextRect;
 
 
PROCEDURE toggleNumbers* (text: tText);
BEGIN
    text.numbers := ~text.numbers
END toggleNumbers;
 
 
PROCEDURE toggleCursor*;
BEGIN
    drawCursor := ~drawCursor
END toggleCursor;
 
 
PROCEDURE showCursor*;
BEGIN
	drawCursor := TRUE
END showCursor;
 
 
PROCEDURE hideCursor*;
BEGIN
	drawCursor := FALSE
END hideCursor;
 
 
PROCEDURE getChar (line: tLine; i: INTEGER): WCHAR;
VAR
    res: WCHAR;
BEGIN
    IF i >= line.length THEN
        res := 0X
    ELSE
        res := Lines.getChar(line, i)
    END
    RETURN res
END getChar;
 
 
PROCEDURE getString (src: tLine; pos, cnt: INTEGER; VAR dst: ARRAY OF WCHAR): INTEGER;
VAR
    i: INTEGER;
BEGIN
    i := 0;
    WHILE (pos < src.length) & (cnt > 0) DO
        IF i < LEN(dst) - 1 THEN
            dst[i] := getChar(src, pos);
            INC(i)
        END;
        INC(pos);
        DEC(cnt)
    END;
    dst[i] := 0X
    RETURN i
END getString;
 
 
PROCEDURE NextLine (VAR line: tLine);
BEGIN
    line := line.next(tLine)
END NextLine;
 
 
PROCEDURE PrevLine (VAR line: tLine);
BEGIN
    line := line.prev(tLine)
END PrevLine;
 
 
PROCEDURE SetColor (textColor, backColor: INTEGER);
BEGIN
    G.SetTextColor(canvas, textColor);
    G.SetBkColor(canvas, backColor)
END SetColor;
 
 
PROCEDURE ProcessComments (line: tLine; VAR depth, pos: INTEGER; minDepth, n: INTEGER; lang: INTEGER);
VAR
    cond: INTEGER;
BEGIN
    cond := 0;
    WHILE (pos <= n) & (depth > minDepth) DO
        Lang.comments(line, depth, cond, pos, n, lang);
        INC(pos)
    END;
    DEC(pos)
END ProcessComments;
 
 
PROCEDURE Comments (text: tText);
VAR
    line: tLine;
    i: INTEGER;
BEGIN
    line := text.first(tLine);
    line.cin := 0;
    line.cout := 0;
    i := 0;
    ProcessComments(line, line.cout, i, -1, line.length - 1, text.lang);
    NextLine(line);
    WHILE line # NIL DO
        line.cin := line.prev(tLine).cout;
        line.cout := line.cin;
        i := 0;
        ProcessComments(line, line.cout, i, -1, line.length - 1, text.lang);
        NextLine(line)
    END;
    text.comments := FALSE
END Comments;
 
 
PROCEDURE parse (text: tText; line: tLine; y: INTEGER; backColor: INTEGER; lang: INTEGER);
VAR
    c: WCHAR;
    i, n, k: INTEGER;
    cond, depth: INTEGER;
    color: INTEGER;
    hex: BOOLEAN;
    isDgt: PROCEDURE (c: WCHAR): BOOLEAN;
 
 
    PROCEDURE PrintLex (text: tText; line: tLine; lexStart, lexEnd: INTEGER; y: INTEGER; color, backColor: INTEGER);
    VAR
        lexLen: INTEGER;
    BEGIN
        SetColor(color, backColor);
        lexLen := MAX(MIN(line.length - lexStart, lexEnd - lexStart + 1), 0);
        G.TextOut(canvas, padding.left + (lexStart - text.scroll.X) * charWidth, y, Lines.getPChar(line, lexStart), lexLen)
    END PrintLex;
 
 
    PROCEDURE PrintComment (text: tText; line: tLine; VAR depth, i: INTEGER; y: INTEGER; backColor: INTEGER);
    VAR
        lexStart: INTEGER;
        color: INTEGER;
    BEGIN
        IF (text.lang = Lang.langLua) & ~ODD(depth) THEN
            color := colors.string
        ELSIF (text.lang = Lang.langIni) & (depth = 1) THEN
            color := colors.key2
        ELSIF (text.lang = Lang.langPascal) & (depth = 3) THEN
            color := colors.key3
        ELSE
            color := colors.comment
        END;
        lexStart := MAX(i - 2, 0);
        ProcessComments(line, depth, i, 0, line.length - 1, text.lang);
        PrintLex(text, line, lexStart, i, y, color, backColor)
    END PrintComment;
 
 
    PROCEDURE cap (c: WCHAR): WCHAR;
    BEGIN
        IF U.cap(c) THEN END
        RETURN c
    END cap;
 
 
    PROCEDURE UL (c: WCHAR): BOOLEAN;
        RETURN (cap(c) = "U") OR (cap(c) = "L")
    END UL;
 
 
    PROCEDURE FL (c: WCHAR): BOOLEAN;
        RETURN (cap(c) = "F") OR (cap(c) = "L")
    END FL;
 
 
    PROCEDURE isFASMdelim (c: WCHAR): BOOLEAN;
    VAR
        s: ARRAY 19 OF WCHAR;
        i: INTEGER;
    BEGIN
        s := "{}[]<>:,()&*/|+-\#";
        i := LEN(s) - 2;
        WHILE (i >= 0) & (c # s[i]) DO
            DEC(i)
        END
        RETURN i >= 0
    END isFASMdelim;
 
 
    PROCEDURE ident (text: tText; VAR i: INTEGER; first, y: INTEGER; line: tLine; backColor: INTEGER; cs: BOOLEAN);
    VAR
        c: WCHAR;
        lexLen: INTEGER;
        s: ARRAY 32 OF WCHAR;
        color: INTEGER;
    BEGIN
        c := getChar(line, i);
        WHILE U.isLetter(c) OR (c = "_") OR U.isDigit(c) DO
            INC(i);
            c := getChar(line, i);
        END;
        DEC(i);
        lexLen := getString(line, first, i - first + 1, s);
        IF ~cs THEN
            U.upcase16(s)
        END;
        IF Lang.isKey(s, text.lang, 1) THEN
            color := colors.key1
        ELSIF Lang.isKey(s, text.lang, 2) THEN
            color := colors.key2
        ELSIF Lang.isKey(s, text.lang, 3) THEN
            color := colors.key3
        ELSE
            color := colors.text
        END;
        IF color # colors.text THEN
            PrintLex(text, line, first, i, y, color, backColor)
        END
    END ident;
 
 
    PROCEDURE String (text: tText; line: tLine; VAR i: INTEGER; y: INTEGER; backColor: INTEGER);
    VAR
        k: INTEGER;
    BEGIN
        k := i;
        Lang.SkipString(line, i, line.length - 1);
        PrintLex(text, line, k, i, y, colors.string, backColor)
    END String;
 
 
BEGIN
    depth := line.cin;
    n := line.length - 1;
    i := 0;
    IF (depth > 0) & (n >= 0) THEN
        PrintComment(text, line, depth, i, y, backColor)
    END;
    cond := 0;
    WHILE i <= n DO
        c := getChar(line, i);
 
        IF lang = Lang.langFasm THEN
 
            IF c = ";" THEN
                PrintLex(text, line, i, n, y, colors.comment, backColor);
                i := n
            ELSIF (c = "'") OR (c = '"') THEN
                String(text, line, i, y, backColor)
            ELSIF (U.isLetter(c) OR (c = "_")) THEN
                ident(text, i, i, y, line, backColor, Lang.isCS(lang))
            ELSIF isFASMdelim(c) THEN
                PrintLex(text, line, i, i, y, colors.delim, backColor)
            ELSIF U.isDigit(c) THEN
                hex := FALSE;
                k := i;
                INC(i);
                c := getChar(line, i);
                IF (cap(c) = "X") & (getChar(line, i - 1) = "0") THEN
                    INC(i);
                    hex := TRUE
                END;
 
                WHILE U.isHex(cap(getChar(line, i))) DO
                    INC(i)
                END;
 
                IF (cap(getChar(line, i)) = "H") & ~hex THEN
                    INC(i)
                END;
 
                DEC(i);
                PrintLex(text, line, k, i, y, colors.num, backColor)
            END
 
        ELSIF (lang = Lang.langC) OR (lang = Lang.langJSON) THEN
 
        IF depth = 0 THEN
            IF c = "/" THEN
                IF cond = 0 THEN
                    cond := 1
                ELSE
                    PrintLex(text, line, i - 1, n, y, colors.comment, backColor);
                    cond := 0;
                    i := n
                END
            ELSIF (c = "*") & (cond = 1) THEN
                depth := 1;
                INC(i);
                PrintComment(text, line, depth, i, y, backColor);
                cond := 0
            ELSIF U.isLetter(c) OR (c = "_") OR (c = "'") OR (c = '"') THEN
            	k := i;
            	IF (c = "'") OR (c = '"') THEN
            		String(text, line, i, y, backColor);
            	ELSE
            		ident(text, i, i - ORD((lang = Lang.langC) & (i > 0) & (getChar(line, i - 1) = "#")), y, line, backColor, Lang.isCS(lang))
            	END;
                IF lang = Lang.langJSON THEN
	                WHILE Lines.isSpace(getChar(line, i + 1)) DO
	                	INC(i)
	                END;
	                IF getChar(line, i + 1) = ":" THEN
	                	PrintLex(text, line, k, i, y, colors.key1, backColor)
	                END
                END;
                cond := 0
            ELSIF U.isDigit(c) THEN
                k := i;
                INC(i);
                c := getChar(line, i);
                IF c = "." THEN
                    DEC(i);
                    c := getChar(line, i)
                END;
                IF (cap(c) = "X") & (getChar(line, i - 1) = "0") THEN
                    REPEAT
                        INC(i);
                        c := getChar(line, i)
                    UNTIL ~U.isHex(cap(c));
                    IF UL(c) THEN
                        INC(i)
                    END
                ELSIF UL(c) THEN
                    INC(i)
                ELSIF U.isDigit(c) THEN
                    REPEAT
                        INC(i)
                    UNTIL ~U.isDigit(getChar(line, i));
                    c := getChar(line, i);
                    IF UL(c) THEN
                        INC(i)
                    ELSIF c = "." THEN
                        INC(i);
                        WHILE U.isDigit(getChar(line, i)) DO
                            INC(i)
                        END;
                        c := getChar(line, i);
                        IF cap(c) = "E" THEN
                            INC(i);
                            c := getChar(line, i);
                            IF (c = "+") OR (c = "-") THEN
                                INC(i)
                            END;
                            IF U.isDigit(getChar(line, i)) THEN
                                WHILE U.isDigit(getChar(line, i)) DO
                                    INC(i)
                                END;
                                c := getChar(line, i);
                                IF FL(c) THEN
                                    INC(i)
                                END
                            END
                        ELSIF FL(c) THEN
                            INC(i)
                        END
                    END
                END;
                DEC(i);
                PrintLex(text, line, k, i, y, colors.num, backColor);
                cond := 0
            ELSE
                cond := 0
            END
        ELSIF depth = 1 THEN
            IF c = "*" THEN
                cond := 1
            ELSIF (c = "/") & (cond = 1) THEN
                cond := 0;
                depth := 0
            ELSE
                cond := 0
            END
        END;
 
        ELSIF lang = Lang.langOberon THEN
 
        IF (depth = 0) & (c = "/") THEN
            IF cond = 3 THEN
                PrintLex(text, line, i - 1, n, y, colors.comment, backColor);
                cond := 0;
                i := n
            ELSE
                cond := 3
            END
        ELSIF (depth = 0) & ((c = "'") OR (c = '"')) THEN
            String(text, line, i, y, backColor);
            cond := 0
        ELSIF (depth = 0) & U.isDigit(c) THEN
            color := colors.num;
            k := i;
            INC(i);
            WHILE U.isHex(getChar(line, i)) DO
                INC(i)
            END;
            IF i <= n THEN
                IF getChar(line, i) = "." THEN
                    INC(i);
                    IF getChar(line, i) = "." THEN
                        DEC(i)
                    END;
                    WHILE U.isDigit(getChar(line, i)) DO
                        INC(i)
                    END;
                    IF getChar(line, i) = "E" THEN
                        INC(i);
                        IF (getChar(line, i) = "+") OR (getChar(line, i) = "-") THEN
                            INC(i)
                        END;
                        WHILE U.isDigit(getChar(line, i)) DO
                            INC(i)
                        END
                    END
                ELSIF getChar(line, i) = "H" THEN
                    INC(i)
                ELSIF getChar(line, i) = "X" THEN
                    color := colors.string;
                    INC(i)
                END
            END;
            DEC(i);
            PrintLex(text, line, k, i, y, color, backColor);
            cond := 0
        ELSIF (depth = 0) & (U.isLetter(c) OR (c = "_")) THEN
            ident(text, i, i, y, line, backColor, Lang.isCS(lang));
            cond := 0
        ELSIF c = "(" THEN
            cond := 1
        ELSIF c = "*" THEN
            IF cond = 1 THEN
                INC(depth);
                INC(i);
                PrintComment(text, line, depth, i, y, backColor);
                cond := 0
            ELSE
                cond := 2
            END
        ELSIF c = ")" THEN
            IF cond = 2 THEN
                IF depth > 0 THEN
                    DEC(depth)
                END
            END;
            cond := 0
        ELSE
            cond := 0
        END
 
        ELSIF lang = Lang.langLua THEN
 
        IF depth = 0 THEN
            IF c = "-" THEN
                IF cond = 1 THEN
                    IF Lang.LuaLong(line, i + 1) >= 0 THEN
                        depth := Lang.LuaLong(line, i + 1)*2 + 1;
                        INC(i);
                        PrintComment(text, line, depth, i, y, backColor)
                    ELSE
                        PrintLex(text, line, i - 1, n, y, colors.comment, backColor);
                        i := n
                    END;
                    cond := 0
                ELSE
                    cond := 1
                END
            ELSIF c = "[" THEN
                cond := 0;
                k := Lang.LuaLong(line, i);
                IF k >= 0 THEN
                    depth := (k + 1)*2;
                    INC(i, 2);
                    PrintComment(text, line, depth, i, y, backColor);
                    cond := 0
                END
            ELSIF (c = "'") OR (c = '"') THEN
                String(text, line, i, y, backColor);
                cond := 0
            ELSIF U.isDigit(c) THEN
                k := i;
                IF (c = "0") & (cap(getChar(line, i + 1)) = "X") THEN
                    isDgt := U.isHex;
                    hex := TRUE;
                    INC(i, 2)
                ELSE
                    isDgt := U.isDigit;
                    hex := FALSE
                END;
                WHILE isDgt(cap(getChar(line, i))) DO
                    INC(i)
                END;
                IF getChar(line, i) = "." THEN
                    INC(i);
                    IF getChar(line, i) = "." THEN
                        DEC(i)
                    END;
                    WHILE isDgt(cap(getChar(line, i))) DO
                        INC(i)
                    END
                END;
                IF (cap(getChar(line, i)) = "E") OR hex & (cap(getChar(line, i)) = "P") THEN
                    INC(i);
                    IF (getChar(line, i) = "-") OR (getChar(line, i) = "+") THEN
                        INC(i)
                    END;
                    WHILE isDgt(cap(getChar(line, i))) DO
                        INC(i)
                    END
                END;
                DEC(i);
                PrintLex(text, line, k, i, y, colors.num, backColor);
                cond := 0
            ELSIF U.isLetter(c) OR (c = "_") THEN
                ident(text, i, i, y, line, backColor, Lang.isCS(lang));
                cond := 0
            ELSE
                cond := 0
            END
 
        ELSIF depth > 0 THEN
            IF (cond = 0) & (c = "]") THEN
                cond := 1
            ELSIF (cond >= 1) & (c = "=") THEN
                INC(cond)
            ELSIF (cond >= 1) & (c = "]") & (cond * 2 - depth MOD 2 = depth) THEN
                depth := 0;
                cond := 0
            ELSE
                cond := 0
            END
        END
 
        ELSIF lang = Lang.langPascal THEN
 
        IF depth = 0 THEN
            IF c = "(" THEN
                cond := 1
            ELSIF (c = "*") & (cond = 1) THEN
                depth := 2;
                INC(i);
                PrintComment(text, line, depth, i, y, backColor);
                cond := 0
            ELSIF c = "/" THEN
                IF cond = 2 THEN
                    PrintLex(text, line, i - 1, n, y, colors.comment, backColor);
                    cond := 0;
                    i := n
                ELSE
                    cond := 2
                END
            ELSIF c = "'" THEN
                String(text, line, i, y, backColor);
                cond := 0
            ELSIF c = "{" THEN
                IF getChar(line, i + 1) = "$" THEN
                    depth := 3
                ELSE
                    depth := 1
                END;
                INC(i, 2);
                PrintComment(text, line, depth, i, y, backColor);
                cond := 0
            ELSIF c = "#" THEN
                k := i;
                INC(i);
                WHILE U.isDigit(getChar(line, i)) DO
                    INC(i)
                END;
                DEC(i);
                PrintLex(text, line, k, i, y, colors.string, backColor);
                cond := 0
            ELSIF c = "$" THEN
                IF (i > 0 ) & (getChar(line, i - 1) = "#") THEN
                    color := colors.string
                ELSE
                    color := colors.num
                END;
                k := i;
                INC(i);
                WHILE U.isHex(cap(getChar(line, i))) DO
                    INC(i)
                END;
                DEC(i);
                PrintLex(text, line, k, i, y, color, backColor);
                cond := 0
            ELSIF U.isDigit(c) THEN
                k := i;
                WHILE U.isDigit(getChar(line, i)) DO
                    INC(i)
                END;
                IF getChar(line, i) = "." THEN
                    INC(i);
                    IF getChar(line, i) = "." THEN
                        DEC(i)
                    END;
                    WHILE U.isDigit(getChar(line, i)) DO
                        INC(i)
                    END;
                    IF cap(getChar(line, i)) = "E" THEN
                        INC(i);
                        IF (getChar(line, i) = "-") OR (getChar(line, i) = "+") THEN
                            INC(i)
                        END;
                        WHILE U.isDigit(getChar(line, i)) DO
                            INC(i)
                        END
                    END
                END;
                DEC(i);
                PrintLex(text, line, k, i, y, colors.num, backColor);
                cond := 0
            ELSIF (U.isLetter(c) OR (c = "_")) THEN
                ident(text, i, i, y, line, backColor, Lang.isCS(lang));
                cond := 0
            ELSE
                cond := 0
            END
        ELSIF depth IN {1, 3} THEN
            IF c = "}" THEN
                depth := 0
            END
        ELSIF depth = 2 THEN
            IF c = "*" THEN
                cond := 1
            ELSIF (c = ")") & (cond = 1) THEN
                depth := 0;
                cond := 0
            ELSE
                cond := 0
            END
        END
 
        ELSIF lang = Lang.langIni THEN
 
        IF depth = 0 THEN
            IF (c = ";") OR (c = "#") THEN
                PrintLex(text, line, i, n, y, colors.comment, backColor);
                i := n
            ELSIF c = '"' THEN
                String(text, line, i, y, backColor)
            ELSIF c = "=" THEN
                PrintLex(text, line, i, i, y, colors.delim, backColor)
            ELSIF c = "[" THEN
                depth := 1;
                INC(i, 2);
                PrintComment(text, line, depth, i, y, backColor)
            ELSIF U.isDigit(c) THEN
                k := i;
                WHILE U.isDigit(getChar(line, i)) DO
                    INC(i)
                END;
                DEC(i);
                PrintLex(text, line, k, i, y, colors.num, backColor)
            ELSIF (U.isLetter(c) OR (c = "_")) THEN
                ident(text, i, i, y, line, backColor, Lang.isCS(lang))
            END
        ELSIF depth = 1 THEN
            IF c = "]" THEN
                depth := 0
            END
        END
 
        END;
        INC(i)
    END
END parse;
 
 
PROCEDURE leadingSpaces (line: tLine): INTEGER;
VAR
    i: INTEGER;
BEGIN
    i := 0;
    WHILE Lines.isSpace(getChar(line, i)) DO
        INC(i)
    END
    RETURN i
END leadingSpaces;
 
 
PROCEDURE plain (text: tText; eot: BOOLEAN): CB.tBuffer;
VAR
    buf: CB.tBuffer;
    size: INTEGER;
    line: tLine;
    EOT: ARRAY 2 OF WCHAR;
BEGIN
    size := 0;
    line := text.first(tLine);
    WHILE line # NIL DO
        line.pos := size;
        INC(size, line.length);
        NextLine(line);
        IF line # NIL THEN
            INC(size, CB.lenEOL)
        END
    END;
    IF eot THEN
        INC(size, 2)
    END;
    buf := CB.create(size);
    line := text.first(tLine);
    WHILE line # NIL DO
        CB.append(buf, line, 0, line.length - 1);
        NextLine(line);
        IF line # NIL THEN
            CB.eol(buf)
        END
    END;
    IF eot THEN
        EOT[0] := 0X;
        EOT[1] := 0X;
        CB.appends(buf, EOT, 0, 1)
    END
    RETURN buf
END plain;
 
 
PROCEDURE search* (text: tText; s: ARRAY OF WCHAR; cs, whole: BOOLEAN): BOOLEAN;
VAR
    pos: List.tItem;
    res: BOOLEAN;
    plainText: Search.tBuffer;
BEGIN
    plainText := NIL;
    WHILE text.foundList.count # 0 DO
        pos := List.pop(text.foundList);
        DISPOSE(pos)
    END;
    text.whole := whole;
    text.cs := cs;
    text.searchText := s;
    IF ~cs THEN
        U.upcase16(text.searchText)
    END;
    IF text.searchText # "" THEN
        plainText := plain(text, TRUE);
        text.idxData := Search.index(plainText, text.table, cs);
        Search.find(plainText, text.table, text.searchText, whole, text.foundList);
        res := text.foundList.count > 0
    ELSE
        res := TRUE
    END;
    CB.destroy(plainText);
    CB.destroy(text.idxData);
    text.search := FALSE;
    text.foundSel := 0
    RETURN res
END search;
 
 
PROCEDURE modify (text: tText);
BEGIN
    text.modified := TRUE;
    text.comments := TRUE;
    text.search := TRUE;
    text.guard := TRUE
END modify;
 
 
PROCEDURE DelLine (text: tText; line: tLine);
BEGIN
    List._delete(text, line);
    Lines.destroy(line);
    modify(text)
END DelLine;
 
 
PROCEDURE setSelect (text: tText);
BEGIN
    IF text.select = text.cursor THEN
        text.select2^ := text.cursor^;
        text.select := text.select2
    END
END setSelect;
 
 
PROCEDURE resetSelect* (text: tText);
BEGIN
    text.select := text.cursor
END resetSelect;
 
 
PROCEDURE getLine (text: tText; n: INTEGER): tLine;
VAR
    item: List.tItem;
BEGIN
    item := List.getItem(text, n);
    RETURN item(tLine)
END getLine;
 
 
PROCEDURE SetPos* (text: tText; x, y: INTEGER);
VAR
    deltaY, n, L, R: INTEGER;
    cursor: pPoint;
    c: WCHAR;
   (* trimLength: INTEGER; *)
BEGIN
    cursor := text.cursor;
    y := MIN(MAX(y, 0), text.count - 1);
    deltaY := y - cursor.Y;
    IF deltaY # 0 THEN
        cursor.Y := y;
(*        trimLength := Lines.trimLength(text.curLine);
        IF text.curLine.length # trimLength THEN
            Lines.setChar(text.curLine, trimLength, 0X);
            text.curLine.length := trimLength
        END;*)
        IF deltaY = 1 THEN
            NextLine(text.curLine)
        ELSIF deltaY = -1 THEN
            PrevLine(text.curLine)
        ELSE
            text.curLine := getLine(text, y)
        END
    END;
    cursor.X := MIN(MAX(x, 0), text.curLine.length);
    c := getChar(text.curLine, cursor.X);
    IF c = TAB1 THEN
        n := cursor.X;
        WHILE getChar(text.curLine, n) = TAB1 DO
            INC(n)
        END;
        R := n - cursor.X;
        n := cursor.X;
        WHILE getChar(text.curLine, n) # TAB DO
            DEC(n)
        END;
        L := cursor.X - n;
        IF L < R THEN
            DEC(cursor.X, L)
        ELSE
            INC(cursor.X, R)
        END
    END;
    IF text.scroll.Y > cursor.Y THEN
        text.scroll.Y := cursor.Y
    ELSIF text.scroll.Y + textsize.Y <= cursor.Y THEN
        text.scroll.Y := cursor.Y - textsize.Y + 1
    END;
    IF text.scroll.X > cursor.X THEN
        text.scroll.X := cursor.X
    ELSIF text.scroll.X + textsize.X <= cursor.X THEN
        text.scroll.X := cursor.X - textsize.X + 1
    END;
    IF (text.select.Y = cursor.Y) & (text.select.X > text.curLine.length) THEN
        text.select.X := text.curLine.length
    END;
    setSelect(text);
    text.foundSel := 0;
    ShowCursor;
    text.CurX := -1
END SetPos;
 
 
PROCEDURE getSelect (text: tText; VAR selBeg, selEnd: tPoint);
BEGIN
    selBeg := text.cursor^;
    selEnd := text.select^;
    IF (selBeg.Y > selEnd.Y) OR (selBeg.Y = selEnd.Y) & (selBeg.X > selEnd.X) THEN
        selBeg := text.select^;
        selEnd := text.cursor^
    END
END getSelect;
 
 
PROCEDURE selected* (text: tText): BOOLEAN;
    RETURN (text.cursor.X # text.select.X) OR (text.cursor.Y # text.select.Y)
END selected;
 
 
PROCEDURE delSelect (text: tText);
VAR
    selBeg, selEnd: tPoint;
    line, last, cur: tLine;
BEGIN
    getSelect(text, selBeg, selEnd);
    IF (selBeg.Y = selEnd.Y) & (selBeg.X < selEnd.X) THEN
        line := text.curLine;
        Lines.delCharN(line, selBeg.X, selEnd.X - selBeg.X);
        Lines.modify(line);
        text.cursor^ := selBeg;
        resetSelect(text);
        SetPos(text, text.cursor.X, text.cursor.Y);
        modify(text)
    ELSIF selBeg.Y < selEnd.Y THEN
        SetPos(text, selBeg.X, selBeg.Y);
        line := text.curLine;
        Lines.delCharN(line, selBeg.X, line.length - selBeg.X);
        last := getLine(text, selEnd.Y);
        Lines.delCharN(last, 0, selEnd.X);
        cur := line.next(tLine);
        WHILE cur # last DO
            DelLine(text, cur);
            cur := line.next(tLine)
        END;
        resetSelect(text);
        SetPos(text, text.cursor.X, text.cursor.Y);
        pdelete(text);
        modify(text)
    END;
    resetSelect(text)
END delSelect;
 
 
PROCEDURE delete (text: tText);
VAR
    i, n: INTEGER;
    nextLine, curLine: tLine;
BEGIN
    IF selected(text) THEN
        delSelect(text)
    ELSE
        i := text.cursor.X;
        curLine := text.curLine;
        IF i < curLine.length THEN
            n := i;
            INC(i);
            IF getChar(curLine, i - 1) = TAB THEN
                WHILE getChar(curLine, i) = TAB1 DO
                    INC(i)
                END
            END;
            Lines.delCharN(curLine, n, i - n);
            Lines.modify(curLine);
            modify(text)
        ELSE
            nextLine := curLine.next(tLine);
            IF nextLine # NIL THEN
                Lines.insert2(curLine, i, nextLine);
                DelLine(text, nextLine);
                Lines.modify(curLine);
                modify(text)
            END
        END
    END;
    setSelect(text)
END delete;
 
 
PROCEDURE move (text: tText; d: INTEGER);
VAR
    pos: INTEGER;
BEGIN
    pos := text.cursor.X + d;
    WHILE getChar(text.curLine, pos) = TAB1 DO
        INC(pos, d)
    END;
    SetPos(text, pos, text.cursor.Y)
END move;
 
 
PROCEDURE BkSpace (text: tText);
VAR
    i, k, n: INTEGER;
    curLine, line, line2: tLine;
BEGIN
    IF selected(text) THEN
        delSelect(text)
    ELSE
        resetSelect(text);
        curLine := text.curLine;
        IF text.cursor.X > 0 THEN
            i := text.cursor.X;
            n := leadingSpaces(curLine);
            modify(text);
            IF n < i THEN
                move(text, -1);
                delete(text)
            ELSE
                n := i;
                line := curLine.prev(tLine);
                line2 := line;
                k := n;
                WHILE (line # NIL) & (k >= n) DO
                    IF Lines.trimLength(line) # 0 THEN
                        k := leadingSpaces(line);
                        line2 := line;
                    END;
                    PrevLine(line)
                END;
                IF k >= n THEN
                    k := 0
                END;
                n := k;
                Lines.delCharN(curLine, 0, i);
                Lines.insert3(curLine, 0, k);
                WHILE k > 0 DO
                    Lines.setChar(curLine, k - 1, getChar(line2, k - 1));
                    DEC(k)
                END;
                Lines.modify(curLine);
                SetPos(text, n, text.cursor.Y)
            END
        ELSE
            PrevLine(curLine);
            IF curLine # NIL THEN
                SetPos(text, curLine.length, text.cursor.Y - 1);
                delete(text)
            END
        END
    END;
    setSelect(text)
END BkSpace;
 
 
PROCEDURE enter (text: tText);
VAR
    n: INTEGER;
    curLine, newLine, line, line2: tLine;
BEGIN
    delSelect(text);
    newLine := Lines.create(FALSE);
    modify(text);
    curLine := text.curLine;
    IF text.cursor.X < curLine.length THEN
        Lines.wrap(curLine, newLine, text.cursor.X);
        Lines.modify(curLine)
    END;
    List._insert(text, curLine, newLine);
    SetPos(text, 0, text.cursor.Y + 1);
    line := text.curLine.prev(tLine);
    n := -1;
    WHILE (line # NIL) & (n = -1) DO
        IF (*line.length*)Lines.trimLength(line) # 0 THEN
            n := leadingSpaces(line);
            line2 := line
        END;
        PrevLine(line)
    END;
    IF n = -1 THEN
        n := 0
    END;
    Lines.insert3(text.curLine, 0, n);
    SetPos(text, n, text.cursor.Y);
    resetSelect(text);
    WHILE n > 0 DO
        Lines.setChar(text.curLine, n - 1, getChar(line2, n - 1));
        DEC(n)
    END;
    Lines.modify(newLine)
END enter;
 
 
PROCEDURE incIndent (line: tLine);
VAR
	c: WCHAR;
	i: INTEGER;
BEGIN
	Lines.modify(line);
	Lines.insert3(line, 0, Lines.tab);
	IF Lines.tabs THEN
		c := TAB1
	ELSE
		c := SPACE
	END;
	i := Lines.tab - 1;
	WHILE i >= 0 DO
		Lines.setChar(line, i, c);
		DEC(i)
	END;
	IF Lines.tabs THEN
		Lines.setChar(line, 0, TAB)
	END
END incIndent;
 
 
PROCEDURE decIndent (line: tLine): BOOLEAN;
VAR
	n: INTEGER;
BEGIN
	n := leadingSpaces(line);
	IF n > 0 THEN
		Lines.delCharN(line, 0, MIN(Lines.tab, n));
		Lines.modify(line)
	END
	RETURN n > 0
END decIndent;
 
 
PROCEDURE Indent* (text: tText; incr: BOOLEAN);
VAR
    i: INTEGER;
    line: tLine;
    selBeg, selEnd: tPoint;
    modified: BOOLEAN;
BEGIN
	getSelect(text, selBeg, selEnd);
	i := selEnd.Y - selBeg.Y + 1;
	line := getLine(text, selBeg.Y);
	modified := incr;
	WHILE i > 0 DO
		IF incr THEN
			incIndent(line)
		ELSE
    		modified := decIndent(line) OR modified
		END;
		NextLine(line);
		DEC(i)
	END;
	line := getLine(text, selEnd.Y);
	text.select^ := selBeg;
	text.select.X := 0;
	SetPos(text, line.length, selEnd.Y);
	IF modified THEN
   		modify(text)
	END
END Indent;
 
 
PROCEDURE input* (text: tText; code: INTEGER);
VAR
    curLine: tLine;
 
 
    PROCEDURE tab (text: tText);
    VAR
        i, x: INTEGER;
        curLine: tLine;
        c: WCHAR;
    BEGIN
		delSelect(text);
		curLine := text.curLine;
		x := text.cursor.X;
		i := Lines.tab - x MOD Lines.tab;
		Lines.insert3(curLine, x, i);
		SetPos(text, x + i, text.cursor.Y);
		IF Lines.tabs THEN
			c := TAB1
		ELSE
			c := SPACE
		END;
		WHILE i > 0 DO
			Lines.setChar(curLine, x + i - 1, c);
			DEC(i)
		END;
		IF Lines.tabs THEN
			Lines.setChar(curLine, x + i, TAB)
		END;
		Lines.modify(curLine);
		modify(text)
    END tab;
 
 
BEGIN
    IF (code >= ORD(SPACE)) & (code # 127) THEN
        delSelect(text);
        curLine := text.curLine;
        Lines.insert(curLine, text.cursor.X, WCHR(code));
        Lines.modify(curLine);
        modify(text);
        SetPos(text, text.cursor.X + 1, text.cursor.Y)
    ELSIF code = 8 THEN
		BkSpace(text)
    ELSIF code = -8 THEN
    	IF selected(text) THEN
    		Indent(text, FALSE)
        END
    ELSIF code = 9 THEN
    	IF selected(text) THEN
    		Indent(text, TRUE)
    	ELSE
	        tab(text)
        END
    ELSIF code = 13 THEN
        enter(text)
    END
END input;
 
 
PROCEDURE scroll* (text: tText; h, v: INTEGER);
BEGIN
    INC(text.scroll.X, h);
    INC(text.scroll.Y, v);
    text.scroll.X := MIN(MAX(text.scroll.X, 0), text.maxLength);
    text.scroll.Y := MIN(MAX(text.scroll.Y, 0), text.count - 1)
END scroll;
 
 
PROCEDURE save* (text: tText; name: RW.tFileName): BOOLEAN;
CONST
    tempFile = "/tmp0/1/cedit~.tmp";
VAR
    line: tLine;
    file: RW.tOutput;
    res: BOOLEAN;
    Len: INTEGER;
BEGIN
    ChangeLog.setGuard(text.edition);
    res := TRUE;
    file := RW.create(tempFile, text.enc, text.eol);
    IF file # NIL THEN
        ChangeLog.delSaved;
        line := text.first(tLine);
        WHILE (line # NIL) & res DO
            Len := Lines.trimLength(line);
            IF RW.putString(file, line, Len) # Len THEN
                res := FALSE
            END;
            IF line.modified THEN
                Lines.save(line)
            END;
            NextLine(line);
            IF line # NIL THEN
                IF ~RW.newLine(file) THEN
                    res := FALSE
                END
            END
        END;
        IF ~RW.close(file) THEN
            res := FALSE
        END
    ELSE
        res := FALSE
    END;
    IF res THEN
        res := File.Copy(tempFile, name);
        IF res THEN
            text.modified := FALSE;
            ChangeLog.save(text.edition);
            IF File.Delete(tempFile) THEN END
        END
    END;
    IF ~res THEN
        ChangeLog.delCurSaved
    END
    RETURN res
END save;
 
 
PROCEDURE redoGuard (text: tText; guard: tGuard);
BEGIN
    text.edition := guard;
    text.cursor^ := guard.cursor;
    text.select2^ := guard.select2;
    text.scroll := guard.scroll;
    text.CurX := guard.CurX;
    IF guard.selected THEN
        text.select := text.select2
    ELSE
        text.select := text.cursor
    END;
    text.curLine := getLine(text, text.cursor.Y);
    text.comments := TRUE;
    text.search := TRUE
END redoGuard;
 
 
PROCEDURE undo* (text: tText);
VAR
    item: List.tItem;
    guard: tGuard;
BEGIN
    guard := text.edition;
    item := guard.prev;
    WHILE (item # NIL) & ~(item IS tGuard) DO
        item := item.prev
    END;
 
    IF item # NIL THEN
        guard := item(tGuard);
        text.edition := guard
    END;
 
    item := ChangeLog.CL.Log.first;
    WHILE item # guard DO
        ChangeLog.redo(item);
        item := item.next
    END;
    redoGuard(text, guard);
    ChangeLog.setGuard(guard);
    text.modified := ~guard.saved;
    ShowCursor
END undo;
 
 
PROCEDURE redo* (text: tText);
VAR
    item: List.tItem;
    guard: tGuard;
BEGIN
    guard := text.edition;
    item := guard.next;
    WHILE (item # NIL) & ~(item IS tGuard) DO
        ChangeLog.redo(item);
        item := item.next
    END;
    IF item # NIL THEN
        guard := item(tGuard);
        redoGuard(text, guard)
    END;
    ChangeLog.setGuard(guard);
    text.modified := ~guard.saved;
    ShowCursor
END redo;
 
 
PROCEDURE copy (text: tText);
VAR
    selBeg, selEnd: tPoint;
    first, line: tLine;
    cnt, n: INTEGER;
    buffer: CB.tBuffer;
 
 
    PROCEDURE append (buffer: CB.tBuffer; line: tLine; first, last: INTEGER);
    BEGIN
        IF first <= last THEN
            CB.append(buffer, line, first, last)
        ELSE
            IF U.OS = "KOS" THEN
                CB.appends(buffer, SPACE, 0, 0)
            END
        END
    END append;
 
 
BEGIN
    getSelect(text, selBeg, selEnd);
 
    first := getLine(text, selBeg.Y);
    line := first;
 
    n := selEnd.Y - selBeg.Y;
    cnt := 0;
    WHILE n >= 0 DO
        INC(cnt, line.length + lenEOL);
        NextLine(line);
        DEC(n)
    END;
 
    buffer := CB.create(cnt);
 
    n := selEnd.Y - selBeg.Y;
    line := first;
    IF n = 0 THEN
        CB.append(buffer, line, selBeg.X, selEnd.X - 1)
    ELSE
        append(buffer, line, selBeg.X, line.length - 1);
        REPEAT
            DEC(n);
            CB.eol(buffer);
            NextLine(line);
            IF n > 0 THEN
                append(buffer, line, 0, line.length - 1)
            END
        UNTIL n = 0;
        append(buffer, line, 0, selEnd.X - 1)
    END;
    CB.eot(buffer);
    CB.put(buffer);
    CB.destroy(buffer)
END copy;
 
 
PROCEDURE paste (text: tText);
VAR
    line, newLine, curLine: tLine;
    w: INTEGER;
    cliptext: RW.tInput;
    eol: BOOLEAN;
    cursor: pPoint;
 
 
    PROCEDURE lineWidth (line: tLine; pos: INTEGER): INTEGER;
    VAR
    	i, res: INTEGER;
    	c: WCHAR;
    BEGIN
    	res := pos;
    	i := 0;
    	REPEAT
	    	c := getChar(line, i);
	    	IF c = TAB THEN
	    		INC(res, Lines.tab - res MOD Lines.tab)
	    	ELSIF c # TAB1 THEN
	    		INC(res)
	    	END;
	    	INC(i)
    	UNTIL c = 0X
    	RETURN res - pos - 1
    END lineWidth;
 
 
BEGIN
    line := Lines.create(TRUE);
    cliptext := RW.clipboard();
    delSelect(text);
    cursor := text.cursor;
    WHILE (cliptext # NIL) & (RW.getString(cliptext, line, Lines.tabs, eol) >= 0) DO
        IF line.length > 0 THEN
        	w := lineWidth(line, cursor.X);
            Lines.insert2(text.curLine, cursor.X, line);
            Lines.modify(text.curLine);
            modify(text);
            SetPos(text, cursor.X + w, cursor.Y);
            resetSelect(text)
        END;
        IF eol THEN
            newLine := Lines.create(FALSE);
            modify(text);
            curLine := text.curLine;
            IF cursor.X < curLine.length THEN
                Lines.wrap(curLine, newLine, cursor.X);
                Lines.modify(curLine)
            END;
            List._insert(text, curLine, newLine);
            Lines.modify(newLine);
            SetPos(text, 0, cursor.Y + 1);
            resetSelect(text)
        END;
        Lines.destroy(line);
        line := Lines.create(TRUE)
    END;
    Lines.destroy(line);
    RW.destroy(cliptext)
END paste;
 
 
PROCEDURE searchScroll (text: tText; n: INTEGER);
BEGIN
    IF n - text.scroll.Y > textsize.Y - 1 THEN
        text.scroll.Y := MAX(n - 2 * textsize.Y DIV 3, 0)
    ELSIF n < text.scroll.Y THEN
        text.scroll.Y := MAX(n - textsize.Y DIV 3, 0)
    END
END searchScroll;
 
 
PROCEDURE goto* (text: tText; n: INTEGER): BOOLEAN;
VAR
    res: BOOLEAN;
BEGIN
    DEC(n);
    IF (0 <= n) & (n < text.count) THEN
        resetSelect(text);
        searchScroll(text, n);
        SetPos(text, 0, n);
        res := TRUE
    ELSE
        res := FALSE
    END
    RETURN res
END goto;
 
 
PROCEDURE toggleLabel* (text: tText);
BEGIN
    text.curLine.label := ~text.curLine.label
END toggleLabel;
 
 
PROCEDURE gotoLabel* (text: tText; frw: BOOLEAN);
VAR
    line: tLine;
    n: INTEGER;
 
    PROCEDURE search (VAR line: tLine; VAR n: INTEGER; frw: BOOLEAN);
    BEGIN
        IF frw THEN
            WHILE (line # NIL) & ~line.label DO
                NextLine(line);
                INC(n)
            END
        ELSE
            WHILE (line # NIL) & ~line.label DO
                PrevLine(line);
                DEC(n)
            END
        END
    END search;
 
BEGIN
    n := text.cursor.Y;
    line := text.curLine;
    IF frw THEN
        NextLine(line);
        INC(n)
    ELSE
        PrevLine(line);
        DEC(n)
    END;
    search(line, n, frw);
    IF line = NIL THEN
        IF frw THEN
            n := 0;
            line := text.first(tLine)
        ELSE
            n := text.count - 1;
            line := text.last(tLine)
        END;
        search(line, n, frw)
    END;
    IF line # NIL THEN
        IF goto(text, n + 1) THEN END
    END
END gotoLabel;
 
 
PROCEDURE changeCase (text: tText; upper: BOOLEAN);
VAR
    i: INTEGER;
    line: tLine;
BEGIN
    line := text.curLine;
    i := text.cursor.X - 1;
 
    WHILE (i >= 0) & U.isLetter(getChar(line, i)) DO
        DEC(i)
    END;
 
    IF Lines.chCase(line, i + 1, text.cursor.X - 1, upper) THEN
        modify(text)
    END
END changeCase;
 
 
PROCEDURE chCase* (text: tText; upper: BOOLEAN);
VAR
    selBeg, selEnd: tPoint;
    first, line: Lines.tLine;
    cnt: INTEGER;
    modified: BOOLEAN;
BEGIN
    modified := FALSE;
    IF selected(text) THEN
        getSelect(text, selBeg, selEnd);
        first := getLine(text, selBeg.Y);
        line := first;
        cnt := selEnd.Y - selBeg.Y;
        IF cnt = 0 THEN
            IF Lines.chCase(line, selBeg.X, selEnd.X - 1, upper) THEN
                modified := TRUE
            END
        ELSE
            IF Lines.chCase(line, selBeg.X, line.length - 1, upper) THEN
                modified := TRUE
            END;
            WHILE cnt > 1 DO
                NextLine(line);
                IF Lines.chCase(line, 0, line.length - 1, upper) THEN
                    modified := TRUE
                END;
                DEC(cnt)
            END;
            NextLine(line);
            IF Lines.chCase(line, 0, selEnd.X - 1, upper) THEN
                modified := TRUE
            END
        END
    END;
    IF modified THEN
        modify(text)
    END
END chCase;
 
 
PROCEDURE UpDown (text: tText; step: INTEGER);
VAR
    temp: INTEGER;
BEGIN
    IF text.CurX = -1 THEN
        text.CurX := text.cursor.X
    END;
    temp := text.CurX;
    SetPos(text, temp, text.cursor.Y + step);
    text.CurX := temp
END UpDown;
 
 
PROCEDURE delLine* (text: tText);
BEGIN
    resetSelect(text);
    IF text.curLine.length > 0 THEN
        Lines.delCharN(text.curLine, 0, text.curLine.length)
    END;
    SetPos(text, 0, text.cursor.Y);
    IF text.cursor.Y = text.count - 1 THEN
        BkSpace(text)
    ELSE
        delete(text)
    END
END delLine;
 
 
PROCEDURE dupLine* (text: tText);
VAR
    newLine, curLine: tLine;
BEGIN
    curLine := text.curLine;
    newLine := Lines.create(FALSE);
    modify(text);
    Lines.insert3(newLine, 0, curLine.length);
    List._insert(text, curLine, newLine);
    Lines.move(curLine, newLine);
    Lines.modify(newLine)
END dupLine;
 
 
PROCEDURE exchange (text: tText; first, second: tLine);
BEGIN
    List._exchange(text, first, second);
    Lines.modify(text.curLine);
    modify(text);
    UpDown(text, 0)
END exchange;
 
 
PROCEDURE upLine* (text: tText);
BEGIN
	resetSelect(text);
    IF text.cursor.Y > 0 THEN
        DEC(text.cursor.Y);
        exchange(text, text.curLine.prev(tLine), text.curLine)
    END
END upLine;
 
 
PROCEDURE downLine* (text: tText);
BEGIN
	resetSelect(text);
    IF text.cursor.Y < text.count - 1 THEN
        INC(text.cursor.Y);
        exchange(text, text.curLine, text.curLine.next(tLine))
    END
END downLine;
 
 
PROCEDURE isWordChar (c: WCHAR): BOOLEAN;
    RETURN U.isLetter(c) OR U.isDigit(c) OR (c = "_")
END isWordChar;
 
 
PROCEDURE wordSel* (text: tText);
VAR
    n, i, x1, x2: INTEGER;
    selBeg, selEnd: tPoint;
    str: tString;
    curLine: tLine;
BEGIN
    curLine := text.curLine;
    IF selected(text) & (text.cursor.Y = text.select.Y) THEN
        getSelect(text, selBeg, selEnd);
        x1 := selBeg.X;
        x2 := selEnd.X;
        n := getString(curLine, x1, x2 - x1, str);
    ELSE
        str := ""
    END;
    IF str # "" THEN
        i := 0;
        WHILE (i < n) & isWordChar(str[i]) DO
            INC(i)
        END;
        IF (i # n) OR
            ((x1 > 0) & isWordChar(getChar(curLine, x1 - 1))) OR
            ((x2 < curLine.length) & isWordChar(getChar(curLine, x2))) THEN
            str := ""
        END
    END;
    IF search(text, str, Lang.isCS(text.lang), TRUE) THEN END
END wordSel;
 
 
PROCEDURE key* (text: tText; code: INTEGER; shift, ctrl: BOOLEAN);
VAR
	n: INTEGER;
BEGIN
    IF shift THEN
        setSelect(text)
    ELSE
        IF (33 <= code) & (code <= 40) THEN
            resetSelect(text)
        END
    END;
 
    CASE code OF
    |33:
        IF ctrl THEN
            UpDown(text, text.scroll.Y - text.cursor.Y)
        ELSE
            text.scroll.Y := MAX(text.scroll.Y - textsize.Y, 0);
            UpDown(text, -textsize.Y)
        END
    |34:
        IF ctrl THEN
            UpDown(text, MIN(text.scroll.Y + textsize.Y - 1, text.count - 1) - text.cursor.Y)
        ELSE
            text.scroll.Y := MIN(text.scroll.Y + textsize.Y, text.count - 1);
            UpDown(text, textsize.Y)
        END
    |35:
        IF ctrl THEN
            SetPos(text, text.last(tLine).length, text.count - 1)
        ELSE
            SetPos(text, text.curLine.length, text.cursor.Y)
        END
    |36:
        IF ctrl THEN
            SetPos(text, 0, 0)
        ELSE
        	n := leadingSpaces(text.curLine);
        	IF text.cursor.X > n THEN
	            SetPos(text, n, text.cursor.Y)
        	ELSE
        		SetPos(text, 0, text.cursor.Y)
        	END
        END
    |37:
        IF (text.cursor.X = 0) & (text.curLine.prev # NIL) THEN
            SetPos(text, text.curLine.prev(tLine).length, text.cursor.Y - 1)
        ELSE
            move(text, -1)
        END
    |38:
        IF ctrl THEN
            upLine(text)
        ELSE
            UpDown(text, -1)
        END
    |39:
        IF (text.cursor.X = text.curLine.length) & (text.curLine.next # NIL) THEN
            SetPos(text, 0, text.cursor.Y + 1)
        ELSE
            move(text, 1)
        END
    |40:
        IF ctrl THEN
            downLine(text)
        ELSE
            UpDown(text, 1)
        END
    |46:
        IF ctrl THEN
            delLine(text)
        ELSE
            delete(text);
            ShowCursor
        END
    |ORD("C"):
        IF ctrl THEN
            IF selected(text) THEN
                copy(text)
            END
        END
    |ORD("X"):
        IF ctrl THEN
            IF selected(text) THEN
                copy(text);
                delSelect(text)
            END
        END
    |ORD("V"):
        IF ctrl THEN
            IF CB.available() THEN
                paste(text)
            END
        END
    |ORD("A"):
        IF ctrl THEN
            text.select2.X := 0;
            text.select2.Y := 0;
            text.select := text.select2;
            SetPos(text, text.last(tLine).length, text.count - 1)
        END
    |ORD("L"), ORD("U"):
        IF ctrl THEN
        	IF selected(text) THEN
            	chCase(text, code = ORD("U"))
            ELSE
            	changeCase(text, code = ORD("U"))
            END;
            ShowCursor
        END
    |ORD("D"):
        IF ctrl THEN
            dupLine(text)
        END
    ELSE
    END
END key;
 
 
PROCEDURE mouse* (text: tText; x, y: INTEGER);
VAR
    cursorX: INTEGER;
BEGIN
    DEC(x, padding.left);
    DEC(y, padding.top);
    cursorX := (x*2) DIV charWidth;
    SetPos(text, cursorX DIV 2 + cursorX MOD 2 + text.scroll.X, y DIV charHeight + text.scroll.Y)
END mouse;
 
 
PROCEDURE selectWord* (text: tText);
VAR
    cursorX, x1, x2: INTEGER;
    line: tLine;
BEGIN
    resetSelect(text);
    cursorX := text.cursor.X;
    line := text.curLine;
    x1 := cursorX - 1;
    IF (cursorX < line.length) & isWordChar(getChar(line,cursorX)) THEN
        x2 := cursorX;
        WHILE (x2 < line.length) & isWordChar(getChar(line, x2)) DO
            INC(x2)
        END
    ELSE
        WHILE (x1 >= 0) & ~isWordChar(getChar(line, x1)) DO
            DEC(x1)
        END;
        x2 := x1 + 1
    END;
    WHILE (x1 >= 0) & isWordChar(getChar(line, x1)) DO
        DEC(x1)
    END;
    INC(x1);
    IF x1 < x2 THEN
        SetPos(text, x1, text.cursor.Y);
        setSelect(text);
        SetPos(text, x2, text.cursor.Y)
    END
END selectWord;
 
 
PROCEDURE cursor (text: tText);
VAR
    x, y, h: INTEGER;
    cursor: pPoint;
BEGIN
    cursor := text.cursor;
    IF ~((text.scroll.Y > cursor.Y) OR (text.scroll.Y + textsize.Y <= cursor.Y) OR
       (text.scroll.X > cursor.X) OR (text.scroll.X + textsize.X <= cursor.X)) THEN
        x := (cursor.X - text.scroll.X)*charWidth + padding.left;
        y := (cursor.Y - text.scroll.Y)*charHeight + 1 + padding.top;
        h := charHeight - 2;
        G.notVLine(canvas, x, y + inter DIV 2, y + h - inter DIV 2);
        G.notVLine(canvas, x - 1, y + inter DIV 2, y + h - inter DIV 2)
    END
END cursor;
 
 
PROCEDURE drawSelect (text: tText; line: tLine; selBeg, selEnd, y: INTEGER);
VAR
    Len, pos, x, firstCharIdx: INTEGER;
BEGIN
    firstCharIdx := MAX(text.scroll.X, selBeg);
    Len := MAX(MIN(line.length - firstCharIdx, selEnd - firstCharIdx), 0);
    Len := MIN(Len, textsize.X - pos + 1);
    SetColor(colors.seltext, colors.selback);
    pos := MAX((selBeg - text.scroll.X), 0);
    x := pos*charWidth + padding.left;
    G.SetColor(canvas, colors.selback);
    G.FillRect(canvas, x - 2, y - inter DIV 2, x + 1 + Len*charWidth, y - inter DIV 2 + charHeight);
    G.TextOut(canvas, pos*charWidth + padding.left, y, Lines.getPChar(line, firstCharIdx), Len)
END drawSelect;
 
 
PROCEDURE mark (line: tLine; y: INTEGER);
VAR
    color, i: INTEGER;
BEGIN
    IF line.modified THEN
        color := colors.modified
    ELSIF line.saved THEN
        color := colors.saved
    ELSE
        color := colors.back
    END;
    G.SetColor(canvas, color);
 
    FOR i := 3 TO mark_width + 2 DO
        G.VLine(canvas, padding.left - i, y, y + charHeight)
    END
END mark;
 
 
PROCEDURE setPadding (left, top: INTEGER);
BEGIN
    padding.left := left;
    padding.top := top;
    textsize.X := (size.X - padding.left) DIV charWidth;
    textsize.Y := (size.Y - padding.top) DIV charHeight;
END setPadding;
 
 
PROCEDURE draw* (text: tText);
VAR
    y, n, Len, cnt, i, x: INTEGER;
    line, firstLine, lastLine: tLine;
    selBeg, selEnd: tPoint;
    s: ARRAY 12 OF WCHAR;
    backColor, numWidth, xNum, wNum: INTEGER;
    p: Search.tPos;
    guard: tGuard;
BEGIN
    IF text.search & search(text, text.searchText, text.cs, text.whole) THEN END;
    IF (text.lang # Lang.langText) & text.comments THEN
        Comments(text)
    END;
    IF text.guard THEN
        NEW(guard);
        List.append(ChangeLog.CL.Log, guard);
        guard.saved := ChangeLog.isFirstGuard(guard);
        text.edition := guard;
        text.guard := FALSE
    ELSE
        guard := text.edition
    END;
 
    guard.cursor := text.cursor^;
    guard.select2 := text.select2^;
    guard.scroll := text.scroll;
    guard.CurX := text.CurX;
    guard.selected := text.select = text.select2;
 
    G.SetColor(canvas, colors.back);
    G.clear(canvas);
    wNum := charWidth;
    IF text.numbers THEN
        numWidth := U.lg10(text.count) + 2;
        xNum := numWidth*wNum - wNum DIV 2;
        setPadding(numWidth*wNum + pad_left, padding.top);
    ELSE
        setPadding(pad_left + wNum*2, padding.top)
    END;
    getSelect(text, selBeg, selEnd);
    y := padding.top + inter DIV 2;
    n := text.scroll.Y;
    line := getLine(text, n);
    firstLine := line;
    cnt := 0;
    WHILE (line # NIL) & (cnt <= textsize.Y) DO
        backColor := colors.back;
        IF (line = text.curLine) & ~selected(text) THEN
            G.SetColor(canvas, colors.curline);
            G.FillRect(canvas, padding.left - 2, y - inter DIV 2, size.X - 1, y - inter DIV 2 + charHeight);
            backColor := colors.curline
        END;
        SetColor(colors.text, backColor);
        Len := MAX(line.length - text.scroll.X, 0);
        G.TextOut(canvas, padding.left, y, Lines.getPChar(line, text.scroll.X), MIN(Len, textsize.X + 1));
        IF text.lang # Lang.langText THEN
            parse(text, line, y, backColor, text.lang)
        END;
        mark(line, y - inter DIV 2);
        IF (selBeg.Y < n) & (n < selEnd.Y) THEN
            drawSelect(text, line, 0, line.length, y)
        ELSIF (selBeg.Y = n) & (selEnd.Y = n) & (selBeg.X # selEnd.X) THEN
            drawSelect(text, line, selBeg.X, selEnd.X, y)
        ELSIF (selBeg.Y = n) & (selEnd.Y # n) THEN
            drawSelect(text, line, selBeg.X, line.length, y)
        ELSIF (selBeg.Y # n) & (selEnd.Y = n) THEN
            drawSelect(text, line, 0, selEnd.X, y)
        END;
        NextLine(line);
        INC(y, charHeight);
        INC(n);
        INC(cnt)
    END;
    G.SetColor(canvas, colors.numback);
    G.FillRect(canvas, 0, 0, padding.left - pad_left (*+ 1*), size.Y - 1);
    line := firstLine;
    SetColor(colors.numtext, colors.numback);
    y := padding.top + inter DIV 2;
    n := MIN(text.scroll.Y + textsize.Y + 1, text.count);
    FOR i := text.scroll.Y + 1 TO n DO
        IF text.numbers THEN
            IF (i MOD 10 = 0) OR (i - 1 = text.cursor.Y) OR line.label THEN
                U.int2str(i, s);
                G.TextOut2(canvas, (numWidth - U.lg10(i) - 1)*wNum - wNum DIV 2, y, s, LENGTH(s))
            ELSIF i MOD 5 = 0 THEN
                G.SetColor(canvas, colors.numtext);
                G.HLine(canvas, y - inter DIV 2 + charHeight DIV 2, xNum - wNum, xNum)
            ELSE
                G.SetColor(canvas, colors.numtext);
                G.HLine(canvas, y - inter DIV 2 + charHeight DIV 2, xNum - wNum DIV 2, xNum)
            END
        END;
        IF line.label THEN
            FOR x := wNum DIV 2 TO (padding.left - pad_left) - wNum DIV 2 DO
                G.notVLine(canvas, x, y, y + charHeight - inter);
                G.xorVLine(canvas, x, y, y + charHeight - inter)
            END
        END;
        NextLine(line);
        INC(y, charHeight)
    END;
 
    IF text.searchText # "" THEN
        cnt := 0;
        line := firstLine;
        lastLine := line;
        WHILE (line # NIL) & (cnt <= textsize.Y) DO
            lastLine := line;
            NextLine(line);
            INC(cnt)
        END;
        p := text.foundList.first(Search.tPos);
        WHILE p # NIL DO
            y := padding.top + inter DIV 2;
            IF (firstLine.pos <= p.pos) & (p.pos <= lastLine.pos + lastLine.length) THEN
                line := firstLine;
                WHILE (line.pos <= p.pos) & (line # lastLine) DO
                    NextLine(line);
                    INC(y, charHeight)
                END;
                IF (line # lastLine) & (line # firstLine) OR (line = lastLine) & (line.pos > p.pos) THEN
                    PrevLine(line);
                    DEC(y, charHeight)
                END;
                x := (p.pos - line.pos - text.scroll.X)*charWidth + padding.left;
                n := LENGTH(text.searchText)*charWidth;
                WHILE n > 0 DO
                    IF x >= padding.left THEN
                        G.notVLine(canvas, x, y, y + charHeight - inter)
                    END;
                    INC(x);
                    DEC(n)
                END;
            END;
            p := p.next(Search.tPos)
        END
    END;
 
    IF text.foundSel > 0 THEN
        x := (text.cursor.X - text.scroll.X)*charWidth + padding.left;
        y := (text.cursor.Y - text.scroll.Y)*charHeight + padding.top + inter DIV 2;
        n := text.foundSel*charWidth;
        WHILE n > 0 DO
            IF x >= padding.left THEN
                G.xorVLine(canvas, x, y, y + charHeight - inter)
            END;
            INC(x);
            DEC(n)
        END
    END;
 
    IF drawCursor THEN
        cursor(text)
    END;
    G.SetColor(canvas, K.borderColor);
    G.VLine(canvas, 0, 0, size.Y - 1);
END draw;
 
 
PROCEDURE switch* (text: tText);
BEGIN
    ChangeLog.set(text.chLog);
    Lines.setMaxLength(text.maxLength)
END switch;
 
 
PROCEDURE create (fileName: RW.tFileName): tText;
VAR
    text: tText;
BEGIN
    NEW(text);
    text.maxLength := 64;
    text.chLog := ChangeLog.create(text.maxLength);
    NEW(text.cursor);
    NEW(text.select2);
    text.cursor.X := 0;
    text.cursor.Y := 0;
    resetSelect(text);
    text.scroll.X := 0;
    text.scroll.Y := 0;
    setPadding(padding.left, padding.top);
    text.curLine := NIL;
    text.modified := FALSE;
    text.comments := TRUE;
    text.search := TRUE;
    text.cs := FALSE;
    text.whole := FALSE;
    text.numbers := TRUE;
    text.guard := TRUE;
    text.idxData := NIL;
    text.edition := NIL;
    text.foundList := List.create(NIL);
    text.searchText := "";
    text.foundSel := 0;
    text.CurX := -1;
    setName(text, fileName);
    ASSERT(text = List.create(text))
    RETURN text
END create;
 
 
PROCEDURE setColors* (text, back, seltext, selback, modified, saved, curline, numtext, numback,
                        comment, string, num, delim, key1, key2, key3: INTEGER);
BEGIN
    colors.text := text;
    colors.back := back;
    colors.seltext := seltext;
    colors.selback := selback;
    colors.modified := modified;
    colors.saved := saved;
    colors.curline := curline;
    colors.numtext := numtext;
    colors.numback := numback;
    colors.comment := comment;
    colors.string  := string;
    colors.num := num;
    colors.delim := delim;
    colors.key1 := key1;
    colors.key2 := key2;
    colors.key3 := key3;
END setColors;
 
 
PROCEDURE setCanvas* (Canvas: G.tCanvas);
BEGIN
    canvas := Canvas;
    charWidth := canvas.font.width;
    charHeight := canvas.font.height + inter
END setCanvas;
 
 
PROCEDURE resize* (width, height: INTEGER);
BEGIN
    size.X := width;
    size.Y := height;
    setPadding(padding.left, padding.top)
END resize;
 
 
PROCEDURE destroy* (VAR text: tText);
BEGIN
    IF search(text, "", FALSE, FALSE) THEN END;
    WHILE text.last # NIL DO
        DelLine(text, text.last(tLine))
    END;
    DISPOSE(text.foundList);
    DISPOSE(text.cursor);
    DISPOSE(text.select2);
    DISPOSE(text)
END destroy;
 
 
PROCEDURE open* (name: RW.tFileName; VAR errno: INTEGER): tText;
VAR
    text: tText;
    file: RW.tInput;
    n, enc, eol: INTEGER;
    _eol: BOOLEAN;
    line: tLine;
BEGIN
    errno := 0;
    text := NIL;
    file := RW.load(name, enc, eol);
    IF file # NIL THEN
        text := create(name);
        text.enc := enc;
        text.eol := eol;
        line := Lines.create(FALSE);
        List._append(text, line);
        REPEAT
            n := RW.getString(file, line, Lines.tabs, _eol);
            IF _eol THEN
            	line := Lines.create(FALSE);
            	List._append(text, line)
            END
        UNTIL ~_eol;
        RW.destroy(file);
        text.curLine := text.first(tLine);
        SetPos(text, 0, 0);
        resetSelect(text)
    ELSE
        errno := 1
    END;
    IF (text # NIL) & (text.lang # Lang.langText) THEN
        Comments(text)
    END
    RETURN text
END open;
 
 
PROCEDURE findNext* (text: tText; prev: BOOLEAN): BOOLEAN;
VAR
    cursorPos, x, y, X, Y, Len: INTEGER;
    p: Search.tPos;
    line: tLine;
    res: BOOLEAN;
BEGIN
    X := text.cursor.X;
    Y := text.cursor.Y;
    text.cursor.X := MIN(text.cursor.X, text.curLine.length);
    cursorPos := text.curLine.pos + text.cursor.X - ORD(prev) - ORD(~prev & (text.foundSel = 0));
    p := text.foundList.first(Search.tPos);
    WHILE (p # NIL) & (p.pos <= cursorPos) DO
        p := p.next(Search.tPos)
    END;
    IF prev THEN
        IF p = NIL THEN
            p := text.foundList.last(Search.tPos)
        ELSE
            p := p.prev(Search.tPos)
        END
    END;
    res := p # NIL;
    IF res THEN
        y := 0;
        line := text.first(tLine);
        WHILE (line.pos <= p.pos) & (line.next # NIL) DO
            NextLine(line);
            INC(y)
        END;
        IF (line.next # NIL) OR (line.pos > p.pos) THEN
            PrevLine(line);
            DEC(y)
        END;
        resetSelect(text);
        searchScroll(text, y);
        x := p.pos - line.pos;
        Len := LENGTH(text.searchText);
        IF x + Len > text.scroll.X + textsize.X THEN
            text.scroll.X := MAX(x + Len - textsize.X + 3, 0)
        ELSIF x < text.scroll.X THEN
            text.scroll.X := MAX(x - 3, 0)
        END;
        SetPos(text, x, y);
        text.foundSel := Len
    ELSE
        SetPos(text, X, Y)
    END
    RETURN res
END findNext;
 
 
PROCEDURE rewrite (line: tLine; repl: ARRAY OF WCHAR; pos, n: INTEGER);
BEGIN
    IF n > 0 THEN
        Lines.copy(line)
    END;
    WHILE n > 0 DO
        DEC(n);
        Lines.setChar(line, pos + n, repl[n])
    END
END rewrite;
 
 
PROCEDURE replace* (text: tText; s: ARRAY OF WCHAR; n: INTEGER);
VAR
    line: tLine;
    sLen, i: INTEGER;
BEGIN
    IF text.foundSel > 0 THEN
        line := text.curLine;
        sLen := LENGTH(s);
        i := text.cursor.X;
        IF sLen > n THEN
            Lines.insert3(line, i, sLen - n)
        END;
        SetPos(text, i + sLen, text.cursor.Y);
        rewrite(line, s, i, sLen);
        IF n > sLen THEN
            Lines.delCharN(line, text.cursor.X, n - sLen)
        END;
        resetSelect(text);
        Lines.modify(line);
        modify(text)
    END
END replace;
 
 
PROCEDURE replaceAll* (text: tText; s: ARRAY OF WCHAR; n: INTEGER): INTEGER;
VAR
    p: Search.tPos;
    line: tLine;
    y, k, d, pos, y0: INTEGER;
BEGIN
    resetSelect(text);
    SetPos(text, 0, 0);
    line := text.first(tLine);
    y := 0;
    y0 := -1;
    k := 0;
    d := LENGTH(s) - n;
    p := text.foundList.first(Search.tPos);
    WHILE p # NIL DO
        pos := p.pos;
        WHILE (line.pos <= pos) & (line.next # NIL) DO
            NextLine(line);
            INC(y)
        END;
        IF (line.next # NIL) OR (line.pos > pos) THEN
            PrevLine(line);
            DEC(y)
        END;
        IF y = y0 THEN
            INC(k, d)
        ELSE
            k := 0;
            y0 := y
        END;
        SetPos(text, pos - line.pos + k, y);
        text.foundSel := n;
        replace(text, s, n);
        p := p.next(Search.tPos)
    END
    RETURN text.foundList.count
END replaceAll;
 
 
PROCEDURE New* (): tText;
VAR
    text: tText;
BEGIN
    text := create("");
    List._append(text, Lines.create(FALSE));
    text.curLine := text.first(tLine);
    text.enc := E.CP866;
    text.eol := RW.EOL_CRLF;
    SetPos(text, 0, 0);
    resetSelect(text)
    RETURN text
END New;
 
 
PROCEDURE init* (pShowCursor: tProcedure);
BEGIN
    ShowCursor := pShowCursor;
    pdelete := delete;
    drawCursor := TRUE;
    padding.left := pad_left;
    padding.top := pad_top;
END init;
 
 
END Text.

Rev 9181	Rev 9190
1	(*	1	(*
2	Copyright 2021 Anton Krotov	2	Copyright 2021 Anton Krotov
3		3
4	This file is part of CEdit.	4	This file is part of CEdit.
5		5
6	CEdit is free software: you can redistribute it and/or modify	6	CEdit is free software: you can redistribute it and/or modify
7	it under the terms of the GNU General Public License as published by	7	it under the terms of the GNU General Public License as published by
8	the Free Software Foundation, either version 3 of the License, or	8	the Free Software Foundation, either version 3 of the License, or
9	(at your option) any later version.	9	(at your option) any later version.
10		10
11	CEdit is distributed in the hope that it will be useful,	11	CEdit is distributed in the hope that it will be useful,
12	but WITHOUT ANY WARRANTY; without even the implied warranty of	12	but WITHOUT ANY WARRANTY; without even the implied warranty of
13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14	GNU General Public License for more details.	14	GNU General Public License for more details.
15		15
16	You should have received a copy of the GNU General Public License	16	You should have received a copy of the GNU General Public License
17	along with CEdit. If not, see .	17	along with CEdit. If not, see .
18	*)	18	*)
19		19
20	MODULE Text;	20	MODULE Text;
21		21
22	IMPORT	22	IMPORT
23	List, Lines,	23	List, Lines,
24	G := Graph,	24	G := Graph,
25	U := Utils,	25	U := Utils,
26	RW, Search,	26	RW, Search,
27	E := Encodings,	27	E := Encodings,
28	CB := Clipboard,	28	CB := Clipboard,
29	K := KolibriOS,	29	K := KolibriOS,
30	ChangeLog, File,	30	ChangeLog, File,
31	Lang := Languages;	31	Lang := Languages;
32		32
33		33
34	CONST	34	CONST
35		35
36	SPACE = Lines.SPACE;	36	SPACE = Lines.SPACE;
37	TAB = Lines.TAB;	37	TAB = Lines.TAB;
38	TAB1 = Lines.TAB1;	38	TAB1 = Lines.TAB1;
39	lenEOL = CB.lenEOL;	39	lenEOL = CB.lenEOL;
40		40
41	mark_width = 2;	41	mark_width = 2;
42	pad_left = mark_width + 3;	42	pad_left = mark_width + 3;
43	pad_top = 0;	43	pad_top = 0;
44	inter = 2;	44	inter = 2;
45		45
46		46
47	TYPE	47	TYPE
48		48
49	tPoint = RECORD	49	tPoint = RECORD
50	X, Y: INTEGER	50	X, Y: INTEGER
51	END;	51	END;
52		52
53	pPoint = POINTER TO tPoint;	53	pPoint = POINTER TO tPoint;
54		54
55	tString* = ARRAY 1000 OF WCHAR;	55	tString* = ARRAY 1000 OF WCHAR;
56		56
57	tLine = Lines.tLine;	57	tLine = Lines.tLine;
58		58
59	tGuard = POINTER TO RECORD (ChangeLog.tGuard)	59	tGuard = POINTER TO RECORD (ChangeLog.tGuard)
60	selected: BOOLEAN;	60	selected: BOOLEAN;
61	cursor, select2, scroll: tPoint;	61	cursor, select2, scroll: tPoint;
62	CurX: INTEGER	62	CurX: INTEGER
63	END;	63	END;
64		64
65	tText* = POINTER TO RECORD (List.tList)	65	tText* = POINTER TO RECORD (List.tList)
66	cursor, select, select2: pPoint;	66	cursor, select, select2: pPoint;
67	scroll: tPoint;	67	scroll: tPoint;
68	CurX: INTEGER;	68	CurX: INTEGER;
69	modified*: BOOLEAN;	69	modified*: BOOLEAN;
70		70
71	edition*: tGuard;	71	edition*: tGuard;
72	comments, numbers*, guard,	72	comments, numbers*, guard,
73	search, cs, whole: BOOLEAN;	73	search, cs, whole: BOOLEAN;
74	curLine: tLine;	74	curLine: tLine;
75	fileName*: RW.tFileName;	75	fileName*: RW.tFileName;
76	lang*: INTEGER;	76	lang*: INTEGER;
77	enc*: INTEGER;	77	enc*: INTEGER;
78	eol*: INTEGER;	78	eol*: INTEGER;
79	table: Search.IdxTable;	79	table: Search.IdxTable;
80	foundList: List.tList;	80	foundList: List.tList;
81	idxData: Search.tBuffer;	81	idxData: Search.tBuffer;
82	foundSel: INTEGER;	82	foundSel: INTEGER;
83	searchText: tString;	83	searchText: tString;
84	chLog*: ChangeLog.tLog;	84	chLog*: ChangeLog.tLog;
85	maxLength*: INTEGER	85	maxLength*: INTEGER
86	END;	86	END;
87		87
88	tProcedure = PROCEDURE;	88	tProcedure = PROCEDURE;
89		89
90		90
91	VAR	91	VAR
92		92
93	pdelete: PROCEDURE (text: tText);	93	pdelete: PROCEDURE (text: tText);
94	ShowCursor: PROCEDURE;	94	ShowCursor: PROCEDURE;
95		95
96	colors*: RECORD	96	colors*: RECORD
97	text, back, seltext, selback, modified, saved, curline, numtext, numback: INTEGER;	97	text, back, seltext, selback, modified, saved, curline, numtext, numback: INTEGER;
98	comment, string, num, delim, key1, key2, key3: INTEGER	98	comment, string, num, delim, key1, key2, key3: INTEGER
99	END;	99	END;
100	canvas: G.tCanvas;	100	canvas: G.tCanvas;
101	drawCursor: BOOLEAN;	101	drawCursor: BOOLEAN;
102	padding: RECORD left, top: INTEGER END;	102	padding: RECORD left, top: INTEGER END;
103	size, textsize: tPoint;	103	size, textsize: tPoint;
104	charWidth, charHeight: INTEGER;	104	charWidth, charHeight: INTEGER;
105		105
106		106
107	PROCEDURE setName* (text: tText; name: RW.tFileName);	107	PROCEDURE setName* (text: tText; name: RW.tFileName);
108	VAR	108	VAR
109	ext: RW.tFileName;	109	ext: RW.tFileName;
110	BEGIN	110	BEGIN
111	text.fileName := name;	111	text.fileName := name;
112	U.getFileName(text.fileName, ext, ".");	112	U.getFileName(text.fileName, ext, ".");
113	U.upcase(ext);	113	U.upcase(ext);
114	IF ext = "OB07" THEN	114	IF ext = "OB07" THEN
115	text.lang := Lang.langOberon	115	text.lang := Lang.langOberon
116	ELSIF (ext = "C") OR (ext = "H") OR (ext = "CPP") THEN	116	ELSIF (ext = "C") OR (ext = "H") OR (ext = "CPP") THEN
117	text.lang := Lang.langC	117	text.lang := Lang.langC
118	ELSIF (ext = "PAS") OR (ext = "PP") THEN	118	ELSIF (ext = "PAS") OR (ext = "PP") THEN
119	text.lang := Lang.langPascal	119	text.lang := Lang.langPascal
120	ELSIF ext = "ASM" THEN	120	ELSIF ext = "ASM" THEN
121	text.lang := Lang.langFasm	121	text.lang := Lang.langFasm
122	ELSIF ext = "LUA" THEN	122	ELSIF ext = "LUA" THEN
123	text.lang := Lang.langLua	123	text.lang := Lang.langLua
124	ELSIF ext = "INI" THEN	124	ELSIF ext = "INI" THEN
125	text.lang := Lang.langIni	125	text.lang := Lang.langIni
126	ELSIF ext = "JSON" THEN	126	ELSIF ext = "JSON" THEN
127	text.lang := Lang.langJSON	127	text.lang := Lang.langJSON
128	ELSE	128	ELSE
129	text.lang := Lang.langNone	129	text.lang := Lang.langText
130	END	130	END
131	END setName;	131	END setName;
132		132
133		133
134	PROCEDURE setLang* (text: tText; lang: INTEGER);	134	PROCEDURE setLang* (text: tText; lang: INTEGER);
135	BEGIN	135	BEGIN
136	text.lang := lang;	136	text.lang := lang;
137	text.comments := TRUE	137	text.comments := TRUE
138	END setLang;	138	END setLang;
139		139
140		140
141	PROCEDURE getPos* (text: tText; VAR x, y: INTEGER);	141	PROCEDURE getPos* (text: tText; VAR x, y: INTEGER);
142	BEGIN	142	BEGIN
143	x := text.cursor.X + 1;	143	x := text.cursor.X + 1;
144	y := text.cursor.Y + 1	144	y := text.cursor.Y + 1
145	END getPos;	145	END getPos;
146		146
147		147
148	PROCEDURE getScroll* (text: tText; VAR x, y: INTEGER);	148	PROCEDURE getScroll* (text: tText; VAR x, y: INTEGER);
149	BEGIN	149	BEGIN
150	x := text.scroll.X;	150	x := text.scroll.X;
151	y := text.scroll.Y	151	y := text.scroll.Y
152	END getScroll;	152	END getScroll;
153		153
154		154
155	PROCEDURE getTextSize* (VAR x, y: INTEGER);	155	PROCEDURE getTextSize* (VAR x, y: INTEGER);
156	BEGIN	156	BEGIN
157	x := textsize.X;	157	x := textsize.X;
158	y := textsize.Y	158	y := textsize.Y
159	END getTextSize;	159	END getTextSize;
160		160
161		161
162	PROCEDURE getTextRect* (VAR left, top, rigth, bottom: INTEGER);	162	PROCEDURE getTextRect* (VAR left, top, rigth, bottom: INTEGER);
163	BEGIN	163	BEGIN
164	left := padding.left - 1;	164	left := padding.left - 1;
165	top := padding.top - 1;	165	top := padding.top - 1;
166	rigth := size.X - 1;	166	rigth := size.X - 1;
167	bottom := top + size.Y - 1;	167	bottom := top + size.Y - 1;
168	END getTextRect;	168	END getTextRect;
169		169
170		170
171	PROCEDURE toggleNumbers* (text: tText);	171	PROCEDURE toggleNumbers* (text: tText);
172	BEGIN	172	BEGIN
173	text.numbers := ~text.numbers	173	text.numbers := ~text.numbers
174	END toggleNumbers;	174	END toggleNumbers;
175		175
176		176
177	PROCEDURE toggleCursor*;	177	PROCEDURE toggleCursor*;
178	BEGIN	178	BEGIN
179	drawCursor := ~drawCursor	179	drawCursor := ~drawCursor
180	END toggleCursor;	180	END toggleCursor;
181		181
182		182
183	PROCEDURE showCursor*;	183	PROCEDURE showCursor*;
184	BEGIN	184	BEGIN
185	drawCursor := TRUE	185	drawCursor := TRUE
186	END showCursor;	186	END showCursor;
187		187
188		188
189	PROCEDURE hideCursor*;	189	PROCEDURE hideCursor*;
190	BEGIN	190	BEGIN
191	drawCursor := FALSE	191	drawCursor := FALSE
192	END hideCursor;	192	END hideCursor;
193		193
194		194
195	PROCEDURE getChar (line: tLine; i: INTEGER): WCHAR;	195	PROCEDURE getChar (line: tLine; i: INTEGER): WCHAR;
196	VAR	196	VAR
197	res: WCHAR;	197	res: WCHAR;
198	BEGIN	198	BEGIN
199	IF i >= line.length THEN	199	IF i >= line.length THEN
200	res := 0X	200	res := 0X
201	ELSE	201	ELSE
202	res := Lines.getChar(line, i)	202	res := Lines.getChar(line, i)
203	END	203	END
204	RETURN res	204	RETURN res
205	END getChar;	205	END getChar;
206		206
207		207
208	PROCEDURE getString (src: tLine; pos, cnt: INTEGER; VAR dst: ARRAY OF WCHAR): INTEGER;	208	PROCEDURE getString (src: tLine; pos, cnt: INTEGER; VAR dst: ARRAY OF WCHAR): INTEGER;
209	VAR	209	VAR
210	i: INTEGER;	210	i: INTEGER;
211	BEGIN	211	BEGIN
212	i := 0;	212	i := 0;
213	WHILE (pos < src.length) & (cnt > 0) DO	213	WHILE (pos < src.length) & (cnt > 0) DO
214	IF i < LEN(dst) - 1 THEN	214	IF i < LEN(dst) - 1 THEN
215	dst[i] := getChar(src, pos);	215	dst[i] := getChar(src, pos);
216	INC(i)	216	INC(i)
217	END;	217	END;
218	INC(pos);	218	INC(pos);
219	DEC(cnt)	219	DEC(cnt)
220	END;	220	END;
221	dst[i] := 0X	221	dst[i] := 0X
222	RETURN i	222	RETURN i
223	END getString;	223	END getString;
224		224
225		225
226	PROCEDURE NextLine (VAR line: tLine);	226	PROCEDURE NextLine (VAR line: tLine);
227	BEGIN	227	BEGIN
228	line := line.next(tLine)	228	line := line.next(tLine)
229	END NextLine;	229	END NextLine;
230		230
231		231
232	PROCEDURE PrevLine (VAR line: tLine);	232	PROCEDURE PrevLine (VAR line: tLine);
233	BEGIN	233	BEGIN
234	line := line.prev(tLine)	234	line := line.prev(tLine)
235	END PrevLine;	235	END PrevLine;
236		236
237		237
238	PROCEDURE SetColor (textColor, backColor: INTEGER);	238	PROCEDURE SetColor (textColor, backColor: INTEGER);
239	BEGIN	239	BEGIN
240	G.SetTextColor(canvas, textColor);	240	G.SetTextColor(canvas, textColor);
241	G.SetBkColor(canvas, backColor)	241	G.SetBkColor(canvas, backColor)
242	END SetColor;	242	END SetColor;
243		243
244		244
245	PROCEDURE ProcessComments (line: tLine; VAR depth, pos: INTEGER; minDepth, n: INTEGER; lang: INTEGER);	245	PROCEDURE ProcessComments (line: tLine; VAR depth, pos: INTEGER; minDepth, n: INTEGER; lang: INTEGER);
246	VAR	246	VAR
247	cond: INTEGER;	247	cond: INTEGER;
248	BEGIN	248	BEGIN
249	cond := 0;	249	cond := 0;
250	WHILE (pos <= n) & (depth > minDepth) DO	250	WHILE (pos <= n) & (depth > minDepth) DO
251	Lang.comments(line, depth, cond, pos, n, lang);	251	Lang.comments(line, depth, cond, pos, n, lang);
252	INC(pos)	252	INC(pos)
253	END;	253	END;
254	DEC(pos)	254	DEC(pos)
255	END ProcessComments;	255	END ProcessComments;
256		256
257		257
258	PROCEDURE Comments (text: tText);	258	PROCEDURE Comments (text: tText);
259	VAR	259	VAR
260	line: tLine;	260	line: tLine;
261	i: INTEGER;	261	i: INTEGER;
262	BEGIN	262	BEGIN
263	line := text.first(tLine);	263	line := text.first(tLine);
264	line.cin := 0;	264	line.cin := 0;
265	line.cout := 0;	265	line.cout := 0;
266	i := 0;	266	i := 0;
267	ProcessComments(line, line.cout, i, -1, line.length - 1, text.lang);	267	ProcessComments(line, line.cout, i, -1, line.length - 1, text.lang);
268	NextLine(line);	268	NextLine(line);
269	WHILE line # NIL DO	269	WHILE line # NIL DO
270	line.cin := line.prev(tLine).cout;	270	line.cin := line.prev(tLine).cout;
271	line.cout := line.cin;	271	line.cout := line.cin;
272	i := 0;	272	i := 0;
273	ProcessComments(line, line.cout, i, -1, line.length - 1, text.lang);	273	ProcessComments(line, line.cout, i, -1, line.length - 1, text.lang);
274	NextLine(line)	274	NextLine(line)
275	END;	275	END;
276	text.comments := FALSE	276	text.comments := FALSE
277	END Comments;	277	END Comments;
278		278
279		279
280	PROCEDURE parse (text: tText; line: tLine; y: INTEGER; backColor: INTEGER; lang: INTEGER);	280	PROCEDURE parse (text: tText; line: tLine; y: INTEGER; backColor: INTEGER; lang: INTEGER);
281	VAR	281	VAR
282	c: WCHAR;	282	c: WCHAR;
283	i, n, k: INTEGER;	283	i, n, k: INTEGER;
284	cond, depth: INTEGER;	284	cond, depth: INTEGER;
285	color: INTEGER;	285	color: INTEGER;
286	hex: BOOLEAN;	286	hex: BOOLEAN;
287	isDgt: PROCEDURE (c: WCHAR): BOOLEAN;	287	isDgt: PROCEDURE (c: WCHAR): BOOLEAN;
288		288
289		289
290	PROCEDURE PrintLex (text: tText; line: tLine; lexStart, lexEnd: INTEGER; y: INTEGER; color, backColor: INTEGER);	290	PROCEDURE PrintLex (text: tText; line: tLine; lexStart, lexEnd: INTEGER; y: INTEGER; color, backColor: INTEGER);
291	VAR	291	VAR
292	lexLen: INTEGER;	292	lexLen: INTEGER;
293	BEGIN	293	BEGIN
294	SetColor(color, backColor);	294	SetColor(color, backColor);
295	lexLen := MAX(MIN(line.length - lexStart, lexEnd - lexStart + 1), 0);	295	lexLen := MAX(MIN(line.length - lexStart, lexEnd - lexStart + 1), 0);
296	G.TextOut(canvas, padding.left + (lexStart - text.scroll.X) * charWidth, y, Lines.getPChar(line, lexStart), lexLen)	296	G.TextOut(canvas, padding.left + (lexStart - text.scroll.X) * charWidth, y, Lines.getPChar(line, lexStart), lexLen)
297	END PrintLex;	297	END PrintLex;
298		298
299		299
300	PROCEDURE PrintComment (text: tText; line: tLine; VAR depth, i: INTEGER; y: INTEGER; backColor: INTEGER);	300	PROCEDURE PrintComment (text: tText; line: tLine; VAR depth, i: INTEGER; y: INTEGER; backColor: INTEGER);
301	VAR	301	VAR
302	lexStart: INTEGER;	302	lexStart: INTEGER;
303	color: INTEGER;	303	color: INTEGER;
304	BEGIN	304	BEGIN
305	IF (text.lang = Lang.langLua) & ~ODD(depth) THEN	305	IF (text.lang = Lang.langLua) & ~ODD(depth) THEN
306	color := colors.string	306	color := colors.string
307	ELSIF (text.lang = Lang.langIni) & (depth = 1) THEN	307	ELSIF (text.lang = Lang.langIni) & (depth = 1) THEN
308	color := colors.key2	308	color := colors.key2
309	ELSIF (text.lang = Lang.langPascal) & (depth = 3) THEN	309	ELSIF (text.lang = Lang.langPascal) & (depth = 3) THEN
310	color := colors.key3	310	color := colors.key3
311	ELSE	311	ELSE
312	color := colors.comment	312	color := colors.comment
313	END;	313	END;
314	lexStart := MAX(i - 2, 0);	314	lexStart := MAX(i - 2, 0);
315	ProcessComments(line, depth, i, 0, line.length - 1, text.lang);	315	ProcessComments(line, depth, i, 0, line.length - 1, text.lang);
316	PrintLex(text, line, lexStart, i, y, color, backColor)	316	PrintLex(text, line, lexStart, i, y, color, backColor)
317	END PrintComment;	317	END PrintComment;
318		318
319		319
320	PROCEDURE cap (c: WCHAR): WCHAR;	320	PROCEDURE cap (c: WCHAR): WCHAR;
321	BEGIN	321	BEGIN
322	IF U.cap(c) THEN END	322	IF U.cap(c) THEN END
323	RETURN c	323	RETURN c
324	END cap;	324	END cap;
325		325
326		326
327	PROCEDURE UL (c: WCHAR): BOOLEAN;	327	PROCEDURE UL (c: WCHAR): BOOLEAN;
328	RETURN (cap(c) = "U") OR (cap(c) = "L")	328	RETURN (cap(c) = "U") OR (cap(c) = "L")
329	END UL;	329	END UL;
330		330
331		331
332	PROCEDURE FL (c: WCHAR): BOOLEAN;	332	PROCEDURE FL (c: WCHAR): BOOLEAN;
333	RETURN (cap(c) = "F") OR (cap(c) = "L")	333	RETURN (cap(c) = "F") OR (cap(c) = "L")
334	END FL;	334	END FL;
335		335
336		336
337	PROCEDURE isFASMdelim (c: WCHAR): BOOLEAN;	337	PROCEDURE isFASMdelim (c: WCHAR): BOOLEAN;
338	VAR	338	VAR
339	s: ARRAY 19 OF WCHAR;	339	s: ARRAY 19 OF WCHAR;
340	i: INTEGER;	340	i: INTEGER;
341	BEGIN	341	BEGIN
342	s := "{}[]<>:,()&*/\|+-\#";	342	s := "{}[]<>:,()&*/\|+-\#";
343	i := LEN(s) - 2;	343	i := LEN(s) - 2;
344	WHILE (i >= 0) & (c # s[i]) DO	344	WHILE (i >= 0) & (c # s[i]) DO
345	DEC(i)	345	DEC(i)
346	END	346	END
347	RETURN i >= 0	347	RETURN i >= 0
348	END isFASMdelim;	348	END isFASMdelim;
349		349
350		350
351	PROCEDURE ident (text: tText; VAR i: INTEGER; first, y: INTEGER; line: tLine; backColor: INTEGER; cs: BOOLEAN);	351	PROCEDURE ident (text: tText; VAR i: INTEGER; first, y: INTEGER; line: tLine; backColor: INTEGER; cs: BOOLEAN);
352	VAR	352	VAR
353	c: WCHAR;	353	c: WCHAR;
354	lexLen: INTEGER;	354	lexLen: INTEGER;
355	s: ARRAY 32 OF WCHAR;	355	s: ARRAY 32 OF WCHAR;
356	color: INTEGER;	356	color: INTEGER;
357	BEGIN	357	BEGIN
358	c := getChar(line, i);	358	c := getChar(line, i);
359	WHILE U.isLetter(c) OR (c = "_") OR U.isDigit(c) DO	359	WHILE U.isLetter(c) OR (c = "_") OR U.isDigit(c) DO
360	INC(i);	360	INC(i);
361	c := getChar(line, i);	361	c := getChar(line, i);
362	END;	362	END;
363	DEC(i);	363	DEC(i);
364	lexLen := getString(line, first, i - first + 1, s);	364	lexLen := getString(line, first, i - first + 1, s);
365	IF ~cs THEN	365	IF ~cs THEN
366	U.upcase16(s)	366	U.upcase16(s)
367	END;	367	END;
368	IF Lang.isKey(s, text.lang, 1) THEN	368	IF Lang.isKey(s, text.lang, 1) THEN
369	color := colors.key1	369	color := colors.key1
370	ELSIF Lang.isKey(s, text.lang, 2) THEN	370	ELSIF Lang.isKey(s, text.lang, 2) THEN
371	color := colors.key2	371	color := colors.key2
372	ELSIF Lang.isKey(s, text.lang, 3) THEN	372	ELSIF Lang.isKey(s, text.lang, 3) THEN
373	color := colors.key3	373	color := colors.key3
374	ELSE	374	ELSE
375	color := colors.text	375	color := colors.text
376	END;	376	END;
377	IF color # colors.text THEN	377	IF color # colors.text THEN
378	PrintLex(text, line, first, i, y, color, backColor)	378	PrintLex(text, line, first, i, y, color, backColor)
379	END	379	END
380	END ident;	380	END ident;
381		381
382		382
383	PROCEDURE String (text: tText; line: tLine; VAR i: INTEGER; y: INTEGER; backColor: INTEGER);	383	PROCEDURE String (text: tText; line: tLine; VAR i: INTEGER; y: INTEGER; backColor: INTEGER);
384	VAR	384	VAR
385	k: INTEGER;	385	k: INTEGER;
386	BEGIN	386	BEGIN
387	k := i;	387	k := i;
388	Lang.SkipString(line, i, line.length - 1);	388	Lang.SkipString(line, i, line.length - 1);
389	PrintLex(text, line, k, i, y, colors.string, backColor)	389	PrintLex(text, line, k, i, y, colors.string, backColor)
390	END String;	390	END String;
391		391
392		392
393	BEGIN	393	BEGIN
394	depth := line.cin;	394	depth := line.cin;
395	n := line.length - 1;	395	n := line.length - 1;
396	i := 0;	396	i := 0;
397	IF (depth > 0) & (n >= 0) THEN	397	IF (depth > 0) & (n >= 0) THEN
398	PrintComment(text, line, depth, i, y, backColor)	398	PrintComment(text, line, depth, i, y, backColor)
399	END;	399	END;
400	cond := 0;	400	cond := 0;
401	WHILE i <= n DO	401	WHILE i <= n DO
402	c := getChar(line, i);	402	c := getChar(line, i);
403		403
404	IF lang = Lang.langFasm THEN	404	IF lang = Lang.langFasm THEN
405		405
406	IF c = ";" THEN	406	IF c = ";" THEN
407	PrintLex(text, line, i, n, y, colors.comment, backColor);	407	PrintLex(text, line, i, n, y, colors.comment, backColor);
408	i := n	408	i := n
409	ELSIF (c = "'") OR (c = '"') THEN	409	ELSIF (c = "'") OR (c = '"') THEN
410	String(text, line, i, y, backColor)	410	String(text, line, i, y, backColor)
411	ELSIF (U.isLetter(c) OR (c = "_")) THEN	411	ELSIF (U.isLetter(c) OR (c = "_")) THEN
412	ident(text, i, i, y, line, backColor, Lang.isCS(lang))	412	ident(text, i, i, y, line, backColor, Lang.isCS(lang))
413	ELSIF isFASMdelim(c) THEN	413	ELSIF isFASMdelim(c) THEN
414	PrintLex(text, line, i, i, y, colors.delim, backColor)	414	PrintLex(text, line, i, i, y, colors.delim, backColor)
415	ELSIF U.isDigit(c) THEN	415	ELSIF U.isDigit(c) THEN
416	hex := FALSE;	416	hex := FALSE;
417	k := i;	417	k := i;
418	INC(i);	418	INC(i);
419	c := getChar(line, i);	419	c := getChar(line, i);
420	IF (cap(c) = "X") & (getChar(line, i - 1) = "0") THEN	420	IF (cap(c) = "X") & (getChar(line, i - 1) = "0") THEN
421	INC(i);	421	INC(i);
422	hex := TRUE	422	hex := TRUE
423	END;	423	END;
424		424
425	WHILE U.isHex(cap(getChar(line, i))) DO	425	WHILE U.isHex(cap(getChar(line, i))) DO
426	INC(i)	426	INC(i)
427	END;	427	END;
428		428
429	IF (cap(getChar(line, i)) = "H") & ~hex THEN	429	IF (cap(getChar(line, i)) = "H") & ~hex THEN
430	INC(i)	430	INC(i)
431	END;	431	END;
432		432
433	DEC(i);	433	DEC(i);
434	PrintLex(text, line, k, i, y, colors.num, backColor)	434	PrintLex(text, line, k, i, y, colors.num, backColor)
435	END	435	END
436		436
437	ELSIF (lang = Lang.langC) OR (lang = Lang.langJSON) THEN	437	ELSIF (lang = Lang.langC) OR (lang = Lang.langJSON) THEN
438		438
439	IF depth = 0 THEN	439	IF depth = 0 THEN
440	IF c = "/" THEN	440	IF c = "/" THEN
441	IF cond = 0 THEN	441	IF cond = 0 THEN
442	cond := 1	442	cond := 1
443	ELSE	443	ELSE
444	PrintLex(text, line, i - 1, n, y, colors.comment, backColor);	444	PrintLex(text, line, i - 1, n, y, colors.comment, backColor);
445	cond := 0;	445	cond := 0;
446	i := n	446	i := n
447	END	447	END
448	ELSIF (c = "*") & (cond = 1) THEN	448	ELSIF (c = "*") & (cond = 1) THEN
449	depth := 1;	449	depth := 1;
450	INC(i);	450	INC(i);
451	PrintComment(text, line, depth, i, y, backColor);	451	PrintComment(text, line, depth, i, y, backColor);
452	cond := 0	452	cond := 0
453	ELSIF U.isLetter(c) OR (c = "_") OR (c = "'") OR (c = '"') THEN	453	ELSIF U.isLetter(c) OR (c = "_") OR (c = "'") OR (c = '"') THEN
454	k := i;	454	k := i;
455	IF (c = "'") OR (c = '"') THEN	455	IF (c = "'") OR (c = '"') THEN
456	String(text, line, i, y, backColor);	456	String(text, line, i, y, backColor);
457	ELSE	457	ELSE
458	ident(text, i, i - ORD((lang = Lang.langC) & (i > 0) & (getChar(line, i - 1) = "#")), y, line, backColor, Lang.isCS(lang))	458	ident(text, i, i - ORD((lang = Lang.langC) & (i > 0) & (getChar(line, i - 1) = "#")), y, line, backColor, Lang.isCS(lang))
459	END;	459	END;
460	IF lang = Lang.langJSON THEN	460	IF lang = Lang.langJSON THEN
461	WHILE Lines.isSpace(getChar(line, i + 1)) DO	461	WHILE Lines.isSpace(getChar(line, i + 1)) DO
462	INC(i)	462	INC(i)
463	END;	463	END;
464	IF getChar(line, i + 1) = ":" THEN	464	IF getChar(line, i + 1) = ":" THEN
465	PrintLex(text, line, k, i, y, colors.key1, backColor)	465	PrintLex(text, line, k, i, y, colors.key1, backColor)
466	END	466	END
467	END;	467	END;
468	cond := 0	468	cond := 0
469	ELSIF U.isDigit(c) THEN	469	ELSIF U.isDigit(c) THEN
470	k := i;	470	k := i;
471	INC(i);	471	INC(i);
472	c := getChar(line, i);	472	c := getChar(line, i);
473	IF c = "." THEN	473	IF c = "." THEN
474	DEC(i);	474	DEC(i);
475	c := getChar(line, i)	475	c := getChar(line, i)
476	END;	476	END;
477	IF (cap(c) = "X") & (getChar(line, i - 1) = "0") THEN	477	IF (cap(c) = "X") & (getChar(line, i - 1) = "0") THEN
478	REPEAT	478	REPEAT
479	INC(i);	479	INC(i);
480	c := getChar(line, i)	480	c := getChar(line, i)
481	UNTIL ~U.isHex(cap(c));	481	UNTIL ~U.isHex(cap(c));
482	IF UL(c) THEN	482	IF UL(c) THEN
483	INC(i)	483	INC(i)
484	END	484	END
485	ELSIF UL(c) THEN	485	ELSIF UL(c) THEN
486	INC(i)	486	INC(i)
487	ELSIF U.isDigit(c) THEN	487	ELSIF U.isDigit(c) THEN
488	REPEAT	488	REPEAT
489	INC(i)	489	INC(i)
490	UNTIL ~U.isDigit(getChar(line, i));	490	UNTIL ~U.isDigit(getChar(line, i));
491	c := getChar(line, i);	491	c := getChar(line, i);
492	IF UL(c) THEN	492	IF UL(c) THEN
493	INC(i)	493	INC(i)
494	ELSIF c = "." THEN	494	ELSIF c = "." THEN
495	INC(i);	495	INC(i);
496	WHILE U.isDigit(getChar(line, i)) DO	496	WHILE U.isDigit(getChar(line, i)) DO
497	INC(i)	497	INC(i)
498	END;	498	END;
499	c := getChar(line, i);	499	c := getChar(line, i);
500	IF cap(c) = "E" THEN	500	IF cap(c) = "E" THEN

Subversion Repositories Kolibri OS

(root)/programs/develop/cedit/SRC/Text.ob07 – Rev 9181 → 9190