svf-lib 1.0.2125 → 1.0.2126

package/SVF-osx/Release-build/include/SVF-LLVM/LLVMModule.h

@@ -166,22 +166,22 @@ public:
     inline void addFunctionMap(const Function* func, SVFFunction* svfFunc)
     {
         LLVMFunc2SVFFunc[func] = svfFunc;
-        setValueAttr(func,svfFunc);
+        setValueAttr(func, svfFunc);
     }
     inline void addBasicBlockMap(const BasicBlock* bb, SVFBasicBlock* svfBB)
     {
         LLVMBB2SVFBB[bb] = svfBB;
-        setValueAttr(bb,svfBB);
+        setValueAttr(bb, svfBB);
     }
     inline void addInstructionMap(const Instruction* inst, SVFInstruction* svfInst)
     {
         LLVMInst2SVFInst[inst] = svfInst;
-        setValueAttr(inst,svfInst);
+        setValueAttr(inst, svfInst);
     }
     inline void addArgumentMap(const Argument* arg, SVFArgument* svfArg)
     {
         LLVMArgument2SVFArgument[arg] = svfArg;
-        setValueAttr(arg,svfArg);
+        setValueAttr(arg, svfArg);
     }
     inline void addGlobalValueMap(const GlobalValue* glob, SVFGlobalValue* svfglob)
     {

package/SVF-osx/Release-build/include/SVF-LLVM/LLVMUtil.h

@@ -233,10 +233,10 @@ inline const ConstantExpr* isTruncConstantExpr(const Value* val)
     if (const ConstantExpr* constExpr = SVFUtil::dyn_cast<ConstantExpr>(val))
     {
         if (constExpr->getOpcode() == Instruction::Trunc ||
-                constExpr->getOpcode() == Instruction::FPTrunc ||
-                constExpr->getOpcode() == Instruction::ZExt ||
-                constExpr->getOpcode() == Instruction::SExt ||
-                constExpr->getOpcode() == Instruction::FPExt)
+        constExpr->getOpcode() == Instruction::FPTrunc ||
+        constExpr->getOpcode() == Instruction::ZExt ||
+        constExpr->getOpcode() == Instruction::SExt ||
+        constExpr->getOpcode() == Instruction::FPExt)
             return constExpr;
     }
     return nullptr;
@@ -247,7 +247,7 @@ inline const ConstantExpr* isCmpConstantExpr(const Value* val)
     if (const ConstantExpr* constExpr = SVFUtil::dyn_cast<ConstantExpr>(val))
     {
         if (constExpr->getOpcode() == Instruction::ICmp ||
-                constExpr->getOpcode() == Instruction::FCmp)
+        constExpr->getOpcode() == Instruction::FCmp)
             return constExpr;
     }
     return nullptr;
@@ -297,7 +297,7 @@ void getNextInsts(const Instruction* curInst,
 inline bool isNoPrecessorBasicBlock(const BasicBlock* bb)
 {
     return bb != &bb->getParent()->getEntryBlock() &&
-           pred_empty(bb);
+                 pred_empty(bb);
 }
 
 /// Check whether a file is an LLVM IR file

package/SVF-osx/Release-build/include/SVFIR/SVFFileSystem.h

@@ -620,7 +620,7 @@ private:
 
     template <typename T,
               typename = std::enable_if_t<SVFUtil::is_iterable_v<T>>>
-                                          cJSON* toJson(const T& container)
+    cJSON* toJson(const T& container)
     {
         cJSON* array = jsonCreateArray();
         for (const auto& item : container)
@@ -792,7 +792,7 @@ public:
     template <typename FillFunc> void fillObjs(FillFunc fillFunc)
     {
         assert(jsonArray.size() == ptrPool.size() &&
-               "jsonArray and ptrPool should have same size");
+                                   "jsonArray and ptrPool should have same size");
         for (size_t i = 0; i < jsonArray.size(); ++i)
         {
             const cJSON*& objFieldJson = jsonArray[i];

package/SVF-osx/Release-build/include/SVFIR/SVFIR.h

@@ -202,7 +202,7 @@ public:
     inline bool hasPTASVFStmtList(const ICFGNode* inst) const
     {
         return icfgNode2PTASVFStmtsMap.find(inst) !=
-               icfgNode2PTASVFStmtsMap.end();
+                   icfgNode2PTASVFStmtsMap.end();
     }
     /// Given an instruction, get all its PAGEdges
     inline SVFStmtList& getSVFStmtList(const ICFGNode* inst)
@@ -601,16 +601,16 @@ private:
     inline NodeID addValNode(const SVFValue*, SVFVar *node, NodeID i)
     {
         assert(hasGNode(i) == false &&
-               "This NodeID clashes here. Please check NodeIDAllocator. Switch "
-               "Strategy::DBUG to SEQ or DENSE");
+                              "This NodeID clashes here. Please check NodeIDAllocator. Switch "
+                              "Strategy::DBUG to SEQ or DENSE");
         return addNode(node, i);
     }
     /// Add a memory obj node
     inline NodeID addObjNode(const SVFValue*, SVFVar *node, NodeID i)
     {
         assert(hasGNode(i) == false &&
-               "This NodeID clashes here. Please check NodeIDAllocator. Switch "
-               "Strategy::DBUG to SEQ or DENSE");
+                              "This NodeID clashes here. Please check NodeIDAllocator. Switch "
+                              "Strategy::DBUG to SEQ or DENSE");
         return addNode(node, i);
     }
     /// Add a unique return node for a procedure

package/SVF-osx/Release-build/include/SVFIR/SVFStatements.h

@@ -107,20 +107,20 @@ public:
     static inline bool classof(const GenericPAGEdgeTy* edge)
     {
         return edge->getEdgeKind() == SVFStmt::Addr ||
-               edge->getEdgeKind() == SVFStmt::Copy ||
-               edge->getEdgeKind() == SVFStmt::Store ||
-               edge->getEdgeKind() == SVFStmt::Load ||
-               edge->getEdgeKind() == SVFStmt::Call ||
-               edge->getEdgeKind() == SVFStmt::Ret ||
-               edge->getEdgeKind() == SVFStmt::Gep ||
-               edge->getEdgeKind() == SVFStmt::Phi ||
-               edge->getEdgeKind() == SVFStmt::Select ||
-               edge->getEdgeKind() == SVFStmt::Cmp ||
-               edge->getEdgeKind() == SVFStmt::BinaryOp ||
-               edge->getEdgeKind() == SVFStmt::UnaryOp ||
-               edge->getEdgeKind() == SVFStmt::Branch ||
-               edge->getEdgeKind() == SVFStmt::ThreadFork ||
-               edge->getEdgeKind() == SVFStmt::ThreadJoin;
+        edge->getEdgeKind() == SVFStmt::Copy ||
+        edge->getEdgeKind() == SVFStmt::Store ||
+        edge->getEdgeKind() == SVFStmt::Load ||
+        edge->getEdgeKind() == SVFStmt::Call ||
+        edge->getEdgeKind() == SVFStmt::Ret ||
+        edge->getEdgeKind() == SVFStmt::Gep ||
+        edge->getEdgeKind() == SVFStmt::Phi ||
+        edge->getEdgeKind() == SVFStmt::Select ||
+        edge->getEdgeKind() == SVFStmt::Cmp ||
+        edge->getEdgeKind() == SVFStmt::BinaryOp ||
+        edge->getEdgeKind() == SVFStmt::UnaryOp ||
+        edge->getEdgeKind() == SVFStmt::Branch ||
+        edge->getEdgeKind() == SVFStmt::ThreadFork ||
+        edge->getEdgeKind() == SVFStmt::ThreadJoin;
     }
     ///@}
 
@@ -264,26 +264,26 @@ public:
     static inline bool classof(const SVFStmt* edge)
     {
         return edge->getEdgeKind() == SVFStmt::Addr ||
-               edge->getEdgeKind() == SVFStmt::Copy ||
-               edge->getEdgeKind() == SVFStmt::Store ||
-               edge->getEdgeKind() == SVFStmt::Load ||
-               edge->getEdgeKind() == SVFStmt::Call ||
-               edge->getEdgeKind() == SVFStmt::Ret ||
-               edge->getEdgeKind() == SVFStmt::Gep ||
-               edge->getEdgeKind() == SVFStmt::ThreadFork ||
-               edge->getEdgeKind() == SVFStmt::ThreadJoin;
+        edge->getEdgeKind() == SVFStmt::Copy ||
+        edge->getEdgeKind() == SVFStmt::Store ||
+        edge->getEdgeKind() == SVFStmt::Load ||
+        edge->getEdgeKind() == SVFStmt::Call ||
+        edge->getEdgeKind() == SVFStmt::Ret ||
+        edge->getEdgeKind() == SVFStmt::Gep ||
+        edge->getEdgeKind() == SVFStmt::ThreadFork ||
+        edge->getEdgeKind() == SVFStmt::ThreadJoin;
     }
     static inline bool classof(const GenericPAGEdgeTy* edge)
     {
         return edge->getEdgeKind() == SVFStmt::Addr ||
-               edge->getEdgeKind() == SVFStmt::Copy ||
-               edge->getEdgeKind() == SVFStmt::Store ||
-               edge->getEdgeKind() == SVFStmt::Load ||
-               edge->getEdgeKind() == SVFStmt::Call ||
-               edge->getEdgeKind() == SVFStmt::Ret ||
-               edge->getEdgeKind() == SVFStmt::Gep ||
-               edge->getEdgeKind() == SVFStmt::ThreadFork ||
-               edge->getEdgeKind() == SVFStmt::ThreadJoin;
+        edge->getEdgeKind() == SVFStmt::Copy ||
+        edge->getEdgeKind() == SVFStmt::Store ||
+        edge->getEdgeKind() == SVFStmt::Load ||
+        edge->getEdgeKind() == SVFStmt::Call ||
+        edge->getEdgeKind() == SVFStmt::Ret ||
+        edge->getEdgeKind() == SVFStmt::Gep ||
+        edge->getEdgeKind() == SVFStmt::ThreadFork ||
+        edge->getEdgeKind() == SVFStmt::ThreadJoin;
     }
     //@}
 
@@ -633,12 +633,12 @@ public:
     static inline bool classof(const SVFStmt* edge)
     {
         return edge->getEdgeKind() == SVFStmt::Call ||
-               edge->getEdgeKind() == SVFStmt::ThreadFork;
+        edge->getEdgeKind() == SVFStmt::ThreadFork;
     }
     static inline bool classof(const GenericPAGEdgeTy* edge)
     {
         return edge->getEdgeKind() == SVFStmt::Call ||
-               edge->getEdgeKind() == SVFStmt::ThreadFork;
+        edge->getEdgeKind() == SVFStmt::ThreadFork;
     }
     //@}
 
@@ -694,12 +694,12 @@ public:
     static inline bool classof(const SVFStmt* edge)
     {
         return edge->getEdgeKind() == SVFStmt::Ret ||
-               edge->getEdgeKind() == SVFStmt::ThreadJoin;
+        edge->getEdgeKind() == SVFStmt::ThreadJoin;
     }
     static inline bool classof(const GenericPAGEdgeTy* edge)
     {
         return edge->getEdgeKind() == SVFStmt::Ret ||
-               edge->getEdgeKind() == SVFStmt::ThreadJoin;
+        edge->getEdgeKind() == SVFStmt::ThreadJoin;
     }
     //@}
 
@@ -763,12 +763,12 @@ public:
     static inline bool classof(const SVFStmt* node)
     {
         return node->getEdgeKind() == Phi || node->getEdgeKind() == Select ||
-               node->getEdgeKind() == BinaryOp || node->getEdgeKind() == Cmp;
+        node->getEdgeKind() == BinaryOp || node->getEdgeKind() == Cmp;
     }
     static inline bool classof(const GenericPAGEdgeTy* node)
     {
         return node->getEdgeKind() == Phi || node->getEdgeKind() == Select ||
-               node->getEdgeKind() == BinaryOp || node->getEdgeKind() == Cmp;
+        node->getEdgeKind() == BinaryOp || node->getEdgeKind() == Cmp;
     }
     //@}
     /// Operands and result at a BinaryNode e.g., p = q + r, `p` is resVar and
@@ -853,14 +853,14 @@ public:
         : MultiOpndStmt(s, opnds, SVFStmt::Phi), opICFGNodes(icfgNodes)
     {
         assert(opnds.size() == icfgNodes.size() &&
-               "Numbers of operands and their ICFGNodes are not consistent?");
+                               "Numbers of operands and their ICFGNodes are not consistent?");
     }
     void addOpVar(SVFVar* op, const ICFGNode* inode)
     {
         opVars.push_back(op);
         opICFGNodes.push_back(inode);
         assert(opVars.size() == opICFGNodes.size() &&
-               "Numbers of operands and their ICFGNodes are not consistent?");
+                                "Numbers of operands and their ICFGNodes are not consistent?");
     }
 
     /// Return the corresponding ICFGNode of this operand
@@ -1247,7 +1247,8 @@ public:
 /*!
  * Thread Fork
  */
-class TDForkPE: public CallPE
+class TDForkPE:
+    public CallPE
 {
     friend class SVFIRWriter;
     friend class SVFIRReader;
@@ -1288,7 +1289,8 @@ public:
 /*!
  * Thread Join
  */
-class TDJoinPE: public RetPE
+class TDJoinPE:
+    public RetPE
 {
     friend class SVFIRWriter;
     friend class SVFIRReader;

package/SVF-osx/Release-build/include/SVFIR/SVFValue.h

@@ -149,7 +149,7 @@ public:
     inline bool isUnreachable(const SVFBasicBlock* bb) const
     {
         return std::find(reachableBBs.begin(), reachableBBs.end(), bb) ==
-               reachableBBs.end();
+                   reachableBBs.end();
     }
 
     inline const BBList& getReachableBBs() const
@@ -215,7 +215,7 @@ protected:
     /// Constructor without name
     SVFValue(const SVFType* ty, SVFValKind k)
         : kind(k), ptrInUncalledFun(false),
-          constDataOrAggData(SVFConstData == k), type(ty), sourceLoc("NoLoc")
+        constDataOrAggData(SVFConstData == k), type(ty), sourceLoc("NoLoc")
     {
     }
 
@@ -540,7 +540,7 @@ protected:
     inline void addICFGNode(const ICFGNode* icfgNode)
     {
         assert(std::find(getICFGNodeList().begin(), getICFGNodeList().end(),
-                         icfgNode) == getICFGNodeList().end() && "duplicated icfgnode");
+        icfgNode) == getICFGNodeList().end() && "duplicated icfgnode");
         allICFGNodes.push_back(icfgNode);
     }
 
@@ -641,8 +641,8 @@ public:
     static inline bool classof(const SVFValue *node)
     {
         return node->getKind() == SVFInst ||
-               node->getKind() == SVFCall ||
-               node->getKind() == SVFVCall;
+        node->getKind() == SVFCall ||
+        node->getKind() == SVFVCall;
     }
 
     inline const SVFBasicBlock* getParent() const
@@ -808,12 +808,12 @@ public:
     static inline bool classof(const SVFValue *node)
     {
         return node->getKind() == SVFConst ||
-               node->getKind() == SVFGlob ||
-               node->getKind() == SVFConstData ||
-               node->getKind() == SVFConstInt ||
-               node->getKind() == SVFConstFP ||
-               node->getKind() == SVFNullPtr ||
-               node->getKind() == SVFBlackHole;
+        node->getKind() == SVFGlob ||
+        node->getKind() == SVFConstData ||
+        node->getKind() == SVFConstInt ||
+        node->getKind() == SVFConstFP ||
+        node->getKind() == SVFNullPtr ||
+        node->getKind() == SVFBlackHole;
     }
 
 };
@@ -913,18 +913,18 @@ public:
     static inline bool classof(const SVFValue *node)
     {
         return node->getKind() == SVFConstData ||
-               node->getKind() == SVFConstInt ||
-               node->getKind() == SVFConstFP ||
-               node->getKind() == SVFNullPtr ||
-               node->getKind() == SVFBlackHole;
+        node->getKind() == SVFConstInt ||
+        node->getKind() == SVFConstFP ||
+        node->getKind() == SVFNullPtr ||
+        node->getKind() == SVFBlackHole;
     }
     static inline bool classof(const SVFConstantData *node)
     {
         return node->getKind() == SVFConstData ||
-               node->getKind() == SVFConstInt ||
-               node->getKind() == SVFConstFP ||
-               node->getKind() == SVFNullPtr ||
-               node->getKind() == SVFBlackHole;
+        node->getKind() == SVFConstInt ||
+        node->getKind() == SVFConstFP ||
+        node->getKind() == SVFNullPtr ||
+        node->getKind() == SVFBlackHole;
     }
 };
 

package/SVF-osx/Release-build/include/SVFIR/SVFVariables.h

@@ -83,8 +83,8 @@ public:
     inline const SVFValue* getValue() const
     {
         assert(this->getNodeKind() != DummyValNode &&
-               this->getNodeKind() != DummyObjNode &&
-               "dummy node do not have value!");
+                                      this->getNodeKind() != DummyObjNode &&
+                                          "dummy node do not have value!");
         assert(!SymbolTableInfo::isBlkObjOrConstantObj(this->getId()) &&
                "blackhole and constant obj do not have value");
         assert(value &&

package/SVF-osx/Release-build/include/Util/Casting.h

@@ -217,8 +217,8 @@ struct isa_impl_wrap
     static bool doit(const From &Val)
     {
         return isa_impl_wrap<To, SimpleFrom,
-               typename simplify_type<SimpleFrom>::SimpleType>::doit(
-                   simplify_type<const From>::getSimplifiedValue(Val));
+        typename simplify_type<SimpleFrom>::SimpleType>::doit(
+            simplify_type<const From>::getSimplifiedValue(Val));
     }
 };
 
@@ -285,11 +285,11 @@ template<class To, class From> struct cast_retty_impl<To, const From*const>
 template <class To, class From>
 struct cast_retty_impl<To, std::unique_ptr<From>>
 {
-private:
+    private:
     using PointerType = typename cast_retty_impl<To, From *>::ret_type;
     using ResultType = typename std::remove_pointer<PointerType>::type;
 
-public:
+    public:
     using ret_type = std::unique_ptr<ResultType>;
 };
 
@@ -325,8 +325,8 @@ template<class To, class From, class SimpleFrom> struct cast_convert_val
     static typename cast_retty<To, From>::ret_type doit(From &Val)
     {
         return cast_convert_val<To, SimpleFrom,
-               typename simplify_type<SimpleFrom>::SimpleType>::doit(
-                   simplify_type<From>::getSimplifiedValue(Val));
+        typename simplify_type<SimpleFrom>::SimpleType>::doit(
+            simplify_type<From>::getSimplifiedValue(Val));
     }
 };
 

package/SVF-osx/Release-build/include/Util/GeneralType.h

@@ -98,30 +98,30 @@ using Set = std::unordered_set<Key, Hash, KeyEqual, Allocator>;
 template <typename Key, typename Value, typename Hash = Hash<Key>,
           typename KeyEqual = std::equal_to<Key>,
           typename Allocator = std::allocator<std::pair<const Key, Value>>>
-              using Map = std::unordered_map<Key, Value, Hash, KeyEqual, Allocator>;
-
-          template <typename Key, typename Compare = std::less<Key>,
-                    typename Allocator = std::allocator<Key>>
-          using OrderedSet = std::set<Key, Compare, Allocator>;
-
-          template <typename Key, typename Value, typename Compare = std::less<Key>,
-                    typename Allocator = std::allocator<std::pair<const Key, Value>>>
-                        using OrderedMap = std::map<Key, Value, Compare, Allocator>;
-
-                    typedef std::pair<NodeID, NodeID> NodePair;
-                    typedef OrderedSet<NodeID> OrderedNodeSet;
-                    typedef Set<NodeID> NodeSet;
-                    typedef Set<NodePair> NodePairSet;
-                    typedef Map<NodePair, NodeID> NodePairMap;
-                    typedef std::vector<NodeID> NodeVector;
-                    typedef std::vector<EdgeID> EdgeVector;
-                    typedef std::stack<NodeID> NodeStack;
-                    typedef std::list<NodeID> NodeList;
-                    typedef std::deque<NodeID> NodeDeque;
-                    typedef NodeSet EdgeSet;
-                    typedef std::vector<u32_t> CallStrCxt;
-                    typedef unsigned Version;
-                    typedef Set<Version> VersionSet;
-                    typedef std::pair<NodeID, Version> VersionedVar;
-                    typedef Set<VersionedVar> VersionedVarSet;
+using Map = std::unordered_map<Key, Value, Hash, KeyEqual, Allocator>;
+
+template <typename Key, typename Compare = std::less<Key>,
+          typename Allocator = std::allocator<Key>>
+using OrderedSet = std::set<Key, Compare, Allocator>;
+
+template <typename Key, typename Value, typename Compare = std::less<Key>,
+          typename Allocator = std::allocator<std::pair<const Key, Value>>>
+using OrderedMap = std::map<Key, Value, Compare, Allocator>;
+
+typedef std::pair<NodeID, NodeID> NodePair;
+typedef OrderedSet<NodeID> OrderedNodeSet;
+typedef Set<NodeID> NodeSet;
+typedef Set<NodePair> NodePairSet;
+typedef Map<NodePair, NodeID> NodePairMap;
+typedef std::vector<NodeID> NodeVector;
+typedef std::vector<EdgeID> EdgeVector;
+typedef std::stack<NodeID> NodeStack;
+typedef std::list<NodeID> NodeList;
+typedef std::deque<NodeID> NodeDeque;
+typedef NodeSet EdgeSet;
+typedef std::vector<u32_t> CallStrCxt;
+typedef unsigned Version;
+typedef Set<Version> VersionSet;
+typedef std::pair<NodeID, Version> VersionedVar;
+typedef Set<VersionedVar> VersionedVarSet;
 }

package/SVF-osx/Release-build/include/Util/SVFUtil.h

@@ -356,8 +356,8 @@ inline const SVFFunction* getProgEntryFunction(SVFModule* svfModule)
 inline bool isProgExitFunction (const SVFFunction * fun)
 {
     return fun && (fun->getName() == "exit" ||
-                   fun->getName() == "__assert_rtn" ||
-                   fun->getName() == "__assert_fail" );
+    fun->getName() == "__assert_rtn" ||
+    fun->getName() == "__assert_fail" );
 }
 
 /// Return true if this argument belongs to an uncalled function
@@ -480,7 +480,7 @@ template <typename... Ts> using void_t = typename make_void<Ts...>::type;
 template <typename T, typename = void> struct is_iterable : std::false_type {};
 template <typename T>
 struct is_iterable<T, void_t<decltype(std::begin(std::declval<T&>()) !=
-                                      std::end(std::declval<T&>()))>>
+        std::end(std::declval<T&>()))>>
     : std::true_type {};
 template <typename T> constexpr bool is_iterable_v = is_iterable<T>::value;
 ///@}

package/SVF-osx/Release-build/include/Util/SparseBitVector.h

@@ -388,7 +388,7 @@ public:
         unsigned BitPos = Curr % BITWORD_SIZE;
         BitWord Copy = Bits[WordPos];
         assert(WordPos <= BITWORDS_PER_ELEMENT
-               && "Word Position outside of element");
+                          && "Word Position outside of element");
 
         // Mask off previous bits.
         Copy &= ~0UL << BitPos;
@@ -552,13 +552,13 @@ class SparseBitVector
         else if (CurrElementIter->index() > ElementIndex)
         {
             while (ElementIter != Begin
-                    && ElementIter->index() > ElementIndex)
+                                  && ElementIter->index() > ElementIndex)
                 --ElementIter;
         }
         else
         {
             while (ElementIter != End &&
-                    ElementIter->index() < ElementIndex)
+                                  ElementIter->index() < ElementIndex)
                 ++ElementIter;
         }
         CurrElementIter = ElementIter;
@@ -758,7 +758,7 @@ public:
         // If we can't find an element that is supposed to contain this bit, there
         // is nothing more to do.
         if (ElementIter == Elements.end() ||
-                ElementIter->index() != ElementIndex)
+                           ElementIter->index() != ElementIndex)
             return false;
         return ElementIter->test(Idx % ElementSize);
     }
@@ -774,7 +774,7 @@ public:
         // If we can't find an element that is supposed to contain this bit, there
         // is nothing more to do.
         if (ElementIter == Elements.end() ||
-                ElementIter->index() != ElementIndex)
+                           ElementIter->index() != ElementIndex)
             return;
         ElementIter->reset(Idx % ElementSize);
 
@@ -799,13 +799,13 @@ public:
             ElementIter = FindLowerBound(ElementIndex);
 
             if (ElementIter == Elements.end() ||
-                    ElementIter->index() != ElementIndex)
+                               ElementIter->index() != ElementIndex)
             {
                 // We may have hit the beginning of our SparseBitVector, in which case,
                 // we may need to insert right after this element, which requires moving
                 // the current iterator forward one, because insert does insert before.
                 if (ElementIter != Elements.end() &&
-                        ElementIter->index() < ElementIndex)
+                                   ElementIter->index() < ElementIndex)
                     ++ElementIter;
                 ElementIter = Elements.emplace(ElementIter, ElementIndex);
             }

package/SVF-osx/Release-build/include/Util/iterator.h

@@ -173,7 +173,7 @@ public:
             IsRandomAccess,
             "Relational operators are only defined for random access iterators.");
         return !(static_cast<const DerivedT &>(*this) < RHS) &&
-               !(static_cast<const DerivedT &>(*this) == RHS);
+        !(static_cast<const DerivedT &>(*this) == RHS);
     }
     bool operator<=(const DerivedT &RHS) const
     {

package/SVF-osx/Release-build/include/WPA/Andersen.h

@@ -109,12 +109,12 @@ public:
     static inline bool classof(const PointerAnalysis *pta)
     {
         return ( pta->getAnalysisTy() == Andersen_BASE
-                 || pta->getAnalysisTy() == Andersen_WPA
-                 || pta->getAnalysisTy() == AndersenWaveDiff_WPA
-                 || pta->getAnalysisTy() == AndersenSCD_WPA
-                 || pta->getAnalysisTy() == AndersenSFR_WPA
-                 || pta->getAnalysisTy() == TypeCPP_WPA
-                 || pta->getAnalysisTy() == Steensgaard_WPA);
+        || pta->getAnalysisTy() == Andersen_WPA
+        || pta->getAnalysisTy() == AndersenWaveDiff_WPA
+        || pta->getAnalysisTy() == AndersenSCD_WPA
+        || pta->getAnalysisTy() == AndersenSFR_WPA
+        || pta->getAnalysisTy() == TypeCPP_WPA
+        || pta->getAnalysisTy() == Steensgaard_WPA);
     }
     //@}
 
@@ -229,9 +229,9 @@ public:
     static inline bool classof(const PointerAnalysis *pta)
     {
         return (pta->getAnalysisTy() == Andersen_WPA
-                || pta->getAnalysisTy() == AndersenWaveDiff_WPA
-                || pta->getAnalysisTy() == AndersenSCD_WPA
-                || pta->getAnalysisTy() == AndersenSFR_WPA);
+        || pta->getAnalysisTy() == AndersenWaveDiff_WPA
+        || pta->getAnalysisTy() == AndersenSCD_WPA
+        || pta->getAnalysisTy() == AndersenSFR_WPA);
     }
     //@}
 

package/SVF-osx/Release-build/include/WPA/FlowSensitive.h

@@ -247,11 +247,11 @@ protected:
     //@{
     inline const PointsTo& getDFInPtsSet(const SVFGNode* stmt, const NodeID node)
     {
-        return getDFPTDataTy()->getDFInPtsSet(stmt->getId(),node);
+        return getDFPTDataTy()->getDFInPtsSet(stmt->getId(), node);
     }
     inline const PointsTo& getDFOutPtsSet(const SVFGNode* stmt, const NodeID node)
     {
-        return getDFPTDataTy()->getDFOutPtsSet(stmt->getId(),node);
+        return getDFPTDataTy()->getDFOutPtsSet(stmt->getId(), node);
     }
     //@}
 

package/package.json

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