Class NamedParameterExpression

  • All Implemented Interfaces:
    ProgramPoint, CodeElement, CodeNode<CFG,​Statement,​Edge>, Node<CFG,​Statement,​Edge>, java.lang.Comparable<Statement>

    public class NamedParameterExpression
    extends UnaryExpression
    An expression that can be used to for by-name parameter passing to Calls. In some languages, parameters can be passed in a different order from the one declared in the target procedure's signature. This is made possible by prefixing the expression representing the parameter's value with its name. This expression models the by-name parameter passing, and instances of ParameterAssigningStrategy can use instances of this class to detect which parameter is being assingned.
    • Constructor Detail

      • NamedParameterExpression

        public NamedParameterExpression​(CFG cfg,
                                        CodeLocation location,
                                        java.lang.String parameterName,
                                        Expression subExpression)
        Builds the expression. The static type of this expression is the one of subExpression.
        Parameters:
        cfg - the CFG where this operation lies
        location - the location where this literal is defined
        parameterName - the name of the parameter being assigned here
        subExpression - the expression being assigned to the target parameter
    • Method Detail

      • getParameterName

        public java.lang.String getParameterName()
        Yields the name of the parameter targeted by this expression.
        Returns:
        the name of the parameter
      • equals

        public boolean equals​(java.lang.Object obj)
        Overrides:
        equals in class NaryExpression
      • unarySemantics

        public <A extends AbstractState<A,​H,​V,​T>,​H extends HeapDomain<H>,​V extends ValueDomain<V>,​T extends TypeDomain<T>> AnalysisState<A,​H,​V,​T> unarySemantics​(InterproceduralAnalysis<A,​H,​V,​T> interprocedural,
                                                                                                                                                                                                                       AnalysisState<A,​H,​V,​T> state,
                                                                                                                                                                                                                       SymbolicExpression expr,
                                                                                                                                                                                                                       StatementStore<A,​H,​V,​T> expressions)
                                                                                                                                                                                                                throws SemanticException
        Description copied from class: UnaryExpression
        Computes the semantics of the expression, after the semantics of the sub-expression has been computed. Meta variables from the sub-expression will be forgotten after this expression returns.
        Specified by:
        unarySemantics in class UnaryExpression
        Type Parameters:
        A - the type of AbstractState
        H - the type of the HeapDomain
        V - the type of the ValueDomain
        T - the type of TypeDomain
        Parameters:
        interprocedural - the interprocedural analysis of the program to analyze
        state - the state where the expression is to be evaluated
        expr - the symbolic expressions representing the computed value of the sub-expression of this expression
        expressions - the cache where analysis states of intermediate expressions are stored and that can be accessed to query for post-states of parameters expressions
        Returns:
        the AnalysisState representing the abstract result of the execution of this expression
        Throws:
        SemanticException - if something goes wrong during the computation