Base64Decoder.cs source code in C# .NET

                        
Code:
                         / 4.0 / 4.0 / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / Xml / System / Xml / Base64Decoder.cs / 1305376 / 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; 
            }
        } 
 
#if SILVERLIGHT && !SILVERLIGHT_DISABLE_SECURITY
        [System.Security.SecuritySafeCritical] 
#endif
        internal override unsafe int Decode( char[] chars, int startPos, int len ) {
            if ( chars == null ) {
                throw new ArgumentNullException( "chars" ); 
            }
            if ( len < 0 ) { 
                throw new ArgumentOutOfRangeException( "len" ); 
            }
            if ( startPos < 0 ) { 
                throw new ArgumentOutOfRangeException( "startPos" );
            }
            if ( chars.Length - startPos < len ) {
                throw new ArgumentOutOfRangeException( "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;
        } 

#if SILVERLIGHT && !SILVERLIGHT_DISABLE_SECURITY
        [System.Security.SecuritySafeCritical]
#endif 
        internal override unsafe int Decode(string str, int startPos, int len) {
            if ( str == null ) { 
                throw new ArgumentNullException( "str" ); 
            }
            if ( len < 0 ) { 
                throw new ArgumentOutOfRangeException( "len" );
            }
            if ( startPos < 0 ) {
                throw new ArgumentOutOfRangeException( "startPos" ); 
            }
            if ( str.Length - startPos < len ) { 
                throw new ArgumentOutOfRangeException( "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; 
        }
 
#if SILVERLIGHT && !SILVERLIGHT_DISABLE_SECURITY
        [System.Security.SecurityCritical]
#endif
        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; 
            }
        } 
 
#if SILVERLIGHT && !SILVERLIGHT_DISABLE_SECURITY
        [System.Security.SecuritySafeCritical] 
#endif
        internal override unsafe int Decode( char[] chars, int startPos, int len ) {
            if ( chars == null ) {
                throw new ArgumentNullException( "chars" ); 
            }
            if ( len < 0 ) { 
                throw new ArgumentOutOfRangeException( "len" ); 
            }
            if ( startPos < 0 ) { 
                throw new ArgumentOutOfRangeException( "startPos" );
            }
            if ( chars.Length - startPos < len ) {
                throw new ArgumentOutOfRangeException( "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;
        } 

#if SILVERLIGHT && !SILVERLIGHT_DISABLE_SECURITY
        [System.Security.SecuritySafeCritical]
#endif 
        internal override unsafe int Decode(string str, int startPos, int len) {
            if ( str == null ) { 
                throw new ArgumentNullException( "str" ); 
            }
            if ( len < 0 ) { 
                throw new ArgumentOutOfRangeException( "len" );
            }
            if ( startPos < 0 ) {
                throw new ArgumentOutOfRangeException( "startPos" ); 
            }
            if ( str.Length - startPos < len ) { 
                throw new ArgumentOutOfRangeException( "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; 
        }
 
#if SILVERLIGHT && !SILVERLIGHT_DISABLE_SECURITY
        [System.Security.SecurityCritical]
#endif
        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

• HierarchicalDataBoundControl.cs
• ExpressionPrefixAttribute.cs
• X500Name.cs
• HeaderLabel.cs
• MDIClient.cs
• DropShadowBitmapEffect.cs
• CellPartitioner.cs
• SamlAction.cs
• WindowsScrollBar.cs
• OutputCacheProfile.cs
• XmlNodeReader.cs
• UnhandledExceptionEventArgs.cs
• xsdvalidator.cs
• GeometryModel3D.cs
• HtmlInputCheckBox.cs
• HttpModulesSection.cs
• MonitoringDescriptionAttribute.cs
• StringDictionary.cs
• SchemaMapping.cs
• SQLBytes.cs
• ThemeDirectoryCompiler.cs
• CTreeGenerator.cs
• DataSetSchema.cs
• FileSecurity.cs
• SecurityPermission.cs
• DistributedTransactionPermission.cs
• DecoderReplacementFallback.cs
• PropertyGroupDescription.cs
• CallContext.cs
• PixelFormats.cs
• TemplateControlCodeDomTreeGenerator.cs
• WpfKnownMember.cs
• HttpCookieCollection.cs
• VirtualStackFrame.cs
• RegionIterator.cs
• PermissionSet.cs
• RadioButton.cs
• CalendarTable.cs
• NewExpression.cs
• DataGridCommandEventArgs.cs
• Delegate.cs
• DBNull.cs
• InvokeGenerator.cs
• SudsCommon.cs
• FileCodeGroup.cs
• BuildTopDownAttribute.cs
• KeySplineConverter.cs
• ToolStripPanelRow.cs
• PeerMessageDispatcher.cs
• InfoCardListRequest.cs
• LocalizeDesigner.cs
• IOException.cs
• GiveFeedbackEventArgs.cs
• XsdValidatingReader.cs
• ValueType.cs
• AdapterDictionary.cs
• SourceItem.cs
• EncryptedPackageFilter.cs
• ContentElementAutomationPeer.cs
• XmlSchemaElement.cs
• SystemIPv4InterfaceProperties.cs
• ListControlDataBindingHandler.cs
• Sql8ConformanceChecker.cs
• NameNode.cs
• DeviceContexts.cs
• ToolStripControlHost.cs
• Int32KeyFrameCollection.cs
• Polygon.cs
• CallbackValidatorAttribute.cs
• OrderingExpression.cs
• TimeEnumHelper.cs
• MenuBindingsEditorForm.cs
• ValueQuery.cs
• ClientUrlResolverWrapper.cs
• MsmqMessageSerializationFormat.cs
• WindowShowOrOpenTracker.cs
• SemanticBasicElement.cs
• NetworkCredential.cs
• DynamicResourceExtension.cs
• designeractionbehavior.cs
• HatchBrush.cs
• LinqDataSourceView.cs
• PolyBezierSegment.cs
• SpeechSynthesizer.cs
• EditingMode.cs
• TypeBuilderInstantiation.cs
• ColorConvertedBitmap.cs
• WizardForm.cs
• NullableFloatAverageAggregationOperator.cs
• AspProxy.cs
• CompilerError.cs
• PrintPreviewDialog.cs
• ToolboxComponentsCreatedEventArgs.cs
• StylusPointPropertyUnit.cs
• XmlCustomFormatter.cs
• ProcessInfo.cs
• DefaultValueTypeConverter.cs
• BackgroundFormatInfo.cs
• StatementContext.cs
• CheckBoxFlatAdapter.cs