/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-makefile.js

  • Committer: Gustav Hatvigsson
  • Date: 2013-05-30 12:02:31 UTC
  • mfrom: (85.1.28 lenasys)
  • Revision ID: gustav.hartvigsson@gmail.com-20130530120231-ttqgqjqw2w8enn7g
Merged Ohlsons changes:
added function to get ssn and name for the registrationspages in the user model.
added the registrationpage for students.
edited the registration page for instructors
edited the css for both the registrationpages
minor fix to registration css

Show diffs side-by-side

added added

removed removed

Lines of Context:
codeigniter/js/ace/mode-makefile.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/makefile', ['require', 'exports', 'module' , 'ace/lib/oop', 'ace/mode/text', 'ace/tokenizer', 'ace/mode/makefile_highlight_rules', 'ace/mode/folding/coffee'], 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 MakefileHighlightRules = require("./makefile_highlight_rules").MakefileHighlightRules;
 
43
var FoldMode = require("./folding/coffee").FoldMode;
 
44
 
 
45
var Mode = function() {
 
46
    var highlighter = new MakefileHighlightRules();
 
47
    this.foldingRules = new FoldMode();
 
48
    
 
49
    this.$tokenizer = new Tokenizer(highlighter.getRules());
 
50
};
 
51
oop.inherits(Mode, TextMode);
 
52
 
 
53
(function() {
 
54
       
 
55
    this.lineCommentStart = "#";
 
56
}).call(Mode.prototype);
 
57
 
 
58
exports.Mode = Mode;
 
59
});define('ace/mode/makefile_highlight_rules', ['require', 'exports', 'module' , 'ace/lib/oop', 'ace/mode/text_highlight_rules', 'ace/mode/sh_highlight_rules'], function(require, exports, module) {
 
60
 
 
61
 
 
62
var oop = require("../lib/oop");
 
63
var TextHighlightRules = require("./text_highlight_rules").TextHighlightRules;
 
64
 
 
65
var ShHighlightFile = require("./sh_highlight_rules");
 
66
 
 
67
var MakefileHighlightRules = function() {
 
68
 
 
69
    var keywordMapper = this.createKeywordMapper({
 
70
        "keyword": ShHighlightFile.reservedKeywords,
 
71
        "support.function.builtin": ShHighlightFile.languageConstructs,
 
72
        "invalid.deprecated": "debugger"
 
73
    }, "string");
 
74
 
 
75
    this.$rules = 
 
76
        {
 
77
    "start": [
 
78
        {
 
79
            token: "string.interpolated.backtick.makefile",
 
80
            regex: "`",
 
81
            next: "shell-start"
 
82
        },
 
83
        {
 
84
            token: "punctuation.definition.comment.makefile",
 
85
            regex: /#(?=.)/,
 
86
            next: "comment"
 
87
        },
 
88
        {
 
89
            token: [ "keyword.control.makefile"],
 
90
            regex: "^(?:\\s*\\b)(\\-??include|ifeq|ifneq|ifdef|ifndef|else|endif|vpath|export|unexport|define|endef|override)(?:\\b)"
 
91
        },
 
92
        {// ^([^\t ]+(\s[^\t ]+)*:(?!\=))\s*.*
 
93
            token: ["entity.name.function.makefile", "text"],
 
94
            regex: "^([^\\t ]+(?:\\s[^\\t ]+)*:)(\\s*.*)"
 
95
        }
 
96
    ],
 
97
    "comment": [
 
98
        {
 
99
            token : "punctuation.definition.comment.makefile",
 
100
            regex : /.+\\/
 
101
        },
 
102
        {
 
103
            token : "punctuation.definition.comment.makefile",
 
104
            regex : ".+",
 
105
            next  : "start"
 
106
        }
 
107
    ],
 
108
    "shell-start": [
 
109
        {
 
110
            token: keywordMapper,
 
111
            regex : "[a-zA-Z_$][a-zA-Z0-9_$]*\\b"
 
112
        }, 
 
113
        {
 
114
            token: "string",
 
115
            regex : "\\w+"
 
116
        }, 
 
117
        {
 
118
            token : "string.interpolated.backtick.makefile",
 
119
            regex : "`",
 
120
            next  : "start"
 
121
        }
 
122
    ]
 
123
}
 
124
 
 
125
};
 
126
 
 
127
oop.inherits(MakefileHighlightRules, TextHighlightRules);
 
128
 
 
129
exports.MakefileHighlightRules = MakefileHighlightRules;
 
130
});
 
131
 
 
132
define('ace/mode/sh_highlight_rules', ['require', 'exports', 'module' , 'ace/lib/oop', 'ace/mode/text_highlight_rules'], function(require, exports, module) {
 
133
 
 
134
 
 
135
var oop = require("../lib/oop");
 
136
var TextHighlightRules = require("./text_highlight_rules").TextHighlightRules;
 
137
 
 
138
var reservedKeywords = exports.reservedKeywords = (
 
139
        '!|{|}|case|do|done|elif|else|'+
 
140
        'esac|fi|for|if|in|then|until|while|'+
 
141
        '&|;|export|local|read|typeset|unset|'+
 
142
        'elif|select|set'
 
143
    );
 
144
 
 
145
var languageConstructs = exports.languageConstructs = (
 
146
    '[|]|alias|bg|bind|break|builtin|'+
 
147
     'cd|command|compgen|complete|continue|'+
 
148
     'dirs|disown|echo|enable|eval|exec|'+
 
149
     'exit|fc|fg|getopts|hash|help|history|'+
 
150
     'jobs|kill|let|logout|popd|printf|pushd|'+
 
151
     'pwd|return|set|shift|shopt|source|'+
 
152
     'suspend|test|times|trap|type|ulimit|'+
 
153
     'umask|unalias|wait'
 
154
);
 
155
 
 
156
var ShHighlightRules = function() {
 
157
    var keywordMapper = this.createKeywordMapper({
 
158
        "keyword": reservedKeywords,
 
159
        "support.function.builtin": languageConstructs,
 
160
        "invalid.deprecated": "debugger"
 
161
    }, "identifier");
 
162
 
 
163
    var integer = "(?:(?:[1-9]\\d*)|(?:0))";
 
164
 
 
165
    var fraction = "(?:\\.\\d+)";
 
166
    var intPart = "(?:\\d+)";
 
167
    var pointFloat = "(?:(?:" + intPart + "?" + fraction + ")|(?:" + intPart + "\\.))";
 
168
    var exponentFloat = "(?:(?:" + pointFloat + "|" +  intPart + ")" + ")";
 
169
    var floatNumber = "(?:" + exponentFloat + "|" + pointFloat + ")";
 
170
    var fileDescriptor = "(?:&" + intPart + ")";
 
171
 
 
172
    var variableName = "[a-zA-Z][a-zA-Z0-9_]*";
 
173
    var variable = "(?:(?:\\$" + variableName + ")|(?:" + variableName + "=))";
 
174
 
 
175
    var builtinVariable = "(?:\\$(?:SHLVL|\\$|\\!|\\?))";
 
176
 
 
177
    var func = "(?:" + variableName + "\\s*\\(\\))";
 
178
 
 
179
    this.$rules = {
 
180
        "start" : [ {
 
181
            token : ["text", "comment"],
 
182
            regex : /(^|\s)(#.*)$/
 
183
        }, {
 
184
            token : "string",           // " string
 
185
            regex : '"(?:[^\\\\]|\\\\.)*?"'
 
186
        }, {
 
187
            token : "variable.language",
 
188
            regex : builtinVariable
 
189
        }, {
 
190
            token : "variable",
 
191
            regex : variable
 
192
        }, {
 
193
            token : "support.function",
 
194
            regex : func
 
195
        }, {
 
196
            token : "support.function",
 
197
            regex : fileDescriptor
 
198
        }, {
 
199
            token : "string",           // ' string
 
200
            regex : "'(?:[^\\\\]|\\\\.)*?'"
 
201
        }, {
 
202
            token : "constant.numeric", // float
 
203
            regex : floatNumber
 
204
        }, {
 
205
            token : "constant.numeric", // integer
 
206
            regex : integer + "\\b"
 
207
        }, {
 
208
            token : keywordMapper,
 
209
            regex : "[a-zA-Z_$][a-zA-Z0-9_$]*\\b"
 
210
        }, {
 
211
            token : "keyword.operator",
 
212
            regex : "\\+|\\-|\\*|\\*\\*|\\/|\\/\\/|~|<|>|<=|=>|=|!="
 
213
        }, {
 
214
            token : "paren.lparen",
 
215
            regex : "[\\[\\(\\{]"
 
216
        }, {
 
217
            token : "paren.rparen",
 
218
            regex : "[\\]\\)\\}]"
 
219
        } ]
 
220
    };
 
221
};
 
222
 
 
223
oop.inherits(ShHighlightRules, TextHighlightRules);
 
224
 
 
225
exports.ShHighlightRules = ShHighlightRules;
 
226
});
 
227
 
 
228
define('ace/mode/folding/coffee', ['require', 'exports', 'module' , 'ace/lib/oop', 'ace/mode/folding/fold_mode', 'ace/range'], function(require, exports, module) {
 
229
 
 
230
 
 
231
var oop = require("../../lib/oop");
 
232
var BaseFoldMode = require("./fold_mode").FoldMode;
 
233
var Range = require("../../range").Range;
 
234
 
 
235
var FoldMode = exports.FoldMode = function() {};
 
236
oop.inherits(FoldMode, BaseFoldMode);
 
237
 
 
238
(function() {
 
239
 
 
240
    this.getFoldWidgetRange = function(session, foldStyle, row) {
 
241
        var range = this.indentationBlock(session, row);
 
242
        if (range)
 
243
            return range;
 
244
 
 
245
        var re = /\S/;
 
246
        var line = session.getLine(row);
 
247
        var startLevel = line.search(re);
 
248
        if (startLevel == -1 || line[startLevel] != "#")
 
249
            return;
 
250
 
 
251
        var startColumn = line.length;
 
252
        var maxRow = session.getLength();
 
253
        var startRow = row;
 
254
        var endRow = row;
 
255
 
 
256
        while (++row < maxRow) {
 
257
            line = session.getLine(row);
 
258
            var level = line.search(re);
 
259
 
 
260
            if (level == -1)
 
261
                continue;
 
262
 
 
263
            if (line[level] != "#")
 
264
                break;
 
265
 
 
266
            endRow = row;
 
267
        }
 
268
 
 
269
        if (endRow > startRow) {
 
270
            var endColumn = session.getLine(endRow).length;
 
271
            return new Range(startRow, startColumn, endRow, endColumn);
 
272
        }
 
273
    };
 
274
    this.getFoldWidget = function(session, foldStyle, row) {
 
275
        var line = session.getLine(row);
 
276
        var indent = line.search(/\S/);
 
277
        var next = session.getLine(row + 1);
 
278
        var prev = session.getLine(row - 1);
 
279
        var prevIndent = prev.search(/\S/);
 
280
        var nextIndent = next.search(/\S/);
 
281
 
 
282
        if (indent == -1) {
 
283
            session.foldWidgets[row - 1] = prevIndent!= -1 && prevIndent < nextIndent ? "start" : "";
 
284
            return "";
 
285
        }
 
286
        if (prevIndent == -1) {
 
287
            if (indent == nextIndent && line[indent] == "#" && next[indent] == "#") {
 
288
                session.foldWidgets[row - 1] = "";
 
289
                session.foldWidgets[row + 1] = "";
 
290
                return "start";
 
291
            }
 
292
        } else if (prevIndent == indent && line[indent] == "#" && prev[indent] == "#") {
 
293
            if (session.getLine(row - 2).search(/\S/) == -1) {
 
294
                session.foldWidgets[row - 1] = "start";
 
295
                session.foldWidgets[row + 1] = "";
 
296
                return "";
 
297
            }
 
298
        }
 
299
 
 
300
        if (prevIndent!= -1 && prevIndent < indent)
 
301
            session.foldWidgets[row - 1] = "start";
 
302
        else
 
303
            session.foldWidgets[row - 1] = "";
 
304
 
 
305
        if (indent < nextIndent)
 
306
            return "start";
 
307
        else
 
308
            return "";
 
309
    };
 
310
 
 
311
}).call(FoldMode.prototype);
 
312
 
 
313
});