svf-lib 1.0.992 → 1.0.993

package/SVF-linux/include/Util/Z3Expr.h

@@ -32,202 +32,249 @@
 #include "z3++.h"
 #include "Util/SVFBasicTypes.h"
 
-namespace SVF {
+namespace SVF
+{
 
-    class Z3Expr {
-    public:
-        static z3::context *ctx;
+class Z3Expr
+{
+public:
+    static z3::context *ctx;
 
-    private:
-        z3::expr e;
+private:
+    z3::expr e;
 
-        Z3Expr(float f); // placeholder don't support floating point expression
-        Z3Expr(double f); // placeholder don't support floating point expression
+    Z3Expr(float f); // placeholder don't support floating point expression
+    Z3Expr(double f); // placeholder don't support floating point expression
 
-    public:
+public:
 
-        Z3Expr() : e(nullExpr()) {
-        }
+    Z3Expr() : e(nullExpr())
+    {
+    }
 
-        Z3Expr(const z3::expr &_e) : e(_e) {
-        }
+    Z3Expr(const z3::expr &_e) : e(_e)
+    {
+    }
 
-        Z3Expr(int i) : e(getContext().int_val(i)) {
-        }
+    Z3Expr(int i) : e(getContext().int_val(i))
+    {
+    }
 
-        Z3Expr(const Z3Expr &z3Expr) : e(z3Expr.getExpr()) {
-        }
+    Z3Expr(const Z3Expr &z3Expr) : e(z3Expr.getExpr())
+    {
+    }
 
-        virtual ~Z3Expr() = default;
+    virtual ~Z3Expr() = default;
 
-        inline Z3Expr &operator=(const Z3Expr &rhs) {
-            if (this->id() != rhs.id()) {
-                e = rhs.getExpr();
-            }
-            return *this;
+    inline Z3Expr &operator=(const Z3Expr &rhs)
+    {
+        if (this->id() != rhs.id())
+        {
+            e = rhs.getExpr();
         }
+        return *this;
+    }
 
-        const z3::expr &getExpr() const {
-            return e;
-        }
+    const z3::expr &getExpr() const
+    {
+        return e;
+    }
 
-        /// Get z3 context, singleton design here to make sure we only have one context
-        static z3::context &getContext() {
-            if (ctx == nullptr) {
-                ctx = new z3::context();
-            }
-            return *ctx;
+    /// Get z3 context, singleton design here to make sure we only have one context
+    static z3::context &getContext()
+    {
+        if (ctx == nullptr)
+        {
+            ctx = new z3::context();
         }
+        return *ctx;
+    }
 
-        /// release z3 context
-        static void releaseContext() {
-            delete ctx;
-            ctx = nullptr;
-        }
+    /// release z3 context
+    static void releaseContext()
+    {
+        delete ctx;
+        ctx = nullptr;
+    }
 
-        /// null expression
-        static z3::expr nullExpr() {
-            return getContext().int_const("null");
-        }
+    /// null expression
+    static z3::expr nullExpr()
+    {
+        return getContext().int_const("null");
+    }
 
-        /// get id
-        inline u32_t id() const {
-            return e.id();
-        }
+    /// get id
+    inline u32_t id() const
+    {
+        return e.id();
+    }
 
-        inline const std::string to_string() const {
-            return e.to_string();
-        }
+    inline const std::string to_string() const
+    {
+        return e.to_string();
+    }
 
-        inline bool is_numeral() const {
-            return e.is_numeral();
-        }
+    inline bool is_numeral() const
+    {
+        return e.is_numeral();
+    }
 
-        inline bool is_bool() const {
-            return e.is_bool();
-        }
+    inline bool is_bool() const
+    {
+        return e.is_bool();
+    }
 
-        inline Z3Expr simplify() const {
-            return e.simplify();
-        }
+    inline Z3Expr simplify() const
+    {
+        return e.simplify();
+    }
 
-        inline int64_t get_numeral_int64() const {
-            return e.get_numeral_int64();
-        }
+    inline int64_t get_numeral_int64() const
+    {
+        return e.get_numeral_int64();
+    }
 
-        inline int get_numeral_int() const {
-            return e.get_numeral_int();
-        }
+    inline int get_numeral_int() const
+    {
+        return e.get_numeral_int();
+    }
 
-        //{% reload operator
-        friend Z3Expr operator==(const Z3Expr &lhs, const Z3Expr &rhs) {
-            return lhs.getExpr() == rhs.getExpr();
-        }
+    //{% reload operator
+    friend Z3Expr operator==(const Z3Expr &lhs, const Z3Expr &rhs)
+    {
+        return lhs.getExpr() == rhs.getExpr();
+    }
 
-        friend Z3Expr operator!=(const Z3Expr &lhs, const Z3Expr &rhs) {
-            return lhs.getExpr() != rhs.getExpr();
-        }
+    friend Z3Expr operator!=(const Z3Expr &lhs, const Z3Expr &rhs)
+    {
+        return lhs.getExpr() != rhs.getExpr();
+    }
 
-        friend Z3Expr operator>(const Z3Expr &lhs, const Z3Expr &rhs) {
-            return lhs.getExpr() > rhs.getExpr();
-        }
+    friend Z3Expr operator>(const Z3Expr &lhs, const Z3Expr &rhs)
+    {
+        return lhs.getExpr() > rhs.getExpr();
+    }
 
-        friend Z3Expr operator<(const Z3Expr &lhs, const Z3Expr &rhs) {
-            return lhs.getExpr() < rhs.getExpr();
-        }
+    friend Z3Expr operator<(const Z3Expr &lhs, const Z3Expr &rhs)
+    {
+        return lhs.getExpr() < rhs.getExpr();
+    }
 
-        friend Z3Expr operator<=(const Z3Expr &lhs, const Z3Expr &rhs) {
-            return lhs.getExpr() <= rhs.getExpr();
-        }
+    friend Z3Expr operator<=(const Z3Expr &lhs, const Z3Expr &rhs)
+    {
+        return lhs.getExpr() <= rhs.getExpr();
+    }
 
-        friend Z3Expr operator>=(const Z3Expr &lhs, const Z3Expr &rhs) {
-            return lhs.getExpr() >= rhs.getExpr();
-        }
+    friend Z3Expr operator>=(const Z3Expr &lhs, const Z3Expr &rhs)
+    {
+        return lhs.getExpr() >= rhs.getExpr();
+    }
 
-        friend Z3Expr operator+(const Z3Expr &lhs, const Z3Expr &rhs) {
-            return lhs.getExpr() + rhs.getExpr();
-        }
+    friend Z3Expr operator+(const Z3Expr &lhs, const Z3Expr &rhs)
+    {
+        return lhs.getExpr() + rhs.getExpr();
+    }
 
-        friend Z3Expr operator-(const Z3Expr &lhs, const Z3Expr &rhs) {
-            return lhs.getExpr() - rhs.getExpr();
-        }
+    friend Z3Expr operator-(const Z3Expr &lhs, const Z3Expr &rhs)
+    {
+        return lhs.getExpr() - rhs.getExpr();
+    }
 
-        friend Z3Expr operator*(const Z3Expr &lhs, const Z3Expr &rhs) {
-            return lhs.getExpr() * rhs.getExpr();
-        }
+    friend Z3Expr operator*(const Z3Expr &lhs, const Z3Expr &rhs)
+    {
+        return lhs.getExpr() * rhs.getExpr();
+    }
 
-        friend Z3Expr operator/(const Z3Expr &lhs, const Z3Expr &rhs) {
-            return lhs.getExpr() / rhs.getExpr();
-        }
+    friend Z3Expr operator/(const Z3Expr &lhs, const Z3Expr &rhs)
+    {
+        return lhs.getExpr() / rhs.getExpr();
+    }
 
-        friend Z3Expr operator%(const Z3Expr &lhs, const Z3Expr &rhs) {
-            return lhs.getExpr() % rhs.getExpr();
-        }
+    friend Z3Expr operator%(const Z3Expr &lhs, const Z3Expr &rhs)
+    {
+        return lhs.getExpr() % rhs.getExpr();
+    }
 
-        friend Z3Expr operator^(const Z3Expr &lhs, const Z3Expr &rhs) {
-            return lhs.getExpr() ^ rhs.getExpr();
-        }
+    friend Z3Expr operator^(const Z3Expr &lhs, const Z3Expr &rhs)
+    {
+        return lhs.getExpr() ^ rhs.getExpr();
+    }
 
-        friend Z3Expr operator&(const Z3Expr &lhs, const Z3Expr &rhs) {
-            return lhs.getExpr() & rhs.getExpr();
-        }
+    friend Z3Expr operator&(const Z3Expr &lhs, const Z3Expr &rhs)
+    {
+        return lhs.getExpr() & rhs.getExpr();
+    }
 
-        friend Z3Expr operator|(const Z3Expr &lhs, const Z3Expr &rhs) {
-            return lhs.getExpr() | rhs.getExpr();
-        }
+    friend Z3Expr operator|(const Z3Expr &lhs, const Z3Expr &rhs)
+    {
+        return lhs.getExpr() | rhs.getExpr();
+    }
 
-        friend Z3Expr ashr(const Z3Expr &lhs, const Z3Expr &rhs) {
-            return ashr(lhs.getExpr(), rhs.getExpr());
-        }
+    friend Z3Expr ashr(const Z3Expr &lhs, const Z3Expr &rhs)
+    {
+        return ashr(lhs.getExpr(), rhs.getExpr());
+    }
 
-        friend Z3Expr shl(const Z3Expr &lhs, const Z3Expr &rhs) {
-            return shl(lhs.getExpr(), rhs.getExpr());
-        }
+    friend Z3Expr shl(const Z3Expr &lhs, const Z3Expr &rhs)
+    {
+        return shl(lhs.getExpr(), rhs.getExpr());
+    }
 
-        friend Z3Expr int2bv(u32_t n, const Z3Expr &e) {
-            return int2bv(n, e.getExpr());
-        }
+    friend Z3Expr int2bv(u32_t n, const Z3Expr &e)
+    {
+        return int2bv(n, e.getExpr());
+    }
 
-        friend Z3Expr bv2int(const Z3Expr &e, bool isSigned) {
-            return z3::bv2int(e.getExpr(), isSigned);
-        }
+    friend Z3Expr bv2int(const Z3Expr &e, bool isSigned)
+    {
+        return z3::bv2int(e.getExpr(), isSigned);
+    }
 
-        friend Z3Expr operator&&(const Z3Expr &lhs, const Z3Expr &rhs) {
-            return lhs.getExpr() && rhs.getExpr();
-        }
+    friend Z3Expr operator&&(const Z3Expr &lhs, const Z3Expr &rhs)
+    {
+        return lhs.getExpr() && rhs.getExpr();
+    }
 
-        friend Z3Expr operator||(const Z3Expr &lhs, const Z3Expr &rhs) {
-            return lhs.getExpr() || rhs.getExpr();
-        }
+    friend Z3Expr operator||(const Z3Expr &lhs, const Z3Expr &rhs)
+    {
+        return lhs.getExpr() || rhs.getExpr();
+    }
 
-        friend Z3Expr operator!(const Z3Expr &lhs) {
-            return !lhs.getExpr();
-        }
+    friend Z3Expr operator!(const Z3Expr &lhs)
+    {
+        return !lhs.getExpr();
+    }
 
-        friend Z3Expr ite(const Z3Expr& cond, const Z3Expr& lhs, const Z3Expr& rhs) {
-            return ite(cond.getExpr(), lhs.getExpr(), rhs.getExpr());
-        }
+    friend Z3Expr ite(const Z3Expr& cond, const Z3Expr& lhs, const Z3Expr& rhs)
+    {
+        return ite(cond.getExpr(), lhs.getExpr(), rhs.getExpr());
+    }
 
-        friend std::ostream &operator<<(std::ostream &out, const Z3Expr &expr) {
-            out << expr.getExpr();
-            return out;
-        }
+    friend std::ostream &operator<<(std::ostream &out, const Z3Expr &expr)
+    {
+        out << expr.getExpr();
+        return out;
+    }
 
-        friend bool eq(const Z3Expr &lhs, const Z3Expr &rhs) {
-            return eq(lhs.getExpr(), rhs.getExpr());
-        }
+    friend bool eq(const Z3Expr &lhs, const Z3Expr &rhs)
+    {
+        return eq(lhs.getExpr(), rhs.getExpr());
+    }
 
-        z3::sort get_sort() const {
-            return getExpr().get_sort();
-        }
-        //%}
-    };
+    z3::sort get_sort() const
+    {
+        return getExpr().get_sort();
+    }
+    //%}
+};
 }
 
 /// Specialise hash for AbsCxtDPItem.
 template<>
-struct std::hash<SVF::Z3Expr> {
-    size_t operator()(const SVF::Z3Expr &z3Expr) const {
+struct std::hash<SVF::Z3Expr>
+{
+    size_t operator()(const SVF::Z3Expr &z3Expr) const
+    {
         return z3Expr.id();
     }
 };

package/SVF-linux/include/WPA/Andersen.h

@@ -85,16 +85,16 @@ public:
     static inline bool classof(const PointerAnalysis *pta)
     {
         return ( pta->getAnalysisTy() == Andersen_BASE
-				|| pta->getAnalysisTy() == Andersen_WPA
-                || pta->getAnalysisTy() == AndersenLCD_WPA
-                || pta->getAnalysisTy() == AndersenHCD_WPA
-                || pta->getAnalysisTy() == AndersenHLCD_WPA
-                || pta->getAnalysisTy() == AndersenWaveDiff_WPA
-                || pta->getAnalysisTy() == AndersenWaveDiffWithType_WPA
-                || pta->getAnalysisTy() == AndersenSCD_WPA
-                || pta->getAnalysisTy() == AndersenSFR_WPA
-				|| pta->getAnalysisTy() == TypeCPP_WPA
-				|| pta->getAnalysisTy() == Steensgaard_WPA);
+                 || pta->getAnalysisTy() == Andersen_WPA
+                 || pta->getAnalysisTy() == AndersenLCD_WPA
+                 || pta->getAnalysisTy() == AndersenHCD_WPA
+                 || pta->getAnalysisTy() == AndersenHLCD_WPA
+                 || pta->getAnalysisTy() == AndersenWaveDiff_WPA
+                 || pta->getAnalysisTy() == AndersenWaveDiffWithType_WPA
+                 || pta->getAnalysisTy() == AndersenSCD_WPA
+                 || pta->getAnalysisTy() == AndersenSFR_WPA
+                 || pta->getAnalysisTy() == TypeCPP_WPA
+                 || pta->getAnalysisTy() == Steensgaard_WPA);
     }
     //@}
 
@@ -190,7 +190,7 @@ public:
     static inline bool classof(const PointerAnalysis *pta)
     {
         return (pta->getAnalysisTy() == Andersen_WPA
-				|| pta->getAnalysisTy() == AndersenLCD_WPA
+                || pta->getAnalysisTy() == AndersenLCD_WPA
                 || pta->getAnalysisTy() == AndersenHCD_WPA
                 || pta->getAnalysisTy() == AndersenHLCD_WPA
                 || pta->getAnalysisTy() == AndersenWaveDiff_WPA

package/SVF-linux/include/WPA/VersionedFlowSensitive.h

@@ -99,7 +99,10 @@ protected:
     virtual void updateConnectedNodes(const SVFGEdgeSetTy& newEdges) override;
 
     /// Override to do nothing. Instead, we will use propagateVersion when necessary.
-    virtual bool propAlongIndirectEdge(const IndirectSVFGEdge*) override { return false; }
+    virtual bool propAlongIndirectEdge(const IndirectSVFGEdge*) override
+    {
+        return false;
+    }
 
     /// Override since we want to assign different weights based on versioning.
     virtual void cluster(void) override;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svf-lib",
-  "version": "1.0.992",
+  "version": "1.0.993",
   "description": "SVF's npm support",
   "main": "index.js",
   "scripts": {