corrade-nucleus-nucleons – Blame information for rev 20

Subversion Repositories:
Rev:
Rev Author Line No. Line
20 office 1 ace.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 ace.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 ace.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 ace.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 });