corrade-nucleus-nucleons – Blame information for rev 24
?pathlinks?
Rev | Author | Line No. | Line |
---|---|---|---|
20 | office | 1 | define("ace/mode/vala_highlight_rules",["require","exports","module","ace/lib/oop","ace/mode/text_highlight_rules"], function(require, exports, module) { |
2 | "use strict"; |
||
3 | |||
4 | var oop = require("../lib/oop"); |
||
5 | var TextHighlightRules = require("./text_highlight_rules").TextHighlightRules; |
||
6 | |||
7 | var ValaHighlightRules = function() { |
||
8 | |||
9 | this.$rules = { start: |
||
10 | [ { token: |
||
11 | [ 'meta.using.vala', |
||
12 | 'keyword.other.using.vala', |
||
13 | 'meta.using.vala', |
||
14 | 'storage.modifier.using.vala', |
||
15 | 'meta.using.vala', |
||
16 | 'punctuation.terminator.vala' ], |
||
17 | regex: '^(\\s*)(using)\\b(?:(\\s*)([^ ;$]+)(\\s*)((?:;)?))?' }, |
||
18 | { include: '#code' } ], |
||
19 | '#all-types': |
||
20 | [ { include: '#primitive-arrays' }, |
||
21 | { include: '#primitive-types' }, |
||
22 | { include: '#object-types' } ], |
||
23 | '#annotations': |
||
24 | [ { token: |
||
25 | [ 'storage.type.annotation.vala', |
||
26 | 'punctuation.definition.annotation-arguments.begin.vala' ], |
||
27 | regex: '(@[^ (]+)(\\()', |
||
28 | push: |
||
29 | [ { token: 'punctuation.definition.annotation-arguments.end.vala', |
||
30 | regex: '\\)', |
||
31 | next: 'pop' }, |
||
32 | { token: |
||
33 | [ 'constant.other.key.vala', |
||
34 | 'text', |
||
35 | 'keyword.operator.assignment.vala' ], |
||
36 | regex: '(\\w*)(\\s*)(=)' }, |
||
37 | { include: '#code' }, |
||
38 | { token: 'punctuation.seperator.property.vala', regex: ',' }, |
||
39 | { defaultToken: 'meta.declaration.annotation.vala' } ] }, |
||
40 | { token: 'storage.type.annotation.vala', regex: '@\\w*' } ], |
||
41 | '#anonymous-classes-and-new': |
||
42 | [ { token: 'keyword.control.new.vala', |
||
43 | regex: '\\bnew\\b', |
||
44 | push_disabled: |
||
45 | [ { token: 'text', |
||
46 | regex: '(?<=\\)|\\])(?!\\s*{)|(?<=})|(?=;)', |
||
47 | TODO: 'FIXME: regexp doesn\'t have js equivalent', |
||
48 | originalRegex: '(?<=\\)|\\])(?!\\s*{)|(?<=})|(?=;)', |
||
49 | next: 'pop' }, |
||
50 | { token: [ 'storage.type.vala', 'text' ], |
||
51 | regex: '(\\w+)(\\s*)(?=\\[)', |
||
52 | push: |
||
53 | [ { token: 'text', regex: '}|(?=;|\\))', next: 'pop' }, |
||
54 | { token: 'text', |
||
55 | regex: '\\[', |
||
56 | push: |
||
57 | [ { token: 'text', regex: '\\]', next: 'pop' }, |
||
58 | { include: '#code' } ] }, |
||
59 | { token: 'text', |
||
60 | regex: '{', |
||
61 | push: |
||
62 | [ { token: 'text', regex: '(?=})', next: 'pop' }, |
||
63 | { include: '#code' } ] } ] }, |
||
64 | { token: 'text', |
||
65 | regex: '(?=\\w.*\\()', |
||
66 | push: |
||
67 | [ { token: 'text', |
||
68 | regex: '(?<=\\))', |
||
69 | TODO: 'FIXME: regexp doesn\'t have js equivalent', |
||
70 | originalRegex: '(?<=\\))', |
||
71 | next: 'pop' }, |
||
72 | { include: '#object-types' }, |
||
73 | { token: 'text', |
||
74 | regex: '\\(', |
||
75 | push: |
||
76 | [ { token: 'text', regex: '\\)', next: 'pop' }, |
||
77 | { include: '#code' } ] } ] }, |
||
78 | { token: 'meta.inner-class.vala', |
||
79 | regex: '{', |
||
80 | push: |
||
81 | [ { token: 'meta.inner-class.vala', regex: '}', next: 'pop' }, |
||
82 | { include: '#class-body' }, |
||
83 | { defaultToken: 'meta.inner-class.vala' } ] } ] } ], |
||
84 | '#assertions': |
||
85 | [ { token: |
||
86 | [ 'keyword.control.assert.vala', |
||
87 | 'meta.declaration.assertion.vala' ], |
||
88 | regex: '\\b(assert|requires|ensures)(\\s)', |
||
89 | push: |
||
90 | [ { token: 'meta.declaration.assertion.vala', |
||
91 | regex: '$', |
||
92 | next: 'pop' }, |
||
93 | { token: 'keyword.operator.assert.expression-seperator.vala', |
||
94 | regex: ':' }, |
||
95 | { include: '#code' }, |
||
96 | { defaultToken: 'meta.declaration.assertion.vala' } ] } ], |
||
97 | '#class': |
||
98 | [ { token: 'meta.class.vala', |
||
99 | regex: '(?=\\w?[\\w\\s]*(?:class|(?:@)?interface|enum|struct|namespace)\\s+\\w+)', |
||
100 | push: |
||
101 | [ { token: 'paren.vala', |
||
102 | regex: '}', |
||
103 | next: 'pop' }, |
||
104 | { include: '#storage-modifiers' }, |
||
105 | { include: '#comments' }, |
||
106 | { token: |
||
107 | [ 'storage.modifier.vala', |
||
108 | 'meta.class.identifier.vala', |
||
109 | 'entity.name.type.class.vala' ], |
||
110 | regex: '(class|(?:@)?interface|enum|struct|namespace)(\\s+)([\\w\\.]+)' }, |
||
111 | { token: 'storage.modifier.extends.vala', |
||
112 | regex: ':', |
||
113 | push: |
||
114 | [ { token: 'meta.definition.class.inherited.classes.vala', |
||
115 | regex: '(?={|,)', |
||
116 | next: 'pop' }, |
||
117 | { include: '#object-types-inherited' }, |
||
118 | { include: '#comments' }, |
||
119 | { defaultToken: 'meta.definition.class.inherited.classes.vala' } ] }, |
||
120 | { token: |
||
121 | [ 'storage.modifier.implements.vala', |
||
122 | 'meta.definition.class.implemented.interfaces.vala' ], |
||
123 | regex: '(,)(\\s)', |
||
124 | push: |
||
125 | [ { token: 'meta.definition.class.implemented.interfaces.vala', |
||
126 | regex: '(?=\\{)', |
||
127 | next: 'pop' }, |
||
128 | { include: '#object-types-inherited' }, |
||
129 | { include: '#comments' }, |
||
130 | { defaultToken: 'meta.definition.class.implemented.interfaces.vala' } ] }, |
||
131 | { token: 'paren.vala', |
||
132 | regex: '{', |
||
133 | push: |
||
134 | [ { token: 'paren.vala', regex: '(?=})', next: 'pop' }, |
||
135 | { include: '#class-body' }, |
||
136 | { defaultToken: 'meta.class.body.vala' } ] }, |
||
137 | { defaultToken: 'meta.class.vala' } ], |
||
138 | comment: 'attempting to put namespace in here.' } ], |
||
139 | '#class-body': |
||
140 | [ { include: '#comments' }, |
||
141 | { include: '#class' }, |
||
142 | { include: '#enums' }, |
||
143 | { include: '#methods' }, |
||
144 | { include: '#annotations' }, |
||
145 | { include: '#storage-modifiers' }, |
||
146 | { include: '#code' } ], |
||
147 | '#code': |
||
148 | [ { include: '#comments' }, |
||
149 | { include: '#class' }, |
||
150 | { token: 'text', |
||
151 | regex: '{', |
||
152 | push: |
||
153 | [ { token: 'text', regex: '}', next: 'pop' }, |
||
154 | { include: '#code' } ] }, |
||
155 | { include: '#assertions' }, |
||
156 | { include: '#parens' }, |
||
157 | { include: '#constants-and-special-vars' }, |
||
158 | { include: '#anonymous-classes-and-new' }, |
||
159 | { include: '#keywords' }, |
||
160 | { include: '#storage-modifiers' }, |
||
161 | { include: '#strings' }, |
||
162 | { include: '#all-types' } ], |
||
163 | '#comments': |
||
164 | [ { token: 'punctuation.definition.comment.vala', |
||
165 | regex: '/\\*\\*/' }, |
||
166 | { include: 'text.html.javadoc' }, |
||
167 | { include: '#comments-inline' } ], |
||
168 | '#comments-inline': |
||
169 | [ { token: 'punctuation.definition.comment.vala', |
||
170 | regex: '/\\*', |
||
171 | push: |
||
172 | [ { token: 'punctuation.definition.comment.vala', |
||
173 | regex: '\\*/', |
||
174 | next: 'pop' }, |
||
175 | { defaultToken: 'comment.block.vala' } ] }, |
||
176 | { token: |
||
177 | [ 'text', |
||
178 | 'punctuation.definition.comment.vala', |
||
179 | 'comment.line.double-slash.vala' ], |
||
180 | regex: '(\\s*)(//)(.*$)' } ], |
||
181 | '#constants-and-special-vars': |
||
182 | [ { token: 'constant.language.vala', |
||
183 | regex: '\\b(?:true|false|null)\\b' }, |
||
184 | { token: 'variable.language.vala', |
||
185 | regex: '\\b(?:this|base)\\b' }, |
||
186 | { token: 'constant.numeric.vala', |
||
187 | regex: '\\b(?:0(?:x|X)[0-9a-fA-F]*|(?:[0-9]+\\.?[0-9]*|\\.[0-9]+)(?:(?:e|E)(?:\\+|-)?[0-9]+)?)(?:[LlFfUuDd]|UL|ul)?\\b' }, |
||
188 | { token: [ 'keyword.operator.dereference.vala', 'constant.other.vala' ], |
||
189 | regex: '((?:\\.)?)\\b([A-Z][A-Z0-9_]+)(?!<|\\.class|\\s*\\w+\\s*=)\\b' } ], |
||
190 | '#enums': |
||
191 | [ { token: 'text', |
||
192 | regex: '^(?=\\s*[A-Z0-9_]+\\s*(?:{|\\(|,))', |
||
193 | push: |
||
194 | [ { token: 'text', regex: '(?=;|})', next: 'pop' }, |
||
195 | { token: 'constant.other.enum.vala', |
||
196 | regex: '\\w+', |
||
197 | push: |
||
198 | [ { token: 'meta.enum.vala', regex: '(?=,|;|})', next: 'pop' }, |
||
199 | { include: '#parens' }, |
||
200 | { token: 'text', |
||
201 | regex: '{', |
||
202 | push: |
||
203 | [ { token: 'text', regex: '}', next: 'pop' }, |
||
204 | { include: '#class-body' } ] }, |
||
205 | { defaultToken: 'meta.enum.vala' } ] } ] } ], |
||
206 | '#keywords': |
||
207 | [ { token: 'keyword.control.catch-exception.vala', |
||
208 | regex: '\\b(?:try|catch|finally|throw)\\b' }, |
||
209 | { token: 'keyword.control.vala', regex: '\\?|:|\\?\\?' }, |
||
210 | { token: 'keyword.control.vala', |
||
211 | regex: '\\b(?:return|break|case|continue|default|do|while|for|foreach|switch|if|else|in|yield|get|set|value)\\b' }, |
||
212 | { token: 'keyword.operator.vala', |
||
213 | regex: '\\b(?:typeof|is|as)\\b' }, |
||
214 | { token: 'keyword.operator.comparison.vala', |
||
215 | regex: '==|!=|<=|>=|<>|<|>' }, |
||
216 | { token: 'keyword.operator.assignment.vala', regex: '=' }, |
||
217 | { token: 'keyword.operator.increment-decrement.vala', |
||
218 | regex: '\\-\\-|\\+\\+' }, |
||
219 | { token: 'keyword.operator.arithmetic.vala', |
||
220 | regex: '\\-|\\+|\\*|\\/|%' }, |
||
221 | { token: 'keyword.operator.logical.vala', regex: '!|&&|\\|\\|' }, |
||
222 | { token: 'keyword.operator.dereference.vala', |
||
223 | regex: '\\.(?=\\S)', |
||
224 | originalRegex: '(?<=\\S)\\.(?=\\S)' }, |
||
225 | { token: 'punctuation.terminator.vala', regex: ';' }, |
||
226 | { token: 'keyword.operator.ownership', regex: 'owned|unowned' } ], |
||
227 | '#methods': |
||
228 | [ { token: 'meta.method.vala', |
||
229 | regex: '(?!new)(?=\\w.*\\s+)(?=[^=]+\\()', |
||
230 | push: |
||
231 | [ { token: 'paren.vala', regex: '}|(?=;)', next: 'pop' }, |
||
232 | { include: '#storage-modifiers' }, |
||
233 | { token: [ 'entity.name.function.vala', 'meta.method.identifier.vala' ], |
||
234 | regex: '([\\~\\w\\.]+)(\\s*\\()', |
||
235 | push: |
||
236 | [ { token: 'meta.method.identifier.vala', |
||
237 | regex: '\\)', |
||
238 | next: 'pop' }, |
||
239 | { include: '#parameters' }, |
||
240 | { defaultToken: 'meta.method.identifier.vala' } ] }, |
||
241 | { token: 'meta.method.return-type.vala', |
||
242 | regex: '(?=\\w.*\\s+\\w+\\s*\\()', |
||
243 | push: |
||
244 | [ { token: 'meta.method.return-type.vala', |
||
245 | regex: '(?=\\w+\\s*\\()', |
||
246 | next: 'pop' }, |
||
247 | { include: '#all-types' }, |
||
248 | { defaultToken: 'meta.method.return-type.vala' } ] }, |
||
249 | { include: '#throws' }, |
||
250 | { token: 'paren.vala', |
||
251 | regex: '{', |
||
252 | push: |
||
253 | [ { token: 'paren.vala', regex: '(?=})', next: 'pop' }, |
||
254 | { include: '#code' }, |
||
255 | { defaultToken: 'meta.method.body.vala' } ] }, |
||
256 | { defaultToken: 'meta.method.vala' } ] } ], |
||
257 | '#namespace': |
||
258 | [ { token: 'text', |
||
259 | regex: '^(?=\\s*[A-Z0-9_]+\\s*(?:{|\\(|,))', |
||
260 | push: |
||
261 | [ { token: 'text', regex: '(?=;|})', next: 'pop' }, |
||
262 | { token: 'constant.other.namespace.vala', |
||
263 | regex: '\\w+', |
||
264 | push: |
||
265 | [ { token: 'meta.namespace.vala', regex: '(?=,|;|})', next: 'pop' }, |
||
266 | { include: '#parens' }, |
||
267 | { token: 'text', |
||
268 | regex: '{', |
||
269 | push: |
||
270 | [ { token: 'text', regex: '}', next: 'pop' }, |
||
271 | { include: '#code' } ] }, |
||
272 | { defaultToken: 'meta.namespace.vala' } ] } ], |
||
273 | comment: 'This is not quite right. See the class grammar right now' } ], |
||
274 | '#object-types': |
||
275 | [ { token: 'storage.type.generic.vala', |
||
276 | regex: '\\b(?:[a-z]\\w*\\.)*[A-Z]+\\w*<', |
||
277 | push: |
||
278 | [ { token: 'storage.type.generic.vala', |
||
279 | regex: '>|[^\\w\\s,\\?<\\[()\\]]', |
||
280 | TODO: 'FIXME: regexp doesn\'t have js equivalent', |
||
281 | originalRegex: '>|[^\\w\\s,\\?<\\[(?:[,]+)\\]]', |
||
282 | next: 'pop' }, |
||
283 | { include: '#object-types' }, |
||
284 | { token: 'storage.type.generic.vala', |
||
285 | regex: '<', |
||
286 | push: |
||
287 | [ { token: 'storage.type.generic.vala', |
||
288 | regex: '>|[^\\w\\s,\\[\\]<]', |
||
289 | next: 'pop' }, |
||
290 | { defaultToken: 'storage.type.generic.vala' } ], |
||
291 | comment: 'This is just to support <>\'s with no actual type prefix' }, |
||
292 | { defaultToken: 'storage.type.generic.vala' } ] }, |
||
293 | { token: 'storage.type.object.array.vala', |
||
294 | regex: '\\b(?:[a-z]\\w*\\.)*[A-Z]+\\w*(?=\\[)', |
||
295 | push: |
||
296 | [ { token: 'storage.type.object.array.vala', |
||
297 | regex: '(?=[^\\]\\s])', |
||
298 | next: 'pop' }, |
||
299 | { token: 'text', |
||
300 | regex: '\\[', |
||
301 | push: |
||
302 | [ { token: 'text', regex: '\\]', next: 'pop' }, |
||
303 | { include: '#code' } ] }, |
||
304 | { defaultToken: 'storage.type.object.array.vala' } ] }, |
||
305 | { token: |
||
306 | [ 'storage.type.vala', |
||
307 | 'keyword.operator.dereference.vala', |
||
308 | 'storage.type.vala' ], |
||
309 | regex: '\\b(?:([a-z]\\w*)(\\.))*([A-Z]+\\w*\\b)' } ], |
||
310 | '#object-types-inherited': |
||
311 | [ { token: 'entity.other.inherited-class.vala', |
||
312 | regex: '\\b(?:[a-z]\\w*\\.)*[A-Z]+\\w*<', |
||
313 | push: |
||
314 | [ { token: 'entity.other.inherited-class.vala', |
||
315 | regex: '>|[^\\w\\s,<]', |
||
316 | next: 'pop' }, |
||
317 | { include: '#object-types' }, |
||
318 | { token: 'storage.type.generic.vala', |
||
319 | regex: '<', |
||
320 | push: |
||
321 | [ { token: 'storage.type.generic.vala', |
||
322 | regex: '>|[^\\w\\s,<]', |
||
323 | next: 'pop' }, |
||
324 | { defaultToken: 'storage.type.generic.vala' } ], |
||
325 | comment: 'This is just to support <>\'s with no actual type prefix' }, |
||
326 | { defaultToken: 'entity.other.inherited-class.vala' } ] }, |
||
327 | { token: |
||
328 | [ 'entity.other.inherited-class.vala', |
||
329 | 'keyword.operator.dereference.vala', |
||
330 | 'entity.other.inherited-class.vala' ], |
||
331 | regex: '\\b(?:([a-z]\\w*)(\\.))*([A-Z]+\\w*)' } ], |
||
332 | '#parameters': |
||
333 | [ { token: 'storage.modifier.vala', regex: 'final' }, |
||
334 | { include: '#primitive-arrays' }, |
||
335 | { include: '#primitive-types' }, |
||
336 | { include: '#object-types' }, |
||
337 | { token: 'variable.parameter.vala', regex: '\\w+' } ], |
||
338 | '#parens': |
||
339 | [ { token: 'text', |
||
340 | regex: '\\(', |
||
341 | push: |
||
342 | [ { token: 'text', regex: '\\)', next: 'pop' }, |
||
343 | { include: '#code' } ] } ], |
||
344 | '#primitive-arrays': |
||
345 | [ { token: 'storage.type.primitive.array.vala', |
||
346 | regex: '\\b(?:bool|byte|sbyte|char|decimal|double|float|int|uint|long|ulong|object|short|ushort|string|void|int8|int16|int32|int64|uint8|uint16|uint32|uint64)(?:\\[\\])*\\b' } ], |
||
347 | '#primitive-types': |
||
348 | [ { token: 'storage.type.primitive.vala', |
||
349 | regex: '\\b(?:var|bool|byte|sbyte|char|decimal|double|float|int|uint|long|ulong|object|short|ushort|string|void|signal|int8|int16|int32|int64|uint8|uint16|uint32|uint64)\\b', |
||
350 | comment: 'var is not really a primitive, but acts like one in most cases' } ], |
||
351 | '#storage-modifiers': |
||
352 | [ { token: 'storage.modifier.vala', |
||
353 | regex: '\\b(?:public|private|protected|internal|static|final|sealed|virtual|override|abstract|readonly|volatile|dynamic|async|unsafe|out|ref|weak|owned|unowned|const)\\b', |
||
354 | comment: 'Not sure about unsafe and readonly' } ], |
||
355 | '#strings': |
||
356 | [ { token: 'punctuation.definition.string.begin.vala', |
||
357 | regex: '@"', |
||
358 | push: |
||
359 | [ { token: 'punctuation.definition.string.end.vala', |
||
360 | regex: '"', |
||
361 | next: 'pop' }, |
||
362 | { token: 'constant.character.escape.vala', |
||
363 | regex: '\\\\.|%[\\w\\.\\-]+|\\$(?:\\w+|\\([\\w\\s\\+\\-\\*\\/]+\\))' }, |
||
364 | { defaultToken: 'string.quoted.interpolated.vala' } ] }, |
||
365 | { token: 'punctuation.definition.string.begin.vala', |
||
366 | regex: '"', |
||
367 | push: |
||
368 | [ { token: 'punctuation.definition.string.end.vala', |
||
369 | regex: '"', |
||
370 | next: 'pop' }, |
||
371 | { token: 'constant.character.escape.vala', regex: '\\\\.' }, |
||
372 | { token: 'constant.character.escape.vala', |
||
373 | regex: '%[\\w\\.\\-]+' }, |
||
374 | { defaultToken: 'string.quoted.double.vala' } ] }, |
||
375 | { token: 'punctuation.definition.string.begin.vala', |
||
376 | regex: '\'', |
||
377 | push: |
||
378 | [ { token: 'punctuation.definition.string.end.vala', |
||
379 | regex: '\'', |
||
380 | next: 'pop' }, |
||
381 | { token: 'constant.character.escape.vala', regex: '\\\\.' }, |
||
382 | { defaultToken: 'string.quoted.single.vala' } ] }, |
||
383 | { token: 'punctuation.definition.string.begin.vala', |
||
384 | regex: '"""', |
||
385 | push: |
||
386 | [ { token: 'punctuation.definition.string.end.vala', |
||
387 | regex: '"""', |
||
388 | next: 'pop' }, |
||
389 | { token: 'constant.character.escape.vala', |
||
390 | regex: '%[\\w\\.\\-]+' }, |
||
391 | { defaultToken: 'string.quoted.triple.vala' } ] } ], |
||
392 | '#throws': |
||
393 | [ { token: 'storage.modifier.vala', |
||
394 | regex: 'throws', |
||
395 | push: |
||
396 | [ { token: 'meta.throwables.vala', regex: '(?={|;)', next: 'pop' }, |
||
397 | { include: '#object-types' }, |
||
398 | { defaultToken: 'meta.throwables.vala' } ] } ], |
||
399 | '#values': |
||
400 | [ { include: '#strings' }, |
||
401 | { include: '#object-types' }, |
||
402 | { include: '#constants-and-special-vars' } ] } |
||
403 | |||
404 | this.normalizeRules(); |
||
405 | }; |
||
406 | |||
407 | ValaHighlightRules.metaData = { |
||
408 | comment: 'Based heavily on the Java bundle\'s language syntax. TODO:\n* Closures\n* Delegates\n* Properties: Better support for properties.\n* Annotations\n* Error domains\n* Named arguments\n* Array slicing, negative indexes, multidimensional\n* construct blocks\n* lock blocks?\n* regex literals\n* DocBlock syntax highlighting. (Currently importing javadoc)\n* Folding rule for comments.\n', |
||
409 | fileTypes: [ 'vala' ], |
||
410 | foldingStartMarker: '(\\{\\s*(//.*)?$|^\\s*// \\{\\{\\{)', |
||
411 | foldingStopMarker: '^\\s*(\\}|// \\}\\}\\}$)', |
||
412 | name: 'Vala', |
||
413 | scopeName: 'source.vala' } |
||
414 | |||
415 | |||
416 | oop.inherits(ValaHighlightRules, TextHighlightRules); |
||
417 | |||
418 | exports.ValaHighlightRules = ValaHighlightRules; |
||
419 | }); |
||
420 | |||
421 | define("ace/mode/folding/cstyle",["require","exports","module","ace/lib/oop","ace/range","ace/mode/folding/fold_mode"], function(require, exports, module) { |
||
422 | "use strict"; |
||
423 | |||
424 | var oop = require("../../lib/oop"); |
||
425 | var Range = require("../../range").Range; |
||
426 | var BaseFoldMode = require("./fold_mode").FoldMode; |
||
427 | |||
428 | var FoldMode = exports.FoldMode = function(commentRegex) { |
||
429 | if (commentRegex) { |
||
430 | this.foldingStartMarker = new RegExp( |
||
431 | this.foldingStartMarker.source.replace(/\|[^|]*?$/, "|" + commentRegex.start) |
||
432 | ); |
||
433 | this.foldingStopMarker = new RegExp( |
||
434 | this.foldingStopMarker.source.replace(/\|[^|]*?$/, "|" + commentRegex.end) |
||
435 | ); |
||
436 | } |
||
437 | }; |
||
438 | oop.inherits(FoldMode, BaseFoldMode); |
||
439 | |||
440 | (function() { |
||
441 | |||
442 | this.foldingStartMarker = /(\{|\[)[^\}\]]*$|^\s*(\/\*)/; |
||
443 | this.foldingStopMarker = /^[^\[\{]*(\}|\])|^[\s\*]*(\*\/)/; |
||
444 | this.singleLineBlockCommentRe= /^\s*(\/\*).*\*\/\s*$/; |
||
445 | this.tripleStarBlockCommentRe = /^\s*(\/\*\*\*).*\*\/\s*$/; |
||
446 | this.startRegionRe = /^\s*(\/\*|\/\/)#?region\b/; |
||
447 | this._getFoldWidgetBase = this.getFoldWidget; |
||
448 | this.getFoldWidget = function(session, foldStyle, row) { |
||
449 | var line = session.getLine(row); |
||
450 | |||
451 | if (this.singleLineBlockCommentRe.test(line)) { |
||
452 | if (!this.startRegionRe.test(line) && !this.tripleStarBlockCommentRe.test(line)) |
||
453 | return ""; |
||
454 | } |
||
455 | |||
456 | var fw = this._getFoldWidgetBase(session, foldStyle, row); |
||
457 | |||
458 | if (!fw && this.startRegionRe.test(line)) |
||
459 | return "start"; // lineCommentRegionStart |
||
460 | |||
461 | return fw; |
||
462 | }; |
||
463 | |||
464 | this.getFoldWidgetRange = function(session, foldStyle, row, forceMultiline) { |
||
465 | var line = session.getLine(row); |
||
466 | |||
467 | if (this.startRegionRe.test(line)) |
||
468 | return this.getCommentRegionBlock(session, line, row); |
||
469 | |||
470 | var match = line.match(this.foldingStartMarker); |
||
471 | if (match) { |
||
472 | var i = match.index; |
||
473 | |||
474 | if (match[1]) |
||
475 | return this.openingBracketBlock(session, match[1], row, i); |
||
476 | |||
477 | var range = session.getCommentFoldRange(row, i + match[0].length, 1); |
||
478 | |||
479 | if (range && !range.isMultiLine()) { |
||
480 | if (forceMultiline) { |
||
481 | range = this.getSectionRange(session, row); |
||
482 | } else if (foldStyle != "all") |
||
483 | range = null; |
||
484 | } |
||
485 | |||
486 | return range; |
||
487 | } |
||
488 | |||
489 | if (foldStyle === "markbegin") |
||
490 | return; |
||
491 | |||
492 | var match = line.match(this.foldingStopMarker); |
||
493 | if (match) { |
||
494 | var i = match.index + match[0].length; |
||
495 | |||
496 | if (match[1]) |
||
497 | return this.closingBracketBlock(session, match[1], row, i); |
||
498 | |||
499 | return session.getCommentFoldRange(row, i, -1); |
||
500 | } |
||
501 | }; |
||
502 | |||
503 | this.getSectionRange = function(session, row) { |
||
504 | var line = session.getLine(row); |
||
505 | var startIndent = line.search(/\S/); |
||
506 | var startRow = row; |
||
507 | var startColumn = line.length; |
||
508 | row = row + 1; |
||
509 | var endRow = row; |
||
510 | var maxRow = session.getLength(); |
||
511 | while (++row < maxRow) { |
||
512 | line = session.getLine(row); |
||
513 | var indent = line.search(/\S/); |
||
514 | if (indent === -1) |
||
515 | continue; |
||
516 | if (startIndent > indent) |
||
517 | break; |
||
518 | var subRange = this.getFoldWidgetRange(session, "all", row); |
||
519 | |||
520 | if (subRange) { |
||
521 | if (subRange.start.row <= startRow) { |
||
522 | break; |
||
523 | } else if (subRange.isMultiLine()) { |
||
524 | row = subRange.end.row; |
||
525 | } else if (startIndent == indent) { |
||
526 | break; |
||
527 | } |
||
528 | } |
||
529 | endRow = row; |
||
530 | } |
||
531 | |||
532 | return new Range(startRow, startColumn, endRow, session.getLine(endRow).length); |
||
533 | }; |
||
534 | this.getCommentRegionBlock = function(session, line, row) { |
||
535 | var startColumn = line.search(/\s*$/); |
||
536 | var maxRow = session.getLength(); |
||
537 | var startRow = row; |
||
538 | |||
539 | var re = /^\s*(?:\/\*|\/\/|--)#?(end)?region\b/; |
||
540 | var depth = 1; |
||
541 | while (++row < maxRow) { |
||
542 | line = session.getLine(row); |
||
543 | var m = re.exec(line); |
||
544 | if (!m) continue; |
||
545 | if (m[1]) depth--; |
||
546 | else depth++; |
||
547 | |||
548 | if (!depth) break; |
||
549 | } |
||
550 | |||
551 | var endRow = row; |
||
552 | if (endRow > startRow) { |
||
553 | return new Range(startRow, startColumn, endRow, line.length); |
||
554 | } |
||
555 | }; |
||
556 | |||
557 | }).call(FoldMode.prototype); |
||
558 | |||
559 | }); |
||
560 | |||
561 | define("ace/mode/matching_brace_outdent",["require","exports","module","ace/range"], function(require, exports, module) { |
||
562 | "use strict"; |
||
563 | |||
564 | var Range = require("../range").Range; |
||
565 | |||
566 | var MatchingBraceOutdent = function() {}; |
||
567 | |||
568 | (function() { |
||
569 | |||
570 | this.checkOutdent = function(line, input) { |
||
571 | if (! /^\s+$/.test(line)) |
||
572 | return false; |
||
573 | |||
574 | return /^\s*\}/.test(input); |
||
575 | }; |
||
576 | |||
577 | this.autoOutdent = function(doc, row) { |
||
578 | var line = doc.getLine(row); |
||
579 | var match = line.match(/^(\s*\})/); |
||
580 | |||
581 | if (!match) return 0; |
||
582 | |||
583 | var column = match[1].length; |
||
584 | var openBracePos = doc.findMatchingBracket({row: row, column: column}); |
||
585 | |||
586 | if (!openBracePos || openBracePos.row == row) return 0; |
||
587 | |||
588 | var indent = this.$getIndent(doc.getLine(openBracePos.row)); |
||
589 | doc.replace(new Range(row, 0, row, column-1), indent); |
||
590 | }; |
||
591 | |||
592 | this.$getIndent = function(line) { |
||
593 | return line.match(/^\s*/)[0]; |
||
594 | }; |
||
595 | |||
596 | }).call(MatchingBraceOutdent.prototype); |
||
597 | |||
598 | exports.MatchingBraceOutdent = MatchingBraceOutdent; |
||
599 | }); |
||
600 | |||
601 | define("ace/mode/vala",["require","exports","module","ace/lib/oop","ace/mode/text","ace/tokenizer","ace/mode/vala_highlight_rules","ace/mode/folding/cstyle","ace/mode/behaviour/cstyle","ace/mode/folding/cstyle","ace/mode/matching_brace_outdent"], function(require, exports, module) { |
||
602 | "use strict"; |
||
603 | |||
604 | var oop = require("../lib/oop"); |
||
605 | var TextMode = require("./text").Mode; |
||
606 | var Tokenizer = require("../tokenizer").Tokenizer; |
||
607 | var ValaHighlightRules = require("./vala_highlight_rules").ValaHighlightRules; |
||
608 | var FoldMode = require("./folding/cstyle").FoldMode; |
||
609 | var CstyleBehaviour = require("./behaviour/cstyle").CstyleBehaviour; |
||
610 | var CStyleFoldMode = require("./folding/cstyle").FoldMode; |
||
611 | var MatchingBraceOutdent = require("./matching_brace_outdent").MatchingBraceOutdent; |
||
612 | |||
613 | var Mode = function() { |
||
614 | this.HighlightRules = ValaHighlightRules; |
||
615 | |||
616 | this.$outdent = new MatchingBraceOutdent(); |
||
617 | this.$behaviour = new CstyleBehaviour(); |
||
618 | this.foldingRules = new CStyleFoldMode(); |
||
619 | }; |
||
620 | oop.inherits(Mode, TextMode); |
||
621 | |||
622 | (function() { |
||
623 | this.lineCommentStart = "//"; |
||
624 | this.blockComment = {start: "/*", end: "*/"}; |
||
625 | |||
626 | this.getNextLineIndent = function(state, line, tab) { |
||
627 | var indent = this.$getIndent(line); |
||
628 | |||
629 | var tokenizedLine = this.getTokenizer().getLineTokens(line, state); |
||
630 | var tokens = tokenizedLine.tokens; |
||
631 | var endState = tokenizedLine.state; |
||
632 | |||
633 | if (tokens.length && tokens[tokens.length-1].type == "comment") { |
||
634 | return indent; |
||
635 | } |
||
636 | |||
637 | if (state == "start" || state == "no_regex") { |
||
638 | var match = line.match(/^.*(?:\bcase\b.*:|[\{\(\[])\s*$/); |
||
639 | if (match) { |
||
640 | indent += tab; |
||
641 | } |
||
642 | } else if (state == "doc-start") { |
||
643 | if (endState == "start" || endState == "no_regex") { |
||
644 | return ""; |
||
645 | } |
||
646 | var match = line.match(/^\s*(\/?)\*/); |
||
647 | if (match) { |
||
648 | if (match[1]) { |
||
649 | indent += " "; |
||
650 | } |
||
651 | indent += "* "; |
||
652 | } |
||
653 | } |
||
654 | |||
655 | return indent; |
||
656 | }; |
||
657 | |||
658 | this.checkOutdent = function(state, line, input) { |
||
659 | return this.$outdent.checkOutdent(line, input); |
||
660 | }; |
||
661 | |||
662 | this.autoOutdent = function(state, doc, row) { |
||
663 | this.$outdent.autoOutdent(doc, row); |
||
664 | }; |
||
665 | this.$id = "ace/mode/vala" |
||
666 | }).call(Mode.prototype); |
||
667 | |||
668 | exports.Mode = Mode; |
||
669 | }); |