| 0,0 → 1,508 |
|---|
| (* |
| Copyright 2021 Anton Krotov |
| |
| This file is part of CEdit. |
| |
| CEdit is free software: you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by |
| the Free Software Foundation, either version 3 of the License, or |
| (at your option) any later version. |
| |
| CEdit is distributed in the hope that it will be useful, |
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| GNU General Public License for more details. |
| |
| You should have received a copy of the GNU General Public License |
| along with CEdit. If not, see <http://www.gnu.org/licenses/>. |
| *) |
| |
| MODULE RW; |
| |
| IMPORT |
| File, SYSTEM, KOSAPI, E := Encodings, |
| CB := Clipboard, Lines; |
| |
| |
| CONST |
| |
| CR = 0DX; LF = 0AX; TAB = 9X; SPACE = 20X; |
| BOM = 0FEFFX; |
| |
| TAB_SIZE* = 4; |
| |
| BUF_SIZE = 65536; |
| |
| NAME_LEN = 1024; |
| |
| EOL_LF* = 0; EOL_CRLF* = 1; EOL_CR* = 2; |
| |
| |
| TYPE |
| |
| tFileName* = ARRAY NAME_LEN OF CHAR; |
| |
| tEOL = ARRAY 3 OF WCHAR; |
| |
| tInput* = POINTER TO RECORD |
| buffer: INTEGER; |
| pos, cnt: INTEGER; |
| enc: INTEGER; |
| CR: BOOLEAN; |
| clipbrd: BOOLEAN; |
| getChar: PROCEDURE (file: tInput): INTEGER |
| END; |
| |
| tOutput* = POINTER TO RECORD |
| handle: File.FS; |
| buffer: ARRAY BUF_SIZE OF BYTE; |
| pos: INTEGER; |
| eol: tEOL; |
| putChar: PROCEDURE (file: tOutput; code: INTEGER): BOOLEAN |
| END; |
| |
| |
| VAR |
| |
| eol*: ARRAY 3 OF tEOL; |
| |
| |
| PROCEDURE getByte (file: tInput): BYTE; |
| VAR |
| res: BYTE; |
| BEGIN |
| IF file.cnt > 0 THEN |
| SYSTEM.GET8(file.buffer + file.pos, res); |
| INC(file.pos); |
| DEC(file.cnt) |
| ELSE |
| res := 0 |
| END |
| RETURN res |
| END getByte; |
| |
| |
| PROCEDURE peakByte (file: tInput): BYTE; |
| VAR |
| res: BYTE; |
| BEGIN |
| IF file.cnt > 0 THEN |
| SYSTEM.GET8(file.buffer + file.pos, res) |
| ELSE |
| res := 0 |
| END |
| RETURN res |
| END peakByte; |
| |
| |
| PROCEDURE getCharUTF8 (file: tInput): INTEGER; |
| VAR |
| code, n: INTEGER; |
| b: BYTE; |
| BEGIN |
| b := getByte(file); |
| IF b <= 07FH THEN |
| n := 0 |
| ELSIF (0C0H <= b) & (b <= 0DFH) THEN |
| DEC(b, 0C0H); |
| n := 1 |
| ELSIF (0E0H <= b) & (b <= 0EFH) THEN |
| DEC(b, 0E0H); |
| n := 2 |
| ELSIF (0F0H <= b) & (b <= 0F7H) THEN |
| DEC(b, 0F0H); |
| n := 3 |
| ELSIF (0F8H <= b) & (b <= 0FBH) THEN |
| DEC(b, 0F8H); |
| n := 4 |
| ELSIF (0FCH <= b) & (b <= 0FDH) THEN |
| DEC(b, 0FCH); |
| n := 5 |
| ELSIF b = 0FEH THEN |
| b := 0; |
| n := 6 |
| ELSIF b = 0FFH THEN |
| n := -1 |
| ELSIF (080H <= b) & (b <= 0BFH) THEN |
| n := -1 |
| END; |
| |
| code := b; |
| |
| IF n > 2 THEN |
| n := -1 |
| END; |
| |
| WHILE n > 0 DO |
| DEC(n); |
| b := peakByte(file); |
| IF (080H <= b) & (b <= 0BFH) THEN |
| code := code*64 + getByte(file) - 080H |
| ELSE |
| n := -1 |
| END |
| END; |
| |
| IF n = -1 THEN |
| code := E.UNDEF |
| END |
| |
| RETURN code |
| END getCharUTF8; |
| |
| |
| PROCEDURE getCharW1251 (file: tInput): INTEGER; |
| RETURN E.cpW1251[getByte(file)] |
| END getCharW1251; |
| |
| |
| PROCEDURE getCharCP866 (file: tInput): INTEGER; |
| RETURN E.cp866[getByte(file)] |
| END getCharCP866; |
| |
| |
| PROCEDURE getCharUTF16LE (file: tInput): INTEGER; |
| RETURN getByte(file) + getByte(file) * 256 |
| END getCharUTF16LE; |
| |
| |
| PROCEDURE getString* (file: tInput; line: Lines.tLine; VAR eol: BOOLEAN): INTEGER; |
| VAR |
| c: WCHAR; |
| i, L, k, n: INTEGER; |
| s: ARRAY 1000 OF WCHAR; |
| BEGIN |
| L := LEN(s); |
| eol := FALSE; |
| n := 0; |
| i := ORD(file.cnt > 0) - 1; |
| WHILE (file.cnt > 0) & ~eol DO |
| c := WCHR(file.getChar(file) MOD 65536); |
| IF c = CR THEN |
| eol := TRUE; |
| file.CR := TRUE |
| ELSIF (c = LF) OR (c = 0X) THEN |
| IF ~file.CR THEN |
| eol := TRUE |
| END; |
| file.CR := FALSE |
| ELSIF c = TAB THEN |
| k := TAB_SIZE - i MOD TAB_SIZE; |
| WHILE k > 0 DO |
| s[i] := SPACE; |
| INC(i); |
| IF i = L THEN |
| Lines.concat(line, s); |
| INC(n, i); |
| i := 0 |
| END; |
| DEC(k) |
| END; |
| file.CR := FALSE |
| ELSIF c = BOM THEN |
| file.CR := FALSE |
| ELSE |
| s[i] := c; |
| INC(i); |
| IF i = L THEN |
| Lines.concat(line, s); |
| INC(n, i); |
| i := 0 |
| END; |
| file.CR := FALSE |
| END |
| END; |
| IF i >= 0 THEN |
| s[i] := 0X; |
| Lines.concat(line, s); |
| END; |
| INC(n, i) |
| RETURN n |
| END getString; |
| |
| |
| PROCEDURE detectEncoding (text: tInput): INTEGER; |
| VAR |
| pos, cnt, res: INTEGER; |
| continue, bom: BOOLEAN; |
| b: BYTE; |
| cp866, w1251: INTEGER; |
| BEGIN |
| pos := text.pos; |
| cnt := text.cnt; |
| continue := TRUE; |
| WHILE (text.cnt > 0) & continue DO |
| IF getByte(text) > 127 THEN |
| continue := FALSE |
| END |
| END; |
| text.cnt := cnt; |
| text.pos := pos; |
| IF continue THEN |
| res := E.CP866 |
| ELSE |
| bom := getCharUTF8(text) = ORD(BOM); |
| continue := TRUE; |
| text.cnt := cnt; |
| text.pos := pos; |
| WHILE (text.cnt > 0) & continue DO |
| IF getCharUTF8(text) = E.UNDEF THEN |
| continue := FALSE |
| END |
| END; |
| IF continue THEN |
| IF bom THEN |
| res := E.UTF8BOM |
| ELSE |
| res := E.UTF8 |
| END |
| ELSE |
| text.cnt := cnt; |
| text.pos := pos; |
| cp866 := 0; |
| w1251 := 0; |
| WHILE text.cnt > 0 DO |
| b := getByte(text); |
| IF b > 127 THEN |
| IF b >= 192 THEN |
| INC(w1251) |
| ELSE |
| INC(cp866) |
| END |
| END |
| END; |
| IF w1251 > cp866 THEN |
| res := E.W1251 |
| ELSE |
| res := E.CP866 |
| END |
| END; |
| text.cnt := cnt; |
| text.pos := pos |
| END |
| RETURN res |
| END detectEncoding; |
| |
| |
| PROCEDURE load* (name: tFileName; VAR enc: INTEGER): tInput; |
| VAR |
| res: tInput; |
| fsize: INTEGER; |
| BEGIN |
| NEW(res); |
| res.pos := 0; |
| res.CR := FALSE; |
| res.getChar := NIL; |
| res.clipbrd := FALSE; |
| fsize := File.FileSize(name); |
| IF fsize = 0 THEN |
| res.buffer := KOSAPI.malloc(4096); |
| ASSERT(res.buffer # 0); |
| res.cnt := 0 |
| ELSE |
| res.buffer := File.Load(name, res.cnt) |
| END; |
| IF res.buffer = 0 THEN |
| DISPOSE(res) |
| ELSE |
| enc := detectEncoding(res); |
| IF (enc = E.UTF8BOM) OR (enc = E.UTF8) THEN |
| res.getChar := getCharUTF8 |
| ELSIF enc = E.CP866 THEN |
| res.getChar := getCharCP866 |
| ELSIF enc = E.W1251 THEN |
| res.getChar := getCharW1251 |
| END; |
| res.enc := enc |
| END |
| RETURN res |
| END load; |
| |
| |
| PROCEDURE clipboard* (): tInput; |
| VAR |
| res: tInput; |
| BEGIN |
| NEW(res); |
| res.pos := 0; |
| res.CR := FALSE; |
| res.clipbrd := TRUE; |
| res.getChar := NIL; |
| res.enc := E.CP866; |
| res.getChar := getCharCP866; |
| res.buffer := CB.get(res.cnt); |
| IF res.buffer = 0 THEN |
| DISPOSE(res) |
| END |
| RETURN res |
| END clipboard; |
| |
| |
| PROCEDURE putByte (file: tOutput; b: BYTE); |
| VAR |
| c: INTEGER; |
| BEGIN |
| IF file.pos = BUF_SIZE THEN |
| c := File.Write(file.handle, SYSTEM.ADR(file.buffer[0]), BUF_SIZE); |
| file.pos := 0 |
| END; |
| file.buffer[file.pos] := b; |
| INC(file.pos) |
| END putByte; |
| |
| |
| PROCEDURE putString* (file: tOutput; line: Lines.tLine; n: INTEGER): INTEGER; |
| VAR |
| i: INTEGER; |
| BEGIN |
| i := 0; |
| WHILE (i < n) & file.putChar(file, ORD(Lines.getChar(line, i))) DO |
| INC(i) |
| END |
| RETURN i |
| END putString; |
| |
| |
| PROCEDURE newLine* (file: tOutput): BOOLEAN; |
| VAR |
| i: INTEGER; |
| BEGIN |
| i := 0; |
| WHILE (file.eol[i] # 0X) & file.putChar(file, ORD(file.eol[i])) DO |
| INC(i) |
| END |
| RETURN i = LENGTH(file.eol) |
| END newLine; |
| |
| |
| PROCEDURE putCharUTF8 (file: tOutput; code: INTEGER): BOOLEAN; |
| VAR |
| res: BOOLEAN; |
| BEGIN |
| res := TRUE; |
| IF code <= 7FH THEN |
| putByte(file, code) |
| ELSIF (80H <= code) & (code <= 7FFH) THEN |
| putByte(file, code DIV 64 + 0C0H); |
| putByte(file, code MOD 64 + 080H) |
| ELSIF (800H <= code) & (code <= 0FFFFH) THEN |
| putByte(file, code DIV 4096 + 0E0H); |
| putByte(file, (code DIV 64) MOD 64 + 080H); |
| putByte(file, code MOD 64 + 080H) |
| ELSE |
| res := FALSE |
| END |
| RETURN res |
| END putCharUTF8; |
| |
| |
| PROCEDURE putCharW1251 (file: tOutput; code: INTEGER): BOOLEAN; |
| VAR |
| n: INTEGER; |
| res: BOOLEAN; |
| BEGIN |
| res := TRUE; |
| n := E.UNI[code, E.W1251]; |
| IF n # E.UNDEF THEN |
| putByte(file, n) |
| ELSE |
| res := FALSE |
| END |
| RETURN res |
| END putCharW1251; |
| |
| |
| PROCEDURE putCharCP866 (file: tOutput; code: INTEGER): BOOLEAN; |
| VAR |
| n: INTEGER; |
| res: BOOLEAN; |
| BEGIN |
| res := TRUE; |
| n := E.UNI[code, E.CP866]; |
| IF n # E.UNDEF THEN |
| putByte(file, n) |
| ELSE |
| res := FALSE |
| END |
| RETURN res |
| END putCharCP866; |
| |
| |
| PROCEDURE putCharUTF16LE (file: tOutput; code: INTEGER): BOOLEAN; |
| VAR |
| res: BOOLEAN; |
| BEGIN |
| IF (0 <= code) & (code <= 65535) THEN |
| res := TRUE; |
| putByte(file, code MOD 256); |
| putByte(file, code DIV 256) |
| ELSE |
| res := FALSE |
| END |
| RETURN res |
| END putCharUTF16LE; |
| |
| |
| PROCEDURE close* (VAR file: tOutput): BOOLEAN; |
| VAR |
| res: BOOLEAN; |
| BEGIN |
| res := TRUE; |
| IF file # NIL THEN |
| IF file.handle # NIL THEN |
| IF file.pos > 0 THEN |
| res := File.Write(file.handle, SYSTEM.ADR(file.buffer[0]), file.pos) = file.pos |
| END; |
| File.Close(file.handle) |
| END; |
| DISPOSE(file) |
| END |
| RETURN res |
| END close; |
| |
| |
| PROCEDURE create* (name: tFileName; enc, nl: INTEGER): tOutput; |
| VAR |
| res: tOutput; |
| BEGIN |
| NEW(res); |
| res.pos := 0; |
| res.eol := eol[nl]; |
| res.putChar := NIL; |
| IF (enc = E.UTF8) OR (enc = E.UTF8BOM) THEN |
| res.putChar := putCharUTF8; |
| IF enc = E.UTF8BOM THEN |
| ASSERT(res.putChar(res, ORD(BOM))) |
| END |
| ELSIF enc = E.UTF16LE THEN |
| res.putChar := putCharUTF16LE; |
| ELSIF enc = E.W1251 THEN |
| res.putChar := putCharW1251 |
| ELSIF enc = E.CP866 THEN |
| res.putChar := putCharCP866 |
| END; |
| ASSERT(res.putChar # NIL); |
| res.handle := File.Create(name); |
| IF res.handle = NIL THEN |
| DISPOSE(res) |
| END |
| RETURN res |
| END create; |
| |
| |
| PROCEDURE destroy* (VAR file: tInput); |
| BEGIN |
| IF file # NIL THEN |
| IF file.buffer # 0 THEN |
| file.buffer := KOSAPI.free(file.buffer - 12*ORD(file.clipbrd)) |
| END; |
| DISPOSE(file) |
| END |
| END destroy; |
| |
| |
| BEGIN |
| eol[EOL_LF] := LF; |
| eol[EOL_CRLF] := CR + LF; |
| eol[EOL_CR] := CR |
| END RW. |