Variable ControlFlowConst

Type Declaration

• alwaysExits: function

  • alwaysExits(this: void, info: DataflowCfgInformation): boolean

    Whether the subtree always jumps away instead of being left normally, i.e. whether a non-default exit point happens in every branch.

    Parameters

    • this: void
    • info: DataflowCfgInformation

    Returns boolean

    See

    ControlFlow#canComplete|canComplete() - for whether it can be left normally at all

    Example

    { break }            # always exits
    { if(u) break }      # only maybe
    Copy

• branchesTo: function

  • branchesTo(
        this: void,
        graph: DataflowGraph,
        from: DataflowCfgInformation,
        target: NodeId,
        cd: ControlDependency,
    ): void

    Whatever from completes at continues with target, but only under the given control dependency. Hand over the very dependency the vertices behind the branch carry, so both say the same thing.

    Parameters

    • this: void
    • graph: DataflowGraph
    • from: DataflowCfgInformation
    • target: NodeId
    • cd: ControlDependency

    Returns void

    See

    ControlFlow#continuesWith|continuesWith() - if it always continues

    Example

    if(u) a else b # `a` is reached when `u` holds, `b` when it does not
    Copy

• canComplete: function

  • canComplete(this: void, info: DataflowCfgInformation): boolean

    Whether the subtree can be left normally instead of always jumping away.

    Parameters

    • this: void
    • info: DataflowCfgInformation

    Returns boolean

    See

    ControlFlow#alwaysExits|alwaysExits() - for whether it always jumps away

    Example

    { 1 }     # can complete
    { break } # cannot
    Copy

• continuesWith: function

  • continuesWith(
        this: void,
        graph: DataflowGraph,
        from: DataflowCfgInformation,
        next: NodeId,
    ): void

    Whatever from completes at continues with next.

    Parameters

    • this: void
    • graph: DataflowGraph
    • from: DataflowCfgInformation
    • next: NodeId

    Returns void

    See

    ControlFlow#branchesTo|branchesTo() - if it only continues under a condition

    Example

    f(); g() # the call to `g` continues what `f` completes
    Copy

• entryOf: function

  • entryOf(this: void, info: DataflowCfgInformation): NodeId

    The node control flow enters the given subtree at.

    Parameters

    • this: void
    • info: DataflowCfgInformation

    Returns NodeId

    Example

    x + 1 # the `+` is entered at `x`
    Copy

• inSequence: function

  • inSequence(
        this: void,
        graph: DataflowGraph,
        parts: readonly (DataflowCfgInformation | undefined)[],
        last?: NodeId,
    ): NodeId | undefined

    The parts run one after the other and the last one continues with last, if it is given. Parts that are undefined are skipped, which keeps optional arguments cheap to handle.

    Parameters

    • this: void
    • graph: DataflowGraph
    • parts: readonly (DataflowCfgInformation | undefined)[]
    • Optionallast: NodeId

    Returns NodeId | undefined

    the node control flow enters the sequence at, or last if there is nothing to enter

    Example

    f(a, b) # `a`, then `b`, then the call
    Copy

• isExpression: function

  • isExpression(this: void, graph: DataflowGraph, id: NodeId): boolean

    Whether the node runs as part of a larger expression instead of as a statement of its own.

    Parameters

    • this: void
    • graph: DataflowGraph
    • id: NodeId

    Returns boolean

    See

    ControlFlow#isStatement|isStatement() - for the other kind

    Example

    print(x + 1) # `x + 1` and `x` are expressions, the call is a statement
    Copy

• isStatement: function

  • isStatement(this: void, graph: DataflowGraph, id: NodeId): boolean

    Whether the node runs as a statement of the program instead of as part of a larger expression. Assignments count as statements wherever they stand.

    Parameters

    • this: void
    • graph: DataflowGraph
    • id: NodeId

    Returns boolean

    See

    ControlFlow#isExpression|isExpression() - for the other kind

    Example

    print(x + 1) # the call is a statement, `x + 1` and `x` are expressions
    Copy

• jumpsTo: function

  • jumpsTo(
        this: void,
        graph: DataflowGraph,
        from: DataflowCfgInformation,
        kind: ExitPointType,
        target: NodeId,
    ): void

    Every jump of the given kind within from lands on target.

    Parameters

    • this: void
    • graph: DataflowGraph
    • from: DataflowCfgInformation
    • kind: ExitPointType
    • target: NodeId

    Returns void

    Example

    while(u) { break } # the `break` lands on the loop it leaves
    Copy

• Readonlyname: "ControlFlow"

• picksOneOf: function

  • picksOneOf(
        this: void,
        graph: DataflowGraph,
        parts: readonly (DataflowCfgInformation | undefined)[],
        from: number,
        joinsAt: NodeId,
        hasDefault: boolean,
    ): NodeId | undefined

    The parts before from run in sequence, the ones after it are alternatives of which at most one runs. Whichever one it is, control joins on joinsAt.

    Parameters

    • this: void
    • graph: DataflowGraph

      the graph to record in

    • parts: readonly (DataflowCfgInformation | undefined)[]

      the arguments of the call, in the order they run

    • from: number

      the index the alternatives start at

    • joinsAt: NodeId

      the call the alternatives belong to

    • hasDefault: boolean

      whether one alternative runs when none of the others matched

    Returns NodeId | undefined

    the node control flow enters the call at

    Example

    switch(k, a = 1, b = 2) # `k`, then one arm, then the switch
    Copy