/lenasys/trunk

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/lenasys/trunk

« back to all changes in this revision

Viewing changes to codeigniter/js/ace/mode-dart.js

  • Committer: gustav.hartvigsson at gmail
  • Date: 2013-04-03 08:13:05 UTC
  • mfrom: (8.1.1 lenasys)
  • Revision ID: gustav.hartvigsson@gmail.com-20130403081305-l2n3uwmrvjuzrzyt
Merged the new structure.

Show diffs side-by-side

added added

removed removed

Lines of Context:
codeigniter/js/ace/mode-dart.js
1
 
/* ***** BEGIN LICENSE BLOCK *****
2
 
 * Distributed under the BSD license:
3
 
 *
4
 
 * Copyright (c) 2012, Ajax.org B.V.
5
 
 * All rights reserved.
6
 
 * 
7
 
 * Redistribution and use in source and binary forms, with or without
8
 
 * modification, are permitted provided that the following conditions are met:
9
 
 *     * Redistributions of source code must retain the above copyright
10
 
 *       notice, this list of conditions and the following disclaimer.
11
 
 *     * Redistributions in binary form must reproduce the above copyright
12
 
 *       notice, this list of conditions and the following disclaimer in the
13
 
 *       documentation and/or other materials provided with the distribution.
14
 
 *     * Neither the name of Ajax.org B.V. nor the
15
 
 *       names of its contributors may be used to endorse or promote products
16
 
 *       derived from this software without specific prior written permission.
17
 
 * 
18
 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
19
 
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
20
 
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
21
 
 * DISCLAIMED. IN NO EVENT SHALL AJAX.ORG B.V. BE LIABLE FOR ANY
22
 
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
23
 
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
24
 
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
25
 
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26
 
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
27
 
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28
 
 *
29
 
 *
30
 
 * Contributor(s):
31
 
 * 
32
 
 *
33
 
 *
34
 
 * ***** END LICENSE BLOCK ***** */
35
 
 
36
 
define('ace/mode/dart', ['require', 'exports', 'module' , 'ace/lib/oop', 'ace/mode/text', 'ace/tokenizer', 'ace/mode/dart_highlight_rules', 'ace/mode/folding/cstyle'], function(require, exports, module) {
37
 
 
38
 
 
39
 
var oop = require("../lib/oop");
40
 
var TextMode = require("./text").Mode;
41
 
var Tokenizer = require("../tokenizer").Tokenizer;
42
 
var DartHighlightRules = require("./dart_highlight_rules").DartHighlightRules;
43
 
var CStyleFoldMode = require("./folding/cstyle").FoldMode;
44
 
 
45
 
var Mode = function() {
46
 
    var highlighter = new DartHighlightRules();
47
 
    this.foldingRules = new CStyleFoldMode();
48
 
 
49
 
    this.$tokenizer = new Tokenizer(highlighter.getRules());
50
 
};
51
 
oop.inherits(Mode, TextMode);
52
 
 
53
 
(function() {
54
 
    this.lineCommentStart = "//";
55
 
    this.blockComment = {start: "/*", end: "*/"};
56
 
}).call(Mode.prototype);
57
 
 
58
 
exports.Mode = Mode;
59
 
});
60
 
 
61
 
 
62
 
define('ace/mode/dart_highlight_rules', ['require', 'exports', 'module' , 'ace/lib/oop', 'ace/mode/text_highlight_rules'], function(require, exports, module) {
63
 
 
64
 
 
65
 
var oop = require("../lib/oop");
66
 
var TextHighlightRules = require("./text_highlight_rules").TextHighlightRules;
67
 
 
68
 
var DartHighlightRules = function() {
69
 
 
70
 
    var constantLanguage = "true|false|null";
71
 
    var variableLanguage = "this|super";
72
 
    var keywordControl = "try|catch|finally|throw|break|case|continue|default|do|else|for|if|in|return|switch|while|new";
73
 
    var keywordDeclaration = "abstract|class|extends|external|factory|implements|interface|get|native|operator|set|typedef";
74
 
    var storageModifier = "static|final|const";
75
 
    var storageType = "void|bool|num|int|double|Dynamic|var|String";
76
 
 
77
 
    var keywordMapper = this.createKeywordMapper({
78
 
        "constant.language.dart": constantLanguage,
79
 
        "variable.language.dart": variableLanguage,
80
 
        "keyword.control.dart": keywordControl,
81
 
        "keyword.declaration.dart": keywordDeclaration,
82
 
        "storage.modifier.dart": storageModifier,
83
 
        "storage.type.primitive.dart": storageType
84
 
    }, "identifier");
85
 
 
86
 
    var stringfill = {
87
 
        token : "string",
88
 
        regex : ".+"
89
 
    };
90
 
 
91
 
    this.$rules = 
92
 
        {
93
 
    "start": [
94
 
        {
95
 
            token : "comment",
96
 
            regex : /\/\/.*$/
97
 
        },
98
 
        {
99
 
            token : "comment", // multi line comment
100
 
            regex : /\/\*/,
101
 
            next : "comment"
102
 
        },
103
 
        {
104
 
            token: ["meta.preprocessor.script.dart"],
105
 
            regex: "^(#!.*)$"
106
 
        },
107
 
        {
108
 
            token: "keyword.other.import.dart",
109
 
            regex: "#(?:\\b)(?:library|import|source|resource)(?:\\b)"
110
 
        },
111
 
        {
112
 
            token : ["keyword.other.import.dart", "text"],
113
 
            regex : "(?:\\b)(prefix)(\\s*:)"
114
 
        },
115
 
        {
116
 
            regex: "\\bas\\b",
117
 
            token: "keyword.cast.dart"
118
 
        },
119
 
        {
120
 
            regex: "\\?|:",
121
 
            token: "keyword.control.ternary.dart"
122
 
        },
123
 
        {
124
 
            regex: "(?:\\b)(is\\!?)(?:\\b)",
125
 
            token: ["keyword.operator.dart"]
126
 
        },
127
 
        {
128
 
            regex: "(<<|>>>?|~|\\^|\\||&)",
129
 
            token: ["keyword.operator.bitwise.dart"]
130
 
        },
131
 
        {
132
 
            regex: "((?:&|\\^|\\||<<|>>>?)=)",
133
 
            token: ["keyword.operator.assignment.bitwise.dart"]
134
 
        },
135
 
        {
136
 
            regex: "(===?|!==?|<=?|>=?)",
137
 
            token: ["keyword.operator.comparison.dart"]
138
 
        },
139
 
        {
140
 
            regex: "((?:[+*/%-]|\\~)=)",
141
 
            token: ["keyword.operator.assignment.arithmetic.dart"]
142
 
        },
143
 
        {
144
 
            regex: "=",
145
 
            token: "keyword.operator.assignment.dart"
146
 
        },
147
 
        {
148
 
            token : "string",
149
 
            regex : "'''",
150
 
            next : "qdoc"
151
 
        }, 
152
 
        {
153
 
            token : "string",
154
 
            regex : '"""',
155
 
            next : "qqdoc"
156
 
        }, 
157
 
        {
158
 
            token : "string",
159
 
            regex : "'",
160
 
            next : "qstring"
161
 
        }, 
162
 
        {
163
 
            token : "string",
164
 
            regex : '"',
165
 
            next : "qqstring"
166
 
        }, 
167
 
        {
168
 
            regex: "(\\-\\-|\\+\\+)",
169
 
            token: ["keyword.operator.increment-decrement.dart"]
170
 
        },
171
 
        {
172
 
            regex: "(\\-|\\+|\\*|\\/|\\~\\/|%)",
173
 
            token: ["keyword.operator.arithmetic.dart"]
174
 
        },
175
 
        {
176
 
            regex: "(!|&&|\\|\\|)",
177
 
            token: ["keyword.operator.logical.dart"]
178
 
        },
179
 
        {
180
 
            token : "constant.numeric", // hex
181
 
            regex : "0[xX][0-9a-fA-F]+\\b"
182
 
        }, 
183
 
        {
184
 
            token : "constant.numeric", // float
185
 
            regex : "[+-]?\\d+(?:(?:\\.\\d*)?(?:[eE][+-]?\\d+)?)?\\b"
186
 
        }, 
187
 
        {
188
 
            token : keywordMapper,
189
 
            regex : "[a-zA-Z_$][a-zA-Z0-9_$]*\\b"
190
 
        }
191
 
    ],
192
 
    "comment" : [
193
 
        {
194
 
            token : "comment", // closing comment
195
 
            regex : ".*?\\*\\/",
196
 
            next : "start"
197
 
        }, {
198
 
            token : "comment", // comment spanning whole line
199
 
            regex : ".+"
200
 
        }
201
 
    ],
202
 
    "qdoc" : [
203
 
        {
204
 
            token : "string",
205
 
            regex : ".*?'''",
206
 
            next : "start"
207
 
        }, stringfill],
208
 
 
209
 
    "qqdoc" : [
210
 
        {
211
 
            token : "string",
212
 
            regex : '.*?"""',
213
 
            next : "start"
214
 
        }, stringfill],
215
 
 
216
 
    "qstring" : [
217
 
        {
218
 
            token : "string",
219
 
            regex : "[^\\\\']*(?:\\\\.[^\\\\']*)*'",
220
 
            next : "start"
221
 
        }, stringfill],
222
 
 
223
 
    "qqstring" : [
224
 
        {
225
 
            token : "string",
226
 
            regex : '[^\\\\"]*(?:\\\\.[^\\\\"]*)*"',
227
 
            next : "start"
228
 
        }, stringfill]
229
 
}
230
 
 
231
 
};
232
 
 
233
 
oop.inherits(DartHighlightRules, TextHighlightRules);
234
 
 
235
 
exports.DartHighlightRules = DartHighlightRules;
236
 
});
237
 
 
238
 
define('ace/mode/folding/cstyle', ['require', 'exports', 'module' , 'ace/lib/oop', 'ace/range', 'ace/mode/folding/fold_mode'], function(require, exports, module) {
239
 
 
240
 
 
241
 
var oop = require("../../lib/oop");
242
 
var Range = require("../../range").Range;
243
 
var BaseFoldMode = require("./fold_mode").FoldMode;
244
 
 
245
 
var FoldMode = exports.FoldMode = function(commentRegex) {
246
 
    if (commentRegex) {
247
 
        this.foldingStartMarker = new RegExp(
248
 
            this.foldingStartMarker.source.replace(/\|[^|]*?$/, "|" + commentRegex.start)
249
 
        );
250
 
        this.foldingStopMarker = new RegExp(
251
 
            this.foldingStopMarker.source.replace(/\|[^|]*?$/, "|" + commentRegex.end)
252
 
        );
253
 
    }
254
 
};
255
 
oop.inherits(FoldMode, BaseFoldMode);
256
 
 
257
 
(function() {
258
 
 
259
 
    this.foldingStartMarker = /(\{|\[)[^\}\]]*$|^\s*(\/\*)/;
260
 
    this.foldingStopMarker = /^[^\[\{]*(\}|\])|^[\s\*]*(\*\/)/;
261
 
 
262
 
    this.getFoldWidgetRange = function(session, foldStyle, row) {
263
 
        var line = session.getLine(row);
264
 
        var match = line.match(this.foldingStartMarker);
265
 
        if (match) {
266
 
            var i = match.index;
267
 
 
268
 
            if (match[1])
269
 
                return this.openingBracketBlock(session, match[1], row, i);
270
 
 
271
 
            return session.getCommentFoldRange(row, i + match[0].length, 1);
272
 
        }
273
 
 
274
 
        if (foldStyle !== "markbeginend")
275
 
            return;
276
 
 
277
 
        var match = line.match(this.foldingStopMarker);
278
 
        if (match) {
279
 
            var i = match.index + match[0].length;
280
 
 
281
 
            if (match[1])
282
 
                return this.closingBracketBlock(session, match[1], row, i);
283
 
 
284
 
            return session.getCommentFoldRange(row, i, -1);
285
 
        }
286
 
    };
287
 
 
288
 
}).call(FoldMode.prototype);
289
 
 
290
 
});