All files / src/abap/5_syntax/statements append.ts

88.24% Statements 30/34
78.79% Branches 26/33
100% Functions 1/1
88.24% Lines 30/34

Press n or j to go to the next uncovered block, b, p or k for the previous block.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 611x     1x 1x 1x   1x     1x     17x   17x 17x 17x     17x 17x 4x       4x   4x     16x 16x 12x   16x 12x         12x 12x 11x 1x 1x   12x     14x 14x     14x 14x          
import * as Expressions from "../../2_statements/expressions";
import {StatementNode} from "../../nodes";
import {CurrentScope} from "../_current_scope";
import {Source} from "../expressions/source";
import {Target} from "../expressions/target";
import {TableType, VoidType} from "../../types/basic";
import {AbstractType} from "../../types/basic/_abstract_type";
import {FSTarget} from "../expressions/fstarget";
import {StatementSyntax} from "../_statement_syntax";
 
export class Append implements StatementSyntax {
  public runSyntax(node: StatementNode, scope: CurrentScope, filename: string): void {
 
    let targetType: AbstractType | undefined = undefined;
 
    const target = node.findDirectExpression(Expressions.Target);
    Eif (target) {
      targetType = new Target().runSyntax(target, scope, filename);
    }
 
    const fsTarget = node.findExpressionAfterToken("ASSIGNING");
    if (fsTarget && fsTarget.get() instanceof Expressions.FSTarget) {
      Iif (!(targetType instanceof TableType) && !(targetType instanceof VoidType)) {
        throw new Error("APPEND to non table type");
      }
 
      const rowType = targetType instanceof TableType ? targetType.getRowType() : targetType;
 
      new FSTarget().runSyntax(fsTarget, scope, filename, rowType);
    }
 
    let source = node.findDirectExpression(Expressions.Source);
    if (source === undefined) {
      source = node.findDirectExpression(Expressions.SimpleSource4);
    }
    if (source) {
      Iif (targetType !== undefined
          && !(targetType instanceof TableType)
          && !(targetType instanceof VoidType)) {
        throw new Error("Append, target not a table type");
      }
      let rowType: AbstractType | undefined = undefined;
      if (targetType instanceof TableType) {
        rowType = targetType.getRowType();
      } else Eif (targetType instanceof VoidType) {
        rowType = targetType;
      }
      new Source().runSyntax(source, scope, filename, rowType);
    }
 
    const from = node.findExpressionAfterToken("FROM");
    Iif (from && from.get() instanceof Expressions.Source) {
      new Source().runSyntax(from, scope, filename);
    }
    const to = node.findExpressionAfterToken("TO");
    Iif (to && to.get() instanceof Expressions.Source) {
      new Source().runSyntax(to, scope, filename);
    }
 
  }
}