crm.clientright.ru/modules/ITS4YouStyles/resources/CodeMirror/mode/vb/vb.js

// CodeMirror, copyright (c) by Marijn Haverbeke and others
// Distributed under an MIT license: http://codemirror.net/LICENSE

(function (mod) {
    if (typeof exports == "object" && typeof module == "object") // CommonJS
        mod(require("../../lib/codemirror"));
    else if (typeof define == "function" && define.amd) // AMD
        define(["../../lib/codemirror"], mod);
    else // Plain browser env
        mod(CodeMirror);
})(function (CodeMirror) {
    "use strict";

    CodeMirror.defineMode("vb", function (conf, parserConf) {
        var ERRORCLASS = 'error';

        function wordRegexp(words) {
            return new RegExp("^((" + words.join(")|(") + "))\\b", "i");
        }

        var singleOperators = new RegExp("^[\\+\\-\\*/%&\\\\|\\^~<>!]");
        var singleDelimiters = new RegExp('^[\\(\\)\\[\\]\\{\\}@,:`=;\\.]');
        var doubleOperators = new RegExp("^((==)|(<>)|(<=)|(>=)|(<>)|(<<)|(>>)|(//)|(\\*\\*))");
        var doubleDelimiters = new RegExp("^((\\+=)|(\\-=)|(\\*=)|(%=)|(/=)|(&=)|(\\|=)|(\\^=))");
        var tripleDelimiters = new RegExp("^((//=)|(>>=)|(<<=)|(\\*\\*=))");
        var identifiers = new RegExp("^[_A-Za-z][_A-Za-z0-9]*");

        var openingKeywords = ['class', 'module', 'sub', 'enum', 'select', 'while', 'if', 'function', 'get', 'set', 'property', 'try'];
        var middleKeywords = ['else', 'elseif', 'case', 'catch'];
        var endKeywords = ['next', 'loop'];

        var operatorKeywords = ['and', 'or', 'not', 'xor', 'in'];
        var wordOperators = wordRegexp(operatorKeywords);
        var commonKeywords = ['as', 'dim', 'break', 'continue', 'optional', 'then', 'until',
            'goto', 'byval', 'byref', 'new', 'handles', 'property', 'return',
            'const', 'private', 'protected', 'friend', 'public', 'shared', 'static', 'true', 'false'];
        var commontypes = ['integer', 'string', 'double', 'decimal', 'boolean', 'short', 'char', 'float', 'single'];

        var keywords = wordRegexp(commonKeywords);
        var types = wordRegexp(commontypes);
        var stringPrefixes = '"';

        var opening = wordRegexp(openingKeywords);
        var middle = wordRegexp(middleKeywords);
        var closing = wordRegexp(endKeywords);
        var doubleClosing = wordRegexp(['end']);
        var doOpening = wordRegexp(['do']);

        var indentInfo = null;

        CodeMirror.registerHelper("hintWords", "vb", openingKeywords.concat(middleKeywords).concat(endKeywords)
            .concat(operatorKeywords).concat(commonKeywords).concat(commontypes));

        function indent(_stream, state) {
            state.currentIndent++;
        }

        function dedent(_stream, state) {
            state.currentIndent--;
        }

        // tokenizers
        function tokenBase(stream, state) {
            if (stream.eatSpace()) {
                return null;
            }

            var ch = stream.peek();

            // Handle Comments
            if (ch === "'") {
                stream.skipToEnd();
                return 'comment';
            }


            // Handle Number Literals
            if (stream.match(/^((&H)|(&O))?[0-9\.a-f]/i, false)) {
                var floatLiteral = false;
                // Floats
                if (stream.match(/^\d*\.\d+F?/i)) {
                    floatLiteral = true;
                } else if (stream.match(/^\d+\.\d*F?/)) {
                    floatLiteral = true;
                } else if (stream.match(/^\.\d+F?/)) {
                    floatLiteral = true;
                }

                if (floatLiteral) {
                    // Float literals may be "imaginary"
                    stream.eat(/J/i);
                    return 'number';
                }
                // Integers
                var intLiteral = false;
                // Hex
                if (stream.match(/^&H[0-9a-f]+/i)) {
                    intLiteral = true;
                }
                // Octal
                else if (stream.match(/^&O[0-7]+/i)) {
                    intLiteral = true;
                }
                // Decimal
                else if (stream.match(/^[1-9]\d*F?/)) {
                    // Decimal literals may be "imaginary"
                    stream.eat(/J/i);
                    // TODO - Can you have imaginary longs?
                    intLiteral = true;
                }
                // Zero by itself with no other piece of number.
                else if (stream.match(/^0(?![\dx])/i)) {
                    intLiteral = true;
                }
                if (intLiteral) {
                    // Integer literals may be "long"
                    stream.eat(/L/i);
                    return 'number';
                }
            }

            // Handle Strings
            if (stream.match(stringPrefixes)) {
                state.tokenize = tokenStringFactory(stream.current());
                return state.tokenize(stream, state);
            }

            // Handle operators and Delimiters
            if (stream.match(tripleDelimiters) || stream.match(doubleDelimiters)) {
                return null;
            }
            if (stream.match(doubleOperators)
                || stream.match(singleOperators)
                || stream.match(wordOperators)) {
                return 'operator';
            }
            if (stream.match(singleDelimiters)) {
                return null;
            }
            if (stream.match(doOpening)) {
                indent(stream, state);
                state.doInCurrentLine = true;
                return 'keyword';
            }
            if (stream.match(opening)) {
                if (!state.doInCurrentLine)
                    indent(stream, state);
                else
                    state.doInCurrentLine = false;
                return 'keyword';
            }
            if (stream.match(middle)) {
                return 'keyword';
            }

            if (stream.match(doubleClosing)) {
                dedent(stream, state);
                dedent(stream, state);
                return 'keyword';
            }
            if (stream.match(closing)) {
                dedent(stream, state);
                return 'keyword';
            }

            if (stream.match(types)) {
                return 'keyword';
            }

            if (stream.match(keywords)) {
                return 'keyword';
            }

            if (stream.match(identifiers)) {
                return 'variable';
            }

            // Handle non-detected items
            stream.next();
            return ERRORCLASS;
        }

        function tokenStringFactory(delimiter) {
            var singleline = delimiter.length == 1;
            var OUTCLASS = 'string';

            return function (stream, state) {
                while (!stream.eol()) {
                    stream.eatWhile(/[^'"]/);
                    if (stream.match(delimiter)) {
                        state.tokenize = tokenBase;
                        return OUTCLASS;
                    } else {
                        stream.eat(/['"]/);
                    }
                }
                if (singleline) {
                    if (parserConf.singleLineStringErrors) {
                        return ERRORCLASS;
                    } else {
                        state.tokenize = tokenBase;
                    }
                }
                return OUTCLASS;
            };
        }


        function tokenLexer(stream, state) {
            var style = state.tokenize(stream, state);
            var current = stream.current();

            // Handle '.' connected identifiers
            if (current === '.') {
                style = state.tokenize(stream, state);
                current = stream.current();
                if (style === 'variable') {
                    return 'variable';
                } else {
                    return ERRORCLASS;
                }
            }


            var delimiter_index = '[({'.indexOf(current);
            if (delimiter_index !== -1) {
                indent(stream, state);
            }
            if (indentInfo === 'dedent') {
                if (dedent(stream, state)) {
                    return ERRORCLASS;
                }
            }
            delimiter_index = '])}'.indexOf(current);
            if (delimiter_index !== -1) {
                if (dedent(stream, state)) {
                    return ERRORCLASS;
                }
            }

            return style;
        }

        var external = {
            electricChars: "dDpPtTfFeE ",
            startState: function () {
                return {
                    tokenize: tokenBase,
                    lastToken: null,
                    currentIndent: 0,
                    nextLineIndent: 0,
                    doInCurrentLine: false


                };
            },

            token: function (stream, state) {
                if (stream.sol()) {
                    state.currentIndent += state.nextLineIndent;
                    state.nextLineIndent = 0;
                    state.doInCurrentLine = 0;
                }
                var style = tokenLexer(stream, state);

                state.lastToken = {style: style, content: stream.current()};


                return style;
            },

            indent: function (state, textAfter) {
                var trueText = textAfter.replace(/^\s+|\s+$/g, '');
                if (trueText.match(closing) || trueText.match(doubleClosing) || trueText.match(middle)) return conf.indentUnit * (state.currentIndent - 1);
                if (state.currentIndent < 0) return 0;
                return state.currentIndent * conf.indentUnit;
            },

            lineComment: "'"
        };
        return external;
    });

    CodeMirror.defineMIME("text/x-vb", "vb");

});