@abaplint/core 2.119.59 → 2.119.60

package/build/src/abap/1_lexer/lexer.js

@@ -12,6 +12,37 @@ const ModeStr = 3;
 const ModeTemplate = 4;
 const ModeComment = 5;
 const ModePragma = 6;
+// character codes, used for integer comparisons in the hot loop
+const EOF = -1; // no character (start/end of file)
+const CH_TAB = 9; // "\t"
+const CH_NL = 10; // "\n"
+const CH_SPACE = 32; // " "
+const CH_DQUOTE = 34; // "\""
+const CH_HASH = 35; // "#"
+const CH_QUOTE = 39; // "'"
+const CH_STAR = 42; // "*"
+const CH_DASH = 45; // "-"
+const CH_COMMA = 44; // ","
+const CH_DOT = 46; // "."
+const CH_COLON = 58; // ":"
+const CH_EQUALS = 61; // "="
+const CH_GT = 62; // ">"
+const CH_AT = 64; // "@"
+const CH_BACKSLASH = 92; // "\\"
+const CH_BACKTICK = 96; // "`"
+const CH_LBRACE = 123; // "{"
+const CH_PIPE = 124; // "|"
+const CH_RBRACE = 125; // "}"
+// characters that terminate the current token
+const SPLITS = new Set([
+    CH_SPACE, CH_COLON, CH_DOT, CH_COMMA, CH_DASH, 43 /* + */, 40 /* ( */,
+    41 /* ) */, 91 /* [ */, 93 /* ] */, CH_BACKSLASH, CH_TAB, CH_NL
+]);
+// single characters that are emitted as their own token
+const BUFS = new Set([
+    CH_DOT, CH_COMMA, CH_COLON, 40 /* ( */, 41 /* ) */, 91 /* [ */,
+    93 /* ] */, 43 /* + */, CH_AT
+]);
 class Lexer {
     run(file, virtual) {
         this.virtual = virtual;
@@ -26,15 +57,17 @@ class Lexer {
             const col = this.stream.getCol();
             const row = this.stream.getRow();
             let whiteBefore = false;
-            if (this.stream.getOffset() - s.length >= 0) {
-                const prev = this.stream.getRaw().substr(this.stream.getOffset() - s.length, 1);
-                if (prev === " " || prev === "\n" || prev === "\t" || prev === ":") {
+            const beforeOffset = this.stream.getOffset() - s.length;
+            if (beforeOffset >= 0) {
+                const prev = this.stream.charCodeAt(beforeOffset);
+                if (prev === CH_SPACE || prev === CH_NL || prev === CH_TAB || prev === CH_COLON) {
                     whiteBefore = true;
                 }
             }
             let whiteAfter = false;
             const next = this.stream.nextChar();
-            if (next === " " || next === "\n" || next === "\t" || next === ":" || next === "," || next === "." || next === "" || next === "\"") {
+            if (next === CH_SPACE || next === CH_NL || next === CH_TAB || next === CH_COLON
+                || next === CH_COMMA || next === CH_DOT || next === EOF || next === CH_DQUOTE) {
                 whiteAfter = true;
             }
             let pos = new position_1.Position(row, col - s.length);
@@ -204,10 +237,10 @@ class Lexer {
                 }
             }
             if (tok === undefined && this.m === ModeNormal && s.charAt(0) === "\\") {
-                const adj = this.stream.nextChar() === "" ? 1 : 0;
+                const adj = this.stream.nextChar() === EOF ? 1 : 0;
                 const prevOffset = this.stream.getOffset() - s.length - adj;
-                const prevChar = prevOffset >= 0 ? this.stream.getRaw().substr(prevOffset, 1) : "";
-                const whiteBeforeBackslash = prevChar === " " || prevChar === "\n" || prevChar === "\t" || prevChar === ":";
+                const prevChar = this.stream.charCodeAt(prevOffset);
+                const whiteBeforeBackslash = prevChar === CH_SPACE || prevChar === CH_NL || prevChar === CH_TAB || prevChar === CH_COLON;
                 if (!whiteBeforeBackslash) {
                     tok = new tokens_1.AssociationName(pos, s);
                 }
@@ -220,100 +253,77 @@ class Lexer {
         this.buffer.clear();
     }
     process(raw) {
-        this.stream = new lexer_stream_1.LexerStream(raw.replace(/\r/g, ""));
-        this.buffer = new lexer_buffer_1.LexerBuffer();
-        const splits = {};
-        splits[" "] = true;
-        splits[":"] = true;
-        splits["."] = true;
-        splits[","] = true;
-        splits["-"] = true;
-        splits["+"] = true;
-        splits["("] = true;
-        splits[")"] = true;
-        splits["["] = true;
-        splits["]"] = true;
-        splits["\\"] = true;
-        splits["\t"] = true;
-        splits["\n"] = true;
-        const bufs = {};
-        bufs["."] = true;
-        bufs[","] = true;
-        bufs[":"] = true;
-        bufs["("] = true;
-        bufs[")"] = true;
-        bufs["["] = true;
-        bufs["]"] = true;
-        bufs["+"] = true;
-        bufs["@"] = true;
+        const stream = new lexer_stream_1.LexerStream(raw.replace(/\r/g, ""));
+        this.stream = stream;
+        this.buffer = new lexer_buffer_1.LexerBuffer(stream.getRaw());
         for (;;) {
-            const current = this.stream.currentChar();
-            const buf = this.buffer.add(current);
-            const ahead = this.stream.nextChar();
-            const aahead = this.stream.nextNextChar();
+            const current = stream.currentChar();
+            this.buffer.add(stream.getOffset());
+            const ahead = stream.nextChar();
+            const aahead = stream.nextNextChar();
             if (this.m === ModeNormal) {
-                if (splits[ahead]) {
+                if (SPLITS.has(ahead)) {
                     this.add();
                 }
-                else if (ahead === "'") {
+                else if (ahead === CH_QUOTE) {
                     // start string
                     this.add();
                     this.m = ModeStr;
                 }
-                else if (ahead === "|" || ahead === "}") {
+                else if (ahead === CH_PIPE || ahead === CH_RBRACE) {
                     // start template
                     this.add();
                     this.m = ModeTemplate;
                 }
-                else if (ahead === "`") {
+                else if (ahead === CH_BACKTICK) {
                     // start ping
                     this.add();
                     this.m = ModePing;
                 }
-                else if (aahead === "##") {
+                else if (ahead === CH_HASH && aahead === CH_HASH) {
                     // start pragma
                     this.add();
                     this.m = ModePragma;
                 }
-                else if (ahead === "\""
-                    || (ahead === "*" && current === "\n")) {
+                else if (ahead === CH_DQUOTE
+                    || (ahead === CH_STAR && current === CH_NL)) {
                     // start comment
                     this.add();
                     this.m = ModeComment;
                 }
-                else if (ahead === "@" && buf.trim().length === 0) {
+                else if (ahead === CH_AT && this.buffer.get().trim().length === 0) {
                     this.add();
                 }
-                else if (aahead === "->"
-                    || aahead === "=>") {
+                else if ((ahead === CH_DASH || ahead === CH_EQUALS) && aahead === CH_GT) {
                     this.add();
                 }
-                else if (current === ">"
-                    && ahead !== " "
-                    && (this.stream.prevChar() === "-" || this.stream.prevChar() === "=")) {
+                else if (current === CH_GT
+                    && ahead !== CH_SPACE
+                    && (stream.prevChar() === CH_DASH || stream.prevChar() === CH_EQUALS)) {
                     // arrows
                     this.add();
                 }
-                else if (buf.length === 1
-                    && (bufs[buf]
-                        || (buf === "-" && ahead !== ">"))) {
+                else if (this.buffer.length() === 1
+                    && (BUFS.has(current)
+                        || (current === CH_DASH && ahead !== CH_GT))) {
                     this.add();
                 }
             }
-            else if (this.m === ModePragma && (ahead === "," || ahead === ":" || ahead === "." || ahead === " " || ahead === "\n")) {
+            else if (this.m === ModePragma && (ahead === CH_COMMA || ahead === CH_COLON
+                || ahead === CH_DOT || ahead === CH_SPACE || ahead === CH_NL)) {
                 // end of pragma
                 this.add();
                 this.m = ModeNormal;
             }
             else if (this.m === ModePing
-                && buf.length > 1
-                && current === "`"
-                && aahead !== "``"
-                && ahead !== "`"
-                && this.buffer.countIsEven("`")) {
+                && this.buffer.length() > 1
+                && current === CH_BACKTICK
+                && !(ahead === CH_BACKTICK && aahead === CH_BACKTICK)
+                && ahead !== CH_BACKTICK
+                && this.buffer.countIsEven(CH_BACKTICK)) {
                 // end of ping
                 this.add();
-                if (ahead === `"`) {
+                if (ahead === CH_DQUOTE) {
                     this.m = ModeComment;
                 }
                 else {
@@ -321,41 +331,41 @@ class Lexer {
                 }
             }
             else if (this.m === ModeTemplate
-                && buf.length > 1
-                && (current === "|" || current === "{")
-                && (this.stream.prevChar() !== "\\" || this.stream.prevPrevChar() === "\\\\")) {
+                && this.buffer.length() > 1
+                && (current === CH_PIPE || current === CH_LBRACE)
+                && (stream.prevChar() !== CH_BACKSLASH || (stream.prevPrevChar() === CH_BACKSLASH && stream.prevChar() === CH_BACKSLASH))) {
                 // end of template
                 this.add();
                 this.m = ModeNormal;
             }
             else if (this.m === ModeTemplate
-                && ahead === "}"
-                && current !== "\\") {
+                && ahead === CH_RBRACE
+                && current !== CH_BACKSLASH) {
                 this.add();
             }
             else if (this.m === ModeStr
-                && current === "'"
-                && buf.length > 1
-                && aahead !== "''"
-                && ahead !== "'"
-                && this.buffer.countIsEven("'")) {
+                && current === CH_QUOTE
+                && this.buffer.length() > 1
+                && !(ahead === CH_QUOTE && aahead === CH_QUOTE)
+                && ahead !== CH_QUOTE
+                && this.buffer.countIsEven(CH_QUOTE)) {
                 // end of string
                 this.add();
-                if (ahead === "\"") {
+                if (ahead === CH_DQUOTE) {
                     this.m = ModeComment;
                 }
                 else {
                     this.m = ModeNormal;
                 }
             }
-            else if (ahead === "\n" && this.m !== ModeTemplate) {
+            else if (ahead === CH_NL && this.m !== ModeTemplate) {
                 this.add();
                 this.m = ModeNormal;
             }
-            else if (this.m === ModeTemplate && current === "\n") {
+            else if (this.m === ModeTemplate && current === CH_NL) {
                 this.add();
             }
-            if (!this.stream.advance()) {
+            if (!stream.advance()) {
                 break;
             }
         }

package/build/src/abap/1_lexer/lexer_buffer.js

@@ -1,24 +1,38 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LexerBuffer = void 0;
+// The buffer holds a reference to the raw input and tracks the [start, end)
+// offset range of the current token, so the token string can be sliced out with
+// a single substring() instead of being concatenated one character at a time.
 class LexerBuffer {
-    constructor() {
-        this.buf = "";
+    constructor(raw) {
+        this.raw = raw;
+        this.start = 0;
+        this.end = 0;
+        this.empty = true;
     }
-    add(s) {
-        this.buf = this.buf + s;
-        return this.buf;
+    add(offset) {
+        if (this.empty === true) {
+            this.start = offset < 0 ? 0 : offset;
+            this.empty = false;
+        }
+        this.end = offset + 1;
     }
     get() {
-        return this.buf;
+        return this.raw.substring(this.start, this.end);
+    }
+    length() {
+        return this.end - this.start;
     }
     clear() {
-        this.buf = "";
+        this.start = 0;
+        this.end = 0;
+        this.empty = true;
     }
     countIsEven(char) {
         let count = 0;
-        for (let i = 0; i < this.buf.length; i += 1) {
-            if (this.buf.charAt(i) === char) {
+        for (let i = this.start; i < this.end; i += 1) {
+            if (this.raw.charCodeAt(i) === char) {
                 count += 1;
             }
         }

package/build/src/abap/1_lexer/lexer_stream.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LexerStream = void 0;
+const NL = 10; // "\n"
+const EOF = -1; // no character (start/end of file)
 class LexerStream {
     constructor(raw) {
         this.offset = -1;
@@ -9,7 +11,7 @@ class LexerStream {
         this.col = 0;
     }
     advance() {
-        if (this.currentChar() === "\n") {
+        if (this.currentChar() === NL) {
             this.col = 1;
             this.row = this.row + 1;
         }
@@ -27,38 +29,51 @@ class LexerStream {
     getRow() {
         return this.row;
     }
+    // the *Char() accessors return character codes (charCodeAt) rather than
+    // single character strings, to avoid allocating a string per input character
+    // in the lexer hot loop. EOF (-1) is returned when the offset is out of range.
     prevChar() {
-        if (this.offset - 1 < 0) {
-            return "";
+        const o = this.offset - 1;
+        if (o < 0) {
+            return EOF;
         }
-        return this.raw.substr(this.offset - 1, 1);
+        return this.raw.charCodeAt(o);
     }
     prevPrevChar() {
-        if (this.offset - 2 < 0) {
-            return "";
+        const o = this.offset - 2;
+        if (o < 0) {
+            return EOF;
         }
-        return this.raw.substr(this.offset - 2, 2);
+        return this.raw.charCodeAt(o);
     }
     currentChar() {
         if (this.offset < 0) {
-            return "\n"; // simulate newline at start of file to handle star(*) comments
+            return NL; // simulate newline at start of file to handle star(*) comments
         }
         else if (this.offset >= this.raw.length) {
-            return "";
+            return EOF;
         }
-        return this.raw.substr(this.offset, 1);
+        return this.raw.charCodeAt(this.offset);
     }
     nextChar() {
-        if (this.offset + 2 > this.raw.length) {
-            return "";
+        const o = this.offset + 1;
+        if (o >= this.raw.length) {
+            return EOF;
         }
-        return this.raw.substr(this.offset + 1, 1);
+        return this.raw.charCodeAt(o);
     }
     nextNextChar() {
-        if (this.offset + 3 > this.raw.length) {
-            return this.nextChar();
+        const o = this.offset + 2;
+        if (o >= this.raw.length) {
+            return EOF;
         }
-        return this.raw.substr(this.offset + 1, 2);
+        return this.raw.charCodeAt(o);
+    }
+    charCodeAt(o) {
+        if (o < 0 || o >= this.raw.length) {
+            return EOF;
+        }
+        return this.raw.charCodeAt(o);
     }
     getRaw() {
         return this.raw;

package/build/src/abap/2_statements/combi.js

@@ -123,8 +123,9 @@ class Word {
     }
 }
 class Token {
-    constructor(s) {
-        this.name = s;
+    constructor(t) {
+        this.tokenType = t;
+        this.name = t.name;
     }
     listKeywords() {
         return [];
@@ -136,7 +137,7 @@ class Token {
         const result = [];
         for (const input of r) {
             if (input.remainingLength() !== 0
-                && input.peek().constructor.name === this.name) {
+                && input.peek().constructor === this.tokenType) {
                 result.push(input.shift(new nodes_1.TokenNode(input.peek())));
             }
         }
@@ -332,7 +333,12 @@ class Optional {
         for (const input of r) {
             result.push(input);
             const res = this.optional.run([input]);
-            result.push(...res);
+            if (res.length === 1) {
+                result.push(res[0]);
+            }
+            else {
+                result.push(...res);
+            }
         }
         return result;
     }
@@ -371,6 +377,9 @@ class Star {
                     // avoid stack overflow
                     result = result.concat(res);
                 }
+                else if (res.length === 1) {
+                    result.push(res[0]);
+                }
                 else {
                     result.push(...res);
                 }
@@ -522,6 +531,9 @@ class Sequence {
                     // avoid stack overflow
                     result = result.concat(temp);
                 }
+                else if (temp.length === 1) {
+                    result.push(temp[0]);
+                }
                 else {
                     result.push(...temp);
                 }
@@ -746,7 +758,12 @@ class Alternative {
         const result = [];
         for (const sequ of this.list) {
             const temp = sequ.run(r);
-            result.push(...temp);
+            if (temp.length === 1) {
+                result.push(temp[0]);
+            }
+            else {
+                result.push(...temp);
+            }
         }
         return result;
     }
@@ -804,7 +821,12 @@ class AlternativePriority {
             //      console.log(seq.toStr());
             const temp = sequ.run(r);
             if (temp.length > 0) {
-                result.push(...temp);
+                if (temp.length === 1) {
+                    result.push(temp[0]);
+                }
+                else {
+                    result.push(...temp);
+                }
                 break;
             }
         }
@@ -920,7 +942,7 @@ function regex(r) {
     return new Regex(r);
 }
 function tok(t) {
-    return new Token(t.name);
+    return new Token(t);
 }
 const expressionSingletons = {};
 const stringSingletons = {};

package/build/src/registry.js

@@ -75,7 +75,7 @@ class Registry {
     }
     static abaplintVersion() {
         // magic, see build script "version.js"
-        return "2.119.59";
+        return "2.119.60";
     }
     getDDICReferences() {
         return this.ddicReferences;

package/build/src/rules/dangerous_statement.js

@@ -59,6 +59,7 @@ class DangerousStatementConf extends _basic_rule_config_1.BasicRuleConfig {
         this.insertTextpool = true;
         this.deleteDynpro = true;
         this.exportDynpro = true;
+        this.editorCallForReport = true;
         /** Finds instances of dynamic SQL: SELECT, UPDATE, DELETE, INSERT, MODIFY */
         this.dynamicSQL = true;
         /** Ignore dynamic SQL in IF_RAP_QUERY_PROVIDER~SELECT implementations */
@@ -143,6 +144,11 @@ dynamic SQL can potentially create SQL injection problems`,
             else if (this.conf.exportDynpro && statement instanceof Statements.ExportDynpro) {
                 message = "EXPORT DYNPRO";
             }
+            else if (this.conf.editorCallForReport
+                && statement instanceof Statements.EditorCall
+                && statementNode.findDirectTokenByText("REPORT")) {
+                message = "EDITOR-CALL FOR REPORT";
+            }
             if (message) {
                 issues.push(issue_1.Issue.atStatement(file, statementNode, this.getDescription(message), this.getMetadata().key, this.conf.severity));
             }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@abaplint/core",
-    "version": "2.119.59",
+    "version": "2.119.60",
     "description": "abaplint - Core API",
     "main": "build/src/index.js",
     "typings": "build/abaplint.d.ts",