diff --git a/src/ctx.cpp b/src/ctx.cpp index baf4be51..73190a26 100644 --- a/src/ctx.cpp +++ b/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_) diff --git a/src/decoder.hpp b/src/decoder.hpp index 6aa912dc..c8fe5bef 100644 --- a/src/decoder.hpp +++ b/src/decoder.hpp @@ -119,7 +119,7 @@ namespace zmq bytes_used_ = size_; while (!to_read) { - const int rc = + const int rc = (static_cast (this)->*next) (data_ + bytes_used_); if (rc != 0) return rc; diff --git a/src/dgram.cpp b/src/dgram.cpp index eecd66cb..64f429c8 100644 --- a/src/dgram.cpp +++ b/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_); diff --git a/src/ip.cpp b/src/ip.cpp index 1d0bbdbc..bc4251d3 100644 --- a/src/ip.cpp +++ b/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 && diff --git a/src/norm_engine.cpp b/src/norm_engine.cpp index 23eac066..3b50acc5 100644 --- a/src/norm_engine.cpp +++ b/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 diff --git a/src/norm_engine.hpp b/src/norm_engine.hpp index fa6d1ffa..5d059ec7 100644 --- a/src/norm_engine.hpp +++ b/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 } diff --git a/src/pipe.cpp b/src/pipe.cpp index ebfacc41..22e7a959 100644 --- a/src/pipe.cpp +++ b/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; diff --git a/src/select.cpp b/src/select.cpp index 4f107518..188281f4 100644 --- a/src/select.cpp +++ b/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); diff --git a/src/signaler.cpp b/src/signaler.cpp index eb84d61c..c280f26d 100644 --- a/src/signaler.cpp +++ b/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); diff --git a/src/socket_base.cpp b/src/socket_base.cpp index 254e5b31..8a8b87df 100644 --- a/src/socket_base.cpp +++ b/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; } diff --git a/src/stream.cpp b/src/stream.cpp index 96acc330..2f4a8d7b 100644 --- a/src/stream.cpp +++ b/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_); diff --git a/src/tcp.cpp b/src/tcp.cpp index 15ccb1ff..a6de1295 100644 --- a/src/tcp.cpp +++ b/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); } diff --git a/src/tcp_listener.cpp b/src/tcp_listener.cpp index 762f421f..0863916b 100644 --- a/src/tcp_listener.cpp +++ b/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 || diff --git a/src/tweetnacl.c b/src/tweetnacl.c index 7095d5cc..02fa9f4f 100644 --- a/src/tweetnacl.c +++ b/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]; }