]>
Commit | Line | Data |
---|---|---|
88a8b04e RD |
1 | // Scintilla source code edit control |
2 | /** @file LexPS.cxx | |
3 | ** Lexer for PostScript | |
4 | ** | |
5 | ** Written by Nigel Hathaway <nigel@bprj.co.uk>. | |
6 | ** The License.txt file describes the conditions under which this software may be distributed. | |
7 | **/ | |
8 | ||
9 | #include <stdlib.h> | |
10 | #include <string.h> | |
11 | #include <ctype.h> | |
12 | #include <stdarg.h> | |
13 | #include <stdio.h> | |
88a8b04e RD |
14 | |
15 | #include "Platform.h" | |
16 | ||
17 | #include "PropSet.h" | |
18 | #include "Accessor.h" | |
19 | #include "StyleContext.h" | |
20 | #include "KeyWords.h" | |
21 | #include "Scintilla.h" | |
22 | #include "SciLexer.h" | |
23 | ||
7e0c58e9 RD |
24 | #ifdef SCI_NAMESPACE |
25 | using namespace Scintilla; | |
26 | #endif | |
27 | ||
88a8b04e RD |
28 | static inline bool IsASelfDelimitingChar(const int ch) { |
29 | return (ch == '[' || ch == ']' || ch == '{' || ch == '}' || | |
30 | ch == '/' || ch == '<' || ch == '>' || | |
31 | ch == '(' || ch == ')' || ch == '%'); | |
32 | } | |
33 | ||
34 | static inline bool IsAWhitespaceChar(const int ch) { | |
35 | return (ch == ' ' || ch == '\t' || ch == '\r' || | |
36 | ch == '\n' || ch == '\f' || ch == '\0'); | |
37 | } | |
38 | ||
39 | static bool IsABaseNDigit(const int ch, const int base) { | |
40 | int maxdig = '9'; | |
41 | int letterext = -1; | |
42 | ||
43 | if (base <= 10) | |
44 | maxdig = '0' + base - 1; | |
45 | else | |
46 | letterext = base - 11; | |
47 | ||
48 | return ((ch >= '0' && ch <= maxdig) || | |
49 | (ch >= 'A' && ch <= ('A' + letterext)) || | |
50 | (ch >= 'a' && ch <= ('a' + letterext))); | |
51 | } | |
52 | ||
53 | static inline bool IsABase85Char(const int ch) { | |
54 | return ((ch >= '!' && ch <= 'u') || ch == 'z'); | |
55 | } | |
56 | ||
57 | static void ColourisePSDoc( | |
58 | unsigned int startPos, | |
59 | int length, | |
60 | int initStyle, | |
61 | WordList *keywordlists[], | |
62 | Accessor &styler) { | |
63 | ||
64 | WordList &keywords1 = *keywordlists[0]; | |
65 | WordList &keywords2 = *keywordlists[1]; | |
66 | WordList &keywords3 = *keywordlists[2]; | |
67 | WordList &keywords4 = *keywordlists[3]; | |
68 | WordList &keywords5 = *keywordlists[4]; | |
69 | ||
70 | StyleContext sc(startPos, length, initStyle, styler); | |
71 | ||
72 | bool tokenizing = styler.GetPropertyInt("ps.tokenize") != 0; | |
73 | int pslevel = styler.GetPropertyInt("ps.level", 3); | |
74 | int lineCurrent = styler.GetLine(startPos); | |
75 | int nestTextCurrent = 0; | |
76 | if (lineCurrent > 0 && initStyle == SCE_PS_TEXT) | |
77 | nestTextCurrent = styler.GetLineState(lineCurrent - 1); | |
78 | int numRadix = 0; | |
79 | bool numHasPoint = false; | |
80 | bool numHasExponent = false; | |
81 | bool numHasSign = false; | |
82 | ||
83 | // Clear out existing tokenization | |
84 | if (tokenizing && length > 0) { | |
85 | styler.StartAt(startPos, static_cast<char>(INDIC2_MASK)); | |
86 | styler.ColourTo(startPos + length-1, 0); | |
87 | styler.Flush(); | |
88 | styler.StartAt(startPos); | |
89 | styler.StartSegment(startPos); | |
90 | } | |
91 | ||
92 | for (; sc.More(); sc.Forward()) { | |
93 | if (sc.atLineStart) | |
94 | lineCurrent = styler.GetLine(sc.currentPos); | |
95 | ||
96 | // Determine if the current state should terminate. | |
97 | if (sc.state == SCE_PS_COMMENT || sc.state == SCE_PS_DSC_VALUE) { | |
98 | if (sc.atLineEnd) { | |
99 | sc.SetState(SCE_C_DEFAULT); | |
100 | } | |
101 | } else if (sc.state == SCE_PS_DSC_COMMENT) { | |
102 | if (sc.ch == ':') { | |
103 | sc.Forward(); | |
104 | if (!sc.atLineEnd) | |
105 | sc.SetState(SCE_PS_DSC_VALUE); | |
106 | else | |
107 | sc.SetState(SCE_C_DEFAULT); | |
108 | } else if (sc.atLineEnd) { | |
109 | sc.SetState(SCE_C_DEFAULT); | |
7e0c58e9 | 110 | } else if (IsAWhitespaceChar(sc.ch) && sc.ch != '\r') { |
88a8b04e RD |
111 | sc.ChangeState(SCE_PS_COMMENT); |
112 | } | |
113 | } else if (sc.state == SCE_PS_NUMBER) { | |
114 | if (IsASelfDelimitingChar(sc.ch) || IsAWhitespaceChar(sc.ch)) { | |
115 | if ((sc.chPrev == '+' || sc.chPrev == '-' || | |
116 | sc.chPrev == 'E' || sc.chPrev == 'e') && numRadix == 0) | |
117 | sc.ChangeState(SCE_PS_NAME); | |
118 | sc.SetState(SCE_C_DEFAULT); | |
119 | } else if (sc.ch == '#') { | |
120 | if (numHasPoint || numHasExponent || numHasSign || numRadix != 0) { | |
121 | sc.ChangeState(SCE_PS_NAME); | |
122 | } else { | |
123 | char szradix[5]; | |
124 | sc.GetCurrent(szradix, 4); | |
125 | numRadix = atoi(szradix); | |
126 | if (numRadix < 2 || numRadix > 36) | |
127 | sc.ChangeState(SCE_PS_NAME); | |
128 | } | |
129 | } else if ((sc.ch == 'E' || sc.ch == 'e') && numRadix == 0) { | |
130 | if (numHasExponent) { | |
131 | sc.ChangeState(SCE_PS_NAME); | |
132 | } else { | |
133 | numHasExponent = true; | |
134 | if (sc.chNext == '+' || sc.chNext == '-') | |
135 | sc.Forward(); | |
136 | } | |
137 | } else if (sc.ch == '.') { | |
138 | if (numHasPoint || numHasExponent || numRadix != 0) { | |
139 | sc.ChangeState(SCE_PS_NAME); | |
140 | } else { | |
141 | numHasPoint = true; | |
142 | } | |
143 | } else if (numRadix == 0) { | |
144 | if (!IsABaseNDigit(sc.ch, 10)) | |
145 | sc.ChangeState(SCE_PS_NAME); | |
146 | } else { | |
147 | if (!IsABaseNDigit(sc.ch, numRadix)) | |
148 | sc.ChangeState(SCE_PS_NAME); | |
149 | } | |
150 | } else if (sc.state == SCE_PS_NAME || sc.state == SCE_PS_KEYWORD) { | |
151 | if (IsASelfDelimitingChar(sc.ch) || IsAWhitespaceChar(sc.ch)) { | |
152 | char s[100]; | |
153 | sc.GetCurrent(s, sizeof(s)); | |
154 | if ((pslevel >= 1 && keywords1.InList(s)) || | |
155 | (pslevel >= 2 && keywords2.InList(s)) || | |
156 | (pslevel >= 3 && keywords3.InList(s)) || | |
157 | keywords4.InList(s) || keywords5.InList(s)) { | |
158 | sc.ChangeState(SCE_PS_KEYWORD); | |
159 | } | |
160 | sc.SetState(SCE_C_DEFAULT); | |
161 | } | |
162 | } else if (sc.state == SCE_PS_LITERAL || sc.state == SCE_PS_IMMEVAL) { | |
163 | if (IsASelfDelimitingChar(sc.ch) || IsAWhitespaceChar(sc.ch)) | |
164 | sc.SetState(SCE_C_DEFAULT); | |
165 | } else if (sc.state == SCE_PS_PAREN_ARRAY || sc.state == SCE_PS_PAREN_DICT || | |
166 | sc.state == SCE_PS_PAREN_PROC) { | |
167 | sc.SetState(SCE_C_DEFAULT); | |
168 | } else if (sc.state == SCE_PS_TEXT) { | |
169 | if (sc.ch == '(') { | |
170 | nestTextCurrent++; | |
171 | } else if (sc.ch == ')') { | |
172 | if (--nestTextCurrent == 0) | |
173 | sc.ForwardSetState(SCE_PS_DEFAULT); | |
174 | } else if (sc.ch == '\\') { | |
175 | sc.Forward(); | |
176 | } | |
177 | } else if (sc.state == SCE_PS_HEXSTRING) { | |
178 | if (sc.ch == '>') { | |
179 | sc.ForwardSetState(SCE_PS_DEFAULT); | |
180 | } else if (!IsABaseNDigit(sc.ch, 16) && !IsAWhitespaceChar(sc.ch)) { | |
181 | sc.SetState(SCE_PS_HEXSTRING); | |
182 | styler.ColourTo(sc.currentPos, SCE_PS_BADSTRINGCHAR); | |
183 | } | |
184 | } else if (sc.state == SCE_PS_BASE85STRING) { | |
185 | if (sc.Match('~', '>')) { | |
186 | sc.Forward(); | |
187 | sc.ForwardSetState(SCE_PS_DEFAULT); | |
188 | } else if (!IsABase85Char(sc.ch) && !IsAWhitespaceChar(sc.ch)) { | |
189 | sc.SetState(SCE_PS_BASE85STRING); | |
190 | styler.ColourTo(sc.currentPos, SCE_PS_BADSTRINGCHAR); | |
191 | } | |
192 | } | |
193 | ||
194 | // Determine if a new state should be entered. | |
195 | if (sc.state == SCE_C_DEFAULT) { | |
196 | unsigned int tokenpos = sc.currentPos; | |
197 | ||
198 | if (sc.ch == '[' || sc.ch == ']') { | |
199 | sc.SetState(SCE_PS_PAREN_ARRAY); | |
200 | } else if (sc.ch == '{' || sc.ch == '}') { | |
201 | sc.SetState(SCE_PS_PAREN_PROC); | |
202 | } else if (sc.ch == '/') { | |
203 | if (sc.chNext == '/') { | |
204 | sc.SetState(SCE_PS_IMMEVAL); | |
205 | sc.Forward(); | |
206 | } else { | |
207 | sc.SetState(SCE_PS_LITERAL); | |
208 | } | |
209 | } else if (sc.ch == '<') { | |
210 | if (sc.chNext == '<') { | |
211 | sc.SetState(SCE_PS_PAREN_DICT); | |
212 | sc.Forward(); | |
213 | } else if (sc.chNext == '~') { | |
214 | sc.SetState(SCE_PS_BASE85STRING); | |
215 | sc.Forward(); | |
216 | } else { | |
217 | sc.SetState(SCE_PS_HEXSTRING); | |
218 | } | |
219 | } else if (sc.ch == '>' && sc.chNext == '>') { | |
220 | sc.SetState(SCE_PS_PAREN_DICT); | |
221 | sc.Forward(); | |
222 | } else if (sc.ch == '>' || sc.ch == ')') { | |
223 | sc.SetState(SCE_C_DEFAULT); | |
224 | styler.ColourTo(sc.currentPos, SCE_PS_BADSTRINGCHAR); | |
225 | } else if (sc.ch == '(') { | |
226 | sc.SetState(SCE_PS_TEXT); | |
227 | nestTextCurrent = 1; | |
228 | } else if (sc.ch == '%') { | |
229 | if (sc.chNext == '%' && sc.atLineStart) { | |
230 | sc.SetState(SCE_PS_DSC_COMMENT); | |
231 | sc.Forward(); | |
232 | if (sc.chNext == '+') { | |
233 | sc.Forward(); | |
234 | sc.ForwardSetState(SCE_PS_DSC_VALUE); | |
235 | } | |
236 | } else { | |
237 | sc.SetState(SCE_PS_COMMENT); | |
238 | } | |
239 | } else if ((sc.ch == '+' || sc.ch == '-' || sc.ch == '.') && | |
240 | IsABaseNDigit(sc.chNext, 10)) { | |
241 | sc.SetState(SCE_PS_NUMBER); | |
242 | numRadix = 0; | |
243 | numHasPoint = (sc.ch == '.'); | |
244 | numHasExponent = false; | |
245 | numHasSign = (sc.ch == '+' || sc.ch == '-'); | |
246 | } else if ((sc.ch == '+' || sc.ch == '-') && sc.chNext == '.' && | |
247 | IsABaseNDigit(sc.GetRelative(2), 10)) { | |
248 | sc.SetState(SCE_PS_NUMBER); | |
249 | numRadix = 0; | |
250 | numHasPoint = false; | |
251 | numHasExponent = false; | |
252 | numHasSign = true; | |
253 | } else if (IsABaseNDigit(sc.ch, 10)) { | |
254 | sc.SetState(SCE_PS_NUMBER); | |
255 | numRadix = 0; | |
256 | numHasPoint = false; | |
257 | numHasExponent = false; | |
258 | numHasSign = false; | |
259 | } else if (!IsAWhitespaceChar(sc.ch)) { | |
260 | sc.SetState(SCE_PS_NAME); | |
261 | } | |
262 | ||
263 | // Mark the start of tokens | |
264 | if (tokenizing && sc.state != SCE_C_DEFAULT && sc.state != SCE_PS_COMMENT && | |
265 | sc.state != SCE_PS_DSC_COMMENT && sc.state != SCE_PS_DSC_VALUE) { | |
266 | styler.Flush(); | |
267 | styler.StartAt(tokenpos, static_cast<char>(INDIC2_MASK)); | |
268 | styler.ColourTo(tokenpos, INDIC2_MASK); | |
269 | styler.Flush(); | |
270 | styler.StartAt(tokenpos); | |
271 | styler.StartSegment(tokenpos); | |
272 | } | |
273 | } | |
274 | ||
275 | if (sc.atLineEnd) | |
276 | styler.SetLineState(lineCurrent, nestTextCurrent); | |
277 | } | |
278 | ||
279 | sc.Complete(); | |
280 | } | |
281 | ||
282 | static void FoldPSDoc(unsigned int startPos, int length, int, WordList *[], | |
283 | Accessor &styler) { | |
284 | bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0; | |
285 | bool foldAtElse = styler.GetPropertyInt("fold.at.else", 0) != 0; | |
286 | unsigned int endPos = startPos + length; | |
287 | int visibleChars = 0; | |
288 | int lineCurrent = styler.GetLine(startPos); | |
289 | int levelCurrent = SC_FOLDLEVELBASE; | |
290 | if (lineCurrent > 0) | |
291 | levelCurrent = styler.LevelAt(lineCurrent-1) >> 16; | |
292 | int levelMinCurrent = levelCurrent; | |
293 | int levelNext = levelCurrent; | |
294 | char chNext = styler[startPos]; | |
295 | int styleNext = styler.StyleAt(startPos); | |
296 | int style; | |
297 | for (unsigned int i = startPos; i < endPos; i++) { | |
298 | char ch = chNext; | |
299 | chNext = styler.SafeGetCharAt(i + 1); | |
300 | style = styleNext; | |
301 | styleNext = styler.StyleAt(i + 1); | |
302 | bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n'); //mac?? | |
303 | if ((style & 31) == SCE_PS_PAREN_PROC) { | |
304 | if (ch == '{') { | |
305 | // Measure the minimum before a '{' to allow | |
306 | // folding on "} {" | |
307 | if (levelMinCurrent > levelNext) { | |
308 | levelMinCurrent = levelNext; | |
309 | } | |
310 | levelNext++; | |
311 | } else if (ch == '}') { | |
312 | levelNext--; | |
313 | } | |
314 | } | |
315 | if (atEOL) { | |
316 | int levelUse = levelCurrent; | |
317 | if (foldAtElse) { | |
318 | levelUse = levelMinCurrent; | |
319 | } | |
320 | int lev = levelUse | levelNext << 16; | |
321 | if (visibleChars == 0 && foldCompact) | |
322 | lev |= SC_FOLDLEVELWHITEFLAG; | |
323 | if (levelUse < levelNext) | |
324 | lev |= SC_FOLDLEVELHEADERFLAG; | |
325 | if (lev != styler.LevelAt(lineCurrent)) { | |
326 | styler.SetLevel(lineCurrent, lev); | |
327 | } | |
328 | lineCurrent++; | |
329 | levelCurrent = levelNext; | |
330 | levelMinCurrent = levelCurrent; | |
331 | visibleChars = 0; | |
332 | } | |
333 | if (!isspacechar(ch)) | |
334 | visibleChars++; | |
335 | } | |
336 | } | |
337 | ||
338 | static const char * const psWordListDesc[] = { | |
339 | "PS Level 1 operators", | |
340 | "PS Level 2 operators", | |
341 | "PS Level 3 operators", | |
342 | "RIP-specific operators", | |
343 | "User-defined operators", | |
344 | 0 | |
345 | }; | |
346 | ||
347 | LexerModule lmPS(SCLEX_PS, ColourisePSDoc, "ps", FoldPSDoc, psWordListDesc); |