@@ -46,11 +46,11 @@
     if (mode == TCL_MODE_NONBLOCKING) {
 	statePtr->flags |= TLS_TCL_ASYNC;
     } else {
 	statePtr->flags &= ~(TLS_TCL_ASYNC);
     }
-    return(0);
+    return 0;
 }
 
 /*
  *-------------------------------------------------------------------
  *
@@ -126,11 +126,11 @@
     dprintFlags(statePtr);
 
     if (!(statePtr->flags & TLS_TCL_INIT)) {
 	dprintf("Tls_WaitForConnect called on already initialized channel -- returning with immediate success");
 	*errorCodePtr = 0;
-	return(0);
+	return 0;
     }
 
     if (statePtr->flags & TLS_TCL_HANDSHAKE_FAILED) {
 	/*
 	 * Different types of operations have different requirements
@@ -141,11 +141,11 @@
 	    *errorCodePtr = ECONNABORTED;
 	} else {
 	    dprintf("Asked to wait for a TLS handshake that has already failed.  Returning soft error");
 	    *errorCodePtr = ECONNRESET;
 	}
-	return(-1);
+	return -1;
     }
 
     for (;;) {
 	/* Not initialized yet! */
 	if (statePtr->flags & TLS_TCL_SERVER) {
@@ -188,11 +188,11 @@
 	    dprintf("The I/O did not complete -- but we should try it again");
 
 	    if (statePtr->flags & TLS_TCL_ASYNC) {
 		dprintf("Returning EAGAIN so that it can be retried later");
 		*errorCodePtr = EAGAIN;
-		return(-1);
+		return -1;
 	    } else {
 		dprintf("Doing so now");
 		continue;
 	    }
 	}
@@ -209,11 +209,11 @@
 	    /* The connection is up, we are done here */
 	    dprintf("The connection is up");
 	    break;
 	case SSL_ERROR_ZERO_RETURN:
 	    dprintf("SSL_ERROR_ZERO_RETURN: Connect returned an invalid value...")
-	    return(-1);
+	    return -1;
 	case SSL_ERROR_SYSCALL:
 	    backingError = ERR_get_error();
 
 	    if (backingError == 0 && err == 0) {
 		dprintf("EOF reached")
@@ -237,11 +237,11 @@
 	case SSL_ERROR_SSL:
 	    dprintf("Got permanent fatal SSL error, aborting immediately");
 		Tls_Error(statePtr, (char *)ERR_reason_error_string(ERR_get_error()));
 	    statePtr->flags |= TLS_TCL_HANDSHAKE_FAILED;
 	    *errorCodePtr = ECONNABORTED;
-	    return(-1);
+	    return -1;
 	default:
 	    dprintf("We got a confusing reply: %i", rc);
 	    *errorCodePtr = Tcl_GetErrno();
 	    dprintf("ERR(%d, %d) ", rc, *errorCodePtr);
 	    return -1;
@@ -256,11 +256,11 @@
 		dprintf("Invalid certificate, returning in failure");
 
 		Tls_Error(statePtr, (char *)X509_verify_cert_error_string(err));
 		statePtr->flags |= TLS_TCL_HANDSHAKE_FAILED;
 		*errorCodePtr = ECONNABORTED;
-		return(-1);
+		return -1;
 	}
     }
 #endif
 
     dprintf("Removing the \"TLS_TCL_INIT\" flag since we have completed the handshake");
@@ -306,11 +306,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) {
@@ -321,11 +321,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
@@ -439,11 +439,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) {
@@ -454,11 +454,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);
@@ -466,16 +466,16 @@
 	if (err <= 0) {
 	    dprintf("Flushing 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
@@ -540,11 +540,11 @@
 	    dprintf("unknown error: %d", err);
 	    break;
     }
 
     dprintf("Output(%d) -> %d", toWrite, written);
-    return(written);
+    return written;
 }
 
 /*
  *-------------------------------------------------------------------
  *
@@ -735,11 +735,11 @@
     int direction,		/* TCL_READABLE or TCL_WRITABLE */
     void **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);
 }
 
 /*
  *-------------------------------------------------------------------
  *
@@ -799,11 +799,11 @@
 	dprintf("Tls_WaitForConnect returned an error");
     }
 
     dprintf("Returning %i", mask);
 
-    return(mask);
+    return mask;
 }
 
 /*
  *------------------------------------------------------*
  *
@@ -853,11 +853,11 @@
 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);
 }
 
 /*