diff --git a/source/pdo_sqlsrv/pdo_dbh.cpp b/source/pdo_sqlsrv/pdo_dbh.cpp
index 878f418d9..be2c00a61 100644
--- a/source/pdo_sqlsrv/pdo_dbh.cpp
+++ b/source/pdo_sqlsrv/pdo_dbh.cpp
@@ -1270,7 +1270,7 @@ char * pdo_sqlsrv_dbh_last_id( _Inout_ pdo_dbh_t *dbh, _In_z_ const char *name,
 
     try {
 
-        char last_insert_id_query[ LAST_INSERT_ID_QUERY_MAX_LEN ] = {'\0'};
+        char last_insert_id_query[LAST_INSERT_ID_QUERY_MAX_LEN] = {'\0'};
         if( name == NULL ) {
             strcpy_s( last_insert_id_query, sizeof( last_insert_id_query ), LAST_INSERT_ID_QUERY );
         }
@@ -1412,13 +1412,13 @@ int pdo_sqlsrv_dbh_quote( _Inout_ pdo_dbh_t* dbh, _In_reads_(unquoted_len) const
     if ( encoding == SQLSRV_ENCODING_BINARY ) {
         // convert from char* to hex digits using os
         std::basic_ostringstream<char> os;
-        for ( size_t index = 0; index < unquoted_len && unquoted[ index ] != '\0'; ++index ) {
+        for ( size_t index = 0; index < unquoted_len && unquoted[index] != '\0'; ++index ) {
             // if unquoted is < 0 or > 255, that means this is a non-ascii character. Translation from non-ascii to binary is not supported.
             // return an empty terminated string for now
-            if (( int )unquoted[ index ] < 0 || ( int )unquoted[ index ] > 255) {
+            if (( int )unquoted[index] < 0 || ( int )unquoted[index] > 255) {
                 *quoted_len = 0;
                 *quoted = reinterpret_cast<char*>( sqlsrv_malloc( *quoted_len, sizeof( char ), 1 ));
-                ( *quoted )[ 0 ] = '\0';
+                ( *quoted )[0] = '\0';
                 return 1;
             }
             // when an int is < 16 and is appended to os, its hex representation which starts
@@ -1427,7 +1427,7 @@ int pdo_sqlsrv_dbh_quote( _Inout_ pdo_dbh_t* dbh, _In_reads_(unquoted_len) const
             if (( int )unquoted[index] < 16 ) {
                 os << '0';
             }
-           os << std::hex << ( int )unquoted[ index ];
+           os << std::hex << ( int )unquoted[index];
         }
         std::basic_string<char> str_hex = os.str();
         // each character is represented by 2 digits of hex
@@ -1439,13 +1439,13 @@ int pdo_sqlsrv_dbh_quote( _Inout_ pdo_dbh_t* dbh, _In_reads_(unquoted_len) const
         *quoted = reinterpret_cast<char*>( sqlsrv_malloc( *quoted_len, sizeof( char ), 1 ));
         unsigned int out_current = 0;
         // insert '0x'
-        ( *quoted )[ out_current++ ] = '0';
-        ( *quoted )[ out_current++ ] = 'x';
-        for ( size_t index = 0; index < unquoted_str_len && unquoted_str[ index ] != '\0'; ++index ) {
-            ( *quoted )[ out_current++ ] = unquoted_str[ index ];
+        ( *quoted )[out_current++] = '0';
+        ( *quoted )[out_current++] = 'x';
+        for ( size_t index = 0; index < unquoted_str_len && unquoted_str[index] != '\0'; ++index ) {
+            ( *quoted )[out_current++] = unquoted_str[index];
         }
         // null terminator
-        ( *quoted )[ out_current ] = '\0';
+        ( *quoted )[out_current] = '\0';
         sqlsrv_free( unquoted_str );
         return 1;
     }
@@ -1457,7 +1457,7 @@ int pdo_sqlsrv_dbh_quote( _Inout_ pdo_dbh_t* dbh, _In_reads_(unquoted_len) const
             quotes_needed = 3;
         }
         for ( size_t index = 0; index < unquoted_len; ++index ) {
-            if ( unquoted[ index ] == '\'' ) {
+            if ( unquoted[index] == '\'' ) {
                 ++quotes_needed;
             }
         }
@@ -1468,24 +1468,24 @@ int pdo_sqlsrv_dbh_quote( _Inout_ pdo_dbh_t* dbh, _In_reads_(unquoted_len) const
 
         // insert N if the encoding is UTF8
         if ( encoding == SQLSRV_ENCODING_UTF8 ) {
-            ( *quoted )[ out_current++ ] = 'N';
+            ( *quoted )[out_current++] = 'N';
         }
         // insert initial quote
-        ( *quoted )[ out_current++ ] = '\'';
+        ( *quoted )[out_current++] = '\'';
 
         for ( size_t index = 0; index < unquoted_len; ++index ) {
-            if ( unquoted[ index ] == '\'' ) {
-                ( *quoted )[ out_current++ ] = '\'';
-                ( *quoted )[ out_current++ ] = '\'';
+            if ( unquoted[index] == '\'' ) {
+                ( *quoted )[out_current++] = '\'';
+                ( *quoted )[out_current++] = '\'';
             }
             else {
-                ( *quoted )[ out_current++ ] = unquoted[ index ];
+                ( *quoted )[out_current++] = unquoted[index];
             }
         }
 
         // trailing quote and null terminator
-        ( *quoted )[ out_current++ ] = '\'';
-        ( *quoted )[ out_current ] = '\0';
+        ( *quoted )[out_current++] = '\'';
+        ( *quoted )[out_current] = '\0';
 
         return 1;
     }
diff --git a/source/pdo_sqlsrv/pdo_init.cpp b/source/pdo_sqlsrv/pdo_init.cpp
index 65e7a0786..f98799b89 100644
--- a/source/pdo_sqlsrv/pdo_init.cpp
+++ b/source/pdo_sqlsrv/pdo_init.cpp
@@ -132,10 +132,10 @@ PHP_MINIT_FUNCTION(pdo_sqlsrv)
     g_pdo_errors_ht = reinterpret_cast<HashTable*>( pemalloc( sizeof( HashTable ), 1 ));
     ::zend_hash_init( g_pdo_errors_ht, 50, NULL, pdo_error_dtor /*pDestructor*/, 1 );
 
-    for( int i = 0; PDO_ERRORS[ i ].error_code != -1; ++i ) {
+    for( int i = 0; PDO_ERRORS[i].error_code != -1; ++i ) {
         
-        void* zr = ::zend_hash_index_update_mem( g_pdo_errors_ht, PDO_ERRORS[ i ].error_code, 
-                                       &( PDO_ERRORS[ i ].sqlsrv_error ), sizeof( PDO_ERRORS[ i ].sqlsrv_error ) );
+        void* zr = ::zend_hash_index_update_mem( g_pdo_errors_ht, PDO_ERRORS[i].error_code, 
+                                       &( PDO_ERRORS[i].sqlsrv_error ), sizeof( PDO_ERRORS[i].sqlsrv_error ) );
         if( zr == NULL ) {
                 
             LOG( SEV_ERROR, "Failed to insert data into PDO errors hashtable." );
diff --git a/source/pdo_sqlsrv/pdo_parser.cpp b/source/pdo_sqlsrv/pdo_parser.cpp
index baafeed73..9710e5d2a 100644
--- a/source/pdo_sqlsrv/pdo_parser.cpp
+++ b/source/pdo_sqlsrv/pdo_parser.cpp
@@ -108,7 +108,7 @@ bool string_parser::discard_white_spaces()
         return false;
     }
 
-    while( this->is_white_space( this->orig_str[ pos ] )) {
+    while( this->is_white_space( this->orig_str[pos] )) {
     
         if( !next() )
             return false;
@@ -148,13 +148,13 @@ void conn_string_parser::validate_key( _In_reads_(key_len) const char *key, _Ino
 {
     int new_len = discard_trailing_white_spaces( key, key_len );
 
-    for( int i=0; PDO_CONN_OPTS[ i ].conn_option_key != SQLSRV_CONN_OPTION_INVALID; ++i )
+    for( int i=0; PDO_CONN_OPTS[i].conn_option_key != SQLSRV_CONN_OPTION_INVALID; ++i )
     {
         // discard the null terminator.
-        if( new_len == ( PDO_CONN_OPTS[ i ].sqlsrv_len - 1 ) && !strncasecmp( key, PDO_CONN_OPTS[ i ].sqlsrv_name, new_len )) {
+        if( new_len == ( PDO_CONN_OPTS[i].sqlsrv_len - 1 ) && !strncasecmp( key, PDO_CONN_OPTS[i].sqlsrv_name, new_len )) {
 
-            this->current_key = PDO_CONN_OPTS[ i ].conn_option_key;
-            this->current_key_name = PDO_CONN_OPTS[ i ].sqlsrv_name;
+            this->current_key = PDO_CONN_OPTS[i].conn_option_key;
+            this->current_key_name = PDO_CONN_OPTS[i].sqlsrv_name;
             return;
         }
     }
@@ -164,7 +164,7 @@ void conn_string_parser::validate_key( _In_reads_(key_len) const char *key, _Ino
     key_name = static_cast<char*>( sqlsrv_malloc( new_len + 1 ));
     memcpy_s( key_name, new_len + 1 ,key, new_len );
 
-    key_name[ new_len ] = '\0';  
+    key_name[new_len] = '\0';  
 
     THROW_PDO_ERROR( this->ctx, PDO_SQLSRV_ERROR_INVALID_DSN_KEY, static_cast<char*>( key_name ) ); 
 }
@@ -232,7 +232,7 @@ void conn_string_parser:: parse_conn_string( TSRMLS_D )
                     start_pos = this->pos;
 
                     // read the key name
-                    while( this->orig_str[ pos ] != '=' ) {
+                    while( this->orig_str[pos] != '=' ) {
                     
                         if( !next() ) {
                             
@@ -240,7 +240,7 @@ void conn_string_parser:: parse_conn_string( TSRMLS_D )
                         }      
                     } 
 
-                    this->validate_key( &( this->orig_str[ start_pos ] ), ( pos - start_pos ) TSRMLS_CC ); 
+                    this->validate_key( &( this->orig_str[start_pos] ), ( pos - start_pos ) TSRMLS_CC ); 
                 
                     state = Value;
 
@@ -249,13 +249,13 @@ void conn_string_parser:: parse_conn_string( TSRMLS_D )
 
                 case Value:
                 {
-                    SQLSRV_ASSERT(( this->orig_str[ pos ] == '=' ), "conn_string_parser:: parse_conn_string: "
+                    SQLSRV_ASSERT(( this->orig_str[pos] == '=' ), "conn_string_parser:: parse_conn_string: "
                                    "Equal was expected" );
 
                     next(); // skip "="
 
                     // if EOS encountered after 0 or more spaces OR semi-colon encountered.
-                    if( !discard_white_spaces() || this->orig_str[ pos ] == ';' ) {
+                    if( !discard_white_spaces() || this->orig_str[pos] == ';' ) {
 
                         add_key_value_pair( NULL, 0 TSRMLS_CC );
 
@@ -265,13 +265,13 @@ void conn_string_parser:: parse_conn_string( TSRMLS_D )
                         }
                         else {
 
-                            // this->orig_str[ pos ] == ';' 
+                            // this->orig_str[pos] == ';' 
                             state = NextKeyValuePair;
                         }
                     }
                     
                     // if LCB
-                    else if( this->orig_str[ pos ] == '{' ) {
+                    else if( this->orig_str[pos] == '{' ) {
                         
                         start_pos = this->pos; // starting character is LCB
                         state = ValueContent1;
@@ -289,7 +289,7 @@ void conn_string_parser:: parse_conn_string( TSRMLS_D )
 
                 case ValueContent1:
                 {
-                    while ( this->orig_str[ pos ] != '}' ) {
+                    while ( this->orig_str[pos] != '}' ) {
                     
                         if ( ! next() ) {
 
@@ -305,7 +305,7 @@ void conn_string_parser:: parse_conn_string( TSRMLS_D )
 
                 case ValueContent2:
                 {
-                    while( this->orig_str[ pos ] != ';' ) {
+                    while( this->orig_str[pos] != ';' ) {
 
                         if( ! next() ) {
                             
@@ -313,13 +313,13 @@ void conn_string_parser:: parse_conn_string( TSRMLS_D )
                         }
                     }
 
-                    if( !this->is_eos() && this->orig_str[ pos ] == ';' ) {
+                    if( !this->is_eos() && this->orig_str[pos] == ';' ) {
                     
                         // semi-colon encountered, so go to next key-value pair
                         state = NextKeyValuePair;
                     }
                     
-                    add_key_value_pair( &( this->orig_str[ start_pos ] ), this->pos - start_pos TSRMLS_CC );
+                    add_key_value_pair( &( this->orig_str[start_pos] ), this->pos - start_pos TSRMLS_CC );
               
                     SQLSRV_ASSERT((( state == NextKeyValuePair ) || ( this->is_eos() )), 
                                   "conn_string_parser::parse_conn_string: Invalid state encountered " );
@@ -334,14 +334,14 @@ void conn_string_parser:: parse_conn_string( TSRMLS_D )
                     if( !next() ) {
 
                         // EOS
-                        add_key_value_pair( &( this->orig_str[ start_pos ] ), this->pos - start_pos TSRMLS_CC );
+                        add_key_value_pair( &( this->orig_str[start_pos] ), this->pos - start_pos TSRMLS_CC );
                         break;
                     }
 
                     SQLSRV_ASSERT( !this->is_eos(), "conn_string_parser::parse_conn_string: Unexpected EOS encountered" );
 
                     // if second RCB encountered than go back to ValueContent1
-                    if( this->orig_str[ pos ] == '}' ) {
+                    if( this->orig_str[pos] == '}' ) {
                         
                         if( !next() ) {
 
@@ -356,20 +356,20 @@ void conn_string_parser:: parse_conn_string( TSRMLS_D )
                     int end_pos = this->pos;
 
                     // discard any trailing white-spaces.
-                    if( this->is_white_space( this->orig_str[ pos ] )) {
+                    if( this->is_white_space( this->orig_str[pos] )) {
                     
                         if( ! this->discard_white_spaces() ) {
                             
                             //EOS
-                            add_key_value_pair( &( this->orig_str[ start_pos ] ), end_pos - start_pos TSRMLS_CC );
+                            add_key_value_pair( &( this->orig_str[start_pos] ), end_pos - start_pos TSRMLS_CC );
                             break;
                         }
                     }
 
                     // if semi-colon than go to next key-value pair
-                    if ( this->orig_str[ pos ] == ';' ) {
+                    if ( this->orig_str[pos] == ';' ) {
                         
-                        add_key_value_pair( &( this->orig_str[ start_pos ] ), end_pos - start_pos TSRMLS_CC );
+                        add_key_value_pair( &( this->orig_str[start_pos] ), end_pos - start_pos TSRMLS_CC );
                         state = NextKeyValuePair;
                         break;
                     }
@@ -380,7 +380,7 @@ void conn_string_parser:: parse_conn_string( TSRMLS_D )
                 }
                 case NextKeyValuePair:
                 {
-                    SQLSRV_ASSERT(( this->orig_str[ pos ] == ';' ), 
+                    SQLSRV_ASSERT(( this->orig_str[pos] == ';' ), 
                                   "conn_string_parser::parse_conn_string: semi-colon was expected." );
 
                     // Call next() to skip the semi-colon.
@@ -390,7 +390,7 @@ void conn_string_parser:: parse_conn_string( TSRMLS_D )
                         break;
                     }
                     
-                    if( this->orig_str[ pos ] == ';' ) {
+                    if( this->orig_str[pos] == ';' ) {
                     
                         // a second semi-colon is error case.
                         THROW_PDO_ERROR( this->ctx, PDO_SQLSRV_ERROR_EXTRA_SEMI_COLON_IN_DSN_STRING, this->pos );      
diff --git a/source/pdo_sqlsrv/pdo_stmt.cpp b/source/pdo_sqlsrv/pdo_stmt.cpp
index 48646a29e..7f16faa70 100644
--- a/source/pdo_sqlsrv/pdo_stmt.cpp
+++ b/source/pdo_sqlsrv/pdo_stmt.cpp
@@ -651,13 +651,13 @@ int pdo_sqlsrv_stmt_fetch( _Inout_ pdo_stmt_t *stmt, _In_ enum pdo_fetch_orienta
                 if (NULL== (bind_data = reinterpret_cast<pdo_bound_param_data*>(zend_hash_index_find_ptr(stmt->bound_columns, i))) &&
                     (NULL == (bind_data = reinterpret_cast<pdo_bound_param_data*>(zend_hash_find_ptr(stmt->bound_columns, stmt->columns[i].name))))) {
 
-                    driver_stmt->bound_column_param_types[ i ] = PDO_PARAM_ZVAL;
+                    driver_stmt->bound_column_param_types[i] = PDO_PARAM_ZVAL;
                     continue;
                 }
 
                 if( bind_data->param_type != PDO_PARAM_ZVAL ) {
 
-                    driver_stmt->bound_column_param_types[ i ] = bind_data->param_type;
+                    driver_stmt->bound_column_param_types[i] = bind_data->param_type;
                     bind_data->param_type = PDO_PARAM_ZVAL;
                 }
             }
@@ -744,10 +744,10 @@ int pdo_sqlsrv_stmt_get_col_data( _Inout_ pdo_stmt_t *stmt, _In_ int colno,
 
         // if a column is bound to a type different than the column type, figure out a way to convert it to the 
         // type they want
-        if( stmt->bound_columns && driver_stmt->bound_column_param_types[ colno ] != PDO_PARAM_ZVAL ) {
+        if( stmt->bound_columns && driver_stmt->bound_column_param_types[colno] != PDO_PARAM_ZVAL ) {
 
             sqlsrv_php_type.typeinfo.type = pdo_type_to_sqlsrv_php_type( driver_stmt, 
-                                                                         driver_stmt->bound_column_param_types[ colno ] 
+                                                                         driver_stmt->bound_column_param_types[colno] 
                                                                          TSRMLS_CC );
 
             pdo_bound_param_data* bind_data = NULL;
@@ -764,8 +764,8 @@ int pdo_sqlsrv_stmt_get_col_data( _Inout_ pdo_stmt_t *stmt, _In_ int colno,
                     throw pdo::PDOException();
                 }
 
-                CHECK_CUSTOM_ERROR( driver_stmt->bound_column_param_types[ colno ] != PDO_PARAM_STR 
-                                    && driver_stmt->bound_column_param_types[ colno ] != PDO_PARAM_LOB, driver_stmt,
+                CHECK_CUSTOM_ERROR( driver_stmt->bound_column_param_types[colno] != PDO_PARAM_STR 
+                                    && driver_stmt->bound_column_param_types[colno] != PDO_PARAM_LOB, driver_stmt,
                                     PDO_SQLSRV_ERROR_COLUMN_TYPE_DOES_NOT_SUPPORT_ENCODING, colno + 1 ) {
 
                         throw pdo::PDOException();
@@ -991,7 +991,7 @@ int pdo_sqlsrv_stmt_get_col_meta( _Inout_ pdo_stmt_t *stmt, _In_ zend_long colno
         add_assoc_long( return_value, "flags", 0 );
 
         // get the name of the data type
-        char field_type_name[ SQL_SERVER_IDENT_SIZE_MAX ] = {'\0'};
+        char field_type_name[SQL_SERVER_IDENT_SIZE_MAX] = {'\0'};
         SQLSMALLINT out_buff_len;
         SQLLEN not_used;
         core::SQLColAttribute( driver_stmt, (SQLUSMALLINT) colno + 1, SQL_DESC_TYPE_NAME, field_type_name,
@@ -1017,13 +1017,13 @@ int pdo_sqlsrv_stmt_get_col_meta( _Inout_ pdo_stmt_t *stmt, _In_ zend_long colno
         }
 
         // add the table name of the field.  All the tests so far show this to always be "", but we adhere to the PDO spec
-        char table_name[ SQL_SERVER_IDENT_SIZE_MAX ] = {'\0'};
+        char table_name[SQL_SERVER_IDENT_SIZE_MAX] = {'\0'};
         SQLLEN field_type_num;
         core::SQLColAttribute( driver_stmt, (SQLUSMALLINT) colno + 1, SQL_DESC_TABLE_NAME, table_name, SQL_SERVER_IDENT_SIZE_MAX,
                                &out_buff_len, &field_type_num TSRMLS_CC );
         add_assoc_string( return_value, "table", table_name );
 
-        if( stmt->columns && stmt->columns[ colno ].param_type == PDO_PARAM_ZVAL ) {
+        if( stmt->columns && stmt->columns[colno].param_type == PDO_PARAM_ZVAL ) {
             add_assoc_long( return_value, "pdo_type", pdo_type );
         }
 
diff --git a/source/pdo_sqlsrv/pdo_util.cpp b/source/pdo_sqlsrv/pdo_util.cpp
index c59ae022f..5b7df6af2 100644
--- a/source/pdo_sqlsrv/pdo_util.cpp
+++ b/source/pdo_sqlsrv/pdo_util.cpp
@@ -37,7 +37,7 @@ const int WARNING_MIN_LENGTH = static_cast<const int>( strlen( WARNING_TEMPLATE
 
 // buffer used to hold a formatted log message prior to actually logging it.
 const int LOG_MSG_SIZE = 2048;
-char log_msg[ LOG_MSG_SIZE ] = {'\0'};
+char log_msg[LOG_MSG_SIZE] = {'\0'};
 
 // internal error that says that FormatMessage failed
 SQLCHAR INTERNAL_FORMAT_ERROR[] = "An internal error occurred.  FormatMessage failed writing an error message.";
diff --git a/source/shared/core_conn.cpp b/source/shared/core_conn.cpp
index f9ac6e532..54ec004f2 100644
--- a/source/shared/core_conn.cpp
+++ b/source/shared/core_conn.cpp
@@ -120,11 +120,11 @@ sqlsrv_conn* core_sqlsrv_connect( _In_ sqlsrv_context& henv_cp, _In_ sqlsrv_cont
         // Instead, MSPHPSQL connection pooling is set according to the ODBCINST.INI file in [ODBC] section.
 
 #ifndef _WIN32
-        char pooling_string[ 128 ] = {'\0'};
+        char pooling_string[128] = {'\0'};
         SQLGetPrivateProfileString( "ODBC", "Pooling", "0", pooling_string, sizeof( pooling_string ), "ODBCINST.INI" );
 
-        if ( pooling_string[ 0 ] == '1' || toupper( pooling_string[ 0 ] ) == 'Y' ||
-            ( toupper( pooling_string[ 0 ] ) == 'O' && toupper( pooling_string[ 1 ] ) == 'N' ))
+        if ( pooling_string[0] == '1' || toupper( pooling_string[0] ) == 'Y' ||
+            ( toupper( pooling_string[0] ) == 'O' && toupper( pooling_string[1] ) == 'N' ))
         {
             henv = &henv_cp;
             is_pooled = true;
@@ -310,7 +310,7 @@ bool core_compare_error_state( _In_ sqlsrv_conn* conn,  _In_ SQLRETURN rc, _In_
     if( SQL_SUCCEEDED( rc ) )
         return false;
 
-    SQLCHAR state[ SQL_SQLSTATE_BUFSIZE ] = {'\0'};
+    SQLCHAR state[SQL_SQLSTATE_BUFSIZE] = {'\0'};
     SQLSMALLINT len;
     SQLRETURN sr = SQLGetDiagField( SQL_HANDLE_DBC, conn->handle(), 1, SQL_DIAG_SQLSTATE, state, SQL_SQLSTATE_BUFSIZE, &len );
 
@@ -695,7 +695,7 @@ bool core_is_conn_opt_value_escaped( _Inout_ const char* value, _Inout_ size_t v
 {
     // if the value is already quoted, then only analyse the part inside the quotes and return it as
     // unquoted since we quote it when adding it to the connection string.
-    if( value_len > 0 && value[0] == '{' && value[ value_len - 1 ] == '}' ) {
+    if( value_len > 0 && value[0] == '{' && value[value_len - 1] == '}' ) {
         ++value;
         value_len -= 2;
     }
@@ -736,11 +736,11 @@ namespace {
 connection_option const* get_connection_option( sqlsrv_conn* conn, _In_ SQLULEN key,
                                                      _In_ const connection_option conn_opts[] TSRMLS_DC )
 {
-    for( int opt_idx = 0; conn_opts[ opt_idx ].conn_option_key != SQLSRV_CONN_OPTION_INVALID; ++opt_idx ) {
+    for( int opt_idx = 0; conn_opts[opt_idx].conn_option_key != SQLSRV_CONN_OPTION_INVALID; ++opt_idx ) {
 
-        if( key == conn_opts[ opt_idx ].conn_option_key ) {
+        if( key == conn_opts[opt_idx].conn_option_key ) {
 
-            return &conn_opts[ opt_idx ];
+            return &conn_opts[opt_idx];
          }
     }
 
@@ -919,15 +919,15 @@ const char* get_processor_arch( void )
 void determine_server_version( _Inout_ sqlsrv_conn* conn TSRMLS_DC )
 {
     SQLSMALLINT info_len;
-    char p[ INFO_BUFFER_LEN ] = {'\0'};
+    char p[INFO_BUFFER_LEN] = {'\0'};
     core::SQLGetInfo( conn, SQL_DBMS_VER, p, INFO_BUFFER_LEN, &info_len TSRMLS_CC );
 
     errno = 0;
-    char version_major_str[ 3 ] = {'\0'};
+    char version_major_str[3] = {'\0'};
     SERVER_VERSION version_major;
     memcpy_s( version_major_str, sizeof( version_major_str ), p, 2 );
 
-    version_major_str[ 2 ] = {'\0'};
+    version_major_str[2] = {'\0'};
     version_major = static_cast<SERVER_VERSION>( atoi( version_major_str ));
 
     CHECK_CUSTOM_ERROR( version_major == 0 && ( errno == ERANGE || errno == EINVAL ), conn, SQLSRV_ERROR_UNKNOWN_SERVER_VERSION )
@@ -1025,7 +1025,7 @@ void common_conn_str_append_func( _In_z_ const char* odbc_name, _In_reads_(val_l
     // be escaped, such as a closing }.
     TSRMLS_C;
 
-    if( val_len > 0 && val[0] == '{' && val[ val_len - 1 ] == '}' ) {
+    if( val_len > 0 && val[0] == '{' && val[val_len - 1] == '}' ) {
         ++val;
         val_len -= 2;
     }
@@ -1151,8 +1151,8 @@ size_t core_str_zval_is_true( _Inout_ zval* value_z )
 
     // strip any whitespace at the end (whitespace is the same value in ASCII and UTF-8)
     size_t last_char = val_len - 1;
-    while( isspace(( unsigned char )value_in[ last_char ] )) {
-        value_in[ last_char ] = '\0';
+    while( isspace(( unsigned char )value_in[last_char] )) {
+        value_in[last_char] = '\0';
         val_len = last_char;
         --last_char;
     }
diff --git a/source/shared/core_results.cpp b/source/shared/core_results.cpp
index ec0105859..76f862e7a 100644
--- a/source/shared/core_results.cpp
+++ b/source/shared/core_results.cpp
@@ -341,8 +341,8 @@ struct row_dtor_closure {
 
 sqlsrv_error* odbc_get_diag_rec( _In_ sqlsrv_stmt* odbc, _In_ SQLSMALLINT record_number )
 {
-    SQLWCHAR wsql_state[ SQL_SQLSTATE_BUFSIZE ] = {L'\0'};
-    SQLWCHAR wnative_message[ SQL_MAX_ERROR_MESSAGE_LENGTH + 1 ] = {L'\0'};
+    SQLWCHAR wsql_state[SQL_SQLSTATE_BUFSIZE] = {L'\0'};
+    SQLWCHAR wnative_message[SQL_MAX_ERROR_MESSAGE_LENGTH + 1] = {L'\0'};
     SQLINTEGER native_code;
     SQLSMALLINT wnative_message_len = 0;
     
@@ -459,29 +459,29 @@ sqlsrv_buffered_result_set::sqlsrv_buffered_result_set( _Inout_ sqlsrv_stmt* stm
     // set up the conversion matrix if this is the first time we're called
     if( conv_matrix.size() == 0 ) {
 
-        conv_matrix[ SQL_C_CHAR ][ SQL_C_CHAR ] = &sqlsrv_buffered_result_set::to_same_string;
-        conv_matrix[ SQL_C_CHAR ][ SQL_C_WCHAR ] = &sqlsrv_buffered_result_set::system_to_wide_string;
-        conv_matrix[ SQL_C_CHAR ][ SQL_C_BINARY ] = &sqlsrv_buffered_result_set::to_binary_string;
-        conv_matrix[ SQL_C_CHAR ][ SQL_C_DOUBLE ] = &sqlsrv_buffered_result_set::string_to_double;
-        conv_matrix[ SQL_C_CHAR ][ SQL_C_LONG ] = &sqlsrv_buffered_result_set::string_to_long;
-        conv_matrix[ SQL_C_WCHAR ][ SQL_C_WCHAR ] = &sqlsrv_buffered_result_set::to_same_string;
-        conv_matrix[ SQL_C_WCHAR ][ SQL_C_BINARY ] = &sqlsrv_buffered_result_set::to_binary_string;
-        conv_matrix[ SQL_C_WCHAR ][ SQL_C_CHAR ] = &sqlsrv_buffered_result_set::wide_to_system_string;
-        conv_matrix[ SQL_C_WCHAR ][ SQL_C_DOUBLE ] = &sqlsrv_buffered_result_set::wstring_to_double;
-        conv_matrix[ SQL_C_WCHAR ][ SQL_C_LONG ] = &sqlsrv_buffered_result_set::wstring_to_long;
-        conv_matrix[ SQL_C_BINARY ][ SQL_C_BINARY ] = &sqlsrv_buffered_result_set::to_same_string;
-        conv_matrix[ SQL_C_BINARY ][ SQL_C_CHAR ] = &sqlsrv_buffered_result_set::binary_to_system_string;
-        conv_matrix[ SQL_C_BINARY ][ SQL_C_WCHAR ] = &sqlsrv_buffered_result_set::binary_to_wide_string;
-        conv_matrix[ SQL_C_LONG ][ SQL_C_DOUBLE ] = &sqlsrv_buffered_result_set::long_to_double;
-        conv_matrix[ SQL_C_LONG ][ SQL_C_LONG ] = &sqlsrv_buffered_result_set::to_long;
-        conv_matrix[ SQL_C_LONG ][ SQL_C_BINARY ] = &sqlsrv_buffered_result_set::to_long;
-        conv_matrix[ SQL_C_LONG ][ SQL_C_CHAR ] = &sqlsrv_buffered_result_set::long_to_system_string;
-        conv_matrix[ SQL_C_LONG ][ SQL_C_WCHAR ] = &sqlsrv_buffered_result_set::long_to_wide_string;
-        conv_matrix[ SQL_C_DOUBLE ][ SQL_C_DOUBLE ] = &sqlsrv_buffered_result_set::to_double;
-        conv_matrix[ SQL_C_DOUBLE ][ SQL_C_BINARY ] = &sqlsrv_buffered_result_set::to_double;
-        conv_matrix[ SQL_C_DOUBLE ][ SQL_C_CHAR ] = &sqlsrv_buffered_result_set::double_to_system_string;
-        conv_matrix[ SQL_C_DOUBLE ][ SQL_C_LONG ] = &sqlsrv_buffered_result_set::double_to_long;
-        conv_matrix[ SQL_C_DOUBLE ][ SQL_C_WCHAR ] = &sqlsrv_buffered_result_set::double_to_wide_string;
+        conv_matrix[SQL_C_CHAR][SQL_C_CHAR] = &sqlsrv_buffered_result_set::to_same_string;
+        conv_matrix[SQL_C_CHAR][SQL_C_WCHAR] = &sqlsrv_buffered_result_set::system_to_wide_string;
+        conv_matrix[SQL_C_CHAR][SQL_C_BINARY] = &sqlsrv_buffered_result_set::to_binary_string;
+        conv_matrix[SQL_C_CHAR][SQL_C_DOUBLE] = &sqlsrv_buffered_result_set::string_to_double;
+        conv_matrix[SQL_C_CHAR][SQL_C_LONG] = &sqlsrv_buffered_result_set::string_to_long;
+        conv_matrix[SQL_C_WCHAR][SQL_C_WCHAR] = &sqlsrv_buffered_result_set::to_same_string;
+        conv_matrix[SQL_C_WCHAR][SQL_C_BINARY] = &sqlsrv_buffered_result_set::to_binary_string;
+        conv_matrix[SQL_C_WCHAR][SQL_C_CHAR] = &sqlsrv_buffered_result_set::wide_to_system_string;
+        conv_matrix[SQL_C_WCHAR][SQL_C_DOUBLE] = &sqlsrv_buffered_result_set::wstring_to_double;
+        conv_matrix[SQL_C_WCHAR][SQL_C_LONG] = &sqlsrv_buffered_result_set::wstring_to_long;
+        conv_matrix[SQL_C_BINARY][SQL_C_BINARY] = &sqlsrv_buffered_result_set::to_same_string;
+        conv_matrix[SQL_C_BINARY][SQL_C_CHAR] = &sqlsrv_buffered_result_set::binary_to_system_string;
+        conv_matrix[SQL_C_BINARY][SQL_C_WCHAR] = &sqlsrv_buffered_result_set::binary_to_wide_string;
+        conv_matrix[SQL_C_LONG][SQL_C_DOUBLE] = &sqlsrv_buffered_result_set::long_to_double;
+        conv_matrix[SQL_C_LONG][SQL_C_LONG] = &sqlsrv_buffered_result_set::to_long;
+        conv_matrix[SQL_C_LONG][SQL_C_BINARY] = &sqlsrv_buffered_result_set::to_long;
+        conv_matrix[SQL_C_LONG][SQL_C_CHAR] = &sqlsrv_buffered_result_set::long_to_system_string;
+        conv_matrix[SQL_C_LONG][SQL_C_WCHAR] = &sqlsrv_buffered_result_set::long_to_wide_string;
+        conv_matrix[SQL_C_DOUBLE][SQL_C_DOUBLE] = &sqlsrv_buffered_result_set::to_double;
+        conv_matrix[SQL_C_DOUBLE][SQL_C_BINARY] = &sqlsrv_buffered_result_set::to_double;
+        conv_matrix[SQL_C_DOUBLE][SQL_C_CHAR] = &sqlsrv_buffered_result_set::double_to_system_string;
+        conv_matrix[SQL_C_DOUBLE][SQL_C_LONG] = &sqlsrv_buffered_result_set::double_to_long;
+        conv_matrix[SQL_C_DOUBLE][SQL_C_WCHAR] = &sqlsrv_buffered_result_set::double_to_wide_string;
     }
 
     SQLSRV_ENCODING encoding = (( stmt->encoding() == SQLSRV_ENCODING_DEFAULT ) ? stmt->conn->encoding() :
@@ -687,7 +687,7 @@ sqlsrv_buffered_result_set::sqlsrv_buffered_result_set( _Inout_ sqlsrv_stmt* stm
                         if( meta[i].length == sqlsrv_buffered_result_set::meta_data::SIZE_UNKNOWN ) {
 
                             out_buffer_length = &out_buffer_temp;
-                            SQLPOINTER* lob_addr = reinterpret_cast<SQLPOINTER*>( &row[ meta[i].offset ] );
+                            SQLPOINTER* lob_addr = reinterpret_cast<SQLPOINTER*>( &row[meta[i].offset] );
                             *lob_addr = read_lob_field( stmt, i, meta[i], mem_used TSRMLS_CC );
                             // a NULL pointer means NULL field
                             if( *lob_addr == NULL ) {
@@ -854,7 +854,7 @@ SQLRETURN sqlsrv_buffered_result_set::get_data( _In_ SQLUSMALLINT field_index, _
         return SQL_ERROR;
     }
 
-    return (( this )->*( conv_matrix[ meta[ field_index ].c_type ][ target_type ] ))( field_index, buffer, buffer_length,
+    return (( this )->*( conv_matrix[meta[field_index].c_type][target_type] ))( field_index, buffer, buffer_length,
                                                                                       out_buffer_length );
 }
 
@@ -965,9 +965,9 @@ SQLRETURN binary_to_string( _Inout_ SQLCHAR* field_data, _Inout_ SQLLEN& read_so
         // to get the number of hex digits we can copy
         SQLLEN to_copy_hex = to_copy / (2 * extra);
         for( SQLLEN i = 0; i < to_copy_hex; ++i ) {
-            *h = hex_chars[ (*b & 0xf0) >> 4 ];
+            *h = hex_chars[(*b & 0xf0) >> 4];
             h++;
-            *h = hex_chars[ (*b++ & 0x0f) ];
+            *h = hex_chars[(*b++ & 0x0f)];
             h++;
         }
         read_so_far += to_copy_hex;
@@ -986,13 +986,13 @@ SQLRETURN sqlsrv_buffered_result_set::binary_to_system_string( _In_ SQLSMALLINT
     SQLCHAR* row = get_row();
     SQLCHAR* field_data = NULL;
 
-    if( meta[ field_index ].length == sqlsrv_buffered_result_set::meta_data::SIZE_UNKNOWN ) {
+    if( meta[field_index].length == sqlsrv_buffered_result_set::meta_data::SIZE_UNKNOWN ) {
 
-        field_data = *reinterpret_cast<SQLCHAR**>( &row[ meta[ field_index ].offset ] ) + sizeof( SQLULEN );
+        field_data = *reinterpret_cast<SQLCHAR**>( &row[meta[field_index].offset] ) + sizeof( SQLULEN );
     }
     else {
 
-        field_data = &row[ meta[ field_index ].offset ] + sizeof( SQLULEN );
+        field_data = &row[meta[field_index].offset] + sizeof( SQLULEN );
     }
 
     return binary_to_string<char>( field_data, read_so_far, buffer, buffer_length, out_buffer_length, last_error );
@@ -1004,13 +1004,13 @@ SQLRETURN sqlsrv_buffered_result_set::binary_to_wide_string( _In_ SQLSMALLINT fi
     SQLCHAR* row = get_row();
     SQLCHAR* field_data = NULL;
 
-    if( meta[ field_index ].length == sqlsrv_buffered_result_set::meta_data::SIZE_UNKNOWN ) {
+    if( meta[field_index].length == sqlsrv_buffered_result_set::meta_data::SIZE_UNKNOWN ) {
 
-        field_data = *reinterpret_cast<SQLCHAR**>( &row[ meta[ field_index ].offset ] ) + sizeof( SQLULEN );
+        field_data = *reinterpret_cast<SQLCHAR**>( &row[meta[field_index].offset] ) + sizeof( SQLULEN );
     }
     else {
 
-        field_data = &row[ meta[ field_index ].offset ] + sizeof( SQLULEN );
+        field_data = &row[meta[field_index].offset] + sizeof( SQLULEN );
     }
 
     return binary_to_string<WCHAR>( field_data, read_so_far, buffer, buffer_length, out_buffer_length, last_error );
@@ -1020,12 +1020,12 @@ SQLRETURN sqlsrv_buffered_result_set::binary_to_wide_string( _In_ SQLSMALLINT fi
 SQLRETURN sqlsrv_buffered_result_set::double_to_long( _In_ SQLSMALLINT field_index, _Inout_updates_bytes_(*out_buffer_length) void* buffer, _In_ SQLLEN buffer_length,
                                                       _Inout_ SQLLEN* out_buffer_length )
 {
-    SQLSRV_ASSERT( meta[ field_index ].c_type == SQL_C_DOUBLE, "Invalid conversion to long" );
+    SQLSRV_ASSERT( meta[field_index].c_type == SQL_C_DOUBLE, "Invalid conversion to long" );
     SQLSRV_ASSERT( buffer_length >= sizeof(SQLLEN), "Buffer length must be able to find a long in "
                    "sqlsrv_buffered_result_set::double_to_long" );
 
     unsigned char* row = get_row();
-    double* double_data = reinterpret_cast<double*>( &row[ meta[ field_index ].offset ] );
+    double* double_data = reinterpret_cast<double*>( &row[meta[field_index].offset] );
     LONG* long_data = reinterpret_cast<LONG*>( buffer );
 
     if( *double_data < double( LONG_MIN ) || *double_data > double( LONG_MAX )) {
@@ -1049,11 +1049,11 @@ SQLRETURN sqlsrv_buffered_result_set::double_to_long( _In_ SQLSMALLINT field_ind
 SQLRETURN sqlsrv_buffered_result_set::double_to_system_string( _In_ SQLSMALLINT field_index, _Out_writes_bytes_to_opt_(buffer_length, *out_buffer_length) void* buffer, _In_ SQLLEN buffer_length,
                                                                _Inout_ SQLLEN* out_buffer_length )
 {
-    SQLSRV_ASSERT( meta[ field_index ].c_type == SQL_C_DOUBLE, "Invalid conversion to system string" );
+    SQLSRV_ASSERT( meta[field_index].c_type == SQL_C_DOUBLE, "Invalid conversion to system string" );
     SQLSRV_ASSERT( buffer_length > 0, "Buffer length must be > 0 in sqlsrv_buffered_result_set::double_to_system_string" );
 
     unsigned char* row = get_row();
-    double* double_data = reinterpret_cast<double*>( &row[ meta[ field_index ].offset ] );
+    double* double_data = reinterpret_cast<double*>( &row[meta[field_index].offset] );
     SQLRETURN r = SQL_SUCCESS;
 #ifdef _WIN32
     r = number_to_string<char>( double_data, buffer, buffer_length, out_buffer_length, last_error );
@@ -1066,11 +1066,11 @@ SQLRETURN sqlsrv_buffered_result_set::double_to_system_string( _In_ SQLSMALLINT
 SQLRETURN sqlsrv_buffered_result_set::double_to_wide_string( _In_ SQLSMALLINT field_index, _Out_writes_bytes_to_opt_(buffer_length, *out_buffer_length) void* buffer, _In_ SQLLEN buffer_length,
                                                              _Inout_ SQLLEN* out_buffer_length )
 {
-    SQLSRV_ASSERT( meta[ field_index ].c_type == SQL_C_DOUBLE, "Invalid conversion to wide string" );
+    SQLSRV_ASSERT( meta[field_index].c_type == SQL_C_DOUBLE, "Invalid conversion to wide string" );
     SQLSRV_ASSERT( buffer_length > 0, "Buffer length must be > 0 in sqlsrv_buffered_result_set::double_to_wide_string" );
 
     unsigned char* row = get_row();
-    double* double_data = reinterpret_cast<double*>( &row[ meta[ field_index ].offset ] );
+    double* double_data = reinterpret_cast<double*>( &row[meta[field_index].offset] );
     SQLRETURN r = SQL_SUCCESS;
 #ifdef _WIN32
     r = number_to_string<WCHAR>( double_data, buffer, buffer_length, out_buffer_length, last_error );
@@ -1083,12 +1083,12 @@ SQLRETURN sqlsrv_buffered_result_set::double_to_wide_string( _In_ SQLSMALLINT fi
 SQLRETURN sqlsrv_buffered_result_set::long_to_double( _In_ SQLSMALLINT field_index, _Out_writes_bytes_(*out_buffer_length) void* buffer, _In_ SQLLEN buffer_length, 
                                                       _Out_ SQLLEN* out_buffer_length )
 {
-    SQLSRV_ASSERT( meta[ field_index ].c_type == SQL_C_LONG, "Invalid conversion to long" );
+    SQLSRV_ASSERT( meta[field_index].c_type == SQL_C_LONG, "Invalid conversion to long" );
     SQLSRV_ASSERT( buffer_length >= sizeof(double), "Buffer length must be able to find a long in sqlsrv_buffered_result_set::double_to_long" );
 
     unsigned char* row = get_row();
     double* double_data = reinterpret_cast<double*>( buffer );
-    LONG* long_data = reinterpret_cast<LONG*>( &row[ meta[ field_index ].offset ] );
+    LONG* long_data = reinterpret_cast<LONG*>( &row[meta[field_index].offset] );
 
     *double_data = static_cast<LONG>( *long_data );
     *out_buffer_length = sizeof( double );
@@ -1098,11 +1098,11 @@ SQLRETURN sqlsrv_buffered_result_set::long_to_double( _In_ SQLSMALLINT field_ind
 SQLRETURN sqlsrv_buffered_result_set::long_to_system_string( _In_ SQLSMALLINT field_index, _Out_writes_bytes_to_opt_(buffer_length, *out_buffer_length) void* buffer, _In_ SQLLEN buffer_length,
                                                              _Inout_ SQLLEN* out_buffer_length )
 {
-    SQLSRV_ASSERT( meta[ field_index ].c_type == SQL_C_LONG, "Invalid conversion to system string" );
+    SQLSRV_ASSERT( meta[field_index].c_type == SQL_C_LONG, "Invalid conversion to system string" );
     SQLSRV_ASSERT( buffer_length > 0, "Buffer length must be > 0 in sqlsrv_buffered_result_set::long_to_system_string" );
 
     unsigned char* row = get_row();
-    LONG* long_data = reinterpret_cast<LONG*>( &row[ meta[ field_index ].offset ] );
+    LONG* long_data = reinterpret_cast<LONG*>( &row[meta[field_index].offset] );
     SQLRETURN r = SQL_SUCCESS;
 #ifdef _WIN32
     r = number_to_string<char>( long_data, buffer, buffer_length, out_buffer_length, last_error );
@@ -1115,11 +1115,11 @@ SQLRETURN sqlsrv_buffered_result_set::long_to_system_string( _In_ SQLSMALLINT fi
 SQLRETURN sqlsrv_buffered_result_set::long_to_wide_string( _In_ SQLSMALLINT field_index, _Out_writes_bytes_to_opt_(buffer_length, *out_buffer_length) void* buffer, _In_ SQLLEN buffer_length,
                                                            _Inout_ SQLLEN* out_buffer_length )
 {
-    SQLSRV_ASSERT( meta[ field_index ].c_type == SQL_C_LONG, "Invalid conversion to wide string" );
+    SQLSRV_ASSERT( meta[field_index].c_type == SQL_C_LONG, "Invalid conversion to wide string" );
     SQLSRV_ASSERT( buffer_length > 0, "Buffer length must be > 0 in sqlsrv_buffered_result_set::long_to_wide_string" );
 
     unsigned char* row = get_row();
-    LONG* long_data = reinterpret_cast<LONG*>( &row[ meta[ field_index ].offset ] );
+    LONG* long_data = reinterpret_cast<LONG*>( &row[meta[field_index].offset] );
     SQLRETURN r = SQL_SUCCESS;
 #ifdef _WIN32
     r = number_to_string<WCHAR>( long_data, buffer, buffer_length, out_buffer_length, last_error );
@@ -1132,49 +1132,49 @@ SQLRETURN sqlsrv_buffered_result_set::long_to_wide_string( _In_ SQLSMALLINT fiel
 SQLRETURN sqlsrv_buffered_result_set::string_to_double( _In_ SQLSMALLINT field_index, _Out_writes_bytes_(*out_buffer_length) void* buffer, _In_ SQLLEN buffer_length,
                                                         _Inout_ SQLLEN* out_buffer_length )
 {
-    SQLSRV_ASSERT( meta[ field_index ].c_type == SQL_C_CHAR, "Invalid conversion from string to double" );
+    SQLSRV_ASSERT( meta[field_index].c_type == SQL_C_CHAR, "Invalid conversion from string to double" );
     SQLSRV_ASSERT( buffer_length >= sizeof( double ), "Buffer needs to be big enough to hold a double" );
 
     unsigned char* row = get_row();
-    char* string_data = reinterpret_cast<char*>( &row[ meta[ field_index ].offset ] ) + sizeof( SQLULEN );
+    char* string_data = reinterpret_cast<char*>( &row[meta[field_index].offset] ) + sizeof( SQLULEN );
 
-    return string_to_number<double>( string_data, meta[ field_index ].length, buffer, buffer_length, out_buffer_length, last_error );
+    return string_to_number<double>( string_data, meta[field_index].length, buffer, buffer_length, out_buffer_length, last_error );
 }
 
 SQLRETURN sqlsrv_buffered_result_set::wstring_to_double( _In_ SQLSMALLINT field_index, _Out_writes_bytes_(*out_buffer_length) void* buffer, _In_ SQLLEN buffer_length,
                                                          _Inout_ SQLLEN* out_buffer_length )
 {
-    SQLSRV_ASSERT( meta[ field_index ].c_type == SQL_C_WCHAR, "Invalid conversion from wide string to double" );
+    SQLSRV_ASSERT( meta[field_index].c_type == SQL_C_WCHAR, "Invalid conversion from wide string to double" );
     SQLSRV_ASSERT( buffer_length >= sizeof( double ), "Buffer needs to be big enough to hold a double" );
 
     unsigned char* row = get_row();
-    SQLWCHAR* string_data = reinterpret_cast<SQLWCHAR*>( &row[ meta[ field_index ].offset ] ) + sizeof( SQLULEN ) / sizeof( SQLWCHAR );
+    SQLWCHAR* string_data = reinterpret_cast<SQLWCHAR*>( &row[meta[field_index].offset] ) + sizeof( SQLULEN ) / sizeof( SQLWCHAR );
 
-    return string_to_number<double>( string_data, meta[ field_index ].length, buffer, buffer_length, out_buffer_length, last_error );
+    return string_to_number<double>( string_data, meta[field_index].length, buffer, buffer_length, out_buffer_length, last_error );
 }
 
 SQLRETURN sqlsrv_buffered_result_set::string_to_long( _In_ SQLSMALLINT field_index, _Out_writes_bytes_(*out_buffer_length) void* buffer, _In_ SQLLEN buffer_length,
                                                       _Inout_ SQLLEN* out_buffer_length )
 {
-    SQLSRV_ASSERT( meta[ field_index ].c_type == SQL_C_CHAR, "Invalid conversion from string to long" );
+    SQLSRV_ASSERT( meta[field_index].c_type == SQL_C_CHAR, "Invalid conversion from string to long" );
     SQLSRV_ASSERT( buffer_length >= sizeof( LONG ), "Buffer needs to be big enough to hold a long" );
 
     unsigned char* row = get_row();
-    char* string_data = reinterpret_cast<char*>( &row[ meta[ field_index ].offset ] ) + sizeof( SQLULEN );
+    char* string_data = reinterpret_cast<char*>( &row[meta[field_index].offset] ) + sizeof( SQLULEN );
 
-    return string_to_number<LONG>( string_data, meta[ field_index ].length, buffer, buffer_length, out_buffer_length, last_error );
+    return string_to_number<LONG>( string_data, meta[field_index].length, buffer, buffer_length, out_buffer_length, last_error );
 }
 
 SQLRETURN sqlsrv_buffered_result_set::wstring_to_long( _In_ SQLSMALLINT field_index, _Out_writes_bytes_(*out_buffer_length) void* buffer, _In_ SQLLEN buffer_length,
                                                       _Inout_ SQLLEN* out_buffer_length )
 {
-    SQLSRV_ASSERT( meta[ field_index ].c_type == SQL_C_WCHAR, "Invalid conversion from wide string to long" );
+    SQLSRV_ASSERT( meta[field_index].c_type == SQL_C_WCHAR, "Invalid conversion from wide string to long" );
     SQLSRV_ASSERT( buffer_length >= sizeof( LONG ), "Buffer needs to be big enough to hold a long" );
 
     unsigned char* row = get_row();
-    SQLWCHAR* string_data = reinterpret_cast<SQLWCHAR*>( &row[ meta[ field_index ].offset ] ) + sizeof( SQLULEN ) / sizeof( SQLWCHAR );
+    SQLWCHAR* string_data = reinterpret_cast<SQLWCHAR*>( &row[meta[field_index].offset] ) + sizeof( SQLULEN ) / sizeof( SQLWCHAR );
 
-    return string_to_number<LONG>( string_data, meta[ field_index ].length, buffer, buffer_length, out_buffer_length, last_error );
+    return string_to_number<LONG>( string_data, meta[field_index].length, buffer, buffer_length, out_buffer_length, last_error );
 }
 
 SQLRETURN sqlsrv_buffered_result_set::system_to_wide_string( _In_ SQLSMALLINT field_index, _Out_writes_z_(*out_buffer_length) void* buffer, _In_ SQLLEN buffer_length, 
@@ -1189,15 +1189,15 @@ SQLRETURN sqlsrv_buffered_result_set::system_to_wide_string( _In_ SQLSMALLINT fi
     SQLCHAR* field_data = NULL;
     SQLULEN field_len = 0;
 
-    if( meta[ field_index ].length == sqlsrv_buffered_result_set::meta_data::SIZE_UNKNOWN ) {
+    if( meta[field_index].length == sqlsrv_buffered_result_set::meta_data::SIZE_UNKNOWN ) {
 
-        field_len = **reinterpret_cast<SQLLEN**>( &row[ meta[ field_index ].offset ] );
-        field_data = *reinterpret_cast<SQLCHAR**>( &row[ meta[ field_index ].offset ] ) + sizeof( SQLULEN ) + read_so_far;
+        field_len = **reinterpret_cast<SQLLEN**>( &row[meta[field_index].offset] );
+        field_data = *reinterpret_cast<SQLCHAR**>( &row[meta[field_index].offset] ) + sizeof( SQLULEN ) + read_so_far;
     }
     else {
 
-        field_len = *reinterpret_cast<SQLLEN*>( &row[ meta[ field_index ].offset ] );
-        field_data = &row[ meta[ field_index ].offset ] + sizeof( SQLULEN ) + read_so_far;
+        field_len = *reinterpret_cast<SQLLEN*>( &row[meta[field_index].offset] );
+        field_data = &row[meta[field_index].offset] + sizeof( SQLULEN ) + read_so_far;
     }
 
     // all fields will be treated as ODBC returns varchar(max) fields:
@@ -1264,7 +1264,7 @@ SQLRETURN sqlsrv_buffered_result_set::system_to_wide_string( _In_ SQLSMALLINT fi
                 return SQL_ERROR;
             }
 
-            ((WCHAR*)buffer)[ to_copy ] = L'\0';
+            ((WCHAR*)buffer)[to_copy] = L'\0';
             read_so_far += to_copy;
             break;
 
@@ -1288,7 +1288,7 @@ SQLRETURN sqlsrv_buffered_result_set::to_same_string( _In_ SQLSMALLINT field_ind
     // Set the amount of space necessary for null characters at the end of the data.
     SQLSMALLINT extra = 0;
 
-    switch( meta[ field_index ].c_type ) {
+    switch( meta[field_index].c_type ) {
         case SQL_C_WCHAR:
             extra = sizeof( SQLWCHAR );
             break;
@@ -1305,13 +1305,13 @@ SQLRETURN sqlsrv_buffered_result_set::to_same_string( _In_ SQLSMALLINT field_ind
 
     SQLCHAR* field_data = NULL;
 
-    if( meta[ field_index ].length == sqlsrv_buffered_result_set::meta_data::SIZE_UNKNOWN ) {
+    if( meta[field_index].length == sqlsrv_buffered_result_set::meta_data::SIZE_UNKNOWN ) {
 
-        field_data = *reinterpret_cast<SQLCHAR**>( &row[ meta[ field_index ].offset ] ) + sizeof( SQLULEN );
+        field_data = *reinterpret_cast<SQLCHAR**>( &row[meta[field_index].offset] ) + sizeof( SQLULEN );
     }
     else {
 
-        field_data = &row[ meta[ field_index ].offset ] + sizeof( SQLULEN );
+        field_data = &row[meta[field_index].offset] + sizeof( SQLULEN );
     }
 
     // all fields will be treated as ODBC returns varchar(max) fields:
@@ -1366,15 +1366,15 @@ SQLRETURN sqlsrv_buffered_result_set::wide_to_system_string( _In_ SQLSMALLINT fi
 
     if( read_so_far == 0 ) {
 
-        if( meta[ field_index ].length == sqlsrv_buffered_result_set::meta_data::SIZE_UNKNOWN ) {
+        if( meta[field_index].length == sqlsrv_buffered_result_set::meta_data::SIZE_UNKNOWN ) {
 
-            field_len = **reinterpret_cast<SQLLEN**>( &row[ meta[ field_index ].offset ] );
-            field_data = *reinterpret_cast<SQLCHAR**>( &row[ meta[ field_index ].offset ] ) + sizeof( SQLULEN ) + read_so_far;
+            field_len = **reinterpret_cast<SQLLEN**>( &row[meta[field_index].offset] );
+            field_data = *reinterpret_cast<SQLCHAR**>( &row[meta[field_index].offset] ) + sizeof( SQLULEN ) + read_so_far;
         }
         else {
 
-            field_len = *reinterpret_cast<SQLLEN*>( &row[ meta[ field_index ].offset ] );
-            field_data = &row[ meta[ field_index ].offset ] + sizeof( SQLULEN ) + read_so_far;
+            field_len = *reinterpret_cast<SQLLEN*>( &row[meta[field_index].offset] );
+            field_data = &row[meta[field_index].offset] + sizeof( SQLULEN ) + read_so_far;
         }
 
         if ( field_len == 0 ) { // empty string, no need for conversion
@@ -1434,7 +1434,7 @@ SQLRETURN sqlsrv_buffered_result_set::wide_to_system_string( _In_ SQLSMALLINT fi
     }
     SQLSRV_ASSERT( to_copy >= 0, "Invalid field copy length" );
     OACR_WARNING_SUPPRESS( BUFFER_UNDERFLOW, "Buffer length verified above" );
-    ((SQLCHAR*) buffer)[ to_copy ] = '\0';
+    ((SQLCHAR*) buffer)[to_copy] = '\0';
     read_so_far += to_copy;
 
     return r;
@@ -1450,11 +1450,11 @@ SQLRETURN sqlsrv_buffered_result_set::to_binary_string( _In_ SQLSMALLINT field_i
 SQLRETURN sqlsrv_buffered_result_set::to_long( _In_ SQLSMALLINT field_index, _Out_writes_bytes_to_opt_(buffer_length, *out_buffer_length) void* buffer, _In_ SQLLEN buffer_length,
                                                 _Out_ SQLLEN* out_buffer_length )
 {
-    SQLSRV_ASSERT( meta[ field_index ].c_type == SQL_C_LONG, "Invalid conversion to long" );
+    SQLSRV_ASSERT( meta[field_index].c_type == SQL_C_LONG, "Invalid conversion to long" );
     SQLSRV_ASSERT( buffer_length >= sizeof( LONG ), "Buffer too small for SQL_C_LONG" );    // technically should ignore this
 
     unsigned char* row = get_row();
-    LONG* long_data = reinterpret_cast<LONG*>( &row[ meta[ field_index ].offset ] );
+    LONG* long_data = reinterpret_cast<LONG*>( &row[meta[field_index].offset] );
     memcpy_s( buffer, buffer_length, long_data, sizeof( LONG ));
     *out_buffer_length = sizeof( LONG );
 
@@ -1464,11 +1464,11 @@ SQLRETURN sqlsrv_buffered_result_set::to_long( _In_ SQLSMALLINT field_index, _Ou
 SQLRETURN sqlsrv_buffered_result_set::to_double( _In_ SQLSMALLINT field_index, _Out_writes_bytes_to_opt_(buffer_length, *out_buffer_length) void* buffer, _In_ SQLLEN buffer_length,
                                                   _Out_ SQLLEN* out_buffer_length )
 {
-    SQLSRV_ASSERT( meta[ field_index ].c_type == SQL_C_DOUBLE, "Invalid conversion to double" );
+    SQLSRV_ASSERT( meta[field_index].c_type == SQL_C_DOUBLE, "Invalid conversion to double" );
     SQLSRV_ASSERT( buffer_length >= sizeof( double ), "Buffer too small for SQL_C_DOUBLE" );  // technically should ignore this
 
     unsigned char* row = get_row();
-    double* double_data = reinterpret_cast<double*>( &row[ meta[ field_index ].offset ] );
+    double* double_data = reinterpret_cast<double*>( &row[meta[field_index].offset] );
     memcpy_s( buffer, buffer_length, double_data, sizeof( double ));
     *out_buffer_length = sizeof( double );
 
@@ -1489,7 +1489,7 @@ void cache_row_dtor( _In_ zval* data )
 
         if( result_set->col_meta_data(i).length == sqlsrv_buffered_result_set::meta_data::SIZE_UNKNOWN ) {
 
-            void* out_of_row_data = *reinterpret_cast<void**>( &row[ result_set->col_meta_data(i).offset ] );
+            void* out_of_row_data = *reinterpret_cast<void**>( &row[result_set->col_meta_data(i).offset] );
             sqlsrv_free( out_of_row_data );
         }
     }
@@ -1525,7 +1525,7 @@ SQLPOINTER read_lob_field( _Inout_ sqlsrv_stmt* stmt, _In_ SQLUSMALLINT field_in
     sqlsrv_malloc_auto_ptr<char> buffer;
     buffer = static_cast<char*>( sqlsrv_malloc( INITIAL_LOB_FIELD_LEN + extra + sizeof( SQLULEN )));
     SQLRETURN r = SQL_SUCCESS;
-    SQLCHAR state[ SQL_SQLSTATE_BUFSIZE ] = {'\0'};
+    SQLCHAR state[SQL_SQLSTATE_BUFSIZE] = {'\0'};
     SQLLEN last_field_len = 0;
     bool full_length_returned = false;
 
diff --git a/source/shared/core_sqlsrv.h b/source/shared/core_sqlsrv.h
index d75d8c689..0e2a47db4 100644
--- a/source/shared/core_sqlsrv.h
+++ b/source/shared/core_sqlsrv.h
@@ -70,7 +70,7 @@ typedef struct _OSVERSIONINFOA {
     DWORD dwMinorVersion;
     DWORD dwBuildNumber;
     DWORD dwPlatformId;
-    CHAR   szCSDVersion[ 128 ];     // Maintenance string for PSS usage
+    CHAR   szCSDVersion[128];     // Maintenance string for PSS usage
 } OSVERSIONINFOA, *POSVERSIONINFOA, *LPOSVERSIONINFOA;
 typedef OSVERSIONINFOA OSVERSIONINFO;
 #endif // !_WIN32
@@ -546,21 +546,21 @@ class sqlsrv_auto_ptr {
     // an array of elements, so this operator allows us to treat the memory as such.
     T& operator[]( _In_ int index ) const
     {
-        return _ptr[ index ];
+        return _ptr[index];
     }
 
     // there are a number of places where we allocate a block intended to be accessed as
     // an array of elements, so this operator allows us to treat the memory as such.
     T& operator[]( _In_ unsigned int index ) const
     {
-        return _ptr[ index ];
+        return _ptr[index];
     }
 
     // there are a number of places where we allocate a block intended to be accessed as
     // an array of elements, so this operator allows us to treat the memory as such.
     T& operator[]( _In_ long index ) const
     {
-        return _ptr[ index ];
+        return _ptr[index];
     }
 
 	
@@ -577,7 +577,7 @@ class sqlsrv_auto_ptr {
     // an array of elements, so this operator allows us to treat the memory as such.
     T& operator[]( _In_ unsigned short index ) const
     {
-        return _ptr[ index ];
+        return _ptr[index];
     }
 
     // access elements of a structure through the auto ptr
@@ -1889,7 +1889,7 @@ namespace core {
         // and return a more helpful message prepended to the ODBC errors if that error occurs
         if( !SQL_SUCCEEDED( r )) {
 
-            SQLCHAR err_msg[ SQL_MAX_ERROR_MESSAGE_LENGTH + 1 ] = {'\0'};
+            SQLCHAR err_msg[SQL_MAX_ERROR_MESSAGE_LENGTH + 1] = {'\0'};
             SQLSMALLINT len = 0;
             
             SQLRETURN rtemp = ::SQLGetDiagField( stmt->handle_type(), stmt->handle(), 1, SQL_DIAG_MESSAGE_TEXT, 
diff --git a/source/shared/core_stmt.cpp b/source/shared/core_stmt.cpp
index ef07469bb..31f2da45e 100644
--- a/source/shared/core_stmt.cpp
+++ b/source/shared/core_stmt.cpp
@@ -364,7 +364,7 @@ void core_sqlsrv_bind_param( _Inout_ sqlsrv_stmt* stmt, _In_ SQLUSMALLINT param_
     if( stmt->param_ind_ptrs.size() < static_cast<size_t>( param_num + 1 )){
         stmt->param_ind_ptrs.resize( param_num + 1, SQL_NULL_DATA );
     }
-    SQLLEN& ind_ptr = stmt->param_ind_ptrs[ param_num ];
+    SQLLEN& ind_ptr = stmt->param_ind_ptrs[param_num];
 
     zval* param_ref = param_z;
     if( Z_ISREF_P( param_z )){
@@ -964,7 +964,7 @@ void core_sqlsrv_get_field( _Inout_ sqlsrv_stmt* stmt, _In_ SQLUSMALLINT field_i
 				memcpy_s( field_value, ( cached->len * sizeof( char )), cached->value, cached->len );
 				if( cached->type.typeinfo.type == SQLSRV_PHPTYPE_STRING) {
 					// prevent the 'string not null terminated' warning
-					reinterpret_cast<char*>( field_value )[ cached->len ] = '\0';
+					reinterpret_cast<char*>( field_value )[cached->len] = '\0';
 				}
 				*field_len = cached->len;
 				if( sqlsrv_php_type_out) { *sqlsrv_php_type_out = static_cast<SQLSRV_PHPTYPE>(cached->type.typeinfo.type); }
@@ -1236,7 +1236,7 @@ void core_sqlsrv_set_query_timeout( _Inout_ sqlsrv_stmt* stmt, _In_ long timeout
         int lock_timeout = (( timeout == 0 ) ? -1 : timeout * 1000 /*convert to milliseconds*/ );
 
         // set the LOCK_TIMEOUT on the server.
-        char lock_timeout_sql[ 32 ] = {'\0'};
+        char lock_timeout_sql[32] = {'\0'};
 
         int written = snprintf( lock_timeout_sql, sizeof( lock_timeout_sql ), "SET LOCK_TIMEOUT %d", lock_timeout );
         SQLSRV_ASSERT( (written != -1 && written != sizeof( lock_timeout_sql )),
@@ -1304,7 +1304,7 @@ bool core_sqlsrv_send_stream_packet( _Inout_ sqlsrv_stmt* stmt TSRMLS_DC )
     }
     // read the data from the stream, send it via SQLPutData and track how much we've sent.
     else {
-        char buffer[ PHP_STREAM_BUFFER_SIZE + 1 ] = {'\0'};
+        char buffer[PHP_STREAM_BUFFER_SIZE + 1] = {'\0'};
 		std::size_t buffer_size = sizeof( buffer ) - 3;   // -3 to preserve enough space for a cut off UTF-8 character
         std::size_t read = php_stream_read( param_stream, buffer, buffer_size );
 
@@ -1325,7 +1325,7 @@ bool core_sqlsrv_send_stream_packet( _Inout_ sqlsrv_stmt* stmt TSRMLS_DC )
 
                 // the size of wbuffer is set for the worst case of UTF-8 to UTF-16 conversion, which is a
                 // expansion of 2x the UTF-8 size.
-                SQLWCHAR wbuffer[ PHP_STREAM_BUFFER_SIZE + 1 ] = {L'\0'};
+                SQLWCHAR wbuffer[PHP_STREAM_BUFFER_SIZE + 1] = {L'\0'};
                 int wbuffer_size = static_cast<int>( sizeof( wbuffer ) / sizeof( SQLWCHAR ));
 				DWORD last_error_code = ERROR_SUCCESS;
 				// buffer_size is the # of wchars.  Since it set to stmt->param_buffer_size / 2, this is accurate
@@ -1631,7 +1631,7 @@ void core_get_field_common( _Inout_ sqlsrv_stmt* stmt, _In_ SQLUSMALLINT field_i
         // convert it to a DateTime object and return the created object
         case SQLSRV_PHPTYPE_DATETIME:
         {
-            char field_value_temp[ MAX_DATETIME_STRING_LEN ] = {'\0'};
+            char field_value_temp[MAX_DATETIME_STRING_LEN] = {'\0'};
             zval params[1];
             zval field_value_temp_z;
             zval function_z;
@@ -1823,7 +1823,7 @@ bool convert_input_param_to_utf16( _In_ zval* input_param_z, _Inout_ zval* conve
     }
 
     // null terminate the string, set the size within the zval, and return success
-    wbuffer[ wchar_size ] = L'\0';
+    wbuffer[wchar_size] = L'\0';
     core::sqlsrv_zval_stringl( converted_param_z, reinterpret_cast<char*>( wbuffer.get() ), wchar_size * sizeof( SQLWCHAR ) );
     sqlsrv_free(wbuffer);
     wbuffer.transferred();
@@ -2075,7 +2075,7 @@ void finalize_output_parameters( _Inout_ sqlsrv_stmt* stmt TSRMLS_DC )
         {
             // adjust the length of the string to the value returned by SQLBindParameter in the ind_ptr parameter
             char* str = Z_STRVAL_P( value_z );
-            SQLLEN str_len = stmt->param_ind_ptrs[ output_param->param_num ];
+            SQLLEN str_len = stmt->param_ind_ptrs[output_param->param_num];
             if( str_len == 0 ) {
                 core::sqlsrv_zval_stringl( value_z, "", 0 );
                 continue;
@@ -2127,7 +2127,7 @@ void finalize_output_parameters( _Inout_ sqlsrv_stmt* stmt TSRMLS_DC )
                 // ODBC doesn't null terminate binary encodings, but PHP complains if a string isn't null terminated
                 // so we do that here if the length of the returned data is less than the original allocation.  The
                 // original allocation null terminates the buffer already.
-                str[ str_len ] = '\0';
+                str[str_len] = '\0';
                 core::sqlsrv_zval_stringl(value_z, str, str_len);
             }
             else {
@@ -2137,7 +2137,7 @@ void finalize_output_parameters( _Inout_ sqlsrv_stmt* stmt TSRMLS_DC )
         break;
         case IS_LONG:
             // for a long or a float, simply check if NULL was returned and set the parameter to a PHP null if so
-            if( stmt->param_ind_ptrs[ output_param->param_num ] == SQL_NULL_DATA ) {
+            if( stmt->param_ind_ptrs[output_param->param_num] == SQL_NULL_DATA ) {
                 ZVAL_NULL( value_z );
             }
             else if( output_param->is_bool ) {
@@ -2442,11 +2442,11 @@ field_value = field_value_temp;
 
 stmt_option const* get_stmt_option( sqlsrv_conn const* conn, _In_ zend_ulong key, _In_ const stmt_option stmt_opts[] TSRMLS_DC )
 {
-    for( int i = 0; stmt_opts[ i ].key != SQLSRV_STMT_OPTION_INVALID; ++i ) {
+    for( int i = 0; stmt_opts[i].key != SQLSRV_STMT_OPTION_INVALID; ++i ) {
 
         // if we find the key we're looking for, return it
-        if( key == stmt_opts[ i ].key ) {
-            return &stmt_opts[ i ];
+        if( key == stmt_opts[i].key ) {
+            return &stmt_opts[i];
         }
     }
 
@@ -2580,8 +2580,8 @@ void resize_output_buffer_if_necessary( _Inout_ sqlsrv_stmt* stmt, _Inout_ zval*
     // The StrLen_Ind_Ptr parameter of SQLBindParameter should contain the length of the data to send, which
     // may be less than the size of the buffer since the output may be more than the input.  If it is greater,
     // than the error 22001 is returned by ODBC.
-    if( stmt->param_ind_ptrs[ paramno ] > buffer_len - (elem_size - buffer_null_extra)) {
-        stmt->param_ind_ptrs[ paramno ] = buffer_len - (elem_size - buffer_null_extra);
+    if( stmt->param_ind_ptrs[paramno] > buffer_len - (elem_size - buffer_null_extra)) {
+        stmt->param_ind_ptrs[paramno] = buffer_len - (elem_size - buffer_null_extra);
     }
 }
 
diff --git a/source/shared/core_util.cpp b/source/shared/core_util.cpp
index 02259261c..c6eca297a 100644
--- a/source/shared/core_util.cpp
+++ b/source/shared/core_util.cpp
@@ -28,7 +28,7 @@ log_callback g_driver_log;
 // internal error that says that FormatMessage failed
 SQLCHAR INTERNAL_FORMAT_ERROR[] = "An internal error occurred.  FormatMessage failed writing an error message.";
 // buffer used to hold a formatted log message prior to actually logging it.
-char last_err_msg[ 2048 ] = {'\0'};  // 2k to hold the error messages
+char last_err_msg[2048] = {'\0'};  // 2k to hold the error messages
 
 // routine used by utf16_string_from_mbcs_string
 unsigned int convert_string_from_default_encoding( _In_ unsigned int php_encoding, _In_reads_bytes_(mbcs_len) char const* mbcs_in_string,
@@ -219,8 +219,8 @@ bool core_sqlsrv_get_odbc_error( _Inout_ sqlsrv_context& ctx, _In_ int record_nu
 
     SQLRETURN r = SQL_SUCCESS;
     SQLSMALLINT wmessage_len = 0;
-    SQLWCHAR wsqlstate[ SQL_SQLSTATE_BUFSIZE ] = {L'\0'};
-    SQLWCHAR wnative_message[ SQL_MAX_ERROR_MESSAGE_LENGTH + 1 ] = {L'\0'};
+    SQLWCHAR wsqlstate[SQL_SQLSTATE_BUFSIZE] = {L'\0'};
+    SQLWCHAR wnative_message[SQL_MAX_ERROR_MESSAGE_LENGTH + 1] = {L'\0'};
     SQLSRV_ENCODING enc = ctx.encoding();
 
     switch( h_type ) {
@@ -393,7 +393,7 @@ unsigned int convert_string_from_default_encoding( _In_ unsigned int php_encodin
     if( required_len == 0 ) {
         return 0;
     }
-    utf16_out_string[ required_len ] = '\0';
+    utf16_out_string[required_len] = '\0';
 
     return required_len;
 }
diff --git a/source/shared/globalization.h b/source/shared/globalization.h
index e2830e175..0d77fff9d 100644
--- a/source/shared/globalization.h
+++ b/source/shared/globalization.h
@@ -362,7 +362,7 @@ class EncodingConverter
         {
             // Use fixed size buffer iteratively to determine final required length
             const size_t CCH_FIXED_SIZE = 256;
-            char fixed_buf[ CCH_FIXED_SIZE*sizeof(DestType) ] = {'\0'};
+            char fixed_buf[CCH_FIXED_SIZE*sizeof(DestType)] = {'\0'};
             iconv_buffer<DestType> dest(
                 &fixed_buf[0],
                 CCH_FIXED_SIZE );
diff --git a/source/sqlsrv/conn.cpp b/source/sqlsrv/conn.cpp
index 7bf805089..30bc65139 100644
--- a/source/sqlsrv/conn.cpp
+++ b/source/sqlsrv/conn.cpp
@@ -1234,12 +1234,12 @@ void sqlsrv_conn_close_stmts( _Inout_ ss_sqlsrv_conn* conn TSRMLS_DC )
 
 int get_conn_option_key( _Inout_ sqlsrv_context& ctx, _In_ zend_string* key, _In_ size_t key_len, _Inout_ zval const* value_z TSRMLS_DC )    
 {
-    for( int i=0; SS_CONN_OPTS[ i ].conn_option_key != SQLSRV_CONN_OPTION_INVALID; ++i )
+    for( int i=0; SS_CONN_OPTS[i].conn_option_key != SQLSRV_CONN_OPTION_INVALID; ++i )
     {
-        if( key_len == SS_CONN_OPTS[ i ].sqlsrv_len && !stricmp( ZSTR_VAL( key ), SS_CONN_OPTS[ i ].sqlsrv_name )) {
+        if( key_len == SS_CONN_OPTS[i].sqlsrv_len && !stricmp( ZSTR_VAL( key ), SS_CONN_OPTS[i].sqlsrv_name )) {
             
 
-             switch( SS_CONN_OPTS[ i ].value_type ) {
+             switch( SS_CONN_OPTS[i].value_type ) {
 
                 case CONN_ATTR_BOOL:                        
                     // bool attributes can be either strings to be appended to the connection string
@@ -1250,7 +1250,7 @@ int get_conn_option_key( _Inout_ sqlsrv_context& ctx, _In_ zend_string* key, _In
                 case CONN_ATTR_INT:
                 {
                     CHECK_CUSTOM_ERROR( (Z_TYPE_P( value_z ) != IS_LONG ), ctx, SQLSRV_ERROR_INVALID_OPTION_TYPE_INT,
-                                        SS_CONN_OPTS[ i ].sqlsrv_name ) 
+                                        SS_CONN_OPTS[i].sqlsrv_name ) 
                     {
                         throw ss::SSException();
                     }
@@ -1259,7 +1259,7 @@ int get_conn_option_key( _Inout_ sqlsrv_context& ctx, _In_ zend_string* key, _In
                 case CONN_ATTR_STRING:
                 {
                     CHECK_CUSTOM_ERROR( Z_TYPE_P( value_z ) != IS_STRING, ctx, SQLSRV_ERROR_INVALID_OPTION_TYPE_STRING, 
-                                        SS_CONN_OPTS[ i ].sqlsrv_name ) {
+                                        SS_CONN_OPTS[i].sqlsrv_name ) {
 
                         throw ss::SSException();
                     }
@@ -1268,7 +1268,7 @@ int get_conn_option_key( _Inout_ sqlsrv_context& ctx, _In_ zend_string* key, _In
                     size_t value_len = Z_STRLEN_P( value_z );
                     bool escaped = core_is_conn_opt_value_escaped( value, value_len );
 
-                    CHECK_CUSTOM_ERROR( !escaped, ctx, SS_SQLSRV_ERROR_CONNECT_BRACES_NOT_ESCAPED, SS_CONN_OPTS[ i ].sqlsrv_name ) {
+                    CHECK_CUSTOM_ERROR( !escaped, ctx, SS_SQLSRV_ERROR_CONNECT_BRACES_NOT_ESCAPED, SS_CONN_OPTS[i].sqlsrv_name ) {
 
                         throw ss::SSException();
                     }
@@ -1278,7 +1278,7 @@ int get_conn_option_key( _Inout_ sqlsrv_context& ctx, _In_ zend_string* key, _In
                         valid = core_is_authentication_option_valid( value, value_len );
                     }
 
-                    CHECK_CUSTOM_ERROR( !valid, ctx, SS_SQLSRV_ERROR_INVALID_AUTHENTICATION_OPTION, SS_CONN_OPTS[ i ].sqlsrv_name ) {
+                    CHECK_CUSTOM_ERROR( !valid, ctx, SS_SQLSRV_ERROR_INVALID_AUTHENTICATION_OPTION, SS_CONN_OPTS[i].sqlsrv_name ) {
 
                         throw ss::SSException();
                     }
@@ -1287,7 +1287,7 @@ int get_conn_option_key( _Inout_ sqlsrv_context& ctx, _In_ zend_string* key, _In
                 }
             }
 
-            return SS_CONN_OPTS[ i ].conn_option_key;
+            return SS_CONN_OPTS[i].conn_option_key;
         }
     }
     return SQLSRV_CONN_OPTION_INVALID;
@@ -1295,10 +1295,10 @@ int get_conn_option_key( _Inout_ sqlsrv_context& ctx, _In_ zend_string* key, _In
 
 int get_stmt_option_key( _In_ zend_string* key, _In_ size_t key_len TSRMLS_DC )
 {
-    for( int i = 0; SS_STMT_OPTS[ i ].key != SQLSRV_STMT_OPTION_INVALID; ++i )
+    for( int i = 0; SS_STMT_OPTS[i].key != SQLSRV_STMT_OPTION_INVALID; ++i )
     {
-        if( key_len == SS_STMT_OPTS[ i ].name_len && !stricmp( ZSTR_VAL( key ), SS_STMT_OPTS[ i ].name )) {
-            return SS_STMT_OPTS[ i ].key;
+        if( key_len == SS_STMT_OPTS[i].name_len && !stricmp( ZSTR_VAL( key ), SS_STMT_OPTS[i].name )) {
+            return SS_STMT_OPTS[i].key;
         }
     }
     return SQLSRV_STMT_OPTION_INVALID;
diff --git a/source/sqlsrv/init.cpp b/source/sqlsrv/init.cpp
index bb8ab04b4..74463d200 100644
--- a/source/sqlsrv/init.cpp
+++ b/source/sqlsrv/init.cpp
@@ -537,9 +537,9 @@ PHP_MINIT_FUNCTION(sqlsrv)
     g_ss_errors_ht = reinterpret_cast<HashTable*>( pemalloc( sizeof( HashTable ), 1 ));
     ::zend_hash_init( g_ss_errors_ht, 50, NULL, sqlsrv_error_const_dtor /*pDestructor*/, 1 );
 
-    for( int i = 0; SS_ERRORS[ i ].error_code != UINT_MAX; ++i ) {
-        if (NULL == ::zend_hash_index_update_mem( g_ss_errors_ht, SS_ERRORS[ i ].error_code,
-                                       &( SS_ERRORS[ i ].sqlsrv_error ), sizeof( SS_ERRORS[ i ].sqlsrv_error ))) {
+    for( int i = 0; SS_ERRORS[i].error_code != UINT_MAX; ++i ) {
+        if (NULL == ::zend_hash_index_update_mem( g_ss_errors_ht, SS_ERRORS[i].error_code,
+                                       &( SS_ERRORS[i].sqlsrv_error ), sizeof( SS_ERRORS[i].sqlsrv_error ))) {
             LOG( SEV_ERROR, "%1!s!: Failed to insert data into sqlsrv errors hashtable.", _FN_ );
             return FAILURE;
         }
diff --git a/source/sqlsrv/stmt.cpp b/source/sqlsrv/stmt.cpp
index 4f780bbf1..2c410fb89 100644
--- a/source/sqlsrv/stmt.cpp
+++ b/source/sqlsrv/stmt.cpp
@@ -137,7 +137,7 @@ ss_sqlsrv_stmt::~ss_sqlsrv_stmt( void )
 
         for( int i=0; i < fetch_fields_count; ++i ) {
             
-            sqlsrv_free( fetch_field_names[ i ].name );
+            sqlsrv_free( fetch_field_names[i].name );
         }
         sqlsrv_free( fetch_field_names );
     }
@@ -155,7 +155,7 @@ void ss_sqlsrv_stmt::new_result_set( TSRMLS_D )
 
         for( int i=0; i < fetch_fields_count; ++i ) {
             
-            sqlsrv_free( fetch_field_names[ i ].name );
+            sqlsrv_free( fetch_field_names[i].name );
         }
         sqlsrv_free( fetch_field_names );
     }
@@ -719,7 +719,7 @@ PHP_FUNCTION( sqlsrv_num_fields )
     }
 }
 
-// sqlsrv_fetch_object( resource $stmt [, string $className [, array $ctorParams ]])
+// sqlsrv_fetch_object( resource $stmt [, string $className [, array $ctorParams]])
 // 
 // Retrieves the next row of data as a PHP object.
 //
@@ -1776,7 +1776,7 @@ void fetch_fields_common( _Inout_ ss_sqlsrv_stmt* stmt, _In_ zend_long fetch_typ
 
         SQLLEN field_name_len = 0;
         SQLSMALLINT field_name_len_w = 0;
-        SQLWCHAR field_name_w[( SS_MAXCOLNAMELEN + 1 ) * 2 ] = {L'\0'};
+        SQLWCHAR field_name_w[( SS_MAXCOLNAMELEN + 1 ) * 2] = {L'\0'};
         sqlsrv_malloc_auto_ptr<char> field_name;
         sqlsrv_malloc_auto_ptr<sqlsrv_fetch_field_name> field_names;
         field_names = static_cast<sqlsrv_fetch_field_name*>( sqlsrv_malloc( num_cols * sizeof( sqlsrv_fetch_field_name )));
@@ -1836,7 +1836,7 @@ void fetch_fields_common( _Inout_ ss_sqlsrv_stmt* stmt, _In_ zend_long fetch_typ
 				throw ss::SSException();
 			}
 
-			if( stmt->fetch_field_names[ i ].len > 1 || allow_empty_field_names ) {
+			if( stmt->fetch_field_names[i].len > 1 || allow_empty_field_names ) {
 
 				zr = add_assoc_zval( &fields, stmt->fetch_field_names[i].name, &field );
 				CHECK_ZEND_ERROR( zr, stmt, SQLSRV_ERROR_ZEND_HASH ) {
diff --git a/source/sqlsrv/util.cpp b/source/sqlsrv/util.cpp
index c431daeff..f8e076218 100644
--- a/source/sqlsrv/util.cpp
+++ b/source/sqlsrv/util.cpp
@@ -28,7 +28,7 @@ unsigned int current_log_subsystem = LOG_UTIL;
 
 // buffer used to hold a formatted log message prior to actually logging it.
 const int LOG_MSG_SIZE = 2048;
-char log_msg[ LOG_MSG_SIZE ] = {'\0'};
+char log_msg[LOG_MSG_SIZE] = {'\0'};
 
 // internal error that says that FormatMessage failed
 SQLCHAR INTERNAL_FORMAT_ERROR[] = "An internal error occurred.  FormatMessage failed writing an error message.";