accrue.analysis.ext

## Interface AccrueExt

- All Superinterfaces:
    java.lang.Cloneable, polyglot.util.Copy<polyglot.ast.Ext>, polyglot.ast.Ext, polyglot.ast.NodeOps, java.io.Serializable
  All Known Subinterfaces:
    ExtAlloc, ExtProcedureCall
  All Known Implementing Classes:
    AccrueExt_c, ExtArrayAccess, ExtArrayAccessAssign, ExtArrayInit, ExtAssert, ExtBinary, ExtBlock, ExtBranch, ExtCall, ExtCast, ExtCatch, ExtCodeDecl, ExtConditional, ExtConstructorCall, ExtConstructorDecl, ExtDo, ExtEmpty, ExtEnumConstant, ExtEnumConstantDecl, ExtEval, ExtExpr, ExtField, ExtFieldAssign, ExtFieldDecl, ExtFormal, ExtIf, ExtInitializer, ExtInstanceof, ExtLabeled, ExtLit, ExtLocal, ExtLocalAssign, ExtLocalDecl, ExtLoop, ExtMethodDecl, ExtNew, ExtNewArray, ExtPrimitiveExpr, ExtProcedureDecl, ExtReturn, ExtSpecial, ExtSuppress, ExtSwitch, ExtSynchronized, ExtTerm, ExtThrow, ExtTry, ExtTypeNode, ExtUnary, ExtWhile

      public interface AccrueExt
      extends polyglot.ast.Ext

- - ### Nested Class Summary

    - ### Nested classes/interfaces inherited from interface polyglot.util.Copy

      `polyglot.util.Copy.Util`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `java.lang.Integer` | `enclosingFinallyDepth()` How many enclosing finally blocks is this node nested inside? This information is used during dataflow analysis to help manage syspended execution contexts.
    `<T> T` | `getAnalysisResult(java.lang.Object analysisKey)`
    `<T> T` | `getAnalysisResult(java.lang.Object analysisKey, AnalysisContext context)`
    `<T> T` | `getAnalysisResult(java.lang.Object analysisKey, AnalysisContext context, polyglot.visit.FlowGraph.PeerKey peerKey)`
    `int` | `numArgumentsOnResultStack()` During a dataflow analysis, when this term is encountered, how many arguments should there be on the expression result stack? For example, for an addition (e1 + e2) there will be two, one for each operand.
    `<T> void` | `recordAnalysisResult(java.lang.Object analysisKey, AnalysisContext context, polyglot.visit.FlowGraph.PeerKey peerKey, T result)`
    `<T> void` | `recordAnalysisResult(java.lang.Object analysisKey, AnalysisContext context, T result)`
    `<T> void` | `recordAnalysisResult(java.lang.Object analysisKey, T result)`
    `void` | `registerPointerStmts(StmtRegistrar registrar, RegisterPointerStmtsVisitor v)`
    `<T> T` | `removeAnalysisResult(java.lang.Object analysisKey)`
    `<T> T` | `removeAnalysisResult(java.lang.Object analysisKey, AnalysisContext context)`
    `<T> T` | `removeAnalysisResult(java.lang.Object analysisKey, AnalysisContext context, polyglot.visit.FlowGraph.PeerKey peerKey)`
    `void` | `setEnclosingFinallyDepth(int finallyDepth)` Set the number of finally blocks that this node is nested inside.

    - ### Methods inherited from interface polyglot.ast.Ext

      `dump, ext, ext, init, initPred, node, pred`

    - ### Methods inherited from interface polyglot.ast.NodeOps

      `addDecls, buildTypes, buildTypesEnter, checkConstants, childExpectedType, copy, copy, disambiguate, disambiguateEnter, disambiguateOverride, dump, dump, dump, dump, enterChildScope, enterScope, exceptionCheck, exceptionCheckEnter, extRewrite, extRewriteEnter, lang, prettyPrint, prettyPrint, prettyPrint, prettyPrint, prettyPrint, throwTypes, translate, typeCheck, typeCheckEnter, typeCheckOverride, visitChild, visitChildren, visitList`

    - ### Methods inherited from interface polyglot.util.Copy

      `copy`

- - ### Method Detail

    - #### registerPointerStmts

          void registerPointerStmts(StmtRegistrar registrar,
                                  RegisterPointerStmtsVisitor v)

    - #### recordAnalysisResult

          <T> void recordAnalysisResult(java.lang.Object analysisKey,
                                      T result)

    - #### recordAnalysisResult

          <T> void recordAnalysisResult(java.lang.Object analysisKey,
                                      AnalysisContext context,
                                      polyglot.visit.FlowGraph.PeerKey peerKey,
                                      T result)

    - #### recordAnalysisResult

          <T> void recordAnalysisResult(java.lang.Object analysisKey,
                                      AnalysisContext context,
                                      T result)

    - #### removeAnalysisResult

          <T> T removeAnalysisResult(java.lang.Object analysisKey)

    - #### removeAnalysisResult

          <T> T removeAnalysisResult(java.lang.Object analysisKey,
                                   AnalysisContext context,
                                   polyglot.visit.FlowGraph.PeerKey peerKey)

    - #### removeAnalysisResult

          <T> T removeAnalysisResult(java.lang.Object analysisKey,
                                   AnalysisContext context)

    - #### getAnalysisResult

          <T> T getAnalysisResult(java.lang.Object analysisKey,
                                AnalysisContext context,
                                polyglot.visit.FlowGraph.PeerKey peerKey)

    - #### getAnalysisResult

          <T> T getAnalysisResult(java.lang.Object analysisKey,
                                AnalysisContext context)

    - #### getAnalysisResult

          <T> T getAnalysisResult(java.lang.Object analysisKey)

    - #### numArgumentsOnResultStack

          int numArgumentsOnResultStack()

      During a dataflow analysis, when this term is encountered, how many arguments should there be on the expression result stack? For example, for an addition (e1 + e2) there will be two, one for each operand. For a field access (o.f) there will be one, the target of the access. In general, this will return a meaningful number only for expressions.
      Returns:
      See Also:
        `VarContextDataFlow`

    - #### enclosingFinallyDepth

          java.lang.Integer enclosingFinallyDepth()

      How many enclosing finally blocks is this node nested inside? This information is used during dataflow analysis to help manage syspended execution contexts. Example depths are given here.

           void m() {
             ; // finally depth here is 0
             try {
               ; // finally depth here is 0
             }
             finally {
               ; // finally depth here is 1
               try {
                 ; // finally depth here is 1
               }
               catch (Exception e) {
                 ; // finally depth here is 1
                 ...
               }
               finally {
                 ; // finally depth here is 2
               }
               ; // finally depth here is 1
             }
             ; // finally depth here is 0
           }

      Note that for a finally block node, the number of enclosing finally blocks does not include itself.
      Returns:
        Number of enclosing finally blocks, null if not yet computed.

    - #### setEnclosingFinallyDepth

          void setEnclosingFinallyDepth(int finallyDepth)

      Set the number of finally blocks that this node is nested inside.
      Parameters:
        `finallyDepth` -