Merge branch '0.5.0.x' into 0.5.x

diff --combined src/qt/transactionfilterproxy.h
index 76cf46f,17c1b48..8d6829d
--- 1/src/qt/transactionfilterproxy.h
--- 2/src/qt/transactionfilterproxy.h
+++ b/src/qt/transactionfilterproxy.h
@@@ -4,34 -4,32 +4,34 @@@
  #include <QSortFilterProxyModel>
  #include <QDateTime>
  
 -// Filter transaction list according to pre-specified rules
 +/** Filter the transaction list according to pre-specified rules. */
  class TransactionFilterProxy : public QSortFilterProxyModel
  {
      Q_OBJECT
  public:
      explicit TransactionFilterProxy(QObject *parent = 0);
  
 -    // Earliest date that can be represented (far in the past)
 +    /** Earliest date that can be represented (far in the past) */
      static const QDateTime MIN_DATE;
 -    // Last date that can be represented (far in the future)
 +    /** Last date that can be represented (far in the future) */
      static const QDateTime MAX_DATE;
 -    // Type filter bit field (all types)
 +    /** Type filter bit field (all types) */
      static const quint32 ALL_TYPES = 0xFFFFFFFF;
  
      static quint32 TYPE(int type) { return 1<<type; }
  
      void setDateRange(const QDateTime &from, const QDateTime &to);
      void setAddressPrefix(const QString &addrPrefix);
 -    // Type filter takes a bitfield created with TYPE() or ALL_TYPES
 +    /**
 +      @note Type filter takes a bitfield created with TYPE() or ALL_TYPES
 +     */
      void setTypeFilter(quint32 modes);
      void setMinAmount(qint64 minimum);
  
 -    // Set maximum number of rows returned, -1 if unlimited
 +    /** Set maximum number of rows returned, -1 if unlimited. */
      void setLimit(int limit);
  
-     int       rowCount(const QModelIndex &parent = QModelIndex()) const;
+     int rowCount(const QModelIndex &parent = QModelIndex()) const;
  protected:
      bool filterAcceptsRow(int source_row, const QModelIndex & source_parent) const;
  

diff --combined src/util.h
index d42b572,c57e82b..5256104
--- 1/src/util.h
--- 2/src/util.h
+++ b/src/util.h
@@@ -243,20 -243,19 +243,20 @@@ public
          pcs = &csIn;
          pcs->Enter(pszName, pszFile, nLine);
      }
 +
 +    operator bool() const
 +    {
 +        return true;
 +    }
 +
      ~CCriticalBlock()
      {
          pcs->Leave();
      }
  };
  
 -// WARNING: This will catch continue and break!
 -// break is caught with an assertion, but there's no way to detect continue.
 -// I'd rather be careful than suffer the other more error prone syntax.
 -// The compiler will optimise away all this loop junk.
  #define CRITICAL_BLOCK(cs)     \
 -    for (bool fcriticalblockonce=true; fcriticalblockonce; assert(("break caught by CRITICAL_BLOCK!" && !fcriticalblockonce)), fcriticalblockonce=false) \
 -        for (CCriticalBlock criticalblock(cs, #cs, __FILE__, __LINE__); fcriticalblockonce; fcriticalblockonce=false)
 +    if (CCriticalBlock criticalblock = CCriticalBlock(cs, #cs, __FILE__, __LINE__))
  
  class CTryCriticalBlock
  {
@@@ -268,12 -267,6 +268,12 @@@ public
      {
          pcs = (csIn.TryEnter(pszName, pszFile, nLine) ? &csIn : NULL);
      }
 +
 +    operator bool() const
 +    {
 +        return Entered();
 +    }
 +
      ~CTryCriticalBlock()
      {
          if (pcs)
@@@ -281,20 -274,17 +281,20 @@@
              pcs->Leave();
          }
      }
 -    bool Entered() { return pcs != NULL; }
 +    bool Entered() const { return pcs != NULL; }
  };
  
  #define TRY_CRITICAL_BLOCK(cs)     \
 -    for (bool fcriticalblockonce=true; fcriticalblockonce; assert(("break caught by TRY_CRITICAL_BLOCK!" && !fcriticalblockonce)), fcriticalblockonce=false) \
 -        for (CTryCriticalBlock criticalblock(cs, #cs, __FILE__, __LINE__); fcriticalblockonce && (fcriticalblockonce = criticalblock.Entered()); fcriticalblockonce=false)
 +    if (CTryCriticalBlock criticalblock = CTryCriticalBlock(cs, #cs, __FILE__, __LINE__))
 +
  
  
  
  
  
 +// This is exactly like std::string, but with a custom allocator.
 +// (secure_allocator<> is defined in serialize.h)
 +typedef std::basic_string<char, std::char_traits<char>, secure_allocator<char> > SecureString;
  
  // This is exactly like std::string, but with a custom allocator.
  // (secure_allocator<> is defined in serialize.h)
@@@ -759,8 -749,8 +759,8 @@@ inline bool AffinityBugWorkaround(void(
  
  inline uint32_t ByteReverse(uint32_t value)
  {
-       value = ((value & 0xFF00FF00) >> 8) | ((value & 0x00FF00FF) << 8);
-       return (value<<16) | (value>>16);
+     value = ((value & 0xFF00FF00) >> 8) | ((value & 0x00FF00FF) << 8);
+     return (value<<16) | (value>>16);
  }
  
  #endif