@openui5/sap.ui.codeeditor 1.133.1 → 1.135.0

package/src/sap/ui/codeeditor/js/ace/mode-basic.js

@@ -0,0 +1,201 @@
+ace.define("ace/mode/basic_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 BasicHighlightRules = function () {
+    var keywordMapper = this.createKeywordMapper({
+        "keyword.control": "FOR|TO|NEXT|GOSUB|RETURN|IF|THEN|ELSE|GOTO|ON|WHILE|WEND|TRON|TROFF",
+        "entity.name": "Auto|Call|Chain|Clear|Close|Common|Cont|Data|MERGE|ALL|Delete|DIM|EDIT|END|ERASE|ERROR|FIELD|"
+            + "GET|INPUT|KILL|LET|LIST|LLIST|LOAD|LSET|RSET|MERGE|NEW|NULL|OPEN|OUT|POKE|PRINT|PUT|RANDOMIZE|READ|"
+            + "RENUM|RESTORE|RESUME|RUN|SAVE|STOP|SWAP|WAIT|WIDTH",
+        "keyword.operator": "Mod|And|Not|Or|Xor|Eqv|Imp",
+        "support.function": "ABS|ASC|ATN|CDBL|CINT|COS|CSNG|CVI|CVS|CVD|EOF|EXP|FIX|FRE|INP|INSTR|INT|LEN|LOC|LOG|LPOS|"
+            + "PEEK|POS|RND|SGN|SIN|SPC|SQR|TAB|TAN|USR|VAL|VARPTR"
+    }, "identifier", true);
+    this.$rules = {
+        "start": [
+            {
+                token: "string",
+                regex: /"(?:\\.|[^"\\])*"/
+            },
+            {
+                token: "support.function",
+                regex: /(HEX|CHR|INPUT|LEFT|MID|MKI|MKS|MKD|OCT|RIGHT|SPACE|STR|STRING)\$/
+            }, {
+                token: "entity.name",
+                regex: /(?:DEF\s(?:SEG|USR|FN[a-zA-Z]+)|LINE\sINPUT|L?PRINT#?(?:\sUSING)?|MID\$|ON\sERROR\sGOTO|OPTION\sBASE|WRITE#?|DATE\$|INKEY\$|TIME\$)/
+            }, {
+                token: "variable",
+                regex: /[a-zA-Z][a-zA-Z0-9_]{0,38}[$%!#]?(?=\s*=)/
+            }, {
+                token: "keyword.operator",
+                regex: /\\|=|\^|\*|\/|\+|\-|<|>|-/
+            }, {
+                token: "paren.lparen",
+                regex: /[([]/
+            }, {
+                token: "paren.rparen",
+                regex: /[\)\]]/
+            }, {
+                token: "constant.numeric",
+                regex: /[+-]?\d+(\.\d+)?([ED][+-]?\d+)?(?:[!#])?/
+            }, {
+                token: "constant.numeric", //hexal, octal
+                regex: /&[HO]?[0-9A-F]+/
+            }, {
+                token: "comment",
+                regex: /REM\s+.*$/
+            }, {
+                regex: "\\w+",
+                token: keywordMapper
+            }, {
+                token: "punctiation",
+                regex: /[,;]/
+            }
+        ]
+    };
+    this.normalizeRules();
+};
+oop.inherits(BasicHighlightRules, TextHighlightRules);
+exports.BasicHighlightRules = BasicHighlightRules;
+
+});
+
+ace.define("ace/mode/folding/basic",["require","exports","module","ace/lib/oop","ace/mode/folding/fold_mode","ace/range","ace/token_iterator"], function(require, exports, module){"use strict";
+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.indentKeywords = {
+        "tron": 1,
+        "while": 1,
+        "for": 1,
+        "troff": -1,
+        "wend": -1,
+        "next": -1
+    };
+    this.foldingStartMarker = /(?:\s|^)(tron|while|for)\b/i;
+    this.foldingStopMarker = /(?:\b)(troff|next|wend)\b/i;
+    this.getFoldWidgetRange = 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 = (isEnd) ? this.foldingStopMarker.exec(line) : this.foldingStartMarker.exec(line);
+            var keyword = match && match[1].toLowerCase();
+            if (keyword) {
+                var type = session.getTokenAt(row, match.index + 2).type;
+                if (type === "keyword.control")
+                    return this.basicBlock(session, row, match.index + 2);
+            }
+        }
+    };
+    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 = this.foldingStartMarker.exec(line);
+            var keyword = match && match[1].toLowerCase();
+            if (keyword) {
+                var type = session.getTokenAt(row, match.index + 2).type;
+                if (type == "keyword.control") {
+                    return "start";
+                }
+            }
+        }
+        if (foldStyle != "markbeginend" || !isEnd || isStart && isEnd)
+            return "";
+        var match = line.match(this.foldingStopMarker);
+        var keyword = match && match[1].toLowerCase();
+        if (this.indentKeywords[keyword]) {
+            if (session.getTokenAt(row, match.index + 2).type === "keyword.control")
+                return "end";
+        }
+        return "";
+    };
+    this.basicBlock = function (session, row, column, tokenRange) {
+        var stream = new TokenIterator(session, row, column);
+        var token = stream.getCurrentToken();
+        if (!token || token.type != "keyword.control")
+            return;
+        var val = token.value.toLowerCase();
+        var stack = [val];
+        var dir = this.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()) {
+            val = token.value.toLowerCase();
+            if (token.type !== "keyword.control" || !this.indentKeywords[val])
+                continue;
+            var level = dir * this.indentKeywords[val];
+            if (level > 0) {
+                stack.unshift(val);
+            }
+            else if (level <= 0) {
+                stack.shift();
+            }
+            if (stack.length === 0) {
+                break;
+            }
+        }
+        if (!token)
+            return null;
+        if (tokenRange)
+            return stream.getCurrentTokenRange();
+        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);
+
+});
+
+ace.define("ace/mode/basic",["require","exports","module","ace/lib/oop","ace/mode/text","ace/mode/basic_highlight_rules","ace/mode/folding/basic"], function(require, exports, module){"use strict";
+var oop = require("../lib/oop");
+var TextMode = require("./text").Mode;
+var BasicHighlightRules = require("./basic_highlight_rules").BasicHighlightRules;
+var FoldMode = require("./folding/basic").FoldMode;
+var Mode = function () {
+    this.HighlightRules = BasicHighlightRules;
+    this.foldingRules = new FoldMode();
+    this.$behaviour = this.$defaultBehaviour;
+    this.indentKeywords = this.foldingRules.indentKeywords;
+};
+oop.inherits(Mode, TextMode);
+(function () {
+    this.lineCommentStart = ["REM"];
+    this.getMatching = function (session, row, column, tokenRange) {
+        if (row == undefined) {
+            var pos = session.selection.lead;
+            column = pos.column;
+            row = pos.row;
+        }
+        if (tokenRange == undefined)
+            tokenRange = true;
+        var startToken = session.getTokenAt(row, column);
+        if (startToken) {
+            var val = startToken.value.toLowerCase();
+            if (val in this.indentKeywords)
+                return this.foldingRules.basicBlock(session, row, column, tokenRange);
+        }
+    };
+    this.$id = "ace/mode/basic";
+}).call(Mode.prototype);
+exports.Mode = Mode;
+
+});                (function() {
+                    ace.require(["ace/mode/basic"], function(m) {
+                        if (typeof module == "object" && typeof exports == "object" && module) {
+                            module.exports = m;
+                        }
+                    });
+                })();
+            

package/src/sap/ui/codeeditor/js/ace/mode-c9search.js

@@ -120,7 +120,7 @@ var C9SearchHighlightRules = function () {
                 next: "numbers"
             },
             {
-                token: "string",
+                token: "string", // single line
                 regex: "^\\S:?[^:]+",
                 next: "numbers"
             }

package/src/sap/ui/codeeditor/js/ace/mode-c_cpp.js

@@ -8,7 +8,7 @@ var DocCommentHighlightRules = function () {
                 token: "comment.doc.tag",
                 regex: "@\\w+(?=\\s|$)"
             }, DocCommentHighlightRules.getTagRule(), {
-                defaultToken: "comment.doc",
+                defaultToken: "comment.doc.body",
                 caseInsensitive: true
             }
         ]
@@ -23,14 +23,14 @@ DocCommentHighlightRules.getTagRule = function (start) {
 };
 DocCommentHighlightRules.getStartRule = function (start) {
     return {
-        token: "comment.doc",
-        regex: "\\/\\*(?=\\*)",
+        token: "comment.doc", // doc comment
+        regex: /\/\*\*(?!\/)/,
         next: start
     };
 };
 DocCommentHighlightRules.getEndRule = function (start) {
     return {
-        token: "comment.doc",
+        token: "comment.doc", // closing comment
         regex: "\\*\\/",
         next: start
     };
@@ -88,11 +88,11 @@ var c_cppHighlightRules = function (extraKeywords) {
             },
             DocCommentHighlightRules.getStartRule("doc-start"),
             {
-                token: "comment",
+                token: "comment", // multi line comment
                 regex: "\\/\\*",
                 next: "comment"
             }, {
-                token: "string",
+                token: "string", // character
                 regex: "'(?:" + escapeRe + "|.)?'"
             }, {
                 token: "string.start",
@@ -114,17 +114,17 @@ var c_cppHighlightRules = function (extraKeywords) {
                     { defaultToken: "string" }
                 ]
             }, {
-                token: "constant.numeric",
+                token: "constant.numeric", // hex
                 regex: "0[xX][0-9a-fA-F]+(L|l|UL|ul|u|U|F|f|ll|LL|ull|ULL)?\\b"
             }, {
-                token: "constant.numeric",
+                token: "constant.numeric", // float
                 regex: "[+-]?\\d+(?:(?:\\.\\d*)?(?:[eE][+-]?\\d+)?)?(L|l|UL|ul|u|U|F|f|ll|LL|ull|ULL)?\\b"
             }, {
-                token: "keyword",
+                token: "keyword", // pre-compiler directives
                 regex: "#\\s*(?:include|import|pragma|line|define|undef)\\b",
                 next: "directive"
             }, {
-                token: "keyword",
+                token: "keyword", // special case pre-compiler directive
                 regex: "#\\s*(?:endif|if|ifdef|else|elif|ifndef)\\b"
             }, {
                 token: keywordMapper,
@@ -148,7 +148,7 @@ var c_cppHighlightRules = function (extraKeywords) {
         ],
         "comment": [
             {
-                token: "comment",
+                token: "comment", // closing comment
                 regex: "\\*\\/",
                 next: "start"
             }, {
@@ -183,12 +183,12 @@ var c_cppHighlightRules = function (extraKeywords) {
                 next: "start"
             },
             {
-                token: "constant.other",
+                token: "constant.other", // single line
                 regex: '\\s*["](?:(?:\\\\.)|(?:[^"\\\\]))*?["]',
                 next: "start"
             },
             {
-                token: "constant.other",
+                token: "constant.other", // single line
                 regex: "\\s*['](?:(?:\\\\.)|(?:[^'\\\\]))*?[']",
                 next: "start"
             },

package/src/sap/ui/codeeditor/js/ace/mode-clojure.js

@@ -84,38 +84,38 @@ var ClojureHighlightRules = function () {
                 token: "comment",
                 regex: ";.*$"
             }, {
-                token: "keyword",
+                token: "keyword", //parens
                 regex: "[\\(|\\)]"
             }, {
-                token: "keyword",
+                token: "keyword", //lists
                 regex: "[\\'\\(]"
             }, {
-                token: "keyword",
+                token: "keyword", //vectors
                 regex: "[\\[|\\]]"
             }, {
-                token: "string.regexp",
+                token: "string.regexp", //Regular Expressions
                 regex: '#"',
                 next: "regex"
             }, {
-                token: "keyword",
+                token: "keyword", //sets and maps
                 regex: "[\\{|\\}|\\#\\{|\\#\\}]"
             }, {
-                token: "keyword",
+                token: "keyword", // ampersands
                 regex: '[\\&]'
             }, {
-                token: "keyword",
+                token: "keyword", // metadata
                 regex: '[\\#\\^\\{]'
             }, {
-                token: "keyword",
+                token: "keyword", // anonymous fn syntactic sugar
                 regex: '[\\%]'
             }, {
-                token: "keyword",
+                token: "keyword", // deref reader macro
                 regex: '[@]'
             }, {
-                token: "constant.numeric",
+                token: "constant.numeric", // hex
                 regex: "0[xX][0-9a-fA-F]+\\b"
             }, {
-                token: "constant.numeric",
+                token: "constant.numeric", // float
                 regex: "[+-]?\\d+(?:(?:\\.\\d*)?(?:[eE][+-]?\\d+)?)?\\b"
             }, {
                 token: "constant.language",
@@ -124,11 +124,11 @@ var ClojureHighlightRules = function () {
                 token: keywordMapper,
                 regex: "[a-zA-Z_$][a-zA-Z0-9_$\\-]*\\b"
             }, {
-                token: "string",
+                token: "string", // single line
                 regex: '"',
                 next: "string"
             }, {
-                token: "constant",
+                token: "constant", // symbol
                 regex: /:[^()\[\]{}'"\^%`,;\s]+/
             }
         ],

package/src/sap/ui/codeeditor/js/ace/mode-cobol.js

@@ -26,13 +26,13 @@ var CobolHighlightRules = function () {
                 token: "comment",
                 regex: "\\*.*$"
             }, {
-                token: "string",
+                token: "string", // " string
                 regex: '".*?"'
             }, {
-                token: "string",
+                token: "string", // ' string
                 regex: "'.*?'"
             }, {
-                token: "constant.numeric",
+                token: "constant.numeric", // float
                 regex: "[+-]?\\d+(?:(?:\\.\\d*)?(?:[eE][+-]?\\d+)?)?\\b"
             }, {
                 token: keywordMapper,