← Back to branch summary

~ubuntu-branches/ubuntu/maverick/codelite/maverick

« back to all changes in this revision

Viewing changes to sdk/wxscintilla/src/scintilla/src/LexErlang.cxx

  • Committer: Bazaar Package Importer
  • Author(s): Alessio Treglia
  • Date: 2010-07-29 19:42:47 UTC
  • mfrom: (1.1.9 upstream) (18.1.1 sid)
  • Revision ID: james.westby@ubuntu.com-20100729194247-cuibfk03wog33nxq
Tags: 2.6.0.4189~dfsg-1
* New upstream release.
* Bump Standards.
* Refresh patches.
* Add license information about files under ./Debugger/

Show diffs side-by-side

added added

removed removed

Lines of Context:
sdk/wxscintilla/src/scintilla/src/LexErlang.cxx
1
1
// Scintilla source code edit control
 
2
// Copyright 1998-2001 by Neil Hodgson <neilh@scintilla.org>
 
3
// The License.txt file describes the conditions under which this software may be distributed.
2
4
/** @file LexErlang.cxx
3
5
 ** Lexer for Erlang.
4
 
 ** Written by Peter-Henry Mander, based on Matlab lexer by Jos� Fonseca
 
6
 ** Enhanced by Etienne 'Lenain' Girondel (lenaing@gmail.com)
 
7
 ** Originally wrote by Peter-Henry Mander, 
 
8
 ** based on Matlab lexer by Jos� Fonseca.
5
9
 **/
6
 
// Copyright 1998-2001 by Neil Hodgson <neilh@scintilla.org>
7
 
// The License.txt file describes the conditions under which this software may be distributed.
8
10
 
9
11
#include <stdlib.h>
10
12
#include <string.h>
13
15
#include <stdarg.h>
14
16
 
15
17
#include "Platform.h"
16
 
 
17
18
#include "PropSet.h"
18
19
#include "Accessor.h"
19
20
#include "StyleContext.h"
25
26
using namespace Scintilla;
26
27
#endif
27
28
 
28
 
/*
29
 
   TODO:
30
 
   o  _Param should be a new lexical type
31
 
*/
32
 
 
33
29
static int is_radix(int radix, int ch) {
34
 
   int digit;
35
 
   if ( 16 < radix || 2 > radix ) {
36
 
      return 0;
37
 
   }
38
 
   if ( isdigit(ch) ) {
39
 
      digit = ch - '0';
40
 
   } else if ( isxdigit(ch) ) {
41
 
      digit = toupper(ch) - 'A' + 10;
42
 
   } else {
43
 
      return 0;
44
 
   }
45
 
   if ( digit < radix ) {
46
 
      return 1;
47
 
   } else {
48
 
      return 0;
49
 
   }
 
30
        int digit;
 
31
 
 
32
        if (36 < radix || 2 > radix)
 
33
                return 0;
 
34
 
 
35
        if (isdigit(ch)) {
 
36
                digit = ch - '0';
 
37
        } else if (isalnum(ch)) {
 
38
                digit = toupper(ch) - 'A' + 10;
 
39
        } else {
 
40
                return 0;
 
41
        }
 
42
 
 
43
        return (digit < radix);
50
44
}
51
45
 
52
46
typedef enum {
53
 
   STATE_NULL,
54
 
   ATOM_UNQUOTED,
55
 
   ATOM_QUOTED,
56
 
   ATOM_FUN_NAME,
57
 
   NODE_NAME_UNQUOTED,
58
 
   NODE_NAME_QUOTED,
59
 
   MACRO_START,
60
 
   MACRO_UNQUOTED,
61
 
   MACRO_QUOTED,
62
 
   RECORD_START,
63
 
   RECORD_UNQUOTED,
64
 
   RECORD_QUOTED,
65
 
   NUMERAL_START,
66
 
   NUMERAL_SIGNED,
67
 
   NUMERAL_RADIX_LITERAL,
68
 
   NUMERAL_SPECULATIVE_MANTISSA,
69
 
   NUMERAL_FLOAT_MANTISSA,
70
 
   NUMERAL_FLOAT_EXPONENT,
71
 
   NUMERAL_FLOAT_SIGNED_EXPONENT,
72
 
   PARSE_ERROR
 
47
        STATE_NULL,
 
48
        COMMENT,
 
49
        COMMENT_FUNCTION,
 
50
        COMMENT_MODULE,
 
51
        COMMENT_DOC,
 
52
        COMMENT_DOC_MACRO,
 
53
        ATOM_UNQUOTED,
 
54
        ATOM_QUOTED,
 
55
        NODE_NAME_UNQUOTED,
 
56
        NODE_NAME_QUOTED,
 
57
        MACRO_START,
 
58
        MACRO_UNQUOTED,
 
59
        MACRO_QUOTED,
 
60
        RECORD_START,
 
61
        RECORD_UNQUOTED,
 
62
        RECORD_QUOTED,
 
63
        NUMERAL_START,
 
64
        NUMERAL_BASE_VALUE,
 
65
        NUMERAL_FLOAT,
 
66
        NUMERAL_EXPONENT,
 
67
        PREPROCESSOR
73
68
} atom_parse_state_t;
74
69
 
 
70
static inline bool IsAWordChar(const int ch) {
 
71
        return (ch < 0x80) && (ch != ' ') && (isalnum(ch) || ch == '_');
 
72
}
 
73
 
75
74
static void ColouriseErlangDoc(unsigned int startPos, int length, int initStyle,
76
 
                               WordList *keywordlists[], Accessor &styler) {
 
75
                                                                WordList *keywordlists[], Accessor &styler) {
77
76
 
78
 
        WordList &keywords = *keywordlists[0];
 
77
        StyleContext sc(startPos, length, initStyle, styler);
 
78
        WordList &reservedWords = *keywordlists[0];
 
79
        WordList &erlangBIFs = *keywordlists[1];
 
80
        WordList &erlangPreproc = *keywordlists[2];
 
81
        WordList &erlangModulesAtt = *keywordlists[3];
 
82
        WordList &erlangDoc = *keywordlists[4];
 
83
        WordList &erlangDocMacro = *keywordlists[5];
 
84
        int radix_digits = 0;
 
85
        int exponent_digits = 0;
 
86
        atom_parse_state_t parse_state = STATE_NULL;
 
87
        atom_parse_state_t old_parse_state = STATE_NULL;
 
88
        bool to_late_to_comment = false;
 
89
        char cur[100];
 
90
        int old_style = SCE_ERLANG_DEFAULT;
79
91
 
80
92
        styler.StartAt(startPos);
81
93
 
82
 
        StyleContext sc(startPos, length, initStyle, styler);
83
 
   atom_parse_state_t parse_state = STATE_NULL;
84
 
   int radix_digits = 0;
85
 
   int exponent_digits = 0;
86
94
        for (; sc.More(); sc.Forward()) {
87
 
      if ( STATE_NULL != parse_state ) {
88
 
         switch (parse_state) {
89
 
         case STATE_NULL:
90
 
                                sc.SetState(SCE_ERLANG_DEFAULT);
91
 
            break;
92
 
         case ATOM_UNQUOTED:
93
 
            if ( '@' == sc.ch ){
94
 
               parse_state = NODE_NAME_UNQUOTED;
95
 
            } else if ( !isalnum(sc.ch) && sc.ch != '_' ) {
96
 
               char s[100];
97
 
               sc.GetCurrent(s, sizeof(s));
98
 
               if (keywords.InList(s)) {
99
 
                  sc.ChangeState(SCE_ERLANG_KEYWORD);
100
 
                  sc.SetState(SCE_ERLANG_DEFAULT);
101
 
                  parse_state = STATE_NULL;
102
 
               } else {
103
 
                  if ( '/' == sc.ch ) {
104
 
                     parse_state = ATOM_FUN_NAME;
105
 
                  } else {
106
 
                     sc.ChangeState(SCE_ERLANG_ATOM);
107
 
                     sc.SetState(SCE_ERLANG_DEFAULT);
108
 
                     parse_state = STATE_NULL;
109
 
                  }
110
 
               }
111
 
            }
112
 
            break;
113
 
         case ATOM_QUOTED:
114
 
            if ( '@' == sc.ch ){
115
 
               parse_state = NODE_NAME_QUOTED;
116
 
            } else if ( '\'' == sc.ch && '\\' != sc.chPrev ) {
117
 
               sc.ChangeState(SCE_ERLANG_ATOM);
118
 
               sc.ForwardSetState(SCE_ERLANG_DEFAULT);
119
 
               parse_state = STATE_NULL;
120
 
            }
121
 
            break;
122
 
         case ATOM_FUN_NAME:
123
 
            if ( !isdigit(sc.ch) ) {
124
 
               sc.ChangeState(SCE_ERLANG_FUNCTION_NAME);
125
 
               sc.SetState(SCE_ERLANG_DEFAULT);
126
 
               parse_state = STATE_NULL;
127
 
            }
128
 
            break;
129
 
         case NODE_NAME_QUOTED:
130
 
            if ( '@' == sc.ch ) {
131
 
               sc.SetState(SCE_ERLANG_DEFAULT);
132
 
               parse_state = STATE_NULL;
133
 
            } else if ( '\'' == sc.ch && '\\' != sc.chPrev ) {
134
 
               sc.ChangeState(SCE_ERLANG_NODE_NAME);
135
 
               sc.ForwardSetState(SCE_ERLANG_DEFAULT);
136
 
               parse_state = STATE_NULL;
137
 
            }
138
 
            break;
139
 
         case NODE_NAME_UNQUOTED:
140
 
            if ( '@' == sc.ch ) {
141
 
               sc.SetState(SCE_ERLANG_DEFAULT);
142
 
               parse_state = STATE_NULL;
143
 
            } else if ( !isalnum(sc.ch) && sc.ch != '_' ) {
144
 
               sc.ChangeState(SCE_ERLANG_NODE_NAME);
145
 
               sc.SetState(SCE_ERLANG_DEFAULT);
146
 
               parse_state = STATE_NULL;
147
 
            }
148
 
            break;
149
 
         case RECORD_START:
150
 
            if ( '\'' == sc.ch ) {
151
 
               parse_state = RECORD_QUOTED;
152
 
            } else if (isalpha(sc.ch) && islower(sc.ch)) {
153
 
               parse_state = RECORD_UNQUOTED;
154
 
            } else { // error
155
 
               sc.SetState(SCE_ERLANG_DEFAULT);
156
 
               parse_state = STATE_NULL;
157
 
            }
158
 
            break;
159
 
         case RECORD_QUOTED:
160
 
            if ( '\'' == sc.ch && '\\' != sc.chPrev ) {
161
 
               sc.ChangeState(SCE_ERLANG_RECORD);
162
 
               sc.ForwardSetState(SCE_ERLANG_DEFAULT);
163
 
               parse_state = STATE_NULL;
164
 
            }
165
 
            break;
166
 
         case RECORD_UNQUOTED:
167
 
            if ( !isalpha(sc.ch) && '_' != sc.ch ) {
168
 
               sc.ChangeState(SCE_ERLANG_RECORD);
169
 
               sc.SetState(SCE_ERLANG_DEFAULT);
170
 
               parse_state = STATE_NULL;
171
 
            }
172
 
            break;
173
 
         case MACRO_START:
174
 
            if ( '\'' == sc.ch ) {
175
 
               parse_state = MACRO_QUOTED;
176
 
            } else if (isalpha(sc.ch)) {
177
 
               parse_state = MACRO_UNQUOTED;
178
 
            } else { // error
179
 
               sc.SetState(SCE_ERLANG_DEFAULT);
180
 
               parse_state = STATE_NULL;
181
 
            }
182
 
            break;
183
 
         case MACRO_UNQUOTED:
184
 
            if ( !isalpha(sc.ch) && '_' != sc.ch ) {
185
 
               sc.ChangeState(SCE_ERLANG_MACRO);
186
 
               sc.SetState(SCE_ERLANG_DEFAULT);
187
 
               parse_state = STATE_NULL;
188
 
            }
189
 
            break;
190
 
         case MACRO_QUOTED:
191
 
            if ( '\'' == sc.ch && '\\' != sc.chPrev ) {
192
 
               sc.ChangeState(SCE_ERLANG_MACRO);
193
 
               sc.ForwardSetState(SCE_ERLANG_DEFAULT);
194
 
               parse_state = STATE_NULL;
195
 
            }
196
 
            break;
197
 
         case NUMERAL_START:
198
 
            if ( isdigit(sc.ch) ) {
199
 
               radix_digits *= 10;
200
 
               radix_digits += sc.ch - '0'; // Assuming ASCII here!
201
 
            } else if ( '#' == sc.ch ) {
202
 
               if ( 2 > radix_digits || 16 < radix_digits) {
203
 
                  sc.SetState(SCE_ERLANG_DEFAULT);
204
 
                  parse_state = STATE_NULL;
205
 
               } else {
206
 
                  parse_state = NUMERAL_RADIX_LITERAL;
207
 
               }
208
 
            } else if ( '.' == sc.ch && isdigit(sc.chNext)) {
209
 
               radix_digits = 0;
210
 
               parse_state = NUMERAL_FLOAT_MANTISSA;
211
 
            } else if ( 'e' == sc.ch || 'E' == sc.ch ) {
212
 
               exponent_digits = 0;
213
 
               parse_state = NUMERAL_FLOAT_EXPONENT;
214
 
            } else {
215
 
               radix_digits = 0;
216
 
               sc.ChangeState(SCE_ERLANG_NUMBER);
217
 
               sc.SetState(SCE_ERLANG_DEFAULT);
218
 
               parse_state = STATE_NULL;
219
 
            }
220
 
            break;
221
 
         case NUMERAL_RADIX_LITERAL:
222
 
            if ( !is_radix(radix_digits,sc.ch) ) {
223
 
               radix_digits = 0;
224
 
               if ( !isalnum(sc.ch) ) {
225
 
                  sc.ChangeState(SCE_ERLANG_NUMBER);
226
 
               }
227
 
               sc.SetState(SCE_ERLANG_DEFAULT);
228
 
               parse_state = STATE_NULL;
229
 
            }
230
 
            break;
231
 
         case NUMERAL_FLOAT_MANTISSA:
232
 
            if ( 'e' == sc.ch || 'E' == sc.ch ) {
233
 
               exponent_digits = 0;
234
 
               parse_state = NUMERAL_FLOAT_EXPONENT;
235
 
            } else if ( !isdigit(sc.ch) ) {
236
 
               sc.ChangeState(SCE_ERLANG_NUMBER);
237
 
               sc.SetState(SCE_ERLANG_DEFAULT);
238
 
               parse_state = STATE_NULL;
239
 
            }
240
 
            break;
241
 
         case NUMERAL_FLOAT_EXPONENT:
242
 
            if ( '-' == sc.ch || '+' == sc.ch ) {
243
 
               parse_state = NUMERAL_FLOAT_SIGNED_EXPONENT;
244
 
            } else if ( !isdigit(sc.ch) ) {
245
 
               if ( 0 < exponent_digits ) {
246
 
                  sc.ChangeState(SCE_ERLANG_NUMBER);
247
 
               }
248
 
               sc.SetState(SCE_ERLANG_DEFAULT);
249
 
               parse_state = STATE_NULL;
250
 
            } else {
251
 
               ++exponent_digits;
252
 
            }
253
 
            break;
254
 
         case NUMERAL_FLOAT_SIGNED_EXPONENT:
255
 
            if ( !isdigit(sc.ch) ) {
256
 
               if ( 0 < exponent_digits ) {
257
 
                  sc.ChangeState(SCE_ERLANG_NUMBER);
258
 
               }
259
 
               sc.SetState(SCE_ERLANG_DEFAULT);
260
 
               parse_state = STATE_NULL;
261
 
            } else {
262
 
               ++exponent_digits;
263
 
            }
264
 
            break;
265
 
         case NUMERAL_SIGNED:
266
 
            if ( !isdigit(sc.ch) ) {
267
 
               sc.ChangeState(SCE_ERLANG_NUMBER);
268
 
               sc.SetState(SCE_ERLANG_DEFAULT);
269
 
               parse_state = STATE_NULL;
270
 
            } else if ( '.' == sc.ch ) {
271
 
               parse_state = NUMERAL_FLOAT_MANTISSA;
272
 
            }
273
 
            break;
274
 
         case NUMERAL_SPECULATIVE_MANTISSA:
275
 
            if ( !isdigit(sc.ch) ) {
276
 
               sc.ChangeState(SCE_ERLANG_OPERATOR);
277
 
               sc.SetState(SCE_ERLANG_DEFAULT);
278
 
               parse_state = STATE_NULL;
279
 
            } else {
280
 
               parse_state = NUMERAL_FLOAT_MANTISSA;
281
 
            }
282
 
            break;
283
 
         case PARSE_ERROR:
284
 
                                sc.SetState(SCE_ERLANG_DEFAULT);
285
 
            parse_state = STATE_NULL;
286
 
            break;
287
 
         }
288
 
      } else if (sc.state == SCE_ERLANG_OPERATOR) {
289
 
                        if (sc.chPrev == '.') {
290
 
                                if (sc.ch == '*' || sc.ch == '/' || sc.ch == '\\' || sc.ch == '^') {
291
 
                                        sc.ForwardSetState(SCE_ERLANG_DEFAULT);
292
 
                                } else if (sc.ch == '\'') {
293
 
                                        sc.ForwardSetState(SCE_ERLANG_DEFAULT);
294
 
                                } else {
295
 
                                        sc.SetState(SCE_ERLANG_DEFAULT);
296
 
                                }
297
 
                        } else {
298
 
                                sc.SetState(SCE_ERLANG_DEFAULT);
299
 
                        }
300
 
                } else if (sc.state == SCE_ERLANG_VARIABLE) {
301
 
                        if (!isalnum(sc.ch) && sc.ch != '_') {
302
 
            sc.SetState(SCE_ERLANG_DEFAULT);
303
 
                        }
304
 
                } else if (sc.state == SCE_ERLANG_STRING) {
305
 
                        if (sc.ch == '\"' && sc.chPrev != '\\') {
306
 
                                sc.ForwardSetState(SCE_ERLANG_DEFAULT);
307
 
                        }
308
 
                } else if (sc.state == SCE_ERLANG_COMMENT ) {
309
 
                        if (sc.atLineEnd) {
310
 
                                sc.SetState(SCE_ERLANG_DEFAULT);
311
 
                        }
312
 
      } else if (sc.state == SCE_ERLANG_CHARACTER ) {
313
 
         if ( sc.chPrev == '\\' ) {
314
 
            sc.ForwardSetState(SCE_ERLANG_DEFAULT);
315
 
         } else if ( sc.ch != '\\' ) {
316
 
            sc.ForwardSetState(SCE_ERLANG_DEFAULT);
317
 
         }
318
 
      }
 
95
                int style = SCE_ERLANG_DEFAULT;
 
96
                if (STATE_NULL != parse_state) {
 
97
 
 
98
                        switch (parse_state) {
 
99
 
 
100
                                case STATE_NULL : sc.SetState(SCE_ERLANG_DEFAULT); break;
 
101
 
 
102
                        /* COMMENTS ------------------------------------------------------*/
 
103
                                case COMMENT : {
 
104
                                        if (sc.ch != '%') {
 
105
                                                to_late_to_comment = true;
 
106
                                        } else if (!to_late_to_comment && sc.ch == '%') {
 
107
                                                // Switch to comment level 2 (Function)
 
108
                                                sc.ChangeState(SCE_ERLANG_COMMENT_FUNCTION);
 
109
                                                old_style = SCE_ERLANG_COMMENT_FUNCTION;
 
110
                                                parse_state = COMMENT_FUNCTION;
 
111
                                                sc.Forward();
 
112
                                        }
 
113
                                }
 
114
                                // V--- Falling through!
 
115
                                case COMMENT_FUNCTION : {
 
116
                                        if (sc.ch != '%') {
 
117
                                                to_late_to_comment = true;
 
118
                                        } else if (!to_late_to_comment && sc.ch == '%') {
 
119
                                                // Switch to comment level 3 (Module)
 
120
                                                sc.ChangeState(SCE_ERLANG_COMMENT_MODULE);
 
121
                                                old_style = SCE_ERLANG_COMMENT_MODULE;
 
122
                                                parse_state = COMMENT_MODULE;
 
123
                                                sc.Forward();
 
124
                                        }
 
125
                                }
 
126
                                // V--- Falling through!
 
127
                                case COMMENT_MODULE : {
 
128
                                        if (parse_state != COMMENT) {
 
129
                                                // Search for comment documentation
 
130
                                                if (sc.chNext == '@') {
 
131
                                                        old_parse_state = parse_state;
 
132
                                                        parse_state = ('{' == sc.ch)
 
133
                                                                                        ? COMMENT_DOC_MACRO
 
134
                                                                                        : COMMENT_DOC;
 
135
                                                        sc.ForwardSetState(sc.state);
 
136
                                                }
 
137
                                        }
 
138
 
 
139
                                        // All comments types fall here.
 
140
                                        if (sc.atLineEnd) {
 
141
                                                to_late_to_comment = false;
 
142
                                                sc.SetState(SCE_ERLANG_DEFAULT);
 
143
                                                parse_state = STATE_NULL;
 
144
                                        }
 
145
                                } break;
 
146
 
 
147
                                case COMMENT_DOC :
 
148
                                // V--- Falling through!
 
149
                                case COMMENT_DOC_MACRO : {
 
150
 
 
151
                                        if (!isalnum(sc.ch)) {
 
152
                                                // Try to match documentation comment
 
153
                                                sc.GetCurrent(cur, sizeof(cur));
 
154
 
 
155
                                                if (parse_state == COMMENT_DOC_MACRO 
 
156
                                                        && erlangDocMacro.InList(cur)) {
 
157
                                                                sc.ChangeState(SCE_ERLANG_COMMENT_DOC_MACRO);
 
158
                                                                while (sc.ch != '}' && !sc.atLineEnd)
 
159
                                                                        sc.Forward();
 
160
                                                } else if (erlangDoc.InList(cur)) {
 
161
                                                        sc.ChangeState(SCE_ERLANG_COMMENT_DOC);
 
162
                                                } else {
 
163
                                                        sc.ChangeState(old_style);
 
164
                                                }
 
165
 
 
166
                                                // Switch back to old state
 
167
                                                sc.SetState(old_style);
 
168
                                                parse_state = old_parse_state;
 
169
                                        }
 
170
 
 
171
                                        if (sc.atLineEnd) {
 
172
                                                to_late_to_comment = false;
 
173
                                                sc.ChangeState(old_style);
 
174
                                                sc.SetState(SCE_ERLANG_DEFAULT);
 
175
                                                parse_state = STATE_NULL;
 
176
                                        }
 
177
                                } break;
 
178
 
 
179
                        /* -------------------------------------------------------------- */
 
180
                        /* Atoms ---------------------------------------------------------*/
 
181
                                case ATOM_UNQUOTED : {
 
182
                                        if ('@' == sc.ch){
 
183
                                                parse_state = NODE_NAME_UNQUOTED;
 
184
                                        } else if (sc.ch == ':') {
 
185
                                                // Searching for module name
 
186
                                                if (sc.chNext == ' ') {
 
187
                                                        // error
 
188
                                                        sc.ChangeState(SCE_ERLANG_UNKNOWN);
 
189
                                                        parse_state = STATE_NULL;
 
190
                                                } else {
 
191
                                                        sc.Forward();
 
192
                                                        if (isalnum(sc.ch))  {
 
193
                                                                sc.GetCurrent(cur, sizeof(cur));
 
194
                                                                sc.ChangeState(SCE_ERLANG_MODULES);
 
195
                                                                sc.SetState(SCE_ERLANG_MODULES);
 
196
                                                        }
 
197
                                                }
 
198
                                        } else if (!IsAWordChar(sc.ch)) {
 
199
 
 
200
                                                sc.GetCurrent(cur, sizeof(cur));
 
201
                                                if (reservedWords.InList(cur)) {
 
202
                                                        style = SCE_ERLANG_KEYWORD;
 
203
                                                } else if (erlangBIFs.InList(cur)
 
204
                                                                        && strcmp(cur,"erlang:")){
 
205
                                                        style = SCE_ERLANG_BIFS;
 
206
                                                } else if (sc.ch == '(' || '/' == sc.ch){
 
207
                                                        style = SCE_ERLANG_FUNCTION_NAME;
 
208
                                                } else {
 
209
                                                        style = SCE_ERLANG_ATOM;
 
210
                                                }
 
211
 
 
212
                                                sc.ChangeState(style);
 
213
                                                sc.SetState(SCE_ERLANG_DEFAULT);
 
214
                                                parse_state = STATE_NULL;
 
215
                                        }
 
216
 
 
217
                                } break;
 
218
 
 
219
                                case ATOM_QUOTED : {
 
220
                                        if ( '@' == sc.ch ){
 
221
                                                parse_state = NODE_NAME_QUOTED;
 
222
                                        } else if ('\'' == sc.ch && '\\' != sc.chPrev) {
 
223
                                                sc.ChangeState(SCE_ERLANG_ATOM);
 
224
                                                sc.ForwardSetState(SCE_ERLANG_DEFAULT);
 
225
                                                parse_state = STATE_NULL;
 
226
                                        }
 
227
                                } break;
 
228
 
 
229
                        /* -------------------------------------------------------------- */
 
230
                        /* Node names ----------------------------------------------------*/
 
231
                                case NODE_NAME_UNQUOTED : {
 
232
                                        if ('@' == sc.ch) {
 
233
                                                sc.SetState(SCE_ERLANG_DEFAULT);
 
234
                                                parse_state = STATE_NULL;
 
235
                                        } else if (!IsAWordChar(sc.ch)) {
 
236
                                                sc.ChangeState(SCE_ERLANG_NODE_NAME);
 
237
                                                sc.SetState(SCE_ERLANG_DEFAULT);
 
238
                                                parse_state = STATE_NULL;
 
239
                                        }
 
240
                                } break;
 
241
 
 
242
                                case NODE_NAME_QUOTED : {
 
243
                                        if ('@' == sc.ch) {
 
244
                                                sc.SetState(SCE_ERLANG_DEFAULT);
 
245
                                                parse_state = STATE_NULL;
 
246
                                        } else if ('\'' == sc.ch && '\\' != sc.chPrev) {
 
247
                                                sc.ChangeState(SCE_ERLANG_NODE_NAME_QUOTED);
 
248
                                                sc.ForwardSetState(SCE_ERLANG_DEFAULT);
 
249
                                                parse_state = STATE_NULL;
 
250
                                        }
 
251
                                } break;
 
252
 
 
253
                        /* -------------------------------------------------------------- */
 
254
                        /* Records -------------------------------------------------------*/
 
255
                                case RECORD_START : {
 
256
                                        if ('\'' == sc.ch) {
 
257
                                                parse_state = RECORD_QUOTED;
 
258
                                        } else if (isalpha(sc.ch) && islower(sc.ch)) {
 
259
                                                parse_state = RECORD_UNQUOTED;
 
260
                                        } else { // error
 
261
                                                sc.SetState(SCE_ERLANG_DEFAULT);
 
262
                                                parse_state = STATE_NULL;
 
263
                                        }
 
264
                                } break;
 
265
 
 
266
                                case RECORD_UNQUOTED : {
 
267
                                        if (!IsAWordChar(sc.ch)) {
 
268
                                                sc.ChangeState(SCE_ERLANG_RECORD);
 
269
                                                sc.SetState(SCE_ERLANG_DEFAULT);
 
270
                                                parse_state = STATE_NULL;
 
271
                                        }
 
272
                                } break;
 
273
 
 
274
                                case RECORD_QUOTED : {
 
275
                                        if ('\'' == sc.ch && '\\' != sc.chPrev) {
 
276
                                                sc.ChangeState(SCE_ERLANG_RECORD_QUOTED);
 
277
                                                sc.ForwardSetState(SCE_ERLANG_DEFAULT);
 
278
                                                parse_state = STATE_NULL;
 
279
                                        }
 
280
                                } break;
 
281
 
 
282
                        /* -------------------------------------------------------------- */
 
283
                        /* Macros --------------------------------------------------------*/
 
284
                                case MACRO_START : {
 
285
                                        if ('\'' == sc.ch) {
 
286
                                                parse_state = MACRO_QUOTED;
 
287
                                        } else if (isalpha(sc.ch)) {
 
288
                                                parse_state = MACRO_UNQUOTED;
 
289
                                        } else { // error
 
290
                                                sc.SetState(SCE_ERLANG_DEFAULT);
 
291
                                                parse_state = STATE_NULL;
 
292
                                        }
 
293
                                } break;
 
294
 
 
295
                                case MACRO_UNQUOTED : {
 
296
                                        if (!IsAWordChar(sc.ch)) {
 
297
                                                sc.ChangeState(SCE_ERLANG_MACRO);
 
298
                                                sc.SetState(SCE_ERLANG_DEFAULT);
 
299
                                                parse_state = STATE_NULL;
 
300
                                        }
 
301
                                } break;
 
302
 
 
303
                                case MACRO_QUOTED : {
 
304
                                        if ('\'' == sc.ch && '\\' != sc.chPrev) {
 
305
                                                sc.ChangeState(SCE_ERLANG_MACRO_QUOTED);
 
306
                                                sc.ForwardSetState(SCE_ERLANG_DEFAULT);
 
307
                                                parse_state = STATE_NULL;
 
308
                                        }
 
309
                                } break;
 
310
 
 
311
                        /* -------------------------------------------------------------- */
 
312
                        /* Numerics ------------------------------------------------------*/
 
313
                        /* Simple integer */
 
314
                                case NUMERAL_START : {
 
315
                                        if (isdigit(sc.ch)) {
 
316
                                                radix_digits *= 10;
 
317
                                                radix_digits += sc.ch - '0'; // Assuming ASCII here!
 
318
                                        } else if ('#' == sc.ch) {
 
319
                                                if (2 > radix_digits || 36 < radix_digits) {
 
320
                                                        sc.SetState(SCE_ERLANG_DEFAULT);
 
321
                                                        parse_state = STATE_NULL;
 
322
                                                } else {
 
323
                                                        parse_state = NUMERAL_BASE_VALUE;
 
324
                                                }
 
325
                                        } else if ('.' == sc.ch && isdigit(sc.chNext)) {
 
326
                                                radix_digits = 0;
 
327
                                                parse_state = NUMERAL_FLOAT;
 
328
                                        } else if ('e' == sc.ch || 'E' == sc.ch) {
 
329
                                                exponent_digits = 0;
 
330
                                                parse_state = NUMERAL_EXPONENT;
 
331
                                        } else {
 
332
                                                radix_digits = 0;
 
333
                                                sc.ChangeState(SCE_ERLANG_NUMBER);
 
334
                                                sc.SetState(SCE_ERLANG_DEFAULT);
 
335
                                                parse_state = STATE_NULL;
 
336
                                        }
 
337
                                } break;
 
338
 
 
339
                        /* Integer in other base than 10 (x#yyy) */
 
340
                                case NUMERAL_BASE_VALUE : {
 
341
                                        if (!is_radix(radix_digits,sc.ch)) {
 
342
                                                radix_digits = 0;
 
343
                                
 
344
                                                if (!isalnum(sc.ch))
 
345
                                                        sc.ChangeState(SCE_ERLANG_NUMBER);
 
346
 
 
347
                                                sc.SetState(SCE_ERLANG_DEFAULT);
 
348
                                                parse_state = STATE_NULL;
 
349
                                        }
 
350
                                } break;
 
351
 
 
352
                        /* Float (x.yyy) */
 
353
                                case NUMERAL_FLOAT : {
 
354
                                        if ('e' == sc.ch || 'E' == sc.ch) {
 
355
                                                exponent_digits = 0;
 
356
                                                parse_state = NUMERAL_EXPONENT;
 
357
                                        } else if (!isdigit(sc.ch)) {
 
358
                                                sc.ChangeState(SCE_ERLANG_NUMBER);
 
359
                                                sc.SetState(SCE_ERLANG_DEFAULT);
 
360
                                                parse_state = STATE_NULL;
 
361
                                        }
 
362
                                } break;
 
363
 
 
364
                        /* Exponent, either integer or float (xEyy, x.yyEzzz) */
 
365
                                case NUMERAL_EXPONENT : {
 
366
                                        if (('-' == sc.ch || '+' == sc.ch)
 
367
                                                        && (isdigit(sc.chNext))) {
 
368
                                                sc.Forward();
 
369
                                        } else if (!isdigit(sc.ch)) {
 
370
                                                if (0 < exponent_digits)
 
371
                                                        sc.ChangeState(SCE_ERLANG_NUMBER);
 
372
                                                sc.SetState(SCE_ERLANG_DEFAULT);
 
373
                                                parse_state = STATE_NULL;
 
374
                                        } else {
 
375
                                                ++exponent_digits;
 
376
                                        }
 
377
                                } break;
 
378
 
 
379
                        /* -------------------------------------------------------------- */
 
380
                        /* Preprocessor --------------------------------------------------*/
 
381
                                case PREPROCESSOR : {
 
382
                                        if (!IsAWordChar(sc.ch)) {
 
383
                                                
 
384
                                                sc.GetCurrent(cur, sizeof(cur));
 
385
                                                if (erlangPreproc.InList(cur)) {
 
386
                                                        style = SCE_ERLANG_PREPROC;
 
387
                                                } else if (erlangModulesAtt.InList(cur)) {
 
388
                                                        style = SCE_ERLANG_MODULES_ATT;
 
389
                                                }
 
390
 
 
391
                                                sc.ChangeState(style);
 
392
                                                sc.SetState(SCE_ERLANG_DEFAULT);
 
393
                                                parse_state = STATE_NULL;
 
394
                                        }
 
395
                                } break;
 
396
 
 
397
                        }
 
398
 
 
399
                } /* End of : STATE_NULL != parse_state */
 
400
                else
 
401
                {
 
402
                        switch (sc.state) {
 
403
                                case SCE_ERLANG_VARIABLE : {
 
404
                                        if (!IsAWordChar(sc.ch))
 
405
                                                sc.SetState(SCE_ERLANG_DEFAULT);
 
406
                                } break;
 
407
                                case SCE_ERLANG_STRING : {
 
408
                                         if (sc.ch == '\"' && sc.chPrev != '\\')
 
409
                                                sc.ForwardSetState(SCE_ERLANG_DEFAULT);
 
410
                                } break;
 
411
                                case SCE_ERLANG_COMMENT : {
 
412
                                         if (sc.atLineEnd)
 
413
                                                sc.SetState(SCE_ERLANG_DEFAULT);
 
414
                                } break;
 
415
                                case SCE_ERLANG_CHARACTER : {
 
416
                                        if (sc.chPrev == '\\') {
 
417
                                                sc.ForwardSetState(SCE_ERLANG_DEFAULT);
 
418
                                        } else if (sc.ch != '\\') {
 
419
                                                sc.ForwardSetState(SCE_ERLANG_DEFAULT);
 
420
                                        }
 
421
                                } break;
 
422
                                case SCE_ERLANG_OPERATOR : {
 
423
                                        if (sc.chPrev == '.') {
 
424
                                                if (sc.ch == '*' || sc.ch == '/' || sc.ch == '\\' 
 
425
                                                        || sc.ch == '^') {
 
426
                                                        sc.ForwardSetState(SCE_ERLANG_DEFAULT);
 
427
                                                } else if (sc.ch == '\'') {
 
428
                                                        sc.ForwardSetState(SCE_ERLANG_DEFAULT);
 
429
                                                } else {
 
430
                                                        sc.SetState(SCE_ERLANG_DEFAULT);
 
431
                                                }
 
432
                                        } else {
 
433
                                                sc.SetState(SCE_ERLANG_DEFAULT);
 
434
                                        }
 
435
                                } break;
 
436
                        }
 
437
                }
319
438
 
320
439
                if (sc.state == SCE_ERLANG_DEFAULT) {
321
 
                        if (sc.ch == '%') {
322
 
                                sc.SetState(SCE_ERLANG_COMMENT);
323
 
                        } else if (sc.ch == '\"') {
324
 
            sc.SetState(SCE_ERLANG_STRING);
325
 
         } else if (sc.ch == '#') {
326
 
            parse_state = RECORD_START;
327
 
                                sc.SetState(SCE_ERLANG_UNKNOWN);
328
 
         } else if (sc.ch == '?') {
329
 
            parse_state = MACRO_START;
330
 
                                sc.SetState(SCE_ERLANG_UNKNOWN);
331
 
         } else if (sc.ch == '$') {
332
 
                                sc.SetState(SCE_ERLANG_CHARACTER);
333
 
         } else if (sc.ch == '\'') {
334
 
            parse_state = ATOM_QUOTED;
335
 
                                sc.SetState(SCE_ERLANG_UNKNOWN);
336
 
                        } else if ( isdigit(sc.ch) ) {
337
 
            parse_state = NUMERAL_START;
338
 
            radix_digits = sc.ch - '0';
339
 
                                sc.SetState(SCE_ERLANG_UNKNOWN);
340
 
         } else if ( '.' == sc.ch ) {
341
 
            parse_state = NUMERAL_SPECULATIVE_MANTISSA;
342
 
                                sc.SetState(SCE_ERLANG_UNKNOWN);
343
 
                        } else if (isalpha(sc.ch) && isupper(sc.ch)) {
344
 
                                sc.SetState(SCE_ERLANG_VARIABLE);
345
 
                        } else if (isalpha(sc.ch)) {
346
 
            parse_state = ATOM_UNQUOTED;
347
 
                                sc.SetState(SCE_ERLANG_UNKNOWN);
348
 
                        } else if (isoperator(static_cast<char>(sc.ch)) || sc.ch == '\\') {
349
 
                                sc.SetState(SCE_ERLANG_OPERATOR);
 
440
                        bool no_new_state = false;
 
441
 
 
442
                        switch (sc.ch) {
 
443
                                case '\"' : sc.SetState(SCE_ERLANG_STRING); break;
 
444
                                case '$' : sc.SetState(SCE_ERLANG_CHARACTER); break;
 
445
                                case '%' : {
 
446
                                        parse_state = COMMENT;
 
447
                                        sc.SetState(SCE_ERLANG_COMMENT);
 
448
                                } break;
 
449
                                case '#' : {
 
450
                                        parse_state = RECORD_START;
 
451
                                        sc.SetState(SCE_ERLANG_UNKNOWN);
 
452
                                } break;
 
453
                                case '?' : {
 
454
                                        parse_state = MACRO_START;
 
455
                                        sc.SetState(SCE_ERLANG_UNKNOWN);
 
456
                                } break;
 
457
                                case '\'' : {
 
458
                                        parse_state = ATOM_QUOTED;
 
459
                                        sc.SetState(SCE_ERLANG_UNKNOWN);
 
460
                                } break;
 
461
                                case '+' :
 
462
                                case '-' : {
 
463
                                        if (IsADigit(sc.chNext)) {
 
464
                                                parse_state = NUMERAL_START;
 
465
                                                radix_digits = 0;
 
466
                                                sc.SetState(SCE_ERLANG_UNKNOWN);
 
467
                                        } else if (sc.ch != '+') {
 
468
                                                parse_state = PREPROCESSOR;
 
469
                                                sc.SetState(SCE_ERLANG_UNKNOWN);
 
470
                                        }
 
471
                                } break;
 
472
                                default : no_new_state = true;
 
473
                        }
 
474
 
 
475
                        if (no_new_state) {
 
476
                                if (isdigit(sc.ch)) {
 
477
                                        parse_state = NUMERAL_START;
 
478
                                        radix_digits = sc.ch - '0';
 
479
                                        sc.SetState(SCE_ERLANG_UNKNOWN);
 
480
                                } else if (isupper(sc.ch) || '_' == sc.ch) {
 
481
                                        sc.SetState(SCE_ERLANG_VARIABLE);
 
482
                                } else if (isalpha(sc.ch)) {
 
483
                                        parse_state = ATOM_UNQUOTED;
 
484
                                        sc.SetState(SCE_ERLANG_UNKNOWN);
 
485
                                } else if (isoperator(static_cast<char>(sc.ch))
 
486
                                                        || sc.ch == '\\') {
 
487
                                        sc.SetState(SCE_ERLANG_OPERATOR);
 
488
                                }
350
489
                        }
351
490
                }
 
491
 
352
492
        }
353
493
        sc.Complete();
354
494
}
355
495
 
356
 
static int ClassifyFoldPointErlang(
357
 
   Accessor &styler,
358
 
   int styleNext,
359
 
   int keyword_start
 
496
static int ClassifyErlangFoldPoint(
 
497
        Accessor &styler,
 
498
        int styleNext,
 
499
        int keyword_start
360
500
) {
361
501
        int lev = 0;
362
 
   if ( styler.Match(keyword_start,"case")
363
 
      || (
364
 
            styler.Match(keyword_start,"fun")
365
 
         && SCE_ERLANG_FUNCTION_NAME != styleNext)
366
 
      || styler.Match(keyword_start,"if")
367
 
      || styler.Match(keyword_start,"query")
368
 
      || styler.Match(keyword_start,"receive")
369
 
   ) {
370
 
      ++lev;
371
 
   } else if ( styler.Match(keyword_start,"end") ) {
372
 
      --lev;
373
 
   }
 
502
        if (styler.Match(keyword_start,"case")
 
503
                || (
 
504
                        styler.Match(keyword_start,"fun")
 
505
                        && (SCE_ERLANG_FUNCTION_NAME != styleNext)
 
506
                        )
 
507
                || styler.Match(keyword_start,"if")
 
508
                || styler.Match(keyword_start,"query")
 
509
                || styler.Match(keyword_start,"receive")
 
510
        ) {
 
511
                ++lev;
 
512
        } else if (styler.Match(keyword_start,"end")) {
 
513
                --lev;
 
514
        }
 
515
 
374
516
        return lev;
375
517
}
376
518
 
377
 
 
378
519
static void FoldErlangDoc(
379
 
   unsigned int startPos, int length, int initStyle,
380
 
   WordList** /*keywordlists*/, Accessor &styler
 
520
        unsigned int startPos, int length, int initStyle,
 
521
        WordList** /*keywordlists*/, Accessor &styler
381
522
) {
382
523
        unsigned int endPos = startPos + length;
383
 
        //~ int visibleChars = 0;
384
 
        int lineCurrent = styler.GetLine(startPos);
385
 
        int levelPrev = styler.LevelAt(lineCurrent) & SC_FOLDLEVELNUMBERMASK;
386
 
        int levelCurrent = levelPrev;
387
 
        char chNext = styler.SafeGetCharAt(startPos);
 
524
        int currentLine = styler.GetLine(startPos);
 
525
        int lev;
 
526
        int previousLevel = styler.LevelAt(currentLine) & SC_FOLDLEVELNUMBERMASK;
 
527
        int currentLevel = previousLevel;
388
528
        int styleNext = styler.StyleAt(startPos);
389
529
        int style = initStyle;
 
530
        int stylePrev;
390
531
        int keyword_start = 0;
391
 
 
392
 
   bool fold_keywords = true;
393
 
   bool fold_comments = true;
394
 
   bool fold_braces = true;
395
 
   bool fold_function_clauses = false;
396
 
   bool fold_clauses = false;
397
 
 
398
 
   //int clause_level = 0;
 
532
        char ch;
 
533
        char chNext = styler.SafeGetCharAt(startPos);
 
534
        bool atEOL;
399
535
 
400
536
        for (unsigned int i = startPos; i < endPos; i++) {
401
 
                char ch = chNext;
 
537
                ch = chNext;
402
538
                chNext = styler.SafeGetCharAt(i + 1);
403
 
                int stylePrev = style;
 
539
 
 
540
                // Get styles
 
541
                stylePrev = style;
404
542
                style = styleNext;
405
543
                styleNext = styler.StyleAt(i + 1);
406
 
                bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n');
407
 
 
408
 
      if ( (stylePrev != SCE_ERLANG_KEYWORD) && (style == SCE_ERLANG_KEYWORD) ) {
409
 
         keyword_start = i;
410
 
      }
411
 
      if ( fold_keywords ) {
412
 
         if ( (stylePrev == SCE_ERLANG_KEYWORD)
413
 
            && (style != SCE_ERLANG_KEYWORD)
414
 
            && (style != SCE_ERLANG_ATOM)
415
 
         ) {
416
 
            levelCurrent += ClassifyFoldPointErlang(styler,styleNext,keyword_start);
417
 
         }
418
 
      }
419
 
 
420
 
      if ( fold_comments ) {
421
 
         if (style == SCE_ERLANG_COMMENT) {
422
 
            if ((ch == '%') && (chNext == '{')) {
423
 
               levelCurrent++;
424
 
            } else if ((ch == '%') && (chNext == '}')) {
425
 
               levelCurrent--;
426
 
            }
427
 
         }
428
 
      }
429
 
 
430
 
      if ( fold_function_clauses ) {
431
 
         if ( (SC_FOLDLEVELBASE == levelCurrent) /*&& (style == SCE_ERLANG_OPERATOR)*/ ) {
432
 
            if ( (ch == '-') && (chNext == '>')) {
433
 
               //~ fprintf(stderr,"levelCurrent=%d\n", levelCurrent);
434
 
               //++clause_level;
435
 
               //~ if ( 0 < clause_level )
436
 
                  ++levelCurrent;
437
 
            }
438
 
         }
439
 
         //~ if (  (stylePrev != SCE_ERLANG_RECORD)
440
 
            //~ && (style != SCE_ERLANG_NUMBER)
441
 
            //~ && (style != SCE_ERLANG_STRING)
442
 
            //~ && (style != SCE_ERLANG_COMMENT)
443
 
         //~ ) {
444
 
            if ( (SC_FOLDLEVELBASE+1 == levelCurrent) && (ch == '.') ) {
445
 
               //--clause_level;
446
 
               //~ if ( 0 == clause_level )
447
 
                  --levelCurrent;
448
 
            }
449
 
         //~ }
450
 
      }
451
 
 
452
 
      if ( fold_clauses ) {
453
 
         if ( (0 < levelCurrent) && (style == SCE_ERLANG_OPERATOR) ) {
454
 
            if ((ch == '-') && (chNext == '>')) {
455
 
               levelCurrent++;
456
 
            }
457
 
            if ( (ch == ';') ) {
458
 
               levelCurrent--;
459
 
            }
460
 
         }
461
 
         if ( (stylePrev != SCE_ERLANG_RECORD)
462
 
            && (style != SCE_ERLANG_NUMBER)
463
 
            && (style != SCE_ERLANG_STRING)
464
 
            && (style != SCE_ERLANG_COMMENT)
465
 
         ) {
466
 
            if ( (ch == '.') ) {
467
 
               levelCurrent--;
468
 
            }
469
 
         }
470
 
         if (  (stylePrev == SCE_ERLANG_KEYWORD)
471
 
            && (style != SCE_ERLANG_KEYWORD)
472
 
            && (style != SCE_ERLANG_ATOM)
473
 
            && (
474
 
               styler.Match(keyword_start,"end") // 'end' counted twice if fold_keywords too
475
 
               || styler.Match(keyword_start,"after") )
476
 
         ) {
477
 
            levelCurrent--;
478
 
         }
479
 
      }
480
 
 
481
 
      if ( fold_braces ) {
482
 
         if (style == SCE_ERLANG_OPERATOR) {
483
 
            if ( (ch == '{') || (ch == '(') || (ch == '[') ) {
484
 
               levelCurrent++;
485
 
            } else if ( (ch == '}') || (ch == ')') || (ch == ']') ) {
486
 
               levelCurrent--;
487
 
            }
488
 
         }
489
 
      }
 
544
                atEOL = ((ch == '\r') && (chNext != '\n')) || (ch == '\n');
 
545
 
 
546
                if (stylePrev != SCE_ERLANG_KEYWORD
 
547
                        && style == SCE_ERLANG_KEYWORD) {
 
548
                        keyword_start = i;
 
549
                }
 
550
 
 
551
                // Fold on keywords
 
552
                if (stylePrev == SCE_ERLANG_KEYWORD
 
553
                        && style != SCE_ERLANG_KEYWORD
 
554
                        && style != SCE_ERLANG_ATOM
 
555
                ) {
 
556
                        currentLevel += ClassifyErlangFoldPoint(styler,
 
557
                                                                                                        styleNext,
 
558
                                                                                                        keyword_start);
 
559
                }
 
560
 
 
561
                // Fold on comments
 
562
                if (style == SCE_ERLANG_COMMENT
 
563
                        || style == SCE_ERLANG_COMMENT_MODULE
 
564
                        || style == SCE_ERLANG_COMMENT_FUNCTION) {
 
565
 
 
566
                        if (ch == '%' && chNext == '{') {
 
567
                                currentLevel++;
 
568
                        } else if (ch == '%' && chNext == '}') {
 
569
                                currentLevel--;
 
570
                        }
 
571
                }
 
572
 
 
573
                // Fold on braces
 
574
                if (style == SCE_ERLANG_OPERATOR) {
 
575
                        if (ch == '{' || ch == '(' || ch == '[') {
 
576
                                currentLevel++;
 
577
                        } else if (ch == '}' || ch == ')' || ch == ']') {
 
578
                                currentLevel--;
 
579
                        }
 
580
                }
 
581
 
490
582
 
491
583
                if (atEOL) {
492
 
                        int lev = levelPrev;
493
 
                        //~ if (visibleChars == 0 && foldCompact)
494
 
                                //~ lev |= SC_FOLDLEVELWHITEFLAG;
495
 
                        //~ if ((levelCurrent > levelPrev) && (visibleChars > 0))
496
 
                        if ((levelCurrent > levelPrev)) {
 
584
                        lev = previousLevel;
 
585
 
 
586
                        if (currentLevel > previousLevel)
497
587
                                lev |= SC_FOLDLEVELHEADERFLAG;
498
 
         }
499
 
                        if (lev != styler.LevelAt(lineCurrent)) {
500
 
                                styler.SetLevel(lineCurrent, lev);
501
 
                        }
502
 
                        lineCurrent++;
503
 
                        levelPrev = levelCurrent;
504
 
                        //~ visibleChars = 0;
 
588
 
 
589
                        if (lev != styler.LevelAt(currentLine))
 
590
                                styler.SetLevel(currentLine, lev);
 
591
 
 
592
                        currentLine++;
 
593
                        previousLevel = currentLevel;
505
594
                }
506
 
                //~ if (!isspacechar(ch))
507
 
                        //~ visibleChars++;
508
595
 
509
596
        }
 
597
 
510
598
        // Fill in the real level of the next line, keeping the current flags as they will be filled in later
511
 
        int flagsNext = styler.LevelAt(lineCurrent) & ~SC_FOLDLEVELNUMBERMASK;
512
 
        styler.SetLevel(lineCurrent, levelPrev | flagsNext);
 
599
        styler.SetLevel(currentLine,
 
600
                                        previousLevel
 
601
                                        | (styler.LevelAt(currentLine) & ~SC_FOLDLEVELNUMBERMASK));
513
602
}
514
603
 
515
604
static const char * const erlangWordListDesc[] = {
516
 
        "Keywords",
 
605
        "Erlang Reserved words",
 
606
        "Erlang BIFs",
 
607
        "Erlang Preprocessor",
 
608
        "Erlang Module Attributes",
 
609
        "Erlang Documentation",
 
610
        "Erlang Documentation Macro",
517
611
        0
518
612
};
519
613
 
520
614
LexerModule lmErlang(
521
 
   SCLEX_ERLANG,
522
 
   ColouriseErlangDoc,
523
 
   "erlang",
524
 
   FoldErlangDoc,
525
 
   erlangWordListDesc);
526
 
 
 
615
        SCLEX_ERLANG,
 
616
        ColouriseErlangDoc,
 
617
        "erlang",
 
618
        FoldErlangDoc,
 
619
        erlangWordListDesc);