Class Concat

    • Field Detail

      • originating

        protected Statement originating
        Statement that has been rewritten to this operation, if any. This is to accomodate the fact that, in most languages, string operations are performed through calls, and one might want to provide the semantics of those calls through NativeCFG that rewrites to instances of this class.
    • Constructor Detail

      • Concat

        public Concat​(CFG cfg,
                      CodeLocation location,
                      Expression left,
                      Expression right)
        Builds the concat.
        Parameters:
        cfg - the CFG where this operation lies
        location - the code location where this operation is defined
        left - the left-hand side of this operation
        right - the right-hand side of this operation
    • Method Detail

      • binarySemantics

        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> binarySemantics​(InterproceduralAnalysis<A,​H,​V,​T> interprocedural,
                                                                                                                                                                                                                        AnalysisState<A,​H,​V,​T> state,
                                                                                                                                                                                                                        SymbolicExpression left,
                                                                                                                                                                                                                        SymbolicExpression right,
                                                                                                                                                                                                                        StatementStore<A,​H,​V,​T> expressions)
                                                                                                                                                                                                                 throws SemanticException
        Description copied from class: BinaryExpression
        Computes the semantics of the expression, after the semantics of the sub-expressions have been computed. Meta variables from the sub-expressions will be forgotten after this expression returns.
        Specified by:
        binarySemantics in class BinaryExpression
        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
        left - the symbolic expression representing the computed value of the first sub-expression of this expression
        right - the symbolic expression representing the computed value of the second 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