Merge pull request #2110 from c-rack/remove-tabs

Problem: source conatins tabs and trailing spaces

src/ctx.cpp

@@ -91,7 +91,7 @@ zmq::ctx_t::ctx_t () :
     vmci_family = -1;
 #endif
 
-	scoped_lock_t locker(crypto_sync);
+    scoped_lock_t locker(crypto_sync);
 #if defined (ZMQ_USE_TWEETNACL)
     // allow opening of /dev/urandom
     unsigned char tmpbytes[4];
@@ -510,13 +510,13 @@ void zmq::ctx_t::pend_connection (const std::string &addr_,
 
     endpoints_t::iterator it = endpoints.find (addr_);
     if (it == endpoints.end ()) {
-        // Still no bind.
+        //  Still no bind.
         endpoint_.socket->inc_seqnum ();
         pending_connections.insert (pending_connections_t::value_type (addr_, pending_connection));
     } else {
-		// Bind has happened in the mean time, connect directly
-		connect_inproc_sockets(it->second.socket, it->second.options, pending_connection, connect_side);
-	}
+        //  Bind has happened in the mean time, connect directly
+        connect_inproc_sockets(it->second.socket, it->second.options, pending_connection, connect_side);
+    }
 }
 
 void zmq::ctx_t::connect_pending (const char *addr_, zmq::socket_base_t *bind_socket_)

src/decoder.hpp

@@ -119,7 +119,7 @@ namespace zmq
                 bytes_used_ = size_;
 
                 while (!to_read) {
-                    const int rc = 
+                    const int rc =
                       (static_cast <T *> (this)->*next) (data_ + bytes_used_);
                     if (rc != 0)
                         return rc;

src/dgram.cpp

@@ -53,7 +53,7 @@ zmq::dgram_t::~dgram_t ()
 
 void zmq::dgram_t::xattach_pipe (pipe_t *pipe_, bool subscribe_to_all_)
 {
-	LIBZMQ_UNUSED(subscribe_to_all_);
+    LIBZMQ_UNUSED(subscribe_to_all_);
 
     zmq_assert (pipe_);
 

src/ip.cpp

@@ -130,7 +130,7 @@ int zmq::get_peer_ip_address (fd_t sockfd_, std::string &ip_addr_)
     rc = getpeername (sockfd_, (struct sockaddr*) &ss, &addrlen);
 #ifdef ZMQ_HAVE_WINDOWS
     if (rc == SOCKET_ERROR) {
-		const int last_error = WSAGetLastError();
+        const int last_error = WSAGetLastError();
         wsa_assert (last_error != WSANOTINITIALISED &&
                     last_error != WSAEFAULT &&
                     last_error != WSAEINPROGRESS &&

src/norm_engine.cpp

@@ -9,14 +9,14 @@
 
 zmq::norm_engine_t::norm_engine_t(io_thread_t*     parent_,
                                   const options_t& options_)
- : io_object_t(parent_), zmq_session(NULL), options(options_),  
-   norm_instance(NORM_INSTANCE_INVALID), norm_session(NORM_SESSION_INVALID), 
+ : io_object_t(parent_), zmq_session(NULL), options(options_),
+   norm_instance(NORM_INSTANCE_INVALID), norm_session(NORM_SESSION_INVALID),
    is_sender(false), is_receiver(false),
-   zmq_encoder(0), norm_tx_stream(NORM_OBJECT_INVALID), 
-   tx_first_msg(true), tx_more_bit(false), 
-   zmq_output_ready(false), norm_tx_ready(false), 
+   zmq_encoder(0), norm_tx_stream(NORM_OBJECT_INVALID),
+   tx_first_msg(true), tx_more_bit(false),
+   zmq_output_ready(false), norm_tx_ready(false),
    tx_index(0), tx_len(0),
-   zmq_input_ready(false)  
+   zmq_input_ready(false)
 {
     int rc = tx_msg.init();
     errno_assert(0 == rc);
@@ -50,7 +50,7 @@ int zmq::norm_engine_t::init(const char* network_, bool send, bool recv)
     {
         ifacePtr = network_;
     }
-    
+
     // Second, look for optional multicast ifaceName
     char ifaceName[256];
     const char* addrPtr = strchr(ifacePtr, ';');
@@ -68,7 +68,7 @@ int zmq::norm_engine_t::init(const char* network_, bool send, bool recv)
         addrPtr = ifacePtr;
         ifacePtr = NULL;
     }
-    
+
     // Finally, parse IP address and port number
     const char* portPtr = strrchr(addrPtr, ':');
     if (NULL == portPtr)
@@ -76,7 +76,7 @@ int zmq::norm_engine_t::init(const char* network_, bool send, bool recv)
         errno = EINVAL;
         return -1;
     }
-    
+
     char addr[256];
     size_t addrLen = portPtr - addrPtr;
     if (addrLen > 255) addrLen = 255;
@@ -84,7 +84,7 @@ int zmq::norm_engine_t::init(const char* network_, bool send, bool recv)
     addr[addrLen] = '\0';
     portPtr++;
     unsigned short portNumber = atoi(portPtr);
-    
+
     if (NORM_INSTANCE_INVALID == norm_instance)
     {
         if (NORM_INSTANCE_INVALID == (norm_instance = NormCreateInstance()))
@@ -93,14 +93,14 @@ int zmq::norm_engine_t::init(const char* network_, bool send, bool recv)
             return -1;
         }
     }
-    
+
     // TBD - What do we use for our local NormNodeId?
     //       (for now we use automatic, IP addr based assignment or passed in 'id')
     //       a) Use ZMQ Identity somehow?
     //       b) Add function to use iface addr
     //       c) Randomize and implement a NORM session layer
     //          conflict detection/resolution protocol
-    
+
     norm_session = NormCreateSession(norm_instance, addr, portNumber, localId);
     if (NORM_SESSION_INVALID == norm_session)
     {
@@ -129,7 +129,7 @@ int zmq::norm_engine_t::init(const char* network_, bool send, bool recv)
             NormSetMulticastInterface(norm_session, ifacePtr);
         }
     }
-    
+
     if (recv)
     {
         // The alternative NORM_SYNC_CURRENT here would provide "instant"
@@ -148,7 +148,7 @@ int zmq::norm_engine_t::init(const char* network_, bool send, bool recv)
         }
         is_receiver = true;
     }
-    
+
     if (send)
     {
         // Pick a random sender instance id (aka norm sender session id)
@@ -163,10 +163,10 @@ int zmq::norm_engine_t::init(const char* network_, bool send, bool recv)
             norm_instance = NORM_INSTANCE_INVALID;
             errno = savedErrno;
             return -1;
-        }    
+        }
         NormSetCongestionControl(norm_session, true);
         norm_tx_ready = true;
-        is_sender = true;   
+        is_sender = true;
         if (NORM_OBJECT_INVALID == (norm_tx_stream = NormStreamOpen(norm_session, 2*1024*1024)))
         {
             // errno set by whatever failed
@@ -178,11 +178,11 @@ int zmq::norm_engine_t::init(const char* network_, bool send, bool recv)
             return -1;
         }
     }
-    
+
     //NormSetMessageTrace(norm_session, true);
     //NormSetDebugLevel(3);
     //NormOpenDebugLog(norm_instance, "normLog.txt");
-    
+
     return 0;  // no error
 }  // end zmq::norm_engine_t::init()
 
@@ -192,12 +192,12 @@ void zmq::norm_engine_t::shutdown()
     if (is_receiver)
     {
         NormStopReceiver(norm_session);
-        
+
         // delete any active NormRxStreamState
         rx_pending_list.Destroy();
         rx_ready_list.Destroy();
         msg_ready_list.Destroy();
-        
+
         is_receiver = false;
     }
     if (is_sender)
@@ -224,20 +224,20 @@ void zmq::norm_engine_t::plug (io_thread_t* io_thread_, session_base_t *session_
     zmq_session = session_;
     if (is_sender) zmq_output_ready = true;
     if (is_receiver) zmq_input_ready = true;
-    
+
     fd_t normDescriptor = NormGetDescriptor(norm_instance);
     norm_descriptor_handle = add_fd(normDescriptor);
     // Set POLLIN for notification of pending NormEvents
-    set_pollin(norm_descriptor_handle); 
-    
+    set_pollin(norm_descriptor_handle);
+
     if (is_sender) send_data();
-    
+
 }  // end zmq::norm_engine_t::init()
 
 void zmq::norm_engine_t::unplug()
 {
     rm_fd(norm_descriptor_handle);
-    
+
     zmq_session = NULL;
 }  // end zmq::norm_engine_t::unplug()
 
@@ -253,7 +253,7 @@ void zmq::norm_engine_t::restart_output()
     // There's new message data available from the session
     zmq_output_ready = true;
     if (norm_tx_ready) send_data();
-    
+
 }  // end zmq::norm_engine_t::restart_output()
 
 void zmq::norm_engine_t::send_data()
@@ -289,7 +289,7 @@ void zmq::norm_engine_t::send_data()
                 // Need to pull and load a new message to send
                 if (-1 == zmq_session->pull_msg(&tx_msg))
                 {
-                    // We need to wait for "restart_output()" to be called by ZMQ 
+                    // We need to wait for "restart_output()" to be called by ZMQ
                     zmq_output_ready = false;
                     break;
                 }
@@ -301,7 +301,7 @@ void zmq::norm_engine_t::send_data()
                 //      'syncs' mid-stream.  We key off the the state of the 'more_flag'
                 //      I.e.,If  more_flag _was_ false previously, this is the first
                 //      frame of a ZMQ message.
-                if (tx_more_bit) 
+                if (tx_more_bit)
                     tx_buffer[0] = (char)0xff;  // this is not first frame of message
                 else
                     tx_buffer[0] = 0x00;  // this is first frame of message
@@ -339,7 +339,7 @@ void zmq::norm_engine_t::in_event()
         zmq_assert(false);
         return;
     }
-    
+
     switch(event.type)
     {
         case NORM_TX_QUEUE_VACANCY:
@@ -350,13 +350,13 @@ void zmq::norm_engine_t::in_event()
                 send_data();
             }
             break;
-            
+
         case NORM_RX_OBJECT_NEW:
             //break;
         case NORM_RX_OBJECT_UPDATED:
             recv_data(event.object);
             break;
-            
+
         case NORM_RX_OBJECT_ABORTED:
         {
             NormRxStreamState* rxState = (NormRxStreamState*)NormObjectGetUserData(event.object);
@@ -370,7 +370,7 @@ void zmq::norm_engine_t::in_event()
             }
             delete rxState;
             break;
-        }           
+        }
         case NORM_REMOTE_SENDER_INACTIVE:
             // Here we free resources used for this formerly active sender.
             // Note w/ NORM_SYNC_STREAM, if sender reactivates, we may
@@ -380,11 +380,11 @@ void zmq::norm_engine_t::in_event()
             // user configurable timeout here to wait some amount of time
             // after this event to declare the remote sender truly dead
             // and delete its state???
-            NormNodeDelete(event.sender);  
+            NormNodeDelete(event.sender);
             break;
-            
+
         default:
-            // We ignore some NORM events 
+            // We ignore some NORM events
             break;
     }
 }  // zmq::norm_engine_t::in_event()
@@ -396,7 +396,7 @@ void zmq::norm_engine_t::restart_input()
     // Process any pending received messages
     if (!msg_ready_list.IsEmpty())
         recv_data(NORM_OBJECT_INVALID);
-    
+
 }  // end zmq::norm_engine_t::restart_input()
 
 void zmq::norm_engine_t::recv_data(NormObjectHandle object)
@@ -447,19 +447,19 @@ void zmq::norm_engine_t::recv_data(NormObjectHandle object)
         {
             switch(rxState->Decode())
             {
-                case 1:  // msg completed   
+                case 1:  // msg completed
                     // Complete message decoded, move this stream to msg_ready_list
-                    // to push the message up to the session below.  Note the stream 
+                    // to push the message up to the session below.  Note the stream
                     // will be returned to the "rx_ready_list" after that's done
                     rx_ready_list.Remove(*rxState);
                     msg_ready_list.Append(*rxState);
                     continue;
-                    
+
                 case -1: // decoding error (shouldn't happen w/ NORM, but ...)
                     // We need to re-sync this stream (decoder buffer was reset)
                     rxState->SetSync(false);
                     break;
-                    
+
                 default:  // 0 - need more data
                     break;
             }
@@ -524,12 +524,12 @@ void zmq::norm_engine_t::recv_data(NormObjectHandle object)
                 rx_pending_list.Append(*rxState);
             }
         }  // end while(NULL != (rxState = iterator.GetNextItem()))
-        
+
         if (zmq_input_ready)
         {
             // At this point, we've made a pass through the "rx_ready" stream list
-            // Now make a pass through the "msg_pending" list (if the zmq session 
-            // ready for more input).  This may possibly return streams back to 
+            // Now make a pass through the "msg_pending" list (if the zmq session
+            // ready for more input).  This may possibly return streams back to
             // the "rx ready" stream list after their pending message is handled
             NormRxStreamState::List::Iterator iterator(msg_ready_list);
             NormRxStreamState* rxState;
@@ -549,7 +549,7 @@ void zmq::norm_engine_t::recv_data(NormObjectHandle object)
                     {
                         // session rejected message?
                         // TBD - handle this better
-                        zmq_assert(false); 
+                        zmq_assert(false);
                     }
                 }
                 // else message was accepted.
@@ -561,15 +561,15 @@ void zmq::norm_engine_t::recv_data(NormObjectHandle object)
             }  // end while(NULL != (rxState = iterator.GetNextItem()))
         }  // end if (zmq_input_ready)
     }  // end while ((!rx_ready_list.empty() || (zmq_input_ready && !msg_ready_list.empty()))
-    
+
     // Alert zmq of the messages we have pushed up
     zmq_session->flush();
-    
+
 }  // end zmq::norm_engine_t::recv_data()
 
-zmq::norm_engine_t::NormRxStreamState::NormRxStreamState(NormObjectHandle normStream, 
+zmq::norm_engine_t::NormRxStreamState::NormRxStreamState(NormObjectHandle normStream,
                                                          int64_t          maxMsgSize)
- : norm_stream(normStream), max_msg_size(maxMsgSize), 
+ : norm_stream(normStream), max_msg_size(maxMsgSize),
    in_sync(false), rx_ready(false), zmq_decoder(NULL), skip_norm_sync(false),
    buffer_ptr(NULL), buffer_size(0), buffer_count(0),
    prev(NULL), next(NULL), list(NULL)
@@ -620,17 +620,17 @@ int zmq::norm_engine_t::NormRxStreamState::Decode()
     {
         // There's pending data for the decoder to decode
         size_t processed = 0;
-        
+
         // This a bit of a kludgy approach used to weed
         // out the NORM ZMQ message transport "syncFlag" byte
         // from the ZMQ message stream being decoded (but it works!)
-        if (skip_norm_sync) 
+        if (skip_norm_sync)
         {
             buffer_ptr++;
             buffer_count--;
             skip_norm_sync = false;
         }
-        
+
         int rc = zmq_decoder->decode(buffer_ptr, buffer_count, processed);
         buffer_ptr += processed;
         buffer_count -= processed;
@@ -651,7 +651,7 @@ int zmq::norm_engine_t::NormRxStreamState::Decode()
                 skip_norm_sync = false;  // will get consumed by norm sync check
                 Init();
                 break;
-                
+
             case 0:
                 // need more data, keep decoding until buffer exhausted
                 break;
@@ -662,7 +662,7 @@ int zmq::norm_engine_t::NormRxStreamState::Decode()
     buffer_size = 0;
     zmq_decoder->get_buffer(&buffer_ptr, &buffer_size);
     return 0;  //  need more data
-    
+
 }  // end zmq::norm_engine_t::NormRxStreamState::Decode()
 
 zmq::norm_engine_t::NormRxStreamState::List::List()
@@ -723,6 +723,6 @@ zmq::norm_engine_t::NormRxStreamState* zmq::norm_engine_t::NormRxStreamState::Li
     if (NULL != nextItem) next_item = nextItem->next;
     return nextItem;
 }  // end zmq::norm_engine_t::NormRxStreamState::List::Iterator::GetNextItem()
-    
+
 
 #endif // ZMQ_HAVE_NORM

src/norm_engine.hpp

@@ -16,17 +16,17 @@ namespace zmq
 {
     class io_thread_t;
     class session_base_t;
-    
+
     class norm_engine_t : public io_object_t, public i_engine
     {
         public:
             norm_engine_t (zmq::io_thread_t *parent_, const options_t &options_);
             ~norm_engine_t ();
-            
+
             // create NORM instance, session, etc
             int init(const char* network_, bool send, bool recv);
             void shutdown();
-            
+
             //  i_engine interface implementation.
             //  Plug the engine to the session.
             virtual void plug (zmq::io_thread_t *io_thread_,
@@ -45,43 +45,43 @@ namespace zmq
             virtual void restart_output ();
 
             virtual void zap_msg_available () {};
-            
+
             // i_poll_events interface implementation.
             // (we only need in_event() for NormEvent notification)
             // (i.e., don't have any output events or timers (yet))
             void in_event ();
-            
+
         private:
             void unplug();
             void send_data();
-            void recv_data(NormObjectHandle stream);      
-                
-                
+            void recv_data(NormObjectHandle stream);
+
+
             enum {BUFFER_SIZE = 2048};
-                   
-            // Used to keep track of streams from multiple senders     
+
+            // Used to keep track of streams from multiple senders
             class NormRxStreamState
             {
                 public:
                     NormRxStreamState(NormObjectHandle normStream,
                                       int64_t          maxMsgSize);
                     ~NormRxStreamState();
-                    
+
                     NormObjectHandle GetStreamHandle() const
                         {return norm_stream;}
-                    
+
                     bool Init();
-                    
+
                     void SetRxReady(bool state)
                         {rx_ready = state;}
                     bool IsRxReady() const
                         {return rx_ready;}
-                    
+
                     void SetSync(bool state)
                         {in_sync = state;}
                     bool InSync() const
                         {return in_sync;}
-                    
+
                     // These are used to feed data to decoder
                     // and its underlying "msg" buffer
                     char* AccessBuffer()
@@ -98,21 +98,21 @@ namespace zmq
                     // occurs the 'sync' is dropped and the
                     // decoder re-initialized
                     int Decode();
-                    
+
                     class List
                     {
                         public:
                             List();
                             ~List();
-                            
+
                             void Append(NormRxStreamState& item);
                             void Remove(NormRxStreamState& item);
-                            
+
                             bool IsEmpty() const
                                 {return (NULL == head);}
-                            
+
                             void Destroy();
-                            
+
                             class Iterator
                             {
                                 public:
@@ -122,36 +122,36 @@ namespace zmq
                                     NormRxStreamState* next_item;
                             };
                             friend class Iterator;
-                            
+
                         private:
                             NormRxStreamState*  head;
-                            NormRxStreamState*  tail;        
-                                
+                            NormRxStreamState*  tail;
+
                     };  // end class zmq::norm_engine_t::NormRxStreamState::List
-                    
+
                     friend class List;
-                    
+
                     List* AccessList()
                         {return list;}
-                    
-                    
+
+
                 private:
                     NormObjectHandle            norm_stream;
                     int64_t                     max_msg_size;
-                    bool                        in_sync; 
+                    bool                        in_sync;
                     bool                        rx_ready;
                     v2_decoder_t*               zmq_decoder;
                     bool                        skip_norm_sync;
                     unsigned char*              buffer_ptr;
                     size_t                      buffer_size;
                     size_t                      buffer_count;
-                    
+
                     NormRxStreamState*          prev;
                     NormRxStreamState*          next;
                     NormRxStreamState::List*    list;
-                
+
             };  // end class zmq::norm_engine_t::NormRxStreamState
-            
+
             session_base_t*         zmq_session;
             options_t               options;
             NormInstanceHandle      norm_instance;
@@ -161,25 +161,25 @@ namespace zmq
             bool                    is_receiver;
             // Sender state
             msg_t                   tx_msg;
-            v2_encoder_t            zmq_encoder;    // for tx messages (we use v2 for now)  
+            v2_encoder_t            zmq_encoder;    // for tx messages (we use v2 for now)
             NormObjectHandle        norm_tx_stream;
             bool                    tx_first_msg;
             bool                    tx_more_bit;
-            bool                    zmq_output_ready; // zmq has msg(s) to send 
+            bool                    zmq_output_ready; // zmq has msg(s) to send
             bool                    norm_tx_ready;    // norm has tx queue vacancy
             // TBD - maybe don't need buffer if can access zmq message buffer directly?
             char                    tx_buffer[BUFFER_SIZE];
             unsigned int            tx_index;
             unsigned int            tx_len;
-            
+
             // Receiver state
             // Lists of norm rx streams from remote senders
             bool                    zmq_input_ready; // zmq ready to receive msg(s)
             NormRxStreamState::List rx_pending_list; // rx streams waiting for data reception
             NormRxStreamState::List rx_ready_list;   // rx streams ready for NormStreamRead()
             NormRxStreamState::List msg_ready_list;  // rx streams w/ msg ready for push to zmq
-            
-        
+
+
     };  // end class norm_engine_t
 }
 

src/pipe.cpp

@@ -390,12 +390,12 @@ void zmq::pipe_t::terminate (bool delay_)
     //  If terminate was already called, we can ignore the duplicate invocation.
     if (state == term_req_sent1 || state == term_req_sent2) {
         return;
-	}
+    }
     //  If the pipe is in the final phase of async termination, it's going to
     //  closed anyway. No need to do anything special here.
     else if (state == term_ack_sent) {
         return;
-	}
+    }
     //  The simple sync termination case. Ask the peer to terminate and wait
     //  for the ack.
     else if (state == active) {
@@ -422,7 +422,7 @@ void zmq::pipe_t::terminate (bool delay_)
     //  There are no other states.
     else {
         zmq_assert (false);
-	}
+    }
 
     //  Stop outbound flow of messages.
     out_active = false;

src/select.cpp

@@ -432,9 +432,9 @@ bool zmq::select_t::is_retired_fd (const fd_entry_t &entry)
 #if defined ZMQ_HAVE_WINDOWS
 u_short zmq::select_t::get_fd_family (fd_t fd_)
 {
-	// Use sockaddr_storage instead of sockaddr to accomodate differect structure sizes
-	sockaddr_storage addr = { 0 };
-	int addr_size = sizeof addr;
+    //  Use sockaddr_storage instead of sockaddr to accomodate differect structure sizes
+    sockaddr_storage addr = { 0 };
+    int addr_size = sizeof addr;
 
     int type;
     int type_length = sizeof(int);

src/signaler.cpp

@@ -338,11 +338,11 @@ int zmq::signaler_t::recv_failable ()
 #if defined ZMQ_HAVE_WINDOWS
     int nbytes = ::recv (r, (char *) &dummy, sizeof (dummy), 0);
     if (nbytes == SOCKET_ERROR) {
-		const int last_error = WSAGetLastError();
-		if (last_error == WSAEWOULDBLOCK) {
-			errno = EAGAIN;
+        const int last_error = WSAGetLastError();
+        if (last_error == WSAEWOULDBLOCK) {
+            errno = EAGAIN;
             return -1;
-		}
+        }
         wsa_assert (last_error == WSAEWOULDBLOCK);
     }
 #else
@@ -388,7 +388,7 @@ int zmq::signaler_t::make_fdpair (fd_t *r_, fd_t *w_)
 
 #elif defined ZMQ_HAVE_WINDOWS
 #   if !defined _WIN32_WCE
-    // Windows CE does not manage security attributes
+    //  Windows CE does not manage security attributes
     SECURITY_DESCRIPTOR sd;
     SECURITY_ATTRIBUTES sa;
     memset (&sd, 0, sizeof sd);

src/socket_base.cpp

@@ -432,7 +432,7 @@ int zmq::socket_base_t::getsockopt (int option_, void *optval_,
             return -1;
         }
         memset(optval_, 0, *optvallen_);
-        *((int*) optval_) = thread_safe	? 1 : 0;
+        *((int*) optval_) = thread_safe ? 1 : 0;
         *optvallen_ = sizeof (int);
         return 0;
     }

src/stream.cpp

@@ -60,7 +60,7 @@ zmq::stream_t::~stream_t ()
 
 void zmq::stream_t::xattach_pipe (pipe_t *pipe_, bool subscribe_to_all_)
 {
-	LIBZMQ_UNUSED(subscribe_to_all_);
+    LIBZMQ_UNUSED(subscribe_to_all_);
 
     zmq_assert (pipe_);
 

src/tcp.cpp

@@ -189,7 +189,7 @@ void zmq::tune_tcp_maxrt (fd_t sockfd_, int timeout_)
 
     //  If not a single byte can be written to the socket in non-blocking mode
     //  we'll get an error (this may happen during the speculative write).
-	const int last_error = WSAGetLastError();
+    const int last_error = WSAGetLastError();
     if (nbytes == SOCKET_ERROR && last_error == WSAEWOULDBLOCK)
         return 0;
 
@@ -201,7 +201,7 @@ void zmq::tune_tcp_maxrt (fd_t sockfd_, int timeout_)
           last_error == WSAECONNABORTED ||
           last_error == WSAETIMEDOUT    ||
           last_error == WSAECONNRESET
-		  ))
+        ))
         return -1;
 
     //  Circumvent a Windows bug:
@@ -256,12 +256,12 @@ int zmq::tcp_read (fd_t s_, void *data_, size_t size_)
             errno = EAGAIN;
         }
         else {
-            wsa_assert (last_error == WSAENETDOWN   ||
-                last_error == WSAENETRESET	   ||
-                last_error == WSAECONNABORTED ||
-                last_error == WSAETIMEDOUT	   ||
-                last_error == WSAECONNRESET   ||
-                last_error == WSAECONNREFUSED ||
+            wsa_assert (last_error == WSAENETDOWN ||
+                last_error == WSAENETRESET        ||
+                last_error == WSAECONNABORTED     ||
+                last_error == WSAETIMEDOUT        ||
+                last_error == WSAECONNRESET       ||
+                last_error == WSAECONNREFUSED     ||
                 last_error == WSAENOTCONN);
             errno = wsa_error_to_errno (last_error);
         }

src/tcp_listener.cpp

@@ -281,7 +281,7 @@ zmq::fd_t zmq::tcp_listener_t::accept ()
 
 #ifdef ZMQ_HAVE_WINDOWS
     if (sock == INVALID_SOCKET) {
-		const int last_error = WSAGetLastError();
+        const int last_error = WSAGetLastError();
         wsa_assert (last_error == WSAEWOULDBLOCK ||
             last_error == WSAECONNRESET ||
             last_error == WSAEMFILE ||

src/tweetnacl.c

@@ -573,8 +573,8 @@ int crypto_hashblocks(u8 *x,const u8 *m,u64 n)
       b[3] += t;
       FOR(j,8) a[(j+1)%8] = b[j];
       if (i%16 == 15)
-	FOR(j,16)
-	  w[j] += w[(j+9)%16] + sigma0(w[(j+1)%16]) + sigma1(w[(j+14)%16]);
+        FOR(j,16)
+          w[j] += w[(j+9)%16] + sigma0(w[(j+1)%16]) + sigma1(w[(j+14)%16]);
     }
 
     FOR(i,8) { a[i] += z[i]; z[i] = a[i]; }