@@ -47,11 +47,11 @@
     if (mode == TCL_MODE_NONBLOCKING) {
 	statePtr->flags |= TLS_TCL_ASYNC;
     } else {
 	statePtr->flags &= ~(TLS_TCL_ASYNC);
     }
-    return(0);
+    return 0;
 }
 
 /*
  *-------------------------------------------------------------------
  *
@@ -76,11 +76,11 @@
 
     dprintf("TlsCloseProc(%p)", (void *) statePtr);
 
     Tls_Clean(statePtr);
     Tcl_EventuallyFree((ClientData)statePtr, Tls_Free);
-    return(0);
+    return 0;
 }
 
 static int TlsClose2Proc(ClientData instanceData,    /* The socket state. */
     Tcl_Interp *interp,		/* For errors - can be NULL. */
     int flags)			/* Flags to close read and/or write side of channel */
@@ -117,11 +117,11 @@
     dprintf("WaitForConnect(%p)", (void *) statePtr);
     dprintFlags(statePtr);
 
     if (!(statePtr->flags & TLS_TCL_INIT)) {
 	dprintf("Tls_WaitForConnect called on already initialized channel -- returning with immediate success");
-	return(0);
+	return 0;
     }
 
     if (statePtr->flags & TLS_TCL_HANDSHAKE_FAILED) {
 	/*
 	 * Different types of operations have different requirements
@@ -133,11 +133,11 @@
 	} else {
 	    dprintf("Asked to wait for a TLS handshake that has already failed.  Returning soft error");
 	    *errorCodePtr = ECONNRESET;
 	}
 	Tls_Error(statePtr, "Wait for failed handshake");
-	return(-1);
+	return -1;
     }
 
     for (;;) {
 	ERR_clear_error();
 
@@ -189,11 +189,11 @@
 
 	    if (statePtr->flags & TLS_TCL_ASYNC) {
 		dprintf("Returning EAGAIN so that it can be retried later");
 		*errorCodePtr = EAGAIN;
 		Tls_Error(statePtr, "Handshake not complete, will retry later");
-		return(-1);
+		return -1;
 	    } else {
 		dprintf("Doing so now");
 		continue;
 	    }
 	}
@@ -212,11 +212,11 @@
 	case SSL_ERROR_ZERO_RETURN:
 	    /* The TLS/SSL peer has closed the connection for writing by sending the close_notify alert */
 	    dprintf("SSL_ERROR_ZERO_RETURN: Connect returned an invalid value...");
 	    *errorCodePtr = EINVAL;
 	    Tls_Error(statePtr, "Peer has closed the connection for writing by sending the close_notify alert");
-	    return(-1);
+	    return -1;
 
 	case SSL_ERROR_SYSCALL:
 	    /* Some non-recoverable, fatal I/O error occurred */
 	    dprintf("SSL_ERROR_SYSCALL");
 
@@ -241,11 +241,11 @@
 		}
 		Tls_Error(statePtr, (char *) ERR_reason_error_string(backingError));
 	    }
 
 	    statePtr->flags |= TLS_TCL_HANDSHAKE_FAILED;
-	    return(-1);
+	    return -1;
 
 	case SSL_ERROR_SSL:
 	    /* A non-recoverable, fatal error in the SSL library occurred, usually a protocol error */
 	    dprintf("SSL_ERROR_SSL: Got permanent fatal SSL error, aborting immediately");
 	    if (SSL_get_verify_result(statePtr->ssl) != X509_V_OK) {
@@ -254,11 +254,11 @@
 	    if (backingError != 0) {
 		Tls_Error(statePtr, (char *) ERR_reason_error_string(backingError));
 	    }
 	    statePtr->flags |= TLS_TCL_HANDSHAKE_FAILED;
 	    *errorCodePtr = ECONNABORTED;
-	    return(-1);
+	    return -1;
 
 	case SSL_ERROR_WANT_READ:
 	case SSL_ERROR_WANT_WRITE:
 	case SSL_ERROR_WANT_X509_LOOKUP:
 	case SSL_ERROR_WANT_CONNECT:
@@ -270,19 +270,19 @@
 	    /* The operation did not complete and should be retried later. */
 	    dprintf("Operation did not complete, call function again later: %i", rc);
 	    *errorCodePtr = EAGAIN;
 	    dprintf("ERR(%d, %d) ", rc, *errorCodePtr);
 	    Tls_Error(statePtr, "Operation did not complete, call function again later");
-	    return(-1);
+	    return -1;
     }
 
     dprintf("Removing the \"TLS_TCL_INIT\" flag since we have completed the handshake");
     statePtr->flags &= ~TLS_TCL_INIT;
 
     dprintf("Returning in success");
     *errorCodePtr = 0;
-    return(0);
+    return 0;
 }
 
 /*
  *-------------------------------------------------------------------
  *
@@ -312,11 +312,11 @@
     dprintf("BIO_read(%d)", bufSize);
 
     if (statePtr->flags & TLS_TCL_CALLBACK) {
 	/* don't process any bytes while verify callback is running */
 	dprintf("Callback is running, reading 0 bytes");
-	return(0);
+	return 0;
     }
 
     dprintf("Calling Tls_WaitForConnect");
     tlsConnect = Tls_WaitForConnect(statePtr, errorCodePtr, 0);
     if (tlsConnect < 0) {
@@ -328,11 +328,11 @@
 	    dprintf("Got connection reset");
 	    /* Soft EOF */
 	    *errorCodePtr = 0;
 	    bytesRead = 0;
 	}
-	return(bytesRead);
+	return bytesRead;
     }
 
     /*
      * We need to clear the SSL error stack now because we sometimes reach
      * this function with leftover errors in the stack.  If BIO_read
@@ -434,11 +434,11 @@
 	    Tls_Error(statePtr, "Unknown error");
 	    break;
     }
 
     dprintf("Input(%d) -> %d [%d]", bufSize, bytesRead, *errorCodePtr);
-    return(bytesRead);
+    return bytesRead;
 }
 
 /*
  *-------------------------------------------------------------------
  *
@@ -469,11 +469,11 @@
 
     if (statePtr->flags & TLS_TCL_CALLBACK) {
 	dprintf("Don't process output while callbacks are running");
 	written = -1;
 	*errorCodePtr = EAGAIN;
-	return(-1);
+	return -1;
     }
 
     dprintf("Calling Tls_WaitForConnect");
     tlsConnect = Tls_WaitForConnect(statePtr, errorCodePtr, 1);
     if (tlsConnect < 0) {
@@ -485,11 +485,11 @@
 	    dprintf("Got connection reset");
 	    /* Soft EOF */
 	    *errorCodePtr = 0;
 	    written = 0;
 	}
-	return(written);
+	return written;
     }
 
     if (toWrite == 0) {
 	dprintf("zero-write");
 	err = BIO_flush(statePtr->bio);
@@ -498,16 +498,16 @@
 	    dprintf("Flushing failed");
 	    Tls_Error(statePtr, "Flush failed");
 
 	    *errorCodePtr = EIO;
 	    written = 0;
-	    return(-1);
+	    return -1;
 	}
 
 	written = 0;
 	*errorCodePtr = 0;
-	return(0);
+	return 0;
     }
 
     /*
      * We need to clear the SSL error stack now because we sometimes reach
      * this function with leftover errors in the stack.  If BIO_write
@@ -599,11 +599,11 @@
 	    Tls_Error(statePtr, "Unknown error");
 	    break;
     }
 
     dprintf("Output(%d) -> %d", toWrite, written);
-    return(written);
+    return written;
 }
 
 /*
  *-------------------------------------------------------------------
  *
@@ -794,11 +794,11 @@
     int direction,		/* TCL_READABLE or TCL_WRITABLE */
     ClientData *handlePtr)	/* Handle associated with the channel */
 {
     State *statePtr = (State *) instanceData;
 
-    return(Tcl_GetChannelHandle(Tls_GetParent(statePtr, TLS_TCL_FASTPATH), direction, handlePtr));
+    return Tcl_GetChannelHandle(Tls_GetParent(statePtr, TLS_TCL_FASTPATH), direction, handlePtr);
 }
 
 /*
  *-------------------------------------------------------------------
  *
@@ -857,11 +857,11 @@
 	dprintf("Tls_WaitForConnect returned an error");
     }
 
     dprintf("Returning %i", mask);
 
-    return(mask);
+    return mask;
 }
 
 /*
  *------------------------------------------------------*
  *
@@ -911,13 +911,13 @@
 Tcl_Channel Tls_GetParent(State *statePtr, int maskFlags) {
     dprintf("Requested to get parent of channel %p", statePtr->self);
 
     if ((statePtr->flags & ~maskFlags) & TLS_TCL_FASTPATH) {
 	dprintf("Asked to get the parent channel while we are using FastPath -- returning NULL");
-	return(NULL);
+	return NULL;
     }
-    return(Tcl_GetStackedChannel(statePtr->self));
+    return Tcl_GetStackedChannel(statePtr->self);
 }
 
 /*
  *-------------------------------------------------------------------
  *