ÿØÿà JFIF    ÿÛ „ ( %!1!%*+...983,7(-.- PKKw]K putback-i.rinu[U:RDoc::AnyMethod[iI" putback:ETI" Encoding::Converter#putback;TF: privateo:RDoc::Markup::Document: @parts[ o:RDoc::Markup::Paragraph; [I"0Put back the bytes which will be converted.;To:RDoc::Markup::BlankLineo; ; [ I":The bytes are caused by invalid_byte_sequence error. ;TI"DWhen invalid_byte_sequence error, some bytes are discarded and ;TI"4some bytes are buffered to be converted later. ;TI"'The latter bytes can be put back. ;TI"It can be observed by ;TI" :invalid_byte_sequence ;TI"gp ec.primitive_errinfo #=> [:invalid_byte_sequence, "UTF-16LE", "UTF-8", "\x00\xD8", "a\x00"] ;TI",p ec.putback #=> "a\x00" ;TI"Kp ec.putback #=> "" # no more bytes to put back;T: @format0: @fileI"transcode.c;T:0@omit_headings_from_table_of_contents_below0I"Uec.putback -> string ec.putback(max_numbytes) -> string ;T0[I" (*args);T@!FI"Converter;TcRDoc::NormalClass00PKKw]geeprimitive_convert-i.rinu[U:RDoc::AnyMethod[iI"primitive_convert:ETI"*Encoding::Converter#primitive_convert;TF: privateo:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"possible opt elements:;To:RDoc::Markup::Verbatim; [ I"hash form: ;TI"U :partial_input => true # source buffer may be part of larger source ;TI"T :after_output => true # stop conversion after output before input ;TI"integer form: ;TI"* Encoding::Converter::PARTIAL_INPUT ;TI") Encoding::Converter::AFTER_OUTPUT ;T: @format0o; ; [I"possible results:;To; ; [ I":invalid_byte_sequence ;TI":incomplete_input ;TI":undefined_conversion ;TI":after_output ;TI":destination_buffer_full ;TI":source_buffer_empty ;TI":finished ;T; 0o; ; [I"Fprimitive_convert converts source_buffer into destination_buffer.;To:RDoc::Markup::BlankLineo; ; [I".source_buffer should be a string or nil. ;TI"nil means an empty string.;T@%o; ; [I"+destination_buffer should be a string.;T@%o; ; [I"9destination_byteoffset should be an integer or nil. ;TI".nil means the end of destination_buffer. ;TI"&If it is omitted, nil is assumed.;T@%o; ; [I"7destination_bytesize should be an integer or nil. ;TI"nil means unlimited. ;TI"&If it is omitted, nil is assumed.;T@%o; ; [I".opt should be nil, a hash or an integer. ;TI"nil means no flags. ;TI"&If it is omitted, nil is assumed.;T@%o; ; [I"Lprimitive_convert converts the content of source_buffer from beginning ;TI"2and store the result into destination_buffer.;T@%o; ; [I"Ndestination_byteoffset and destination_bytesize specify the region which ;TI"%the converted result is stored. ;TI"Ydestination_byteoffset specifies the start position in destination_buffer in bytes. ;TI"'If destination_byteoffset is nil, ;TI"Cdestination_buffer.bytesize is used for appending the result. ;TI"=destination_bytesize specifies maximum number of bytes. ;TI"%If destination_bytesize is nil, ;TI"$destination size is unlimited. ;TI"8After conversion, destination_buffer is resized to ;TI"Adestination_byteoffset + actually produced number of bytes. ;TI"GAlso destination_buffer's encoding is set to destination_encoding.;T@%o; ; [I"Bprimitive_convert drops the converted part of source_buffer. ;TI" [:finished, "", "\x00p\x00i"] ;TI" ;TI"7ec = Encoding::Converter.new("UTF-8", "UTF-16BE") ;TI":ret = ec.primitive_convert(src="pi", dst="", nil, 1) ;TI"Cp [ret, src, dst] #=> [:destination_buffer_full, "i", "\x00"] ;TI"5ret = ec.primitive_convert(src, dst="", nil, 1) ;TI"?p [ret, src, dst] #=> [:destination_buffer_full, "", "p"] ;TI"5ret = ec.primitive_convert(src, dst="", nil, 1) ;TI"Bp [ret, src, dst] #=> [:destination_buffer_full, "", "\x00"] ;TI"5ret = ec.primitive_convert(src, dst="", nil, 1) ;TI"/p [ret, src, dst] #=> [:finished, "", "i"];T; 0: @fileI"transcode.c;T:0@omit_headings_from_table_of_contents_below0I"ec.primitive_convert(source_buffer, destination_buffer) -> symbol ec.primitive_convert(source_buffer, destination_buffer, destination_byteoffset) -> symbol ec.primitive_convert(source_buffer, destination_buffer, destination_byteoffset, destination_bytesize) -> symbol ec.primitive_convert(source_buffer, destination_buffer, destination_byteoffset, destination_bytesize, opt) -> symbol ;T0[I"1(p1, p2, p3 = v3, p4 = v4, p5 = v5, p6 = {});T@FI"Converter;TcRDoc::NormalClass00PKKw]iLasciicompat_encoding-c.rinu[U:RDoc::AnyMethod[iI"asciicompat_encoding:ETI".Encoding::Converter::asciicompat_encoding;TT: privateo:RDoc::Markup::Document: @parts[ o:RDoc::Markup::Paragraph; [I"9Returns the corresponding ASCII compatible encoding.;To:RDoc::Markup::BlankLineo; ; [I"AReturns nil if the argument is an ASCII compatible encoding.;T@o; ; [I"U"corresponding ASCII compatible encoding" is an ASCII compatible encoding which ;TI"Zcan represents exactly the same characters as the given ASCII incompatible encoding. ;TI"XSo, no conversion undefined error occurs when converting between the two encodings.;T@o:RDoc::Markup::Verbatim; [I"cEncoding::Converter.asciicompat_encoding("ISO-2022-JP") #=> # ;TI"PEncoding::Converter.asciicompat_encoding("UTF-16BE") #=> # ;TI">Encoding::Converter.asciicompat_encoding("UTF-8") #=> nil;T: @format0: @fileI"transcode.c;T:0@omit_headings_from_table_of_contents_below0I"Encoding::Converter.asciicompat_encoding(string) -> encoding or nil Encoding::Converter.asciicompat_encoding(encoding) -> encoding or nil ;T0[I" (p1);T@FI"Converter;TcRDoc::NormalClass00PKKw]R%% convpath-i.rinu[U:RDoc::AnyMethod[iI" convpath:ETI"!Encoding::Converter#convpath;TF: privateo:RDoc::Markup::Document: @parts[ o:RDoc::Markup::Paragraph; [I"'Returns the conversion path of ec.;To:RDoc::Markup::BlankLineo; ; [I"+The result is an array of conversions.;T@o:RDoc::Markup::Verbatim; [ I"Nec = Encoding::Converter.new("ISO-8859-1", "EUC-JP", crlf_newline: true) ;TI"p ec.convpath ;TI"7#=> [[#, #], ;TI"3# [#, #], ;TI"# "crlf_newline"] ;T: @format0o; ; [I"CEach element of the array is a pair of encodings or a string. ;TI"*A pair means an encoding conversion. ;TI" A string means a decorator.;T@o; ; [I"MIn the above example, [#, #] means ;TI"+a converter from ISO-8859-1 to UTF-8. ;TI"<"crlf_newline" means newline converter from LF to CRLF.;T: @fileI"transcode.c;T:0@omit_headings_from_table_of_contents_below0I"ec.convpath -> ary ;T0[I"();T@#FI"Converter;TcRDoc::NormalClass00PKKw]A}++ inspect-i.rinu[U:RDoc::AnyMethod[iI" inspect:ETI" Encoding::Converter#inspect;TF: privateo:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"-Returns a printable version of ec;To:RDoc::Markup::BlankLineo:RDoc::Markup::Verbatim; [I"9ec = Encoding::Converter.new("iso-8859-1", "utf-8") ;TI"Gputs ec.inspect #=> #;T: @format0: @fileI"transcode.c;T:0@omit_headings_from_table_of_contents_below0I""ec.inspect -> string ;T0[I"();T@FI"Converter;TcRDoc::NormalClass00PKKw]>++primitive_errinfo-i.rinu[U:RDoc::AnyMethod[iI"primitive_errinfo:ETI"*Encoding::Converter#primitive_errinfo;TF: privateo:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"Nprimitive_errinfo returns important information regarding the last error ;TI"as a 5-element array:;To:RDoc::Markup::BlankLineo:RDoc::Markup::Verbatim; [I"8[result, enc1, enc2, error_bytes, readagain_bytes] ;T: @format0o; ; [I"4result is the last result of primitive_convert.;T@o; ; [I"7Other elements are only meaningful when result is ;TI"H:invalid_byte_sequence, :incomplete_input or :undefined_conversion.;T@o; ; [ I"Denc1 and enc2 indicate a conversion step as a pair of strings. ;TI"AFor example, a converter from EUC-JP to ISO-8859-1 converts ;TI"9a string as follows: EUC-JP -> UTF-8 -> ISO-8859-1. ;TI"NSo [enc1, enc2] is either ["EUC-JP", "UTF-8"] or ["UTF-8", "ISO-8859-1"].;T@o; ; [I"Yerror_bytes and readagain_bytes indicate the byte sequences which caused the error. ;TI"'error_bytes is discarded portion. ;TI"Preadagain_bytes is buffered portion which is read again on next conversion.;T@o; ; [I" Example:;T@o; ; [5I""# \xff is invalid as EUC-JP. ;TI"9ec = Encoding::Converter.new("EUC-JP", "Shift_JIS") ;TI"7ec.primitive_convert(src="\xff", dst="", nil, 10) ;TI"p ec.primitive_errinfo ;TI"E#=> [:invalid_byte_sequence, "EUC-JP", "Shift_JIS", "\xFF", ""] ;TI" ;TI"R# HIRAGANA LETTER A (\xa4\xa2 in EUC-JP) is not representable in ISO-8859-1. ;TI"D# Since this error is occur in UTF-8 to ISO-8859-1 conversion, ;TI"A# error_bytes is HIRAGANA LETTER A in UTF-8 (\xE3\x81\x82). ;TI":ec = Encoding::Converter.new("EUC-JP", "ISO-8859-1") ;TI";ec.primitive_convert(src="\xa4\xa2", dst="", nil, 10) ;TI"p ec.primitive_errinfo ;TI"L#=> [:undefined_conversion, "UTF-8", "ISO-8859-1", "\xE3\x81\x82", ""] ;TI" ;TI"$# partial character is invalid ;TI":ec = Encoding::Converter.new("EUC-JP", "ISO-8859-1") ;TI"7ec.primitive_convert(src="\xa4", dst="", nil, 10) ;TI"p ec.primitive_errinfo ;TI"<#=> [:incomplete_input, "EUC-JP", "UTF-8", "\xA4", ""] ;TI" ;TI"E# Encoding::Converter::PARTIAL_INPUT prevents invalid errors by ;TI"# partial characters. ;TI":ec = Encoding::Converter.new("EUC-JP", "ISO-8859-1") ;TI"[ec.primitive_convert(src="\xa4", dst="", nil, 10, Encoding::Converter::PARTIAL_INPUT) ;TI"p ec.primitive_errinfo ;TI"4#=> [:source_buffer_empty, nil, nil, nil, nil] ;TI" ;TI"4# \xd8\x00\x00@ is invalid as UTF-16BE because ;TI"9# no low surrogate after high surrogate (\xd8\x00). ;TI"I# It is detected by 3rd byte (\00) which is part of next character. ;TI"9# So the high surrogate (\xd8\x00) is discarded and ;TI")# the 3rd byte is read again later. ;TI"A# Since the byte is buffered in ec, it is dropped from src. ;TI"7ec = Encoding::Converter.new("UTF-16BE", "UTF-8") ;TI"@ec.primitive_convert(src="\xd8\x00\x00@", dst="", nil, 10) ;TI"p ec.primitive_errinfo ;TI"K#=> [:invalid_byte_sequence, "UTF-16BE", "UTF-8", "\xD8\x00", "\x00"] ;TI" p src ;TI" #=> "@" ;TI" ;TI"B# Similar to UTF-16BE, \x00\xd8@\x00 is invalid as UTF-16LE. ;TI",# The problem is detected by 4th byte. ;TI"7ec = Encoding::Converter.new("UTF-16LE", "UTF-8") ;TI"@ec.primitive_convert(src="\x00\xd8@\x00", dst="", nil, 10) ;TI"p ec.primitive_errinfo ;TI"L#=> [:invalid_byte_sequence, "UTF-16LE", "UTF-8", "\x00\xD8", "@\x00"] ;TI" p src ;TI" #=> "";T; 0: @fileI"transcode.c;T:0@omit_headings_from_table_of_contents_below0I"#ec.primitive_errinfo -> array ;T0[I"();T@ZFI"Converter;TcRDoc::NormalClass00PKKw]צ`-**new-c.rinu[U:RDoc::AnyMethod[iI"new:ETI"Encoding::Converter::new;TT: privateo:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"possible options elements:;To:RDoc::Markup::Verbatim; [I"hash form: ;TI"S :invalid => nil # raise error on invalid byte sequence (default) ;TI"B :invalid => :replace # replace invalid byte sequence ;TI"R :undef => nil # raise error on undefined conversion (default) ;TI"A :undef => :replace # replace undefined conversion ;TI"Z :replace => string # replacement string ("?" or "\uFFFD" if not specified) ;TI"O :newline => :universal # decorator for converting CRLF and CR to LF ;TI"H :newline => :crlf # decorator for converting LF to CRLF ;TI"F :newline => :cr # decorator for converting LF to CR ;TI"O :universal_newline => true # decorator for converting CRLF and CR to LF ;TI"H :crlf_newline => true # decorator for converting LF to CRLF ;TI"F :cr_newline => true # decorator for converting LF to CR ;TI"< :xml => :text # escape as XML CharData. ;TI"; :xml => :attr # escape as XML AttValue ;TI"integer form: ;TI", Encoding::Converter::INVALID_REPLACE ;TI"* Encoding::Converter::UNDEF_REPLACE ;TI". Encoding::Converter::UNDEF_HEX_CHARREF ;TI"8 Encoding::Converter::UNIVERSAL_NEWLINE_DECORATOR ;TI"3 Encoding::Converter::CRLF_NEWLINE_DECORATOR ;TI"1 Encoding::Converter::CR_NEWLINE_DECORATOR ;TI"/ Encoding::Converter::XML_TEXT_DECORATOR ;TI"7 Encoding::Converter::XML_ATTR_CONTENT_DECORATOR ;TI"5 Encoding::Converter::XML_ATTR_QUOTE_DECORATOR ;T: @format0o; ; [I"HEncoding::Converter.new creates an instance of Encoding::Converter.;To:RDoc::Markup::BlankLineo; ; [I"DSource_encoding and destination_encoding should be a string or ;TI"Encoding object.;T@+o; ; [I"-opt should be nil, a hash or an integer.;T@+o; ; [I""convpath should be an array. ;TI"convpath may contain;To:RDoc::Markup::List: @type: BULLET: @items[o:RDoc::Markup::ListItem: @label0; [o; ; [I"Etwo-element arrays which contain encodings or encoding names, or;To;;0; [o; ; [I"*strings representing decorator names.;T@+o; ; [ I"9Encoding::Converter.new optionally takes an option. ;TI"0The option should be a hash or an integer. ;TI"7The option hash can contain :invalid => nil, etc. ;TI"BThe option integer should be logical-or of constants such as ;TI"/Encoding::Converter::INVALID_REPLACE, etc.;T@+o;;: LABEL;[o;;[I":invalid => nil;T; [o; ; [I"GRaise error on invalid byte sequence. This is a default behavior.;To;;[I":invalid => :replace;T; [o; ; [I"9Replace invalid byte sequence by replacement string.;To;;[I":undef => nil;T; [o; ; [I"^Raise an error if a character in source_encoding is not defined in destination_encoding. ;TI" This is a default behavior.;To;;[I":undef => :replace;T; [o; ; [I"QReplace undefined character in destination_encoding with replacement string.;To;;[I":replace => string;T; [o; ; [I"%Specify the replacement string. ;TI"QIf not specified, "\uFFFD" is used for Unicode encodings and "?" for others.;To;;[I":universal_newline => true;T; [o; ; [I"Convert CRLF and CR to LF.;To;;[I":crlf_newline => true;T; [o; ; [I"Convert LF to CRLF.;To;;[I":cr_newline => true;T; [o; ; [I"Convert LF to CR.;To;;[I":xml => :text;T; [o; ; [I"Escape as XML CharData. ;TI"2This form can be used as an HTML 4.0 #PCDATA.;To;;;;[ o;;0; [o; ; [I"'&' -> '&';To;;0; [o; ; [I"'<' -> '<';To;;0; [o; ; [I"'>' -> '>';To;;0; [o; ; [I"Wundefined characters in destination_encoding -> hexadecimal CharRef such as &#xHH;;To;;[I":xml => :attr;T; [o; ; [I"Escape as XML AttValue. ;TI".The converted result is quoted as "...". ;TI":This form can be used as an HTML 4.0 attribute value.;To;;;;[ o;;0; [o; ; [I"'&' -> '&';To;;0; [o; ; [I"'<' -> '<';To;;0; [o; ; [I"'>' -> '>';To;;0; [o; ; [I"'"' -> '"';To;;0; [o; ; [I"Wundefined characters in destination_encoding -> hexadecimal CharRef such as &#xHH;;T@+o; ; [I"Examples:;To; ; [I"# UTF-16BE to UTF-8 ;TI"7ec = Encoding::Converter.new("UTF-16BE", "UTF-8") ;TI" ;TI"I# Usually, decorators such as newline conversion are inserted last. ;TI"Sec = Encoding::Converter.new("UTF-16BE", "UTF-8", :universal_newline => true) ;TI"Cp ec.convpath #=> [[#, #], ;TI"- # "universal_newline"] ;TI" ;TI"8# But, if the last encoding is ASCII incompatible, ;TI";# decorators are inserted before the last conversion. ;TI"Nec = Encoding::Converter.new("UTF-8", "UTF-16BE", :crlf_newline => true) ;TI"(p ec.convpath #=> ["crlf_newline", ;TI"C # [#, #]] ;TI" ;TI"2# Conversion path can be specified directly. ;TI"eec = Encoding::Converter.new(["universal_newline", ["EUC-JP", "UTF-8"], ["UTF-8", "UTF-16BE"]]) ;TI"-p ec.convpath #=> ["universal_newline", ;TI"A # [#, #], ;TI"B # [#, #]];T; 0: @fileI"transcode.c;T:0@omit_headings_from_table_of_contents_below0I"Encoding::Converter.new(source_encoding, destination_encoding) Encoding::Converter.new(source_encoding, destination_encoding, opt) Encoding::Converter.new(convpath) ;T0[I" (*args);T@FI"Converter;TcRDoc::NormalClass00PKKw]ִuucdesc-Converter.rinu[U:RDoc::NormalClass[iI"Converter:ETI"Encoding::Converter;TI" Object;To:RDoc::Markup::Document: @parts[o;;[o:RDoc::Markup::Paragraph;[I"Encoding conversion class.;T: @fileI"transcode.c;T:0@omit_headings_from_table_of_contents_below0; 0; 0[[U:RDoc::Constant[iI"INVALID_MASK;TI"&Encoding::Converter::INVALID_MASK;T: public0o;;[o; ;[I"INVALID_MASK;To:RDoc::Markup::BlankLineo; ;[I"$Mask for invalid byte sequences;T; @; 0@@cRDoc::NormalClass0U; [iI"INVALID_REPLACE;TI")Encoding::Converter::INVALID_REPLACE;T; 0o;;[o; ;[I"INVALID_REPLACE;T@o; ;[I"#Replace invalid byte sequences;T; @; 0@@@!0U; [iI"UNDEF_MASK;TI"$Encoding::Converter::UNDEF_MASK;T; 0o;;[o; ;[I"UNDEF_MASK;T@o; ;[I"FMask for a valid character in the source encoding but no related ;TI"*character(s) in destination encoding.;T; @; 0@@@!0U; [iI"UNDEF_REPLACE;TI"'Encoding::Converter::UNDEF_REPLACE;T; 0o;;[o; ;[I"UNDEF_REPLACE;T@o; ;[I"KReplace byte sequences that are undefined in the destination encoding.;T; @; 0@@@!0U; [iI"UNDEF_HEX_CHARREF;TI"+Encoding::Converter::UNDEF_HEX_CHARREF;T; 0o;;[o; ;[I"UNDEF_HEX_CHARREF;T@o; ;[I"KReplace byte sequences that are undefined in the destination encoding ;TI"Iwith an XML hexadecimal character reference. This is valid for XML ;TI"conversion.;T; @; 0@@@!0U; [iI"PARTIAL_INPUT;TI"'Encoding::Converter::PARTIAL_INPUT;T; 0o;;[o; ;[I"PARTIAL_INPUT;T@o; ;[I"?Indicates the source may be part of a larger string. See ;TI"&primitive_convert for an example.;T; @; 0@@@!0U; [iI"AFTER_OUTPUT;TI"&Encoding::Converter::AFTER_OUTPUT;T; 0o;;[o; ;[I"AFTER_OUTPUT;T@o; ;[I"IStop converting after some output is complete but before all of the ;TI"?input was consumed. See primitive_convert for an example.;T; @; 0@@@!0U; [iI" UNIVERSAL_NEWLINE_DECORATOR;TI"5Encoding::Converter::UNIVERSAL_NEWLINE_DECORATOR;T; 0o;;[o; ;[I" UNIVERSAL_NEWLINE_DECORATOR;T@o; ;[I"/Decorator for converting CRLF and CR to LF;T; @; 0@@@!0U; [iI"CRLF_NEWLINE_DECORATOR;TI"0Encoding::Converter::CRLF_NEWLINE_DECORATOR;T; 0o;;[o; ;[I"CRLF_NEWLINE_DECORATOR;T@o; ;[I"(Decorator for converting LF to CRLF;T; @; 0@@@!0U; [iI"CR_NEWLINE_DECORATOR;TI".Encoding::Converter::CR_NEWLINE_DECORATOR;T; 0o;;[o; ;[I"CR_NEWLINE_DECORATOR;T@o; ;[I"&Decorator for converting LF to CR;T; @; 0@@@!0U; [iI"XML_TEXT_DECORATOR;TI",Encoding::Converter::XML_TEXT_DECORATOR;T; 0o;;[o; ;[I"XML_TEXT_DECORATOR;T@o; ;[I"Escape as XML CharData;T; @; 0@@@!0U; [iI"XML_ATTR_CONTENT_DECORATOR;TI"4Encoding::Converter::XML_ATTR_CONTENT_DECORATOR;T; 0o;;[o; ;[I"XML_ATTR_CONTENT_DECORATOR;T@o; ;[I"Escape as XML AttValue;T; @; 0@@@!0U; [iI"XML_ATTR_QUOTE_DECORATOR;TI"2Encoding::Converter::XML_ATTR_QUOTE_DECORATOR;T; 0o;;[o; ;[I"XML_ATTR_QUOTE_DECORATOR;T@o; ;[I"Escape as XML AttValue;T; @; 0@@@!0[[[I" class;T[[; [[:protected[[: private[[I"asciicompat_encoding;TI"transcode.c;T[I"new;T@[I"search_convpath;T@[I" instance;T[[; [[;[[;[[I"==;T@[I" convert;T@[I" convpath;T@[I"destination_encoding;T@[I" finish;T@[I"insert_output;T@[I" inspect;T@[I"last_error;T@[I"primitive_convert;T@[I"primitive_errinfo;T@[I" putback;T@[I"replacement;T@[I"replacement=;T@[I"source_encoding;T@[[U:RDoc::Context::Section[i0o;;[; 0; 0[I"encoding.c;TI" Encoding;T@!PKKw]seereplacement-i.rinu[U:RDoc::AnyMethod[iI"replacement:ETI"$Encoding::Converter#replacement;TF: privateo:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"$Returns the replacement string.;To:RDoc::Markup::BlankLineo:RDoc::Markup::Verbatim; [ I"8ec = Encoding::Converter.new("euc-jp", "us-ascii") ;TI"!p ec.replacement #=> "?" ;TI" ;TI"5ec = Encoding::Converter.new("euc-jp", "utf-8") ;TI"%p ec.replacement #=> "\uFFFD";T: @format0: @fileI"transcode.c;T:0@omit_headings_from_table_of_contents_below0I"ec.replacement -> string ;T0[I"();T@FI"Converter;TcRDoc::NormalClass00PKKw]Clast_error-i.rinu[U:RDoc::AnyMethod[iI"last_error:ETI"#Encoding::Converter#last_error;TF: privateo:RDoc::Markup::Document: @parts[ o:RDoc::Markup::Paragraph; [I":Returns an exception object for the last conversion. ;TI"AReturns nil if the last conversion did not produce an error.;To:RDoc::Markup::BlankLineo; ; [ I""error" means that ;TI"SEncoding::InvalidByteSequenceError and Encoding::UndefinedConversionError for ;TI"%Encoding::Converter#convert and ;TI"M:invalid_byte_sequence, :incomplete_input and :undefined_conversion for ;TI"+Encoding::Converter#primitive_convert.;T@o:RDoc::Markup::Verbatim; [ I"9ec = Encoding::Converter.new("utf-8", "iso-8859-1") ;TI"Up ec.primitive_convert(src="\xf1abcd", dst="") #=> :invalid_byte_sequence ;TI"ep ec.last_error #=> # ;TI"Wp ec.primitive_convert(src, dst, nil, 1) #=> :destination_buffer_full ;TI"!p ec.last_error #=> nil;T: @format0: @fileI"transcode.c;T:0@omit_headings_from_table_of_contents_below0I"'ec.last_error -> exception or nil ;T0[I"();T@FI"Converter;TcRDoc::NormalClass00PKKw]MTdestination_encoding-i.rinu[U:RDoc::AnyMethod[iI"destination_encoding:ETI"-Encoding::Converter#destination_encoding;TF: privateo:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I" encoding ;T0[I"();T@FI"Converter;TcRDoc::NormalClass00PKKw]Dʱsearch_convpath-c.rinu[U:RDoc::AnyMethod[iI"search_convpath:ETI")Encoding::Converter::search_convpath;TT: privateo:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"Returns a conversion path.;To:RDoc::Markup::BlankLineo:RDoc::Markup::Verbatim; [I"Cp Encoding::Converter.search_convpath("ISO-8859-1", "EUC-JP") ;TI"7#=> [[#, #], ;TI"3# [#, #]] ;TI" ;TI"\p Encoding::Converter.search_convpath("ISO-8859-1", "EUC-JP", universal_newline: true) ;TI"or ;TI"Xp Encoding::Converter.search_convpath("ISO-8859-1", "EUC-JP", newline: :universal) ;TI"7#=> [[#, #], ;TI"3# [#, #], ;TI"# "universal_newline"] ;TI" ;TI"^p Encoding::Converter.search_convpath("ISO-8859-1", "UTF-32BE", universal_newline: true) ;TI"or ;TI"Zp Encoding::Converter.search_convpath("ISO-8859-1", "UTF-32BE", newline: :universal) ;TI"7#=> [[#, #], ;TI"# "universal_newline", ;TI"4# [#, #]];T: @format0: @fileI"transcode.c;T:0@omit_headings_from_table_of_contents_below0I"Encoding::Converter.search_convpath(source_encoding, destination_encoding) -> ary Encoding::Converter.search_convpath(source_encoding, destination_encoding, opt) -> ary ;T0[I" (*args);T@"FI"Converter;TcRDoc::NormalClass00PKKw]Ju\\ finish-i.rinu[U:RDoc::AnyMethod[iI" finish:ETI"Encoding::Converter#finish;TF: privateo:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"Finishes the converter. ;TI"6It returns the last part of the converted string.;To:RDoc::Markup::BlankLineo:RDoc::Markup::Verbatim; [I":ec = Encoding::Converter.new("utf-8", "iso-2022-jp") ;TI".p ec.convert("\u3042") #=> "\e$B$\"" ;TI"*p ec.finish #=> "\e(B";T: @format0: @fileI"transcode.c;T:0@omit_headings_from_table_of_contents_below0I"ec.finish -> string ;T0[I"();T@FI"Converter;TcRDoc::NormalClass00PKKw]'/9insert_output-i.rinu[U:RDoc::AnyMethod[iI"insert_output:ETI"&Encoding::Converter#insert_output;TF: privateo:RDoc::Markup::Document: @parts[ o:RDoc::Markup::Paragraph; [I"1Inserts string into the encoding converter. ;TI"BThe string will be converted to the destination encoding and ;TI"!output on later conversions.;To:RDoc::Markup::BlankLineo; ; [I".If the destination encoding is stateful, ;TI"Istring is converted according to the state and the state is updated.;T@o; ; [I"DThis method should be used only when a conversion error occurs.;T@o:RDoc::Markup::Verbatim; [I"9ec = Encoding::Converter.new("utf-8", "iso-8859-1") ;TI",src = "HIRAGANA LETTER A is \u{3042}." ;TI"dst = "" ;TI"Cp ec.primitive_convert(src, dst) #=> :undefined_conversion ;TI"Lputs "[#{dst.dump}, #{src.dump}]" #=> ["HIRAGANA LETTER A is ", "."] ;TI"ec.insert_output("") ;TI"7p ec.primitive_convert(src, dst) #=> :finished ;TI"Qputs "[#{dst.dump}, #{src.dump}]" #=> ["HIRAGANA LETTER A is .", ""] ;TI" ;TI":ec = Encoding::Converter.new("utf-8", "iso-2022-jp") ;TI"Wsrc = "\u{306F 3041 3068 2661 3002}" # U+2661 is not representable in iso-2022-jp ;TI"dst = "" ;TI"Cp ec.primitive_convert(src, dst) #=> :undefined_conversion ;TI"jputs "[#{dst.dump}, #{src.dump}]" #=> ["\e$B$O$!$H".force_encoding("ISO-2022-JP"), "\xE3\x80\x82"] ;TI"Pec.insert_output "?" # state change required to output "?". ;TI"7p ec.primitive_convert(src, dst) #=> :finished ;TI"lputs "[#{dst.dump}, #{src.dump}]" #=> ["\e$B$O$!$H\e(B?\e$B!#\e(B".force_encoding("ISO-2022-JP"), ""];T: @format0: @fileI"transcode.c;T:0@omit_headings_from_table_of_contents_below0I"%ec.insert_output(string) -> nil ;T0[I" (p1);T@+FI"Converter;TcRDoc::NormalClass00PKKw]Ysource_encoding-i.rinu[U:RDoc::AnyMethod[iI"source_encoding:ETI"(Encoding::Converter#source_encoding;TF: privateo:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"7Returns the source encoding as an Encoding object.;T: @fileI"transcode.c;T:0@omit_headings_from_table_of_contents_below0I"$ec.source_encoding -> encoding ;T0[I"();T@FI"Converter;TcRDoc::NormalClass00PKKw]OqIIreplacement%3d-i.rinu[U:RDoc::AnyMethod[iI"replacement=:ETI"%Encoding::Converter#replacement=;TF: privateo:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"!Sets the replacement string.;To:RDoc::Markup::BlankLineo:RDoc::Markup::Verbatim; [I"Kec = Encoding::Converter.new("utf-8", "us-ascii", :undef => :replace) ;TI" ec.replacement = "" ;TI"6p ec.convert("a \u3042 b") #=> "a b";T: @format0: @fileI"transcode.c;T:0@omit_headings_from_table_of_contents_below0I"ec.replacement = string ;T0[I" (p1);T@FI"Converter;TcRDoc::NormalClass00PKKw]z %3d%3d-i.rinu[U:RDoc::AnyMethod[iI"==:ETI"Encoding::Converter#==;TF: privateo:RDoc::Markup::Document: @parts[: @fileI"transcode.c;T:0@omit_headings_from_table_of_contents_below0I"(ec == other -> true or false;T0[I" (p1);T@ FI"Converter;TcRDoc::NormalClass00PKKw]Bw convert-i.rinu[U:RDoc::AnyMethod[iI" convert:ETI" Encoding::Converter#convert;TF: privateo:RDoc::Markup::Document: @parts[ o:RDoc::Markup::Paragraph; [I"9Convert source_string and return destination_string.;To:RDoc::Markup::BlankLineo; ; [I"3source_string is assumed as a part of source. ;TI"9i.e. :partial_input=>true is specified internally. ;TI"'finish method should be used last.;T@o:RDoc::Markup::Verbatim; [I"5ec = Encoding::Converter.new("utf-8", "euc-jp") ;TI"7puts ec.convert("\u3042").dump #=> "\xA4\xA2" ;TI"/puts ec.finish.dump #=> "" ;TI" ;TI"5ec = Encoding::Converter.new("euc-jp", "utf-8") ;TI"/puts ec.convert("\xA4").dump #=> "" ;TI";puts ec.convert("\xA2").dump #=> "\xE3\x81\x82" ;TI"/puts ec.finish.dump #=> "" ;TI" ;TI":ec = Encoding::Converter.new("utf-8", "iso-2022-jp") ;TI"Mputs ec.convert("\xE3").dump #=> "".force_encoding("ISO-2022-JP") ;TI"Mputs ec.convert("\x81").dump #=> "".force_encoding("ISO-2022-JP") ;TI"Tputs ec.convert("\x82").dump #=> "\e$B$\"".force_encoding("ISO-2022-JP") ;TI"Qputs ec.finish.dump #=> "\e(B".force_encoding("ISO-2022-JP") ;T: @format0o; ; [ I""If a conversion error occur, ;TI"+Encoding::UndefinedConversionError or ;TI"3Encoding::InvalidByteSequenceError is raised. ;TI"NEncoding::Converter#convert doesn't supply methods to recover or restart ;TI"from these exceptions. ;TI"6When you want to handle these conversion errors, ;TI"/use Encoding::Converter#primitive_convert.;T: @fileI"transcode.c;T:0@omit_headings_from_table_of_contents_below0I"5ec.convert(source_string) -> destination_string ;T0[I" (p1);T@-FI"Converter;TcRDoc::NormalClass00PKKw]K putback-i.rinu[PKKw]gee(primitive_convert-i.rinu[PKKw]iLasciicompat_encoding-c.rinu[PKKw]R%% convpath-i.rinu[PKKw]A}++ "inspect-i.rinu[PKKw]>++~$primitive_errinfo-i.rinu[PKKw]צ`-**2new-c.rinu[PKKw]ִuuQIcdesc-Converter.rinu[PKKw]seeXreplacement-i.rinu[PKKw]CZlast_error-i.rinu[PKKw]MT_destination_encoding-i.rinu[PKKw]Dʱ\asearch_convpath-c.rinu[PKKw]Ju\\ Qgfinish-i.rinu[PKKw]'/9iinsert_output-i.rinu[PKKw]Y2qsource_encoding-i.rinu[PKKw]OqIIrreplacement%3d-i.rinu[PKKw]z u%3d%3d-i.rinu[PKKw]Bw vconvert-i.rinu[PK}