/lenasys/trunk : contents of codeigniter/js/ace/mode-lua.js at revision 20.1.1

: (revision 20.1.1)

To get this branch, use:

bzr branch
http://gegoxaren.bato24.eu/bzr/lenasys/trunk

/* ***** BEGIN LICENSE BLOCK *****
 * Distributed under the BSD license:
 *
 * Copyright (c) 2010, Ajax.org B.V.
 * All rights reserved.
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of Ajax.org B.V. nor the
 *       names of its contributors may be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 * 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL AJAX.ORG B.V. BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * ***** END LICENSE BLOCK ***** */

define('ace/mode/lua', ['require', 'exports', 'module' , 'ace/lib/oop', 'ace/mode/text', 'ace/tokenizer', 'ace/mode/lua_highlight_rules', 'ace/mode/folding/lua', 'ace/range'], function(require, exports, module) {


var oop = require("../lib/oop");
var TextMode = require("./text").Mode;
var Tokenizer = require("../tokenizer").Tokenizer;
var LuaHighlightRules = require("./lua_highlight_rules").LuaHighlightRules;
var LuaFoldMode = require("./folding/lua").FoldMode;
var Range = require("../range").Range;

var Mode = function() {
    this.$tokenizer = new Tokenizer(new LuaHighlightRules().getRules());
    this.foldingRules = new LuaFoldMode();
};
oop.inherits(Mode, TextMode);

(function() {
   
    this.lineCommentStart = "--";
    this.blockComment = {start: "--[", end: "]--"};
    
    var indentKeywords = {
        "function": 1,
        "then": 1,
        "do": 1,
        "else": 1,
        "elseif": 1,
        "repeat": 1,
        "end": -1,
        "until": -1
    };
    var outdentKeywords = [
        "else",
        "elseif",
        "end",
        "until"
    ];

    function getNetIndentLevel(tokens) {
        var level = 0;
        for (var i = 0; i < tokens.length; i++) {
            var token = tokens[i];
            if (token.type == "keyword") {
                if (token.value in indentKeywords) {
                    level += indentKeywords[token.value];
                }
            } else if (token.type == "paren.lparen") {
                level ++;
            } else if (token.type == "paren.rparen") {
                level --;
            }
        }
        if (level < 0) {
            return -1;
        } else if (level > 0) {
            return 1;
        } else {
            return 0;
        }
    }

    this.getNextLineIndent = function(state, line, tab) {
        var indent = this.$getIndent(line);
        var level = 0;

        var tokenizedLine = this.$tokenizer.getLineTokens(line, state);
        var tokens = tokenizedLine.tokens;

        if (state == "start") {
            level = getNetIndentLevel(tokens);
        }
        if (level > 0) {
            return indent + tab;
        } else if (level < 0 && indent.substr(indent.length - tab.length) == tab) {
            if (!this.checkOutdent(state, line, "\n")) {
                return indent.substr(0, indent.length - tab.length);
            }
        }
        return indent;
    };

    this.checkOutdent = function(state, line, input) {
        if (input != "\n" && input != "\r" && input != "\r\n")
            return false;

        if (line.match(/^\s*[\)\}\]]$/))
            return true;

        var tokens = this.$tokenizer.getLineTokens(line.trim(), state).tokens;

        if (!tokens || !tokens.length)
            return false;

        return (tokens[0].type == "keyword" && outdentKeywords.indexOf(tokens[0].value) != -1);
    };

    this.autoOutdent = function(state, session, row) {
        var prevLine = session.getLine(row - 1);
        var prevIndent = this.$getIndent(prevLine).length;
        var prevTokens = this.$tokenizer.getLineTokens(prevLine, "start").tokens;
        var tabLength = session.getTabString().length;
        var expectedIndent = prevIndent + tabLength * getNetIndentLevel(prevTokens);
        var curIndent = this.$getIndent(session.getLine(row)).length;
        if (curIndent < expectedIndent) {
            return;
        }
        session.outdentRows(new Range(row, 0, row + 2, 0));
    };

}).call(Mode.prototype);

exports.Mode = Mode;
});

define('ace/mode/lua_highlight_rules', ['require', 'exports', 'module' , 'ace/lib/oop', 'ace/mode/text_highlight_rules'], function(require, exports, module) {


var oop = require("../lib/oop");
var TextHighlightRules = require("./text_highlight_rules").TextHighlightRules;

var LuaHighlightRules = function() {

    var keywords = (
        "break|do|else|elseif|end|for|function|if|in|local|repeat|"+
         "return|then|until|while|or|and|not"
    );

    var builtinConstants = ("true|false|nil|_G|_VERSION");

    var functions = (
        "string|xpcall|package|tostring|print|os|unpack|require|"+
        "getfenv|setmetatable|next|assert|tonumber|io|rawequal|"+
        "collectgarbage|getmetatable|module|rawset|math|debug|"+
        "pcall|table|newproxy|type|coroutine|_G|select|gcinfo|"+
        "pairs|rawget|loadstring|ipairs|_VERSION|dofile|setfenv|"+
        "load|error|loadfile|"+

        "sub|upper|len|gfind|rep|find|match|char|dump|gmatch|"+
        "reverse|byte|format|gsub|lower|preload|loadlib|loaded|"+
        "loaders|cpath|config|path|seeall|exit|setlocale|date|"+
        "getenv|difftime|remove|time|clock|tmpname|rename|execute|"+
        "lines|write|close|flush|open|output|type|read|stderr|"+
        "stdin|input|stdout|popen|tmpfile|log|max|acos|huge|"+
        "ldexp|pi|cos|tanh|pow|deg|tan|cosh|sinh|random|randomseed|"+
        "frexp|ceil|floor|rad|abs|sqrt|modf|asin|min|mod|fmod|log10|"+
        "atan2|exp|sin|atan|getupvalue|debug|sethook|getmetatable|"+
        "gethook|setmetatable|setlocal|traceback|setfenv|getinfo|"+
        "setupvalue|getlocal|getregistry|getfenv|setn|insert|getn|"+
        "foreachi|maxn|foreach|concat|sort|remove|resume|yield|"+
        "status|wrap|create|running|"+
        "__add|__sub|__mod|__unm|__concat|__lt|__index|__call|__gc|__metatable|"+
         "__mul|__div|__pow|__len|__eq|__le|__newindex|__tostring|__mode|__tonumber"
    );

    var stdLibaries = ("string|package|os|io|math|debug|table|coroutine");

    var futureReserved = "";

    var deprecatedIn5152 = ("setn|foreach|foreachi|gcinfo|log10|maxn");

    var keywordMapper = this.createKeywordMapper({
        "keyword": keywords,
        "support.function": functions,
        "invalid.deprecated": deprecatedIn5152,
        "constant.library": stdLibaries,
        "constant.language": builtinConstants,
        "invalid.illegal": futureReserved,
        "variable.language": "this"
    }, "identifier");

    var decimalInteger = "(?:(?:[1-9]\\d*)|(?:0))";
    var hexInteger = "(?:0[xX][\\dA-Fa-f]+)";
    var integer = "(?:" + decimalInteger + "|" + hexInteger + ")";

    var fraction = "(?:\\.\\d+)";
    var intPart = "(?:\\d+)";
    var pointFloat = "(?:(?:" + intPart + "?" + fraction + ")|(?:" + intPart + "\\.))";
    var floatNumber = "(?:" + pointFloat + ")";

    this.$rules = {
        "start" : [{
            stateName: "bracketedComment",
            onMatch : function(value, currentState, stack){
                stack.unshift(this.next, value.length, currentState);
                return "comment";
            },
            regex : /\-\-\[=*\[/,
            next  : [
                {
                    onMatch : function(value, currentState, stack) {
                        if (value.length == stack[1]) {
                            stack.shift();
                            stack.shift();
                            this.next = stack.shift();
                        } else {
                            this.next = "";
                        }
                        return "comment";
                    },
                    regex : /(?:[^\\]|\\.)*?\]=*\]/,
                    next  : "start"
                }, {
                    defaultToken : "comment"
                }
            ]
        },

        {
            token : "comment",
            regex : "\\-\\-.*$"
        },
        {
            stateName: "bracketedString",
            onMatch : function(value, currentState, stack){
                stack.unshift(this.next, value.length, currentState);
                return "comment";
            },
            regex : /\[=*\[/,
            next  : [
                {
                    onMatch : function(value, currentState, stack) {
                        if (value.length == stack[1]) {
                            stack.shift();
                            stack.shift();
                            this.next = stack.shift();
                        } else {
                            this.next = "";
                        }
                        return "comment";
                    },
                    
                    regex : /(?:[^\\]|\\.)*?\]=*\]/,
                    next  : "start"
                }, {
                    defaultToken : "comment"
                }
            ]
        },
        {
            token : "string",           // " string
            regex : '"(?:[^\\\\]|\\\\.)*?"'
        }, {
            token : "string",           // ' string
            regex : "'(?:[^\\\\]|\\\\.)*?'"
        }, {
            token : "constant.numeric", // float
            regex : floatNumber
        }, {
            token : "constant.numeric", // integer
            regex : integer + "\\b"
        }, {
            token : keywordMapper,
            regex : "[a-zA-Z_$][a-zA-Z0-9_$]*\\b"
        }, {
            token : "keyword.operator",
            regex : "\\+|\\-|\\*|\\/|%|\\#|\\^|~|<|>|<=|=>|==|~=|=|\\:|\\.\\.\\.|\\.\\."
        }, {
            token : "paren.lparen",
            regex : "[\\[\\(\\{]"
        }, {
            token : "paren.rparen",
            regex : "[\\]\\)\\}]"
        }, {
            token : "text",
            regex : "\\s+|\\w+"
        } ]
    };
    
    this.normalizeRules();
}

oop.inherits(LuaHighlightRules, TextHighlightRules);

exports.LuaHighlightRules = LuaHighlightRules;
});

define('ace/mode/folding/lua', ['require', 'exports', 'module' , 'ace/lib/oop', 'ace/mode/folding/fold_mode', 'ace/range', 'ace/token_iterator'], function(require, exports, module) {


var oop = require("../../lib/oop");
var BaseFoldMode = require("./fold_mode").FoldMode;
var Range = require("../../range").Range;
var TokenIterator = require("../../token_iterator").TokenIterator;


var FoldMode = exports.FoldMode = function() {};

oop.inherits(FoldMode, BaseFoldMode);

(function() {

    this.foldingStartMarker = /\b(function|then|do|repeat)\b|{\s*$|(\[=*\[)/;
    this.foldingStopMarker = /\bend\b|^\s*}|\]=*\]/;

    this.getFoldWidget = function(session, foldStyle, row) {
        var line = session.getLine(row);
        var isStart = this.foldingStartMarker.test(line);
        var isEnd = this.foldingStopMarker.test(line);

        if (isStart && !isEnd) {
            var match = line.match(this.foldingStartMarker);
            if (match[1] == "then" && /\belseif\b/.test(line))
                return;
            if (match[1]) {
                if (session.getTokenAt(row, match.index + 1).type === "keyword")
                    return "start";
            } else if (match[2]) {
                var type = session.bgTokenizer.getState(row) || "";
                if (type[0] == "bracketedComment" || type[0] == "bracketedString")
                    return "start";
            } else {
                return "start";
            }
        }
        if (foldStyle != "markbeginend" || !isEnd || isStart && isEnd)
            return "";

        var match = line.match(this.foldingStopMarker);
        if (match[0] === "end") {
            if (session.getTokenAt(row, match.index + 1).type === "keyword")
                return "end";
        } else if (match[0][0] === "]") {
            var type = session.bgTokenizer.getState(row - 1) || "";
            if (type[0] == "bracketedComment" || type[0] == "bracketedString")
                return "end";
        } else
            return "end";
    };

    this.getFoldWidgetRange = function(session, foldStyle, row) {
        var line = session.doc.getLine(row);
        var match = this.foldingStartMarker.exec(line);
        if (match) {
            if (match[1])
                return this.luaBlock(session, row, match.index + 1);

            if (match[2])
                return session.getCommentFoldRange(row, match.index + 1);

            return this.openingBracketBlock(session, "{", row, match.index);
        }

        var match = this.foldingStopMarker.exec(line);
        if (match) {
            if (match[0] === "end") {
                if (session.getTokenAt(row, match.index + 1).type === "keyword")
                    return this.luaBlock(session, row, match.index + 1);
            }

            if (match[0][0] === "]")
                return session.getCommentFoldRange(row, match.index + 1);

            return this.closingBracketBlock(session, "}", row, match.index + match[0].length);
        }
    };

    this.luaBlock = function(session, row, column) {
        var stream = new TokenIterator(session, row, column);
        var indentKeywords = {
            "function": 1,
            "do": 1,
            "then": 1,
            "elseif": -1,
            "end": -1,
            "repeat": 1,
            "until": -1,
        };

        var token = stream.getCurrentToken();
        if (!token || token.type != "keyword")
            return;

        var val = token.value;
        var stack = [val];
        var dir = indentKeywords[val];

        if (!dir)
            return;

        var startColumn = dir === -1 ? stream.getCurrentTokenColumn() : session.getLine(row).length;
        var startRow = row;

        stream.step = dir === -1 ? stream.stepBackward : stream.stepForward;
        while(token = stream.step()) {
            if (token.type !== "keyword")
                continue;
            var level = dir * indentKeywords[token.value];

            if (level > 0) {
                stack.unshift(token.value);
            } else if (level <= 0) {
                stack.shift();
                if (!stack.length && token.value != "elseif")
                    break;
                if (level === 0)
                    stack.unshift(token.value);
            }
        }

        var row = stream.getCurrentTokenRow();
        if (dir === -1)
            return new Range(row, session.getLine(row).length, startRow, startColumn);
        else
            return new Range(startRow, startColumn, row, stream.getCurrentTokenColumn());
    };

}).call(FoldMode.prototype);

});

20.1.1 by galaxyAbstractor * Added an simple admin panel to the codeviewer-cmssy stuff	1	/* *** BEGIN LICENSE BLOCK ***
	2	* Distributed under the BSD license:
	3	*
	4	* Copyright (c) 2010, 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	* *** END LICENSE BLOCK *** */
	30
	31	define('ace/mode/lua', ['require', 'exports', 'module' , 'ace/lib/oop', 'ace/mode/text', 'ace/tokenizer', 'ace/mode/lua_highlight_rules', 'ace/mode/folding/lua', 'ace/range'], function(require, exports, module) {
	32
	33
	34	var oop = require("../lib/oop");
	35	var TextMode = require("./text").Mode;
	36	var Tokenizer = require("../tokenizer").Tokenizer;
	37	var LuaHighlightRules = require("./lua_highlight_rules").LuaHighlightRules;
	38	var LuaFoldMode = require("./folding/lua").FoldMode;
	39	var Range = require("../range").Range;
	40
	41	var Mode = function() {
	42	this.$tokenizer = new Tokenizer(new LuaHighlightRules().getRules());
	43	this.foldingRules = new LuaFoldMode();
	44	};
	45	oop.inherits(Mode, TextMode);
	46
	47	(function() {
	48
	49	this.lineCommentStart = "--";
	50	this.blockComment = {start: "--[", end: "]--"};
	51
	52	var indentKeywords = {
	53	"function": 1,
	54	"then": 1,
	55	"do": 1,
	56	"else": 1,
	57	"elseif": 1,
	58	"repeat": 1,
	59	"end": -1,
	60	"until": -1
	61	};
	62	var outdentKeywords = [
	63	"else",
	64	"elseif",
65	"end",
66	"until"
67	];
68
69	function getNetIndentLevel(tokens) {
70	var level = 0;
71	for (var i = 0; i < tokens.length; i++) {
72	var token = tokens[i];
73	if (token.type == "keyword") {
74	if (token.value in indentKeywords) {
75	level += indentKeywords[token.value];
76	}
77	} else if (token.type == "paren.lparen") {
78	level ++;
79	} else if (token.type == "paren.rparen") {
80	level --;
81	}
82	}
83	if (level < 0) {
84	return -1;
85	} else if (level > 0) {
86	return 1;
87	} else {
88	return 0;
89	}
90	}
91
92	this.getNextLineIndent = function(state, line, tab) {
93	var indent = this.$getIndent(line);
94	var level = 0;
95
96	var tokenizedLine = this.$tokenizer.getLineTokens(line, state);
97	var tokens = tokenizedLine.tokens;
98
99	if (state == "start") {
100	level = getNetIndentLevel(tokens);
101	}
102	if (level > 0) {
103	return indent + tab;
104	} else if (level < 0 && indent.substr(indent.length - tab.length) == tab) {
105	if (!this.checkOutdent(state, line, "\n")) {
106	return indent.substr(0, indent.length - tab.length);
107	}
108	}
109	return indent;
110	};
111
112	this.checkOutdent = function(state, line, input) {
113	if (input != "\n" && input != "\r" && input != "\r\n")
114	return false;
115
116	if (line.match(/^\s*[\)\}\]]$/))
117	return true;
118
119	var tokens = this.$tokenizer.getLineTokens(line.trim(), state).tokens;
120
121	if (!tokens \|\| !tokens.length)
122	return false;
123
124	return (tokens[0].type == "keyword" && outdentKeywords.indexOf(tokens[0].value) != -1);
125	};
126
127	this.autoOutdent = function(state, session, row) {
128	var prevLine = session.getLine(row - 1);
129	var prevIndent = this.$getIndent(prevLine).length;
130	var prevTokens = this.$tokenizer.getLineTokens(prevLine, "start").tokens;
131	var tabLength = session.getTabString().length;
132	var expectedIndent = prevIndent + tabLength * getNetIndentLevel(prevTokens);
133	var curIndent = this.$getIndent(session.getLine(row)).length;
134	if (curIndent < expectedIndent) {
135	return;
136	}
137	session.outdentRows(new Range(row, 0, row + 2, 0));
138	};
139
140	}).call(Mode.prototype);
141
142	exports.Mode = Mode;
143	});
144
145	define('ace/mode/lua_highlight_rules', ['require', 'exports', 'module' , 'ace/lib/oop', 'ace/mode/text_highlight_rules'], function(require, exports, module) {
146
147
148	var oop = require("../lib/oop");
149	var TextHighlightRules = require("./text_highlight_rules").TextHighlightRules;
150
151	var LuaHighlightRules = function() {
152
153	var keywords = (
154	"break\|do\|else\|elseif\|end\|for\|function\|if\|in\|local\|repeat\|"+
155	"return\|then\|until\|while\|or\|and\|not"
156	);
157
158	var builtinConstants = ("true\|false\|nil\|_G\|_VERSION");
159
160	var functions = (
161	"string\|xpcall\|package\|tostring\|print\|os\|unpack\|require\|"+
162	"getfenv\|setmetatable\|next\|assert\|tonumber\|io\|rawequal\|"+
163	"collectgarbage\|getmetatable\|module\|rawset\|math\|debug\|"+
164	"pcall\|table\|newproxy\|type\|coroutine\|_G\|select\|gcinfo\|"+
165	"pairs\|rawget\|loadstring\|ipairs\|_VERSION\|dofile\|setfenv\|"+
166	"load\|error\|loadfile\|"+
167
168	"sub\|upper\|len\|gfind\|rep\|find\|match\|char\|dump\|gmatch\|"+
169	"reverse\|byte\|format\|gsub\|lower\|preload\|loadlib\|loaded\|"+
170	"loaders\|cpath\|config\|path\|seeall\|exit\|setlocale\|date\|"+
171	"getenv\|difftime\|remove\|time\|clock\|tmpname\|rename\|execute\|"+
172	"lines\|write\|close\|flush\|open\|output\|type\|read\|stderr\|"+
173	"stdin\|input\|stdout\|popen\|tmpfile\|log\|max\|acos\|huge\|"+
174	"ldexp\|pi\|cos\|tanh\|pow\|deg\|tan\|cosh\|sinh\|random\|randomseed\|"+
175	"frexp\|ceil\|floor\|rad\|abs\|sqrt\|modf\|asin\|min\|mod\|fmod\|log10\|"+
176	"atan2\|exp\|sin\|atan\|getupvalue\|debug\|sethook\|getmetatable\|"+
177	"gethook\|setmetatable\|setlocal\|traceback\|setfenv\|getinfo\|"+
178	"setupvalue\|getlocal\|getregistry\|getfenv\|setn\|insert\|getn\|"+
179	"foreachi\|maxn\|foreach\|concat\|sort\|remove\|resume\|yield\|"+
180	"status\|wrap\|create\|running\|"+
181	"__add\|__sub\|__mod\|__unm\|__concat\|__lt\|__index\|__call\|__gc\|__metatable\|"+
182	"__mul\|__div\|__pow\|__len\|__eq\|__le\|__newindex\|__tostring\|__mode\|__tonumber"
183	);
184
185	var stdLibaries = ("string\|package\|os\|io\|math\|debug\|table\|coroutine");
186
187	var futureReserved = "";
188
189	var deprecatedIn5152 = ("setn\|foreach\|foreachi\|gcinfo\|log10\|maxn");
190
191	var keywordMapper = this.createKeywordMapper({
192	"keyword": keywords,
193	"support.function": functions,
194	"invalid.deprecated": deprecatedIn5152,
195	"constant.library": stdLibaries,
196	"constant.language": builtinConstants,
197	"invalid.illegal": futureReserved,
198	"variable.language": "this"
199	}, "identifier");
200
201	var decimalInteger = "(?:(?:[1-9]\\d*)\|(?:0))";
202	var hexInteger = "(?:0[xX][\\dA-Fa-f]+)";
203	var integer = "(?:" + decimalInteger + "\|" + hexInteger + ")";
204
205	var fraction = "(?:\\.\\d+)";
206	var intPart = "(?:\\d+)";
207	var pointFloat = "(?:(?:" + intPart + "?" + fraction + ")\|(?:" + intPart + "\\.))";
208	var floatNumber = "(?:" + pointFloat + ")";
209
210	this.$rules = {
211	"start" : [{
212	stateName: "bracketedComment",
213	onMatch : function(value, currentState, stack){
214	stack.unshift(this.next, value.length, currentState);
215	return "comment";
216	},
217	regex : /\-\-\[=*\[/,
218	next : [
219	{
220	onMatch : function(value, currentState, stack) {
221	if (value.length == stack[1]) {
222	stack.shift();
223	stack.shift();
224	this.next = stack.shift();
225	} else {
226	this.next = "";
227	}
228	return "comment";
229	},
230	regex : /(?:[^\\]\|\\.)?\]=\]/,
231	next : "start"
232	}, {
233	defaultToken : "comment"
234	}
235	]
236	},
237
238	{
239	token : "comment",
240	regex : "\\-\\-.*$"
241	},
242	{
243	stateName: "bracketedString",
244	onMatch : function(value, currentState, stack){
245	stack.unshift(this.next, value.length, currentState);
246	return "comment";
247	},
248	regex : /\[=*\[/,
249	next : [
250	{
251	onMatch : function(value, currentState, stack) {
252	if (value.length == stack[1]) {
253	stack.shift();
254	stack.shift();
255	this.next = stack.shift();
256	} else {
257	this.next = "";
258	}
259	return "comment";
260	},
261
262	regex : /(?:[^\\]\|\\.)?\]=\]/,
263	next : "start"
264	}, {
265	defaultToken : "comment"
266	}
267	]
268	},
269	{
270	token : "string", // " string
271	regex : '"(?:[^\\\\]\|\\\\.)*?"'
272	}, {
273	token : "string", // ' string
274	regex : "'(?:[^\\\\]\|\\\\.)*?'"
275	}, {
276	token : "constant.numeric", // float
277	regex : floatNumber
278	}, {
279	token : "constant.numeric", // integer
280	regex : integer + "\\b"
281	}, {
282	token : keywordMapper,
283	regex : "[a-zA-Z_$][a-zA-Z0-9_$]*\\b"
284	}, {
285	token : "keyword.operator",
286	regex : "\\+\|\\-\|\\*\|\\/\|%\|\\#\|\\^\|~\|<\|>\|<=\|=>\|==\|~=\|=\|\\:\|\\.\\.\\.\|\\.\\."
287	}, {
288	token : "paren.lparen",
289	regex : "[\\[\\(\\{]"
290	}, {
291	token : "paren.rparen",
292	regex : "[\\]\\)\\}]"
293	}, {
294	token : "text",
295	regex : "\\s+\|\\w+"
296	} ]
297	};
298
299	this.normalizeRules();
300	}
301
302	oop.inherits(LuaHighlightRules, TextHighlightRules);
303
304	exports.LuaHighlightRules = LuaHighlightRules;
305	});
306
307	define('ace/mode/folding/lua', ['require', 'exports', 'module' , 'ace/lib/oop', 'ace/mode/folding/fold_mode', 'ace/range', 'ace/token_iterator'], function(require, exports, module) {
308
309
310	var oop = require("../../lib/oop");
311	var BaseFoldMode = require("./fold_mode").FoldMode;
312	var Range = require("../../range").Range;
313	var TokenIterator = require("../../token_iterator").TokenIterator;
314
315
316	var FoldMode = exports.FoldMode = function() {};
317
318	oop.inherits(FoldMode, BaseFoldMode);
319
320	(function() {
321
322	this.foldingStartMarker = /\b(function\|then\|do\|repeat)\b\|{\s$\|(\[=\[)/;
323	this.foldingStopMarker = /\bend\b\|^\s}\|\]=\]/;
324
325	this.getFoldWidget = function(session, foldStyle, row) {
326	var line = session.getLine(row);
327	var isStart = this.foldingStartMarker.test(line);
328	var isEnd = this.foldingStopMarker.test(line);
329
330	if (isStart && !isEnd) {
331	var match = line.match(this.foldingStartMarker);
332	if (match[1] == "then" && /\belseif\b/.test(line))
333	return;
334	if (match[1]) {
335	if (session.getTokenAt(row, match.index + 1).type === "keyword")
336	return "start";
337	} else if (match[2]) {
338	var type = session.bgTokenizer.getState(row) \|\| "";
339	if (type[0] == "bracketedComment" \|\| type[0] == "bracketedString")
340	return "start";
341	} else {
342	return "start";
343	}
344	}
345	if (foldStyle != "markbeginend" \|\| !isEnd \|\| isStart && isEnd)
346	return "";
347
348	var match = line.match(this.foldingStopMarker);
349	if (match[0] === "end") {
350	if (session.getTokenAt(row, match.index + 1).type === "keyword")
351	return "end";
352	} else if (match[0][0] === "]") {
353	var type = session.bgTokenizer.getState(row - 1) \|\| "";
354	if (type[0] == "bracketedComment" \|\| type[0] == "bracketedString")
355	return "end";
356	} else
357	return "end";
358	};
359
360	this.getFoldWidgetRange = function(session, foldStyle, row) {
361	var line = session.doc.getLine(row);
362	var match = this.foldingStartMarker.exec(line);
363	if (match) {
364	if (match[1])
365	return this.luaBlock(session, row, match.index + 1);
366
367	if (match[2])
368	return session.getCommentFoldRange(row, match.index + 1);
369
370	return this.openingBracketBlock(session, "{", row, match.index);
371	}
372
373	var match = this.foldingStopMarker.exec(line);
374	if (match) {
375	if (match[0] === "end") {
376	if (session.getTokenAt(row, match.index + 1).type === "keyword")
377	return this.luaBlock(session, row, match.index + 1);
378	}
379
380	if (match[0][0] === "]")
381	return session.getCommentFoldRange(row, match.index + 1);
382
383	return this.closingBracketBlock(session, "}", row, match.index + match[0].length);
384	}
385	};
386
387	this.luaBlock = function(session, row, column) {
388	var stream = new TokenIterator(session, row, column);
389	var indentKeywords = {
390	"function": 1,
391	"do": 1,
392	"then": 1,
393	"elseif": -1,
394	"end": -1,
395	"repeat": 1,
396	"until": -1,
397	};
398
399	var token = stream.getCurrentToken();
400	if (!token \|\| token.type != "keyword")
401	return;
402
403	var val = token.value;
404	var stack = [val];
405	var dir = indentKeywords[val];
406
407	if (!dir)
408	return;
409
410	var startColumn = dir === -1 ? stream.getCurrentTokenColumn() : session.getLine(row).length;
411	var startRow = row;
412
413	stream.step = dir === -1 ? stream.stepBackward : stream.stepForward;
414	while(token = stream.step()) {
415	if (token.type !== "keyword")
416	continue;
417	var level = dir * indentKeywords[token.value];
418
419	if (level > 0) {
420	stack.unshift(token.value);
421	} else if (level <= 0) {
422	stack.shift();
423	if (!stack.length && token.value != "elseif")
424	break;
425	if (level === 0)
426	stack.unshift(token.value);
427	}
428	}
429
430	var row = stream.getCurrentTokenRow();
431	if (dir === -1)
432	return new Range(row, session.getLine(row).length, startRow, startColumn);
433	else
434	return new Range(startRow, startColumn, row, stream.getCurrentTokenColumn());
435	};
436
437	}).call(FoldMode.prototype);
438
439	});