← Back to branch summary

~efargaspro/+junk/codeblocks-16.01-release

« back to all changes in this revision

Viewing changes to src/sdk/wxscintilla/src/scintilla/lexers/LexBullant.cxx

  • Committer: damienlmoore at gmail
  • Date: 2016-02-02 02:43:22 UTC
  • Revision ID: damienlmoore@gmail.com-20160202024322-yql5qmtbwdyamdwd
Code::Blocks 16.01

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/sdk/wxscintilla/src/scintilla/lexers/LexBullant.cxx
 
1
// SciTE - Scintilla based Text Editor
 
2
// LexBullant.cxx - lexer for Bullant
 
3
 
 
4
#include <stdlib.h>
 
5
#include <string.h>
 
6
#include <stdio.h>
 
7
#include <stdarg.h>
 
8
#include <assert.h>
 
9
#include <ctype.h>
 
10
 
 
11
#include "ILexer.h"
 
12
#include "Scintilla.h"
 
13
#include "SciLexer.h"
 
14
 
 
15
#include "WordList.h"
 
16
#include "LexAccessor.h"
 
17
#include "Accessor.h"
 
18
#include "StyleContext.h"
 
19
#include "CharacterSet.h"
 
20
#include "LexerModule.h"
 
21
 
 
22
#ifdef SCI_NAMESPACE
 
23
using namespace Scintilla;
 
24
#endif
 
25
 
 
26
static int classifyWordBullant(unsigned int start, unsigned int end, WordList &keywords, Accessor &styler) {
 
27
        char s[100];
 
28
        s[0] = '\0';
 
29
        for (unsigned int i = 0; i < end - start + 1 && i < 30; i++) {
 
30
                s[i] = static_cast<char>(tolower(styler[start + i]));
 
31
                s[i + 1] = '\0';
 
32
        }
 
33
        int lev= 0;
 
34
        char chAttr = SCE_C_IDENTIFIER;
 
35
        if (isdigit(s[0]) || (s[0] == '.')){
 
36
                chAttr = SCE_C_NUMBER;
 
37
        }
 
38
        else {
 
39
                if (keywords.InList(s)) {
 
40
                        chAttr = SCE_C_WORD;
 
41
                        if (strcmp(s, "end") == 0)
 
42
                                lev = -1;
 
43
                        else if (strcmp(s, "method") == 0 ||
 
44
                                strcmp(s, "case") == 0 ||
 
45
                                strcmp(s, "class") == 0 ||
 
46
                                strcmp(s, "debug") == 0 ||
 
47
                                strcmp(s, "test") == 0 ||
 
48
                                strcmp(s, "if") == 0 ||
 
49
                                strcmp(s, "lock") == 0 ||
 
50
                                strcmp(s, "transaction") == 0 ||
 
51
                                strcmp(s, "trap") == 0 ||
 
52
                                strcmp(s, "until") == 0 ||
 
53
                                strcmp(s, "while") == 0)
 
54
                                lev = 1;
 
55
                }
 
56
        }
 
57
        styler.ColourTo(end, chAttr);
 
58
        return lev;
 
59
}
 
60
 
 
61
static void ColouriseBullantDoc(unsigned int startPos, int length, int initStyle, WordList *keywordlists[],
 
62
        Accessor &styler) {
 
63
        WordList &keywords = *keywordlists[0];
 
64
 
 
65
        styler.StartAt(startPos);
 
66
 
 
67
        bool fold = styler.GetPropertyInt("fold") != 0;
 
68
        int lineCurrent = styler.GetLine(startPos);
 
69
        int levelPrev = styler.LevelAt(lineCurrent) & SC_FOLDLEVELNUMBERMASK;
 
70
        int levelCurrent = levelPrev;
 
71
 
 
72
        int state = initStyle;
 
73
        if (state == SCE_C_STRINGEOL)   // Does not leak onto next line
 
74
                state = SCE_C_DEFAULT;
 
75
        char chPrev = ' ';
 
76
        char chNext = styler[startPos];
 
77
        unsigned int lengthDoc = startPos + length;
 
78
        int visibleChars = 0;
 
79
        styler.StartSegment(startPos);
 
80
        int endFoundThisLine = 0;
 
81
        for (unsigned int i = startPos; i < lengthDoc; i++) {
 
82
                char ch = chNext;
 
83
                chNext = styler.SafeGetCharAt(i + 1);
 
84
 
 
85
                if ((ch == '\r' && chNext != '\n') || (ch == '\n')) {
 
86
                        // Trigger on CR only (Mac style) or either on LF from CR+LF (Dos/Win) or on LF alone (Unix)
 
87
                        // Avoid triggering two times on Dos/Win
 
88
                        // End of line
 
89
                        endFoundThisLine = 0;
 
90
                        if (state == SCE_C_STRINGEOL) {
 
91
                                styler.ColourTo(i, state);
 
92
                                state = SCE_C_DEFAULT;
 
93
                        }
 
94
                        if (fold) {
 
95
                                int lev = levelPrev;
 
96
                                if (visibleChars == 0)
 
97
                                        lev |= SC_FOLDLEVELWHITEFLAG;
 
98
                                if ((levelCurrent > levelPrev) && (visibleChars > 0))
 
99
                                        lev |= SC_FOLDLEVELHEADERFLAG;
 
100
                                styler.SetLevel(lineCurrent, lev);
 
101
                                lineCurrent++;
 
102
                                levelPrev = levelCurrent;
 
103
                        }
 
104
                        visibleChars = 0;
 
105
 
 
106
/*                      int indentBlock = GetLineIndentation(lineCurrent);
 
107
                        if (blockChange==1){
 
108
                                lineCurrent++;
 
109
                                int pos=SetLineIndentation(lineCurrent, indentBlock + indentSize);
 
110
                        } else if (blockChange==-1) {
 
111
                                indentBlock -= indentSize;
 
112
                                if (indentBlock < 0)
 
113
                                        indentBlock = 0;
 
114
                                SetLineIndentation(lineCurrent, indentBlock);
 
115
                                lineCurrent++;
 
116
                        }
 
117
                        blockChange=0;
 
118
*/              }
 
119
                if (!(IsASCII(ch) && isspace(ch)))
 
120
                        visibleChars++;
 
121
 
 
122
                if (styler.IsLeadByte(ch)) {
 
123
                        chNext = styler.SafeGetCharAt(i + 2);
 
124
                        chPrev = ' ';
 
125
                        i += 1;
 
126
                        continue;
 
127
                }
 
128
 
 
129
                if (state == SCE_C_DEFAULT) {
 
130
                        if (iswordstart(ch)) {
 
131
                                styler.ColourTo(i-1, state);
 
132
                                        state = SCE_C_IDENTIFIER;
 
133
                        } else if (ch == '@' && chNext == 'o') {
 
134
                                if ((styler.SafeGetCharAt(i+2) =='f') && (styler.SafeGetCharAt(i+3) == 'f')) {
 
135
                                        styler.ColourTo(i-1, state);
 
136
                                        state = SCE_C_COMMENT;
 
137
                                }
 
138
                        } else if (ch == '#') {
 
139
                                styler.ColourTo(i-1, state);
 
140
                                state = SCE_C_COMMENTLINE;
 
141
                        } else if (ch == '\"') {
 
142
                                styler.ColourTo(i-1, state);
 
143
                                state = SCE_C_STRING;
 
144
                        } else if (ch == '\'') {
 
145
                                styler.ColourTo(i-1, state);
 
146
                                state = SCE_C_CHARACTER;
 
147
                        } else if (isoperator(ch)) {
 
148
                                styler.ColourTo(i-1, state);
 
149
                                styler.ColourTo(i, SCE_C_OPERATOR);
 
150
                        }
 
151
                } else if (state == SCE_C_IDENTIFIER) {
 
152
                        if (!iswordchar(ch)) {
 
153
                                int levelChange = classifyWordBullant(styler.GetStartSegment(), i - 1, keywords, styler);
 
154
                                state = SCE_C_DEFAULT;
 
155
                                chNext = styler.SafeGetCharAt(i + 1);
 
156
                                if (ch == '#') {
 
157
                                        state = SCE_C_COMMENTLINE;
 
158
                                } else if (ch == '\"') {
 
159
                                        state = SCE_C_STRING;
 
160
                                } else if (ch == '\'') {
 
161
                                        state = SCE_C_CHARACTER;
 
162
                                } else if (isoperator(ch)) {
 
163
                                        styler.ColourTo(i, SCE_C_OPERATOR);
 
164
                                }
 
165
                                if (endFoundThisLine == 0)
 
166
                                        levelCurrent+=levelChange;
 
167
                                if (levelChange == -1)
 
168
                                        endFoundThisLine=1;
 
169
                        }
 
170
                } else if (state == SCE_C_COMMENT) {
 
171
                        if (ch == '@' && chNext == 'o') {
 
172
                                if (styler.SafeGetCharAt(i+2) == 'n') {
 
173
                                        styler.ColourTo(i+2, state);
 
174
                                        state = SCE_C_DEFAULT;
 
175
                                        i+=2;
 
176
                                }
 
177
                        }
 
178
                } else if (state == SCE_C_COMMENTLINE) {
 
179
                        if (ch == '\r' || ch == '\n') {
 
180
                                endFoundThisLine = 0;
 
181
                                styler.ColourTo(i-1, state);
 
182
                                state = SCE_C_DEFAULT;
 
183
                        }
 
184
                } else if (state == SCE_C_STRING) {
 
185
                        if (ch == '\\') {
 
186
                                if (chNext == '\"' || chNext == '\'' || chNext == '\\') {
 
187
                                        i++;
 
188
                                        ch = chNext;
 
189
                                        chNext = styler.SafeGetCharAt(i + 1);
 
190
                                }
 
191
                        } else if (ch == '\"') {
 
192
                                styler.ColourTo(i, state);
 
193
                                state = SCE_C_DEFAULT;
 
194
                        } else if (chNext == '\r' || chNext == '\n') {
 
195
                                endFoundThisLine = 0;
 
196
                                styler.ColourTo(i-1, SCE_C_STRINGEOL);
 
197
                                state = SCE_C_STRINGEOL;
 
198
                        }
 
199
                } else if (state == SCE_C_CHARACTER) {
 
200
                        if ((ch == '\r' || ch == '\n') && (chPrev != '\\')) {
 
201
                                endFoundThisLine = 0;
 
202
                                styler.ColourTo(i-1, SCE_C_STRINGEOL);
 
203
                                state = SCE_C_STRINGEOL;
 
204
                        } else if (ch == '\\') {
 
205
                                if (chNext == '\"' || chNext == '\'' || chNext == '\\') {
 
206
                                        i++;
 
207
                                        ch = chNext;
 
208
                                        chNext = styler.SafeGetCharAt(i + 1);
 
209
                                }
 
210
                        } else if (ch == '\'') {
 
211
                                styler.ColourTo(i, state);
 
212
                                state = SCE_C_DEFAULT;
 
213
                        }
 
214
                }
 
215
                chPrev = ch;
 
216
        }
 
217
        styler.ColourTo(lengthDoc - 1, state);
 
218
 
 
219
        // Fill in the real level of the next line, keeping the current flags as they will be filled in later
 
220
        if (fold) {
 
221
                int flagsNext = styler.LevelAt(lineCurrent) & ~SC_FOLDLEVELNUMBERMASK;
 
222
                //styler.SetLevel(lineCurrent, levelCurrent | flagsNext);
 
223
                styler.SetLevel(lineCurrent, levelPrev | flagsNext);
 
224
 
 
225
        }
 
226
}
 
227
 
 
228
static const char * const bullantWordListDesc[] = {
 
229
        "Keywords",
 
230
        0
 
231
};
 
232
 
 
233
LexerModule lmBullant(SCLEX_BULLANT, ColouriseBullantDoc, "bullant", 0, bullantWordListDesc);