ÿØÿà JFIF    ÿÛ „ ( %!1!%*+...983,7(-.- PK4 ],Converter/putback-i.rinu[U:RDoc::AnyMethod[iI" putback:ETI" Encoding::Converter#putback;TF: publico:RDoc::Markup::Document: @parts[ o:RDoc::Markup::Paragraph; [I" call-seq;To:RDoc::Markup::Verbatim; [I"-ec.putback -> string ;TI"-ec.putback(max_numbytes) -> string ;T: @format0o; ; [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; 0: @fileI"transcode.c;T:0@omit_headings_from_table_of_contents_below000[I"(p1 = v1);T@(FI"Converter;TcRDoc::NormalClass00PK4 ]׉Ddd Converter/primitive_convert-i.rinu[U:RDoc::AnyMethod[iI"primitive_convert:ETI"*Encoding::Converter#primitive_convert;TF: publico: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::NormalClass00PK4 ]R#Converter/asciicompat_encoding-c.rinu[U:RDoc::AnyMethod[iI"asciicompat_encoding:ETI".Encoding::Converter::asciicompat_encoding;TT: publico: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::NormalClass00PK4 ]0 $$Converter/convpath-i.rinu[U:RDoc::AnyMethod[iI" convpath:ETI"!Encoding::Converter#convpath;TF: publico: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::NormalClass00PK4 ]>**Converter/inspect-i.rinu[U:RDoc::AnyMethod[iI" inspect:ETI" Encoding::Converter#inspect;TF: publico: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::NormalClass00PK4 ]}-&& Converter/primitive_errinfo-i.rinu[U:RDoc::AnyMethod[iI"primitive_errinfo:ETI"*Encoding::Converter#primitive_errinfo;TF: publico: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"A#=> [:invalid_byte_sequence, "EUC-JP", "UTF-8", "\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::NormalClass00PK4 ]w`i''Converter/new-c.rinu[U:RDoc::AnyMethod[iI"new:ETI"Encoding::Converter::new;TT: publico: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"1This form can be used as a 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"9This form can be used as a 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::NormalClass00PK4 ]X ==Converter/cdesc-Converter.rinu[U:RDoc::NormalClass[iI"Converter:ETI"Encoding::Converter;TI" Data;To:RDoc::Markup::Document: @parts[o;;[: @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;T00o;;[o:RDoc::Markup::Paragraph;[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;T00o;;[o; ;[I"INVALID_REPLACE;T@o; ;[I"#Replace invalid byte sequences;T; @; 0@@@0U; [iI"UNDEF_MASK;TI"$Encoding::Converter::UNDEF_MASK;T00o;;[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;T00o;;[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;T00o;;[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;T00o;;[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;T00o;;[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;T00o;;[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;T00o;;[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;T00o;;[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;T00o;;[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;T00o;;[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;T00o;;[o; ;[I"XML_ATTR_QUOTE_DECORATOR;T@o; ;[I"Escape as XML AttValue;T; @; 0@@@0[[[I" class;T[[: public[[I"asciicompat_encoding;TI"transcode.c;T[I"new;T@[I"search_convpath;T@[:protected[[: private[[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@PK4 ]EPddConverter/replacement-i.rinu[U:RDoc::AnyMethod[iI"replacement:ETI"$Encoding::Converter#replacement;TF: publico: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::NormalClass00PK4 ]CConverter/last_error-i.rinu[U:RDoc::AnyMethod[iI"last_error:ETI"#Encoding::Converter#last_error;TF: publico: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::NormalClass00PK4 ]8:#Converter/destination_encoding-i.rinu[U:RDoc::AnyMethod[iI"destination_encoding:ETI"-Encoding::Converter#destination_encoding;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I" encoding ;T0[I"();T@FI"Converter;TcRDoc::NormalClass00PK4 ]G}3ްConverter/search_convpath-c.rinu[U:RDoc::AnyMethod[iI"search_convpath:ETI")Encoding::Converter::search_convpath;TT: publico: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::NormalClass00PK4 ]z7[[Converter/finish-i.rinu[U:RDoc::AnyMethod[iI" finish:ETI"Encoding::Converter#finish;TF: publico: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::NormalClass00PK4 ]$:Converter/insert_output-i.rinu[U:RDoc::AnyMethod[iI"insert_output:ETI"&Encoding::Converter#insert_output;TF: publico: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::NormalClass00PK4 ]2Converter/source_encoding-i.rinu[U:RDoc::AnyMethod[iI"source_encoding:ETI"(Encoding::Converter#source_encoding;TF: publico: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::NormalClass00PK4 ]nijHHConverter/replacement%3d-i.rinu[U:RDoc::AnyMethod[iI"replacement=:ETI"%Encoding::Converter#replacement=;TF: publico: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::NormalClass00PK4 ]%)|Converter/%3d%3d-i.rinu[U:RDoc::AnyMethod[iI"==:ETI"Encoding::Converter#==;TF: publico: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::NormalClass00PK4 ]ZConverter/convert-i.rinu[U:RDoc::AnyMethod[iI" convert:ETI" Encoding::Converter#convert;TF: publico: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::NormalClass00PK4 ]replicate-i.rinu[U:RDoc::AnyMethod[iI"replicate:ETI"Encoding#replicate;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"BReturns a replicated encoding of _enc_ whose name is _name_. ;TI"DThe new encoding should have the same byte structure of _enc_. ;TI"@If _name_ is used by another encoding, raise ArgumentError.;T: @fileI"encoding.c;T:0@omit_headings_from_table_of_contents_below0I"%enc.replicate(name) -> encoding ;T0[I" (p1);T@FI" Encoding;TcRDoc::NormalClass00PK4 ]Ǵ00 inspect-i.rinu[U:RDoc::AnyMethod[iI" inspect:ETI"Encoding#inspect;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"DReturns a string which represents the encoding for programmers.;To:RDoc::Markup::BlankLineo:RDoc::Markup::Verbatim; [I";Encoding::UTF_8.inspect #=> "#" ;TI"HEncoding::ISO_2022_JP.inspect #=> "#";T: @format0: @fileI"encoding.c;T:0@omit_headings_from_table_of_contents_below0I"enc.inspect -> string ;T0[I"();T@FI" Encoding;TcRDoc::NormalClass00PK4 ])V names-i.rinu[U:RDoc::AnyMethod[iI" names:ETI"Encoding#names;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I":Returns the list of name and aliases of the encoding.;To:RDoc::Markup::BlankLineo:RDoc::Markup::Verbatim; [I"NEncoding::WINDOWS_31J.names #=> ["Windows-31J", "CP932", "csWindows31J"];T: @format0: @fileI"encoding.c;T:0@omit_headings_from_table_of_contents_below0I"enc.names -> array ;T0[I"();T@FI" Encoding;TcRDoc::NormalClass00PK4 ]- UUdefault_internal%3d-c.rinu[U:RDoc::AnyMethod[iI"default_internal=:ETI" Encoding::default_internal=;TT: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [ I"NSets default internal encoding or removes default internal encoding when ;TI"Ppassed nil. You should not set Encoding::default_internal in ruby code as ;TI"Mstrings created before changing the value may have a different encoding ;TI"Dfrom strings created after the change. Instead you should use ;TI"Gruby -E to invoke ruby with the correct default_internal.;To:RDoc::Markup::BlankLineo; ; [I"PSee Encoding::default_internal for information on how the default internal ;TI"encoding is used.;T: @fileI"encoding.c;T:0@omit_headings_from_table_of_contents_below0I",Encoding.default_internal = enc or nil ;T0[I" (p1);T@FI" Encoding;TcRDoc::NormalClass00PK4 ]3 aliases-c.rinu[U:RDoc::AnyMethod[iI" aliases:ETI"Encoding::aliases;TT: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"MReturns the hash of available encoding alias and original encoding name.;To:RDoc::Markup::BlankLineo:RDoc::Markup::Verbatim; [I"Encoding.aliases ;TI"U#=> {"BINARY"=>"ASCII-8BIT", "ASCII"=>"US-ASCII", "ANSI_X3.4-1986"=>"US-ASCII", ;TI"J "SJIS"=>"Shift_JIS", "eucJP"=>"EUC-JP", "CP932"=>"Windows-31J"};T: @format0: @fileI"encoding.c;T:0@omit_headings_from_table_of_contents_below0I"IEncoding.aliases -> {"alias1" => "orig1", "alias2" => "orig2", ...} ;T0[I"();T@FI" Encoding;TcRDoc::NormalClass00PK4 ]  list-c.rinu[U:RDoc::AnyMethod[iI" list:ETI"Encoding::list;TT: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"*Returns the list of loaded encodings.;To:RDoc::Markup::BlankLineo:RDoc::Markup::Verbatim; [I"Encoding.list ;TI"5#=> [#, #, ;TI", #] ;TI" ;TI"Encoding.find("US-ASCII") ;TI"#=> # ;TI" ;TI"Encoding.list ;TI"5#=> [#, #, ;TI"A #, #];T: @format0: @fileI"encoding.c;T:0@omit_headings_from_table_of_contents_below0I"(Encoding.list -> [enc1, enc2, ...] ;T0[I"();T@FI" Encoding;TcRDoc::NormalClass00PK4 ]JY??.CompatibilityError/cdesc-CompatibilityError.rinu[U:RDoc::NormalClass[iI"CompatibilityError:ETI"!Encoding::CompatibilityError;TI"EncodingError;To:RDoc::Markup::Document: @parts[o;;[o:RDoc::Markup::Paragraph;[I"GRaised by Encoding and String methods when the source encoding is ;TI"+incompatible with the target encoding.;T: @fileI" error.c;T:0@omit_headings_from_table_of_contents_below0; 0; 0[[[[[I" class;T[[: public[[:protected[[: private[[I" instance;T[[; [[; [[;[[[U:RDoc::Context::Section[i0o;;[; 0; 0[I"encoding.c;TI" Encoding;TcRDoc::NormalClassPK4 ]@@d to_s-i.rinu[U:RDoc::AnyMethod[iI" to_s:ETI"Encoding#to_s;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"&Returns the name of the encoding.;To:RDoc::Markup::BlankLineo:RDoc::Markup::Verbatim; [I"*Encoding::UTF_8.name #=> "UTF-8";T: @format0: @fileI"encoding.c;T:0@omit_headings_from_table_of_contents_below0I"enc.to_s -> string;T0[I"();T@FI" Encoding;TcRDoc::NormalClass00PK4 ]_ name-i.rinu[U:RDoc::AnyMethod[iI" name:ETI"Encoding#name;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"&Returns the name of the encoding.;To:RDoc::Markup::BlankLineo:RDoc::Markup::Verbatim; [I"*Encoding::UTF_8.name #=> "UTF-8";T: @format0: @fileI"encoding.c;T:0@omit_headings_from_table_of_contents_below0I"enc.name -> string;T0[I"();T@FI" Encoding;TcRDoc::NormalClass00PK4 ]m4 find-c.rinu[U:RDoc::AnyMethod[iI" find:ETI"Encoding::find;TT: publico:RDoc::Markup::Document: @parts[ o:RDoc::Markup::Paragraph; [I"5Search the encoding with specified name. ;TI"$name should be a string.;To:RDoc::Markup::BlankLineo:RDoc::Markup::Verbatim; [I"9Encoding.find("US-ASCII") #=> # ;T: @format0o; ; [I"CNames which this method accept are encoding names and aliases ;TI"(including following special aliases;T@o:RDoc::Markup::List: @type: NOTE: @items[ o:RDoc::Markup::ListItem: @label[I""external";T; [o; ; [I"default external encoding;To;;[I""internal";T; [o; ; [I"default internal encoding;To;;[I" "locale";T; [o; ; [I"locale encoding;To;;[I""filesystem";T; [o; ; [I"filesystem encoding;T@o; ; [ I"CAn ArgumentError is raised when no encoding with name. ;TI"EOnly Encoding.find("internal") however returns nil ;TI"Iwhen no encoding named "internal", in other words, when Ruby has no ;TI"default internal encoding.;T: @fileI"encoding.c;T:0@omit_headings_from_table_of_contents_below0I""Encoding.find(string) -> enc ;T0[I" (p1);T@;FI" Encoding;TcRDoc::NormalClass00PK4 ]compatible%3f-c.rinu[U:RDoc::AnyMethod[iI"compatible?:ETI"Encoding::compatible?;TT: publico:RDoc::Markup::Document: @parts[ o:RDoc::Markup::Paragraph; [I"-Checks the compatibility of two objects.;To:RDoc::Markup::BlankLineo; ; [I"GIf the objects are both strings they are compatible when they are ;TI"Oconcatenatable. The encoding of the concatenated string will be returned ;TI"1if they are compatible, nil if they are not.;T@o:RDoc::Markup::Verbatim; [ I"DEncoding.compatible?("\xa1".force_encoding("iso-8859-1"), "b") ;TI" #=> # ;TI" ;TI"Encoding.compatible?( ;TI", "\xa1".force_encoding("iso-8859-1"), ;TI", "\xa1\xa1".force_encoding("euc-jp")) ;TI" #=> nil ;T: @format0o; ; [I"MIf the objects are non-strings their encodings are compatible when they ;TI"have an encoding and:;To:RDoc::Markup::List: @type: BULLET: @items[o:RDoc::Markup::ListItem: @label0; [o; ; [I"+Either encoding is US-ASCII compatible;To;;0; [o; ; [I"-One of the encodings is a 7-bit encoding;T: @fileI"encoding.c;T:0@omit_headings_from_table_of_contents_below0I"4Encoding.compatible?(obj1, obj2) -> enc or nil ;T0[I" (p1, p2);T@-FI" Encoding;TcRDoc::NormalClass00PK4 ]bdefault_internal-c.rinu[U:RDoc::AnyMethod[iI"default_internal:ETI"Encoding::default_internal;TT: publico:RDoc::Markup::Document: @parts[ o:RDoc::Markup::Paragraph; [I"KReturns default internal encoding. Strings will be transcoded to the ;TI"Odefault internal encoding in the following places if the default internal ;TI"encoding is not nil:;To:RDoc::Markup::BlankLineo:RDoc::Markup::List: @type: BULLET: @items[o:RDoc::Markup::ListItem: @label0; [o; ; [I"CSV;To;;0; [o; ; [I"%Etc.sysconfdir and Etc.systmpdir;To;;0; [o; ; [I"File data read from disk;To;;0; [o; ; [I"File names from Dir;To;;0; [o; ; [I"Integer#chr;To;;0; [o; ; [I"&String#inspect and Regexp#inspect;To;;0; [o; ; [I"#Strings returned from Readline;To;;0; [o; ; [I"Strings returned from SDBM;To;;0; [o; ; [I"Time#zone;To;;0; [o; ; [I"Values from ENV;To;;0; [o; ; [I"+Values in ARGV including $PROGRAM_NAME;To;;0; [o; ; [I" __FILE__;T@o; ; [I"LAdditionally String#encode and String#encode! use the default internal ;TI"&encoding if no encoding is given.;T@o; ; [I"NThe locale encoding (__ENCODING__), not default_internal, is used as the ;TI"!encoding of created strings.;T@o; ; [I"DEncoding::default_internal is initialized by the source file's ;TI"$internal_encoding or -E option.;T: @fileI"encoding.c;T:0@omit_headings_from_table_of_contents_below0I"&Encoding.default_internal -> enc ;T0[I"();T@[FI" Encoding;TcRDoc::NormalClass00PK4 ],E:UndefinedConversionError/cdesc-UndefinedConversionError.rinu[U:RDoc::NormalClass[iI"UndefinedConversionError:ETI"'Encoding::UndefinedConversionError;TI"rb_eEncodingError;To:RDoc::Markup::Document: @parts[o;;[o:RDoc::Markup::Paragraph;[I"HRaised by Encoding and String methods when a transcoding operation ;TI" fails.;T: @fileI"transcode.c;T:0@omit_headings_from_table_of_contents_below0; 0; 0[[[[[I" class;T[[: public[[:protected[[: private[[I" instance;T[[; [ [I"destination_encoding;TI"transcode.c;T[I"destination_encoding_name;T@'[I"error_char;T@'[I"source_encoding;T@'[I"source_encoding_name;T@'[; [[;[[[U:RDoc::Context::Section[i0o;;[; 0; 0[I"encoding.c;TI" Encoding;TcRDoc::NormalClassPK4 ](UndefinedConversionError/error_char-i.rinu[U:RDoc::AnyMethod[iI"error_char:ETI"2Encoding::UndefinedConversionError#error_char;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"UReturns the one-character string which cause Encoding::UndefinedConversionError.;To:RDoc::Markup::BlankLineo:RDoc::Markup::Verbatim; [ I":ec = Encoding::Converter.new("ISO-8859-1", "EUC-JP") ;TI" begin ;TI" ec.convert("\xa0") ;TI"/rescue Encoding::UndefinedConversionError ;TI"0 puts $!.error_char.dump #=> "\xC2\xA0" ;TI"7 p $!.error_char.encoding #=> # ;TI"end;T: @format0: @fileI"transcode.c;T:0@omit_headings_from_table_of_contents_below0I"(ecerr.error_char -> string ;T0[I"();T@FI"UndefinedConversionError;TcRDoc::NormalClass00PK4 ] 2UndefinedConversionError/destination_encoding-i.rinu[U:RDoc::AnyMethod[iI"destination_encoding:ETI" string ;T0[I"();T@FI"UndefinedConversionError;TcRDoc::NormalClass00PK4 ]:o7UndefinedConversionError/destination_encoding_name-i.rinu[U:RDoc::AnyMethod[iI"destination_encoding_name:ETI"AEncoding::UndefinedConversionError#destination_encoding_name;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"7Returns the destination encoding name as a string.;T: @fileI"transcode.c;T:0@omit_headings_from_table_of_contents_below0I"7ecerr.destination_encoding_name -> string ;T0[I"();T@FI"UndefinedConversionError;TcRDoc::NormalClass00PK4 ]zFww-UndefinedConversionError/source_encoding-i.rinu[U:RDoc::AnyMethod[iI"source_encoding:ETI"7Encoding::UndefinedConversionError#source_encoding;TF: publico:RDoc::Markup::Document: @parts[ o:RDoc::Markup::Paragraph; [I"7Returns the source encoding as an encoding object.;To:RDoc::Markup::BlankLineo; ; [I"ENote that the result may not be equal to the source encoding of ;TI"Athe encoding converter if the conversion has multiple steps.;T@o:RDoc::Markup::Verbatim; [I"Zec = Encoding::Converter.new("ISO-8859-1", "EUC-JP") # ISO-8859-1 -> UTF-8 -> EUC-JP ;TI" begin ;TI"[ ec.convert("\xa0") # NO-BREAK SPACE, which is available in UTF-8 but not in EUC-JP. ;TI"/rescue Encoding::UndefinedConversionError ;TI"? p $!.source_encoding #=> # ;TI"@ p $!.destination_encoding #=> # ;TI"5 p $!.source_encoding_name #=> "UTF-8" ;TI"6 p $!.destination_encoding_name #=> "EUC-JP" ;TI"end;T: @format0: @fileI"transcode.c;T:0@omit_headings_from_table_of_contents_below0I"4ecerr.source_encoding -> encoding ;T0[I"();T@FI"UndefinedConversionError;TcRDoc::NormalClass00PK4 ]J2UndefinedConversionError/source_encoding_name-i.rinu[U:RDoc::AnyMethod[iI"source_encoding_name:ETI" string ;T0[I"();T@FI"UndefinedConversionError;TcRDoc::NormalClass00PK4 ]ڇ dummy%3f-i.rinu[U:RDoc::AnyMethod[iI" dummy?:ETI"Encoding#dummy?;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [ I"'Returns true for dummy encodings. ;TI"RA dummy encoding is an encoding for which character handling is not properly ;TI"implemented. ;TI"'It is used for stateful encodings.;To:RDoc::Markup::BlankLineo:RDoc::Markup::Verbatim; [I"1Encoding::ISO_2022_JP.dummy? #=> true ;TI"1Encoding::UTF_8.dummy? #=> false;T: @format0: @fileI"encoding.c;T:0@omit_headings_from_table_of_contents_below0I"!enc.dummy? -> true or false ;T0[I"();T@FI" Encoding;TcRDoc::NormalClass00PK4 ]i/-InvalidByteSequenceError/readagain_bytes-i.rinu[U:RDoc::AnyMethod[iI"readagain_bytes:ETI"7Encoding::InvalidByteSequenceError#readagain_bytes;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"WReturns the bytes to be read again when Encoding::InvalidByteSequenceError occurs.;T: @fileI"transcode.c;T:0@omit_headings_from_table_of_contents_below0I"-ecerr.readagain_bytes -> string ;T0[I"();T@FI"InvalidByteSequenceError;TcRDoc::NormalClass00PK4 ]dXaa1InvalidByteSequenceError/incomplete_input%3f-i.rinu[U:RDoc::AnyMethod[iI"incomplete_input?:ETI"9Encoding::InvalidByteSequenceError#incomplete_input?;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"BReturns true if the invalid byte sequence error is caused by ;TI"premature end of string.;To:RDoc::Markup::BlankLineo:RDoc::Markup::Verbatim; [I":ec = Encoding::Converter.new("EUC-JP", "ISO-8859-1") ;TI" ;TI" begin ;TI" ec.convert("abc\xA1z") ;TI"/rescue Encoding::InvalidByteSequenceError ;TI"] p $! #=> # ;TI"+ p $!.incomplete_input? #=> false ;TI" end ;TI" ;TI" begin ;TI" ec.convert("abc\xA1") ;TI" ec.finish ;TI"/rescue Encoding::InvalidByteSequenceError ;TI"X p $! #=> # ;TI"* p $!.incomplete_input? #=> true ;TI"end;T: @format0: @fileI"transcode.c;T:0@omit_headings_from_table_of_contents_below0I"6ecerr.incomplete_input? -> true or false ;T0[I"();T@"FI"InvalidByteSequenceError;TcRDoc::NormalClass00PK4 ]&22InvalidByteSequenceError/destination_encoding-i.rinu[U:RDoc::AnyMethod[iI"destination_encoding:ETI" string ;T0[I"();T@FI"InvalidByteSequenceError;TcRDoc::NormalClass00PK4 ]yjVV:InvalidByteSequenceError/cdesc-InvalidByteSequenceError.rinu[U:RDoc::NormalClass[iI"InvalidByteSequenceError:ETI"'Encoding::InvalidByteSequenceError;TI"rb_eEncodingError;To:RDoc::Markup::Document: @parts[o;;[o:RDoc::Markup::Paragraph;[I"ARaised by Encoding and String methods when the string being ;TI"Etranscoded contains a byte invalid for the either the source or ;TI"target encoding.;T: @fileI"transcode.c;T:0@omit_headings_from_table_of_contents_below0; 0; 0[[[[[I" class;T[[: public[[:protected[[: private[[I" instance;T[[; [ [I"destination_encoding;TI"transcode.c;T[I"destination_encoding_name;T@([I"error_bytes;T@([I"incomplete_input?;T@([I"readagain_bytes;T@([I"source_encoding;T@([I"source_encoding_name;T@([; [[;[[[U:RDoc::Context::Section[i0o;;[; 0; 0[I"encoding.c;TI" Encoding;TcRDoc::NormalClassPK4 ]NrB7InvalidByteSequenceError/destination_encoding_name-i.rinu[U:RDoc::AnyMethod[iI"destination_encoding_name:ETI"AEncoding::InvalidByteSequenceError#destination_encoding_name;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"7Returns the destination encoding name as a string.;T: @fileI"transcode.c;T:0@omit_headings_from_table_of_contents_below0I"7ecerr.destination_encoding_name -> string ;T0[I"();T@FI"InvalidByteSequenceError;TcRDoc::NormalClass00PK4 ]Pww-InvalidByteSequenceError/source_encoding-i.rinu[U:RDoc::AnyMethod[iI"source_encoding:ETI"7Encoding::InvalidByteSequenceError#source_encoding;TF: publico:RDoc::Markup::Document: @parts[ o:RDoc::Markup::Paragraph; [I"7Returns the source encoding as an encoding object.;To:RDoc::Markup::BlankLineo; ; [I"ENote that the result may not be equal to the source encoding of ;TI"Athe encoding converter if the conversion has multiple steps.;T@o:RDoc::Markup::Verbatim; [I"Zec = Encoding::Converter.new("ISO-8859-1", "EUC-JP") # ISO-8859-1 -> UTF-8 -> EUC-JP ;TI" begin ;TI"[ ec.convert("\xa0") # NO-BREAK SPACE, which is available in UTF-8 but not in EUC-JP. ;TI"/rescue Encoding::UndefinedConversionError ;TI"? p $!.source_encoding #=> # ;TI"@ p $!.destination_encoding #=> # ;TI"5 p $!.source_encoding_name #=> "UTF-8" ;TI"6 p $!.destination_encoding_name #=> "EUC-JP" ;TI"end;T: @format0: @fileI"transcode.c;T:0@omit_headings_from_table_of_contents_below0I"4ecerr.source_encoding -> encoding ;T0[I"();T@FI"InvalidByteSequenceError;TcRDoc::NormalClass00PK4 ]2InvalidByteSequenceError/source_encoding_name-i.rinu[U:RDoc::AnyMethod[iI"source_encoding_name:ETI" string ;T0[I"();T@FI"InvalidByteSequenceError;TcRDoc::NormalClass00PK4 ]]Onn)InvalidByteSequenceError/error_bytes-i.rinu[U:RDoc::AnyMethod[iI"error_bytes:ETI"3Encoding::InvalidByteSequenceError#error_bytes;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"PReturns the discarded bytes when Encoding::InvalidByteSequenceError occurs.;To:RDoc::Markup::BlankLineo:RDoc::Markup::Verbatim; [ I":ec = Encoding::Converter.new("EUC-JP", "ISO-8859-1") ;TI" begin ;TI"$ ec.convert("abc\xA1\xFFdef") ;TI"/rescue Encoding::InvalidByteSequenceError ;TI"` p $! #=> # ;TI"4 puts $!.error_bytes.dump #=> "\xA1" ;TI"4 puts $!.readagain_bytes.dump #=> "\xFF" ;TI"end;T: @format0: @fileI"transcode.c;T:0@omit_headings_from_table_of_contents_below0I")ecerr.error_bytes -> string ;T0[I"();T@FI"InvalidByteSequenceError;TcRDoc::NormalClass00PK4 ](OZ qqname_list-c.rinu[U:RDoc::AnyMethod[iI"name_list:ETI"Encoding::name_list;TT: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"2Returns the list of available encoding names.;To:RDoc::Markup::BlankLineo:RDoc::Markup::Verbatim; [ I"Encoding.name_list ;TI"-#=> ["US-ASCII", "ASCII-8BIT", "UTF-8", ;TI"0 "ISO-8859-1", "Shift_JIS", "EUC-JP", ;TI" "Windows-31J", ;TI"& "BINARY", "CP932", "eucJP"];T: @format0: @fileI"encoding.c;T:0@omit_headings_from_table_of_contents_below0I"1Encoding.name_list -> ["enc1", "enc2", ...] ;T0[I"();T@FI" Encoding;TcRDoc::NormalClass00PK4 ]odefault_external-c.rinu[U:RDoc::AnyMethod[iI"default_external:ETI"Encoding::default_external;TT: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"'Returns default external encoding.;To:RDoc::Markup::BlankLineo; ; [I"OThe default external encoding is used by default for strings created from ;TI"the following locations:;T@o:RDoc::Markup::List: @type: BULLET: @items[ o:RDoc::Markup::ListItem: @label0; [o; ; [I"CSV;To;;0; [o; ; [I"File data read from disk;To;;0; [o; ; [I" SDBM;To;;0; [o; ; [I" StringIO;To;;0; [o; ; [I"Zlib::GzipReader;To;;0; [o; ; [I"Zlib::GzipWriter;To;;0; [o; ; [I"String#inspect;To;;0; [o; ; [I"Regexp#inspect;T@o; ; [I"MWhile strings created from these locations will have this encoding, the ;TI"Iencoding may not be valid. Be sure to check String#valid_encoding?.;T@o; ; [I"JFile data written to disk will be transcoded to the default external ;TI"encoding when written.;T@o; ; [I"MThe default external encoding is initialized by the locale or -E option.;T: @fileI"encoding.c;T:0@omit_headings_from_table_of_contents_below0I"&Encoding.default_external -> enc ;T0[I"();T@HFI" Encoding;TcRDoc::NormalClass00PK4 ]e5$$default_external%3d-c.rinu[U:RDoc::AnyMethod[iI"default_external=:ETI" Encoding::default_external=;TT: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [ I"9Sets default external encoding. You should not set ;TI"PEncoding::default_external in ruby code as strings created before changing ;TI"Rthe value may have a different encoding from strings created after the value ;TI"Owas changed., instead you should use ruby -E to invoke ruby with ;TI""the correct default_external.;To:RDoc::Markup::BlankLineo; ; [I"PSee Encoding::default_external for information on how the default external ;TI"encoding is used.;T: @fileI"encoding.c;T:0@omit_headings_from_table_of_contents_below0I"%Encoding.default_external = enc ;T0[I" (p1);T@FI" Encoding;TcRDoc::NormalClass00PK4 ]m&FF6ConverterNotFoundError/cdesc-ConverterNotFoundError.rinu[U:RDoc::NormalClass[iI"ConverterNotFoundError:ETI"%Encoding::ConverterNotFoundError;TI"rb_eEncodingError;To:RDoc::Markup::Document: @parts[o;;[o:RDoc::Markup::Paragraph;[I"BRaised by transcoding methods when a named encoding does not ;TI"'correspond with a known converter.;T: @fileI"transcode.c;T:0@omit_headings_from_table_of_contents_below0; 0; 0[[[[[I" class;T[[: public[[:protected[[: private[[I" instance;T[[; [[; [[;[[[U:RDoc::Context::Section[i0o;;[; 0; 0[I"encoding.c;TI" Encoding;TcRDoc::NormalClassPK4 ]ցӊ$$cdesc-Encoding.rinu[U:RDoc::NormalClass[iI" Encoding:ET@I" Object;To:RDoc::Markup::Document: @parts[o;;[Oo:RDoc::Markup::Paragraph;[I"PAn Encoding instance represents a character encoding usable in Ruby. It is ;TI"Kdefined as a constant under the Encoding namespace. It has a name and ;TI"optionally, aliases:;To:RDoc::Markup::BlankLineo:RDoc::Markup::Verbatim;[ I"Encoding::ISO_8859_1.name ;TI" #=> # ;TI" ;TI" Encoding::ISO_8859_1.names ;TI"%#=> ["ISO-8859-1", "ISO8859-1"] ;T: @format0o; ;[I"PRuby methods dealing with encodings return or accept Encoding instances as ;TI"Narguments (when a method accepts an Encoding instance as an argument, it ;TI"6can be passed an Encoding name or alias instead).;T@o; ;[I""some string".encoding ;TI"#=> # ;TI" ;TI"9string = "some string".encode(Encoding::ISO_8859_1) ;TI"#=> "some string" ;TI"string.encoding ;TI" #=> # ;TI" ;TI"'"some string".encode "ISO-8859-1" ;TI"#=> "some string" ;T; 0o; ;[ I"MEncoding::ASCII_8BIT is a special encoding that is usually ;TI"Nused for a byte string, not a character string. But as the name insists, ;TI"Nits characters in the range of ASCII are considered as ASCII characters. ;TI"HThis is useful when you use ASCII-8BIT characters with other ASCII ;TI"compatible characters.;T@S:RDoc::Markup::Heading: leveli: textI"Changing an encoding;T@o; ;[I"NThe associated Encoding of a String can be changed in two different ways.;T@o; ;[ I"MFirst, it is possible to set the Encoding of a string to a new Encoding ;TI"Kwithout changing the internal byte representation of the string, with ;TI"OString#force_encoding. This is how you can tell Ruby the correct encoding ;TI"of a string.;T@o; ;[ I" string ;TI" #=> "R\xC3\xA9sum\xC3\xA9" ;TI"string.encoding ;TI" #=> # ;TI",string.force_encoding(Encoding::UTF_8) ;TI"#=> "R\u00E9sum\u00E9" ;T; 0o; ;[ I"OSecond, it is possible to transcode a string, i.e. translate its internal ;TI"Nbyte representation to another encoding. Its associated encoding is also ;TI"Kset to the other encoding. See String#encode for the various forms of ;TI"Ptranscoding, and the Encoding::Converter class for additional control over ;TI"the transcoding process.;T@o; ;[ I" string ;TI"#=> "R\u00E9sum\u00E9" ;TI"string.encoding ;TI"#=> # ;TI"3string = string.encode!(Encoding::ISO_8859_1) ;TI"#=> "R\xE9sum\xE9" ;TI"string.encoding ;TI"!#=> # ;T; 0S; ;i;I"Script encoding;T@o; ;[I"NAll Ruby script code has an associated Encoding which any String literal ;TI"6created in the source code will be associated to.;T@o; ;[ I"XThe default script encoding is Encoding::UTF-8 after v2.0, but it can ;TI"Qbe changed by a magic comment on the first line of the source code file (or ;TI"Msecond line, if there is a shebang line on the first). The comment must ;TI"Mcontain the word coding or encoding, followed ;TI"6by a colon, space and the Encoding name or alias:;T@o; ;[ I"# encoding: UTF-8 ;TI" ;TI""some string".encoding ;TI"#=> # ;T; 0o; ;[I"SThe __ENCODING__ keyword returns the script encoding of the file ;TI""which the keyword is written:;T@o; ;[ I"# encoding: ISO-8859-1 ;TI" ;TI"__ENCODING__ ;TI" #=> # ;T; 0o; ;[ I"Oruby -K will change the default locale encoding, but this is ;TI"Pnot recommended. Ruby source files should declare its script encoding by a ;TI"Mmagic comment even when they only depend on US-ASCII strings or regular ;TI"expressions.;T@S; ;i;I"Locale encoding;T@o; ;[I"JThe default encoding of the environment. Usually derived from locale.;T@o; ;[I"9see Encoding.locale_charmap, Encoding.find('locale');T@S; ;i;I"Filesystem encoding;T@o; ;[I"MThe default encoding of strings from the filesystem of the environment. ;TI"5This is used for strings of file names or paths.;T@o; ;[I"$see Encoding.find('filesystem');T@S; ;i;I"External encoding;T@o; ;[ I"OEach IO object has an external encoding which indicates the encoding that ;TI"PRuby will use to read its data. By default Ruby sets the external encoding ;TI"Lof an IO object to the default external encoding. The default external ;TI"Sencoding is set by locale encoding or the interpreter -E option. ;TI"IEncoding.default_external returns the current value of the external ;TI"encoding.;T@o; ;[I"ENV["LANG"] ;TI"#=> "UTF-8" ;TI"Encoding.default_external ;TI"#=> # ;TI" ;TI";$ ruby -E ISO-8859-1 -e "p Encoding.default_external" ;TI"# ;TI" ;TI"4$ LANG=C ruby -e 'p Encoding.default_external' ;TI"# ;T; 0o; ;[ I";The default external encoding may also be set through ;TI"OEncoding.default_external=, but you should not do this as strings created ;TI"Pbefore and after the change will have inconsistent encodings. Instead use ;TI"Lruby -E to invoke ruby with the correct external encoding.;T@o; ;[I"OWhen you know that the actual encoding of the data of an IO object is not ;TI"Mthe default external encoding, you can reset its external encoding with ;TI"JIO#set_encoding or set it at IO object creation (see IO.new options).;T@S; ;i;I"Internal encoding;T@o; ;[ I"ITo process the data of an IO object which has an encoding different ;TI"Rfrom its external encoding, you can set its internal encoding. Ruby will use ;TI"Nthis internal encoding to transcode the data when it is read from the IO ;TI" object.;T@o; ;[I"QConversely, when data is written to the IO object it is transcoded from the ;TI"Ainternal encoding to the external encoding of the IO object.;T@o; ;[I";The internal encoding of an IO object can be set with ;TI"CIO#set_encoding or at IO object creation (see IO.new options).;T@o; ;[I"JThe internal encoding is optional and when not set, the Ruby default ;TI"Linternal encoding is used. If not explicitly set this default internal ;TI"Fencoding is +nil+ meaning that by default, no transcoding occurs.;T@o; ;[I"JThe default internal encoding can be set with the interpreter option ;TI"M-E. Encoding.default_internal returns the current internal ;TI"encoding.;T@o; ;[ I"-$ ruby -e 'p Encoding.default_internal' ;TI" nil ;TI" ;TI"D$ ruby -E ISO-8859-1:UTF-8 -e "p [Encoding.default_external, \ ;TI"# Encoding.default_internal]" ;TI"1[#, #] ;T; 0o; ;[ I";The default internal encoding may also be set through ;TI"OEncoding.default_internal=, but you should not do this as strings created ;TI"Pbefore and after the change will have inconsistent encodings. Instead use ;TI"Lruby -E to invoke ruby with the correct internal encoding.;T@S; ;i;I"IO encoding example;T@o; ;[I"ZIn the following example a UTF-8 encoded string "R\u00E9sum\u00E9" is transcoded for ;TI"Noutput to ISO-8859-1 encoding, then read back in and transcoded to UTF-8:;T@o; ;[I"!string = "R\u00E9sum\u00E9" ;TI" ;TI"4open("transcoded.txt", "w:ISO-8859-1") do |io| ;TI" io.write(string) ;TI" end ;TI" ;TI"puts "raw text:" ;TI"&p File.binread("transcoded.txt") ;TI" puts ;TI" ;TI":open("transcoded.txt", "r:ISO-8859-1:UTF-8") do |io| ;TI" puts "transcoded text:" ;TI" p io.read ;TI" end ;T; 0o; ;[I"MWhile writing the file, the internal encoding is not specified as it is ;TI"Oonly necessary for reading. While reading the file both the internal and ;TI"Fexternal encoding must be specified to obtain the correct result.;T@o; ;[ I"$ ruby t.rb ;TI"raw text: ;TI""R\xE9sum\xE9" ;TI" ;TI"transcoded text: ;TI""R\u00E9sum\u00E9";T; 0: @fileI"encoding.c;T:0@omit_headings_from_table_of_contents_below0o;;[;I"transcode.c;T;0;0;0[[[[[I" class;T[[: public[[I" aliases;TI"encoding.c;T[I"compatible?;T@[I"default_external;T@[I"default_external=;T@[I"default_internal;T@[I"default_internal=;T@[I" find;T@[I" list;T@[I"name_list;T@[:protected[[: private[[I" instance;T[[;[ [I"ascii_compatible?;T@[I" dummy?;T@[I" inspect;T@[I" name;T@[I" names;T@[I"replicate;T@[I" to_s;T@[;[[;[[[U:RDoc::Context::Section[i0o;;[;0;0[@I")ext/openssl/lib/openssl/buffering.rb;TI".ext/psych/lib/psych/visitors/yaml_tree.rb;TI"lib/cgi/core.rb;TI"lib/cgi/util.rb;TI"lib/csv.rb;TI"lib/fileutils.rb;TI"lib/find.rb;TI"&lib/irb/lc/ja/encoding_aliases.rb;TI"lib/irb/xmp.rb;TI"lib/net/imap.rb;TI"lib/open-uri.rb;TI"%lib/rdoc/generator/json_index.rb;TI"lib/rdoc/markup/parser.rb;TI"lib/rdoc/options.rb;TI"+lib/rubygems/commands/setup_command.rb;TI"lib/rubygems/package.rb;TI""lib/rubygems/specification.rb;TI"lib/rubygems/util.rb;TI"lib/uri/common.rb;TI"+lib/webrick/httpservlet/filehandler.rb;TI"lib/webrick/httputils.rb;T@@cRDoc::TopLevelPK4 ]g!locale_charmap-c.rinu[U:RDoc::AnyMethod[iI"locale_charmap:ETI"Encoding::locale_charmap;TT: privateo:RDoc::Markup::Document: @parts[ o:RDoc::Markup::Paragraph; [I"&Returns the locale charmap name. ;FI"2It returns nil if no appropriate information.;Fo:RDoc::Markup::BlankLineo:RDoc::Markup::Verbatim; [I"Debian GNU/Linux ;TI" LANG=C ;TI"7 Encoding.locale_charmap #=> "ANSI_X3.4-1968" ;TI" LANG=ja_JP.EUC-JP ;TI"/ Encoding.locale_charmap #=> "EUC-JP" ;TI" ;TI" SunOS 5 ;TI" LANG=C ;TI", Encoding.locale_charmap #=> "646" ;TI" LANG=ja ;TI". Encoding.locale_charmap #=> "eucJP" ;T: @format0o; ; [ I".The result is highly platform dependent. ;FI"CSo Encoding.find(Encoding.locale_charmap) may cause an error. ;FI"?If you need some encoding object even for unknown locale, ;FI")Encoding.find("locale") can be used.;F: @fileI"encoding.c;T:0@omit_headings_from_table_of_contents_below0I"'Encoding.locale_charmap -> string ;F0[I"();T@#FI" Encoding;TcRDoc::NormalClass00PK4 ]`}##ascii_compatible%3f-i.rinu[U:RDoc::AnyMethod[iI"ascii_compatible?:ETI"Encoding#ascii_compatible?;TF: publico:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"-Returns whether ASCII-compatible or not.;To:RDoc::Markup::BlankLineo:RDoc::Markup::Verbatim; [I"4Encoding::UTF_8.ascii_compatible? #=> true ;TI"4Encoding::UTF_16BE.ascii_compatible? #=> false;T: @format0: @fileI"encoding.c;T:0@omit_headings_from_table_of_contents_below0I",enc.ascii_compatible? -> true or false ;T0[I"();T@FI" Encoding;TcRDoc::NormalClass00PKB;]W!˻oodetect_encoding-c.rinu[U:RDoc::AnyMethod[iI"detect_encoding:ETI"$RDoc::Encoding::detect_encoding;TT: privateo:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"@Detects the encoding of +string+ based on the magic comment;T: @fileI"lib/rdoc/encoding.rb;T:0@omit_headings_from_table_of_contents_below000[I" (string);T@FI" Encoding;TcRDoc::NormalModule00PKB;]5jread_file-c.rinu[U:RDoc::AnyMethod[iI"read_file:ETI"RDoc::Encoding::read_file;TT: privateo:RDoc::Markup::Document: @parts[ o:RDoc::Markup::Paragraph; [I"MReads the contents of +filename+ and handles any encoding directives in ;TI"the file.;To:RDoc::Markup::BlankLineo; ; [I"MThe content will be converted to the +encoding+. If the file cannot be ;TI"Bconverted a warning will be printed and nil will be returned.;T@o; ; [I"JIf +force_transcode+ is true the document will be transcoded and any ;TI"Gunknown character in the target encoding will be replaced with '?';T: @fileI"lib/rdoc/encoding.rb;T:0@omit_headings_from_table_of_contents_below000[I"2(filename, encoding, force_transcode = false);T@FI" Encoding;TcRDoc::NormalModule00PKB;]<>change_encoding-c.rinu[U:RDoc::AnyMethod[iI"change_encoding:ETI"$RDoc::Encoding::change_encoding;TT: privateo:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"MChanges encoding based on +encoding+ without converting and returns new ;TI" string;T: @fileI"lib/rdoc/encoding.rb;T:0@omit_headings_from_table_of_contents_below000[I"(text, encoding);T@FI" Encoding;TcRDoc::NormalModule00PKB;]ʡ``remove_magic_comment-c.rinu[U:RDoc::AnyMethod[iI"remove_magic_comment:ETI")RDoc::Encoding::remove_magic_comment;TT: privateo:RDoc::Markup::Document: @parts[o:RDoc::Markup::Paragraph; [I"'Removes magic comments and shebang;T: @fileI"lib/rdoc/encoding.rb;T:0@omit_headings_from_table_of_contents_below000[I" (string);T@FI" Encoding;TcRDoc::NormalModule00PKB;]to((!remove_frozen_string_literal-c.rinu[U:RDoc::AnyMethod[iI"!remove_frozen_string_literal:ETI"1RDoc::Encoding::remove_frozen_string_literal;TT: privateo:RDoc::Markup::Document: @parts[: @fileI"lib/rdoc/encoding.rb;T:0@omit_headings_from_table_of_contents_below000[I" (string);T@ FI" Encoding;TcRDoc::NormalModule00PK4 ],Converter/putback-i.rinu[PK4 ]׉Ddd ]Converter/primitive_convert-i.rinu[PK4 ]R#Converter/asciicompat_encoding-c.rinu[PK4 ]0 $$Converter/convpath-i.rinu[PK4 ]>**g"Converter/inspect-i.rinu[PK4 ]}-&& $Converter/primitive_errinfo-i.rinu[PK4 ]w`i''M3Converter/new-c.rinu[PK4 ]X ==IConverter/cdesc-Converter.rinu[PK4 ]EPdd?XConverter/replacement-i.rinu[PK4 ]CZConverter/last_error-i.rinu[PK4 ]8:#_Converter/destination_encoding-i.rinu[PK4 ]G}3ްaConverter/search_convpath-c.rinu[PK4 ]z7[[gConverter/finish-i.rinu[PK4 ]$:LjConverter/insert_output-i.rinu[PK4 ]2qConverter/source_encoding-i.rinu[PK4 ]nijHHlsConverter/replacement%3d-i.rinu[PK4 ]%)|vConverter/%3d%3d-i.rinu[PK4 ]ZYwConverter/convert-i.rinu[PK4 ]x~replicate-i.rinu[PK4 ]Ǵ00 inspect-i.rinu[PK4 ])V names-i.rinu[PK4 ]- UU@default_internal%3d-c.rinu[PK4 ]3 ݈aliases-c.rinu[PK4 ]  list-c.rinu[PK4 ]JY??.ߎCompatibilityError/cdesc-CompatibilityError.rinu[PK4 ]@@d |to_s-i.rinu[PK4 ]_ bname-i.rinu[PK4 ]m4 Hfind-c.rinu[PK4 ]Hcompatible%3f-c.rinu[PK4 ]bSdefault_internal-c.rinu[PK4 ],E:UndefinedConversionError/cdesc-UndefinedConversionError.rinu[PK4 ](רUndefinedConversionError/error_char-i.rinu[PK4 ] 22UndefinedConversionError/destination_encoding-i.rinu[PK4 ]:o7NUndefinedConversionError/destination_encoding_name-i.rinu[PK4 ]zFww-yUndefinedConversionError/source_encoding-i.rinu[PK4 ]J2MUndefinedConversionError/source_encoding_name-i.rinu[PK4 ]ڇ _dummy%3f-i.rinu[PK4 ]i/-#InvalidByteSequenceError/readagain_bytes-i.rinu[PK4 ]dXaa1FInvalidByteSequenceError/incomplete_input%3f-i.rinu[PK4 ]&22InvalidByteSequenceError/destination_encoding-i.rinu[PK4 ]yjVV:$InvalidByteSequenceError/cdesc-InvalidByteSequenceError.rinu[PK4 ]NrB7InvalidByteSequenceError/destination_encoding_name-i.rinu[PK4 ]Pww-InvalidByteSequenceError/source_encoding-i.rinu[PK4 ]2InvalidByteSequenceError/source_encoding_name-i.rinu[PK4 ]]Onn)InvalidByteSequenceError/error_bytes-i.rinu[PK4 ](OZ qqname_list-c.rinu[PK4 ]okdefault_external-c.rinu[PK4 ]e5$$default_external%3d-c.rinu[PK4 ]m&FF6ConverterNotFoundError/cdesc-ConverterNotFoundError.rinu[PK4 ]ցӊ$$cdesc-Encoding.rinu[PK4 ]g!}locale_charmap-c.rinu[PK4 ]`}## ascii_compatible%3f-i.rinu[PKB;]W!˻oo2 detect_encoding-c.rinu[PKB;]5jread_file-c.rinu[PKB;]<>change_encoding-c.rinu[PKB;]ʡ``remove_magic_comment-c.rinu[PKB;]to((!remove_frozen_string_literal-c.rinu[PK99