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


﻿(*
    Copyright 2021-2023 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,
    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 = 1;
    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;
        smallChange: INTEGER;
        modified*, smallMove,
        comments, guard, fasm*,
        search, cs, whole: BOOLEAN;
        edition*: tGuard;
        curLine: tLine;
        lang*: INTEGER;
        enc, eol: INTEGER;
        foundList: List.tList;
        foundSel: INTEGER;
        searchText: tString;
        LinesVector: Lines.tVector;
        chLog*: ChangeLog.tLog;
        maxLength*: INTEGER;
        fileName*: RW.tFileName
    END;
 
    tProcedure = PROCEDURE;
 
 
VAR
 
    pdelete: PROCEDURE (text: tText);
    ShowCursor: PROCEDURE;
 
    colors: RECORD
                text, back, seltext, selback, modified, saved, curline, numtext, numback: INTEGER;
                comment, string, escape, num, delim, key1, key2, key3: INTEGER
             END;
    canvas: G.tCanvas;
    drawCursor: BOOLEAN;
    padding: RECORD left, top: INTEGER END;
    size, textsize: tPoint;
    charWidth, charHeight: INTEGER;
    autoIndents*, lineNumbers*, autoBrackets*, trimSpace*: BOOLEAN;
    idxTable: Search.IdxTable;
 
 
PROCEDURE setLang* (text: tText; lang: INTEGER);
BEGIN
	IF text.lang # lang THEN
		text.fasm := lang = Lang.langFasm;
		text.lang := lang
	END;
    text.comments := TRUE;
    Lang.setCurLang(text.lang)
END setLang;
 
 
PROCEDURE setName* (text: tText; name: RW.tFileName);
VAR
    ext: RW.tFileName;
BEGIN
    text.fileName := name;
    U.getFileName(name, ext, ".");
    U.upcase(ext);
    setLang(text, Lang.getLang(ext))
END setName;
 
 
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*;
BEGIN
    lineNumbers := ~lineNumbers
END toggleNumbers;
 
 
PROCEDURE toggleIndents*;
BEGIN
    autoIndents := ~autoIndents
END toggleIndents;
 
 
PROCEDURE toggleBrackets*;
BEGIN
    autoBrackets := ~autoBrackets
END toggleBrackets;
 
 
PROCEDURE toggleTrimSpace*;
BEGIN
    trimSpace := ~trimSpace
END toggleTrimSpace;
 
 
PROCEDURE showCursor*;
BEGIN
	drawCursor := TRUE
END showCursor;
 
 
PROCEDURE hideCursor*;
BEGIN
	drawCursor := FALSE
END hideCursor;
 
 
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] := Lines.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 getLine2 (text: tText; n: INTEGER): tLine;
VAR
	item: tLine;
BEGIN
	IF (0 <= n) & (n < text.count) THEN
		item := Lines.getVectorItem(text.LinesVector, n)
	ELSE
		item := NIL
	END
	RETURN item
END getLine2;
 
 
PROCEDURE Comments (text: tText);
VAR
	line: tLine;
	i, k, cout: INTEGER;
BEGIN
	IF text.smallChange = 1 THEN
		line := getLine2(text, text.cursor.Y);
		IF line.prev # NIL THEN
			line.cin := line.prev(tLine).cout
		ELSE
			line.cin := 0
		END;
		cout := line.cout;
		line.cout := line.cin;
		i := 0;
		ProcessComments(line, line.cout, i, -1, line.length - 1, text.lang);
		IF line.cout # cout THEN
			text.smallChange := 0;
			Comments(text)
		END
	ELSE
		Lines.destroyVector(text.LinesVector);
		text.LinesVector := Lines.createVector(text.count);
		k := 0;
		line := text.first(tLine);
		Lines.setVectorItem(text.LinesVector, k, line);
		INC(k);
		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
			Lines.setVectorItem(text.LinesVector, k, line);
			INC(k);
			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
	END;
	text.smallChange := 0;
	text.comments := FALSE
END Comments;
 
 
PROCEDURE leadingSpaces (line: tLine): INTEGER;
VAR
    i: INTEGER;
BEGIN
    i := 0;
    WHILE Lines.isSpace(Lines.getChar(line, i)) DO
        INC(i)
    END
    RETURN i
END leadingSpaces;
 
 
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, color)
    END PrintLex;
 
 
    PROCEDURE PrintComment (text: tText; line: tLine; VAR depth, i: INTEGER; w, 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 - w, 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 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 := Lines.getChar(line, i);
        WHILE U.isLetter(c) OR (c = "_") OR U.isDigit(c) DO
            INC(i);
            c := Lines.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, j, Start, End: INTEGER;
        c: WCHAR;
    BEGIN
        k := i;
        Lang.SkipString(line, i, line.length - 1, text.lang);
        PrintLex(text, line, k, i, y, colors.string, backColor);
        IF text.lang IN Lang.escLang THEN
	        Start := k + 1;
	        End := i - 1;
	        k := Start;
	        WHILE k <= End DO
	        	c := Lines.getChar(line, k);
	        	IF c = "\" THEN
	        		j := k;
	        		Lang.SkipEsc(line, k, line.length - 1, text.lang);
	        		PrintLex(text, line, j, k, y, colors.escape, backColor)
	        	END;
	        	INC(k)
	        END
        END
    END String;
 
 
BEGIN
    depth := line.cin;
    n := line.length - 1;
    i := 0;
    IF (depth > 0) & (n >= 0) THEN
        PrintComment(text, line, depth, i, 2, y, backColor)
    END;
    cond := 0;
    WHILE i <= n DO
        c := Lines.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 U.isDigit(c) THEN
                hex := FALSE;
                k := i;
                INC(i);
                c := Lines.getChar(line, i);
                IF (cap(c) = "X") & (Lines.getChar(line, i - 1) = "0") THEN
                    INC(i);
                    hex := TRUE
                END;
 
                WHILE U.isHex(cap(Lines.getChar(line, i))) DO
                    INC(i)
                END;
 
                IF (cap(Lines.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, 2, 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) & (Lines.getChar(line, i - 1) = "#")), y, line, backColor, Lang.isCS(lang))
	            	END;
	                IF lang = Lang.langJSON THEN
		                WHILE Lines.isSpace(Lines.getChar(line, i + 1)) DO
		                	INC(i)
		                END;
		                IF Lines.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 := Lines.getChar(line, i);
	                IF c = "." THEN
	                    DEC(i);
	                    c := Lines.getChar(line, i)
	                END;
	                IF (cap(c) = "X") & (Lines.getChar(line, i - 1) = "0") THEN
	                    REPEAT
	                        INC(i);
	                        c := Lines.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(Lines.getChar(line, i));
	                    c := Lines.getChar(line, i);
	                    IF UL(c) THEN
	                        INC(i)
	                    ELSIF c = "." THEN
	                        INC(i);
	                        WHILE U.isDigit(Lines.getChar(line, i)) DO
	                            INC(i)
	                        END;
	                        c := Lines.getChar(line, i);
	                        IF cap(c) = "E" THEN
	                            INC(i);
	                            c := Lines.getChar(line, i);
	                            IF (c = "+") OR (c = "-") THEN
	                                INC(i)
	                            END;
	                            IF U.isDigit(Lines.getChar(line, i)) THEN
	                                WHILE U.isDigit(Lines.getChar(line, i)) DO
	                                    INC(i)
	                                END;
	                                c := Lines.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(Lines.getChar(line, i)) DO
	                INC(i)
	            END;
	            IF i <= n THEN
	                IF Lines.getChar(line, i) = "." THEN
	                    INC(i);
	                    IF Lines.getChar(line, i) = "." THEN
	                        DEC(i)
	                    END;
	                    WHILE U.isDigit(Lines.getChar(line, i)) DO
	                        INC(i)
	                    END;
	                    IF Lines.getChar(line, i) = "E" THEN
	                        INC(i);
	                        IF (Lines.getChar(line, i) = "+") OR (Lines.getChar(line, i) = "-") THEN
	                            INC(i)
	                        END;
	                        WHILE U.isDigit(Lines.getChar(line, i)) DO
	                            INC(i)
	                        END
	                    END
	                ELSIF Lines.getChar(line, i) = "H" THEN
	                    INC(i)
	                ELSIF Lines.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, 2, 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, 2, 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, 2, 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(Lines.getChar(line, i + 1)) = "X") THEN
	                    isDgt := U.isHex;
	                    hex := TRUE;
	                    INC(i, 2)
	                ELSE
	                    isDgt := U.isDigit;
	                    hex := FALSE
	                END;
	                WHILE isDgt(cap(Lines.getChar(line, i))) DO
	                    INC(i)
	                END;
	                IF Lines.getChar(line, i) = "." THEN
	                    INC(i);
	                    IF Lines.getChar(line, i) = "." THEN
	                        DEC(i)
	                    END;
	                    WHILE isDgt(cap(Lines.getChar(line, i))) DO
	                        INC(i)
	                    END
	                END;
	                IF (cap(Lines.getChar(line, i)) = "E") OR hex & (cap(Lines.getChar(line, i)) = "P") THEN
	                    INC(i);
	                    IF (Lines.getChar(line, i) = "-") OR (Lines.getChar(line, i) = "+") THEN
	                        INC(i)
	                    END;
	                    WHILE isDgt(cap(Lines.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, 2, 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 Lines.getChar(line, i + 1) = "$" THEN
	                    depth := 3
	                ELSE
	                    depth := 1
	                END;
	                INC(i);
	                PrintComment(text, line, depth, i, 1, y, backColor);
	                cond := 0
	            ELSIF c = "#" THEN
	                k := i;
	                INC(i);
	                WHILE U.isDigit(Lines.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 ) & (Lines.getChar(line, i - 1) = "#") THEN
	                    color := colors.string
	                ELSE
	                    color := colors.num
	                END;
	                k := i;
	                INC(i);
	                WHILE U.isHex(cap(Lines.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(Lines.getChar(line, i)) DO
	                    INC(i)
	                END;
	                IF Lines.getChar(line, i) = "." THEN
	                    INC(i);
	                    IF Lines.getChar(line, i) = "." THEN
	                        DEC(i)
	                    END;
	                    WHILE U.isDigit(Lines.getChar(line, i)) DO
	                        INC(i)
	                    END;
	                    IF cap(Lines.getChar(line, i)) = "E" THEN
	                        INC(i);
	                        IF (Lines.getChar(line, i) = "-") OR (Lines.getChar(line, i) = "+") THEN
	                            INC(i)
	                        END;
	                        WHILE U.isDigit(Lines.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 = "#")) & (leadingSpaces(line) = i) THEN
	                PrintLex(text, line, i, n, y, colors.comment, backColor);
	                i := n
	            ELSIF c = '"' THEN
	                String(text, line, i, y, backColor)
	            ELSIF c = "[" THEN
	                depth := 1;
	                INC(i);
	                PrintComment(text, line, depth, i, 1, y, backColor)
	            ELSIF U.isDigit(c) THEN
	                k := i;
	                WHILE U.isDigit(Lines.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 plain (text: tText): CB.tBuffer;
VAR
    buf: CB.tBuffer;
    size: INTEGER;
    line: tLine;
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;
    buf := CB.create(size + 2);
    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;
    CB.appends(buf, 0X, 0, 0);
    CB.appends(buf, 0X, 0, 0)
    RETURN buf
END plain;
 
 
PROCEDURE search* (text: tText; s: ARRAY OF WCHAR; cs, whole: BOOLEAN): BOOLEAN;
VAR
	pos: List.tItem;
	res: BOOLEAN;
	plainText, idxData: Search.tBuffer;
BEGIN
	res := TRUE;
	plainText := NIL;
	idxData := 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);
		idxData := Search.index(plainText, idxTable, cs);
		Search.find(plainText, idxTable, text.searchText, whole, text.foundList);
		res := text.foundList.count > 0
	END;
	CB.destroy(plainText);
	CB.destroy(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 setEnc* (text: tText; enc: INTEGER);
BEGIN
	IF text.enc # enc THEN
		ChangeLog.changeInt(text.enc, enc);
		text.enc := enc;
		modify(text)
	END
END setEnc;
 
 
PROCEDURE setEol* (text: tText; eol: INTEGER);
BEGIN
	IF text.eol # eol THEN
		ChangeLog.changeInt(text.eol, eol);
		text.eol := eol;
		modify(text)
	END
END setEol;
 
 
PROCEDURE getEnc* (text: tText): INTEGER;
	RETURN text.enc
END getEnc;
 
 
PROCEDURE getEol* (text: tText): INTEGER;
	RETURN text.eol
END getEol;
 
 
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 := Lines.getChar(text.curLine, cursor.X);
    IF c = TAB1 THEN
        n := cursor.X;
        WHILE Lines.getChar(text.curLine, n) = TAB1 DO
            INC(n)
        END;
        R := n - cursor.X;
        n := cursor.X;
        WHILE Lines.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 Lines.getChar(curLine, i - 1) = TAB THEN
                WHILE Lines.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 Lines.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
        	INC(text.smallChange);
            i := text.cursor.X;
            IF autoIndents THEN
	            n := leadingSpaces(curLine)
            ELSE
    	        n := 0
            END;
            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, Lines.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) & autoIndents 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, Lines.getChar(line2, n - 1));
        DEC(n)
    END;
    Lines.modify(newLine);
    SetPos(text, text.cursor.X, text.cursor.Y)
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 := getLine2(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 := getLine2(text, selEnd.Y);
	text.select^ := selBeg;
	text.select.X := 0;
	SetPos(text, line.length, selEnd.Y);
	IF modified THEN
		INC(text.smallChange);
   		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
    	IF ~selected(text) THEN
    		INC(text.smallChange)
    	END;
        delSelect(text);
        curLine := text.curLine;
        Lines.insert(curLine, text.cursor.X, WCHR(code));
        IF autoBrackets THEN
        	IF code = ORD("(") THEN
        		code := ORD(")")
        	ELSIF code = ORD("[") THEN
        		code := ORD("]")
        	ELSIF code = ORD("{") THEN
        		code := ORD("}")
        	ELSE
        		code := -1
        	END;
        	IF code # -1 THEN
        		Lines.insert(curLine, text.cursor.X + 1, WCHR(code))
        	END
        END;
        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
    		INC(text.smallChange);
	        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);
    file := RW.create(tempFile, text.enc, text.eol);
    IF file # NIL THEN
        ChangeLog.delSaved;
        line := text.first(tLine);
        WHILE line # NIL DO
        	IF trimSpace THEN
        		Len := Lines.trimLength(line)
        	ELSE
        		Len := line.length
        	END;
            RW.putString(file, line, Len);
            NextLine(line);
            IF line # NIL THEN
                RW.newLine(file)
            END
        END;
        res := RW.close(file)
    ELSE
        res := FALSE
    END;
    IF res THEN
        res := File.Copy(tempFile, name);
        IF res THEN
            text.modified := FALSE;
            ChangeLog.save(text.edition);
 
	        line := text.first(tLine);
	        WHILE line # NIL DO
	            IF line.modified THEN
	                Lines.save(line)
	            END;
	            NextLine(line)
	        END
        END
    END;
    IF File.Delete(tempFile) THEN 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 getSelCnt* (text: tText; VAR chars, lines: INTEGER);
VAR
	selBeg, selEnd: tPoint;
	first, last, line: tLine;
 
	PROCEDURE charCnt (line: tLine; first, last: INTEGER): INTEGER;
	VAR
		i, res: INTEGER;
	BEGIN
		res := 0;
		FOR i := first TO last DO
			IF Lines.getChar(line, i) # TAB1 THEN
				INC(res)
			END
		END
		RETURN res
	END charCnt;
 
BEGIN
	IF selected(text) THEN
		getSelect(text, selBeg, selEnd);
		first := getLine2(text, selBeg.Y);
		last  := getLine2(text, selEnd.Y);
		lines := selEnd.Y - selBeg.Y + 1;
 
		IF lines > 1 THEN
			chars := charCnt(first, selBeg.X, first.length - 1) + charCnt(last, 0, selEnd.X - 1) + lenEOL;
			line := first.next(tLine);
			WHILE line # last DO
				INC(chars, charCnt(line, 0, line.length - 1) + lenEOL);
				NextLine(line)
			END
		ELSE
			chars := charCnt(first, selBeg.X, selEnd.X - 1)
		END
	ELSE
		chars := 0;
		lines := 0
	END
END getSelCnt;
 
 
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 := getLine2(text, selBeg.Y);
    line := first;
 
    n := selEnd.Y - selBeg.Y;
    cnt := 0;
    WHILE n >= 0 DO
        INC(cnt, line.length + (lenEOL + ORD(U.OS = "KOS")));
        NextLine(line);
        DEC(n)
    END;
 
    buffer := CB.create(cnt + 2); (* +2 wchars EOT *)
 
    n := selEnd.Y - selBeg.Y;
    line := first;
    IF n = 0 THEN
        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 := Lines.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;
    SetPos(text, cursor.X, cursor.Y);
    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;
    func: Lines.fConvert;
BEGIN
    line := text.curLine;
    i := text.cursor.X - 1;
 
    WHILE (i >= 0) & U.isLetter(Lines.getChar(line, i)) DO
        DEC(i)
    END;
 
    IF upper THEN
    	func := U.cap
    ELSE
    	func := U.low
    END;
 
    IF Lines.convert(line, i + 1, text.cursor.X - 1, func) THEN
    	INC(text.smallChange);
        modify(text)
    END
END changeCase;
 
 
PROCEDURE chCase* (text: tText; upper: BOOLEAN);
VAR
    selBeg, selEnd: tPoint;
    first, line: Lines.tLine;
    cnt: INTEGER;
    func: Lines.fConvert;
    modified: BOOLEAN;
BEGIN
    modified := FALSE;
    IF selected(text) THEN
        getSelect(text, selBeg, selEnd);
        first := getLine2(text, selBeg.Y);
        line := first;
        cnt := selEnd.Y - selBeg.Y;
 
	    IF upper THEN
	    	func := U.cap
	    ELSE
	    	func := U.low
	    END;
 
        IF cnt = 0 THEN
            IF Lines.convert(line, selBeg.X, selEnd.X - 1, func) THEN
                modified := TRUE
            END
        ELSE
            IF Lines.convert(line, selBeg.X, line.length - 1, func) THEN
                modified := TRUE
            END;
            WHILE cnt > 1 DO
                NextLine(line);
                IF Lines.convert(line, 0, line.length - 1, func) THEN
                    modified := TRUE
                END;
                DEC(cnt)
            END;
            NextLine(line);
            IF Lines.convert(line, 0, selEnd.X - 1, func) THEN
                modified := TRUE
            END
        END
    END;
    IF modified THEN
    	INC(text.smallChange);
        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
	text.smallChange := 2;
    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 MoveLines* (text: tText; down: BOOLEAN);
VAR
	last, first, line: tLine;
	selBeg, selEnd, temp: tPoint;
	step: INTEGER;
	frw: BOOLEAN;
BEGIN
	getSelect(text, selBeg, selEnd);
	IF ((selBeg.Y > 0) & ~down OR (selEnd.Y < text.count - 1) & down) THEN
		modify(text);
		step := ORD(down)*2 - 1;
		IF selBeg.Y # selEnd.Y THEN
			frw := (text.cursor.X = selEnd.X) & (text.cursor.Y = selEnd.Y);
 
			IF down # frw THEN
				temp := text.cursor^;
				SetPos(text, 0, text.select.Y);
				setSelect(text);
				text.select^ := temp
			END;
 
			ASSERT(selBeg.Y < selEnd.Y);
 
			first := getLine(text, selBeg.Y);
			last := getLine(text, selEnd.Y);
 
			line := first;
			Lines.modify(line);
			REPEAT
				NextLine(line);
				Lines.modify(line)
			UNTIL line = last;
 
			IF down THEN
				text.curLine := last.prev(tLine)
			ELSE
				text.curLine := first.next(tLine)
			END;
			selBeg.X := 0;
			selEnd.X := last.length;
			IF down THEN
				last := last.next(tLine);
				List._delete(text, last);
				List._insert(text, first.prev, last)
			ELSE
				first := first.prev(tLine);
				List._delete(text, first);
				List._insert(text, last, first)
			END;
			IF down THEN
				temp := selBeg;
				selBeg := selEnd;
				selEnd := temp;
			END;
			SetPos(text, selBeg.X, selBeg.Y + step);
			setSelect(text);
			text.select.X := selEnd.X;
			text.select.Y := selEnd.Y + step
		ELSE
			first := getLine(text, selBeg.Y);
			Lines.modify(first);
			IF down THEN
				last := first.next(tLine)
			ELSE
				last := first.prev.prev(tLine)
			END;
			List._delete(text, first);
			List._insert(text, last, first);
			INC(text.cursor.Y, step);
			INC(text.select.Y, step);
			SetPos(text, text.cursor.X, text.cursor.Y)
		END
	END
END MoveLines;
 
 
PROCEDURE isWordChar (c: WCHAR): BOOLEAN;
    RETURN U.isLetter(c) OR U.isDigit(c) OR (c = "_")
END isWordChar;
 
 
PROCEDURE getSelectedText* (text: tText; VAR s: ARRAY OF WCHAR);
VAR
    n: INTEGER;
    selBeg, selEnd: tPoint;
BEGIN
	s[0] := 0X;
    IF selected(text) & (text.cursor.Y = text.select.Y) THEN
        getSelect(text, selBeg, selEnd);
        n := getString(text.curLine, selBeg.X, selEnd.X - selBeg.X, s)
    END
END getSelectedText;
 
 
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(Lines.getChar(curLine, x1 - 1))) OR
            ((x2 < curLine.length) & isWordChar(Lines.getChar(curLine, x2))) THEN
            str := ""
        END
    END;
    IF text.searchText # str THEN
    	text.smallMove := FALSE
    END;
    IF search(text, str, Lang.isCS(text.lang), TRUE) THEN END
END wordSel;
 
 
PROCEDURE getWordPos (line: tLine; pos: INTEGER): INTEGER;
VAR
	c: WCHAR;
BEGIN
	c := Lines.getChar(line, pos);
	IF isWordChar(c) THEN
		WHILE (pos < line.length) & isWordChar(Lines.getChar(line, pos)) DO
			INC(pos)
		END
	ELSIF Lines.isSpace(c) THEN
		WHILE (pos < line.length) & Lines.isSpace(Lines.getChar(line, pos)) DO
			INC(pos)
		END
	ELSE
		WHILE (pos < line.length) & ~Lines.isSpace(Lines.getChar(line, pos)) & ~isWordChar(Lines.getChar(line, pos)) DO
			INC(pos)
		END
	END
	RETURN pos
END getWordPos;
 
 
PROCEDURE key* (text: tText; code: INTEGER; shift, ctrl: BOOLEAN);
VAR
	n, wPos: INTEGER;
	scrX, scrY: INTEGER;
	resSel: BOOLEAN;
BEGIN
	resSel := FALSE;
    IF shift THEN
        setSelect(text)
    ELSE
        IF (33 <= code) & (code <= 40) THEN
        	IF ~(((code = 38) OR (code = 40)) & ctrl) THEN
        		resSel := selected(text);
	            resetSelect(text)
            END
        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
	            n := 0
        	END;
        	SetPos(text, n, text.cursor.Y)
        END
    |37:
        IF (text.cursor.X = 0) & (text.curLine.prev # NIL) THEN
            SetPos(text, text.curLine.prev(tLine).length, text.cursor.Y - 1)
        ELSE
        	scrX := text.scroll.X;
        	scrY := text.scroll.Y;
        	IF ctrl THEN
        		wPos := 0;
        		REPEAT
        			n := wPos;
        			wPos := getWordPos(text.curLine, wPos)
        		UNTIL wPos >= text.cursor.X;
				move(text, n - text.cursor.X)
        	ELSE
            	move(text, -1)
            END;
            text.smallMove := (scrX = text.scroll.X) & (scrY = text.scroll.Y) & ~resSel
        END
    |38:
        IF ctrl THEN
            MoveLines(text, FALSE)
        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
        	scrX := text.scroll.X;
        	scrY := text.scroll.Y;
        	IF ctrl THEN
				move(text, getWordPos(text.curLine, text.cursor.X) - text.cursor.X)
        	ELSE
            	move(text, 1)
        	END;
        	text.smallMove := (scrX = text.scroll.X) & (scrY = text.scroll.Y) & ~resSel
        END
    |40:
        IF ctrl THEN
            MoveLines(text, TRUE)
        ELSE
            UpDown(text, 1)
        END
    |46:
        IF ctrl THEN
            delLine(text)
        ELSE
        	IF ~selected(text) & (text.cursor.X < text.curLine.length) THEN
        		INC(text.smallChange)
        	END;
            delete(text);
            ShowCursor
        END
    |ORD("C"), ORD("X"):
        IF ctrl THEN
            IF selected(text) THEN
                copy(text);
                IF code = ORD("X") THEN
                	delSelect(text)
                END
            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(Lines.getChar(line, cursorX)) THEN
        x2 := cursorX;
        WHILE (x2 < line.length) & isWordChar(Lines.getChar(line, x2)) DO
            INC(x2)
        END
    ELSE
        WHILE (x1 >= 0) & ~isWordChar(Lines.getChar(line, x1)) DO
            DEC(x1)
        END;
        x2 := x1 + 1
    END;
    WHILE (x1 >= 0) & isWordChar(Lines.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, y1, y2, scrollX, scrollY: INTEGER;
    cursor: pPoint;
BEGIN
	IF drawCursor THEN
	    cursor := text.cursor;
	    scrollX := text.scroll.X;
	    scrollY := text.scroll.Y;
	    IF ~((scrollY > cursor.Y) OR (scrollY + textsize.Y + 1 <= cursor.Y) OR
	       (scrollX > cursor.X) OR (scrollX + textsize.X <= cursor.X)) THEN
	        x := (cursor.X - scrollX)*charWidth + padding.left;
	        y1 := (cursor.Y - scrollY)*charHeight + padding.top + (inter DIV 2 + 1);
	        y2 := y1 + charHeight - (inter + 2);
	        G.notVLine(canvas, x, y1, y2);
	        G.notVLine(canvas, x - 1, y1, y2)
	    END
    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 - 1, y - inter DIV 2, x + Len*charWidth, y - inter DIV 2 + charHeight);
    G.TextOut(canvas, pos*charWidth + padding.left, y, Lines.getPChar(line, firstCharIdx), Len, colors.seltext)
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, 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.comments THEN
        Comments(text)
    END;
    IF text.search & search(text, text.searchText, text.cs, text.whole) THEN 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);
    IF ~text.smallMove THEN
    	G.clear(canvas)
    END;
    wNum := charWidth;
    IF lineNumbers 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;
    firstLine := getLine2(text, n);
 
    IF text.smallMove THEN
    	line := text.curLine;
    	cnt := textsize.Y;
    	y := y + charHeight*(text.cursor.Y - text.scroll.Y);
    	G.SetColor(canvas, colors.back);
    	G.FillRect(canvas, padding.left - 2, y - inter DIV 2, size.X - 1, y - inter DIV 2 + charHeight);
    	n := text.cursor.Y
    ELSE
	    line := firstLine;
    	cnt := 0
    END;
 
    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);
		IF (selBeg.Y < n) & (n < selEnd.Y) THEN
			drawSelect(text, line, 0, line.length, y)
		ELSE
			G.TextOut(canvas, padding.left, y, Lines.getPChar(line, text.scroll.X), MIN(MAX(line.length - text.scroll.X, 0), textsize.X + 1), colors.delim);
			IF text.lang # Lang.langText THEN
				parse(text, line, y, backColor, text.lang)
			END
		END;
		IF (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;
        mark(line, y - inter DIV 2);
        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 lineNumbers 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))
            ELSE
                G.SetColor(canvas, colors.numtext);
                G.HLine(canvas, y - inter DIV 2 + charHeight DIV 2, xNum - wNum DIV (1 + ORD(i MOD 5 # 0)), 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 + 1));
                G.xorVLine(canvas, x, y, y + charHeight - (inter + 1))
            END
        END;
        NextLine(line);
        INC(y, charHeight)
    END;
 
    IF text.searchText # "" THEN
    	IF text.smallMove THEN
    		firstLine := text.curLine;
    		lastLine := firstLine
    	ELSE
    	    lastLine := getLine2(text, MIN(text.scroll.Y + textsize.Y + 1, text.count) - 1)
        END;
        p := text.foundList.first(Search.tPos);
        WHILE p # NIL DO
        	y := padding.top + inter DIV 2;
        	IF text.smallMove THEN
        		y := y + charHeight*(text.cursor.Y - text.scroll.Y)
            END;
            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;
 
    text.smallMove := FALSE;
 
    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;
	cursor(text)
END draw;
 
 
PROCEDURE switch* (text: tText);
BEGIN
    ChangeLog.set(text.chLog);
    Lines.setMaxLength(text.maxLength);
    Lang.setCurLang(text.lang)
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.smallMove := FALSE;
    text.comments := TRUE;
    text.search := TRUE;
    text.cs := FALSE;
    text.whole := FALSE;
    text.guard := TRUE;
    text.edition := NIL;
    text.foundList := List.create(NIL);
    text.searchText := "";
    text.foundSel := 0;
    text.CurX := -1;
    text.smallChange := 0;
    text.lang := Lang.langText;
    text.LinesVector := NIL;
    Lang.setCurLang(Lang.langText);
    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, escape, 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.escape  := escape;
    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;
    ChangeLog.destroy(text.chLog);
    Lines.destroyVector(text.LinesVector);
    DISPOSE(text.foundList);
    DISPOSE(text.cursor);
    DISPOSE(text.select2);
    DISPOSE(text)
END destroy;
 
 
PROCEDURE open* (name: RW.tFileName; ptr, size: INTEGER; VAR errno: INTEGER): tText;
VAR
    text: tText;
    file: RW.tInput;
    n, enc, eol: INTEGER;
    _eol: BOOLEAN;
    line: tLine;
BEGIN
    errno := 0;
    text := create(name);
    IF text # NIL THEN
    	IF ptr = 0 THEN
    		file := RW.loadFromFile(name, enc, eol)
    	ELSE
    		file := RW.loadFromMem(ptr, size, enc, eol)
    	END;
    	IF file = NIL THEN
    		destroy(text)
    	END
    ELSE
    	file := NIL
    END;
    IF file # NIL THEN
        ChangeLog.changeInt(text.enc, enc);
        ChangeLog.changeInt(text.eol, eol);
        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);
        Comments(text)
    ELSE
        errno := 1
    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 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)
        ELSIF n > sLen THEN
            Lines.delCharN(line, i, n - sLen)
        ELSE (* n = sLen *)
        	Lines.copy(line)
        END;
        SetPos(text, i + sLen, text.cursor.Y);
	    WHILE sLen > 0 DO
	        DEC(sLen);
	        Lines.setChar(line, i + sLen, s[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 conv (VAR c: WCHAR; cp: E.CP; enc: INTEGER): BOOLEAN;
VAR
	code: INTEGER;
	res: BOOLEAN;
BEGIN
	res := FALSE;
	IF (c # 0X) & (c # Lines.NUL) & (c # Lines.TAB1) THEN
		code := E.UNI[ORD(c), enc];
		IF (0 <= code) & (code <= 255) THEN
			code := cp[code]
		ELSE
			code := ORD(c)
		END;
		IF code # ORD(c) THEN
			c := WCHR(code);
			res := TRUE
		END
	END
	RETURN res
END conv;
 
 
PROCEDURE conv1251to866 (VAR c: WCHAR): BOOLEAN;
	RETURN conv(c, E.cp866, E.CP1251)
END conv1251to866;
 
 
PROCEDURE conv866to1251 (VAR c: WCHAR): BOOLEAN;
	RETURN conv(c, E.cp1251, E.CP866)
END conv866to1251;
 
 
PROCEDURE convert* (text: tText; (*cp: E.CP;*) enc: INTEGER);
VAR
	line: tLine;
	func: Lines.fConvert;
	modified: BOOLEAN;
BEGIN
	modified := FALSE;
	line := text.first(tLine);
	IF enc = E.CP866 THEN
		func := conv866to1251
	ELSIF enc = E.CP1251 THEN
		func := conv1251to866
	ELSE
		line := NIL
	END;
 
	WHILE line # NIL DO
		IF Lines.convert(line, 0, line.length - 1, func) THEN
			modified := TRUE
		END;
		NextLine(line)
	END;
 
	IF modified THEN
		modify(text)
	END
END convert;
 
 
PROCEDURE New* (): tText;
VAR
    text: tText;
BEGIN
    text := create("");
    List._append(text, Lines.create(FALSE));
    text.curLine := text.first(tLine);
    ChangeLog.changeInt(text.enc, E.CP866);
    ChangeLog.changeInt(text.eol, E.EOL_CRLF);
    text.enc := E.CP866;
    text.eol := E.EOL_CRLF;
    SetPos(text, 0, 0);
    resetSelect(text)
    RETURN text
END New;
 
 
PROCEDURE empty* (text: tText): BOOLEAN;
	RETURN (text.count = 1) & (text.curLine.length = 0)
END empty;
 
 
PROCEDURE init* (pShowCursor: tProcedure; _lineNumbers, _autoIndents, _autoBrackets, _trimSpace: BOOLEAN);
BEGIN
    ShowCursor := pShowCursor;
    pdelete := delete;
    drawCursor := TRUE;
    lineNumbers := _lineNumbers;
    autoIndents := _autoIndents;
    autoBrackets := _autoBrackets;
    trimSpace := _trimSpace;
    padding.left := pad_left;
    padding.top := pad_top;
END init;
 
 
END Text.

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

Subversion Repositories Kolibri OS

(root)/programs/develop/cedit/SRC/Text.ob07 – Rev 9891 → 9892