Base64Decoder.cs source code in C# .NET

                        
Code:
                         / Dotnetfx_Vista_SP2 / Dotnetfx_Vista_SP2 / 8.0.50727.4016 / DEVDIV / depot / DevDiv / releases / whidbey / NetFxQFE / ndp / fx / src / Xml / System / Xml / Base64Decoder.cs / 1 / Base64Decoder.cs
                        

                        
                            //------------------------------------------------------------------------------ 
// 
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// 
// [....] 
//-----------------------------------------------------------------------------
 
using System; 
using System.Diagnostics;
 
namespace System.Xml {

    internal class Base64Decoder : IncrementalReadDecoder {
// 
// Fields
// 
        byte[]  buffer; 
        int     startIndex;
        int     curIndex; 
        int     endIndex;

        int     bits;
        int     bitsFilled; 

        private static readonly String CharsBase64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; 
        private static readonly byte[] MapBase64 = ConstructMapBase64(); 
        private const int MaxValidChar = (int)'z';
        private const byte Invalid = unchecked((byte)-1); 

//
// IncrementalReadDecoder interface
// 
        internal override int DecodedCount {
            get { 
                return curIndex - startIndex; 
            }
        } 

        internal override bool IsFull {
            get {
                return curIndex == endIndex; 
            }
        } 
 
        internal override unsafe int Decode( char[] chars, int startPos, int len ) {
            Debug.Assert( chars != null ); 
            Debug.Assert( len >= 0 );
            Debug.Assert( startPos >= 0 );
            Debug.Assert( chars.Length - startPos >= len );
 
            if ( len == 0 ) {
                return 0; 
            } 
            int bytesDecoded, charsDecoded;
            fixed ( char* pChars = &chars[startPos] ) { 
                fixed ( byte* pBytes = &buffer[curIndex] ) {
                    Decode( pChars, pChars + len, pBytes, pBytes + ( endIndex - curIndex ), out charsDecoded, out bytesDecoded );
                }
            } 
            curIndex += bytesDecoded;
            return charsDecoded; 
        } 

        internal override unsafe int Decode( string str, int startPos, int len ) { 
            Debug.Assert( str != null );
            Debug.Assert( len >= 0 );
            Debug.Assert( startPos >= 0 );
            Debug.Assert( str.Length - startPos >= len ); 

            if ( len == 0 ) { 
                return 0; 
            }
            int bytesDecoded, charsDecoded; 
            fixed ( char* pChars = str ) {
                fixed ( byte* pBytes = &buffer[curIndex] ) {
                    Decode( pChars + startPos, pChars + startPos + len, pBytes, pBytes + ( endIndex - curIndex ), out charsDecoded, out bytesDecoded );
                } 
            }
            curIndex += bytesDecoded; 
            return charsDecoded; 
        }
 
        internal override void Reset() {
            bitsFilled = 0;
            bits = 0;
        } 

        internal override void SetNextOutputBuffer( Array buffer, int index, int count ) { 
            Debug.Assert( buffer != null ); 
            Debug.Assert( count >= 0 );
            Debug.Assert( index >= 0 ); 
            Debug.Assert( buffer.Length - index >= count );
            Debug.Assert( ( buffer as byte[] ) != null );

            this.buffer = (byte[])buffer; 
            this.startIndex = index;
            this.curIndex = index; 
            this.endIndex = index + count; 
        }
 
//
// Private methods
//
        private static byte[] ConstructMapBase64() { 
            byte[] mapBase64 = new byte[MaxValidChar + 1];
            for ( int i = 0; i < mapBase64.Length; i++ ) { 
                mapBase64[i]= Invalid; 
            }
            for ( int i = 0; i < CharsBase64.Length; i++ ) { 
                mapBase64[(int)CharsBase64[i]] = (byte)i;
            }
            return mapBase64;
        } 

        private unsafe void Decode( char* pChars, char* pCharsEndPos, 
                             byte* pBytes, byte* pBytesEndPos, 
                             out int charsDecoded, out int bytesDecoded ) {
#if DEBUG 
            Debug.Assert( pCharsEndPos - pChars >= 0 );
            Debug.Assert( pBytesEndPos - pBytes >= 0 );
#endif
 
            // walk hex digits pairing them up and shoving the value of each pair into a byte
            byte *pByte = pBytes; 
            char *pChar = pChars; 
            int b = bits;
            int bFilled = bitsFilled; 
            XmlCharType xmlCharType = XmlCharType.Instance;
            while ( pChar < pCharsEndPos && pByte < pBytesEndPos ) {
                char ch = *pChar;
                // end? 
                if ( ch == '=' ) {
                    break; 
                } 
                pChar++;
 
                // ignore white space
                if ( ( xmlCharType.charProperties[ch] & XmlCharType.fWhitespace ) != 0 ) {  // if ( xmlCharType.IsWhiteSpace(ch) ) {
                    continue;
                } 

                int digit; 
                if ( ch > 122 || ( digit = MapBase64[ch] ) == Invalid ) { 
                    throw new XmlException(Res.Xml_InvalidBase64Value, new string( pChars, 0, (int)(pCharsEndPos - pChars) ));
                } 

                b = ( b << 6 ) | digit;
                bFilled += 6;
 
                if ( bFilled >= 8 ) {
                    // get top eight valid bits 
                    *pByte++ = (byte)( ( b >> ( bFilled - 8 ) ) & 0xFF ); 
                    bFilled -= 8;
 
                    if ( pByte == pBytesEndPos ) {
                        goto Return;
                    }
                } 
            }
 
            if ( pChar < pCharsEndPos && *pChar == '=' ) { 
                bFilled = 0;
                // ignore padding chars 
                do {
                    pChar++;
                } while ( pChar < pCharsEndPos && *pChar == '=' );
 
                // ignore whitespace after the padding chars
                if ( pChar < pCharsEndPos ) { 
                    do { 
                        if ( !( ( xmlCharType.charProperties[*pChar++] & XmlCharType.fWhitespace ) != 0 ) ) {  // if ( !( xmlCharType.IsWhiteSpace( chars[charPos++] ) ) ) {
                            throw new XmlException(Res.Xml_InvalidBase64Value, new string( pChars, 0, (int)( pCharsEndPos - pChars ) )); 
                        }
                    } while ( pChar < pCharsEndPos );
                }
            } 

        Return: 
            bits = b; 
            bitsFilled = bFilled;
 
            bytesDecoded = (int)(pByte - pBytes);
            charsDecoded = (int)(pChar - pChars);
        }
    } 
}

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
//------------------------------------------------------------------------------ 
// 
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// 
// [....] 
//-----------------------------------------------------------------------------
 
using System; 
using System.Diagnostics;
 
namespace System.Xml {

    internal class Base64Decoder : IncrementalReadDecoder {
// 
// Fields
// 
        byte[]  buffer; 
        int     startIndex;
        int     curIndex; 
        int     endIndex;

        int     bits;
        int     bitsFilled; 

        private static readonly String CharsBase64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; 
        private static readonly byte[] MapBase64 = ConstructMapBase64(); 
        private const int MaxValidChar = (int)'z';
        private const byte Invalid = unchecked((byte)-1); 

//
// IncrementalReadDecoder interface
// 
        internal override int DecodedCount {
            get { 
                return curIndex - startIndex; 
            }
        } 

        internal override bool IsFull {
            get {
                return curIndex == endIndex; 
            }
        } 
 
        internal override unsafe int Decode( char[] chars, int startPos, int len ) {
            Debug.Assert( chars != null ); 
            Debug.Assert( len >= 0 );
            Debug.Assert( startPos >= 0 );
            Debug.Assert( chars.Length - startPos >= len );
 
            if ( len == 0 ) {
                return 0; 
            } 
            int bytesDecoded, charsDecoded;
            fixed ( char* pChars = &chars[startPos] ) { 
                fixed ( byte* pBytes = &buffer[curIndex] ) {
                    Decode( pChars, pChars + len, pBytes, pBytes + ( endIndex - curIndex ), out charsDecoded, out bytesDecoded );
                }
            } 
            curIndex += bytesDecoded;
            return charsDecoded; 
        } 

        internal override unsafe int Decode( string str, int startPos, int len ) { 
            Debug.Assert( str != null );
            Debug.Assert( len >= 0 );
            Debug.Assert( startPos >= 0 );
            Debug.Assert( str.Length - startPos >= len ); 

            if ( len == 0 ) { 
                return 0; 
            }
            int bytesDecoded, charsDecoded; 
            fixed ( char* pChars = str ) {
                fixed ( byte* pBytes = &buffer[curIndex] ) {
                    Decode( pChars + startPos, pChars + startPos + len, pBytes, pBytes + ( endIndex - curIndex ), out charsDecoded, out bytesDecoded );
                } 
            }
            curIndex += bytesDecoded; 
            return charsDecoded; 
        }
 
        internal override void Reset() {
            bitsFilled = 0;
            bits = 0;
        } 

        internal override void SetNextOutputBuffer( Array buffer, int index, int count ) { 
            Debug.Assert( buffer != null ); 
            Debug.Assert( count >= 0 );
            Debug.Assert( index >= 0 ); 
            Debug.Assert( buffer.Length - index >= count );
            Debug.Assert( ( buffer as byte[] ) != null );

            this.buffer = (byte[])buffer; 
            this.startIndex = index;
            this.curIndex = index; 
            this.endIndex = index + count; 
        }
 
//
// Private methods
//
        private static byte[] ConstructMapBase64() { 
            byte[] mapBase64 = new byte[MaxValidChar + 1];
            for ( int i = 0; i < mapBase64.Length; i++ ) { 
                mapBase64[i]= Invalid; 
            }
            for ( int i = 0; i < CharsBase64.Length; i++ ) { 
                mapBase64[(int)CharsBase64[i]] = (byte)i;
            }
            return mapBase64;
        } 

        private unsafe void Decode( char* pChars, char* pCharsEndPos, 
                             byte* pBytes, byte* pBytesEndPos, 
                             out int charsDecoded, out int bytesDecoded ) {
#if DEBUG 
            Debug.Assert( pCharsEndPos - pChars >= 0 );
            Debug.Assert( pBytesEndPos - pBytes >= 0 );
#endif
 
            // walk hex digits pairing them up and shoving the value of each pair into a byte
            byte *pByte = pBytes; 
            char *pChar = pChars; 
            int b = bits;
            int bFilled = bitsFilled; 
            XmlCharType xmlCharType = XmlCharType.Instance;
            while ( pChar < pCharsEndPos && pByte < pBytesEndPos ) {
                char ch = *pChar;
                // end? 
                if ( ch == '=' ) {
                    break; 
                } 
                pChar++;
 
                // ignore white space
                if ( ( xmlCharType.charProperties[ch] & XmlCharType.fWhitespace ) != 0 ) {  // if ( xmlCharType.IsWhiteSpace(ch) ) {
                    continue;
                } 

                int digit; 
                if ( ch > 122 || ( digit = MapBase64[ch] ) == Invalid ) { 
                    throw new XmlException(Res.Xml_InvalidBase64Value, new string( pChars, 0, (int)(pCharsEndPos - pChars) ));
                } 

                b = ( b << 6 ) | digit;
                bFilled += 6;
 
                if ( bFilled >= 8 ) {
                    // get top eight valid bits 
                    *pByte++ = (byte)( ( b >> ( bFilled - 8 ) ) & 0xFF ); 
                    bFilled -= 8;
 
                    if ( pByte == pBytesEndPos ) {
                        goto Return;
                    }
                } 
            }
 
            if ( pChar < pCharsEndPos && *pChar == '=' ) { 
                bFilled = 0;
                // ignore padding chars 
                do {
                    pChar++;
                } while ( pChar < pCharsEndPos && *pChar == '=' );
 
                // ignore whitespace after the padding chars
                if ( pChar < pCharsEndPos ) { 
                    do { 
                        if ( !( ( xmlCharType.charProperties[*pChar++] & XmlCharType.fWhitespace ) != 0 ) ) {  // if ( !( xmlCharType.IsWhiteSpace( chars[charPos++] ) ) ) {
                            throw new XmlException(Res.Xml_InvalidBase64Value, new string( pChars, 0, (int)( pCharsEndPos - pChars ) )); 
                        }
                    } while ( pChar < pCharsEndPos );
                }
            } 

        Return: 
            bits = b; 
            bitsFilled = bFilled;
 
            bytesDecoded = (int)(pByte - pBytes);
            charsDecoded = (int)(pChar - pChars);
        }
    } 
}

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.

                        

                        

                        
                        

Link Menu

This book is available now!
Buy at Amazon US or
Buy at Amazon UK

• FontFamilyConverter.cs
• Rule.cs
• PropertyItem.cs
• WindowsRichEditRange.cs
• RTLAwareMessageBox.cs
• Vars.cs
• RunClient.cs
• TableStyle.cs
• DetailsViewPagerRow.cs
• SchemaObjectWriter.cs
• TraceContextEventArgs.cs
• EllipticalNodeOperations.cs
• TraceHandler.cs
• ImageDrawing.cs
• SystemInfo.cs
• Helper.cs
• DirectoryNotFoundException.cs
• QueryCacheEntry.cs
• OleStrCAMarshaler.cs
• NotifyInputEventArgs.cs
• CodeMemberField.cs
• X509Certificate2Collection.cs
• VolatileEnlistmentMultiplexing.cs
• XmlNodeComparer.cs
• SafeLibraryHandle.cs
• ProgressBarHighlightConverter.cs
• ResourceDescriptionAttribute.cs
• XamlToRtfWriter.cs
• ReflectPropertyDescriptor.cs
• URL.cs
• XmlBindingWorker.cs
• RadioButtonStandardAdapter.cs
• EditingCommands.cs
• TextParaClient.cs
• ExpressionsCollectionConverter.cs
• AttributedMetaModel.cs
• ColorComboBox.cs
• StorageBasedPackageProperties.cs
• RuntimeConfigurationRecord.cs
• CryptoConfig.cs
• GestureRecognitionResult.cs
• CompiledRegexRunnerFactory.cs
• HttpResponseHeader.cs
• ProfileGroupSettingsCollection.cs
• Int64Converter.cs
• Viewport2DVisual3D.cs
• GroupByQueryOperator.cs
• ValidationEventArgs.cs
• TabControlCancelEvent.cs
• RoleGroup.cs
• ModelTreeEnumerator.cs
• TextDecorations.cs
• ComplexBindingPropertiesAttribute.cs
• coordinatorscratchpad.cs
• WebServiceHandler.cs
• SymmetricKeyWrap.cs
• DynamicUpdateCommand.cs
• DataKey.cs
• serverconfig.cs
• Rotation3DAnimationUsingKeyFrames.cs
• MenuItemCollection.cs
• Converter.cs
• ASCIIEncoding.cs
• _Semaphore.cs
• ObjectCacheSettings.cs
• GACMembershipCondition.cs
• FixedTextView.cs
• PropertyMap.cs
• TagElement.cs
• Property.cs
• DropDownButton.cs
• Expression.cs
• IChannel.cs
• RadialGradientBrush.cs
• MetaData.cs
• RevocationPoint.cs
• IntAverageAggregationOperator.cs
• TextBoxRenderer.cs
• DomainConstraint.cs
• WCFBuildProvider.cs
• ServerProtocol.cs
• ActivityFunc.cs
• StringConverter.cs
• ProfilePropertyNameValidator.cs
• AppSettingsReader.cs
• StringFunctions.cs
• RequestCachingSection.cs
• GacUtil.cs
• TcpChannelHelper.cs
• SmtpClient.cs
• WinEventQueueItem.cs
• CacheRequest.cs
• MimeParameterWriter.cs
• SelectionHighlightInfo.cs
• QilXmlReader.cs
• WSDualHttpBindingElement.cs
• SpecularMaterial.cs
• GlobalizationSection.cs
• ThemeInfoAttribute.cs
• SaveFileDialog.cs