@eagleoutice/flowr 1.3.11

package/r-bridge/lang-4.x/ast/parser/xml/v1/internal/operators/binary.js

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tryNormalizeBinary = void 0;
+const input_format_1 = require("../../../common/input-format");
+const normalize_1 = require("../../normalize");
+const meta_1 = require("../../../common/meta");
+const special_1 = require("./special");
+const structure_1 = require("../structure");
+const model_1 = require("../../../../../model");
+const hooks_1 = require("../../hooks");
+const assert_1 = require("../../../../../../../../util/assert");
+/**
+ * Parsing binary operations includes the pipe, even though the produced PIPE construct is not a binary operation,
+ * to ensure it is handled separately from the others (especially in the combination of a pipe bind)
+ */
+function tryNormalizeBinary(data, lhs, operator, rhs) {
+    normalize_1.parseLog.trace(`binary op for ${lhs.name} [${operator.name}] ${rhs.name}`);
+    let flavor;
+    if ("SPECIAL" /* RawRType.Special */ === operator.name) {
+        flavor = 'special';
+    }
+    else if (model_1.ArithmeticOperatorsRAst.has(operator.name)) {
+        flavor = 'arithmetic';
+    }
+    else if (model_1.ComparisonOperatorsRAst.has(operator.name)) {
+        flavor = 'comparison';
+    }
+    else if (model_1.LogicalOperatorsRAst.has(operator.name)) {
+        flavor = 'logical';
+    }
+    else if (model_1.ModelFormulaOperatorsRAst.has(operator.name)) {
+        flavor = 'model formula';
+    }
+    else if (model_1.AssignmentsRAst.has(operator.name)) {
+        flavor = 'assignment';
+    }
+    else if (operator.name === "PIPE" /* RawRType.Pipe */) {
+        flavor = 'pipe';
+    }
+    else {
+        return (0, hooks_1.executeUnknownHook)(data.hooks.operators.onBinary.unknown, data, { lhs, operator, rhs });
+    }
+    return parseBinaryOp(data, flavor, lhs, operator, rhs);
+}
+exports.tryNormalizeBinary = tryNormalizeBinary;
+function parseBinaryOp(data, flavor, lhs, operator, rhs) {
+    normalize_1.parseLog.debug(`[binary op] trying to parse ${flavor}`);
+    ({ flavor, lhs, rhs, operator } = (0, hooks_1.executeHook)(data.hooks.operators.onBinary.before, data, { flavor, lhs, operator, rhs }));
+    (0, meta_1.ensureChildrenAreLhsAndRhsOrdered)(data.config, lhs.content, rhs.content);
+    let parsedLhs = (0, structure_1.tryNormalizeSingleNode)(data, lhs);
+    let parsedRhs = (0, structure_1.tryNormalizeSingleNode)(data, rhs);
+    if (parsedLhs.type === "RDelimiter" /* RType.Delimiter */ || parsedRhs.type === "RDelimiter" /* RType.Delimiter */) {
+        throw new input_format_1.XmlParseError(`unexpected under-sided binary op, received ${JSON.stringify([parsedLhs, parsedRhs])} for ${JSON.stringify([lhs, operator, rhs])}`);
+    }
+    const operationName = (0, meta_1.retrieveOpName)(data.config, operator);
+    // special support for strings in assignments
+    if (flavor === 'assignment') {
+        [parsedLhs, parsedRhs] = processLhsAndRhsForAssignment(data, operationName, parsedLhs, parsedRhs);
+    }
+    const { location, content } = (0, meta_1.retrieveMetaStructure)(data.config, operator.content);
+    if (flavor === 'special') {
+        flavor = (0, special_1.identifySpecialOp)(content);
+    }
+    if (flavor === 'special') {
+        (0, assert_1.guard)(parsedLhs.location !== undefined && parsedLhs.lexeme !== undefined && parsedRhs.location !== undefined && parsedRhs.lexeme !== undefined, () => `special op lhs and rhs must have a locations and lexemes, but ${JSON.stringify(parsedLhs)} and ${JSON.stringify(parsedRhs)})`);
+        // parse as infix function call!
+        const result = {
+            type: "RFunctionCall" /* RType.FunctionCall */,
+            flavor: 'named',
+            infixSpecial: true,
+            lexeme: data.currentLexeme ?? content,
+            location,
+            functionName: {
+                type: "RSymbol" /* RType.Symbol */,
+                location,
+                lexeme: content,
+                content,
+                namespace: undefined,
+                info: {}
+            },
+            arguments: [
+                {
+                    type: "RArgument" /* RType.Argument */,
+                    location: parsedLhs.location,
+                    value: parsedLhs,
+                    name: undefined,
+                    lexeme: parsedLhs.lexeme,
+                    info: {}
+                },
+                {
+                    type: "RArgument" /* RType.Argument */,
+                    location: parsedRhs.location,
+                    value: parsedRhs,
+                    name: undefined,
+                    lexeme: parsedRhs.lexeme,
+                    info: {}
+                }
+            ],
+            info: {}
+        };
+        return (0, hooks_1.executeHook)(data.hooks.operators.onBinary.after, data, result);
+    }
+    let result;
+    if (flavor === 'pipe') {
+        (0, assert_1.guard)(parsedLhs.location !== undefined, () => `pipe lhs must have a location, but ${JSON.stringify(parsedLhs)})`);
+        (0, assert_1.guard)(parsedLhs.lexeme !== undefined, () => `pipe lhs must have a full lexeme, but ${JSON.stringify(parsedLhs)})`);
+        result = {
+            type: "RPipe" /* RType.Pipe */,
+            location,
+            lhs: {
+                type: "RArgument" /* RType.Argument */,
+                location: parsedLhs.location,
+                value: parsedLhs,
+                name: undefined,
+                lexeme: parsedLhs.lexeme,
+                info: {}
+            },
+            rhs: parsedRhs,
+            lexeme: content,
+            info: {
+                fullRange: data.currentRange,
+                additionalTokens: [],
+                fullLexeme: data.currentLexeme
+            }
+        };
+    }
+    else {
+        result = {
+            type: "RBinaryOp" /* RType.BinaryOp */,
+            flavor,
+            location,
+            lhs: parsedLhs,
+            rhs: parsedRhs,
+            operator: operationName,
+            lexeme: content,
+            info: {
+                fullRange: data.currentRange,
+                additionalTokens: [],
+                fullLexeme: data.currentLexeme
+            }
+        };
+    }
+    return (0, hooks_1.executeHook)(data.hooks.operators.onBinary.after, data, result);
+}
+function processLhsAndRhsForAssignment(data, opName, parsedLhs, parsedRhs) {
+    const isRhs = opName === '->' || opName === '->>';
+    const assigned = isRhs ? parsedRhs : parsedLhs;
+    if (assigned.type !== "RString" /* RType.String */) {
+        return [parsedLhs, parsedRhs];
+    }
+    // update the assigned value to be parsed as a symbol
+    const result = {
+        type: "RSymbol" /* RType.Symbol */,
+        lexeme: assigned.lexeme,
+        location: assigned.location,
+        content: assigned.content.str,
+        namespace: undefined,
+        info: assigned.info
+    };
+    return isRhs ? [parsedLhs, result] : [result, parsedRhs];
+}
+//# sourceMappingURL=binary.js.map

package/r-bridge/lang-4.x/ast/parser/xml/v1/internal/operators/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./unary"), exports);
+__exportStar(require("./binary"), exports);
+__exportStar(require("./special"), exports);
+//# sourceMappingURL=index.js.map

package/r-bridge/lang-4.x/ast/parser/xml/v1/internal/operators/special.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.identifySpecialOp = void 0;
+const model_1 = require("../../../../../model");
+/**
+ * Identify the flavor of a given operator, as we do not really have a use for "special"
+ * operators within our internal AST.
+ */
+function identifySpecialOp(content) {
+    if (model_1.ComparisonOperatorsRAst.has(content)) {
+        return 'comparison';
+    }
+    else if (model_1.LogicalOperatorsRAst.has(content)) {
+        return 'logical';
+    }
+    else if (model_1.ArithmeticOperatorsRAst.has(content)) {
+        return 'arithmetic';
+    }
+    else {
+        return 'special';
+    }
+}
+exports.identifySpecialOp = identifySpecialOp;
+//# sourceMappingURL=special.js.map

package/r-bridge/lang-4.x/ast/parser/xml/v1/internal/operators/unary.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tryNormalizeUnary = void 0;
+const meta_1 = require("../../../common/meta");
+const normalize_1 = require("../../normalize");
+const structure_1 = require("../structure");
+const assert_1 = require("../../../../../../../../util/assert");
+const model_1 = require("../../../../../model");
+const hooks_1 = require("../../hooks");
+/**
+ * Parses the construct as a {@link RUnaryOp} (automatically identifies the flavor).
+ *
+ * @param data     - The data used by the parser (see {@link ParserData})
+ * @param operator - The operator token
+ * @param operand  - The operand of the unary operator
+ *
+ * @returns The parsed {@link RUnaryOp} or `undefined` if the given construct is not a unary operator
+ */
+function tryNormalizeUnary(data, operator, operand) {
+    normalize_1.parseLog.trace(`unary op for ${operator.name} ${operand.name}`);
+    let flavor;
+    if (model_1.ArithmeticOperatorsRAst.has(operator.name)) {
+        flavor = 'arithmetic';
+    }
+    else if (model_1.LogicalOperatorsRAst.has(operator.name)) {
+        flavor = 'logical';
+    }
+    else if (model_1.ModelFormulaOperatorsRAst.has(operator.name)) {
+        flavor = 'model formula';
+    }
+    else {
+        return (0, hooks_1.executeUnknownHook)(data.hooks.operators.onUnary.unknown, data, { operator, operand });
+    }
+    return parseUnaryOp(data, flavor, operator, operand);
+}
+exports.tryNormalizeUnary = tryNormalizeUnary;
+function parseUnaryOp(data, flavor, operator, operand) {
+    normalize_1.parseLog.debug(`[unary op] parse ${flavor}`); // <- semicolon sadly required for not miss-interpreting the destructuring match as call
+    ({ flavor, operator, operand } = (0, hooks_1.executeHook)(data.hooks.operators.onUnary.before, data, { flavor, operator, operand }));
+    const parsedOperand = (0, structure_1.tryNormalizeSingleNode)(data, operand);
+    (0, assert_1.guard)(parsedOperand.type !== "RDelimiter" /* RType.Delimiter */, () => 'unexpected under-sided unary op');
+    const operationName = (0, meta_1.retrieveOpName)(data.config, operator);
+    const { location, content } = (0, meta_1.retrieveMetaStructure)(data.config, operator.content);
+    const result = {
+        type: "RUnaryOp" /* RType.UnaryOp */,
+        flavor,
+        location,
+        operator: operationName,
+        lexeme: content,
+        operand: parsedOperand,
+        info: {
+            fullRange: data.currentRange,
+            additionalTokens: [],
+            fullLexeme: data.currentLexeme
+        }
+    };
+    return (0, hooks_1.executeHook)(data.hooks.operators.onUnary.after, data, result);
+}
+//# sourceMappingURL=unary.js.map

package/r-bridge/lang-4.x/ast/parser/xml/v1/internal/other/comment.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeComment = void 0;
+const normalize_1 = require("../../normalize");
+const meta_1 = require("../../../common/meta");
+const assert_1 = require("../../../../../../../../util/assert");
+const hooks_1 = require("../../hooks");
+/**
+ * Normalize the given object as an R comment.
+ * This requires you to check the corresponding name beforehand.
+ *
+ * @param data - The data used by the parser (see {@link ParserData})
+ * @param obj  - The json object to extract the meta-information from
+ */
+function normalizeComment(data, obj) {
+    normalize_1.parseLog.debug('[comment]');
+    obj = (0, hooks_1.executeHook)(data.hooks.other.onComment.before, data, obj);
+    const { location, content } = (0, meta_1.retrieveMetaStructure)(data.config, obj);
+    (0, assert_1.guard)(content.startsWith('#'), 'comment must start with #');
+    const result = {
+        type: "RComment" /* RType.Comment */,
+        location,
+        content: content.slice(1),
+        lexeme: content,
+        info: {
+            fullRange: data.currentRange,
+            additionalTokens: [],
+            fullLexeme: content
+        }
+    };
+    return (0, hooks_1.executeHook)(data.hooks.other.onComment.after, data, result);
+}
+exports.normalizeComment = normalizeComment;
+//# sourceMappingURL=comment.js.map

package/r-bridge/lang-4.x/ast/parser/xml/v1/internal/other/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./comment"), exports);
+//# sourceMappingURL=index.js.map

package/r-bridge/lang-4.x/ast/parser/xml/v1/internal/other/line-directive.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeLineDirective = void 0;
+const normalize_1 = require("../../normalize");
+const meta_1 = require("../../../common/meta");
+const assert_1 = require("../../../../../../../../util/assert");
+const hooks_1 = require("../../hooks");
+const LineDirectiveRegex = /^#line\s+(\d+)\s+"([^"]+)"\s*$/;
+/**
+ * Normalize the given object as an R line directive (`#line <number> "<file>"`).
+ * This requires you to check the corresponding name beforehand.
+ * If the given object turns out to be no line directive, this returns a normal comment instead.
+ *
+ * @param data - The data used by the parser (see {@link ParserData})
+ * @param obj  - The json object to extract the meta-information from
+ */
+function normalizeLineDirective(data, obj) {
+    normalize_1.parseLog.debug('[line-directive]');
+    obj = (0, hooks_1.executeHook)(data.hooks.other.onLineDirective.before, data, obj);
+    const { location, content } = (0, meta_1.retrieveMetaStructure)(data.config, obj);
+    (0, assert_1.guard)(content.startsWith('#line'), 'line directive must start with #line');
+    const match = LineDirectiveRegex.exec(content);
+    let result;
+    if (match === null) {
+        normalize_1.parseLog.debug(`[line-directive] does not match the regex ${LineDirectiveRegex.source} given ${JSON.stringify(content)}`);
+        result = {
+            type: "RComment" /* RType.Comment */,
+            location,
+            lexeme: content,
+            info: {
+                fullRange: data.currentRange,
+                additionalTokens: [],
+                fullLexeme: content
+            },
+            content: content.slice(1)
+        };
+    }
+    else {
+        result = {
+            type: "RLineDirective" /* RType.LineDirective */,
+            location,
+            line: parseInt(match[1]),
+            file: match[2],
+            lexeme: content,
+            info: {
+                fullRange: data.currentRange,
+                additionalTokens: [],
+                fullLexeme: content
+            }
+        };
+    }
+    return (0, hooks_1.executeHook)(data.hooks.other.onLineDirective.after, data, result);
+}
+exports.normalizeLineDirective = normalizeLineDirective;
+//# sourceMappingURL=line-directive.js.map

package/r-bridge/lang-4.x/ast/parser/xml/v1/internal/structure/elements.js

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseNodesWithUnknownType = exports.normalizeBasedOnType = exports.splitComments = void 0;
+const arrays_1 = require("../../../../../../../../util/arrays");
+const normalize_1 = require("../../normalize");
+const meta_1 = require("../../../common/meta");
+const single_element_1 = require("./single-element");
+const values_1 = require("../values");
+const operators_1 = require("../operators");
+const loops_1 = require("../loops");
+const control_1 = require("../control");
+const log_1 = require("../../../../../../../../util/log");
+const other_1 = require("../other");
+function normalizeMappedWithoutSemicolonBasedOnType(mappedWithName, data) {
+    if (mappedWithName.length === 1) {
+        return [(0, single_element_1.tryNormalizeSingleNode)(data, mappedWithName[0])];
+    }
+    else if (mappedWithName.length === 2) {
+        const unaryOp = (0, operators_1.tryNormalizeUnary)(data, mappedWithName[0], mappedWithName[1]);
+        if (unaryOp !== undefined) {
+            return [unaryOp];
+        }
+        const repeatLoop = (0, loops_1.tryNormalizeRepeat)(data, mappedWithName[0], mappedWithName[1]);
+        if (repeatLoop !== undefined) {
+            return [repeatLoop];
+        }
+    }
+    else if (mappedWithName.length === 3) {
+        const binary = (0, operators_1.tryNormalizeBinary)(data, mappedWithName[0], mappedWithName[1], mappedWithName[2]);
+        if (binary !== undefined) {
+            return [binary];
+        }
+        else {
+            const forLoop = (0, loops_1.tryNormalizeFor)(data, mappedWithName[0], mappedWithName[1], mappedWithName[2]);
+            if (forLoop !== undefined) {
+                return [forLoop];
+            }
+            else {
+                // could be a symbol with namespace information
+                const symbol = (0, values_1.tryNormalizeSymbol)(data, mappedWithName);
+                if (symbol !== undefined) {
+                    return [symbol];
+                }
+            }
+        }
+    }
+    else if (mappedWithName.length === 5) {
+        const ifThen = (0, control_1.tryNormalizeIfThen)(data, [
+            mappedWithName[0],
+            mappedWithName[1],
+            mappedWithName[2],
+            mappedWithName[3],
+            mappedWithName[4]
+        ]);
+        if (ifThen !== undefined) {
+            return [ifThen];
+        }
+        else {
+            const whileLoop = (0, loops_1.tryNormalizeWhile)(data, mappedWithName[0], mappedWithName[1], mappedWithName[2], mappedWithName[3], mappedWithName[4]);
+            if (whileLoop !== undefined) {
+                return [whileLoop];
+            }
+        }
+    }
+    else if (mappedWithName.length === 7) {
+        const ifThenElse = (0, control_1.tryNormalizeIfThenElse)(data, [
+            mappedWithName[0],
+            mappedWithName[1],
+            mappedWithName[2],
+            mappedWithName[3],
+            mappedWithName[4],
+            mappedWithName[5],
+            mappedWithName[6]
+        ]);
+        if (ifThenElse !== undefined) {
+            return [ifThenElse];
+        }
+    }
+    // otherwise perform default parsing
+    return parseNodesWithUnknownType(data, mappedWithName);
+}
+function splitComments(mappedWithName) {
+    const comments = [];
+    const others = [];
+    for (const elem of mappedWithName) {
+        if (elem.name === "COMMENT" /* RawRType.Comment */) {
+            comments.push(elem);
+        }
+        else {
+            others.push(elem);
+        }
+    }
+    return { comments, others };
+}
+exports.splitComments = splitComments;
+function normalizeBasedOnType(data, obj) {
+    if (obj.length === 0) {
+        normalize_1.parseLog.warn('no children received, skipping');
+        return [];
+    }
+    let mappedWithName;
+    if (obj[0].name) {
+        mappedWithName = obj;
+    }
+    else {
+        mappedWithName = (0, meta_1.getWithTokenType)(data.config.tokenMap, obj);
+    }
+    log_1.log.trace(`[parseBasedOnType] names: [${mappedWithName.map(({ name }) => name).join(', ')}]`);
+    const semiColons = [];
+    const splitOnSemicolon = (0, arrays_1.splitArrayOn)(mappedWithName, node => {
+        const res = node.name === ";" /* RawRType.Semicolon */;
+        if (res) {
+            const { location, content } = (0, meta_1.retrieveMetaStructure)(data.config, node.content);
+            semiColons.push({
+                type: "RDelimiter" /* RType.Delimiter */,
+                subtype: ";" /* RawRType.Semicolon */,
+                location: location,
+                lexeme: content
+            });
+        }
+        return res;
+    });
+    if (splitOnSemicolon.length > 1) {
+        log_1.log.trace(`found ${splitOnSemicolon.length} expressions by semicolon-split, parsing them separately`);
+        const flattened = [];
+        for (const sub of splitOnSemicolon) {
+            const result = normalizeBasedOnType(data, sub);
+            if (result.length === 1 && result[0].type === "RExpressionList" /* RType.ExpressionList */) {
+                flattened.push(...result[0].children);
+            }
+            else {
+                flattened.push(...result);
+            }
+        }
+        return [...flattened, ...semiColons];
+    }
+    /*
+   * if splitOnSemicolon.length === 1, we can continue with the normal parsing, but we may have had a trailing semicolon, with this, it is removed as well.
+   * splitOnSemicolon.length === 0 is not possible, as we would have had an empty array before, split does not add elements.
+   */
+    mappedWithName = splitOnSemicolon[0];
+    const { comments, others } = splitComments(mappedWithName);
+    const parsedComments = comments.map(c => (0, other_1.normalizeComment)(data, c.content));
+    const result = normalizeMappedWithoutSemicolonBasedOnType(others, data);
+    // we hoist comments
+    return [...parsedComments, ...result];
+}
+exports.normalizeBasedOnType = normalizeBasedOnType;
+function parseNodesWithUnknownType(data, mappedWithName) {
+    const parsedNodes = [];
+    // used to indicate the new root node of this set of nodes
+    for (const elem of mappedWithName) {
+        const retrieved = (0, single_element_1.tryNormalizeSingleNode)(data, elem);
+        parsedNodes.push(retrieved);
+    }
+    return parsedNodes;
+}
+exports.parseNodesWithUnknownType = parseNodesWithUnknownType;
+//# sourceMappingURL=elements.js.map

package/r-bridge/lang-4.x/ast/parser/xml/v1/internal/structure/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./root"), exports);
+__exportStar(require("./elements"), exports);
+__exportStar(require("./single-element"), exports);
+//# sourceMappingURL=index.js.map

package/r-bridge/lang-4.x/ast/parser/xml/v1/internal/structure/root.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeRootObjToAst = void 0;
+const input_format_1 = require("../../../common/input-format");
+const meta_1 = require("../../../common/meta");
+const elements_1 = require("./elements");
+const log_1 = require("../../../../../../../../util/log");
+const arrays_1 = require("../../../../../../../../util/arrays");
+function normalizeRootObjToAst(data, obj) {
+    const config = data.config;
+    const exprContent = (0, input_format_1.getKeyGuarded)(obj, "exprlist" /* RawRType.ExpressionList */);
+    (0, meta_1.assureTokenType)(config.tokenMap, exprContent, "exprlist" /* RawRType.ExpressionList */);
+    let parsedChildren = [];
+    if (config.children in exprContent) {
+        const children = (0, input_format_1.getKeyGuarded)(exprContent, config.children);
+        parsedChildren = (0, elements_1.normalizeBasedOnType)(data, children);
+    }
+    else {
+        log_1.log.debug('no children found, assume empty input');
+    }
+    const [delimiters, nodes] = (0, arrays_1.partition)(parsedChildren, x => x.type === "RDelimiter" /* RType.Delimiter */);
+    return {
+        type: "RExpressionList" /* RType.ExpressionList */,
+        children: nodes,
+        lexeme: undefined,
+        info: {
+            fullRange: data.currentRange,
+            additionalTokens: delimiters,
+            fullLexeme: data.currentLexeme
+        }
+    };
+}
+exports.normalizeRootObjToAst = normalizeRootObjToAst;
+//# sourceMappingURL=root.js.map

package/r-bridge/lang-4.x/ast/parser/xml/v1/internal/structure/single-element.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tryNormalizeSingleNode = void 0;
+const input_format_1 = require("../../../common/input-format");
+const values_1 = require("../values");
+const assert_1 = require("../../../../../../../../util/assert");
+const expression_1 = require("../expression");
+const meta_1 = require("../../../common/meta");
+const other_1 = require("../other");
+const loops_1 = require("../loops");
+const line_directive_1 = require("../other/line-directive");
+function normalizeDelimiter(data, elem) {
+    const { location, content } = (0, meta_1.retrieveMetaStructure)(data.config, elem.content);
+    return {
+        type: "RDelimiter" /* RType.Delimiter */,
+        location,
+        lexeme: content,
+        subtype: elem.name
+    };
+}
+/**
+ * Parses a single structure in the ast based on its type (e.g., a string, a number, a symbol, ...)
+ *
+ * @param data - The data used by the parser (see {@link ParserData})
+ * @param elem - The element to parse
+ *
+ * @returns The parsed element as an `RNode` or an `RDelimiter` if it is such.
+ */
+function tryNormalizeSingleNode(data, elem) {
+    switch (elem.name) {
+        case "(" /* RawRType.ParenLeft */:
+        case ")" /* RawRType.ParenRight */:
+        case "{" /* RawRType.BraceLeft */:
+        case "}" /* RawRType.BraceRight */:
+            return normalizeDelimiter(data, elem);
+        case "COMMENT" /* RawRType.Comment */:
+            return (0, other_1.normalizeComment)(data, elem.content);
+        case "LINE_DIRECTIVE" /* RawRType.LineDirective */:
+            return (0, line_directive_1.normalizeLineDirective)(data, elem.content);
+        case "exprlist" /* RawRType.ExpressionList */:
+        case "expr" /* RawRType.Expression */:
+        case "expr_or_assign_or_help" /* RawRType.ExprOfAssignOrHelp */:
+            return (0, expression_1.normalizeExpression)(data, elem.content);
+        case "NUM_CONST" /* RawRType.NumericConst */:
+            return (0, values_1.normalizeNumber)(data, elem.content);
+        case "STR_CONST" /* RawRType.StringConst */:
+            return (0, values_1.normalizeString)(data, elem.content);
+        case "BREAK" /* RawRType.Break */:
+            return (0, loops_1.normalizeBreak)(data, elem.content);
+        case "NEXT" /* RawRType.Next */:
+            return (0, loops_1.normalizeNext)(data, elem.content);
+        case "SYMBOL" /* RawRType.Symbol */:
+        case "SLOT" /* RawRType.Slot */:
+        case "NULL_CONST" /* RawRType.NullConst */: {
+            const symbol = (0, values_1.tryNormalizeSymbol)(data, (0, meta_1.getWithTokenType)(data.config.tokenMap, [elem.content]));
+            (0, assert_1.guard)(symbol !== undefined, () => `should have been parsed to a symbol but was ${JSON.stringify(symbol)}`);
+            return symbol;
+        }
+        default:
+            throw new input_format_1.XmlParseError(`unknown type ${elem.name} for ${JSON.stringify(elem)} in ${JSON.stringify(data)}`);
+    }
+}
+exports.tryNormalizeSingleNode = tryNormalizeSingleNode;
+//# sourceMappingURL=single-element.js.map