Encode/ISO2022/ISO646.pm

=head1 NAME

Encode::ISO2022::ISO646 --- Encode and decode of versions of
ISO/IEC 646

=head1 ENCODINGS

=over 4

=cut

require 5.7.3;
use strict;
package Encode::ISO2022::ISO646;
use vars qw($VERSION);
$VERSION=do{my @r=(q$Revision: 1.3 $=~/\d+/g);sprintf "%d."."%02d" x $#r,@r};
use base qw(Encode::Encoding);
require Encode::ISO2022;

sub encode ($$;$) {
  my ($obj, $str, $chk) = @_;
  $_[1] = '' if $chk;
  $str = &Encode::ISO2022::internal_to_iso2022 ($str, $obj->__2022_encode);
  return $str;
}

sub decode ($$;$) {
  my ($obj, $str, $chk) = @_;
  $_[1] = '' if $chk;
  return &Encode::ISO2022::iso2022_to_internal ($str, $obj->__2022_decode);
}

sub __2022__common ($) {
  my $C = Encode::ISO2022->new_object;
  $C->{option}->{designate_to}->{C0}->{default} = -1;
  $C->{option}->{designate_to}->{C1}->{default} = -1;
  $C->{option}->{designate_to}->{G94}->{default} = -1;
  $C->{option}->{designate_to}->{G94}->{B} = -1;
  $C->{option}->{designate_to}->{G94n}->{default} = -1;
  $C->{option}->{designate_to}->{G96}->{default} = -1;
  $C->{option}->{designate_to}->{G96n}->{default} = -1;
  $C->{G1} = $Encode::ISO2022::CHARSET{G94}->{"\x7E"};  ## empty
  $C->{option}->{reset}->{Gdesignation} = 0;
  $C->{option}->{reset}->{Ginvoke} = 0;
  $C;
}
sub __2022_encode ($) {
  my $C = shift->__2022__common;
  $C->{GR} = undef;
  $C;
}
sub __2022_decode ($) {
  my $C = shift->__2022__common;
  $C;
}

sub __clone ($) {
  my $self = shift;
  bless {%$self}, ref $self;
};

package Encode::ISO2022::ISO646::ISO646basic1993;
use vars qw/@ISA/;
push @ISA, 'Encode::ISO2022::ISO646';
__PACKAGE__->Define (qw/ISO_646.basic:1983 ref csISO646basic1983/);

=item ISO_646.basic:1983

A coded character set of
basic code table of ISO/IEC 646 (only graphic characters, 02/00-07/14).
(Name: ISO_646.basic:1983 (RFC 1345), ref (RFC 1345), csISO646basic1983 (IANA))

=cut

sub __2022__common ($) {
  my $C = shift->SUPER::__2022__common;
  $C->{bit} = 7;
  $C->{C0} = $Encode::ISO2022::CHARSET{C0}->{"\x7E"};   ## empty
  $C->{G0} = $Encode::ISO2022::CHARSET{G94}->{"\x21\x40"};      ## IR170
  # 0x7E = undef
  $C->{option}->{undef_char} = ["\x3F", {type => 'G94', charset => "\x21\x40"}];
  $C;
}

package Encode::ISO2022::ISO646::INVARIANT;
use vars qw/@ISA/;
push @ISA, 'Encode::ISO2022::ISO646';
__PACKAGE__->Define (qw!INVARIANT csINVARIANT ISO/IEC646.BCT!);

=item INVARIANT

A coded character set of
basic code table of ISO/IEC 646 (with C0 set of ISO/IEC 6429).
(Name: INVARIANT (RFC 1345), csINVARIANT (IANA), ISO/IEC646.BCT)

=cut

sub __2022__common ($) {
  my $C = shift->SUPER::__2022__common;
  $C->{bit} = 7;
  $C->{G0} = $Encode::ISO2022::CHARSET{G94}->{"\x21\x40"};      ## IR170
  $C->{option}->{undef_char} = ["\x3F", {type => 'G94', charset => "\x21\x40"}];
  $C;
}

package Encode::ISO2022::ISO646::ISO646irv;
use vars qw/@ISA/;
push @ISA, 'Encode::ISO2022::ISO646';
__PACKAGE__->Define (qw!ISO_646.irv:1983 iso-ir-2 irv csISO2IntlRefVersion ICS!);

=item ISO_646.irv:1983

International reference version (IRV) of ISO 646:1983.
(Name: ISO_646.irv:1983 (RFC 1345), iso-ir-2 (RFC 1345), irv (RFC 1345),
csISO2IntlRefVersion (IANA), ICS)

=cut

sub __2022__common ($) {
  my $C = shift->SUPER::__2022__common;
  $C->{bit} = 7;
  $C->{G0} = $Encode::ISO2022::CHARSET{G94}->{"\x40"};
  $C->{G1} = $C->{G0}; $C->{G2} = $C->{G1}; $C->{G3} = $C->{G1};
  $C->{option}->{undef_char} = ["\x3F", {type => 'G94', charset => "\x40"}];
  $C;
}

package Encode::ISO2022::ISO646::BS_4730;
use vars qw/@ISA/;
push @ISA, 'Encode::ISO2022::ISO646';
__PACKAGE__->Define (qw!BS_4730 iso-ir-4 ISO646-GB gb uk csISO4UnitedKingdom!);

=item BS_4730

BS 4730, a United Kingdom version of ISO/IEC 646.
(Name: BS_4730 (RFC 1345), iso-ir-4 (RFC 1345), ISO646-GB (RFC 1345), 
gb (RFC 1345), uk (RFC 1345), csISO4UnitedKingdom (IANA))

=cut

sub __2022__common ($) {
  my $C = shift->SUPER::__2022__common;
  $C->{bit} = 7;
  $C->{G0} = $Encode::ISO2022::CHARSET{G94}->{"\x41"};
  $C->{G1} = $C->{G0}; $C->{G2} = $C->{G1}; $C->{G3} = $C->{G1};
  $C->{option}->{undef_char} = ["\x3F", {type => 'G94', charset => "\x41"}];
  $C;
}

package Encode::ISO2022::ISO646::USASCII;
use vars qw/@ISA/;
push @ISA, 'Encode::ISO2022::ISO646';
#__PACKAGE__->Define (qw!ANSI_X3.4-1968 iso-ir-6 ANSI_X3.4-1986 ISO_646.irv:1991
#  ASCII ISO646-US US-ASCII us IBM367 cp367 csASCII
#  646 ASCII-7 ATF-8 CP20127 US_ASCII!);

=item ANSI_X3.4-1968

ANSI X3.4-1968 or ISO/IEC 646:1991 International reference version (IRV).
(Name: ANSI_X3.4-1968 (RFC 1345), iso-ir-6 (RFC 1345), ANSI_X3.4-1986 (RFC 1345),
ISO_646.irv:1991 (RFC 1345), ASCII (RFC 1345), ISO646-US (RFC 1345), 
US-ASCII (RFC 1345), us (RFC 1345), IBM367 (RFC 1345), cp367 (RFC 1345),
csASCII (IANA), 646, ASCII-7, ATF-8, CP20127 (M$), US_ASCII)

Note that this coding system defined in this module is not used,
since perl standard Encode module already implement this.

=cut

sub __2022__common ($) {
  my $C = shift->SUPER::__2022__common;
  $C->{bit} = 7;
  $C->{G0} = $Encode::ISO2022::CHARSET{G94}->{"\x41"};
  $C->{G1} = $C->{G0}; $C->{G2} = $C->{G1}; $C->{G3} = $C->{G1};
  $C->{option}->{undef_char} = ["\x3F", {type => 'G94', charset => "\x41"}];
  $C;
}

package Encode::ISO2022::ISO646::SEN_850200_B;
use vars qw/@ISA/;
push @ISA, 'Encode::ISO2022::ISO646';
__PACKAGE__->Define (qw!SEN_850200_B iso-ir-10 FI ISO646-FI ISO646-SE 
csISO10Swedish!);

=item SEN_850200_B

SEN 850200 Appendix B, Swedish version of ISO/IEC 646.
(Name: SEN_850200_B (RFC 1345), iso-ir-10 (RFC 1345), FI (RFC 1345), 
ISO646-FI (RFC 1345), ISO646-SE (RFC 1345), se (RFC 1345), csISO10Swedish (IANA))

=cut

sub __2022__common ($) {
  my $C = shift->SUPER::__2022__common;
  $C->{bit} = 7;
  $C->{G0} = $Encode::ISO2022::CHARSET{G94}->{"\x47"};
  $C->{G1} = $C->{G0}; $C->{G2} = $C->{G1}; $C->{G3} = $C->{G1};
  $C->{option}->{undef_char} = ["\x3F", {type => 'G94', charset => "\x47"}];
  $C;
}

package Encode::ISO2022::ISO646::SEN_850200_C;
use vars qw/@ISA/;
push @ISA, 'Encode::ISO2022::ISO646';
__PACKAGE__->Define (qw!SEN_850200_C iso-ir-11 ISO646-SE2
csISO11SwedishForNames!);

=item SEN_850200_C

SEN 850200 Appendix C, Swedish version of ISO/IEC 646 for names.
(Name: SEN_850200_C (RFC 1345), iso-ir-11 (RFC 1345), ISO646-SE2 (RFC 1345), 
csISO11SwedishForNames (IANA))

=cut

sub __2022__common ($) {
  my $C = shift->SUPER::__2022__common;
  $C->{bit} = 7;
  $C->{G0} = $Encode::ISO2022::CHARSET{G94}->{"\x48"};
  $C->{G1} = $C->{G0}; $C->{G2} = $C->{G1}; $C->{G3} = $C->{G1};
  $C->{option}->{undef_char} = ["\x3F", {type => 'G94', charset => "\x48"}];
  $C;
}

package Encode::ISO2022::ISO646::IT;
use vars qw/@ISA/;
push @ISA, 'Encode::ISO2022::ISO646';
__PACKAGE__->Define (qw!IT iso-ir-15 ISO646-IT csISO15Italian!);

=item IT

Italic version of ISO/IEC 646.
(Name: IT (RFC 1345), iso-ir-15 (RFC 1345), ISO646-IT (RFC 1345), 
csISO15Italian (IANA))

=cut

sub __2022__common ($) {
  my $C = shift->SUPER::__2022__common;
  $C->{bit} = 7;
  $C->{G0} = $Encode::ISO2022::CHARSET{G94}->{"\x59"};
  $C->{G1} = $C->{G0}; $C->{G2} = $C->{G1}; $C->{G3} = $C->{G1};
  $C->{option}->{undef_char} = ["\x3F", {type => 'G94', charset => "\x59"}];
  $C;
}

package Encode::ISO2022::ISO646::PT;
use vars qw/@ISA/;
push @ISA, 'Encode::ISO2022::ISO646';
__PACKAGE__->Define (qw!PT iso-ir-16 ISO646-PT csISO16Portuguese!);

=item PT

Portuguese version of ISO/IEC 646.
(Name: PT (RFC 1345), iso-ir-16 (RFC 1345), ISO646-PT (RFC 1345), 
csISO16Portuguese (IANA))

=cut

sub __2022__common ($) {
  my $C = shift->SUPER::__2022__common;
  $C->{bit} = 7;
  $C->{G0} = $Encode::ISO2022::CHARSET{G94}->{"\x4C"};
  $C->{G1} = $C->{G0}; $C->{G2} = $C->{G1}; $C->{G3} = $C->{G1};
  $C->{option}->{undef_char} = ["\x3F", {type => 'G94', charset => "\x4C"}];
  $C;
}

package Encode::ISO2022::ISO646::ES;
use vars qw/@ISA/;
push @ISA, 'Encode::ISO2022::ISO646';
__PACKAGE__->Define (qw!ES iso-ir-17 ISO646-ES csISO17Spanish!);

=item ES

Spanish version of ISO/IEC 646.
(Name: ES (RFC 1345), iso-ir-17 (RFC 1345), ISO646-ES (RFC 1345), 
csISO17Spanish (IANA))

=cut

sub __2022__common ($) {
  my $C = shift->SUPER::__2022__common;
  $C->{bit} = 7;
  $C->{G0} = $Encode::ISO2022::CHARSET{G94}->{"\x5A"};
  $C->{G1} = $C->{G0}; $C->{G2} = $C->{G1}; $C->{G3} = $C->{G1};
  $C->{option}->{undef_char} = ["\x3F", {type => 'G94', charset => "\x5A"}];
  $C;
}

package Encode::ISO2022::ISO646::DIN_66003;
use vars qw/@ISA/;
push @ISA, 'Encode::ISO2022::ISO646';
__PACKAGE__->Define (qw!DIN_66003 iso-ir-21 de ISO646-de csISO21German!);

=item DIN_66003

DIN 66003, German version of ISO/IEC 646.
(Name: DIN_66003 (RFC 1345), iso-ir-21 (RFC 1345), de (RFC 1345),
ISO646-de (RFC 1345), csISO21German (IANA))

=cut

sub __2022__common ($) {
  my $C = shift->SUPER::__2022__common;
  $C->{bit} = 7;
  $C->{G0} = $Encode::ISO2022::CHARSET{G94}->{"\x4B"};
  $C->{G1} = $C->{G0}; $C->{G2} = $C->{G1}; $C->{G3} = $C->{G1};
  $C->{option}->{undef_char} = ["\x3F", {type => 'G94', charset => "\x4B"}];
  $C;
}

package Encode::ISO2022::ISO646::DIN_66003;
use vars qw/@ISA/;
push @ISA, 'Encode::ISO2022::ISO646';
__PACKAGE__->Define (qw!NF_Z_62-010_(1973) iso-ir-25 ISO646-FR1 csISO25French!);

=item NF_Z_62-010_(1973)

NF Z 62-010 1973, French version of ISO/IEC 646.
(Name: NF_Z_62-010_(1973) (RFC 1345), iso-ir-25 (RFC 1345),
ISO646-FR1 (RFC 1345), csISO25French (IANA))

=cut

sub __2022__common ($) {
  my $C = shift->SUPER::__2022__common;
  $C->{bit} = 7;
  $C->{G0} = $Encode::ISO2022::CHARSET{G94}->{"\x52"};
  $C->{G1} = $C->{G0}; $C->{G2} = $C->{G1}; $C->{G3} = $C->{G1};
  $C->{option}->{undef_char} = ["\x3F", {type => 'G94', charset => "\x52"}];
  $C;
}

package Encode::ISO2022::ISO646::GB_1988;
use vars qw/@ISA/;
push @ISA, 'Encode::ISO2022::ISO646';
__PACKAGE__->Define (qw!GB_1988-80 iso-ir-57 cn ISO646-cn csISO57GB1988!);

=item GB_1988-80

GB_1988-80, Chinese version of ISO/IEC 646.
(Name: GB_1988-80 (RFC 1345), iso-ir-57 (RFC 1345), cn (RFC 1345),
ISO646-cn (RFC 1345), csISO57GB1988 (IANA))

=cut

sub __2022__common ($) {
  my $C = shift->SUPER::__2022__common;
  $C->{bit} = 7;
  $C->{G0} = $Encode::ISO2022::CHARSET{G94}->{"\x54"};
  $C->{G1} = $C->{G0}; $C->{G2} = $C->{G1}; $C->{G3} = $C->{G1};
  $C->{option}->{undef_char} = ["\x3F", {type => 'G94', charset => "\x54"}];
  $C;
}

package Encode::ISO2022::ISO646::csISO60DanishNorwegian;
use vars qw/@ISA/;
push @ISA, 'Encode::ISO2022::ISO646';
__PACKAGE__->Define (qw! NS_4551-1 iso-ir-60 ISO646-NO no csISO60DanishNorwegian
 csISO60Norwegian1!);

=item NS_4551-1

NS_4551-1, Norwegian version of ISO/IEC 646.
(Name: NS_4551-1 (RFC 1345), iso-ir-60 (RFC 1345), ISO646-NO (RFC 1345),
no (RFC 1345), csISO60DanishNorwegian (IANA), csISO60Norwegian1 (IANA))

=cut

sub __2022__common ($) {
  my $C = shift->SUPER::__2022__common;
  $C->{bit} = 7;
  $C->{G0} = $Encode::ISO2022::CHARSET{G94}->{"\x60"};
  $C->{G1} = $C->{G0}; $C->{G2} = $C->{G1}; $C->{G3} = $C->{G1};
  $C->{option}->{undef_char} = ["\x3F", {type => 'G94', charset => "\x60"}];
  $C;
}

package Encode::ISO2022::ISO646::csISO61Norwegian2;
use vars qw/@ISA/;
push @ISA, 'Encode::ISO2022::ISO646';
__PACKAGE__->Define (qw! NS_4551-2 iso-ir-61 ISO646-NO2 no2 csISO61Norwegian2!);

=item NS_4551-2

NS_4551-2, Norwegian version of ISO/IEC 646.
(Name: NS_4551-2 (RFC 1345), iso-ir-61 (RFC 1345), ISO646-NO2 (RFC 1345),
no2 (RFC 1345), csISO61Norwegian2 (IANA))

=cut

sub __2022__common ($) {
  my $C = shift->SUPER::__2022__common;
  $C->{bit} = 7;
  $C->{G0} = $Encode::ISO2022::CHARSET{G94}->{"\x61"};
  $C->{G1} = $C->{G0}; $C->{G2} = $C->{G1}; $C->{G3} = $C->{G1};
  $C->{option}->{undef_char} = ["\x3F", {type => 'G94', charset => "\x61"}];
  $C;
}

package Encode::ISO2022::ISO646::csISO69French;
use vars qw/@ISA/;
push @ISA, 'Encode::ISO2022::ISO646';
__PACKAGE__->Define (qw!NF_Z_62-010 iso-ir-69 ISO646-FR fr csISO69French!);

=item NF_Z_62-010

NF Z 62-010, French version of ISO/IEC 646.
(Name: NS_4551-2 (RFC 1345), iso-ir-69 (RFC 1345), ISO646-FR (RFC 1345),
fr (RFC 1345), csISO69French (IANA))

=cut

sub __2022__common ($) {
  my $C = shift->SUPER::__2022__common;
  $C->{bit} = 7;
  $C->{G0} = $Encode::ISO2022::CHARSET{G94}->{"\x66"};
  $C->{G1} = $C->{G0}; $C->{G2} = $C->{G1}; $C->{G3} = $C->{G1};
  $C->{option}->{undef_char} = ["\x3F", {type => 'G94', charset => "\x66"}];
  $C;
}

package Encode::ISO2022::ISO646::PT2;
use vars qw/@ISA/;
push @ISA, 'Encode::ISO2022::ISO646';
__PACKAGE__->Define (qw!PT2 iso-ir-84 ISO646-PT2 csISO84Portuguese2!);

=item PT2

Portuguse version of ISO/IEC 646.
(Name: PT2 (RFC 1345), iso-ir-84 (RFC 1345), ISO646-PT2 (RFC 1345),
csISO84Portuguese2 (IANA))

=cut

sub __2022__common ($) {
  my $C = shift->SUPER::__2022__common;
  $C->{bit} = 7;
  $C->{G0} = $Encode::ISO2022::CHARSET{G94}->{"\x67"};
  $C->{G1} = $C->{G0}; $C->{G2} = $C->{G1}; $C->{G3} = $C->{G1};
  $C->{option}->{undef_char} = ["\x3F", {type => 'G94', charset => "\x67"}];
  $C;
}

package Encode::ISO2022::ISO646::ES2;
use vars qw/@ISA/;
push @ISA, 'Encode::ISO2022::ISO646';
__PACKAGE__->Define (qw!ES2 iso-ir-85 ISO646-ES2 csISO85Spanish2!);

=item ES2

Spanish version of ISO/IEC 646.
(Name: ES2 (RFC 1345), iso-ir-85 (RFC 1345), ISO646-ES2 (RFC 1345),
csISO85Spanish2 (IANA))

=cut

sub __2022__common ($) {
  my $C = shift->SUPER::__2022__common;
  $C->{bit} = 7;
  $C->{G0} = $Encode::ISO2022::CHARSET{G94}->{"\x68"};
  $C->{G1} = $C->{G0}; $C->{G2} = $C->{G1}; $C->{G3} = $C->{G1};
  $C->{option}->{undef_char} = ["\x3F", {type => 'G94', charset => "\x68"}];
  $C;
}

package Encode::ISO2022::ISO646::csISO86Hungarian;
use vars qw/@ISA/;
push @ISA, 'Encode::ISO2022::ISO646';
__PACKAGE__->Define (qw!MSZ_7795.3 iso-ir-86 ISO646-HU hu csISO86Hungarian!);

=item MSZ_7795.3

Hungarian version of ISO/IEC 646.
(Name: MSZ_7795.3 (RFC 1345), iso-ir-86 (RFC 1345), ISO646-HU (RFC 1345),
hu (RFC 1345), csISO86Hungarian (IANA))

=cut

sub __2022__common ($) {
  my $C = shift->SUPER::__2022__common;
  $C->{bit} = 7;
  $C->{G0} = $Encode::ISO2022::CHARSET{G94}->{"\x69"};
  $C->{G1} = $C->{G0}; $C->{G2} = $C->{G1}; $C->{G3} = $C->{G1};
  $C->{option}->{undef_char} = ["\x3F", {type => 'G94', charset => "\x69"}];
  $C;
}

package Encode::ISO2022::ISO646::csISO121Canadian1;
use vars qw/@ISA/;
push @ISA, 'Encode::ISO2022::ISO646';
__PACKAGE__->Define (qw!CSA_Z243.4-1985-1 iso-ir-121 ISO646-CA csa7-1 ca
 csISO121Canadian1!);

=item CSA_Z243.4-1985-1

Canadian version of ISO/IEC 646.
(Name: CSA_Z243.4-1985-1 (RFC 1345), iso-ir-121 (RFC 1345), ISO646-CA (RFC 1345),
csa7-1 (RFC 1345), ca (RFC 1345), csISO121Canadian1 (IANA))

=cut

sub __2022__common ($) {
  my $C = shift->SUPER::__2022__common;
  $C->{bit} = 7;
  $C->{G0} = $Encode::ISO2022::CHARSET{G94}->{"\x77"};
  $C->{G1} = $C->{G0}; $C->{G2} = $C->{G1}; $C->{G3} = $C->{G1};
  $C->{option}->{undef_char} = ["\x3F", {type => 'G94', charset => "\x77"}];
  $C;
}

package Encode::ISO2022::ISO646::csISO122Canadian2;
use vars qw/@ISA/;
push @ISA, 'Encode::ISO2022::ISO646';
__PACKAGE__->Define (qw!CSA_Z243.4-1985-2 iso-ir-122 ISO646-CA2 csa7-2
 csISO122Canadian2!);

=item CSA_Z243.4-1985-2

Canadian version of ISO/IEC 646.
(Name: CSA_Z243.4-1985-2 (RFC 1345), iso-ir-122 (RFC 1345), ISO646-CA2 (RFC 1345),
csa7-2 (RFC 1345), csISO122Canadian2 (IANA))

=cut

sub __2022__common ($) {
  my $C = shift->SUPER::__2022__common;
  $C->{bit} = 7;
  $C->{G0} = $Encode::ISO2022::CHARSET{G94}->{"\x78"};
  $C->{G1} = $C->{G0}; $C->{G2} = $C->{G1}; $C->{G3} = $C->{G1};
  $C->{option}->{undef_char} = ["\x3F", {type => 'G94', charset => "\x78"}];
  $C;
}

package Encode::ISO2022::ISO646::csISO122Canadian2;
use vars qw/@ISA/;
push @ISA, 'Encode::ISO2022::ISO646';
__PACKAGE__->Define (qw!JUS_I.B1.0022 iso-ir-141 ISO646-YU js yu
 csISO141JUSIB1002!);

=item JUS_I.B1.002

Canadian version of ISO/IEC 646.
(Name: JUS_I.B1.002 (RFC 1345), iso-ir-141 (RFC 1345), ISO646-YU (RFC 1345),
js (RFC 1345), yu (RFC 1345), csISO141JUSIB1002 (IANA))

=cut

sub __2022__common ($) {
  my $C = shift->SUPER::__2022__common;
  $C->{bit} = 7;
  $C->{G0} = $Encode::ISO2022::CHARSET{G94}->{"\x7A"};
  $C->{G1} = $C->{G0}; $C->{G2} = $C->{G1}; $C->{G3} = $C->{G1};
  $C->{option}->{undef_char} = ["\x3F", {type => 'G94', charset => "\x7A"}];
  $C;
}

package Encode::ISO2022::ISO646::csISO151Cuba;
use vars qw/@ISA/;
push @ISA, 'Encode::ISO2022::ISO646';
__PACKAGE__->Define (qw!NC_NC00-10:81 cuba iso-ir-151ISO646-CU
 csISO151Cuba!);

=item NC_NC00-10:81

Canadian version of ISO/IEC 646.
(Name: NC_NC00-10:81 (RFC 1345), cuba (RFC 1345), iso-ir-151 (RFC 1345),
ISO646-CU (RFC 1345), csISO151Cuba (IANA))

=cut

sub __2022__common ($) {
  my $C = shift->SUPER::__2022__common;
  $C->{bit} = 7;
  $C->{G0} = $Encode::ISO2022::CHARSET{G94}->{"\x21\x41"};
  $C->{G1} = $C->{G0}; $C->{G2} = $C->{G1}; $C->{G3} = $C->{G1};
  $C->{option}->{undef_char} = ["\x3F", {type => 'G94', charset => "\x21\x41"}];
  $C;
}

# DS_2089 DS2089 ISO646-DK dk csISO646Danish (IANA)
        ## Not in ISOREG
# KSC5636 ISO646-KR csKSC5636 (IANA)
        ## Not in ISOREG

1;
__END__

=back

=head1 AUTHORS

Nanashi-san

Wakaba <w@suika.fam.cx>

=head1 LICENSE

Copyright 2002 Authors

This library is free software; you can redistribute it
and/or modify it under the same terms as Perl itself.

=cut

# $Date: 2002/09/23 10:36:03 $
### ISO646.pm ends here
1	=head1 NAME
2
3	Encode::ISO2022::ISO646 --- Encode and decode of versions of
4	ISO/IEC 646
5
6	=head1 ENCODINGS
7
8	=over 4
9
10	=cut
11
12	require 5.7.3;
13	use strict;
14	package Encode::ISO2022::ISO646;
15	use vars qw($VERSION);
16	$VERSION=do{my @r=(q$Revision: 1.3 $=~/\d+/g);sprintf "%d."."%02d" x $#r,@r};
17	use base qw(Encode::Encoding);
18	require Encode::ISO2022;
19
20	sub encode ($$;$) {
21	my ($obj, $str, $chk) = @_;
22	$_[1] = '' if $chk;
23	$str = &Encode::ISO2022::internal_to_iso2022 ($str, $obj->__2022_encode);
24	return $str;
25	}
26
27	sub decode ($$;$) {
28	my ($obj, $str, $chk) = @_;
29	$_[1] = '' if $chk;
30	return &Encode::ISO2022::iso2022_to_internal ($str, $obj->__2022_decode);
31	}
32
33	sub __2022__common ($) {
34	my $C = Encode::ISO2022->new_object;
35	$C->{option}->{designate_to}->{C0}->{default} = -1;
36	$C->{option}->{designate_to}->{C1}->{default} = -1;
37	$C->{option}->{designate_to}->{G94}->{default} = -1;
38	$C->{option}->{designate_to}->{G94}->{B} = -1;
39	$C->{option}->{designate_to}->{G94n}->{default} = -1;
40	$C->{option}->{designate_to}->{G96}->{default} = -1;
41	$C->{option}->{designate_to}->{G96n}->{default} = -1;
42	$C->{G1} = $Encode::ISO2022::CHARSET{G94}->{"\x7E"}; ## empty
43	$C->{option}->{reset}->{Gdesignation} = 0;
44	$C->{option}->{reset}->{Ginvoke} = 0;
45	$C;
46	}
47	sub __2022_encode ($) {
48	my $C = shift->__2022__common;
49	$C->{GR} = undef;
50	$C;
51	}
52	sub __2022_decode ($) {
53	my $C = shift->__2022__common;
54	$C;
55	}
56
57	sub __clone ($) {
58	my $self = shift;
59	bless {%$self}, ref $self;
60	};
61
62	package Encode::ISO2022::ISO646::ISO646basic1993;
63	use vars qw/@ISA/;
64	push @ISA, 'Encode::ISO2022::ISO646';
65	__PACKAGE__->Define (qw/ISO_646.basic:1983 ref csISO646basic1983/);
66
67	=item ISO_646.basic:1983
68
69	A coded character set of
70	basic code table of ISO/IEC 646 (only graphic characters, 02/00-07/14).
71	(Name: ISO_646.basic:1983 (RFC 1345), ref (RFC 1345), csISO646basic1983 (IANA))
72
73	=cut
74
75	sub __2022__common ($) {
76	my $C = shift->SUPER::__2022__common;
77	$C->{bit} = 7;
78	$C->{C0} = $Encode::ISO2022::CHARSET{C0}->{"\x7E"}; ## empty
79	$C->{G0} = $Encode::ISO2022::CHARSET{G94}->{"\x21\x40"}; ## IR170
80	# 0x7E = undef
81	$C->{option}->{undef_char} = ["\x3F", {type => 'G94', charset => "\x21\x40"}];
82	$C;
83	}
84
85	package Encode::ISO2022::ISO646::INVARIANT;
86	use vars qw/@ISA/;
87	push @ISA, 'Encode::ISO2022::ISO646';
88	__PACKAGE__->Define (qw!INVARIANT csINVARIANT ISO/IEC646.BCT!);
89
90	=item INVARIANT
91
92	A coded character set of
93	basic code table of ISO/IEC 646 (with C0 set of ISO/IEC 6429).
94	(Name: INVARIANT (RFC 1345), csINVARIANT (IANA), ISO/IEC646.BCT)
95
96	=cut
97
98	sub __2022__common ($) {
99	my $C = shift->SUPER::__2022__common;
100	$C->{bit} = 7;
101	$C->{G0} = $Encode::ISO2022::CHARSET{G94}->{"\x21\x40"}; ## IR170
102	$C->{option}->{undef_char} = ["\x3F", {type => 'G94', charset => "\x21\x40"}];
103	$C;
104	}
105
106	package Encode::ISO2022::ISO646::ISO646irv;
107	use vars qw/@ISA/;
108	push @ISA, 'Encode::ISO2022::ISO646';
109	__PACKAGE__->Define (qw!ISO_646.irv:1983 iso-ir-2 irv csISO2IntlRefVersion ICS!);
110
111	=item ISO_646.irv:1983
112
113	International reference version (IRV) of ISO 646:1983.
114	(Name: ISO_646.irv:1983 (RFC 1345), iso-ir-2 (RFC 1345), irv (RFC 1345),
115	csISO2IntlRefVersion (IANA), ICS)
116
117	=cut
118
119	sub __2022__common ($) {
120	my $C = shift->SUPER::__2022__common;
121	$C->{bit} = 7;
122	$C->{G0} = $Encode::ISO2022::CHARSET{G94}->{"\x40"};
123	$C->{G1} = $C->{G0}; $C->{G2} = $C->{G1}; $C->{G3} = $C->{G1};
124	$C->{option}->{undef_char} = ["\x3F", {type => 'G94', charset => "\x40"}];
125	$C;
126	}
127
128	package Encode::ISO2022::ISO646::BS_4730;
129	use vars qw/@ISA/;
130	push @ISA, 'Encode::ISO2022::ISO646';
131	__PACKAGE__->Define (qw!BS_4730 iso-ir-4 ISO646-GB gb uk csISO4UnitedKingdom!);
132
133	=item BS_4730
134
135	BS 4730, a United Kingdom version of ISO/IEC 646.
136	(Name: BS_4730 (RFC 1345), iso-ir-4 (RFC 1345), ISO646-GB (RFC 1345),
137	gb (RFC 1345), uk (RFC 1345), csISO4UnitedKingdom (IANA))
138
139	=cut
140
141	sub __2022__common ($) {
142	my $C = shift->SUPER::__2022__common;
143	$C->{bit} = 7;
144	$C->{G0} = $Encode::ISO2022::CHARSET{G94}->{"\x41"};
145	$C->{G1} = $C->{G0}; $C->{G2} = $C->{G1}; $C->{G3} = $C->{G1};
146	$C->{option}->{undef_char} = ["\x3F", {type => 'G94', charset => "\x41"}];
147	$C;
148	}
149
150	package Encode::ISO2022::ISO646::USASCII;
151	use vars qw/@ISA/;
152	push @ISA, 'Encode::ISO2022::ISO646';
153	#__PACKAGE__->Define (qw!ANSI_X3.4-1968 iso-ir-6 ANSI_X3.4-1986 ISO_646.irv:1991
154	# ASCII ISO646-US US-ASCII us IBM367 cp367 csASCII
155	# 646 ASCII-7 ATF-8 CP20127 US_ASCII!);
156
157	=item ANSI_X3.4-1968
158
159	ANSI X3.4-1968 or ISO/IEC 646:1991 International reference version (IRV).
160	(Name: ANSI_X3.4-1968 (RFC 1345), iso-ir-6 (RFC 1345), ANSI_X3.4-1986 (RFC 1345),
161	ISO_646.irv:1991 (RFC 1345), ASCII (RFC 1345), ISO646-US (RFC 1345),
162	US-ASCII (RFC 1345), us (RFC 1345), IBM367 (RFC 1345), cp367 (RFC 1345),
163	csASCII (IANA), 646, ASCII-7, ATF-8, CP20127 (M$), US_ASCII)
164
165	Note that this coding system defined in this module is not used,
166	since perl standard Encode module already implement this.
167
168	=cut
169
170	sub __2022__common ($) {
171	my $C = shift->SUPER::__2022__common;
172	$C->{bit} = 7;
173	$C->{G0} = $Encode::ISO2022::CHARSET{G94}->{"\x41"};
174	$C->{G1} = $C->{G0}; $C->{G2} = $C->{G1}; $C->{G3} = $C->{G1};
175	$C->{option}->{undef_char} = ["\x3F", {type => 'G94', charset => "\x41"}];
176	$C;
177	}
178
179	package Encode::ISO2022::ISO646::SEN_850200_B;
180	use vars qw/@ISA/;
181	push @ISA, 'Encode::ISO2022::ISO646';
182	__PACKAGE__->Define (qw!SEN_850200_B iso-ir-10 FI ISO646-FI ISO646-SE
183	csISO10Swedish!);
184
185	=item SEN_850200_B
186
187	SEN 850200 Appendix B, Swedish version of ISO/IEC 646.
188	(Name: SEN_850200_B (RFC 1345), iso-ir-10 (RFC 1345), FI (RFC 1345),
189	ISO646-FI (RFC 1345), ISO646-SE (RFC 1345), se (RFC 1345), csISO10Swedish (IANA))
190
191	=cut
192
193	sub __2022__common ($) {
194	my $C = shift->SUPER::__2022__common;
195	$C->{bit} = 7;
196	$C->{G0} = $Encode::ISO2022::CHARSET{G94}->{"\x47"};
197	$C->{G1} = $C->{G0}; $C->{G2} = $C->{G1}; $C->{G3} = $C->{G1};
198	$C->{option}->{undef_char} = ["\x3F", {type => 'G94', charset => "\x47"}];
199	$C;
200	}
201
202	package Encode::ISO2022::ISO646::SEN_850200_C;
203	use vars qw/@ISA/;
204	push @ISA, 'Encode::ISO2022::ISO646';
205	__PACKAGE__->Define (qw!SEN_850200_C iso-ir-11 ISO646-SE2
206	csISO11SwedishForNames!);
207
208	=item SEN_850200_C
209
210	SEN 850200 Appendix C, Swedish version of ISO/IEC 646 for names.
211	(Name: SEN_850200_C (RFC 1345), iso-ir-11 (RFC 1345), ISO646-SE2 (RFC 1345),
212	csISO11SwedishForNames (IANA))
213
214	=cut
215
216	sub __2022__common ($) {
217	my $C = shift->SUPER::__2022__common;
218	$C->{bit} = 7;
219	$C->{G0} = $Encode::ISO2022::CHARSET{G94}->{"\x48"};
220	$C->{G1} = $C->{G0}; $C->{G2} = $C->{G1}; $C->{G3} = $C->{G1};
221	$C->{option}->{undef_char} = ["\x3F", {type => 'G94', charset => "\x48"}];
222	$C;
223	}
224
225	package Encode::ISO2022::ISO646::IT;
226	use vars qw/@ISA/;
227	push @ISA, 'Encode::ISO2022::ISO646';
228	__PACKAGE__->Define (qw!IT iso-ir-15 ISO646-IT csISO15Italian!);
229
230	=item IT
231
232	Italic version of ISO/IEC 646.
233	(Name: IT (RFC 1345), iso-ir-15 (RFC 1345), ISO646-IT (RFC 1345),
234	csISO15Italian (IANA))
235
236	=cut
237
238	sub __2022__common ($) {
239	my $C = shift->SUPER::__2022__common;
240	$C->{bit} = 7;
241	$C->{G0} = $Encode::ISO2022::CHARSET{G94}->{"\x59"};
242	$C->{G1} = $C->{G0}; $C->{G2} = $C->{G1}; $C->{G3} = $C->{G1};
243	$C->{option}->{undef_char} = ["\x3F", {type => 'G94', charset => "\x59"}];
244	$C;
245	}
246
247	package Encode::ISO2022::ISO646::PT;
248	use vars qw/@ISA/;
249	push @ISA, 'Encode::ISO2022::ISO646';
250	__PACKAGE__->Define (qw!PT iso-ir-16 ISO646-PT csISO16Portuguese!);
251
252	=item PT
253
254	Portuguese version of ISO/IEC 646.
255	(Name: PT (RFC 1345), iso-ir-16 (RFC 1345), ISO646-PT (RFC 1345),
256	csISO16Portuguese (IANA))
257
258	=cut
259
260	sub __2022__common ($) {
261	my $C = shift->SUPER::__2022__common;
262	$C->{bit} = 7;
263	$C->{G0} = $Encode::ISO2022::CHARSET{G94}->{"\x4C"};
264	$C->{G1} = $C->{G0}; $C->{G2} = $C->{G1}; $C->{G3} = $C->{G1};
265	$C->{option}->{undef_char} = ["\x3F", {type => 'G94', charset => "\x4C"}];
266	$C;
267	}
268
269	package Encode::ISO2022::ISO646::ES;
270	use vars qw/@ISA/;
271	push @ISA, 'Encode::ISO2022::ISO646';
272	__PACKAGE__->Define (qw!ES iso-ir-17 ISO646-ES csISO17Spanish!);
273
274	=item ES
275
276	Spanish version of ISO/IEC 646.
277	(Name: ES (RFC 1345), iso-ir-17 (RFC 1345), ISO646-ES (RFC 1345),
278	csISO17Spanish (IANA))
279
280	=cut
281
282	sub __2022__common ($) {
283	my $C = shift->SUPER::__2022__common;
284	$C->{bit} = 7;
285	$C->{G0} = $Encode::ISO2022::CHARSET{G94}->{"\x5A"};
286	$C->{G1} = $C->{G0}; $C->{G2} = $C->{G1}; $C->{G3} = $C->{G1};
287	$C->{option}->{undef_char} = ["\x3F", {type => 'G94', charset => "\x5A"}];
288	$C;
289	}
290
291	package Encode::ISO2022::ISO646::DIN_66003;
292	use vars qw/@ISA/;
293	push @ISA, 'Encode::ISO2022::ISO646';
294	__PACKAGE__->Define (qw!DIN_66003 iso-ir-21 de ISO646-de csISO21German!);
295
296	=item DIN_66003
297
298	DIN 66003, German version of ISO/IEC 646.
299	(Name: DIN_66003 (RFC 1345), iso-ir-21 (RFC 1345), de (RFC 1345),
300	ISO646-de (RFC 1345), csISO21German (IANA))
301
302	=cut
303
304	sub __2022__common ($) {
305	my $C = shift->SUPER::__2022__common;
306	$C->{bit} = 7;
307	$C->{G0} = $Encode::ISO2022::CHARSET{G94}->{"\x4B"};
308	$C->{G1} = $C->{G0}; $C->{G2} = $C->{G1}; $C->{G3} = $C->{G1};
309	$C->{option}->{undef_char} = ["\x3F", {type => 'G94', charset => "\x4B"}];
310	$C;
311	}
312
313	package Encode::ISO2022::ISO646::DIN_66003;
314	use vars qw/@ISA/;
315	push @ISA, 'Encode::ISO2022::ISO646';
316	__PACKAGE__->Define (qw!NF_Z_62-010_(1973) iso-ir-25 ISO646-FR1 csISO25French!);
317
318	=item NF_Z_62-010_(1973)
319
320	NF Z 62-010 1973, French version of ISO/IEC 646.
321	(Name: NF_Z_62-010_(1973) (RFC 1345), iso-ir-25 (RFC 1345),
322	ISO646-FR1 (RFC 1345), csISO25French (IANA))
323
324	=cut
325
326	sub __2022__common ($) {
327	my $C = shift->SUPER::__2022__common;
328	$C->{bit} = 7;
329	$C->{G0} = $Encode::ISO2022::CHARSET{G94}->{"\x52"};
330	$C->{G1} = $C->{G0}; $C->{G2} = $C->{G1}; $C->{G3} = $C->{G1};
331	$C->{option}->{undef_char} = ["\x3F", {type => 'G94', charset => "\x52"}];
332	$C;
333	}
334
335	package Encode::ISO2022::ISO646::GB_1988;
336	use vars qw/@ISA/;
337	push @ISA, 'Encode::ISO2022::ISO646';
338	__PACKAGE__->Define (qw!GB_1988-80 iso-ir-57 cn ISO646-cn csISO57GB1988!);
339
340	=item GB_1988-80
341
342	GB_1988-80, Chinese version of ISO/IEC 646.
343	(Name: GB_1988-80 (RFC 1345), iso-ir-57 (RFC 1345), cn (RFC 1345),
344	ISO646-cn (RFC 1345), csISO57GB1988 (IANA))
345
346	=cut
347
348	sub __2022__common ($) {
349	my $C = shift->SUPER::__2022__common;
350	$C->{bit} = 7;
351	$C->{G0} = $Encode::ISO2022::CHARSET{G94}->{"\x54"};
352	$C->{G1} = $C->{G0}; $C->{G2} = $C->{G1}; $C->{G3} = $C->{G1};
353	$C->{option}->{undef_char} = ["\x3F", {type => 'G94', charset => "\x54"}];
354	$C;
355	}
356
357	package Encode::ISO2022::ISO646::csISO60DanishNorwegian;
358	use vars qw/@ISA/;
359	push @ISA, 'Encode::ISO2022::ISO646';
360	__PACKAGE__->Define (qw! NS_4551-1 iso-ir-60 ISO646-NO no csISO60DanishNorwegian
361	csISO60Norwegian1!);
362
363	=item NS_4551-1
364
365	NS_4551-1, Norwegian version of ISO/IEC 646.
366	(Name: NS_4551-1 (RFC 1345), iso-ir-60 (RFC 1345), ISO646-NO (RFC 1345),
367	no (RFC 1345), csISO60DanishNorwegian (IANA), csISO60Norwegian1 (IANA))
368
369	=cut
370
371	sub __2022__common ($) {
372	my $C = shift->SUPER::__2022__common;
373	$C->{bit} = 7;
374	$C->{G0} = $Encode::ISO2022::CHARSET{G94}->{"\x60"};
375	$C->{G1} = $C->{G0}; $C->{G2} = $C->{G1}; $C->{G3} = $C->{G1};
376	$C->{option}->{undef_char} = ["\x3F", {type => 'G94', charset => "\x60"}];
377	$C;
378	}
379
380	package Encode::ISO2022::ISO646::csISO61Norwegian2;
381	use vars qw/@ISA/;
382	push @ISA, 'Encode::ISO2022::ISO646';
383	__PACKAGE__->Define (qw! NS_4551-2 iso-ir-61 ISO646-NO2 no2 csISO61Norwegian2!);
384
385	=item NS_4551-2
386
387	NS_4551-2, Norwegian version of ISO/IEC 646.
388	(Name: NS_4551-2 (RFC 1345), iso-ir-61 (RFC 1345), ISO646-NO2 (RFC 1345),
389	no2 (RFC 1345), csISO61Norwegian2 (IANA))
390
391	=cut
392
393	sub __2022__common ($) {
394	my $C = shift->SUPER::__2022__common;
395	$C->{bit} = 7;
396	$C->{G0} = $Encode::ISO2022::CHARSET{G94}->{"\x61"};
397	$C->{G1} = $C->{G0}; $C->{G2} = $C->{G1}; $C->{G3} = $C->{G1};
398	$C->{option}->{undef_char} = ["\x3F", {type => 'G94', charset => "\x61"}];
399	$C;
400	}
401
402	package Encode::ISO2022::ISO646::csISO69French;
403	use vars qw/@ISA/;
404	push @ISA, 'Encode::ISO2022::ISO646';
405	__PACKAGE__->Define (qw!NF_Z_62-010 iso-ir-69 ISO646-FR fr csISO69French!);
406
407	=item NF_Z_62-010
408
409	NF Z 62-010, French version of ISO/IEC 646.
410	(Name: NS_4551-2 (RFC 1345), iso-ir-69 (RFC 1345), ISO646-FR (RFC 1345),
411	fr (RFC 1345), csISO69French (IANA))
412
413	=cut
414
415	sub __2022__common ($) {
416	my $C = shift->SUPER::__2022__common;
417	$C->{bit} = 7;
418	$C->{G0} = $Encode::ISO2022::CHARSET{G94}->{"\x66"};
419	$C->{G1} = $C->{G0}; $C->{G2} = $C->{G1}; $C->{G3} = $C->{G1};
420	$C->{option}->{undef_char} = ["\x3F", {type => 'G94', charset => "\x66"}];
421	$C;
422	}
423
424	package Encode::ISO2022::ISO646::PT2;
425	use vars qw/@ISA/;
426	push @ISA, 'Encode::ISO2022::ISO646';
427	__PACKAGE__->Define (qw!PT2 iso-ir-84 ISO646-PT2 csISO84Portuguese2!);
428
429	=item PT2
430
431	Portuguse version of ISO/IEC 646.
432	(Name: PT2 (RFC 1345), iso-ir-84 (RFC 1345), ISO646-PT2 (RFC 1345),
433	csISO84Portuguese2 (IANA))
434
435	=cut
436
437	sub __2022__common ($) {
438	my $C = shift->SUPER::__2022__common;
439	$C->{bit} = 7;
440	$C->{G0} = $Encode::ISO2022::CHARSET{G94}->{"\x67"};
441	$C->{G1} = $C->{G0}; $C->{G2} = $C->{G1}; $C->{G3} = $C->{G1};
442	$C->{option}->{undef_char} = ["\x3F", {type => 'G94', charset => "\x67"}];
443	$C;
444	}
445
446	package Encode::ISO2022::ISO646::ES2;
447	use vars qw/@ISA/;
448	push @ISA, 'Encode::ISO2022::ISO646';
449	__PACKAGE__->Define (qw!ES2 iso-ir-85 ISO646-ES2 csISO85Spanish2!);
450
451	=item ES2
452
453	Spanish version of ISO/IEC 646.
454	(Name: ES2 (RFC 1345), iso-ir-85 (RFC 1345), ISO646-ES2 (RFC 1345),
455	csISO85Spanish2 (IANA))
456
457	=cut
458
459	sub __2022__common ($) {
460	my $C = shift->SUPER::__2022__common;
461	$C->{bit} = 7;
462	$C->{G0} = $Encode::ISO2022::CHARSET{G94}->{"\x68"};
463	$C->{G1} = $C->{G0}; $C->{G2} = $C->{G1}; $C->{G3} = $C->{G1};
464	$C->{option}->{undef_char} = ["\x3F", {type => 'G94', charset => "\x68"}];
465	$C;
466	}
467
468	package Encode::ISO2022::ISO646::csISO86Hungarian;
469	use vars qw/@ISA/;
470	push @ISA, 'Encode::ISO2022::ISO646';
471	__PACKAGE__->Define (qw!MSZ_7795.3 iso-ir-86 ISO646-HU hu csISO86Hungarian!);
472
473	=item MSZ_7795.3
474
475	Hungarian version of ISO/IEC 646.
476	(Name: MSZ_7795.3 (RFC 1345), iso-ir-86 (RFC 1345), ISO646-HU (RFC 1345),
477	hu (RFC 1345), csISO86Hungarian (IANA))
478
479	=cut
480
481	sub __2022__common ($) {
482	my $C = shift->SUPER::__2022__common;
483	$C->{bit} = 7;
484	$C->{G0} = $Encode::ISO2022::CHARSET{G94}->{"\x69"};
485	$C->{G1} = $C->{G0}; $C->{G2} = $C->{G1}; $C->{G3} = $C->{G1};
486	$C->{option}->{undef_char} = ["\x3F", {type => 'G94', charset => "\x69"}];
487	$C;
488	}
489
490	package Encode::ISO2022::ISO646::csISO121Canadian1;
491	use vars qw/@ISA/;
492	push @ISA, 'Encode::ISO2022::ISO646';
493	__PACKAGE__->Define (qw!CSA_Z243.4-1985-1 iso-ir-121 ISO646-CA csa7-1 ca
494	csISO121Canadian1!);
495
496	=item CSA_Z243.4-1985-1
497
498	Canadian version of ISO/IEC 646.
499	(Name: CSA_Z243.4-1985-1 (RFC 1345), iso-ir-121 (RFC 1345), ISO646-CA (RFC 1345),
500	csa7-1 (RFC 1345), ca (RFC 1345), csISO121Canadian1 (IANA))
501
502	=cut
503
504	sub __2022__common ($) {
505	my $C = shift->SUPER::__2022__common;
506	$C->{bit} = 7;
507	$C->{G0} = $Encode::ISO2022::CHARSET{G94}->{"\x77"};
508	$C->{G1} = $C->{G0}; $C->{G2} = $C->{G1}; $C->{G3} = $C->{G1};
509	$C->{option}->{undef_char} = ["\x3F", {type => 'G94', charset => "\x77"}];
510	$C;
511	}
512
513	package Encode::ISO2022::ISO646::csISO122Canadian2;
514	use vars qw/@ISA/;
515	push @ISA, 'Encode::ISO2022::ISO646';
516	__PACKAGE__->Define (qw!CSA_Z243.4-1985-2 iso-ir-122 ISO646-CA2 csa7-2
517	csISO122Canadian2!);
518
519	=item CSA_Z243.4-1985-2
520
521	Canadian version of ISO/IEC 646.
522	(Name: CSA_Z243.4-1985-2 (RFC 1345), iso-ir-122 (RFC 1345), ISO646-CA2 (RFC 1345),
523	csa7-2 (RFC 1345), csISO122Canadian2 (IANA))
524
525	=cut
526
527	sub __2022__common ($) {
528	my $C = shift->SUPER::__2022__common;
529	$C->{bit} = 7;
530	$C->{G0} = $Encode::ISO2022::CHARSET{G94}->{"\x78"};
531	$C->{G1} = $C->{G0}; $C->{G2} = $C->{G1}; $C->{G3} = $C->{G1};
532	$C->{option}->{undef_char} = ["\x3F", {type => 'G94', charset => "\x78"}];
533	$C;
534	}
535
536	package Encode::ISO2022::ISO646::csISO122Canadian2;
537	use vars qw/@ISA/;
538	push @ISA, 'Encode::ISO2022::ISO646';
539	__PACKAGE__->Define (qw!JUS_I.B1.0022 iso-ir-141 ISO646-YU js yu
540	csISO141JUSIB1002!);
541
542	=item JUS_I.B1.002
543
544	Canadian version of ISO/IEC 646.
545	(Name: JUS_I.B1.002 (RFC 1345), iso-ir-141 (RFC 1345), ISO646-YU (RFC 1345),
546	js (RFC 1345), yu (RFC 1345), csISO141JUSIB1002 (IANA))
547
548	=cut
549
550	sub __2022__common ($) {
551	my $C = shift->SUPER::__2022__common;
552	$C->{bit} = 7;
553	$C->{G0} = $Encode::ISO2022::CHARSET{G94}->{"\x7A"};
554	$C->{G1} = $C->{G0}; $C->{G2} = $C->{G1}; $C->{G3} = $C->{G1};
555	$C->{option}->{undef_char} = ["\x3F", {type => 'G94', charset => "\x7A"}];
556	$C;
557	}
558
559	package Encode::ISO2022::ISO646::csISO151Cuba;
560	use vars qw/@ISA/;
561	push @ISA, 'Encode::ISO2022::ISO646';
562	__PACKAGE__->Define (qw!NC_NC00-10:81 cuba iso-ir-151ISO646-CU
563	csISO151Cuba!);
564
565	=item NC_NC00-10:81
566
567	Canadian version of ISO/IEC 646.
568	(Name: NC_NC00-10:81 (RFC 1345), cuba (RFC 1345), iso-ir-151 (RFC 1345),
569	ISO646-CU (RFC 1345), csISO151Cuba (IANA))
570
571	=cut
572
573	sub __2022__common ($) {
574	my $C = shift->SUPER::__2022__common;
575	$C->{bit} = 7;
576	$C->{G0} = $Encode::ISO2022::CHARSET{G94}->{"\x21\x41"};
577	$C->{G1} = $C->{G0}; $C->{G2} = $C->{G1}; $C->{G3} = $C->{G1};
578	$C->{option}->{undef_char} = ["\x3F", {type => 'G94', charset => "\x21\x41"}];
579	$C;
580	}
581
582	# DS_2089 DS2089 ISO646-DK dk csISO646Danish (IANA)
583	## Not in ISOREG
584	# KSC5636 ISO646-KR csKSC5636 (IANA)
585	## Not in ISOREG
586
587	1;
588	__END__
589
590	=back
591
592	=head1 AUTHORS
593
594	Nanashi-san
595
596	Wakaba <w@suika.fam.cx>
597
598	=head1 LICENSE
599
600	Copyright 2002 Authors
601
602	This library is free software; you can redistribute it
603	and/or modify it under the same terms as Perl itself.
604
605	=cut
606
607	# $Date: 2002/09/23 10:36:03 $
608	### ISO646.pm ends here