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


﻿(*
    Copyright 2021 Anton Krotov
 
    This file is part of CEdit.
 
    CEdit is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
 
    CEdit is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with CEdit. If not, see .
*)
 
MODULE Languages;
 
IMPORT Lines;
 
 
CONST
 
    langText* = 0; langC* = 1; langOberon* = 2; langPascal* = 3;
    langFasm* = 4; langLua* = 5; langIni* = 6; langJSON* = 7;
 
    csLang = {langC, langOberon, langLua, langIni, langJSON};
 
TYPE
 
    tLine = Lines.tLine;
 
    tKeyWords = RECORD
        words: ARRAY 200, 32 OF WCHAR; cnt: INTEGER
    END;
 
    procGetStr = PROCEDURE (secName, keyName: ARRAY OF CHAR; VAR s: ARRAY OF CHAR);
 
 
VAR
 
    oberonKW, cKW, pascalKW, luaKW, iniKW, fasmKW, jsonKW: ARRAY 3 OF tKeyWords;
 
 
PROCEDURE isCS* (lang: INTEGER): BOOLEAN;
    RETURN lang IN csLang
END isCS;
 
 
PROCEDURE checkKW (s: ARRAY OF WCHAR; KW: tKeyWords): BOOLEAN;
VAR
    i: INTEGER;
BEGIN
    i := KW.cnt - 1;
    WHILE (i >= 0) & (s # KW.words[i]) DO
        DEC(i)
    END
    RETURN i >= 0
END checkKW;
 
 
PROCEDURE isKey* (s: ARRAY OF WCHAR; lang, kwSet: INTEGER): BOOLEAN;
VAR
    res: BOOLEAN;
BEGIN
	DEC(kwSet);
    res := FALSE;
    CASE lang OF
    |langC:      res := checkKW(s, cKW[kwSet])
    |langOberon: res := checkKW(s, oberonKW[kwSet])
    |langPascal: res := checkKW(s, pascalKW[kwSet])
    |langLua:    res := checkKW(s, luaKW[kwSet])
    |langIni:    res := checkKW(s, iniKW[kwSet])
    |langFasm:   res := checkKW(s, fasmKW[kwSet])
    |langJSON:   res := checkKW(s, jsonKW[kwSet])
    END
    RETURN res
END isKey;
 
 
PROCEDURE SkipString* (line: tLine; VAR pos: INTEGER; n: INTEGER);
VAR
    quot: WCHAR;
BEGIN
    quot := Lines.getChar(line, pos);
    REPEAT
        INC(pos)
    UNTIL (pos > n) OR (Lines.getChar(line, pos) = quot)
END SkipString;
 
 
PROCEDURE C (line: tLine; VAR depth, cond, pos: INTEGER; n: INTEGER);
VAR
    c: WCHAR;
BEGIN
    c := Lines.getChar(line, pos);
    IF depth = 0 THEN
        IF c = "/" THEN
            IF cond = 0 THEN
                cond := 1
            ELSE
                cond := 0;
                pos := n
            END
        ELSIF (c = "*") & (cond = 1) THEN
            depth := 1;
            cond := 0
        ELSIF (c = "'") OR (c = '"') THEN
            SkipString(line, pos, n);
            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
END C;
 
 
PROCEDURE getChar (line: tLine; i: INTEGER): WCHAR;
VAR
    res: WCHAR;
BEGIN
    IF i >= line.length THEN
        res := 0X
    ELSE
        res := Lines.getChar(line, i)
    END
    RETURN res
END getChar;
 
 
PROCEDURE LuaLong* (line: tLine; pos: INTEGER): INTEGER;
VAR
    res: INTEGER;
BEGIN
    res := -1;
    IF getChar(line, pos) = "[" THEN
        INC(pos);
        WHILE getChar(line, pos) = "=" DO
            INC(res);
            INC(pos)
        END;
        IF getChar(line, pos) = "[" THEN
            INC(res)
        ELSE
            res := -1
        END
    END
    RETURN res
END LuaLong;
 
 
PROCEDURE Lua (line: tLine; VAR depth, cond, pos: INTEGER; n: INTEGER);
VAR
    c: WCHAR;
    k: INTEGER;
BEGIN
    c := Lines.getChar(line, pos);
    IF depth = 0 THEN
        IF c = "-" THEN
            IF cond = 0 THEN
                cond := 1
            ELSE
                cond := 0;
                k := LuaLong(line, pos + 1);
                IF k >= 0 THEN
                    depth := k*2 + 1
                ELSE
                    pos := n
                END
            END
        ELSIF c = "[" THEN
            cond := 0;
            k := LuaLong(line, pos);
            IF k >= 0 THEN
                depth := (k + 1)*2
            END
        ELSIF (c = "'") OR (c = '"') THEN
            SkipString(line, pos, n);
            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
END Lua;
 
 
PROCEDURE Pascal (line: tLine; VAR depth, cond, pos: INTEGER; n: INTEGER);
VAR
    c: WCHAR;
BEGIN
    c := Lines.getChar(line, pos);
    IF depth = 0 THEN
        IF c = "(" THEN
            cond := 1
        ELSIF c = "/" THEN
            IF cond = 2 THEN
                cond := 0;
                pos := n
            ELSE
                cond := 2
            END
        ELSIF (c = "*") & (cond = 1) THEN
            depth := 2;
            cond := 0
        ELSIF c = "'" THEN
            SkipString(line, pos, n);
            cond := 0
        ELSIF c = "{" THEN
            IF Lines.getChar(line, pos + 1) = "$" THEN
                depth := 3
            ELSE
                depth := 1
            END;
            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
END Pascal;
 
 
PROCEDURE Oberon (line: tLine; VAR depth, cond, pos: INTEGER; n: INTEGER);
VAR
    c: WCHAR;
BEGIN
    c := Lines.getChar(line, pos);
    IF (depth = 0) & (c = "/") THEN
        IF cond = 3 THEN
            cond := 0;
            pos := n
        ELSE
            cond := 3
        END
    ELSIF (depth = 0) & ((c = "'") OR (c = '"')) THEN
        SkipString(line, pos, n);
        cond := 0
    ELSIF c = "(" THEN
        cond := 1
    ELSIF c = "*" THEN
        IF cond = 1 THEN
            INC(depth);
            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;
END Oberon;
 
 
PROCEDURE Ini (line: tLine; VAR depth, cond, pos: INTEGER; n: INTEGER);
VAR
    c: WCHAR;
BEGIN
    cond := 0;
    c := Lines.getChar(line, pos);
    IF depth = 0 THEN
        IF c = ";" THEN
            pos := n
        ELSIF c = '"' THEN
            SkipString(line, pos, n)
        ELSIF c = "[" THEN
            depth := 1
        END
    ELSIF depth = 1 THEN
        IF c = "]" THEN
            depth := 0
        END
    END
END Ini;
 
 
PROCEDURE comments* (line: tLine; VAR depth, cond, pos: INTEGER; n: INTEGER; lang: INTEGER);
BEGIN
    CASE lang OF
    |langText:
    |langFasm:
    |langC,
     langJSON:    C(line, depth, cond, pos, n)
    |langOberon:  Oberon(line, depth, cond, pos, n)
    |langPascal:  Pascal(line, depth, cond, pos, n)
    |langLua:     Lua(line, depth, cond, pos, n)
    |langIni:     Ini(line, depth, cond, pos, n)
    END
END comments;
 
 
PROCEDURE EnterKW (s: ARRAY OF CHAR; VAR KW: tKeyWords; CPrep: BOOLEAN);
CONST
    SPACE = 20X; CR = 0DX; LF = 0AX; TAB = 9X; COMMA = ",";
VAR
    i, j, k: INTEGER;
 
    PROCEDURE delim (c: CHAR): BOOLEAN;
        RETURN (c = COMMA) OR (c = SPACE) OR (c = CR) OR (c = LF) OR (c = TAB)
    END delim;
 
BEGIN
    k := KW.cnt;
    i := 0;
    REPEAT
        KW.words[k, 0] := "#";
        j := ORD(CPrep);
        WHILE (s[i] # 0X) & ~delim(s[i]) DO
            KW.words[k, j] := WCHR(ORD(s[i]));
            INC(i);
            INC(j)
        END;
        KW.words[k, j] := 0X;
        INC(k);
        WHILE delim(s[i]) DO
            INC(i)
        END
    UNTIL s[i] = 0X;
    KW.cnt := k
END EnterKW;
 
 
PROCEDURE loadKW (VAR KW: ARRAY OF tKeyWords; getStr: procGetStr; lang: ARRAY OF CHAR);
VAR
    s: ARRAY 16*1024 OF CHAR;
    key: ARRAY 4 OF CHAR;
    i: INTEGER;
BEGIN
    key := "KW1";
    FOR i := 0 TO 2 DO
        KW[i].cnt := 0;
        key[2] := CHR(ORD("1") + i);
        getStr(lang, key, s);
        EnterKW(s, KW[i], (lang = "lang_C") & (i = 1))
    END
END loadKW;
 
 
PROCEDURE init* (getStr: procGetStr);
BEGIN
    loadKW(oberonKW, getStr, "lang_Oberon");
    loadKW(cKW,      getStr, "lang_C");
    loadKW(pascalKW, getStr, "lang_Pascal");
    loadKW(luaKW,    getStr, "lang_Lua");
    loadKW(iniKW,    getStr, "lang_Ini");
    loadKW(fasmKW,   getStr, "lang_Fasm");
    loadKW(jsonKW,   getStr, "lang_JSON");
END init;
 
 
END Languages.

Rev 9174	Rev 9190
1	(*	1	(*
2	Copyright 2021 Anton Krotov	2	Copyright 2021 Anton Krotov
3		3
4	This file is part of CEdit.	4	This file is part of CEdit.
5		5
6	CEdit is free software: you can redistribute it and/or modify	6	CEdit is free software: you can redistribute it and/or modify
7	it under the terms of the GNU General Public License as published by	7	it under the terms of the GNU General Public License as published by
8	the Free Software Foundation, either version 3 of the License, or	8	the Free Software Foundation, either version 3 of the License, or
9	(at your option) any later version.	9	(at your option) any later version.
10		10
11	CEdit is distributed in the hope that it will be useful,	11	CEdit is distributed in the hope that it will be useful,
12	but WITHOUT ANY WARRANTY; without even the implied warranty of	12	but WITHOUT ANY WARRANTY; without even the implied warranty of
13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14	GNU General Public License for more details.	14	GNU General Public License for more details.
15		15
16	You should have received a copy of the GNU General Public License	16	You should have received a copy of the GNU General Public License
17	along with CEdit. If not, see .	17	along with CEdit. If not, see .
18	*)	18	*)
19		19
20	MODULE Languages;	20	MODULE Languages;
21		21
22	IMPORT Lines;	22	IMPORT Lines;
23		23
24		24
25	CONST	25	CONST
26		26
27	langNone* = 0; langC* = 1; langOberon* = 2; langPascal* = 3;	27	langText* = 0; langC* = 1; langOberon* = 2; langPascal* = 3;
28	langFasm* = 4; langLua* = 5; langIni* = 6; langJSON* = 7;	28	langFasm* = 4; langLua* = 5; langIni* = 6; langJSON* = 7;
29		29
30	csLang = {langC, langOberon, langLua, langIni, langJSON};	30	csLang = {langC, langOberon, langLua, langIni, langJSON};
31		31
32	TYPE	32	TYPE
33		33
34	tLine = Lines.tLine;	34	tLine = Lines.tLine;
35		35
36	tKeyWords = RECORD	36	tKeyWords = RECORD
37	words: ARRAY 200, 32 OF WCHAR; cnt: INTEGER	37	words: ARRAY 200, 32 OF WCHAR; cnt: INTEGER
38	END;	38	END;
39		39
40	procGetStr = PROCEDURE (secName, keyName: ARRAY OF CHAR; VAR s: ARRAY OF CHAR);	40	procGetStr = PROCEDURE (secName, keyName: ARRAY OF CHAR; VAR s: ARRAY OF CHAR);
41		41
42		42
43	VAR	43	VAR
44		44
45	oberonKW, cKW, pascalKW, luaKW, iniKW, fasmKW, jsonKW: ARRAY 3 OF tKeyWords;	45	oberonKW, cKW, pascalKW, luaKW, iniKW, fasmKW, jsonKW: ARRAY 3 OF tKeyWords;
46		46
47		47
48	PROCEDURE isCS* (lang: INTEGER): BOOLEAN;	48	PROCEDURE isCS* (lang: INTEGER): BOOLEAN;
49	RETURN lang IN csLang	49	RETURN lang IN csLang
50	END isCS;	50	END isCS;
51		51
52		52
53	PROCEDURE checkKW (s: ARRAY OF WCHAR; KW: tKeyWords): BOOLEAN;	53	PROCEDURE checkKW (s: ARRAY OF WCHAR; KW: tKeyWords): BOOLEAN;
54	VAR	54	VAR
55	i: INTEGER;	55	i: INTEGER;
56	BEGIN	56	BEGIN
57	i := KW.cnt - 1;	57	i := KW.cnt - 1;
58	WHILE (i >= 0) & (s # KW.words[i]) DO	58	WHILE (i >= 0) & (s # KW.words[i]) DO
59	DEC(i)	59	DEC(i)
60	END	60	END
61	RETURN i >= 0	61	RETURN i >= 0
62	END checkKW;	62	END checkKW;
63		63
64		64
65	PROCEDURE isKey* (s: ARRAY OF WCHAR; lang, kwSet: INTEGER): BOOLEAN;	65	PROCEDURE isKey* (s: ARRAY OF WCHAR; lang, kwSet: INTEGER): BOOLEAN;
66	VAR	66	VAR
67	res: BOOLEAN;	67	res: BOOLEAN;
68	BEGIN	68	BEGIN
69	DEC(kwSet);	69	DEC(kwSet);
70	res := FALSE;	70	res := FALSE;
71	CASE lang OF	71	CASE lang OF
72	\|langC: res := checkKW(s, cKW[kwSet])	72	\|langC: res := checkKW(s, cKW[kwSet])
73	\|langOberon: res := checkKW(s, oberonKW[kwSet])	73	\|langOberon: res := checkKW(s, oberonKW[kwSet])
74	\|langPascal: res := checkKW(s, pascalKW[kwSet])	74	\|langPascal: res := checkKW(s, pascalKW[kwSet])
75	\|langLua: res := checkKW(s, luaKW[kwSet])	75	\|langLua: res := checkKW(s, luaKW[kwSet])
76	\|langIni: res := checkKW(s, iniKW[kwSet])	76	\|langIni: res := checkKW(s, iniKW[kwSet])
77	\|langFasm: res := checkKW(s, fasmKW[kwSet])	77	\|langFasm: res := checkKW(s, fasmKW[kwSet])
78	\|langJSON: res := checkKW(s, jsonKW[kwSet])	78	\|langJSON: res := checkKW(s, jsonKW[kwSet])
79	END	79	END
80	RETURN res	80	RETURN res
81	END isKey;	81	END isKey;
82		82
83		83
84	PROCEDURE SkipString* (line: tLine; VAR pos: INTEGER; n: INTEGER);	84	PROCEDURE SkipString* (line: tLine; VAR pos: INTEGER; n: INTEGER);
85	VAR	85	VAR
86	quot: WCHAR;	86	quot: WCHAR;
87	BEGIN	87	BEGIN
88	quot := Lines.getChar(line, pos);	88	quot := Lines.getChar(line, pos);
89	REPEAT	89	REPEAT
90	INC(pos)	90	INC(pos)
91	UNTIL (pos > n) OR (Lines.getChar(line, pos) = quot)	91	UNTIL (pos > n) OR (Lines.getChar(line, pos) = quot)
92	END SkipString;	92	END SkipString;
93		93
94		94
95	PROCEDURE C (line: tLine; VAR depth, cond, pos: INTEGER; n: INTEGER);	95	PROCEDURE C (line: tLine; VAR depth, cond, pos: INTEGER; n: INTEGER);
96	VAR	96	VAR
97	c: WCHAR;	97	c: WCHAR;
98	BEGIN	98	BEGIN
99	c := Lines.getChar(line, pos);	99	c := Lines.getChar(line, pos);
100	IF depth = 0 THEN	100	IF depth = 0 THEN
101	IF c = "/" THEN	101	IF c = "/" THEN
102	IF cond = 0 THEN	102	IF cond = 0 THEN
103	cond := 1	103	cond := 1
104	ELSE	104	ELSE
105	cond := 0;	105	cond := 0;
106	pos := n	106	pos := n
107	END	107	END
108	ELSIF (c = "*") & (cond = 1) THEN	108	ELSIF (c = "*") & (cond = 1) THEN
109	depth := 1;	109	depth := 1;
110	cond := 0	110	cond := 0
111	ELSIF (c = "'") OR (c = '"') THEN	111	ELSIF (c = "'") OR (c = '"') THEN
112	SkipString(line, pos, n);	112	SkipString(line, pos, n);
113	cond := 0	113	cond := 0
114	ELSE	114	ELSE
115	cond := 0	115	cond := 0
116	END	116	END
117	ELSIF depth = 1 THEN	117	ELSIF depth = 1 THEN
118	IF c = "*" THEN	118	IF c = "*" THEN
119	cond := 1	119	cond := 1
120	ELSIF (c = "/") & (cond = 1) THEN	120	ELSIF (c = "/") & (cond = 1) THEN
121	cond := 0;	121	cond := 0;
122	depth := 0	122	depth := 0
123	ELSE	123	ELSE
124	cond := 0	124	cond := 0
125	END	125	END
126	END	126	END
127	END C;	127	END C;
128		128
129		129
130	PROCEDURE getChar (line: tLine; i: INTEGER): WCHAR;	130	PROCEDURE getChar (line: tLine; i: INTEGER): WCHAR;
131	VAR	131	VAR
132	res: WCHAR;	132	res: WCHAR;
133	BEGIN	133	BEGIN
134	IF i >= line.length THEN	134	IF i >= line.length THEN
135	res := 0X	135	res := 0X
136	ELSE	136	ELSE
137	res := Lines.getChar(line, i)	137	res := Lines.getChar(line, i)
138	END	138	END
139	RETURN res	139	RETURN res
140	END getChar;	140	END getChar;
141		141
142		142
143	PROCEDURE LuaLong* (line: tLine; pos: INTEGER): INTEGER;	143	PROCEDURE LuaLong* (line: tLine; pos: INTEGER): INTEGER;
144	VAR	144	VAR
145	res: INTEGER;	145	res: INTEGER;
146	BEGIN	146	BEGIN
147	res := -1;	147	res := -1;
148	IF getChar(line, pos) = "[" THEN	148	IF getChar(line, pos) = "[" THEN
149	INC(pos);	149	INC(pos);
150	WHILE getChar(line, pos) = "=" DO	150	WHILE getChar(line, pos) = "=" DO
151	INC(res);	151	INC(res);
152	INC(pos)	152	INC(pos)
153	END;	153	END;
154	IF getChar(line, pos) = "[" THEN	154	IF getChar(line, pos) = "[" THEN
155	INC(res)	155	INC(res)
156	ELSE	156	ELSE
157	res := -1	157	res := -1
158	END	158	END
159	END	159	END
160	RETURN res	160	RETURN res
161	END LuaLong;	161	END LuaLong;
162		162
163		163
164	PROCEDURE Lua (line: tLine; VAR depth, cond, pos: INTEGER; n: INTEGER);	164	PROCEDURE Lua (line: tLine; VAR depth, cond, pos: INTEGER; n: INTEGER);
165	VAR	165	VAR
166	c: WCHAR;	166	c: WCHAR;
167	k: INTEGER;	167	k: INTEGER;
168	BEGIN	168	BEGIN
169	c := Lines.getChar(line, pos);	169	c := Lines.getChar(line, pos);
170	IF depth = 0 THEN	170	IF depth = 0 THEN
171	IF c = "-" THEN	171	IF c = "-" THEN
172	IF cond = 0 THEN	172	IF cond = 0 THEN
173	cond := 1	173	cond := 1
174	ELSE	174	ELSE
175	cond := 0;	175	cond := 0;
176	k := LuaLong(line, pos + 1);	176	k := LuaLong(line, pos + 1);
177	IF k >= 0 THEN	177	IF k >= 0 THEN
178	depth := k*2 + 1	178	depth := k*2 + 1
179	ELSE	179	ELSE
180	pos := n	180	pos := n
181	END	181	END
182	END	182	END
183	ELSIF c = "[" THEN	183	ELSIF c = "[" THEN
184	cond := 0;	184	cond := 0;
185	k := LuaLong(line, pos);	185	k := LuaLong(line, pos);
186	IF k >= 0 THEN	186	IF k >= 0 THEN
187	depth := (k + 1)*2	187	depth := (k + 1)*2
188	END	188	END
189	ELSIF (c = "'") OR (c = '"') THEN	189	ELSIF (c = "'") OR (c = '"') THEN
190	SkipString(line, pos, n);	190	SkipString(line, pos, n);
191	cond := 0	191	cond := 0
192	ELSE	192	ELSE
193	cond := 0	193	cond := 0
194	END	194	END
195	ELSIF depth > 0 THEN	195	ELSIF depth > 0 THEN
196	IF (cond = 0) & (c = "]") THEN	196	IF (cond = 0) & (c = "]") THEN
197	cond := 1	197	cond := 1
198	ELSIF (cond >= 1) & (c = "=") THEN	198	ELSIF (cond >= 1) & (c = "=") THEN
199	INC(cond)	199	INC(cond)
200	ELSIF (cond >= 1) & (c = "]") & (cond*2 - depth MOD 2 = depth) THEN	200	ELSIF (cond >= 1) & (c = "]") & (cond*2 - depth MOD 2 = depth) THEN
201	depth := 0;	201	depth := 0;
202	cond := 0	202	cond := 0
203	ELSE	203	ELSE
204	cond := 0	204	cond := 0
205	END	205	END
206	END	206	END
207	END Lua;	207	END Lua;
208		208
209		209
210	PROCEDURE Pascal (line: tLine; VAR depth, cond, pos: INTEGER; n: INTEGER);	210	PROCEDURE Pascal (line: tLine; VAR depth, cond, pos: INTEGER; n: INTEGER);
211	VAR	211	VAR
212	c: WCHAR;	212	c: WCHAR;
213	BEGIN	213	BEGIN
214	c := Lines.getChar(line, pos);	214	c := Lines.getChar(line, pos);
215	IF depth = 0 THEN	215	IF depth = 0 THEN
216	IF c = "(" THEN	216	IF c = "(" THEN
217	cond := 1	217	cond := 1
218	ELSIF c = "/" THEN	218	ELSIF c = "/" THEN
219	IF cond = 2 THEN	219	IF cond = 2 THEN
220	cond := 0;	220	cond := 0;
221	pos := n	221	pos := n
222	ELSE	222	ELSE
223	cond := 2	223	cond := 2
224	END	224	END
225	ELSIF (c = "*") & (cond = 1) THEN	225	ELSIF (c = "*") & (cond = 1) THEN
226	depth := 2;	226	depth := 2;
227	cond := 0	227	cond := 0
228	ELSIF c = "'" THEN	228	ELSIF c = "'" THEN
229	SkipString(line, pos, n);	229	SkipString(line, pos, n);
230	cond := 0	230	cond := 0
231	ELSIF c = "{" THEN	231	ELSIF c = "{" THEN
232	IF Lines.getChar(line, pos + 1) = "$" THEN	232	IF Lines.getChar(line, pos + 1) = "$" THEN
233	depth := 3	233	depth := 3
234	ELSE	234	ELSE
235	depth := 1	235	depth := 1
236	END;	236	END;
237	cond := 0	237	cond := 0
238	ELSE	238	ELSE
239	cond := 0	239	cond := 0
240	END	240	END
241	ELSIF depth IN {1, 3} THEN	241	ELSIF depth IN {1, 3} THEN
242	IF c = "}" THEN	242	IF c = "}" THEN
243	depth := 0	243	depth := 0
244	END	244	END
245	ELSIF depth = 2 THEN	245	ELSIF depth = 2 THEN
246	IF c = "*" THEN	246	IF c = "*" THEN
247	cond := 1	247	cond := 1
248	ELSIF (c = ")") & (cond = 1) THEN	248	ELSIF (c = ")") & (cond = 1) THEN
249	depth := 0;	249	depth := 0;
250	cond := 0	250	cond := 0
251	ELSE	251	ELSE
252	cond := 0	252	cond := 0
253	END	253	END
254	END	254	END
255	END Pascal;	255	END Pascal;
256		256
257		257
258	PROCEDURE Oberon (line: tLine; VAR depth, cond, pos: INTEGER; n: INTEGER);	258	PROCEDURE Oberon (line: tLine; VAR depth, cond, pos: INTEGER; n: INTEGER);
259	VAR	259	VAR
260	c: WCHAR;	260	c: WCHAR;
261	BEGIN	261	BEGIN
262	c := Lines.getChar(line, pos);	262	c := Lines.getChar(line, pos);
263	IF (depth = 0) & (c = "/") THEN	263	IF (depth = 0) & (c = "/") THEN
264	IF cond = 3 THEN	264	IF cond = 3 THEN
265	cond := 0;	265	cond := 0;
266	pos := n	266	pos := n
267	ELSE	267	ELSE
268	cond := 3	268	cond := 3
269	END	269	END
270	ELSIF (depth = 0) & ((c = "'") OR (c = '"')) THEN	270	ELSIF (depth = 0) & ((c = "'") OR (c = '"')) THEN
271	SkipString(line, pos, n);	271	SkipString(line, pos, n);
272	cond := 0	272	cond := 0
273	ELSIF c = "(" THEN	273	ELSIF c = "(" THEN
274	cond := 1	274	cond := 1
275	ELSIF c = "*" THEN	275	ELSIF c = "*" THEN
276	IF cond = 1 THEN	276	IF cond = 1 THEN
277	INC(depth);	277	INC(depth);
278	cond := 0	278	cond := 0
279	ELSE	279	ELSE
280	cond := 2	280	cond := 2
281	END	281	END
282	ELSIF c = ")" THEN	282	ELSIF c = ")" THEN
283	IF cond = 2 THEN	283	IF cond = 2 THEN
284	IF depth > 0 THEN	284	IF depth > 0 THEN
285	DEC(depth)	285	DEC(depth)
286	END	286	END
287	END;	287	END;
288	cond := 0	288	cond := 0
289	ELSE	289	ELSE
290	cond := 0	290	cond := 0
291	END;	291	END;
292	END Oberon;	292	END Oberon;
293		293
294		294
295	PROCEDURE Ini (line: tLine; VAR depth, cond, pos: INTEGER; n: INTEGER);	295	PROCEDURE Ini (line: tLine; VAR depth, cond, pos: INTEGER; n: INTEGER);
296	VAR	296	VAR
297	c: WCHAR;	297	c: WCHAR;
298	BEGIN	298	BEGIN
299	cond := 0;	299	cond := 0;
300	c := Lines.getChar(line, pos);	300	c := Lines.getChar(line, pos);
301	IF depth = 0 THEN	301	IF depth = 0 THEN
302	IF c = ";" THEN	302	IF c = ";" THEN
303	pos := n	303	pos := n
304	ELSIF c = '"' THEN	304	ELSIF c = '"' THEN
305	SkipString(line, pos, n)	305	SkipString(line, pos, n)
306	ELSIF c = "[" THEN	306	ELSIF c = "[" THEN
307	depth := 1	307	depth := 1
308	END	308	END
309	ELSIF depth = 1 THEN	309	ELSIF depth = 1 THEN
310	IF c = "]" THEN	310	IF c = "]" THEN
311	depth := 0	311	depth := 0
312	END	312	END
313	END	313	END
314	END Ini;	314	END Ini;
315		315
316		316
317	PROCEDURE comments* (line: tLine; VAR depth, cond, pos: INTEGER; n: INTEGER; lang: INTEGER);	317	PROCEDURE comments* (line: tLine; VAR depth, cond, pos: INTEGER; n: INTEGER; lang: INTEGER);
318	BEGIN	318	BEGIN
319	CASE lang OF	319	CASE lang OF
320	\|langNone:	320	\|langText:
321	\|langFasm:	321	\|langFasm:
322	\|langC,	322	\|langC,
323	langJSON: C(line, depth, cond, pos, n)	323	langJSON: C(line, depth, cond, pos, n)
324	\|langOberon: Oberon(line, depth, cond, pos, n)	324	\|langOberon: Oberon(line, depth, cond, pos, n)
325	\|langPascal: Pascal(line, depth, cond, pos, n)	325	\|langPascal: Pascal(line, depth, cond, pos, n)
326	\|langLua: Lua(line, depth, cond, pos, n)	326	\|langLua: Lua(line, depth, cond, pos, n)
327	\|langIni: Ini(line, depth, cond, pos, n)	327	\|langIni: Ini(line, depth, cond, pos, n)
328	END	328	END
329	END comments;	329	END comments;
330		330
331		331
332	PROCEDURE EnterKW (s: ARRAY OF CHAR; VAR KW: tKeyWords; CPrep: BOOLEAN);	332	PROCEDURE EnterKW (s: ARRAY OF CHAR; VAR KW: tKeyWords; CPrep: BOOLEAN);
333	CONST	333	CONST
334	SPACE = 20X; CR = 0DX; LF = 0AX; TAB = 9X; COMMA = ",";	334	SPACE = 20X; CR = 0DX; LF = 0AX; TAB = 9X; COMMA = ",";
335	VAR	335	VAR
336	i, j, k: INTEGER;	336	i, j, k: INTEGER;
337		337
338	PROCEDURE delim (c: CHAR): BOOLEAN;	338	PROCEDURE delim (c: CHAR): BOOLEAN;
339	RETURN (c = COMMA) OR (c = SPACE) OR (c = CR) OR (c = LF) OR (c = TAB)	339	RETURN (c = COMMA) OR (c = SPACE) OR (c = CR) OR (c = LF) OR (c = TAB)
340	END delim;	340	END delim;
341		341
342	BEGIN	342	BEGIN
343	k := KW.cnt;	343	k := KW.cnt;
344	i := 0;	344	i := 0;
345	REPEAT	345	REPEAT
346	KW.words[k, 0] := "#";	346	KW.words[k, 0] := "#";
347	j := ORD(CPrep);	347	j := ORD(CPrep);
348	WHILE (s[i] # 0X) & ~delim(s[i]) DO	348	WHILE (s[i] # 0X) & ~delim(s[i]) DO
349	KW.words[k, j] := WCHR(ORD(s[i]));	349	KW.words[k, j] := WCHR(ORD(s[i]));
350	INC(i);	350	INC(i);
351	INC(j)	351	INC(j)
352	END;	352	END;
353	KW.words[k, j] := 0X;	353	KW.words[k, j] := 0X;
354	INC(k);	354	INC(k);
355	WHILE delim(s[i]) DO	355	WHILE delim(s[i]) DO
356	INC(i)	356	INC(i)
357	END	357	END
358	UNTIL s[i] = 0X;	358	UNTIL s[i] = 0X;
359	KW.cnt := k	359	KW.cnt := k
360	END EnterKW;	360	END EnterKW;
361		361
362		362
363	PROCEDURE loadKW (VAR KW: ARRAY OF tKeyWords; getStr: procGetStr; lang: ARRAY OF CHAR);	363	PROCEDURE loadKW (VAR KW: ARRAY OF tKeyWords; getStr: procGetStr; lang: ARRAY OF CHAR);
364	VAR	364	VAR
365	s: ARRAY 16*1024 OF CHAR;	365	s: ARRAY 16*1024 OF CHAR;
366	key: ARRAY 4 OF CHAR;	366	key: ARRAY 4 OF CHAR;
367	i: INTEGER;	367	i: INTEGER;
368	BEGIN	368	BEGIN
369	key := "KW1";	369	key := "KW1";
370	FOR i := 0 TO 2 DO	370	FOR i := 0 TO 2 DO
371	KW[i].cnt := 0;	371	KW[i].cnt := 0;
372	key[2] := CHR(ORD("1") + i);	372	key[2] := CHR(ORD("1") + i);
373	getStr(lang, key, s);	373	getStr(lang, key, s);
374	EnterKW(s, KW[i], (lang = "lang_C") & (i = 1))	374	EnterKW(s, KW[i], (lang = "lang_C") & (i = 1))
375	END	375	END
376	END loadKW;	376	END loadKW;
377		377
378		378
379	PROCEDURE init* (getStr: procGetStr);	379	PROCEDURE init* (getStr: procGetStr);
380	BEGIN	380	BEGIN
381	loadKW(oberonKW, getStr, "lang_Oberon");	381	loadKW(oberonKW, getStr, "lang_Oberon");
382	loadKW(cKW, getStr, "lang_C");	382	loadKW(cKW, getStr, "lang_C");
383	loadKW(pascalKW, getStr, "lang_Pascal");	383	loadKW(pascalKW, getStr, "lang_Pascal");
384	loadKW(luaKW, getStr, "lang_Lua");	384	loadKW(luaKW, getStr, "lang_Lua");
385	loadKW(iniKW, getStr, "lang_Ini");	385	loadKW(iniKW, getStr, "lang_Ini");
386	loadKW(fasmKW, getStr, "lang_Fasm");	386	loadKW(fasmKW, getStr, "lang_Fasm");
387	loadKW(jsonKW, getStr, "lang_JSON");	387	loadKW(jsonKW, getStr, "lang_JSON");
388	END init;	388	END init;
389		389
390		390
391	END Languages.	391	END Languages.

Subversion Repositories Kolibri OS

(root)/programs/develop/cedit/SRC/Languages.ob07 – Rev 9174 → 9190