/lenasys/trunk : contents of js/ace/mode-golang.js at revision 15.1.1

: (revision 15.1.1)

To get this branch, use:

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

define('ace/mode/golang', ['require', 'exports', 'module' , 'ace/lib/oop', 'ace/mode/text', 'ace/tokenizer', 'ace/mode/golang_highlight_rules', 'ace/mode/matching_brace_outdent', 'ace/mode/behaviour/cstyle', 'ace/mode/folding/cstyle'], function(require, exports, module) {

var oop = require("../lib/oop");
var TextMode = require("./text").Mode;
var Tokenizer = require("../tokenizer").Tokenizer;
var GolangHighlightRules = require("./golang_highlight_rules").GolangHighlightRules;
var MatchingBraceOutdent = require("./matching_brace_outdent").MatchingBraceOutdent;
var CstyleBehaviour = require("./behaviour/cstyle").CstyleBehaviour;
var CStyleFoldMode = require("./folding/cstyle").FoldMode;

var Mode = function() {
    this.$tokenizer = new Tokenizer(new GolangHighlightRules().getRules());
    this.$outdent = new MatchingBraceOutdent();
    this.foldingRules = new CStyleFoldMode();
};
oop.inherits(Mode, TextMode);

(function() {
    
    this.lineCommentStart = "//";
    this.blockComment = {start: "/*", end: "*/"};

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

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

        if (tokens.length && tokens[tokens.length-1].type == "comment") {
            return indent;
        }
        
        if (state == "start") {
            var match = line.match(/^.*[\{\(\[]\s*$/);
            if (match) {
                indent += tab;
            }
        }

        return indent;
    };//end getNextLineIndent

    this.checkOutdent = function(state, line, input) {
        return this.$outdent.checkOutdent(line, input);
    };

    this.autoOutdent = function(state, doc, row) {
        this.$outdent.autoOutdent(doc, row);
    };

}).call(Mode.prototype);

exports.Mode = Mode;
});
define('ace/mode/golang_highlight_rules', ['require', 'exports', 'module' , 'ace/lib/oop', 'ace/mode/doc_comment_highlight_rules', 'ace/mode/text_highlight_rules'], function(require, exports, module) {
    var oop = require("../lib/oop");
    var DocCommentHighlightRules = require("./doc_comment_highlight_rules").DocCommentHighlightRules;
    var TextHighlightRules = require("./text_highlight_rules").TextHighlightRules;

    var GolangHighlightRules = function() {
        var keywords = (
            "true|else|false|break|case|return|goto|if|const|" +
            "continue|struct|default|switch|for|" +
            "func|import|package|chan|defer|fallthrough|go|interface|map|range" +
            "select|type|var"
        );
        var buildinConstants = ("nil|true|false|iota");

        var keywordMapper = this.createKeywordMapper({
            "variable.language": "this",
            "keyword": keywords,
            "constant.language": buildinConstants
        }, "identifier");

        this.$rules = {
            "start" : [
                {
                    token : "comment",
                    regex : "\\/\\/.*$"
                },
                DocCommentHighlightRules.getStartRule("doc-start"),
                {
                    token : "comment", // multi line comment
                    regex : "\\/\\*",
                    next : "comment"
                }, {
                    token : "string", // single line
                    regex : '["](?:(?:\\\\.)|(?:[^"\\\\]))*?["]'
                }, {
                    token : "string", // multi line string start
                    regex : '["].*\\\\$',
                    next : "qqstring"
                }, {
                    token : "string", // single line
                    regex : "['](?:(?:\\\\.)|(?:[^'\\\\]))*?[']"
                }, {
                    token : "string", // multi line string start
                    regex : "['].*\\\\$",
                    next : "qstring"
                }, {
                    token : "constant.numeric", // hex
                    regex : "0[xX][0-9a-fA-F]+\\b"
                }, {
                    token : "constant.numeric", // float
                    regex : "[+-]?\\d+(?:(?:\\.\\d*)?(?:[eE][+-]?\\d+)?)?\\b"
                }, {
                    token : "constant", // <CONSTANT>
                    regex : "<[a-zA-Z0-9.]+>"
                }, {
                    token : "keyword", // pre-compiler directivs
                    regex : "(?:#include|#pragma|#line|#define|#undef|#ifdef|#else|#elif|#endif|#ifndef)"
                }, {
                    token : keywordMapper,
                    regex : "[a-zA-Z_$][a-zA-Z0-9_$]*\\b"
                }, {
                    token : "keyword.operator",
                    regex : "!|\\$|%|&|\\*|\\-\\-|\\-|\\+\\+|\\+|~|==|=|!=|<=|>=|<<=|>>=|>>>=|<>|<|>|!|&&|\\|\\||\\?\\:|\\*=|%=|\\+=|\\-=|&=|\\^=|\\b(?:in|new|delete|typeof|void)"
                }, {
                    token : "punctuation.operator",
                    regex : "\\?|\\:|\\,|\\;|\\."
                }, {
                    token : "paren.lparen",
                    regex : "[[({]"
                }, {
                    token : "paren.rparen",
                    regex : "[\\])}]"
                }, {
                    token : "text",
                    regex : "\\s+"
                }
            ],
            "comment" : [
                {
                    token : "comment", // closing comment
                    regex : ".*?\\*\\/",
                    next : "start"
                }, {
                    token : "comment", // comment spanning whole line
                    regex : ".+"
                }
            ],
            "qqstring" : [
                {
                    token : "string",
                    regex : '(?:(?:\\\\.)|(?:[^"\\\\]))*?"',
                    next : "start"
                }, {
                    token : "string",
                    regex : '.+'
                }
            ],
            "qstring" : [
                {
                    token : "string",
                    regex : "(?:(?:\\\\.)|(?:[^'\\\\]))*?'",
                    next : "start"
                }, {
                    token : "string",
                    regex : '.+'
                }
            ]
        };

        this.embedRules(DocCommentHighlightRules, "doc-",
            [ DocCommentHighlightRules.getEndRule("start") ]);
    }
    oop.inherits(GolangHighlightRules, TextHighlightRules);

    exports.GolangHighlightRules = GolangHighlightRules;
});

define('ace/mode/doc_comment_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 DocCommentHighlightRules = function() {

    this.$rules = {
        "start" : [ {
            token : "comment.doc.tag",
            regex : "@[\\w\\d_]+" // TODO: fix email addresses
        }, {
            token : "comment.doc.tag",
            regex : "\\bTODO\\b"
        }, {
            defaultToken : "comment.doc"
        }]
    };
};

oop.inherits(DocCommentHighlightRules, TextHighlightRules);

DocCommentHighlightRules.getStartRule = function(start) {
    return {
        token : "comment.doc", // doc comment
        regex : "\\/\\*(?=\\*)",
        next  : start
    };
};

DocCommentHighlightRules.getEndRule = function (start) {
    return {
        token : "comment.doc", // closing comment
        regex : "\\*\\/",
        next  : start
    };
};


exports.DocCommentHighlightRules = DocCommentHighlightRules;

});

define('ace/mode/matching_brace_outdent', ['require', 'exports', 'module' , 'ace/range'], function(require, exports, module) {


var Range = require("../range").Range;

var MatchingBraceOutdent = function() {};

(function() {

    this.checkOutdent = function(line, input) {
        if (! /^\s+$/.test(line))
            return false;

        return /^\s*\}/.test(input);
    };

    this.autoOutdent = function(doc, row) {
        var line = doc.getLine(row);
        var match = line.match(/^(\s*\})/);

        if (!match) return 0;

        var column = match[1].length;
        var openBracePos = doc.findMatchingBracket({row: row, column: column});

        if (!openBracePos || openBracePos.row == row) return 0;

        var indent = this.$getIndent(doc.getLine(openBracePos.row));
        doc.replace(new Range(row, 0, row, column-1), indent);
    };

    this.$getIndent = function(line) {
        return line.match(/^\s*/)[0];
    };

}).call(MatchingBraceOutdent.prototype);

exports.MatchingBraceOutdent = MatchingBraceOutdent;
});

define('ace/mode/behaviour/cstyle', ['require', 'exports', 'module' , 'ace/lib/oop', 'ace/mode/behaviour', 'ace/token_iterator', 'ace/lib/lang'], function(require, exports, module) {


var oop = require("../../lib/oop");
var Behaviour = require("../behaviour").Behaviour;
var TokenIterator = require("../../token_iterator").TokenIterator;
var lang = require("../../lib/lang");

var SAFE_INSERT_IN_TOKENS =
    ["text", "paren.rparen", "punctuation.operator"];
var SAFE_INSERT_BEFORE_TOKENS =
    ["text", "paren.rparen", "punctuation.operator", "comment"];


var autoInsertedBrackets = 0;
var autoInsertedRow = -1;
var autoInsertedLineEnd = "";
var maybeInsertedBrackets = 0;
var maybeInsertedRow = -1;
var maybeInsertedLineStart = "";
var maybeInsertedLineEnd = "";

var CstyleBehaviour = function () {
    
    CstyleBehaviour.isSaneInsertion = function(editor, session) {
        var cursor = editor.getCursorPosition();
        var iterator = new TokenIterator(session, cursor.row, cursor.column);
        if (!this.$matchTokenType(iterator.getCurrentToken() || "text", SAFE_INSERT_IN_TOKENS)) {
            var iterator2 = new TokenIterator(session, cursor.row, cursor.column + 1);
            if (!this.$matchTokenType(iterator2.getCurrentToken() || "text", SAFE_INSERT_IN_TOKENS))
                return false;
        }
        iterator.stepForward();
        return iterator.getCurrentTokenRow() !== cursor.row ||
            this.$matchTokenType(iterator.getCurrentToken() || "text", SAFE_INSERT_BEFORE_TOKENS);
    };
    
    CstyleBehaviour.$matchTokenType = function(token, types) {
        return types.indexOf(token.type || token) > -1;
    };
    
    CstyleBehaviour.recordAutoInsert = function(editor, session, bracket) {
        var cursor = editor.getCursorPosition();
        var line = session.doc.getLine(cursor.row);
        if (!this.isAutoInsertedClosing(cursor, line, autoInsertedLineEnd[0]))
            autoInsertedBrackets = 0;
        autoInsertedRow = cursor.row;
        autoInsertedLineEnd = bracket + line.substr(cursor.column);
        autoInsertedBrackets++;
    };
    
    CstyleBehaviour.recordMaybeInsert = function(editor, session, bracket) {
        var cursor = editor.getCursorPosition();
        var line = session.doc.getLine(cursor.row);
        if (!this.isMaybeInsertedClosing(cursor, line))
            maybeInsertedBrackets = 0;
        maybeInsertedRow = cursor.row;
        maybeInsertedLineStart = line.substr(0, cursor.column) + bracket;
        maybeInsertedLineEnd = line.substr(cursor.column);
        maybeInsertedBrackets++;
    };
    
    CstyleBehaviour.isAutoInsertedClosing = function(cursor, line, bracket) {
        return autoInsertedBrackets > 0 &&
            cursor.row === autoInsertedRow &&
            bracket === autoInsertedLineEnd[0] &&
            line.substr(cursor.column) === autoInsertedLineEnd;
    };
    
    CstyleBehaviour.isMaybeInsertedClosing = function(cursor, line) {
        return maybeInsertedBrackets > 0 &&
            cursor.row === maybeInsertedRow &&
            line.substr(cursor.column) === maybeInsertedLineEnd &&
            line.substr(0, cursor.column) == maybeInsertedLineStart;
    };
    
    CstyleBehaviour.popAutoInsertedClosing = function() {
        autoInsertedLineEnd = autoInsertedLineEnd.substr(1);
        autoInsertedBrackets--;
    };
    
    CstyleBehaviour.clearMaybeInsertedClosing = function() {
        maybeInsertedBrackets = 0;
        maybeInsertedRow = -1;
    };

    this.add("braces", "insertion", function (state, action, editor, session, text) {
        var cursor = editor.getCursorPosition();
        var line = session.doc.getLine(cursor.row);
        if (text == '{') {
            var selection = editor.getSelectionRange();
            var selected = session.doc.getTextRange(selection);
            if (selected !== "" && selected !== "{" && editor.getWrapBehavioursEnabled()) {
                return {
                    text: '{' + selected + '}',
                    selection: false
                };
            } else if (CstyleBehaviour.isSaneInsertion(editor, session)) {
                if (/[\]\}\)]/.test(line[cursor.column])) {
                    CstyleBehaviour.recordAutoInsert(editor, session, "}");
                    return {
                        text: '{}',
                        selection: [1, 1]
                    };
                } else {
                    CstyleBehaviour.recordMaybeInsert(editor, session, "{");
                    return {
                        text: '{',
                        selection: [1, 1]
                    };
                }
            }
        } else if (text == '}') {
            var rightChar = line.substring(cursor.column, cursor.column + 1);
            if (rightChar == '}') {
                var matching = session.$findOpeningBracket('}', {column: cursor.column + 1, row: cursor.row});
                if (matching !== null && CstyleBehaviour.isAutoInsertedClosing(cursor, line, text)) {
                    CstyleBehaviour.popAutoInsertedClosing();
                    return {
                        text: '',
                        selection: [1, 1]
                    };
                }
            }
        } else if (text == "\n" || text == "\r\n") {
            var closing = "";
            if (CstyleBehaviour.isMaybeInsertedClosing(cursor, line)) {
                closing = lang.stringRepeat("}", maybeInsertedBrackets);
                CstyleBehaviour.clearMaybeInsertedClosing();
            }
            var rightChar = line.substring(cursor.column, cursor.column + 1);
            if (rightChar == '}' || closing !== "") {
                var openBracePos = session.findMatchingBracket({row: cursor.row, column: cursor.column}, '}');
                if (!openBracePos)
                     return null;

                var indent = this.getNextLineIndent(state, line.substring(0, cursor.column), session.getTabString());
                var next_indent = this.$getIndent(line);

                return {
                    text: '\n' + indent + '\n' + next_indent + closing,
                    selection: [1, indent.length, 1, indent.length]
                };
            }
        }
    });

    this.add("braces", "deletion", function (state, action, editor, session, range) {
        var selected = session.doc.getTextRange(range);
        if (!range.isMultiLine() && selected == '{') {
            var line = session.doc.getLine(range.start.row);
            var rightChar = line.substring(range.end.column, range.end.column + 1);
            if (rightChar == '}') {
                range.end.column++;
                return range;
            } else {
                maybeInsertedBrackets--;
            }
        }
    });

    this.add("parens", "insertion", function (state, action, editor, session, text) {
        if (text == '(') {
            var selection = editor.getSelectionRange();
            var selected = session.doc.getTextRange(selection);
            if (selected !== "" && editor.getWrapBehavioursEnabled()) {
                return {
                    text: '(' + selected + ')',
                    selection: false
                };
            } else if (CstyleBehaviour.isSaneInsertion(editor, session)) {
                CstyleBehaviour.recordAutoInsert(editor, session, ")");
                return {
                    text: '()',
                    selection: [1, 1]
                };
            }
        } else if (text == ')') {
            var cursor = editor.getCursorPosition();
            var line = session.doc.getLine(cursor.row);
            var rightChar = line.substring(cursor.column, cursor.column + 1);
            if (rightChar == ')') {
                var matching = session.$findOpeningBracket(')', {column: cursor.column + 1, row: cursor.row});
                if (matching !== null && CstyleBehaviour.isAutoInsertedClosing(cursor, line, text)) {
                    CstyleBehaviour.popAutoInsertedClosing();
                    return {
                        text: '',
                        selection: [1, 1]
                    };
                }
            }
        }
    });

    this.add("parens", "deletion", function (state, action, editor, session, range) {
        var selected = session.doc.getTextRange(range);
        if (!range.isMultiLine() && selected == '(') {
            var line = session.doc.getLine(range.start.row);
            var rightChar = line.substring(range.start.column + 1, range.start.column + 2);
            if (rightChar == ')') {
                range.end.column++;
                return range;
            }
        }
    });

    this.add("brackets", "insertion", function (state, action, editor, session, text) {
        if (text == '[') {
            var selection = editor.getSelectionRange();
            var selected = session.doc.getTextRange(selection);
            if (selected !== "" && editor.getWrapBehavioursEnabled()) {
                return {
                    text: '[' + selected + ']',
                    selection: false
                };
            } else if (CstyleBehaviour.isSaneInsertion(editor, session)) {
                CstyleBehaviour.recordAutoInsert(editor, session, "]");
                return {
                    text: '[]',
                    selection: [1, 1]
                };
            }
        } else if (text == ']') {
            var cursor = editor.getCursorPosition();
            var line = session.doc.getLine(cursor.row);
            var rightChar = line.substring(cursor.column, cursor.column + 1);
            if (rightChar == ']') {
                var matching = session.$findOpeningBracket(']', {column: cursor.column + 1, row: cursor.row});
                if (matching !== null && CstyleBehaviour.isAutoInsertedClosing(cursor, line, text)) {
                    CstyleBehaviour.popAutoInsertedClosing();
                    return {
                        text: '',
                        selection: [1, 1]
                    };
                }
            }
        }
    });

    this.add("brackets", "deletion", function (state, action, editor, session, range) {
        var selected = session.doc.getTextRange(range);
        if (!range.isMultiLine() && selected == '[') {
            var line = session.doc.getLine(range.start.row);
            var rightChar = line.substring(range.start.column + 1, range.start.column + 2);
            if (rightChar == ']') {
                range.end.column++;
                return range;
            }
        }
    });

    this.add("string_dquotes", "insertion", function (state, action, editor, session, text) {
        if (text == '"' || text == "'") {
            var quote = text;
            var selection = editor.getSelectionRange();
            var selected = session.doc.getTextRange(selection);
            if (selected !== "" && selected !== "'" && selected != '"' && editor.getWrapBehavioursEnabled()) {
                return {
                    text: quote + selected + quote,
                    selection: false
                };
            } else {
                var cursor = editor.getCursorPosition();
                var line = session.doc.getLine(cursor.row);
                var leftChar = line.substring(cursor.column-1, cursor.column);
                if (leftChar == '\\') {
                    return null;
                }
                var tokens = session.getTokens(selection.start.row);
                var col = 0, token;
                var quotepos = -1; // Track whether we're inside an open quote.

                for (var x = 0; x < tokens.length; x++) {
                    token = tokens[x];
                    if (token.type == "string") {
                      quotepos = -1;
                    } else if (quotepos < 0) {
                      quotepos = token.value.indexOf(quote);
                    }
                    if ((token.value.length + col) > selection.start.column) {
                        break;
                    }
                    col += tokens[x].value.length;
                }
                if (!token || (quotepos < 0 && token.type !== "comment" && (token.type !== "string" || ((selection.start.column !== token.value.length+col-1) && token.value.lastIndexOf(quote) === token.value.length-1)))) {
                    if (!CstyleBehaviour.isSaneInsertion(editor, session))
                        return;
                    return {
                        text: quote + quote,
                        selection: [1,1]
                    };
                } else if (token && token.type === "string") {
                    var rightChar = line.substring(cursor.column, cursor.column + 1);
                    if (rightChar == quote) {
                        return {
                            text: '',
                            selection: [1, 1]
                        };
                    }
                }
            }
        }
    });

    this.add("string_dquotes", "deletion", function (state, action, editor, session, range) {
        var selected = session.doc.getTextRange(range);
        if (!range.isMultiLine() && (selected == '"' || selected == "'")) {
            var line = session.doc.getLine(range.start.row);
            var rightChar = line.substring(range.start.column + 1, range.start.column + 2);
            if (rightChar == selected) {
                range.end.column++;
                return range;
            }
        }
    });

};

oop.inherits(CstyleBehaviour, Behaviour);

exports.CstyleBehaviour = CstyleBehaviour;
});

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


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

var FoldMode = exports.FoldMode = function(commentRegex) {
    if (commentRegex) {
        this.foldingStartMarker = new RegExp(
            this.foldingStartMarker.source.replace(/\|[^|]*?$/, "|" + commentRegex.start)
        );
        this.foldingStopMarker = new RegExp(
            this.foldingStopMarker.source.replace(/\|[^|]*?$/, "|" + commentRegex.end)
        );
    }
};
oop.inherits(FoldMode, BaseFoldMode);

(function() {

    this.foldingStartMarker = /(\{|\[)[^\}\]]*$|^\s*(\/\*)/;
    this.foldingStopMarker = /^[^\[\{]*(\}|\])|^[\s\*]*(\*\/)/;

    this.getFoldWidgetRange = function(session, foldStyle, row) {
        var line = session.getLine(row);
        var match = line.match(this.foldingStartMarker);
        if (match) {
            var i = match.index;

            if (match[1])
                return this.openingBracketBlock(session, match[1], row, i);

            return session.getCommentFoldRange(row, i + match[0].length, 1);
        }

        if (foldStyle !== "markbeginend")
            return;

        var match = line.match(this.foldingStopMarker);
        if (match) {
            var i = match.index + match[0].length;

            if (match[1])
                return this.closingBracketBlock(session, match[1], row, i);

            return session.getCommentFoldRange(row, i, -1);
        }
    };

}).call(FoldMode.prototype);

});

15.1.1 by galaxyAbstractor Started implementation of a new codeviewer using Ace	1	define('ace/mode/golang', ['require', 'exports', 'module' , 'ace/lib/oop', 'ace/mode/text', 'ace/tokenizer', 'ace/mode/golang_highlight_rules', 'ace/mode/matching_brace_outdent', 'ace/mode/behaviour/cstyle', 'ace/mode/folding/cstyle'], function(require, exports, module) {
	2
	3	var oop = require("../lib/oop");
	4	var TextMode = require("./text").Mode;
	5	var Tokenizer = require("../tokenizer").Tokenizer;
	6	var GolangHighlightRules = require("./golang_highlight_rules").GolangHighlightRules;
	7	var MatchingBraceOutdent = require("./matching_brace_outdent").MatchingBraceOutdent;
	8	var CstyleBehaviour = require("./behaviour/cstyle").CstyleBehaviour;
	9	var CStyleFoldMode = require("./folding/cstyle").FoldMode;
	10
	11	var Mode = function() {
	12	this.$tokenizer = new Tokenizer(new GolangHighlightRules().getRules());
	13	this.$outdent = new MatchingBraceOutdent();
	14	this.foldingRules = new CStyleFoldMode();
	15	};
	16	oop.inherits(Mode, TextMode);
	17
	18	(function() {
	19
	20	this.lineCommentStart = "//";
	21	this.blockComment = {start: "/", end: "/"};
	22
	23	this.getNextLineIndent = function(state, line, tab) {
	24	var indent = this.$getIndent(line);
	25
	26	var tokenizedLine = this.$tokenizer.getLineTokens(line, state);
	27	var tokens = tokenizedLine.tokens;
	28	var endState = tokenizedLine.state;
	29
	30	if (tokens.length && tokens[tokens.length-1].type == "comment") {
	31	return indent;
	32	}
	33
	34	if (state == "start") {
	35	var match = line.match(/^.[\{\(\[]\s$/);
	36	if (match) {
	37	indent += tab;
	38	}
	39	}
	40
	41	return indent;
	42	};//end getNextLineIndent
	43
	44	this.checkOutdent = function(state, line, input) {
	45	return this.$outdent.checkOutdent(line, input);
	46	};
	47
	48	this.autoOutdent = function(state, doc, row) {
	49	this.$outdent.autoOutdent(doc, row);
	50	};
	51
	52	}).call(Mode.prototype);
	53
	54	exports.Mode = Mode;
	55	});
	56	define('ace/mode/golang_highlight_rules', ['require', 'exports', 'module' , 'ace/lib/oop', 'ace/mode/doc_comment_highlight_rules', 'ace/mode/text_highlight_rules'], function(require, exports, module) {
	57	var oop = require("../lib/oop");
	58	var DocCommentHighlightRules = require("./doc_comment_highlight_rules").DocCommentHighlightRules;
	59	var TextHighlightRules = require("./text_highlight_rules").TextHighlightRules;
	60
	61	var GolangHighlightRules = function() {
	62	var keywords = (
	63	"true\|else\|false\|break\|case\|return\|goto\|if\|const\|" +
	64	"continue\|struct\|default\|switch\|for\|" +
65	"func\|import\|package\|chan\|defer\|fallthrough\|go\|interface\|map\|range" +
66	"select\|type\|var"
67	);
68	var buildinConstants = ("nil\|true\|false\|iota");
69
70	var keywordMapper = this.createKeywordMapper({
71	"variable.language": "this",
72	"keyword": keywords,
73	"constant.language": buildinConstants
74	}, "identifier");
75
76	this.$rules = {
77	"start" : [
78	{
79	token : "comment",
80	regex : "\\/\\/.*$"
81	},
82	DocCommentHighlightRules.getStartRule("doc-start"),
83	{
84	token : "comment", // multi line comment
85	regex : "\\/\\*",
86	next : "comment"
87	}, {
88	token : "string", // single line
89	regex : '["](?:(?:\\\\.)\|(?:[^"\\\\]))*?["]'
90	}, {
91	token : "string", // multi line string start
92	regex : '["].*\\\\$',
93	next : "qqstring"
94	}, {
95	token : "string", // single line
96	regex : "['](?:(?:\\\\.)\|(?:[^'\\\\]))*?[']"
97	}, {
98	token : "string", // multi line string start
99	regex : "['].*\\\\$",
100	next : "qstring"
101	}, {
102	token : "constant.numeric", // hex
103	regex : "0[xX][0-9a-fA-F]+\\b"
104	}, {
105	token : "constant.numeric", // float
106	regex : "[+-]?\\d+(?:(?:\\.\\d*)?(?:[eE][+-]?\\d+)?)?\\b"
107	}, {
108	token : "constant", // <CONSTANT>
109	regex : "<[a-zA-Z0-9.]+>"
110	}, {
111	token : "keyword", // pre-compiler directivs
112	regex : "(?:#include\|#pragma\|#line\|#define\|#undef\|#ifdef\|#else\|#elif\|#endif\|#ifndef)"
113	}, {
114	token : keywordMapper,
115	regex : "[a-zA-Z_$][a-zA-Z0-9_$]*\\b"
116	}, {
117	token : "keyword.operator",
118	regex : "!\|\\$\|%\|&\|\\\|\\-\\-\|\\-\|\\+\\+\|\\+\|~\|==\|=\|!=\|<=\|>=\|<<=\|>>=\|>>>=\|<>\|<\|>\|!\|&&\|\\\|\\\|\|\\?\\:\|\\=\|%=\|\\+=\|\\-=\|&=\|\\^=\|\\b(?:in\|new\|delete\|typeof\|void)"
119	}, {
120	token : "punctuation.operator",
121	regex : "\\?\|\\:\|\\,\|\\;\|\\."
122	}, {
123	token : "paren.lparen",
124	regex : "[[({]"
125	}, {
126	token : "paren.rparen",
127	regex : "[\\])}]"
128	}, {
129	token : "text",
130	regex : "\\s+"
131	}
132	],
133	"comment" : [
134	{
135	token : "comment", // closing comment
136	regex : ".?\\\\/",
137	next : "start"
138	}, {
139	token : "comment", // comment spanning whole line
140	regex : ".+"
141	}
142	],
143	"qqstring" : [
144	{
145	token : "string",
146	regex : '(?:(?:\\\\.)\|(?:[^"\\\\]))*?"',
147	next : "start"
148	}, {
149	token : "string",
150	regex : '.+'
151	}
152	],
153	"qstring" : [
154	{
155	token : "string",
156	regex : "(?:(?:\\\\.)\|(?:[^'\\\\]))*?'",
157	next : "start"
158	}, {
159	token : "string",
160	regex : '.+'
161	}
162	]
163	};
164
165	this.embedRules(DocCommentHighlightRules, "doc-",
166	[ DocCommentHighlightRules.getEndRule("start") ]);
167	}
168	oop.inherits(GolangHighlightRules, TextHighlightRules);
169
170	exports.GolangHighlightRules = GolangHighlightRules;
171	});
172
173	define('ace/mode/doc_comment_highlight_rules', ['require', 'exports', 'module' , 'ace/lib/oop', 'ace/mode/text_highlight_rules'], function(require, exports, module) {
174
175
176	var oop = require("../lib/oop");
177	var TextHighlightRules = require("./text_highlight_rules").TextHighlightRules;
178
179	var DocCommentHighlightRules = function() {
180
181	this.$rules = {
182	"start" : [ {
183	token : "comment.doc.tag",
184	regex : "@[\\w\\d_]+" // TODO: fix email addresses
185	}, {
186	token : "comment.doc.tag",
187	regex : "\\bTODO\\b"
188	}, {
189	defaultToken : "comment.doc"
190	}]
191	};
192	};
193
194	oop.inherits(DocCommentHighlightRules, TextHighlightRules);
195
196	DocCommentHighlightRules.getStartRule = function(start) {
197	return {
198	token : "comment.doc", // doc comment
199	regex : "\\/\\(?=\\)",
200	next : start
201	};
202	};
203
204	DocCommentHighlightRules.getEndRule = function (start) {
205	return {
206	token : "comment.doc", // closing comment
207	regex : "\\*\\/",
208	next : start
209	};
210	};
211
212
213	exports.DocCommentHighlightRules = DocCommentHighlightRules;
214
215	});
216
217	define('ace/mode/matching_brace_outdent', ['require', 'exports', 'module' , 'ace/range'], function(require, exports, module) {
218
219
220	var Range = require("../range").Range;
221
222	var MatchingBraceOutdent = function() {};
223
224	(function() {
225
226	this.checkOutdent = function(line, input) {
227	if (! /^\s+$/.test(line))
228	return false;
229
230	return /^\s*\}/.test(input);
231	};
232
233	this.autoOutdent = function(doc, row) {
234	var line = doc.getLine(row);
235	var match = line.match(/^(\s*\})/);
236
237	if (!match) return 0;
238
239	var column = match[1].length;
240	var openBracePos = doc.findMatchingBracket({row: row, column: column});
241
242	if (!openBracePos \|\| openBracePos.row == row) return 0;
243
244	var indent = this.$getIndent(doc.getLine(openBracePos.row));
245	doc.replace(new Range(row, 0, row, column-1), indent);
246	};
247
248	this.$getIndent = function(line) {
249	return line.match(/^\s*/)[0];
250	};
251
252	}).call(MatchingBraceOutdent.prototype);
253
254	exports.MatchingBraceOutdent = MatchingBraceOutdent;
255	});
256
257	define('ace/mode/behaviour/cstyle', ['require', 'exports', 'module' , 'ace/lib/oop', 'ace/mode/behaviour', 'ace/token_iterator', 'ace/lib/lang'], function(require, exports, module) {
258
259
260	var oop = require("../../lib/oop");
261	var Behaviour = require("../behaviour").Behaviour;
262	var TokenIterator = require("../../token_iterator").TokenIterator;
263	var lang = require("../../lib/lang");
264
265	var SAFE_INSERT_IN_TOKENS =
266	["text", "paren.rparen", "punctuation.operator"];
267	var SAFE_INSERT_BEFORE_TOKENS =
268	["text", "paren.rparen", "punctuation.operator", "comment"];
269
270
271	var autoInsertedBrackets = 0;
272	var autoInsertedRow = -1;
273	var autoInsertedLineEnd = "";
274	var maybeInsertedBrackets = 0;
275	var maybeInsertedRow = -1;
276	var maybeInsertedLineStart = "";
277	var maybeInsertedLineEnd = "";
278
279	var CstyleBehaviour = function () {
280
281	CstyleBehaviour.isSaneInsertion = function(editor, session) {
282	var cursor = editor.getCursorPosition();
283	var iterator = new TokenIterator(session, cursor.row, cursor.column);
284	if (!this.$matchTokenType(iterator.getCurrentToken() \|\| "text", SAFE_INSERT_IN_TOKENS)) {
285	var iterator2 = new TokenIterator(session, cursor.row, cursor.column + 1);
286	if (!this.$matchTokenType(iterator2.getCurrentToken() \|\| "text", SAFE_INSERT_IN_TOKENS))
287	return false;
288	}
289	iterator.stepForward();
290	return iterator.getCurrentTokenRow() !== cursor.row \|\|
291	this.$matchTokenType(iterator.getCurrentToken() \|\| "text", SAFE_INSERT_BEFORE_TOKENS);
292	};
293
294	CstyleBehaviour.$matchTokenType = function(token, types) {
295	return types.indexOf(token.type \|\| token) > -1;
296	};
297
298	CstyleBehaviour.recordAutoInsert = function(editor, session, bracket) {
299	var cursor = editor.getCursorPosition();
300	var line = session.doc.getLine(cursor.row);
301	if (!this.isAutoInsertedClosing(cursor, line, autoInsertedLineEnd[0]))
302	autoInsertedBrackets = 0;
303	autoInsertedRow = cursor.row;
304	autoInsertedLineEnd = bracket + line.substr(cursor.column);
305	autoInsertedBrackets++;
306	};
307
308	CstyleBehaviour.recordMaybeInsert = function(editor, session, bracket) {
309	var cursor = editor.getCursorPosition();
310	var line = session.doc.getLine(cursor.row);
311	if (!this.isMaybeInsertedClosing(cursor, line))
312	maybeInsertedBrackets = 0;
313	maybeInsertedRow = cursor.row;
314	maybeInsertedLineStart = line.substr(0, cursor.column) + bracket;
315	maybeInsertedLineEnd = line.substr(cursor.column);
316	maybeInsertedBrackets++;
317	};
318
319	CstyleBehaviour.isAutoInsertedClosing = function(cursor, line, bracket) {
320	return autoInsertedBrackets > 0 &&
321	cursor.row === autoInsertedRow &&
322	bracket === autoInsertedLineEnd[0] &&
323	line.substr(cursor.column) === autoInsertedLineEnd;
324	};
325
326	CstyleBehaviour.isMaybeInsertedClosing = function(cursor, line) {
327	return maybeInsertedBrackets > 0 &&
328	cursor.row === maybeInsertedRow &&
329	line.substr(cursor.column) === maybeInsertedLineEnd &&
330	line.substr(0, cursor.column) == maybeInsertedLineStart;
331	};
332
333	CstyleBehaviour.popAutoInsertedClosing = function() {
334	autoInsertedLineEnd = autoInsertedLineEnd.substr(1);
335	autoInsertedBrackets--;
336	};
337
338	CstyleBehaviour.clearMaybeInsertedClosing = function() {
339	maybeInsertedBrackets = 0;
340	maybeInsertedRow = -1;
341	};
342
343	this.add("braces", "insertion", function (state, action, editor, session, text) {
344	var cursor = editor.getCursorPosition();
345	var line = session.doc.getLine(cursor.row);
346	if (text == '{') {
347	var selection = editor.getSelectionRange();
348	var selected = session.doc.getTextRange(selection);
349	if (selected !== "" && selected !== "{" && editor.getWrapBehavioursEnabled()) {
350	return {
351	text: '{' + selected + '}',
352	selection: false
353	};
354	} else if (CstyleBehaviour.isSaneInsertion(editor, session)) {
355	if (/[\]\}\)]/.test(line[cursor.column])) {
356	CstyleBehaviour.recordAutoInsert(editor, session, "}");
357	return {
358	text: '{}',
359	selection: [1, 1]
360	};
361	} else {
362	CstyleBehaviour.recordMaybeInsert(editor, session, "{");
363	return {
364	text: '{',
365	selection: [1, 1]
366	};
367	}
368	}
369	} else if (text == '}') {
370	var rightChar = line.substring(cursor.column, cursor.column + 1);
371	if (rightChar == '}') {
372	var matching = session.$findOpeningBracket('}', {column: cursor.column + 1, row: cursor.row});
373	if (matching !== null && CstyleBehaviour.isAutoInsertedClosing(cursor, line, text)) {
374	CstyleBehaviour.popAutoInsertedClosing();
375	return {
376	text: '',
377	selection: [1, 1]
378	};
379	}
380	}
381	} else if (text == "\n" \|\| text == "\r\n") {
382	var closing = "";
383	if (CstyleBehaviour.isMaybeInsertedClosing(cursor, line)) {
384	closing = lang.stringRepeat("}", maybeInsertedBrackets);
385	CstyleBehaviour.clearMaybeInsertedClosing();
386	}
387	var rightChar = line.substring(cursor.column, cursor.column + 1);
388	if (rightChar == '}' \|\| closing !== "") {
389	var openBracePos = session.findMatchingBracket({row: cursor.row, column: cursor.column}, '}');
390	if (!openBracePos)
391	return null;
392
393	var indent = this.getNextLineIndent(state, line.substring(0, cursor.column), session.getTabString());
394	var next_indent = this.$getIndent(line);
395
396	return {
397	text: '\n' + indent + '\n' + next_indent + closing,
398	selection: [1, indent.length, 1, indent.length]
399	};
400	}
401	}
402	});
403
404	this.add("braces", "deletion", function (state, action, editor, session, range) {
405	var selected = session.doc.getTextRange(range);
406	if (!range.isMultiLine() && selected == '{') {
407	var line = session.doc.getLine(range.start.row);
408	var rightChar = line.substring(range.end.column, range.end.column + 1);
409	if (rightChar == '}') {
410	range.end.column++;
411	return range;
412	} else {
413	maybeInsertedBrackets--;
414	}
415	}
416	});
417
418	this.add("parens", "insertion", function (state, action, editor, session, text) {
419	if (text == '(') {
420	var selection = editor.getSelectionRange();
421	var selected = session.doc.getTextRange(selection);
422	if (selected !== "" && editor.getWrapBehavioursEnabled()) {
423	return {
424	text: '(' + selected + ')',
425	selection: false
426	};
427	} else if (CstyleBehaviour.isSaneInsertion(editor, session)) {
428	CstyleBehaviour.recordAutoInsert(editor, session, ")");
429	return {
430	text: '()',
431	selection: [1, 1]
432	};
433	}
434	} else if (text == ')') {
435	var cursor = editor.getCursorPosition();
436	var line = session.doc.getLine(cursor.row);
437	var rightChar = line.substring(cursor.column, cursor.column + 1);
438	if (rightChar == ')') {
439	var matching = session.$findOpeningBracket(')', {column: cursor.column + 1, row: cursor.row});
440	if (matching !== null && CstyleBehaviour.isAutoInsertedClosing(cursor, line, text)) {
441	CstyleBehaviour.popAutoInsertedClosing();
442	return {
443	text: '',
444	selection: [1, 1]
445	};
446	}
447	}
448	}
449	});
450
451	this.add("parens", "deletion", function (state, action, editor, session, range) {
452	var selected = session.doc.getTextRange(range);
453	if (!range.isMultiLine() && selected == '(') {
454	var line = session.doc.getLine(range.start.row);
455	var rightChar = line.substring(range.start.column + 1, range.start.column + 2);
456	if (rightChar == ')') {
457	range.end.column++;
458	return range;
459	}
460	}
461	});
462
463	this.add("brackets", "insertion", function (state, action, editor, session, text) {
464	if (text == '[') {
465	var selection = editor.getSelectionRange();
466	var selected = session.doc.getTextRange(selection);
467	if (selected !== "" && editor.getWrapBehavioursEnabled()) {
468	return {
469	text: '[' + selected + ']',
470	selection: false
471	};
472	} else if (CstyleBehaviour.isSaneInsertion(editor, session)) {
473	CstyleBehaviour.recordAutoInsert(editor, session, "]");
474	return {
475	text: '[]',
476	selection: [1, 1]
477	};
478	}
479	} else if (text == ']') {
480	var cursor = editor.getCursorPosition();
481	var line = session.doc.getLine(cursor.row);
482	var rightChar = line.substring(cursor.column, cursor.column + 1);
483	if (rightChar == ']') {
484	var matching = session.$findOpeningBracket(']', {column: cursor.column + 1, row: cursor.row});
485	if (matching !== null && CstyleBehaviour.isAutoInsertedClosing(cursor, line, text)) {
486	CstyleBehaviour.popAutoInsertedClosing();
487	return {
488	text: '',
489	selection: [1, 1]
490	};
491	}
492	}
493	}
494	});
495
496	this.add("brackets", "deletion", function (state, action, editor, session, range) {
497	var selected = session.doc.getTextRange(range);
498	if (!range.isMultiLine() && selected == '[') {
499	var line = session.doc.getLine(range.start.row);
500	var rightChar = line.substring(range.start.column + 1, range.start.column + 2);
501	if (rightChar == ']') {
502	range.end.column++;
503	return range;
504	}
505	}
506	});
507
508	this.add("string_dquotes", "insertion", function (state, action, editor, session, text) {
509	if (text == '"' \|\| text == "'") {
510	var quote = text;
511	var selection = editor.getSelectionRange();
512	var selected = session.doc.getTextRange(selection);
513	if (selected !== "" && selected !== "'" && selected != '"' && editor.getWrapBehavioursEnabled()) {
514	return {
515	text: quote + selected + quote,
516	selection: false
517	};
518	} else {
519	var cursor = editor.getCursorPosition();
520	var line = session.doc.getLine(cursor.row);
521	var leftChar = line.substring(cursor.column-1, cursor.column);
522	if (leftChar == '\\') {
523	return null;
524	}
525	var tokens = session.getTokens(selection.start.row);
526	var col = 0, token;
527	var quotepos = -1; // Track whether we're inside an open quote.
528
529	for (var x = 0; x < tokens.length; x++) {
530	token = tokens[x];
531	if (token.type == "string") {
532	quotepos = -1;
533	} else if (quotepos < 0) {
534	quotepos = token.value.indexOf(quote);
535	}
536	if ((token.value.length + col) > selection.start.column) {
537	break;
538	}
539	col += tokens[x].value.length;
540	}
541	if (!token \|\| (quotepos < 0 && token.type !== "comment" && (token.type !== "string" \|\| ((selection.start.column !== token.value.length+col-1) && token.value.lastIndexOf(quote) === token.value.length-1)))) {
542	if (!CstyleBehaviour.isSaneInsertion(editor, session))
543	return;
544	return {
545	text: quote + quote,
546	selection: [1,1]
547	};
548	} else if (token && token.type === "string") {
549	var rightChar = line.substring(cursor.column, cursor.column + 1);
550	if (rightChar == quote) {
551	return {
552	text: '',
553	selection: [1, 1]
554	};
555	}
556	}
557	}
558	}
559	});
560
561	this.add("string_dquotes", "deletion", function (state, action, editor, session, range) {
562	var selected = session.doc.getTextRange(range);
563	if (!range.isMultiLine() && (selected == '"' \|\| selected == "'")) {
564	var line = session.doc.getLine(range.start.row);
565	var rightChar = line.substring(range.start.column + 1, range.start.column + 2);
566	if (rightChar == selected) {
567	range.end.column++;
568	return range;
569	}
570	}
571	});
572
573	};
574
575	oop.inherits(CstyleBehaviour, Behaviour);
576
577	exports.CstyleBehaviour = CstyleBehaviour;
578	});
579
580	define('ace/mode/folding/cstyle', ['require', 'exports', 'module' , 'ace/lib/oop', 'ace/range', 'ace/mode/folding/fold_mode'], function(require, exports, module) {
581
582
583	var oop = require("../../lib/oop");
584	var Range = require("../../range").Range;
585	var BaseFoldMode = require("./fold_mode").FoldMode;
586
587	var FoldMode = exports.FoldMode = function(commentRegex) {
588	if (commentRegex) {
589	this.foldingStartMarker = new RegExp(
590	this.foldingStartMarker.source.replace(/\\|[^\|]*?$/, "\|" + commentRegex.start)
591	);
592	this.foldingStopMarker = new RegExp(
593	this.foldingStopMarker.source.replace(/\\|[^\|]*?$/, "\|" + commentRegex.end)
594	);
595	}
596	};
597	oop.inherits(FoldMode, BaseFoldMode);
598
599	(function() {
600
601	this.foldingStartMarker = /(\{\|\[)[^\}\]]$\|^\s(\/\*)/;
602	this.foldingStopMarker = /^[^\[\{](\}\|\])\|^[\s\](\\/)/;
603
604	this.getFoldWidgetRange = function(session, foldStyle, row) {
605	var line = session.getLine(row);
606	var match = line.match(this.foldingStartMarker);
607	if (match) {
608	var i = match.index;
609
610	if (match[1])
611	return this.openingBracketBlock(session, match[1], row, i);
612
613	return session.getCommentFoldRange(row, i + match[0].length, 1);
614	}
615
616	if (foldStyle !== "markbeginend")
617	return;
618
619	var match = line.match(this.foldingStopMarker);
620	if (match) {
621	var i = match.index + match[0].length;
622
623	if (match[1])
624	return this.closingBracketBlock(session, match[1], row, i);
625
626	return session.getCommentFoldRange(row, i, -1);
627	}
628	};
629
630	}).call(FoldMode.prototype);
631
632	});