コード例 #1
0
 public StopEncoderFallbackBuffer(StopEncoderFallback fallback)
 {
     this.result = fallback.result ?? new EncoderResult();
 }
コード例 #2
0
        public static PhpString iconv(Context ctx, string in_charset, string out_charset, PhpString str)
        {
            // check args
            if (str.IsDefault)
            {
                PhpException.ArgumentNull("str");
                return(default(PhpString));
            }
            if (out_charset == null)
            {
                PhpException.ArgumentNull("out_charset");
                return(default(PhpString));
            }

            // resolve out_charset
            bool transliterate, discard_ilseq;

            out_charset = ParseOutputEncoding(out_charset, out transliterate, out discard_ilseq);
            var out_encoding = ResolveEncoding(ctx, out_charset);

            if (out_encoding == null)
            {
                PhpException.Throw(PhpError.Notice, Resources.LibResources.wrong_charset, out_charset, in_charset, out_charset);
                return(default(PhpString));
            }

            // encoding fallback
            EncoderFallback enc_fallback;
            var             out_result = new EncoderResult();

            if (transliterate)
            {
                enc_fallback = new TranslitEncoderFallback();   // transliterate unknown characters
            }
            else if (discard_ilseq)
            {
                enc_fallback = new IgnoreEncoderFallback();    // ignore character and continue
            }
            else
            {
                enc_fallback = new StopEncoderFallback(out_result);    // throw notice and discard all remaining characters
            }
            //// out_encoding.Clone() ensures it is NOT readOnly
            //// then set EncoderFallback to catch handle unconvertable characters

            //out_encoding = (Encoding)out_encoding.Clone();
            out_encoding = Encoding.GetEncoding(out_encoding.CodePage, enc_fallback, DecoderFallback.ExceptionFallback);

            try
            {
                //
                if (str.ContainsBinaryData)
                {
                    // resolve in_charset
                    if (in_charset == null)
                    {
                        PhpException.ArgumentNull("in_charset");
                        return(default(PhpString));
                    }
                    var in_encoding = ResolveEncoding(ctx, in_charset);
                    if (in_encoding == null)
                    {
                        PhpException.Throw(PhpError.Notice, Resources.LibResources.wrong_charset, in_charset, in_charset, out_charset);
                        return(default(PhpString));
                    }

                    // TODO: in_encoding.Clone() ensures it is NOT readOnly, then set DecoderFallback to catch invalid byte sequences

                    // convert <in_charset> to <out_charset>
                    return(new PhpString(out_encoding.GetBytes(str.ToString(in_encoding))));
                }
                else
                {
                    // convert UTF16 to <out_charset>
                    return(new PhpString(str.ToBytes(out_encoding)));
                }
            }
            finally
            {
                if (out_result.firstFallbackCharIndex >= 0)
                {
                    // Notice: iconv(): Detected an illegal character in input string
                    PhpException.Throw(Core.PhpError.Notice, Resources.LibResources.illegal_character);
                }
            }
        }