Clean separation for XDR reading and writing.

Author: cincuranet

Provider/src/FirebirdSql.Data.External/FirebirdSql.Data.External.projitems

@@ -10,7 +10,6 @@
   </PropertyGroup>
   <ItemGroup>
     <Compile Include="$(MSBuildThisFileDirectory)RC4\ICipherParameters.cs" />
-    <Compile Include="$(MSBuildThisFileDirectory)RC4\IStreamCipher.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)RC4\KeyParameter.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)RC4\RC4Engine.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)zlib\Deflate.cs" />

Provider/src/FirebirdSql.Data.External/RC4/IStreamCipher.cs

@@ -6,7 +6,7 @@
 namespace Org.BouncyCastle.Crypto.Engines
 {
     internal class RC4Engine
-		: IStreamCipher
+		//: IStreamCipher
     {
         private readonly static int STATE_LENGTH = 256;
 

Provider/src/FirebirdSql.Data.External/RC4/RC4Engine.cs

@@ -386,11 +386,11 @@ private void _InitializeTreeData()
         internal void _InitializeBlocks()
         {
             // Initialize the trees.
-            for (var i = 0; i < InternalConstants.L_CODES; i++)
+            for (int i = 0; i < InternalConstants.L_CODES; i++)
                 dyn_ltree[i * 2] = 0;
-            for (var i = 0; i < InternalConstants.D_CODES; i++)
+            for (int i = 0; i < InternalConstants.D_CODES; i++)
                 dyn_dtree[i * 2] = 0;
-            for (var i = 0; i < InternalConstants.BL_CODES; i++)
+            for (int i = 0; i < InternalConstants.BL_CODES; i++)
                 bl_tree[i * 2] = 0;
 
             dyn_ltree[END_BLOCK * 2] = 1;
@@ -404,8 +404,8 @@ internal void _InitializeBlocks()
         // two sons).
         internal void pqdownheap(short[] tree, int k)
         {
-            var v = heap[k];
-            var j = k << 1; // left son of k
+            int v = heap[k];
+            int j = k << 1; // left son of k
             while (j <= heap_len)
             {
                 // Set j to the smallest of the two sons:
@@ -427,8 +427,8 @@ internal void pqdownheap(short[] tree, int k)
 
         internal static bool _IsSmaller(short[] tree, int n, int m, sbyte[] depth)
         {
-            var tn2 = tree[n * 2];
-            var tm2 = tree[m * 2];
+            short tn2 = tree[n * 2];
+            short tm2 = tree[m * 2];
             return (tn2 < tm2 || (tn2 == tm2 && depth[n] <= depth[m]));
         }
 
@@ -438,12 +438,12 @@ internal static bool _IsSmaller(short[] tree, int n, int m, sbyte[] depth)
         internal void scan_tree(short[] tree, int max_code)
         {
             int n; // iterates over all tree elements
-            var prevlen = -1; // last emitted length
+            int prevlen = -1; // last emitted length
             int curlen; // length of current code
-            var nextlen = (int)tree[0 * 2 + 1]; // length of next code
-            var count = 0; // repeat count of the current code
-            var max_count = 7; // max repeat count
-            var min_count = 4; // min repeat count
+            int nextlen = (int)tree[0 * 2 + 1]; // length of next code
+            int count = 0; // repeat count of the current code
+            int max_count = 7; // max repeat count
+            int min_count = 4; // min repeat count
 
             if (nextlen == 0)
             {
@@ -545,12 +545,12 @@ internal void send_all_trees(int lcodes, int dcodes, int blcodes)
         internal void send_tree(short[] tree, int max_code)
         {
             int n;                           // iterates over all tree elements
-            var prevlen   = -1;              // last emitted length
+            int prevlen   = -1;              // last emitted length
             int curlen;                      // length of current code
             int nextlen   = tree[0 * 2 + 1]; // length of next code
-            var count     = 0;               // repeat count of the current code
-            var max_count = 7;               // max repeat count
-            var min_count = 4;               // min repeat count
+            int count     = 0;               // repeat count of the current code
+            int max_count = 7;               // max repeat count
+            int min_count = 4;               // min repeat count
 
             if (nextlen == 0)
             {
@@ -640,13 +640,13 @@ internal void putShortMSB(int b)
 
         internal void send_code(int c, short[] tree)
         {
-            var c2 = c * 2;
+            int c2 = c * 2;
             send_bits((tree[c2] & 0xffff), (tree[c2 + 1] & 0xffff));
         }
 
         internal void send_bits(int value, int length)
         {
-            var len = length;
+            int len = length;
             unchecked
             {
                 if (bi_valid > (int)Buf_size - len)
@@ -728,8 +728,8 @@ internal bool _tr_tally(int dist, int lc)
             if ((last_lit & 0x1fff) == 0 && (int)compressionLevel > 2)
             {
                 // Compute an upper bound for the compressed length
-                var out_length = last_lit << 3;
-                var in_length = strstart - block_start;
+                int out_length = last_lit << 3;
+                int in_length = strstart - block_start;
                 int dcode;
                 for (dcode = 0; dcode < InternalConstants.D_CODES; dcode++)
                 {
@@ -754,15 +754,15 @@ internal void send_compressed_block(short[] ltree, short[] dtree)
         {
             int distance; // distance of matched string
             int lc;       // match length or unmatched char (if dist == 0)
-            var lx = 0;   // running index in l_buf
+            int lx = 0;   // running index in l_buf
             int code;     // the code to send
             int extra;    // number of extra bits to send
 
             if (last_lit != 0)
             {
                 do
                 {
-                    var ix = _distanceOffset + lx * 2;
+                    int ix = _distanceOffset + lx * 2;
                     distance = ((pending[ix] << 8) & 0xff00) |
                         (pending[ix + 1] & 0xff);
                     lc = (pending[_lengthOffset + lx]) & 0xff;
@@ -819,9 +819,9 @@ internal void send_compressed_block(short[] ltree, short[] dtree)
         // frequencies does not exceed 64K (to fit in an int on 16 bit machines).
         internal void set_data_type()
         {
-            var n = 0;
-            var ascii_freq = 0;
-            var bin_freq = 0;
+            int n = 0;
+            int ascii_freq = 0;
+            int bin_freq = 0;
             while (n < 7)
             {
                 bin_freq += dyn_ltree[n * 2]; n++;
@@ -915,7 +915,7 @@ internal BlockState DeflateNone(FlushType flush)
             // Stored blocks are limited to 0xffff bytes, pending is limited
             // to pending_buf_size, and each stored block has a 5 byte header:
 
-            var max_block_size = 0xffff;
+            int max_block_size = 0xffff;
             int max_start;
 
             if (max_block_size > pending.Length - 5)
@@ -982,7 +982,7 @@ internal void _tr_stored_block(int buf, int stored_len, bool eof)
         internal void _tr_flush_block(int buf, int stored_len, bool eof)
         {
             int opt_lenb, static_lenb; // opt_len and static_len in bytes
-            var max_blindex = 0; // index of last bit length code of non zero freq
+            int max_blindex = 0; // index of last bit length code of non zero freq
 
             // Build the Huffman trees unless a stored block is forced
             if (compressionLevel > 0)
@@ -1152,7 +1152,7 @@ private void _fillWindow()
         internal BlockState DeflateFast(FlushType flush)
         {
             //    short hash_head = 0; // head of the hash chain
-            var hash_head = 0; // head of the hash chain
+            int hash_head = 0; // head of the hash chain
             bool bflush; // set if current block must be flushed
 
             while (true)
@@ -1271,7 +1271,7 @@ internal BlockState DeflateFast(FlushType flush)
         internal BlockState DeflateSlow(FlushType flush)
         {
             //    short hash_head = 0;    // head of hash chain
-            var hash_head = 0; // head of hash chain
+            int hash_head = 0; // head of hash chain
             bool bflush; // set if current block must be flushed
 
             // Process the input block.
@@ -1336,7 +1336,7 @@ internal BlockState DeflateSlow(FlushType flush)
                 // match is not better, output the previous match:
                 if (prev_length >= MIN_MATCH && match_length <= prev_length)
                 {
-                    var max_insert = strstart + lookahead - MIN_MATCH;
+                    int max_insert = strstart + lookahead - MIN_MATCH;
                     // Do not insert strings in hash table beyond this.
 
                     //          check_match(strstart-1, prev_match, prev_length);
@@ -1422,23 +1422,23 @@ internal BlockState DeflateSlow(FlushType flush)
 
         internal int longest_match(int cur_match)
         {
-            var chain_length = config.MaxChainLength; // max hash chain length
-            var scan         = strstart;              // current string
+            int chain_length = config.MaxChainLength; // max hash chain length
+            int scan         = strstart;              // current string
             int match;                                // matched string
             int len;                                  // length of current match
-            var best_len     = prev_length;           // best match length so far
-            var limit        = strstart > (w_size - MIN_LOOKAHEAD) ? strstart - (w_size - MIN_LOOKAHEAD) : 0;
+            int best_len     = prev_length;           // best match length so far
+            int limit        = strstart > (w_size - MIN_LOOKAHEAD) ? strstart - (w_size - MIN_LOOKAHEAD) : 0;
 
-            var niceLength = config.NiceLength;
+            int niceLength = config.NiceLength;
 
             // Stop when cur_match becomes <= limit. To simplify the code,
             // we prevent matches with the string of window index 0.
 
-            var wmask = w_mask;
+            int wmask = w_mask;
 
-            var strend = strstart + MAX_MATCH;
-            var scan_end1 = window[scan + best_len - 1];
-            var scan_end = window[scan + best_len];
+            int strend = strstart + MAX_MATCH;
+            byte scan_end1 = window[scan + best_len - 1];
+            byte scan_end = window[scan + best_len];
 
             // The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16.
             // It is easy to get rid of this optimization if necessary.
@@ -1640,11 +1640,11 @@ private void SetDeflater()
 
         internal int SetParams(CompressionLevel level, CompressionStrategy strategy)
         {
-            var result = ZlibConstants.Z_OK;
+            int result = ZlibConstants.Z_OK;
 
             if (compressionLevel != level)
             {
-                var newConfig = Config.Lookup(level);
+                Config newConfig = Config.Lookup(level);
 
                 // change in the deflate flavor (Fast vs slow vs none)?
                 if (newConfig.Flavor != config.Flavor && _codec.TotalBytesIn != 0)
@@ -1667,8 +1667,8 @@ internal int SetParams(CompressionLevel level, CompressionStrategy strategy)
 
         internal int SetDictionary(byte[] dictionary)
         {
-            var length = dictionary.Length;
-            var index = 0;
+            int length = dictionary.Length;
+            int index = 0;
 
             if (dictionary == null || status != INIT_STATE)
                 throw new ZlibException("Stream error.");
@@ -1693,7 +1693,7 @@ internal int SetDictionary(byte[] dictionary)
             ins_h = window[0] & 0xff;
             ins_h = (((ins_h) << hash_shift) ^ (window[1] & 0xff)) & hash_mask;
 
-            for (var n = 0; n <= length - MIN_MATCH; n++)
+            for (int n = 0; n <= length - MIN_MATCH; n++)
             {
                 ins_h = (((ins_h) << hash_shift) ^ (window[(n) + (MIN_MATCH - 1)] & 0xff)) & hash_mask;
                 prev[n & w_mask] = head[ins_h];
@@ -1727,8 +1727,8 @@ internal int Deflate(FlushType flush)
             // Write the zlib (rfc1950) header bytes
             if (status == INIT_STATE)
             {
-                var header = (Z_DEFLATED + ((w_bits - 8) << 4)) << 8;
-                var level_flags = (((int)compressionLevel - 1) & 0xff) >> 1;
+                int header = (Z_DEFLATED + ((w_bits - 8) << 4)) << 8;
+                int level_flags = (((int)compressionLevel - 1) & 0xff) >> 1;
 
                 if (level_flags > 3)
                     level_flags = 3;
@@ -1802,7 +1802,7 @@ internal int Deflate(FlushType flush)
             // Start a new block or continue the current one.
             if (_codec.AvailableBytesIn != 0 || lookahead != 0 || (flush != FlushType.None && status != FINISH_STATE))
             {
-                var bstate = DeflateFunction(flush);
+                BlockState bstate = DeflateFunction(flush);
 
                 if (bstate == BlockState.FinishStarted || bstate == BlockState.FinishDone)
                 {
@@ -1838,7 +1838,7 @@ internal int Deflate(FlushType flush)
                         if (flush == FlushType.Full)
                         {
                             // clear hash (forget the history)
-                            for (var i = 0; i < hash_size; i++)
+                            for (int i = 0; i < hash_size; i++)
                                 head[i] = 0;
                         }
                     }