bedrock_sass 0.1.9 → 0.2.0

data/assets/_vendor/ace/mode-csound_score.js

@@ -0,0 +1,454 @@
+define("ace/mode/csound_preprocessor_highlight_rules",["require","exports","module","ace/lib/oop","ace/mode/text_highlight_rules"], function(require, exports, module) {
+"use strict";
+
+var oop = require("../lib/oop");
+
+var TextHighlightRules = require("./text_highlight_rules").TextHighlightRules;
+
+var CsoundPreprocessorHighlightRules = function() {
+
+    this.semicolonComments = {
+        token : "comment.line.semicolon.csound",
+        regex : ";.*$"
+    };
+
+    this.comments = [
+        {
+            token : "punctuation.definition.comment.begin.csound",
+            regex : "/\\*",
+            push  : [
+                {
+                    token : "punctuation.definition.comment.end.csound",
+                    regex : "\\*/",
+                    next  : "pop"
+                }, {
+                    defaultToken: "comment.block.csound"
+                }
+            ]
+        }, {
+            token : "comment.line.double-slash.csound",
+            regex : "//.*$"
+        },
+        this.semicolonComments
+    ];
+
+    this.macroUses = [
+        {
+            token : ["entity.name.function.preprocessor.csound", "punctuation.definition.macro-parameter-value-list.begin.csound"],
+            regex : /(\$[A-Z_a-z]\w*\.?)(\()/,
+            next  : "macro parameter value list"
+        }, {
+            token : "entity.name.function.preprocessor.csound",
+            regex : /\$[A-Z_a-z]\w*(?:\.|\b)/
+        }
+    ];
+
+    this.numbers = [
+        {
+            token : "constant.numeric.float.csound",
+            regex : /(?:\d+[Ee][+-]?\d+)|(?:\d+\.\d*|\d*\.\d+)(?:[Ee][+-]?\d+)?/
+        }, {
+            token : ["storage.type.number.csound", "constant.numeric.integer.hexadecimal.csound"],
+            regex : /(0[Xx])([0-9A-Fa-f]+)/
+        }, {
+            token : "constant.numeric.integer.decimal.csound",
+            regex : /\d+/
+        }
+    ];
+
+    this.bracedStringContents = [
+        {
+            token : "constant.character.escape.csound",
+            regex : /\\(?:[\\abnrt"]|[0-7]{1,3})/
+        },
+        {
+            token : "constant.character.placeholder.csound",
+            regex : /%[#0\- +]*\d*(?:\.\d+)?[diuoxXfFeEgGaAcs]/
+        }, {
+            token : "constant.character.escape.csound",
+            regex : /%%/
+        }
+    ];
+
+    this.quotedStringContents = [
+        this.macroUses,
+        this.bracedStringContents
+    ];
+
+    var start = [
+        this.comments,
+
+        {
+            token : "keyword.preprocessor.csound",
+            regex : /#(?:e(?:nd(?:if)?|lse)\b|##)|@@?[ \t]*\d+/
+        }, {
+            token : "keyword.preprocessor.csound",
+            regex : /#include/,
+            push  : [
+                this.comments,
+                {
+                    token : "string.csound",
+                    regex : /([^ \t])(?:.*?\1)/,
+                    next  : "pop"
+                }
+            ]
+        }, {
+            token : "keyword.preprocessor.csound",
+            regex : /#[ \t]*define/,
+            next  : "define directive"
+        }, {
+            token : "keyword.preprocessor.csound",
+            regex : /#(?:ifn?def|undef)\b/,
+            next  : "macro directive"
+        },
+
+        this.macroUses
+    ];
+
+    this.$rules = {
+        "start": start,
+
+        "define directive": [
+            this.comments,
+            {
+                token : "entity.name.function.preprocessor.csound",
+                regex : /[A-Z_a-z]\w*/
+            }, {
+                token : "punctuation.definition.macro-parameter-name-list.begin.csound",
+                regex : /\(/,
+                next  : "macro parameter name list"
+            }, {
+                token : "punctuation.definition.macro.begin.csound",
+                regex : /#/,
+                next  : "macro body"
+            }
+        ],
+        "macro parameter name list": [
+            {
+                token : "variable.parameter.preprocessor.csound",
+                regex : /[A-Z_a-z]\w*/
+            }, {
+                token : "punctuation.definition.macro-parameter-name-list.end.csound",
+                regex : /\)/,
+                next  : "define directive"
+            }
+        ],
+        "macro body": [
+            {
+                token : "constant.character.escape.csound",
+                regex : /\\#/
+            }, {
+                token : "punctuation.definition.macro.end.csound",
+                regex : /#/,
+                next  : "start"
+            },
+            start
+        ],
+
+        "macro directive": [
+            this.comments,
+            {
+                token : "entity.name.function.preprocessor.csound",
+                regex : /[A-Z_a-z]\w*/,
+                next  : "start"
+            }
+        ],
+
+        "macro parameter value list": [
+            {
+                token : "punctuation.definition.macro-parameter-value-list.end.csound",
+                regex : /\)/,
+                next  : "start"
+            }, {
+                token : "punctuation.definition.string.begin.csound",
+                regex : /"/,
+                next  : "macro parameter value quoted string"
+            }, this.pushRule({
+                token : "punctuation.macro-parameter-value-parenthetical.begin.csound",
+                regex : /\(/,
+                next  : "macro parameter value parenthetical"
+            }), {
+                token : "punctuation.macro-parameter-value-separator.csound",
+                regex : "[#']"
+            }
+        ],
+        "macro parameter value quoted string": [
+            {
+                token : "constant.character.escape.csound",
+                regex : /\\[#'()]/
+            }, {
+                token : "invalid.illegal.csound",
+                regex : /[#'()]/
+            }, {
+                token : "punctuation.definition.string.end.csound",
+                regex : /"/,
+                next  : "macro parameter value list"
+            },
+            this.quotedStringContents,
+            {
+                defaultToken: "string.quoted.csound"
+            }
+        ],
+        "macro parameter value parenthetical": [
+            {
+                token : "constant.character.escape.csound",
+                regex : /\\\)/
+            }, this.popRule({
+                token : "punctuation.macro-parameter-value-parenthetical.end.csound",
+                regex : /\)/
+            }), this.pushRule({
+                token : "punctuation.macro-parameter-value-parenthetical.begin.csound",
+                regex : /\(/,
+                next  : "macro parameter value parenthetical"
+            }),
+            start
+        ]
+    };
+};
+
+oop.inherits(CsoundPreprocessorHighlightRules, TextHighlightRules);
+
+(function() {
+
+    this.pushRule = function(params) {
+        return {
+            regex : params.regex, onMatch: function(value, currentState, stack, line) {
+                if (stack.length === 0)
+                    stack.push(currentState);
+                if (Array.isArray(params.next)) {
+                    for (var i = 0; i < params.next.length; i++) {
+                        stack.push(params.next[i]);
+                    }
+                } else {
+                    stack.push(params.next);
+                }
+                this.next = stack[stack.length - 1];
+                return params.token;
+            },
+            get next() { return Array.isArray(params.next) ? params.next[params.next.length - 1] : params.next; },
+            set next(next) {
+                if (Array.isArray(params.next)) {
+                    var oldNext = params.next[params.next.length - 1];
+                    var oldNextIndex = oldNext.length - 1;
+                    var newNextIndex = next.length - 1;
+                    if (newNextIndex > oldNextIndex) {
+                        while (oldNextIndex >= 0 && newNextIndex >= 0) {
+                            if (oldNext.charAt(oldNextIndex) !== next.charAt(newNextIndex)) {
+                                var prefix = next.substr(0, newNextIndex);
+                                for (var i = 0; i < params.next.length; i++) {
+                                    params.next[i] = prefix + params.next[i];
+                                }
+                                break;
+                            }
+                            oldNextIndex--;
+                            newNextIndex--;
+                        }
+                    }
+                } else {
+                    params.next = next;
+                }
+            },
+            get token() { return params.token; }
+        };
+    };
+
+    this.popRule = function(params) {
+        return {
+            regex : params.regex, onMatch: function(value, currentState, stack, line) {
+                stack.pop();
+                if (params.next) {
+                    stack.push(params.next);
+                    this.next = stack[stack.length - 1];
+                } else {
+                    this.next = stack.length > 1 ? stack[stack.length - 1] : stack.pop();
+                }
+                return params.token;
+            }
+        };
+    };
+
+}).call(CsoundPreprocessorHighlightRules.prototype);
+
+exports.CsoundPreprocessorHighlightRules = CsoundPreprocessorHighlightRules;
+});
+
+define("ace/mode/csound_score_highlight_rules",["require","exports","module","ace/lib/oop","ace/mode/csound_preprocessor_highlight_rules"], function(require, exports, module) {
+"use strict";
+
+var oop = require("../lib/oop");
+
+var CsoundPreprocessorHighlightRules = require("./csound_preprocessor_highlight_rules").CsoundPreprocessorHighlightRules;
+
+var CsoundScoreHighlightRules = function() {
+
+    CsoundPreprocessorHighlightRules.call(this);
+
+    this.quotedStringContents.push({
+        token : "invalid.illegal.csound-score",
+        regex : /[^"]*$/
+    });
+
+    var start = this.$rules.start;
+    start.push(
+        {
+            token : "keyword.control.csound-score",
+            regex : /[abCdefiqstvxy]/
+        }, {
+            token : "invalid.illegal.csound-score",
+            regex : /w/
+        }, {
+            token : "constant.numeric.language.csound-score",
+            regex : /z/
+        }, {
+            token : ["keyword.control.csound-score", "constant.numeric.integer.decimal.csound-score"],
+            regex : /([nNpP][pP])(\d+)/
+        }, {
+            token : "keyword.other.csound-score",
+            regex : /[mn]/,
+            push  : [
+                {
+                    token : "empty",
+                    regex : /$/,
+                    next  : "pop"
+                },
+                this.comments,
+                {
+                    token : "entity.name.label.csound-score",
+                    regex : /[A-Z_a-z]\w*/
+                }
+            ]
+        }, {
+            token : "keyword.preprocessor.csound-score",
+            regex : /r\b/,
+            next  : "repeat section"
+        },
+
+        this.numbers,
+
+        {
+            token : "keyword.operator.csound-score",
+            regex : "[!+\\-*/^%&|<>#~.]"
+        },
+
+        this.pushRule({
+            token : "punctuation.definition.string.begin.csound-score",
+            regex : /"/,
+            next  : "quoted string"
+        }),
+
+        this.pushRule({
+            token : "punctuation.braced-loop.begin.csound-score",
+            regex : /{/,
+            next  : "loop after left brace"
+        })
+    );
+
+    this.addRules({
+        "repeat section": [
+            {
+                token : "empty",
+                regex : /$/,
+                next  : "start"
+            },
+            this.comments,
+            {
+                token : "constant.numeric.integer.decimal.csound-score",
+                regex : /\d+/,
+                next  : "repeat section before label"
+            }
+        ],
+        "repeat section before label": [
+            {
+                token : "empty",
+                regex : /$/,
+                next  : "start"
+            },
+            this.comments,
+            {
+                token : "entity.name.label.csound-score",
+                regex : /[A-Z_a-z]\w*/,
+                next  : "start"
+            }
+        ],
+
+        "quoted string": [
+            this.popRule({
+                token : "punctuation.definition.string.end.csound-score",
+                regex : /"/
+            }),
+            this.quotedStringContents,
+            {
+                defaultToken: "string.quoted.csound-score"
+            }
+        ],
+
+        "loop after left brace": [
+            this.popRule({
+                token : "constant.numeric.integer.decimal.csound-score",
+                regex : /\d+/,
+                next  : "loop after repeat count"
+            }),
+            this.comments,
+            {
+                token : "invalid.illegal.csound",
+                regex : /\S.*/
+            }
+        ],
+        "loop after repeat count": [
+            this.popRule({
+                token : "entity.name.function.preprocessor.csound-score",
+                regex : /[A-Z_a-z]\w*\b/,
+                next  : "loop after macro name"
+            }),
+            this.comments,
+            {
+                token : "invalid.illegal.csound",
+                regex : /\S.*/
+            }
+        ],
+        "loop after macro name": [
+            start,
+            this.popRule({
+                token : "punctuation.braced-loop.end.csound-score",
+                regex : /}/
+            })
+        ]
+    });
+
+    this.normalizeRules();
+};
+
+oop.inherits(CsoundScoreHighlightRules, CsoundPreprocessorHighlightRules);
+
+exports.CsoundScoreHighlightRules = CsoundScoreHighlightRules;
+});
+
+define("ace/mode/csound_score",["require","exports","module","ace/lib/oop","ace/mode/text","ace/mode/csound_score_highlight_rules"], function(require, exports, module) {
+"use strict";
+
+var oop = require("../lib/oop");
+var TextMode = require("./text").Mode;
+var CsoundScoreHighlightRules = require("./csound_score_highlight_rules").CsoundScoreHighlightRules;
+
+var Mode = function() {
+    this.HighlightRules = CsoundScoreHighlightRules;
+};
+oop.inherits(Mode, TextMode);
+
+(function() {
+
+    this.lineCommentStart = ";";
+    this.blockComment = {start: "/*", end: "*/"};
+
+}).call(Mode.prototype);
+
+exports.Mode = Mode;
+});
+                (function() {
+                    window.require(["ace/mode/csound_score"], function(m) {
+                        if (typeof module == "object" && typeof exports == "object" && module) {
+                            module.exports = m;
+                        }
+                    });
+                })();
+