/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: galaxyAbstractor
  • Date: 2013-04-10 15:49:32 UTC
  • mto: (19.1.5 lenasys)
  • mto: This revision was merged to the branch mainline in revision 23.
  • Revision ID: galaxyabstractor@gmail.com-20130410154932-4vizlzk0ar5gykvi
* Added an simple admin panel to the codeviewer-cmssy stuff
* Redesigned a bit like the mockups - still stuff to come
* Implemented the codeviewer + admin panel again using the Framework CodeIgniter instead 

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
});