[p5sagit/p5-mst-13.2.git] / ext / Unicode / Normalize / Normalize.pm

package Unicode::Normalize;

BEGIN {
    unless ("A" eq pack('U', 0x41)) {
	die "Unicode::Normalize cannot stringify a Unicode code point\n";
    }
}

use 5.006;
use strict;
use warnings;
use Carp;

no warnings 'utf8';

our $VERSION = '0.28';
our $PACKAGE = __PACKAGE__;

require Exporter;
require DynaLoader;

our @ISA = qw(Exporter DynaLoader);
our @EXPORT = qw( NFC NFD NFKC NFKD );
our @EXPORT_OK = qw(
    normalize decompose reorder compose
    checkNFD checkNFKD checkNFC checkNFKC check
    getCanon getCompat getComposite getCombinClass
    isExclusion isSingleton isNonStDecomp isComp2nd isComp_Ex
    isNFD_NO isNFC_NO isNFC_MAYBE isNFKD_NO isNFKC_NO isNFKC_MAYBE
    FCD checkFCD FCC checkFCC composeContiguous
    splitOnLastStarter
);
our %EXPORT_TAGS = (
    all       => [ @EXPORT, @EXPORT_OK ],
    normalize => [ @EXPORT, qw/normalize decompose reorder compose/ ],
    check     => [ qw/checkNFD checkNFKD checkNFC checkNFKC check/ ],
    fast      => [ qw/FCD checkFCD FCC checkFCC composeContiguous/ ],
);

######

bootstrap Unicode::Normalize $VERSION;

######

sub pack_U {
    return pack('U*', @_);
}

sub unpack_U {
    return unpack('U*', pack('U*').shift);
}


##
## normalization forms
##

use constant COMPAT => 1;

sub NFD  ($) { reorder(decompose($_[0])) }
sub NFKD ($) { reorder(decompose($_[0], COMPAT)) }
sub NFC  ($) { compose(reorder(decompose($_[0]))) }
sub NFKC ($) { compose(reorder(decompose($_[0], COMPAT))) }

sub FCD ($) {
    my $str = shift;
    return checkFCD($str) ? $str : NFD($str);
}
sub FCC ($) { composeContiguous(reorder(decompose($_[0]))) }

our %formNorm = (
    NFC  => \&NFC,	C  => \&NFC,
    NFD  => \&NFD,	D  => \&NFD,
    NFKC => \&NFKC,	KC => \&NFKC,
    NFKD => \&NFKD,	KD => \&NFKD,
    FCD  => \&FCD,	FCC => \&FCC,
);

sub normalize($$)
{
    my $form = shift;
    my $str = shift;
    return exists $formNorm{$form} 
	? $formNorm{$form}->($str)
	: croak $PACKAGE."::normalize: invalid form name: $form";
}


##
## quick check
##

our %formCheck = (
    NFC  => \&checkNFC, 	C  => \&checkNFC,
    NFD  => \&checkNFD, 	D  => \&checkNFD,
    NFKC => \&checkNFKC,	KC => \&checkNFKC,
    NFKD => \&checkNFKD,	KD => \&checkNFKD,
    FCD  => \&checkFCD, 	FCC => \&checkFCC,
);

sub check($$)
{
    my $form = shift;
    my $str = shift;
    return exists $formCheck{$form} 
	? $formCheck{$form}->($str)
	: croak $PACKAGE."::check: invalid form name: $form";
}

1;
__END__

=head1 NAME

Unicode::Normalize - Unicode Normalization Forms

=head1 SYNOPSIS

  use Unicode::Normalize;

  $NFD_string  = NFD($string);  # Normalization Form D
  $NFC_string  = NFC($string);  # Normalization Form C
  $NFKD_string = NFKD($string); # Normalization Form KD
  $NFKC_string = NFKC($string); # Normalization Form KC

   or

  use Unicode::Normalize 'normalize';

  $NFD_string  = normalize('D',  $string);  # Normalization Form D
  $NFC_string  = normalize('C',  $string);  # Normalization Form C
  $NFKD_string = normalize('KD', $string);  # Normalization Form KD
  $NFKC_string = normalize('KC', $string);  # Normalization Form KC

=head1 DESCRIPTION

Parameters:

C<$string> is used as a string under character semantics
(see F<perlunicode>).

C<$codepoint> should be an unsigned integer
representing a Unicode code point.

Note: Between XS edition and pure Perl edition,
interpretation of C<$codepoint> as a decimal number has incompatibility.
XS converts C<$codepoint> to an unsigned integer, but pure Perl does not.
Do not use a floating point nor a negative sign in C<$codepoint>.

=head2 Normalization Forms

=over 4

=item C<$NFD_string = NFD($string)>

returns the Normalization Form D (formed by canonical decomposition).

=item C<$NFC_string = NFC($string)>

returns the Normalization Form C (formed by canonical decomposition
followed by canonical composition).

=item C<$NFKD_string = NFKD($string)>

returns the Normalization Form KD (formed by compatibility decomposition).

=item C<$NFKC_string = NFKC($string)>

returns the Normalization Form KC (formed by compatibility decomposition
followed by B<canonical> composition).

=item C<$FCD_string = FCD($string)>

If the given string is in FCD ("Fast C or D" form; cf. UTN #5),
returns it without modification; otherwise returns an FCD string.

Note: FCD is not always unique, then plural forms may be equivalent
each other. C<FCD()> will return one of these equivalent forms.

=item C<$FCC_string = FCC($string)>

returns the FCC form ("Fast C Contiguous"; cf. UTN #5).

Note: FCC is unique, as well as four normalization forms (NF*).

=item C<$normalized_string = normalize($form_name, $string)>

As C<$form_name>, one of the following names must be given.

  'C'  or 'NFC'  for Normalization Form C  (UAX #15)
  'D'  or 'NFD'  for Normalization Form D  (UAX #15)
  'KC' or 'NFKC' for Normalization Form KC (UAX #15)
  'KD' or 'NFKD' for Normalization Form KD (UAX #15)

  'FCD'          for "Fast C or D" Form  (UTN #5)
  'FCC'          for "Fast C Contiguous" (UTN #5)

=back

=head2 Decomposition and Composition

=over 4

=item C<$decomposed_string = decompose($string)>

=item C<$decomposed_string = decompose($string, $useCompatMapping)>

Decomposes the specified string and returns the result.

If the second parameter (a boolean) is omitted or false, decomposes it
using the Canonical Decomposition Mapping.
If true, decomposes it using the Compatibility Decomposition Mapping.

The string returned is not always in NFD/NFKD.
Reordering may be required.

    $NFD_string  = reorder(decompose($string));       # eq. to NFD()
    $NFKD_string = reorder(decompose($string, TRUE)); # eq. to NFKD()

=item C<$reordered_string  = reorder($string)>

Reorders the combining characters and the like in the canonical ordering
and returns the result.

E.g., when you have a list of NFD/NFKD strings,
you can get the concatenated NFD/NFKD string from them, saying

    $concat_NFD  = reorder(join '', @NFD_strings);
    $concat_NFKD = reorder(join '', @NFKD_strings);

=item C<$composed_string   = compose($string)>

Returns the string where composable pairs are composed.

E.g., when you have a NFD/NFKD string,
you can get its NFC/NFKC string, saying

    $NFC_string  = compose($NFD_string);
    $NFKC_string = compose($NFKD_string);

=back

=head2 Quick Check

(see Annex 8, UAX #15; and F<DerivedNormalizationProps.txt>)

The following functions check whether the string is in that normalization form.

The result returned will be:

    YES     The string is in that normalization form.
    NO      The string is not in that normalization form.
    MAYBE   Dubious. Maybe yes, maybe no.

=over 4

=item C<$result = checkNFD($string)>

returns C<YES> (C<1>) or C<NO> (C<empty string>).

=item C<$result = checkNFC($string)>

returns C<YES> (C<1>), C<NO> (C<empty string>), or C<MAYBE> (C<undef>).

=item C<$result = checkNFKD($string)>

returns C<YES> (C<1>) or C<NO> (C<empty string>).

=item C<$result = checkNFKC($string)>

returns C<YES> (C<1>), C<NO> (C<empty string>), or C<MAYBE> (C<undef>).

=item C<$result = checkFCD($string)>

returns C<YES> (C<1>) or C<NO> (C<empty string>).

=item C<$result = checkFCC($string)>

returns C<YES> (C<1>), C<NO> (C<empty string>), or C<MAYBE> (C<undef>).

If a string is not in FCD, it must not be in FCC.
So C<checkFCC($not_FCD_string)> should return C<NO>.

=item C<$result = check($form_name, $string)>

returns C<YES> (C<1>), C<NO> (C<empty string>), or C<MAYBE> (C<undef>).

C<$form_name> is alike to that for C<normalize()>.

=back

B<Note>

In the cases of NFD, NFKD, and FCD, the answer must be
either C<YES> or C<NO>. The answer C<MAYBE> may be returned
in the cases of NFC, NFKC, and FCC.

A C<MAYBE> string should contain at least one combining character
or the like. For example, C<COMBINING ACUTE ACCENT> has
the MAYBE_NFC/MAYBE_NFKC property.

Both C<checkNFC("A\N{COMBINING ACUTE ACCENT}")>
and C<checkNFC("B\N{COMBINING ACUTE ACCENT}")> will return C<MAYBE>.
C<"A\N{COMBINING ACUTE ACCENT}"> is not in NFC
(its NFC is C<"\N{LATIN CAPITAL LETTER A WITH ACUTE}">),
while C<"B\N{COMBINING ACUTE ACCENT}"> is in NFC.

If you want to check exactly, compare the string with its NFC/NFKC/FCC;
i.e.,

    $string eq NFC($string)    # thorough than checkNFC($string)
    $string eq NFKC($string)   # thorough than checkNFKC($string)
    $string eq FCC($string)    # thorough than checkFCC($string)

=head2 Character Data

These functions are interface of character data used internally.
If you want only to get Unicode normalization forms, you don't need
call them yourself.

=over 4

=item C<$canonical_decomposed = getCanon($codepoint)>

If the character of the specified codepoint is canonically
decomposable (including Hangul Syllables),
returns the B<completely decomposed> string canonically equivalent to it.

If it is not decomposable, returns C<undef>.

=item C<$compatibility_decomposed = getCompat($codepoint)>

If the character of the specified codepoint is compatibility
decomposable (including Hangul Syllables),
returns the B<completely decomposed> string compatibility equivalent to it.

If it is not decomposable, returns C<undef>.

=item C<$codepoint_composite = getComposite($codepoint_here, $codepoint_next)>

If two characters here and next (as codepoints) are composable
(including Hangul Jamo/Syllables and Composition Exclusions),
returns the codepoint of the composite.

If they are not composable, returns C<undef>.

=item C<$combining_class = getCombinClass($codepoint)>

Returns the combining class of the character as an integer.

=item C<$is_exclusion = isExclusion($codepoint)>

Returns a boolean whether the character of the specified codepoint
is a composition exclusion.

=item C<$is_singleton = isSingleton($codepoint)>

Returns a boolean whether the character of the specified codepoint is
a singleton.

=item C<$is_non_starter_decomposition = isNonStDecomp($codepoint)>

Returns a boolean whether the canonical decomposition
of the character of the specified codepoint
is a Non-Starter Decomposition.

=item C<$may_be_composed_with_prev_char = isComp2nd($codepoint)>

Returns a boolean whether the character of the specified codepoint
may be composed with the previous one in a certain composition
(including Hangul Compositions, but excluding
Composition Exclusions and Non-Starter Decompositions).

=back

=head2 EXPORT

C<NFC>, C<NFD>, C<NFKC>, C<NFKD>: by default.

C<normalize> and other some functions: on request.

=head1 AUTHOR

SADAHIRO Tomoyuki, <SADAHIRO@cpan.org>

  http://homepage1.nifty.com/nomenclator/perl/

  Copyright(C) 2001-2003, SADAHIRO Tomoyuki. Japan. All rights reserved.

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

=head1 SEE ALSO

=over 4

=item http://www.unicode.org/reports/tr15/

Unicode Normalization Forms - UAX #15

=item http://www.unicode.org/Public/UNIDATA/DerivedNormalizationProps.txt

Derived Normalization Properties

=item http://www.unicode.org/notes/tn5/

Canonical Equivalence in Applications - UTN #5

=back

=cut
Commit	Line	Data
ac5ea531	1	package Unicode::Normalize;
ac5ea531	2
4a2e806c	3	BEGIN {
1efaba7f	4	unless ("A" eq pack('U', 0x41)) {
9f1f04a1	5	die "Unicode::Normalize cannot stringify a Unicode code point\n";
4a2e806c	6	}
	7	}
	8
ac5ea531	9	use 5.006;
	10	use strict;
	11	use warnings;
	12	use Carp;
	13
e524f5b2	14	no warnings 'utf8';
	15
	16	our $VERSION = '0.28';
ac5ea531	17	our $PACKAGE = __PACKAGE__;
	18
	19	require Exporter;
	20	require DynaLoader;
ac5ea531	21
	22	our @ISA = qw(Exporter DynaLoader);
	23	our @EXPORT = qw( NFC NFD NFKC NFKD );
2a204b45	24	our @EXPORT_OK = qw(
2a204b45	25	normalize decompose reorder compose
8f118dcd	26	checkNFD checkNFKD checkNFC checkNFKC check
	27	getCanon getCompat getComposite getCombinClass
	28	isExclusion isSingleton isNonStDecomp isComp2nd isComp_Ex
	29	isNFD_NO isNFC_NO isNFC_MAYBE isNFKD_NO isNFKC_NO isNFKC_MAYBE
82e740b6	30	FCD checkFCD FCC checkFCC composeContiguous
82e740b6	31	splitOnLastStarter
8f118dcd	32	);
	33	our %EXPORT_TAGS = (
	34	all => [ @EXPORT, @EXPORT_OK ],
	35	normalize => [ @EXPORT, qw/normalize decompose reorder compose/ ],
	36	check => [ qw/checkNFD checkNFKD checkNFC checkNFKC check/ ],
82e740b6	37	fast => [ qw/FCD checkFCD FCC checkFCC composeContiguous/ ],
2a204b45	38	);
ac5ea531	39
82e740b6	40	######
82e740b6	41
ac5ea531	42	bootstrap Unicode::Normalize $VERSION;
ac5ea531	43
82e740b6	44	######
82e740b6	45
9f1f04a1	46	sub pack_U {
b8d10bc1	47	return pack('U*', @_);
9f1f04a1	48	}
	49
	50	sub unpack_U {
b8d10bc1	51	return unpack('U', pack('U').shift);
9f1f04a1	52	}
9f1f04a1	53
82e740b6	54
	55	##
	56	## normalization forms
	57	##
	58
ac5ea531	59	use constant COMPAT => 1;
ac5ea531	60
d85850a7	61	sub NFD ($) { reorder(decompose($_[0])) }
ac5ea531	62	sub NFKD ($) { reorder(decompose($_[0], COMPAT)) }
d85850a7	63	sub NFC ($) { compose(reorder(decompose($_[0]))) }
ac5ea531	64	sub NFKC ($) { compose(reorder(decompose($_[0], COMPAT))) }
ac5ea531	65
82e740b6	66	sub FCD ($) {
	67	my $str = shift;
	68	return checkFCD($str) ? $str : NFD($str);
	69	}
	70	sub FCC ($) { composeContiguous(reorder(decompose($_[0]))) }
	71
	72	our %formNorm = (
	73	NFC => \&NFC, C => \&NFC,
	74	NFD => \&NFD, D => \&NFD,
	75	NFKC => \&NFKC, KC => \&NFKC,
	76	NFKD => \&NFKD, KD => \&NFKD,
	77	FCD => \&FCD, FCC => \&FCC,
	78	);
	79
ac5ea531	80	sub normalize($$)
ac5ea531	81	{
d85850a7	82	my $form = shift;
f027f502	83	my $str = shift;
82e740b6	84	return exists $formNorm{$form}
	85	? $formNorm{$form}->($str)
	86	: croak $PACKAGE."::normalize: invalid form name: $form";
ac5ea531	87	}
ac5ea531	88
82e740b6	89
	90	##
	91	## quick check
	92	##
	93
	94	our %formCheck = (
	95	NFC => \&checkNFC, C => \&checkNFC,
	96	NFD => \&checkNFD, D => \&checkNFD,
	97	NFKC => \&checkNFKC, KC => \&checkNFKC,
	98	NFKD => \&checkNFKD, KD => \&checkNFKD,
	99	FCD => \&checkFCD, FCC => \&checkFCC,
	100	);
	101
8f118dcd	102	sub check($$)
	103	{
	104	my $form = shift;
f027f502	105	my $str = shift;
82e740b6	106	return exists $formCheck{$form}
	107	? $formCheck{$form}->($str)
	108	: croak $PACKAGE."::check: invalid form name: $form";
8f118dcd	109	}
8f118dcd	110
ac5ea531	111	1;
ac5ea531	112	__END__
2a204b45	113
	114	=head1 NAME
	115
f027f502	116	Unicode::Normalize - Unicode Normalization Forms
2a204b45	117
	118	=head1 SYNOPSIS
	119
	120	use Unicode::Normalize;
	121
8f118dcd	122	$NFD_string = NFD($string); # Normalization Form D
	123	$NFC_string = NFC($string); # Normalization Form C
	124	$NFKD_string = NFKD($string); # Normalization Form KD
	125	$NFKC_string = NFKC($string); # Normalization Form KC
2a204b45	126
	127	or
	128
	129	use Unicode::Normalize 'normalize';
	130
8f118dcd	131	$NFD_string = normalize('D', $string); # Normalization Form D
	132	$NFC_string = normalize('C', $string); # Normalization Form C
	133	$NFKD_string = normalize('KD', $string); # Normalization Form KD
	134	$NFKC_string = normalize('KC', $string); # Normalization Form KC
2a204b45	135
	136	=head1 DESCRIPTION
	137
00f2676f	138	Parameters:
	139
	140	C<$string> is used as a string under character semantics
	141	(see F<perlunicode>).
	142
	143	C<$codepoint> should be an unsigned integer
	144	representing a Unicode code point.
	145
	146	Note: Between XS edition and pure Perl edition,
	147	interpretation of C<$codepoint> as a decimal number has incompatibility.
	148	XS converts C<$codepoint> to an unsigned integer, but pure Perl does not.
	149	Do not use a floating point nor a negative sign in C<$codepoint>.
	150
d85850a7	151	=head2 Normalization Forms
2a204b45	152
	153	=over 4
	154
8f118dcd	155	=item C<$NFD_string = NFD($string)>
2a204b45	156
	157	returns the Normalization Form D (formed by canonical decomposition).
	158
8f118dcd	159	=item C<$NFC_string = NFC($string)>
2a204b45	160
	161	returns the Normalization Form C (formed by canonical decomposition
	162	followed by canonical composition).
	163
8f118dcd	164	=item C<$NFKD_string = NFKD($string)>
2a204b45	165
	166	returns the Normalization Form KD (formed by compatibility decomposition).
	167
8f118dcd	168	=item C<$NFKC_string = NFKC($string)>
2a204b45	169
	170	returns the Normalization Form KC (formed by compatibility decomposition
	171	followed by B<canonical> composition).
	172
82e740b6	173	=item C<$FCD_string = FCD($string)>
	174
	175	If the given string is in FCD ("Fast C or D" form; cf. UTN #5),
	176	returns it without modification; otherwise returns an FCD string.
	177
	178	Note: FCD is not always unique, then plural forms may be equivalent
	179	each other. C<FCD()> will return one of these equivalent forms.
	180
	181	=item C<$FCC_string = FCC($string)>
	182
	183	returns the FCC form ("Fast C Contiguous"; cf. UTN #5).
	184
e524f5b2	185	Note: FCC is unique, as well as four normalization forms (NF*).
82e740b6	186
8f118dcd	187	=item C<$normalized_string = normalize($form_name, $string)>
2a204b45	188
	189	As C<$form_name>, one of the following names must be given.
	190
82e740b6	191	'C' or 'NFC' for Normalization Form C (UAX #15)
	192	'D' or 'NFD' for Normalization Form D (UAX #15)
	193	'KC' or 'NFKC' for Normalization Form KC (UAX #15)
	194	'KD' or 'NFKD' for Normalization Form KD (UAX #15)
	195
	196	'FCD' for "Fast C or D" Form (UTN #5)
	197	'FCC' for "Fast C Contiguous" (UTN #5)
2a204b45	198
	199	=back
	200
8f118dcd	201	=head2 Decomposition and Composition
	202
	203	=over 4
	204
	205	=item C<$decomposed_string = decompose($string)>
	206
	207	=item C<$decomposed_string = decompose($string, $useCompatMapping)>
	208
9f1f04a1	209	Decomposes the specified string and returns the result.
8f118dcd	210
	211	If the second parameter (a boolean) is omitted or false, decomposes it
	212	using the Canonical Decomposition Mapping.
	213	If true, decomposes it using the Compatibility Decomposition Mapping.
	214
	215	The string returned is not always in NFD/NFKD.
	216	Reordering may be required.
	217
	218	$NFD_string = reorder(decompose($string)); # eq. to NFD()
	219	$NFKD_string = reorder(decompose($string, TRUE)); # eq. to NFKD()
	220
	221	=item C<$reordered_string = reorder($string)>
	222
9f1f04a1	223	Reorders the combining characters and the like in the canonical ordering
8f118dcd	224	and returns the result.
	225
	226	E.g., when you have a list of NFD/NFKD strings,
	227	you can get the concatenated NFD/NFKD string from them, saying
	228
	229	$concat_NFD = reorder(join '', @NFD_strings);
	230	$concat_NFKD = reorder(join '', @NFKD_strings);
	231
	232	=item C<$composed_string = compose($string)>
	233
	234	Returns the string where composable pairs are composed.
	235
	236	E.g., when you have a NFD/NFKD string,
	237	you can get its NFC/NFKC string, saying
	238
	239	$NFC_string = compose($NFD_string);
	240	$NFKC_string = compose($NFKD_string);
	241
	242	=back
	243
	244	=head2 Quick Check
	245
82e740b6	246	(see Annex 8, UAX #15; and F<DerivedNormalizationProps.txt>)
8f118dcd	247
	248	The following functions check whether the string is in that normalization form.
	249
	250	The result returned will be:
	251
	252	YES The string is in that normalization form.
	253	NO The string is not in that normalization form.
	254	MAYBE Dubious. Maybe yes, maybe no.
	255
	256	=over 4
	257
	258	=item C<$result = checkNFD($string)>
	259
f027f502	260	returns C<YES> (C<1>) or C<NO> (C<empty string>).
8f118dcd	261
	262	=item C<$result = checkNFC($string)>
	263
f027f502	264	returns C<YES> (C<1>), C<NO> (C<empty string>), or C<MAYBE> (C<undef>).
8f118dcd	265
	266	=item C<$result = checkNFKD($string)>
	267
f027f502	268	returns C<YES> (C<1>) or C<NO> (C<empty string>).
8f118dcd	269
	270	=item C<$result = checkNFKC($string)>
	271
f027f502	272	returns C<YES> (C<1>), C<NO> (C<empty string>), or C<MAYBE> (C<undef>).
8f118dcd	273
82e740b6	274	=item C<$result = checkFCD($string)>
	275
	276	returns C<YES> (C<1>) or C<NO> (C<empty string>).
	277
	278	=item C<$result = checkFCC($string)>
	279
	280	returns C<YES> (C<1>), C<NO> (C<empty string>), or C<MAYBE> (C<undef>).
	281
e524f5b2	282	If a string is not in FCD, it must not be in FCC.
82e740b6	283	So C<checkFCC($not_FCD_string)> should return C<NO>.
82e740b6	284
8f118dcd	285	=item C<$result = check($form_name, $string)>
8f118dcd	286
f027f502	287	returns C<YES> (C<1>), C<NO> (C<empty string>), or C<MAYBE> (C<undef>).
8f118dcd	288
	289	C<$form_name> is alike to that for C<normalize()>.
	290
	291	=back
	292
	293	B<Note>
	294
82e740b6	295	In the cases of NFD, NFKD, and FCD, the answer must be
	296	either C<YES> or C<NO>. The answer C<MAYBE> may be returned
	297	in the cases of NFC, NFKC, and FCC.
8f118dcd	298
82e740b6	299	A C<MAYBE> string should contain at least one combining character
82e740b6	300	or the like. For example, C<COMBINING ACUTE ACCENT> has
8f118dcd	301	the MAYBE_NFC/MAYBE_NFKC property.
82e740b6	302
8f118dcd	303	Both C<checkNFC("A\N{COMBINING ACUTE ACCENT}")>
8f118dcd	304	and C<checkNFC("B\N{COMBINING ACUTE ACCENT}")> will return C<MAYBE>.
f027f502	305	C<"A\N{COMBINING ACUTE ACCENT}"> is not in NFC
8f118dcd	306	(its NFC is C<"\N{LATIN CAPITAL LETTER A WITH ACUTE}">),
	307	while C<"B\N{COMBINING ACUTE ACCENT}"> is in NFC.
	308
82e740b6	309	If you want to check exactly, compare the string with its NFC/NFKC/FCC;
82e740b6	310	i.e.,
8f118dcd	311
82e740b6	312	$string eq NFC($string) # thorough than checkNFC($string)
	313	$string eq NFKC($string) # thorough than checkNFKC($string)
	314	$string eq FCC($string) # thorough than checkFCC($string)
8f118dcd	315
2a204b45	316	=head2 Character Data
	317
	318	These functions are interface of character data used internally.
d0ed0342	319	If you want only to get Unicode normalization forms, you don't need
d0ed0342	320	call them yourself.
2a204b45	321
	322	=over 4
	323
	324	=item C<$canonical_decomposed = getCanon($codepoint)>
	325
8f118dcd	326	If the character of the specified codepoint is canonically
	327	decomposable (including Hangul Syllables),
	328	returns the B<completely decomposed> string canonically equivalent to it.
	329
f027f502	330	If it is not decomposable, returns C<undef>.
8f118dcd	331
2a204b45	332	=item C<$compatibility_decomposed = getCompat($codepoint)>
2a204b45	333
8f118dcd	334	If the character of the specified codepoint is compatibility
	335	decomposable (including Hangul Syllables),
	336	returns the B<completely decomposed> string compatibility equivalent to it.
2a204b45	337
f027f502	338	If it is not decomposable, returns C<undef>.
2a204b45	339
8f118dcd	340	=item C<$codepoint_composite = getComposite($codepoint_here, $codepoint_next)>
2a204b45	341
d85850a7	342	If two characters here and next (as codepoints) are composable
8f118dcd	343	(including Hangul Jamo/Syllables and Composition Exclusions),
2a204b45	344	returns the codepoint of the composite.
2a204b45	345
f027f502	346	If they are not composable, returns C<undef>.
2a204b45	347
	348	=item C<$combining_class = getCombinClass($codepoint)>
	349
8f118dcd	350	Returns the combining class of the character as an integer.
2a204b45	351
	352	=item C<$is_exclusion = isExclusion($codepoint)>
	353
8f118dcd	354	Returns a boolean whether the character of the specified codepoint
	355	is a composition exclusion.
	356
	357	=item C<$is_singleton = isSingleton($codepoint)>
	358
2a204b45	359	Returns a boolean whether the character of the specified codepoint is
8f118dcd	360	a singleton.
8f118dcd	361
6c941e0c	362	=item C<$is_non_starter_decomposition = isNonStDecomp($codepoint)>
8f118dcd	363
	364	Returns a boolean whether the canonical decomposition
	365	of the character of the specified codepoint
	366	is a Non-Starter Decomposition.
	367
	368	=item C<$may_be_composed_with_prev_char = isComp2nd($codepoint)>
	369
	370	Returns a boolean whether the character of the specified codepoint
	371	may be composed with the previous one in a certain composition
	372	(including Hangul Compositions, but excluding
	373	Composition Exclusions and Non-Starter Decompositions).
2a204b45	374
	375	=back
	376
	377	=head2 EXPORT
	378
	379	C<NFC>, C<NFD>, C<NFKC>, C<NFKD>: by default.
	380
	381	C<normalize> and other some functions: on request.
	382
	383	=head1 AUTHOR
	384
82e740b6	385	SADAHIRO Tomoyuki, <SADAHIRO@cpan.org>
2a204b45	386
	387	http://homepage1.nifty.com/nomenclator/perl/
	388
6c941e0c	389	Copyright(C) 2001-2003, SADAHIRO Tomoyuki. Japan. All rights reserved.
2a204b45	390
6c941e0c	391	This module is free software; you can redistribute it
6c941e0c	392	and/or modify it under the same terms as Perl itself.
2a204b45	393
	394	=head1 SEE ALSO
	395
	396	=over 4
	397
e524f5b2	398	=item http://www.unicode.org/reports/tr15/
2a204b45	399
	400	Unicode Normalization Forms - UAX #15
	401
14e6b36c	402	=item http://www.unicode.org/Public/UNIDATA/DerivedNormalizationProps.txt
8f118dcd	403
	404	Derived Normalization Properties
	405
82e740b6	406	=item http://www.unicode.org/notes/tn5/
	407
	408	Canonical Equivalence in Applications - UTN #5
	409
2a204b45	410	=back
	411
	412	=cut
	413