笙默考试管理系统-MyExamTest----codemirror（68）

笙默考试管理系统-MyExamTest----codemirror（68）

  

目录

一、 笙默考试管理系统-MyExamTest----codemirror

三、 笙默考试管理系统-MyExamTest----codemirror

四、 笙默考试管理系统-MyExamTest----codemirror

五、 笙默考试管理系统-MyExamTest----codemirror

• 笙默考试管理系统-MyExamTest----codemirror

  }

    // Combinator utils

    var cx = {state: null, column: null, marked: null, cc: null};

    function pass() {

        for (var i = arguments.length - 1; i >= 0; i--) cx.cc.push(arguments[i]);

    }

    function cont() {

        pass.apply(null, arguments);

        return true;

    }

    function register(varname) {

        var state = cx.state;

        if (state.context) {

•        笙默考试管理系统-MyExamTest----codemirror

  

   cx.marked = "def";

            for (var v = state.localVars; v; v = v.next)

                if (v.name == varname) return;

            state.localVars = {name: varname, next: state.localVars};

        }

    }

    // Combinators

    var defaultVars = {name: "this", next: {name: "arguments"}};

    function pushcontext() {

        if (!cx.state.context) cx.state.localVars = defaultVars;

        cx.state.context = {prev: cx.state.context, vars: cx.state.localVars};

    }

    function popcontext() {

        cx.state.localVars = cx.state.context.vars;

        cx.state.context = cx.state.context.prev;

}

• 笙默考试管理系统-MyExamTest----codemirror

    function pushlex(type, info) {

        var result = function() {

            var state = cx.state;

            state.lexical = new JSLexical(state.indented, cx.stream.column(), type, null, state.lexical, info)

        };

        result.lex = true;

        return result;

    }

    function poplex() {

        var state = cx.state;

        if (state.lexical.prev) {

            if (state.lexical.type == ")")

                state.indented = state.lexical.indented;

            state.lexical = state.lexical.prev;

        }

}

• 笙默考试管理系统-MyExamTest----codemirror

    poplex.lex = true;

    function expect(wanted) {

        return function expecting(type) {

            if (type == wanted) return cont();

            else if (wanted == ";") return pass();

            else return cont(arguments.callee);

        };

    }

    function statement(type) {

        if (type == "var") return cont(pushlex("vardef"), vardef1, expect(";"), poplex);

        if (type == "keyword a") return cont(pushlex("form"), expression, statement, poplex);

        if (type == "keyword b") return cont(pushlex("form"), statement, poplex);

        if (type == "{") return cont(pushlex("}"), block, poplex);

        if (type == ";") return cont();

        if (type == "function") return cont(functiondef);

        if (type == "for") return cont(pushlex("form"), expect("("), pushlex(")"), forspec1, expect(")"),

            poplex, statement, poplex);

        if (type == "variable") return cont(pushlex("stat"), maybelabel);

• 笙默考试管理系统-MyExamTest----codemirror

        if (type == "switch") return cont(pushlex("form"), expression, pushlex("}", "switch"), expect("{"),

            block, poplex, poplex);

        if (type == "case") return cont(expression, expect(":"));

        if (type == "default") return cont(expect(":"));

        if (type == "catch") return cont(pushlex("form"), pushcontext, expect("("), funarg, expect(")"),

            statement, poplex, popcontext);

        return pass(pushlex("stat"), expression, expect(";"), poplex);

    }

    function expression(type) {

        if (atomicTypes.hasOwnProperty(type)) return cont(maybeoperator);

        if (type == "function") return cont(functiondef);

        if (type == "keyword c") return cont(maybeexpression);

        if (type == "(") return cont(pushlex(")"), expression, expect(")"), poplex, maybeoperator);

        if (type == "operator") return cont(expression);

        if (type == "[") return cont(pushlex("]"), commasep(expression, "]"), poplex, maybeoperator);

        if (type == "{") return cont(pushlex("}"), commasep(objprop, "}"), poplex, maybeoperator);

        return cont();

    }

    function maybeexpression(type) {

        if (type.match(/[;\}\)\],]/)) return pass();

        return pass(expression);

    }

    function maybeoperator(type, value) {

        if (type == "operator" && /\+\+|--/.test(value)) return cont(maybeoperator);

        if (type == "operator") return cont(expression);

        if (type == ";") return;

        if (type == "(") return cont(pushlex(")"), commasep(expression, ")"), poplex, maybeoperator);

        if (type == ".") return cont(property, maybeoperator);

        if (type == "[") return cont(pushlex("]"), expression, expect("]"), poplex, maybeoperator);

    }

    function maybelabel(type) {

        if (type == ":") return cont(poplex, statement);

        return pass(maybeoperator, expect(";"), poplex);

    }

    function property(type) {

        if (type == "variable") {cx.marked = "property"; return cont();}

    }

    function objprop(type) {

        if (type == "variable") cx.marked = "property";

        if (atomicTypes.hasOwnProperty(type)) return cont(expect(":"), expression);

    }

    function commasep(what, end) {

        function proceed(type) {

            if (type == ",") return cont(what, proceed);

            if (type == end) return cont();

            return cont(expect(end));

        }

        return function commaSeparated(type) {

            if (type == end) return cont();

            else return pass(what, proceed);

        };