sodium ext: use unexpand -t 4 --first-only to convert from spaces to tabs

No actual code changes.

Fun fact: macOS' unexpand(1) tool doesn't work as documented, and always
converts everything to tabs, regardless of the -a switch.

diff --git a/ext/sodium/libsodium.c b/ext/sodium/libsodium.c
index ae06c6934a0d26523b936ea2fa743a4b34bbed63..2c9a385b1472730ec23fdd8f17aa4ad2d0d354af 100644 (file)
--- a/ext/sodium/libsodium.c
+++ b/ext/sodium/libsodium.c
@@ -537,7 +537,7 @@ PHP_MINFO_FUNCTION(sodium)
 
 PHP_FUNCTION(sodium_memzero)
 {
-       zval      *buf_zv;
+       zval      *buf_zv;
 
        if (zend_parse_parameters(ZEND_NUM_ARGS(),
                                                          "z", &buf_zv) == FAILURE) {
@@ -560,9 +560,9 @@ PHP_FUNCTION(sodium_memzero)
 
 PHP_FUNCTION(sodium_increment)
 {
-       zval              *val_zv;
+       zval          *val_zv;
        unsigned char *val;
-       size_t             val_len;
+       size_t         val_len;
 
        if (zend_parse_parameters(ZEND_NUM_ARGS(),
                                                          "z", &val_zv) == FAILURE) {
@@ -582,11 +582,11 @@ PHP_FUNCTION(sodium_increment)
 
 PHP_FUNCTION(sodium_add)
 {
-       zval              *val_zv;
+       zval          *val_zv;
        unsigned char *val;
        unsigned char *addv;
-       size_t             val_len;
-       size_t             addv_len;
+       size_t         val_len;
+       size_t         addv_len;
 
        if (zend_parse_parameters(ZEND_NUM_ARGS(),
                                                          "zs", &val_zv, &addv, &addv_len) == FAILURE) {
@@ -610,10 +610,10 @@ PHP_FUNCTION(sodium_add)
 
 PHP_FUNCTION(sodium_memcmp)
 {
-       char      *buf1;
-       char      *buf2;
-       size_t     len1;
-       size_t     len2;
+       char      *buf1;
+       char      *buf2;
+       size_t     len1;
+       size_t     len2;
 
        if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss",
                                                          &buf1, &len1,
@@ -629,11 +629,11 @@ PHP_FUNCTION(sodium_memcmp)
 
 PHP_FUNCTION(sodium_crypto_shorthash)
 {
-       zend_string       *hash;
+       zend_string   *hash;
        unsigned char *key;
        unsigned char *msg;
-       size_t             key_len;
-       size_t             msg_len;
+       size_t         key_len;
+       size_t         msg_len;
 
        if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss",
                                                          &msg, &msg_len,
@@ -660,13 +660,13 @@ PHP_FUNCTION(sodium_crypto_shorthash)
 
 PHP_FUNCTION(sodium_crypto_secretbox)
 {
-       zend_string       *ciphertext;
+       zend_string   *ciphertext;
        unsigned char *key;
        unsigned char *msg;
        unsigned char *nonce;
-       size_t             key_len;
-       size_t             msg_len;
-       size_t             nonce_len;
+       size_t         key_len;
+       size_t         msg_len;
+       size_t         nonce_len;
 
        if (zend_parse_parameters(ZEND_NUM_ARGS(), "sss",
                                                          &msg, &msg_len,
@@ -705,13 +705,13 @@ PHP_FUNCTION(sodium_crypto_secretbox)
 
 PHP_FUNCTION(sodium_crypto_secretbox_open)
 {
-       zend_string       *msg;
+       zend_string   *msg;
        unsigned char *key;
        unsigned char *ciphertext;
        unsigned char *nonce;
-       size_t             key_len;
-       size_t             ciphertext_len;
-       size_t             nonce_len;
+       size_t         key_len;
+       size_t         ciphertext_len;
+       size_t         nonce_len;
 
        if (zend_parse_parameters(ZEND_NUM_ARGS(), "sss",
                                                          &ciphertext, &ciphertext_len,
@@ -749,12 +749,12 @@ PHP_FUNCTION(sodium_crypto_secretbox_open)
 
 PHP_FUNCTION(sodium_crypto_generichash)
 {
-       zend_string       *hash;
+       zend_string   *hash;
        unsigned char *key = NULL;
        unsigned char *msg;
-       zend_long          hash_len = crypto_generichash_BYTES;
-       size_t             key_len = 0;
-       size_t             msg_len;
+       zend_long      hash_len = crypto_generichash_BYTES;
+       size_t         key_len = 0;
+       size_t         msg_len;
 
        if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|sl",
                                                          &msg, &msg_len,
@@ -789,11 +789,11 @@ PHP_FUNCTION(sodium_crypto_generichash)
 PHP_FUNCTION(sodium_crypto_generichash_init)
 {
        crypto_generichash_state  state_tmp;
-       zend_string                              *state;
-       unsigned char                    *key = NULL;
-       size_t                                    state_len = sizeof (crypto_generichash_state);
-       zend_long                                 hash_len = crypto_generichash_BYTES;
-       size_t                                    key_len = 0;
+       zend_string              *state;
+       unsigned char            *key = NULL;
+       size_t                    state_len = sizeof (crypto_generichash_state);
+       zend_long                 hash_len = crypto_generichash_BYTES;
+       size_t                    key_len = 0;
 
        if (zend_parse_parameters(ZEND_NUM_ARGS(), "|sl",
                                                          &key, &key_len,
@@ -827,11 +827,11 @@ PHP_FUNCTION(sodium_crypto_generichash_init)
 PHP_FUNCTION(sodium_crypto_generichash_update)
 {
        crypto_generichash_state  state_tmp;
-       zval                                     *state_zv;
-       unsigned char                    *msg;
-       unsigned char                    *state;
-       size_t                                    msg_len;
-       size_t                                    state_len;
+       zval                     *state_zv;
+       unsigned char            *msg;
+       unsigned char            *state;
+       size_t                    msg_len;
+       size_t                    state_len;
 
        if (zend_parse_parameters(ZEND_NUM_ARGS(), "zs",
                                                          &state_zv, &msg, &msg_len) == FAILURE) {
@@ -865,11 +865,11 @@ PHP_FUNCTION(sodium_crypto_generichash_update)
 PHP_FUNCTION(sodium_crypto_generichash_final)
 {
        crypto_generichash_state  state_tmp;
-       zend_string                              *hash;
-       zval                                     *state_zv;
-       unsigned char                    *state;
-       size_t                                    state_len;
-       zend_long                                 hash_len = crypto_generichash_BYTES;
+       zend_string              *hash;
+       zval                     *state_zv;
+       unsigned char            *state;
+       size_t                    state_len;
+       zend_long                 hash_len = crypto_generichash_BYTES;
 
        if (zend_parse_parameters(ZEND_NUM_ARGS(), "z|l",
                                                          &state_zv, &hash_len) == FAILURE) {
@@ -913,7 +913,7 @@ PHP_FUNCTION(sodium_crypto_generichash_final)
 PHP_FUNCTION(sodium_crypto_box_keypair)
 {
        zend_string *keypair;
-       size_t           keypair_len;
+       size_t       keypair_len;
 
        if (zend_parse_parameters_none() == FAILURE) {
                return;
@@ -934,10 +934,10 @@ PHP_FUNCTION(sodium_crypto_box_keypair)
 
 PHP_FUNCTION(sodium_crypto_box_seed_keypair)
 {
-       zend_string       *keypair;
+       zend_string   *keypair;
        unsigned char *seed;
-       size_t             keypair_len;
-       size_t             seed_len;
+       size_t         keypair_len;
+       size_t         seed_len;
 
        if (zend_parse_parameters(ZEND_NUM_ARGS(), "s",
                                                          &seed, &seed_len) == FAILURE) {
@@ -967,11 +967,11 @@ PHP_FUNCTION(sodium_crypto_box_seed_keypair)
 PHP_FUNCTION(sodium_crypto_box_keypair_from_secretkey_and_publickey)
 {
        zend_string *keypair;
-       char            *publickey;
-       char            *secretkey;
-       size_t           keypair_len;
-       size_t           publickey_len;
-       size_t           secretkey_len;
+       char        *publickey;
+       char        *secretkey;
+       size_t       keypair_len;
+       size_t       publickey_len;
+       size_t       secretkey_len;
 
        if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss",
                                                          &secretkey, &secretkey_len,
@@ -1002,9 +1002,9 @@ PHP_FUNCTION(sodium_crypto_box_keypair_from_secretkey_and_publickey)
 
 PHP_FUNCTION(sodium_crypto_box_secretkey)
 {
-       zend_string       *secretkey;
+       zend_string   *secretkey;
        unsigned char *keypair;
-       size_t             keypair_len;
+       size_t         keypair_len;
 
        if (zend_parse_parameters(ZEND_NUM_ARGS(), "s",
                                                          &keypair, &keypair_len) == FAILURE) {
@@ -1026,9 +1026,9 @@ PHP_FUNCTION(sodium_crypto_box_secretkey)
 
 PHP_FUNCTION(sodium_crypto_box_publickey)
 {
-       zend_string       *publickey;
+       zend_string   *publickey;
        unsigned char *keypair;
-       size_t             keypair_len;
+       size_t         keypair_len;
 
        if (zend_parse_parameters(ZEND_NUM_ARGS(), "s",
                                                          &keypair, &keypair_len) == FAILURE) {
@@ -1051,9 +1051,9 @@ PHP_FUNCTION(sodium_crypto_box_publickey)
 
 PHP_FUNCTION(sodium_crypto_box_publickey_from_secretkey)
 {
-       zend_string       *publickey;
+       zend_string   *publickey;
        unsigned char *secretkey;
-       size_t             secretkey_len;
+       size_t         secretkey_len;
 
        if (zend_parse_parameters(ZEND_NUM_ARGS(), "s",
                                                          &secretkey, &secretkey_len) == FAILURE) {
@@ -1078,15 +1078,15 @@ PHP_FUNCTION(sodium_crypto_box_publickey_from_secretkey)
 
 PHP_FUNCTION(sodium_crypto_box)
 {
-       zend_string       *ciphertext;
+       zend_string   *ciphertext;
        unsigned char *keypair;
        unsigned char *msg;
        unsigned char *nonce;
        unsigned char *publickey;
        unsigned char *secretkey;
-       size_t             keypair_len;
-       size_t             msg_len;
-       size_t             nonce_len;
+       size_t         keypair_len;
+       size_t         msg_len;
+       size_t         nonce_len;
 
        if (zend_parse_parameters(ZEND_NUM_ARGS(), "sss",
                                                          &msg, &msg_len,
@@ -1127,15 +1127,15 @@ PHP_FUNCTION(sodium_crypto_box)
 
 PHP_FUNCTION(sodium_crypto_box_open)
 {
-       zend_string       *msg;
+       zend_string   *msg;
        unsigned char *ciphertext;
        unsigned char *keypair;
        unsigned char *nonce;
        unsigned char *publickey;
        unsigned char *secretkey;
-       size_t             ciphertext_len;
-       size_t             keypair_len;
-       size_t             nonce_len;
+       size_t         ciphertext_len;
+       size_t         keypair_len;
+       size_t         nonce_len;
 
        if (zend_parse_parameters(ZEND_NUM_ARGS(), "sss",
                                                          &ciphertext, &ciphertext_len,
@@ -1175,11 +1175,11 @@ PHP_FUNCTION(sodium_crypto_box_open)
 #ifdef crypto_box_SEALBYTES
 PHP_FUNCTION(sodium_crypto_box_seal)
 {
-       zend_string       *ciphertext;
+       zend_string   *ciphertext;
        unsigned char *msg;
        unsigned char *publickey;
-       size_t             msg_len;
-       size_t             publickey_len;
+       size_t         msg_len;
+       size_t         publickey_len;
 
        if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss",
                                                          &msg, &msg_len,
@@ -1210,13 +1210,13 @@ PHP_FUNCTION(sodium_crypto_box_seal)
 
 PHP_FUNCTION(sodium_crypto_box_seal_open)
 {
-       zend_string       *msg;
+       zend_string   *msg;
        unsigned char *ciphertext;
        unsigned char *keypair;
        unsigned char *publickey;
        unsigned char *secretkey;
-       size_t             ciphertext_len;
-       size_t             keypair_len;
+       size_t         ciphertext_len;
+       size_t         keypair_len;
 
        if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss",
                                                          &ciphertext, &ciphertext_len,
@@ -1250,7 +1250,7 @@ PHP_FUNCTION(sodium_crypto_box_seal_open)
 PHP_FUNCTION(sodium_crypto_sign_keypair)
 {
        zend_string *keypair;
-       size_t           keypair_len;
+       size_t       keypair_len;
 
        if (zend_parse_parameters_none() == FAILURE) {
                return;
@@ -1271,10 +1271,10 @@ PHP_FUNCTION(sodium_crypto_sign_keypair)
 
 PHP_FUNCTION(sodium_crypto_sign_seed_keypair)
 {
-       zend_string       *keypair;
+       zend_string   *keypair;
        unsigned char *seed;
-       size_t             keypair_len;
-       size_t             seed_len;
+       size_t         keypair_len;
+       size_t         seed_len;
 
        if (zend_parse_parameters(ZEND_NUM_ARGS(), "s",
                                                          &seed, &seed_len) == FAILURE) {
@@ -1304,11 +1304,11 @@ PHP_FUNCTION(sodium_crypto_sign_seed_keypair)
 PHP_FUNCTION(sodium_crypto_sign_keypair_from_secretkey_and_publickey)
 {
        zend_string *keypair;
-       char            *publickey;
-       char            *secretkey;
-       size_t           keypair_len;
-       size_t           publickey_len;
-       size_t           secretkey_len;
+       char        *publickey;
+       char        *secretkey;
+       size_t       keypair_len;
+       size_t       publickey_len;
+       size_t       secretkey_len;
 
        if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss",
                                                          &secretkey, &secretkey_len,
@@ -1340,8 +1340,8 @@ PHP_FUNCTION(sodium_crypto_sign_keypair_from_secretkey_and_publickey)
 PHP_FUNCTION(sodium_crypto_sign_publickey_from_secretkey)
 {
        zend_string *publickey;
-       char            *secretkey;
-       size_t           secretkey_len;
+       char        *secretkey;
+       size_t       secretkey_len;
 
        if (zend_parse_parameters(ZEND_NUM_ARGS(), "s",
                                                          &secretkey, &secretkey_len) == FAILURE) {
@@ -1368,9 +1368,9 @@ PHP_FUNCTION(sodium_crypto_sign_publickey_from_secretkey)
 
 PHP_FUNCTION(sodium_crypto_sign_secretkey)
 {
-       zend_string       *secretkey;
+       zend_string   *secretkey;
        unsigned char *keypair;
-       size_t             keypair_len;
+       size_t         keypair_len;
 
        if (zend_parse_parameters(ZEND_NUM_ARGS(), "s",
                                                          &keypair, &keypair_len) == FAILURE) {
@@ -1392,9 +1392,9 @@ PHP_FUNCTION(sodium_crypto_sign_secretkey)
 
 PHP_FUNCTION(sodium_crypto_sign_publickey)
 {
-       zend_string       *publickey;
+       zend_string   *publickey;
        unsigned char *keypair;
-       size_t             keypair_len;
+       size_t         keypair_len;
 
        if (zend_parse_parameters(ZEND_NUM_ARGS(), "s",
                                                          &keypair, &keypair_len) == FAILURE) {
@@ -1417,13 +1417,13 @@ PHP_FUNCTION(sodium_crypto_sign_publickey)
 
 PHP_FUNCTION(sodium_crypto_sign)
 {
-       zend_string                *msg_signed;
-       unsigned char      *msg;
-       unsigned char      *secretkey;
-       unsigned long long      msg_signed_real_len;
-       size_t                          msg_len;
-       size_t                          msg_signed_len;
-       size_t                          secretkey_len;
+       zend_string        *msg_signed;
+       unsigned char      *msg;
+       unsigned char      *secretkey;
+       unsigned long long  msg_signed_real_len;
+       size_t              msg_len;
+       size_t              msg_signed_len;
+       size_t              secretkey_len;
 
        if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss",
                                                          &msg, &msg_len,
@@ -1463,13 +1463,13 @@ PHP_FUNCTION(sodium_crypto_sign)
 
 PHP_FUNCTION(sodium_crypto_sign_open)
 {
-       zend_string                *msg;
-       unsigned char      *msg_signed;
-       unsigned char      *publickey;
-       unsigned long long      msg_real_len;
-       size_t                          msg_len;
-       size_t                          msg_signed_len;
-       size_t                          publickey_len;
+       zend_string        *msg;
+       unsigned char      *msg_signed;
+       unsigned char      *publickey;
+       unsigned long long  msg_real_len;
+       size_t              msg_len;
+       size_t              msg_signed_len;
+       size_t              publickey_len;
 
        if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss",
                                                          &msg_signed, &msg_signed_len,
@@ -1507,12 +1507,12 @@ PHP_FUNCTION(sodium_crypto_sign_open)
 
 PHP_FUNCTION(sodium_crypto_sign_detached)
 {
-       zend_string                *signature;
-       unsigned char      *msg;
-       unsigned char      *secretkey;
-       unsigned long long      signature_real_len;
-       size_t                          msg_len;
-       size_t                          secretkey_len;
+       zend_string        *signature;
+       unsigned char      *msg;
+       unsigned char      *secretkey;
+       unsigned long long  signature_real_len;
+       size_t              msg_len;
+       size_t              secretkey_len;
 
        if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss",
                                                          &msg, &msg_len,
@@ -1549,9 +1549,9 @@ PHP_FUNCTION(sodium_crypto_sign_verify_detached)
        unsigned char *msg;
        unsigned char *publickey;
        unsigned char *signature;
-       size_t             msg_len;
-       size_t             publickey_len;
-       size_t             signature_len;
+       size_t         msg_len;
+       size_t         publickey_len;
+       size_t         signature_len;
 
        if (zend_parse_parameters(ZEND_NUM_ARGS(), "sss",
                                                          &signature, &signature_len,
@@ -1581,12 +1581,12 @@ PHP_FUNCTION(sodium_crypto_sign_verify_detached)
 
 PHP_FUNCTION(sodium_crypto_stream)
 {
-       zend_string       *ciphertext;
+       zend_string   *ciphertext;
        unsigned char *key;
        unsigned char *nonce;
-       zend_long          ciphertext_len;
-       size_t             key_len;
-       size_t             nonce_len;
+       zend_long      ciphertext_len;
+       size_t         key_len;
+       size_t         nonce_len;
 
        if (zend_parse_parameters(ZEND_NUM_ARGS(), "lss",
                                                          &ciphertext_len,
@@ -1620,14 +1620,14 @@ PHP_FUNCTION(sodium_crypto_stream)
 
 PHP_FUNCTION(sodium_crypto_stream_xor)
 {
-       zend_string       *ciphertext;
+       zend_string   *ciphertext;
        unsigned char *key;
        unsigned char *msg;
        unsigned char *nonce;
-       size_t             ciphertext_len;
-       size_t             key_len;
-       size_t             msg_len;
-       size_t             nonce_len;
+       size_t         ciphertext_len;
+       size_t         key_len;
+       size_t         msg_len;
+       size_t         nonce_len;
 
        if (zend_parse_parameters(ZEND_NUM_ARGS(), "sss",
                                                          &msg, &msg_len,
@@ -1658,14 +1658,14 @@ PHP_FUNCTION(sodium_crypto_stream_xor)
 
 PHP_FUNCTION(sodium_crypto_pwhash_scryptsalsa208sha256)
 {
-       zend_string       *hash;
+       zend_string   *hash;
        unsigned char *salt;
-       char              *passwd;
-       zend_long          hash_len;
-       zend_long          memlimit;
-       zend_long          opslimit;
-       size_t             passwd_len;
-       size_t             salt_len;
+       char          *passwd;
+       zend_long      hash_len;
+       zend_long      memlimit;
+       zend_long      opslimit;
+       size_t         passwd_len;
+       size_t         salt_len;
 
        if (zend_parse_parameters(ZEND_NUM_ARGS(), "lssll",
                                                          &hash_len,
@@ -1711,10 +1711,10 @@ PHP_FUNCTION(sodium_crypto_pwhash_scryptsalsa208sha256)
 PHP_FUNCTION(sodium_crypto_pwhash_scryptsalsa208sha256_str)
 {
        zend_string *hash_str;
-       char            *passwd;
-       zend_long        memlimit;
-       zend_long        opslimit;
-       size_t           passwd_len;
+       char        *passwd;
+       zend_long    memlimit;
+       zend_long    opslimit;
+       size_t       passwd_len;
 
        if (zend_parse_parameters(ZEND_NUM_ARGS(), "sll",
                                                          &passwd, &passwd_len,
@@ -1752,10 +1752,10 @@ PHP_FUNCTION(sodium_crypto_pwhash_scryptsalsa208sha256_str)
 
 PHP_FUNCTION(sodium_crypto_pwhash_scryptsalsa208sha256_str_verify)
 {
-       char      *hash_str;
-       char      *passwd;
-       size_t     hash_str_len;
-       size_t     passwd_len;
+       char      *hash_str;
+       char      *passwd;
+       size_t     hash_str_len;
+       size_t     passwd_len;
 
        if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss",
                                                          &hash_str, &hash_str_len,
@@ -1782,15 +1782,15 @@ PHP_FUNCTION(sodium_crypto_pwhash_scryptsalsa208sha256_str_verify)
 #ifdef crypto_pwhash_SALTBYTES
 PHP_FUNCTION(sodium_crypto_pwhash)
 {
-       zend_string       *hash;
+       zend_string   *hash;
        unsigned char *salt;
-       char              *passwd;
-       zend_long          hash_len;
-       zend_long          memlimit;
-       zend_long          opslimit;
-       zend_long          alg;
-       size_t             passwd_len;
-       size_t             salt_len;
+       char          *passwd;
+       zend_long      hash_len;
+       zend_long      memlimit;
+       zend_long      opslimit;
+       zend_long      alg;
+       size_t         passwd_len;
+       size_t         salt_len;
 
        alg = (zend_long) crypto_pwhash_ALG_DEFAULT;
        if (zend_parse_parameters(ZEND_NUM_ARGS(), "lssll|l",
@@ -1843,11 +1843,11 @@ PHP_FUNCTION(sodium_crypto_pwhash)
 PHP_FUNCTION(sodium_crypto_pwhash_str)
 {
        zend_string *hash_str;
-       char            *passwd;
-       zend_long        memlimit;
-       zend_long        opslimit;
-       size_t           passwd_len;
-       size_t           len;
+       char        *passwd;
+       zend_long    memlimit;
+       zend_long    opslimit;
+       size_t       passwd_len;
+       size_t       len;
 
        if (zend_parse_parameters(ZEND_NUM_ARGS(), "sll",
                                                          &passwd, &passwd_len,
@@ -1887,10 +1887,10 @@ PHP_FUNCTION(sodium_crypto_pwhash_str)
 
 PHP_FUNCTION(sodium_crypto_pwhash_str_verify)
 {
-       char      *hash_str;
-       char      *passwd;
-       size_t     hash_str_len;
-       size_t     passwd_len;
+       char      *hash_str;
+       char      *passwd;
+       size_t     hash_str_len;
+       size_t     passwd_len;
 
        if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss",
                                                          &hash_str, &hash_str_len,
@@ -1926,17 +1926,17 @@ PHP_FUNCTION(sodium_crypto_aead_aes256gcm_is_available)
 #ifdef HAVE_AESGCM
 PHP_FUNCTION(sodium_crypto_aead_aes256gcm_encrypt)
 {
-       zend_string                *ciphertext;
-       unsigned char      *ad;
-       unsigned char      *msg;
-       unsigned char      *npub;
-       unsigned char      *secretkey;
-       unsigned long long      ciphertext_real_len;
-       size_t                          ad_len;
-       size_t                          ciphertext_len;
-       size_t                          msg_len;
-       size_t                          npub_len;
-       size_t                          secretkey_len;
+       zend_string        *ciphertext;
+       unsigned char      *ad;
+       unsigned char      *msg;
+       unsigned char      *npub;
+       unsigned char      *secretkey;
+       unsigned long long  ciphertext_real_len;
+       size_t              ad_len;
+       size_t              ciphertext_len;
+       size_t              msg_len;
+       size_t              npub_len;
+       size_t              secretkey_len;
 
        if (zend_parse_parameters(ZEND_NUM_ARGS(), "ssss",
                                                          &msg, &msg_len,
@@ -1987,17 +1987,17 @@ PHP_FUNCTION(sodium_crypto_aead_aes256gcm_encrypt)
 
 PHP_FUNCTION(sodium_crypto_aead_aes256gcm_decrypt)
 {
-       zend_string                *msg;
-       unsigned char      *ad;
-       unsigned char      *ciphertext;
-       unsigned char      *npub;
-       unsigned char      *secretkey;
-       unsigned long long      msg_real_len;
-       size_t                          ad_len;
-       size_t                          ciphertext_len;
-       size_t                          msg_len;
-       size_t                          npub_len;
-       size_t                          secretkey_len;
+       zend_string        *msg;
+       unsigned char      *ad;
+       unsigned char      *ciphertext;
+       unsigned char      *npub;
+       unsigned char      *secretkey;
+       unsigned long long  msg_real_len;
+       size_t              ad_len;
+       size_t              ciphertext_len;
+       size_t              msg_len;
+       size_t              npub_len;
+       size_t              secretkey_len;
 
        if (zend_parse_parameters(ZEND_NUM_ARGS(), "ssss",
                                                          &ciphertext, &ciphertext_len,
@@ -2048,17 +2048,17 @@ PHP_FUNCTION(sodium_crypto_aead_aes256gcm_decrypt)
 
 PHP_FUNCTION(sodium_crypto_aead_chacha20poly1305_encrypt)
 {
-       zend_string                *ciphertext;
-       unsigned char      *ad;
-       unsigned char      *msg;
-       unsigned char      *npub;
-       unsigned char      *secretkey;
-       unsigned long long      ciphertext_real_len;
-       size_t                          ad_len;
-       size_t                          ciphertext_len;
-       size_t                          msg_len;
-       size_t                          npub_len;
-       size_t                          secretkey_len;
+       zend_string        *ciphertext;
+       unsigned char      *ad;
+       unsigned char      *msg;
+       unsigned char      *npub;
+       unsigned char      *secretkey;
+       unsigned long long  ciphertext_real_len;
+       size_t              ad_len;
+       size_t              ciphertext_len;
+       size_t              msg_len;
+       size_t              npub_len;
+       size_t              secretkey_len;
 
        if (zend_parse_parameters(ZEND_NUM_ARGS(), "ssss",
                                                          &msg, &msg_len,
@@ -2109,17 +2109,17 @@ PHP_FUNCTION(sodium_crypto_aead_chacha20poly1305_encrypt)
 
 PHP_FUNCTION(sodium_crypto_aead_chacha20poly1305_decrypt)
 {
-       zend_string                *msg;
-       unsigned char      *ad;
-       unsigned char      *ciphertext;
-       unsigned char      *npub;
-       unsigned char      *secretkey;
-       unsigned long long      msg_real_len;
-       size_t                          ad_len;
-       size_t                          ciphertext_len;
-       size_t                          msg_len;
-       size_t                          npub_len;
-       size_t                          secretkey_len;
+       zend_string        *msg;
+       unsigned char      *ad;
+       unsigned char      *ciphertext;
+       unsigned char      *npub;
+       unsigned char      *secretkey;
+       unsigned long long  msg_real_len;
+       size_t              ad_len;
+       size_t              ciphertext_len;
+       size_t              msg_len;
+       size_t              npub_len;
+       size_t              secretkey_len;
 
        if (zend_parse_parameters(ZEND_NUM_ARGS(), "ssss",
                                                          &ciphertext, &ciphertext_len,
@@ -2170,17 +2170,17 @@ PHP_FUNCTION(sodium_crypto_aead_chacha20poly1305_decrypt)
 #ifdef crypto_aead_chacha20poly1305_IETF_NPUBBYTES
 PHP_FUNCTION(sodium_crypto_aead_chacha20poly1305_ietf_encrypt)
 {
-       zend_string                *ciphertext;
-       unsigned char      *ad;
-       unsigned char      *msg;
-       unsigned char      *npub;
-       unsigned char      *secretkey;
-       unsigned long long      ciphertext_real_len;
-       size_t                          ad_len;
-       size_t                          ciphertext_len;
-       size_t                          msg_len;
-       size_t                          npub_len;
-       size_t                          secretkey_len;
+       zend_string        *ciphertext;
+       unsigned char      *ad;
+       unsigned char      *msg;
+       unsigned char      *npub;
+       unsigned char      *secretkey;
+       unsigned long long  ciphertext_real_len;
+       size_t              ad_len;
+       size_t              ciphertext_len;
+       size_t              msg_len;
+       size_t              npub_len;
+       size_t              secretkey_len;
 
        if (zend_parse_parameters(ZEND_NUM_ARGS(), "ssss",
                                                          &msg, &msg_len,
@@ -2235,17 +2235,17 @@ PHP_FUNCTION(sodium_crypto_aead_chacha20poly1305_ietf_encrypt)
 
 PHP_FUNCTION(sodium_crypto_aead_chacha20poly1305_ietf_decrypt)
 {
-       zend_string                *msg;
-       unsigned char      *ad;
-       unsigned char      *ciphertext;
-       unsigned char      *npub;
-       unsigned char      *secretkey;
-       unsigned long long      msg_real_len;
-       size_t                          ad_len;
-       size_t                          ciphertext_len;
-       size_t                          msg_len;
-       size_t                          npub_len;
-       size_t                          secretkey_len;
+       zend_string        *msg;
+       unsigned char      *ad;
+       unsigned char      *ciphertext;
+       unsigned char      *npub;
+       unsigned char      *secretkey;
+       unsigned long long  msg_real_len;
+       size_t              ad_len;
+       size_t              ciphertext_len;
+       size_t              msg_len;
+       size_t              npub_len;
+       size_t              secretkey_len;
 
        if (zend_parse_parameters(ZEND_NUM_ARGS(), "ssss",
                                                          &ciphertext, &ciphertext_len,
@@ -2302,17 +2302,17 @@ PHP_FUNCTION(sodium_crypto_aead_chacha20poly1305_ietf_decrypt)
 #ifdef crypto_aead_xchacha20poly1305_IETF_NPUBBYTES
 PHP_FUNCTION(sodium_crypto_aead_xchacha20poly1305_ietf_encrypt)
 {
-       zend_string                *ciphertext;
-       unsigned char      *ad;
-       unsigned char      *msg;
-       unsigned char      *npub;
-       unsigned char      *secretkey;
-       unsigned long long      ciphertext_real_len;
-       size_t                          ad_len;
-       size_t                          ciphertext_len;
-       size_t                          msg_len;
-       size_t                          npub_len;
-       size_t                          secretkey_len;
+       zend_string        *ciphertext;
+       unsigned char      *ad;
+       unsigned char      *msg;
+       unsigned char      *npub;
+       unsigned char      *secretkey;
+       unsigned long long  ciphertext_real_len;
+       size_t              ad_len;
+       size_t              ciphertext_len;
+       size_t              msg_len;
+       size_t              npub_len;
+       size_t              secretkey_len;
 
        if (zend_parse_parameters(ZEND_NUM_ARGS(), "ssss",
                                                          &msg, &msg_len,
@@ -2367,17 +2367,17 @@ PHP_FUNCTION(sodium_crypto_aead_xchacha20poly1305_ietf_encrypt)
 
 PHP_FUNCTION(sodium_crypto_aead_xchacha20poly1305_ietf_decrypt)
 {
-       zend_string                *msg;
-       unsigned char      *ad;
-       unsigned char      *ciphertext;
-       unsigned char      *npub;
-       unsigned char      *secretkey;
-       unsigned long long      msg_real_len;
-       size_t                          ad_len;
-       size_t                          ciphertext_len;
-       size_t                          msg_len;
-       size_t                          npub_len;
-       size_t                          secretkey_len;
+       zend_string        *msg;
+       unsigned char      *ad;
+       unsigned char      *ciphertext;
+       unsigned char      *npub;
+       unsigned char      *secretkey;
+       unsigned long long  msg_real_len;
+       size_t              ad_len;
+       size_t              ciphertext_len;
+       size_t              msg_len;
+       size_t              npub_len;
+       size_t              secretkey_len;
 
        if (zend_parse_parameters(ZEND_NUM_ARGS(), "ssss",
                                                          &ciphertext, &ciphertext_len,
@@ -2433,10 +2433,10 @@ PHP_FUNCTION(sodium_crypto_aead_xchacha20poly1305_ietf_decrypt)
 
 PHP_FUNCTION(sodium_bin2hex)
 {
-       zend_string       *hex;
+       zend_string   *hex;
        unsigned char *bin;
-       size_t             bin_len;
-       size_t             hex_len;
+       size_t         bin_len;
+       size_t         hex_len;
 
        if (zend_parse_parameters(ZEND_NUM_ARGS(), "s",
                                                          &bin, &bin_len) == FAILURE) {
@@ -2456,13 +2456,13 @@ PHP_FUNCTION(sodium_bin2hex)
 
 PHP_FUNCTION(sodium_hex2bin)
 {
-       zend_string       *bin;
-       char              *hex;
-       char              *ignore = NULL;
-       size_t             bin_real_len;
-       size_t             bin_len;
-       size_t             hex_len;
-       size_t             ignore_len = 0;
+       zend_string   *bin;
+       char          *hex;
+       char          *ignore = NULL;
+       size_t         bin_real_len;
+       size_t         bin_len;
+       size_t         hex_len;
+       size_t         ignore_len = 0;
 
        if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|s",
                                                          &hex, &hex_len,
@@ -2486,11 +2486,11 @@ PHP_FUNCTION(sodium_hex2bin)
 
 PHP_FUNCTION(sodium_crypto_scalarmult)
 {
-       zend_string       *q;
+       zend_string   *q;
        unsigned char *n;
        unsigned char *p;
-       size_t             n_len;
-       size_t             p_len;
+       size_t         n_len;
+       size_t         p_len;
 
        if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss",
                                                          &n, &n_len, &p, &p_len) == FAILURE) {
@@ -2519,7 +2519,7 @@ PHP_FUNCTION(sodium_crypto_kx_seed_keypair)
        unsigned char *sk;
        unsigned char *pk;
        unsigned char *seed;
-       size_t           seed_len;
+       size_t       seed_len;
        zend_string   *keypair;
 
        if (zend_parse_parameters(ZEND_NUM_ARGS(), "s",
@@ -2569,7 +2569,7 @@ PHP_FUNCTION(sodium_crypto_kx_secretkey)
 {
        zend_string   *secretkey;
        unsigned char *keypair;
-       size_t           keypair_len;
+       size_t       keypair_len;
 
        if (zend_parse_parameters(ZEND_NUM_ARGS(), "s",
                                                          &keypair, &keypair_len) == FAILURE) {
@@ -2593,7 +2593,7 @@ PHP_FUNCTION(sodium_crypto_kx_publickey)
 {
        zend_string   *publickey;
        unsigned char *keypair;
-       size_t           keypair_len;
+       size_t       keypair_len;
 
        if (zend_parse_parameters(ZEND_NUM_ARGS(), "s",
                                                          &keypair, &keypair_len) == FAILURE) {
@@ -2623,8 +2623,8 @@ PHP_FUNCTION(sodium_crypto_kx_client_session_keys)
        unsigned char *client_pk;
        unsigned char *server_pk;
        unsigned char  session_keys[2 * crypto_kx_SESSIONKEYBYTES];
-       size_t           keypair_len;
-       size_t           server_pk_len;
+       size_t       keypair_len;
+       size_t       server_pk_len;
 
        if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss",
                                                          &keypair, &keypair_len,
@@ -2672,8 +2672,8 @@ PHP_FUNCTION(sodium_crypto_kx_server_session_keys)
        unsigned char *server_pk;
        unsigned char *client_pk;
        unsigned char  session_keys[2 * crypto_kx_SESSIONKEYBYTES];
-       size_t           keypair_len;
-       size_t           client_pk_len;
+       size_t       keypair_len;
+       size_t       client_pk_len;
 
        if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss",
                                                          &keypair, &keypair_len,
@@ -2715,10 +2715,10 @@ PHP_FUNCTION(sodium_crypto_kx_server_session_keys)
 PHP_FUNCTION(sodium_crypto_auth)
 {
        zend_string *mac;
-       char            *key;
-       char            *msg;
-       size_t           msg_len;
-       size_t           key_len;
+       char        *key;
+       char        *msg;
+       size_t       msg_len;
+       size_t       key_len;
 
        if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss",
                                                          &msg, &msg_len,
@@ -2743,12 +2743,12 @@ PHP_FUNCTION(sodium_crypto_auth)
 
 PHP_FUNCTION(sodium_crypto_auth_verify)
 {
-       char      *mac;
-       char      *key;
-       char      *msg;
-       size_t     mac_len;
-       size_t     msg_len;
-       size_t     key_len;
+       char      *mac;
+       char      *key;
+       char      *msg;
+       size_t     mac_len;
+       size_t     msg_len;
+       size_t     key_len;
 
        if (zend_parse_parameters(ZEND_NUM_ARGS(), "sss",
                                                          &mac, &mac_len,
@@ -2775,8 +2775,8 @@ PHP_FUNCTION(sodium_crypto_auth_verify)
 PHP_FUNCTION(sodium_crypto_sign_ed25519_sk_to_curve25519)
 {
        zend_string *ecdhkey;
-       char            *eddsakey;
-       size_t           eddsakey_len;
+       char        *eddsakey;
+       size_t       eddsakey_len;
 
        if (zend_parse_parameters(ZEND_NUM_ARGS(), "s",
                                                          &eddsakey, &eddsakey_len) == FAILURE) {
@@ -2803,8 +2803,8 @@ PHP_FUNCTION(sodium_crypto_sign_ed25519_sk_to_curve25519)
 PHP_FUNCTION(sodium_crypto_sign_ed25519_pk_to_curve25519)
 {
        zend_string *ecdhkey;
-       char            *eddsakey;
-       size_t           eddsakey_len;
+       char        *eddsakey;
+       size_t       eddsakey_len;
 
        if (zend_parse_parameters(ZEND_NUM_ARGS(), "s",
                                                          &eddsakey, &eddsakey_len) == FAILURE) {
@@ -2832,10 +2832,10 @@ PHP_FUNCTION(sodium_crypto_sign_ed25519_pk_to_curve25519)
        (SODIUM_LIBRARY_VERSION_MAJOR == 7 && SODIUM_LIBRARY_VERSION_MINOR >= 6)
 PHP_FUNCTION(sodium_compare)
 {
-       char      *buf1;
-       char      *buf2;
-       size_t     len1;
-       size_t     len2;
+       char      *buf1;
+       char      *buf2;
+       size_t     len1;
+       size_t     len2;
 
        if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss",
                                                          &buf1, &len1,
@@ -2969,13 +2969,13 @@ PHP_FUNCTION(sodium_crypto_kdf_derive_from_key)
 {
        unsigned char  ctx_padded[crypto_generichash_blake2b_PERSONALBYTES];
        unsigned char  salt[crypto_generichash_blake2b_SALTBYTES];
-       char              *ctx;
-       char              *key;
+       char          *ctx;
+       char          *key;
        zend_string   *subkey;
-       long               subkey_id;
-       long               subkey_len;
-       size_t           ctx_len;
-       size_t           key_len;
+       long           subkey_id;
+       long           subkey_len;
+       size_t         ctx_len;
+       size_t         key_len;
 
        if (zend_parse_parameters(ZEND_NUM_ARGS(), "llss",
                                                          &subkey_len,
@@ -3001,7 +3001,7 @@ PHP_FUNCTION(sodium_crypto_kdf_derive_from_key)
        }
        memcpy(ctx_padded, ctx, crypto_kdf_CONTEXTBYTES);
        memset(ctx_padded + crypto_kdf_CONTEXTBYTES, 0, sizeof ctx_padded - crypto_kdf_CONTEXTBYTES);
-       salt[0] = (unsigned char) (((uint64_t) subkey_id)         );
+       salt[0] = (unsigned char) (((uint64_t) subkey_id)      );
        salt[1] = (unsigned char) (((uint64_t) subkey_id) >>  8);
        salt[2] = (unsigned char) (((uint64_t) subkey_id) >> 16);
        salt[3] = (unsigned char) (((uint64_t) subkey_id) >> 24);