svf-lib 1.0.2694 → 1.0.2695

package/SVF-osx/include/MemoryModel/ConditionalPT.h

@@ -261,13 +261,13 @@ public:
     bool intersects(const CondStdSet<Element>& rhs) const
     {
         if (empty() && rhs.empty())
-        return false;
+            return false;
 
         for (const_iterator i = rhs.begin(); i != rhs.end(); ++i)
         {
             if (elements.find(*i) != elements.end())
-                    return true;
-            }
+                return true;
+        }
         return false;
     }
 
@@ -382,17 +382,17 @@ public:
     inline unsigned numElement() const
     {
         if (_condPts.empty())
-        return 0;
+            return 0;
         else
         {
             unsigned num = 0;
             for (CondPtsConstIter it = cptsBegin(); it != cptsEnd(); it++)
-                {
-                    PointsTo pts = it->second;
-                    num += pts.count();
-                }
-                return num;
+            {
+                PointsTo pts = it->second;
+                num += pts.count();
             }
+            return num;
+        }
     }
     /// Return true if no element in the set
     inline bool empty() const
@@ -434,49 +434,49 @@ public:
     inline bool aliased(const CondPointsToSet<Cond>& rhs) const
     {
         if (pointsTo().empty() || rhs.pointsTo().empty())
-        return false;
+            return false;
         else
         {
             CondPtsConstIter lit = cptsBegin(), elit = cptsEnd();
-                for (; lit != elit; ++lit)
+            for (; lit != elit; ++lit)
+            {
+                const Cond& lc = lit->first;
+                const PointsTo& pts = lit->second;
+                CondPtsConstIter rit = rhs.pointsTo().find(lc);
+                if(rit !=rhs.pointsTo().end())
                 {
-                    const Cond& lc = lit->first;
-                    const PointsTo& pts = lit->second;
-                    CondPtsConstIter rit = rhs.pointsTo().find(lc);
-                    if(rit !=rhs.pointsTo().end())
-                    {
-                        const PointsTo& rpts = rit->second;
-                        if (pts.intersects(rpts))
-                            return true;
-                    }
+                    const PointsTo& rpts = rit->second;
+                    if (pts.intersects(rpts))
+                        return true;
                 }
-                return false;
             }
+            return false;
+        }
     }
 
     /// Check whether this CondPointsToSet is a subset of RHS
     inline bool isSubset(const CondPointsToSet<Cond>& rhs) const
     {
         if (pointsTo().size() > rhs.pointsTo().size())
-        return false;
+            return false;
         else
         {
             CondPtsConstIter lit = cptsBegin(), elit = cptsEnd();
-                for (; lit != elit; ++lit)
+            for (; lit != elit; ++lit)
+            {
+                const Cond& lc = lit->first;
+                CondPtsConstIter rit = rhs.pointsTo().find(lc);
+                if (rit == rhs.pointsTo().end())
+                    return false;
+                else
                 {
-                    const Cond& lc = lit->first;
-                    CondPtsConstIter rit = rhs.pointsTo().find(lc);
-                    if (rit == rhs.pointsTo().end())
+                    const PointsTo& pts = lit->second;
+                    const PointsTo& rpts = rit->second;
+                    if (!rpts.contains(pts))
                         return false;
-                    else
-                    {
-                        const PointsTo& pts = lit->second;
-                        const PointsTo& rpts = rit->second;
-                        if (!rpts.contains(pts))
-                            return false;
-                    }
                 }
             }
+        }
         return true;
     }
 
@@ -485,20 +485,20 @@ public:
     {
         /// if either cpts is empty, just return.
         if (pointsTo().empty() && rhs->pointsTo().empty())
-        return false;
+            return false;
 
         CondPtsConstIter it = rhs->cptsBegin(), eit = rhs->cptsEnd();
         for (; it != eit; ++it)
         {
             const Cond& cond = it->first;
             if (hasPointsTo(cond))
-                {
-                    const PointsTo& rhs_pts= it->second;
-                    const PointsTo& pts= pointsTo(cond);
-                    if (pts.intersects(rhs_pts))
-                        return true;
-                }
+            {
+                const PointsTo& rhs_pts= it->second;
+                const PointsTo& pts= pointsTo(cond);
+                if (pts.intersects(rhs_pts))
+                    return true;
             }
+        }
 
         return false;
     }
@@ -634,44 +634,44 @@ public:
     inline bool operator< (const CondPointsToSet<Cond>& rhs) const
     {
         if (pointsTo().size() < rhs.pointsTo().size())
-        return true;
+            return true;
         else if (pointsTo().size() == rhs.pointsTo().size())
         {
             CondPtsConstIter lit = cptsBegin(), elit = cptsEnd();
-                CondPtsConstIter rit = rhs.cptsBegin(), erit = rhs.cptsEnd();
-                for (; lit != elit && rit != erit; ++lit, ++rit)
+            CondPtsConstIter rit = rhs.cptsBegin(), erit = rhs.cptsEnd();
+            for (; lit != elit && rit != erit; ++lit, ++rit)
+            {
+                const Cond& lc = lit->first;
+                const Cond& rc = rit->first;
+                if (lc < rc)
+                    return true;
+                else if (lc == rc)
                 {
-                    const Cond& lc = lit->first;
-                    const Cond& rc = rit->first;
-                    if (lc < rc)
+                    const PointsTo& lpts = lit->second;
+                    const PointsTo& rpts = rit->second;
+                    if (lpts.count() < rpts.count())
                         return true;
-                    else if (lc == rc)
+                    else if (lpts.count() == rpts.count())
                     {
-                        const PointsTo& lpts = lit->second;
-                        const PointsTo& rpts = rit->second;
-                        if (lpts.count() < rpts.count())
-                            return true;
-                        else if (lpts.count() == rpts.count())
+                        PointsTo::iterator bit = lpts.begin();
+                        PointsTo::iterator eit = lpts.end();
+                        PointsTo::iterator rbit = rpts.begin();
+                        PointsTo::iterator reit = rpts.end();
+                        for (; bit != eit && rbit != reit; bit++, rbit++)
                         {
-                            PointsTo::iterator bit = lpts.begin();
-                            PointsTo::iterator eit = lpts.end();
-                            PointsTo::iterator rbit = rpts.begin();
-                            PointsTo::iterator reit = rpts.end();
-                            for (; bit != eit && rbit != reit; bit++, rbit++)
-                            {
-                                if (*bit < *rbit)
-                                    return true;
-                                else if (*bit > *rbit)
-                                    return false;
-                            }
+                            if (*bit < *rbit)
+                                return true;
+                            else if (*bit > *rbit)
+                                return false;
                         }
-                        else
-                            return false;
                     }
                     else
                         return false;
                 }
+                else
+                    return false;
             }
+        }
         return false;
     }
 
@@ -685,8 +685,8 @@ public:
     inline bool test(const SingleCondVar& var) const
     {
         if (hasPointsTo(var.get_cond()))
-    {
-        const PointsTo& pts = pointsTo(var.get_cond());
+        {
+            const PointsTo& pts = pointsTo(var.get_cond());
             return pts.test(var.get_id());
         }
         return false;
@@ -763,11 +763,11 @@ private:
         {
             // If they are both at the end, ignore the rest of the fields.
             if (atEnd && RHS.atEnd)
-            return true;
+                return true;
             // Otherwise they are the same if they have the same condVar
             return atEnd == RHS.atEnd && RHS._curIter == _curIter && RHS._ptIter == _ptIter;
         }
-    bool operator!=(const CondPtsSetIterator &RHS) const
+        bool operator!=(const CondPtsSetIterator &RHS) const
         {
             return !(*this == RHS);
         }

package/SVF-osx/include/MemoryModel/MutablePointsToDS.h

@@ -128,10 +128,10 @@ public:
 
     virtual void remapAllPts(void) override
     {
-for (typename PtsMap::value_type &ppt : ptsMap) ppt.second.checkAndRemap();
+        for (typename PtsMap::value_type &ppt : ptsMap) ppt.second.checkAndRemap();
     }
 
-virtual inline Map<DataSet, unsigned> getAllPts(bool liveOnly) const override
+    virtual inline Map<DataSet, unsigned> getAllPts(bool liveOnly) const override
     {
         Map<DataSet, unsigned> allPts;
         for (typename PtsMap::value_type ppt : ptsMap)
@@ -286,11 +286,11 @@ public:
     virtual void remapAllPts(void) override
     {
         mutPTData.remapAllPts();
-for (typename PtsMap::value_type &ppt : diffPtsMap) ppt.second.checkAndRemap();
-for (typename PtsMap::value_type &ppt : propaPtsMap) ppt.second.checkAndRemap();
-        }
+        for (typename PtsMap::value_type &ppt : diffPtsMap) ppt.second.checkAndRemap();
+        for (typename PtsMap::value_type &ppt : propaPtsMap) ppt.second.checkAndRemap();
+    }
 
-virtual inline void dumpPTData() override
+    virtual inline void dumpPTData() override
     {
         mutPTData.dumpPTData();
     }
@@ -545,14 +545,14 @@ public:
     virtual void remapAllPts(void) override
     {
         mutPTData.remapAllPts();
-for (typename DFPtsMap::value_type &lopt : dfInPtsMap)
-    {
-        for (typename PtsMap::value_type &opt : lopt.second) opt.second.checkAndRemap();
+        for (typename DFPtsMap::value_type &lopt : dfInPtsMap)
+        {
+            for (typename PtsMap::value_type &opt : lopt.second) opt.second.checkAndRemap();
         }
 
-for (typename DFPtsMap::value_type &lopt : dfOutPtsMap)
-    {
-        for (typename PtsMap::value_type &opt : lopt.second) opt.second.checkAndRemap();
+        for (typename DFPtsMap::value_type &lopt : dfOutPtsMap)
+        {
+            for (typename PtsMap::value_type &opt : lopt.second) opt.second.checkAndRemap();
         }
     }
     ///@}
@@ -616,9 +616,9 @@ public:
         std::error_code ErrInfo;
         std::fstream f("svfg_pts.data", std::ios_base::out);
         if (f.good())
-    {
-        NodeBS locs;
-        for(DFPtsMapconstIter it = dfInPtsMap.begin(), eit = dfInPtsMap.end(); it!=eit; ++it)
+        {
+            NodeBS locs;
+            for(DFPtsMapconstIter it = dfInPtsMap.begin(), eit = dfInPtsMap.end(); it!=eit; ++it)
                 locs.set(it->first);
 
             for(DFPtsMapconstIter it = dfOutPtsMap.begin(), eit = dfOutPtsMap.end(); it!=eit; ++it)
@@ -706,9 +706,9 @@ public:
     virtual inline bool updateDFInFromIn(LocID srcLoc, const Key& srcVar, LocID dstLoc, const Key& dstVar) override
     {
         if(varHasNewDFInPts(srcLoc, srcVar) &&
-        this->unionPts(this->getDFInPtsSet(dstLoc,dstVar), this->getDFInPtsSet(srcLoc,srcVar)))
-    {
-        setVarDFInSetUpdated(dstLoc,dstVar);
+                this->unionPts(this->getDFInPtsSet(dstLoc,dstVar), this->getDFInPtsSet(srcLoc,srcVar)))
+        {
+            setVarDFInSetUpdated(dstLoc,dstVar);
             return true;
         }
         return false;
@@ -717,9 +717,9 @@ public:
     virtual inline bool updateDFInFromOut(LocID srcLoc, const Key& srcVar, LocID dstLoc, const Key& dstVar) override
     {
         if(varHasNewDFOutPts(srcLoc, srcVar) &&
-        this->unionPts(this->getDFInPtsSet(dstLoc,dstVar), this->getDFOutPtsSet(srcLoc,srcVar)))
-    {
-        setVarDFInSetUpdated(dstLoc,dstVar);
+                this->unionPts(this->getDFInPtsSet(dstLoc,dstVar), this->getDFOutPtsSet(srcLoc,srcVar)))
+        {
+            setVarDFInSetUpdated(dstLoc,dstVar);
             return true;
         }
         return false;
@@ -728,8 +728,8 @@ public:
     virtual inline bool updateDFOutFromIn(LocID srcLoc, const Key& srcVar, LocID dstLoc, const Key& dstVar) override
     {
         if(varHasNewDFInPts(srcLoc,srcVar))
-    {
-        removeVarFromDFInUpdatedSet(srcLoc,srcVar);
+        {
+            removeVarFromDFInUpdatedSet(srcLoc,srcVar);
             if (this->unionPts(this->getDFOutPtsSet(dstLoc,dstVar), this->getDFInPtsSet(srcLoc,srcVar)))
             {
                 setVarDFOutSetUpdated(dstLoc,dstVar);
@@ -742,8 +742,8 @@ public:
     virtual inline bool updateAllDFInFromOut(LocID srcLoc, const Key& srcVar, LocID dstLoc, const Key& dstVar) override
     {
         if(this->unionPts(this->getDFInPtsSet(dstLoc,dstVar), this->getDFOutPtsSet(srcLoc,srcVar)))
-    {
-        setVarDFInSetUpdated(dstLoc,dstVar);
+        {
+            setVarDFInSetUpdated(dstLoc,dstVar);
             return true;
         }
         return false;
@@ -752,8 +752,8 @@ public:
     virtual inline bool updateAllDFInFromIn(LocID srcLoc, const Key& srcVar, LocID dstLoc, const Key& dstVar) override
     {
         if(this->unionPts(this->getDFInPtsSet(dstLoc,dstVar), this->getDFInPtsSet(srcLoc,srcVar)))
-    {
-        setVarDFInSetUpdated(dstLoc,dstVar);
+        {
+            setVarDFInSetUpdated(dstLoc,dstVar);
             return true;
         }
         return false;
@@ -782,8 +782,8 @@ public:
     virtual inline bool updateTLVPts(LocID srcLoc, const Key& srcVar, const Key& dstVar) override
     {
         if(varHasNewDFInPts(srcLoc,srcVar))
-    {
-        removeVarFromDFInUpdatedSet(srcLoc,srcVar);
+        {
+            removeVarFromDFInUpdatedSet(srcLoc,srcVar);
             return this->mutPTData.unionPts(dstVar, this->getDFInPtsSet(srcLoc,srcVar));
         }
         return false;
@@ -792,8 +792,8 @@ public:
     virtual inline bool updateATVPts(const Key& srcVar, LocID dstLoc, const Key& dstVar) override
     {
         if (this->unionPts(this->getDFOutPtsSet(dstLoc, dstVar), this->mutPTData.getPts(srcVar)))
-    {
-        setVarDFOutSetUpdated(dstLoc, dstVar);
+        {
+            setVarDFOutSetUpdated(dstLoc, dstVar);
             return true;
         }
         return false;
@@ -802,8 +802,8 @@ public:
     virtual inline void clearAllDFOutUpdatedVar(LocID loc) override
     {
         if (this->hasDFOutSet(loc))
-    {
-        DataSet pts = getDFOutUpdatedVar(loc);
+        {
+            DataSet pts = getDFOutUpdatedVar(loc);
             for (DataIter ptsIt = pts.begin(), ptsEit = pts.end(); ptsIt != ptsEit; ++ptsIt)
             {
                 const Key var = *ptsIt;

package/SVF-osx/include/MemoryModel/PersistentPointsToDS.h

@@ -598,9 +598,9 @@ public:
     inline bool updateDFInFromIn(LocID srcLoc, const Key& srcVar, LocID dstLoc, const Key& dstVar) override
     {
         if (varHasNewDFInPts(srcLoc, srcVar)
-        && this->unionPtsThroughIds(this->getDFInPtIdRef(dstLoc, dstVar), this->getDFInPtIdRef(srcLoc, srcVar)))
-    {
-        setVarDFInSetUpdated(dstLoc, dstVar);
+                && this->unionPtsThroughIds(this->getDFInPtIdRef(dstLoc, dstVar), this->getDFInPtIdRef(srcLoc, srcVar)))
+        {
+            setVarDFInSetUpdated(dstLoc, dstVar);
             return true;
         }
 
@@ -610,9 +610,9 @@ public:
     inline bool updateDFInFromOut(LocID srcLoc, const Key& srcVar, LocID dstLoc, const Key& dstVar) override
     {
         if (varHasNewDFOutPts(srcLoc, srcVar)
-        && this->unionPtsThroughIds(this->getDFInPtIdRef(dstLoc, dstVar), this->getDFOutPtIdRef(srcLoc, srcVar)))
-    {
-        setVarDFInSetUpdated(dstLoc, dstVar);
+                && this->unionPtsThroughIds(this->getDFInPtIdRef(dstLoc, dstVar), this->getDFOutPtIdRef(srcLoc, srcVar)))
+        {
+            setVarDFInSetUpdated(dstLoc, dstVar);
             return true;
         }
 
@@ -622,8 +622,8 @@ public:
     inline bool updateDFOutFromIn(LocID srcLoc, const Key& srcVar, LocID dstLoc, const Key& dstVar) override
     {
         if (varHasNewDFInPts(srcLoc, srcVar))
-    {
-        removeVarFromDFInUpdatedSet(srcLoc, srcVar);
+        {
+            removeVarFromDFInUpdatedSet(srcLoc, srcVar);
             if (this->unionPtsThroughIds(this->getDFOutPtIdRef(dstLoc, dstVar), this->getDFInPtIdRef(srcLoc, srcVar)))
             {
                 setVarDFOutSetUpdated(dstLoc, dstVar);
@@ -637,8 +637,8 @@ public:
     inline bool updateAllDFInFromOut(LocID srcLoc, const Key& srcVar, LocID dstLoc, const Key& dstVar) override
     {
         if (this->unionPtsThroughIds(this->getDFInPtIdRef(dstLoc, dstVar), this->getDFOutPtIdRef(srcLoc, srcVar)))
-    {
-        setVarDFInSetUpdated(dstLoc, dstVar);
+        {
+            setVarDFInSetUpdated(dstLoc, dstVar);
             return true;
         }
 
@@ -648,8 +648,8 @@ public:
     inline bool updateAllDFInFromIn(LocID srcLoc, const Key& srcVar, LocID dstLoc, const Key& dstVar) override
     {
         if (this->unionPtsThroughIds(this->getDFInPtIdRef(dstLoc, dstVar), this->getDFInPtIdRef(srcLoc, srcVar)))
-    {
-        setVarDFInSetUpdated(dstLoc, dstVar);
+        {
+            setVarDFInSetUpdated(dstLoc, dstVar);
             return true;
         }
 
@@ -677,8 +677,8 @@ public:
     inline bool updateTLVPts(LocID srcLoc, const Key& srcVar, const Key& dstVar) override
     {
         if (varHasNewDFInPts(srcLoc, srcVar))
-    {
-        removeVarFromDFInUpdatedSet(srcLoc, srcVar);
+        {
+            removeVarFromDFInUpdatedSet(srcLoc, srcVar);
             return this->unionPtsThroughIds(this->persPTData.ptsMap[dstVar], this->getDFInPtIdRef(srcLoc, srcVar));
         }
 
@@ -688,8 +688,8 @@ public:
     inline bool updateATVPts(const Key& srcVar, LocID dstLoc, const Key& dstVar) override
     {
         if (this->unionPtsThroughIds(this->getDFOutPtIdRef(dstLoc, dstVar), this->persPTData.ptsMap[srcVar]))
-    {
-        setVarDFOutSetUpdated(dstLoc, dstVar);
+        {
+            setVarDFOutSetUpdated(dstLoc, dstVar);
             return true;
         }
 
@@ -699,8 +699,8 @@ public:
     inline void clearAllDFOutUpdatedVar(LocID loc) override
     {
         if (this->hasDFOutSet(loc))
-    {
-        const KeySet vars = getDFOutUpdatedVar(loc);
+        {
+            const KeySet vars = getDFOutUpdatedVar(loc);
             for (const Key &var : vars)
             {
                 removeVarFromDFOutUpdatedSet(loc, var);

package/SVF-osx/include/MemoryModel/PointerAnalysis.h

@@ -189,6 +189,10 @@ public:
     /// Interface exposed to users of our pointer analysis, given PAGNodeID
     virtual AliasResult alias(NodeID node1, NodeID node2) = 0;
 
+    /// Collect the nodes that may alias the given node.
+    /// Subclasses must implement this query; the default reports unsupported and aborts.
+    virtual NodeBS getMayAliases(NodeID node);
+
     /// Get points-to targets of a pointer. It needs to be implemented in child class
     virtual const PointsTo& getPts(NodeID ptr) = 0;
 

package/SVF-osx/include/MemoryModel/PointerAnalysisImpl.h

@@ -225,6 +225,10 @@ public:
     /// Interface expose to users of our pointer analysis, given two pts
     virtual AliasResult alias(const PointsTo& pts1, const PointsTo& pts2);
 
+    /// Declaring the PointsTo overload below would otherwise hide the base class's
+    /// mayAlias(NodeID, NodeID) and mayAlias(const SVFVar*, const SVFVar*).
+    using PointerAnalysis::mayAlias;
+
     /// Convenience bool wrappers: return true if the two operands may/must/partial alias
     inline bool mayAlias(const PointsTo& pts1, const PointsTo& pts2)
     {

package/SVF-osx/include/SABER/SaberCheckerAPI.h

@@ -76,8 +76,8 @@ private:
     inline CHECKER_TYPE getType(const FunObjVar* F) const
     {
         if(F)
-    {
-        TDAPIMap::const_iterator it= tdAPIMap.find(F->getName());
+        {
+            TDAPIMap::const_iterator it= tdAPIMap.find(F->getName());
             if(it != tdAPIMap.end())
                 return it->second;
         }

package/SVF-osx/include/SVF-LLVM/GEPTypeBridgeIterator.h

@@ -67,34 +67,34 @@ public:
     Type* operator*() const
     {
         if ( CurTy.getInt() )
-        return PointerType::get(CurTy.getPointer()->getContext(), AddrSpace);
+            return PointerType::get(CurTy.getPointer()->getContext(), AddrSpace);
         return CurTy.getPointer();
     }
 
-Type* getIndexedType() const
+    Type* getIndexedType() const
     {
         assert(false && "needs to be refactored");
         if ( CurTy.getInt() )
-        return CurTy.getPointer();
+            return CurTy.getPointer();
 #if LLVM_VERSION_MAJOR >= 11
         Type*  CT = CurTy.getPointer();
         if (auto ST = dyn_cast<StructType>(CT))
             return ST->getTypeAtIndex(getOperand());
-            else if (auto Array = dyn_cast<ArrayType>(CT))
-                return Array->getElementType();
-                else if (auto Vector = dyn_cast<VectorType>(CT))
-                    return Vector->getElementType();
-                    else
-                        return CT;
+        else if (auto Array = dyn_cast<ArrayType>(CT))
+            return Array->getElementType();
+        else if (auto Vector = dyn_cast<VectorType>(CT))
+            return Vector->getElementType();
+        else
+            return CT;
 #else
         CompositeType *CT = llvm::cast<CompositeType>( CurTy.getPointer() );
         return CT->getTypeAtIndex(getOperand());
 #endif
-                    }
+    }
 
 // non-standard operators, these may not need be bridged but seems it's
 // prudent to do so...
-Type* operator->() const
+    Type* operator->() const
     {
         return operator*();
     }

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

@@ -370,8 +370,8 @@ public:
     {
         assert(!empty() && "empty LLVM module!!");
         for (size_t i = 0; i < getModuleNum(); ++i)
-    {
-        Module& module = getModuleRef(i);
+        {
+            Module& module = getModuleRef(i);
             if (module.getName().str() != ExtAPI::getExtAPI()->getExtBcPath())
             {
                 return &module;

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

@@ -261,9 +261,9 @@ public:
     inline const std::string& getModuleIdentifier() const
     {
         if (pagReadFromTxt.empty())
-    {
-        assert(!moduleIdentifier.empty() &&
-               "No module found! Reading from a file other than LLVM-IR?");
+        {
+            assert(!moduleIdentifier.empty() &&
+                   "No module found! Reading from a file other than LLVM-IR?");
             return moduleIdentifier;
         }
         else

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

@@ -504,7 +504,7 @@ public:
     inline const std::string getValueName() const
     {
         return getName() + "_" +
-        std::to_string(getConstantFieldIdx());
+               std::to_string(getConstantFieldIdx());
     }
 
     virtual bool isPointer() const

package/SVF-osx/include/Util/CommandLine.h

@@ -430,10 +430,10 @@ public:
 
     virtual bool parseAndSetValue(const std::string s) override
     {
-for (const OptionPossibility<T> &op : possibilities)
-    {
-        // Check if the given string is a valid one.
-        if (s == std::get<1>(op))
+        for (const OptionPossibility<T> &op : possibilities)
+        {
+            // Check if the given string is a valid one.
+            if (s == std::get<1>(op))
             {
                 // What that string maps to.
                 value = std::get<0>(op);
@@ -487,9 +487,9 @@ public:
     virtual bool parseAndSetValue(const std::string s) override
     {
         // Like in OptionMap basically, except we can have many values.
-for (const OptionPossibility<T> &op : possibilities)
-    {
-        if (s == std::get<1>(op))
+        for (const OptionPossibility<T> &op : possibilities)
+        {
+            if (s == std::get<1>(op))
             {
                 optionValues[std::get<0>(op)] = true;
                 return true;
@@ -507,9 +507,9 @@ for (const OptionPossibility<T> &op : possibilities)
     /// If the bitset is empty.
     bool nothingSet(void) const
     {
-for (const std::pair<T, bool> tb : optionValues)
-    {
-        if (tb.second) return false;
+        for (const std::pair<T, bool> tb : optionValues)
+        {
+            if (tb.second) return false;
         }
 
         return true;