Joomla Platform  13.1
Documentation des API du framework Joomla Platform
 Tout Classes Espaces de nommage Fichiers Fonctions Variables Pages
Fonctions membres publiques | Attributs publics
Référence de la classe idna_convert
+ Graphe d'héritage de idna_convert:

Liste de tous les membres

Fonctions membres publiques

 idna_convert ($options=false)
 set_parameter ($option, $value=false)
 decode ($input, $one_time_encoding=false)
 encode ($decoded, $one_time_encoding=false)
 get_last_error ()
 _decode ($encoded)
 _encode ($decoded)
 _adapt ($delta, $npoints, $is_first)
 _encode_digit ($d)
 _decode_digit ($cp)
 _error ($error= '')
 _nameprep ($input)
 _hangul_decompose ($char)
 _hangul_compose ($input)
 _get_combining_class ($char)
 _apply_cannonical_ordering ($input)
 _combine ($input)
 _utf8_to_ucs4 ($input)
 _ucs4_to_utf8 ($input)
 _ucs4_to_ucs4_string ($input)
 _ucs4_string_to_ucs4 ($input)

Attributs publics

 $NP = array()
 $_punycode_prefix = 'xn--'
 $_invalid_ucs = 0x80000000
 $_max_ucs = 0x10FFFF
 $_base = 36
 $_tmin = 1
 $_tmax = 26
 $_skew = 38
 $_damp = 700
 $_initial_bias = 72
 $_initial_n = 0x80
 $_sbase = 0xAC00
 $_lbase = 0x1100
 $_vbase = 0x1161
 $_tbase = 0x11A7
 $_lcount = 19
 $_vcount = 21
 $_tcount = 28
 $_ncount = 588
 $_scount = 11172
 $_error = false
 $_api_encoding = 'utf8'
 $_allow_overlong = false
 $_strict_mode = false

Description détaillée

Encode/decode Internationalized Domain Names.

The class allows to convert internationalized domain names (see RFC 3490 for details) as they can be used with various registries worldwide to be translated between their original (localized) form and their encoded form as it will be used in the DNS (Domain Name System).

The class provides two public methods, encode() and decode(), which do exactly what you would expect them to do. You are allowed to use complete domain names, simple strings and complete email addresses as well. That means, that you might use any of the following notations:

  • www.nörgler.com
  • xn–nrgler-wxa
  • xn–brse-5qa.xn–knrz-1ra.info

Unicode input might be given as either UTF-8 string, UCS-4 string or UCS-4 array. Unicode output is available in the same formats. You can select your preferred format via set_paramter().

ACE input and output is always expected to be ASCII.

Auteur:
Matthias Sommerfeld mso@p.nosp@m.hlyl.nosp@m.abs.d.nosp@m.e
Copyright:
2004-2007 phlyLabs Berlin, http://phlylabs.de
Version:
0.5.1

Définition à la ligne 54 du fichier idna_convert.class.php.

Documentation des fonctions membres

idna_convert::_adapt (   $delta,
  $npoints,
  $is_first 
)

Adapt the bias according to the current code point and position private

Définition à la ligne 517 du fichier idna_convert.class.php.

Références $_base, et $_tmin.

Référencé par _decode(), et _encode().

{
$delta = intval($is_first ? ($delta / $this->_damp) : ($delta / 2));
$delta += intval($delta / $npoints);
for ($k = 0; $delta > (($this->_base - $this->_tmin) * $this->_tmax) / 2; $k += $this->_base) {
$delta = intval($delta / ($this->_base - $this->_tmin));
}
return intval($k + ($this->_base - $this->_tmin + 1) * $delta / ($delta + $this->_skew));
}

+ Voici le graphe des appelants de cette fonction :

idna_convert::_apply_cannonical_ordering (   $input)

Apllies the cannonical ordering of a decomposed UCS4 sequence

Paramètres:
arrayDecomposed UCS4 sequence
Renvoie:
array Ordered USC4 sequence private

Définition à la ligne 718 du fichier idna_convert.class.php.

Références _get_combining_class().

Référencé par _nameprep().

{
$swap = true;
$size = count($input);
while ($swap) {
$swap = false;
$last = $this->_get_combining_class(intval($input[0]));
for ($i = 0; $i < $size-1; ++$i) {
$next = $this->_get_combining_class(intval($input[$i+1]));
if ($next != 0 && $last > $next) {
// Move item leftward until it fits
for ($j = $i + 1; $j > 0; --$j) {
if ($this->_get_combining_class(intval($input[$j-1])) <= $next) break;
$t = intval($input[$j]);
$input[$j] = intval($input[$j-1]);
$input[$j-1] = $t;
$swap = true;
}
// Reentering the loop looking at the old character again
$next = $last;
}
$last = $next;
}
}
return $input;
}

+ Voici le graphe d'appel pour cette fonction :

+ Voici le graphe des appelants de cette fonction :

idna_convert::_combine (   $input)

Do composition of a sequence of starter and non-starter

Paramètres:
arrayUCS4 Decomposed sequence
Renvoie:
array Ordered USC4 sequence private

Définition à la ligne 751 du fichier idna_convert.class.php.

Référencé par _nameprep().

{
$inp_len = count($input);
foreach ($this->NP['replacemaps'] as $np_src => $np_target) {
if ($np_target[0] != $input[0]) continue;
if (count($np_target) != $inp_len) continue;
$hit = false;
foreach ($input as $k2 => $v2) {
if ($v2 == $np_target[$k2]) {
$hit = true;
} else {
$hit = false;
break;
}
}
if ($hit) return $np_src;
}
return false;
}

+ Voici le graphe des appelants de cette fonction :

idna_convert::_decode (   $encoded)

The actual decoding algorithm private

Définition à la ligne 360 du fichier idna_convert.class.php.

Références $_base, $_initial_bias, $_initial_n, _adapt(), _decode_digit(), _error(), et _ucs4_to_utf8().

Référencé par decode().

{
// We do need to find the Punycode prefix
if (!preg_match('!^'.preg_quote($this->_punycode_prefix, '!').'!', $encoded)) {
$this->_error('This is not a punycode string');
return false;
}
$encode_test = preg_replace('!^'.preg_quote($this->_punycode_prefix, '!').'!', '', $encoded);
// If nothing left after removing the prefix, it is hopeless
if (!$encode_test) {
$this->_error('The given encoded string was empty');
return false;
}
// Find last occurence of the delimiter
$delim_pos = strrpos($encoded, '-');
if ($delim_pos > strlen($this->_punycode_prefix)) {
for ($k = strlen($this->_punycode_prefix); $k < $delim_pos; ++$k) {
$decoded[] = ord($encoded{$k});
}
} else {
$decoded = array();
}
$deco_len = count($decoded);
$enco_len = strlen($encoded);
// Wandering through the strings; init
$is_first = true;
$bias = $this->_initial_bias;
$idx = 0;
$char = $this->_initial_n;
for ($enco_idx = ($delim_pos) ? ($delim_pos + 1) : 0; $enco_idx < $enco_len; ++$deco_len) {
for ($old_idx = $idx, $w = 1, $k = $this->_base; 1 ; $k += $this->_base) {
$digit = $this->_decode_digit($encoded{$enco_idx++});
$idx += $digit * $w;
$t = ($k <= $bias) ? $this->_tmin :
(($k >= $bias + $this->_tmax) ? $this->_tmax : ($k - $bias));
if ($digit < $t) break;
$w = (int) ($w * ($this->_base - $t));
}
$bias = $this->_adapt($idx - $old_idx, $deco_len + 1, $is_first);
$is_first = false;
$char += (int) ($idx / ($deco_len + 1));
$idx %= ($deco_len + 1);
if ($deco_len > 0) {
// Make room for the decoded char
for ($i = $deco_len; $i > $idx; $i--) {
$decoded[$i] = $decoded[($i - 1)];
}
}
$decoded[$idx++] = $char;
}
return $this->_ucs4_to_utf8($decoded);
}

+ Voici le graphe d'appel pour cette fonction :

+ Voici le graphe des appelants de cette fonction :

idna_convert::_decode_digit (   $cp)

Decode a certain digit private

Définition à la ligne 540 du fichier idna_convert.class.php.

Références $_base.

Référencé par _decode().

{
$cp = ord($cp);
return ($cp - 48 < 10) ? $cp - 22 : (($cp - 65 < 26) ? $cp - 65 : (($cp - 97 < 26) ? $cp - 97 : $this->_base));
}

+ Voici le graphe des appelants de cette fonction :

idna_convert::_encode (   $decoded)

The actual encoding algorithm private

Définition à la ligne 419 du fichier idna_convert.class.php.

Références $_base, $_initial_bias, $_initial_n, _adapt(), _encode_digit(), _error(), _nameprep(), et _utf8_to_ucs4().

Référencé par encode().

{
// We cannot encode a domain name containing the Punycode prefix
$extract = strlen($this->_punycode_prefix);
$check_pref = $this->_utf8_to_ucs4($this->_punycode_prefix);
$check_deco = array_slice($decoded, 0, $extract);
if ($check_pref == $check_deco) {
$this->_error('This is already a punycode string');
return false;
}
// We will not try to encode strings consisting of basic code points only
$encodable = false;
foreach ($decoded as $k => $v) {
if ($v > 0x7a) {
$encodable = true;
break;
}
}
if (!$encodable) {
$this->_error('The given string does not contain encodable chars');
return false;
}
// Do NAMEPREP
$decoded = $this->_nameprep($decoded);
if (!$decoded || !is_array($decoded)) return false; // NAMEPREP failed
$deco_len = count($decoded);
if (!$deco_len) return false; // Empty array
$codecount = 0; // How many chars have been consumed
$encoded = '';
// Copy all basic code points to output
for ($i = 0; $i < $deco_len; ++$i) {
$test = $decoded[$i];
// Will match [-0-9a-zA-Z]
if ((0x2F < $test && $test < 0x40) || (0x40 < $test && $test < 0x5B)
|| (0x60 < $test && $test <= 0x7B) || (0x2D == $test)) {
$encoded .= chr($decoded[$i]);
$codecount++;
}
}
if ($codecount == $deco_len) return $encoded; // All codepoints were basic ones
// Start with the prefix; copy it to output
$encoded = $this->_punycode_prefix.$encoded;
// If we have basic code points in output, add an hyphen to the end
if ($codecount) $encoded .= '-';
// Now find and encode all non-basic code points
$is_first = true;
$cur_code = $this->_initial_n;
$bias = $this->_initial_bias;
$delta = 0;
while ($codecount < $deco_len) {
// Find the smallest code point >= the current code point and
// remember the last ouccrence of it in the input
for ($i = 0, $next_code = $this->_max_ucs; $i < $deco_len; $i++) {
if ($decoded[$i] >= $cur_code && $decoded[$i] <= $next_code) {
$next_code = $decoded[$i];
}
}
$delta += ($next_code - $cur_code) * ($codecount + 1);
$cur_code = $next_code;
// Scan input again and encode all characters whose code point is $cur_code
for ($i = 0; $i < $deco_len; $i++) {
if ($decoded[$i] < $cur_code) {
$delta++;
} elseif ($decoded[$i] == $cur_code) {
for ($q = $delta, $k = $this->_base; 1; $k += $this->_base) {
$t = ($k <= $bias) ? $this->_tmin :
(($k >= $bias + $this->_tmax) ? $this->_tmax : $k - $bias);
if ($q < $t) break;
$encoded .= $this->_encode_digit(intval($t + (($q - $t) % ($this->_base - $t)))); //v0.4.5 Changed from ceil() to intval()
$q = (int) (($q - $t) / ($this->_base - $t));
}
$encoded .= $this->_encode_digit($q);
$bias = $this->_adapt($delta, $codecount+1, $is_first);
$codecount++;
$delta = 0;
$is_first = false;
}
}
$delta++;
$cur_code++;
}
return $encoded;
}

+ Voici le graphe d'appel pour cette fonction :

+ Voici le graphe des appelants de cette fonction :

idna_convert::_encode_digit (   $d)

Encoding a certain digit private

Définition à la ligne 531 du fichier idna_convert.class.php.

Référencé par _encode().

{
return chr($d + 22 + 75 * ($d < 26));
}

+ Voici le graphe des appelants de cette fonction :

idna_convert::_error (   $error = '')

Internal error handling method private

Définition à la ligne 550 du fichier idna_convert.class.php.

Référencé par _decode(), _encode(), _nameprep(), _ucs4_string_to_ucs4(), _ucs4_to_utf8(), _utf8_to_ucs4(), decode(), encode(), et set_parameter().

{
$this->_error = $error;
}

+ Voici le graphe des appelants de cette fonction :

idna_convert::_get_combining_class (   $char)

Returns the combining class of a certain wide char

Paramètres:
integerWide char to check (32bit integer)
Renvoie:
integer Combining class if found, else 0 private

Définition à la ligne 707 du fichier idna_convert.class.php.

Référencé par _apply_cannonical_ordering(), et _nameprep().

{
return isset($this->NP['norm_combcls'][$char]) ? $this->NP['norm_combcls'][$char] : 0;
}

+ Voici le graphe des appelants de cette fonction :

idna_convert::_hangul_compose (   $input)

Ccomposes a Hangul syllable (see http://www.unicode.org/unicode/reports/tr15/#Hangul

Paramètres:
arrayDecomposed UCS4 sequence
Renvoie:
array UCS4 sequence with syllables composed private

Définition à la ligne 665 du fichier idna_convert.class.php.

Références $_lbase, $_sbase, $_tbase, $_tcount, et $_vbase.

Référencé par _nameprep().

{
$inp_len = count($input);
if (!$inp_len) return array();
$result = array();
$last = (int) $input[0];
$result[] = $last; // copy first char from input to output
for ($i = 1; $i < $inp_len; ++$i) {
$char = (int) $input[$i];
$sindex = $last - $this->_sbase;
$lindex = $last - $this->_lbase;
$vindex = $char - $this->_vbase;
$tindex = $char - $this->_tbase;
// Find out, whether two current characters are LV and T
if (0 <= $sindex && $sindex < $this->_scount && ($sindex % $this->_tcount == 0)
&& 0 <= $tindex && $tindex <= $this->_tcount) {
// create syllable of form LVT
$last += $tindex;
$result[(count($result) - 1)] = $last; // reset last
continue; // discard char
}
// Find out, whether two current characters form L and V
if (0 <= $lindex && $lindex < $this->_lcount && 0 <= $vindex && $vindex < $this->_vcount) {
// create syllable of form LV
$last = (int) $this->_sbase + ($lindex * $this->_vcount + $vindex) * $this->_tcount;
$result[(count($result) - 1)] = $last; // reset last
continue; // discard char
}
// if neither case was true, just add the character
$last = $char;
$result[] = $char;
}
return $result;
}

+ Voici le graphe des appelants de cette fonction :

idna_convert::_hangul_decompose (   $char)

Decomposes a Hangul syllable (see http://www.unicode.org/unicode/reports/tr15/#Hangul

Paramètres:
integer32bit UCS4 code point
Renvoie:
array Either Hangul Syllable decomposed or original 32bit value as one value array private

Définition à la ligne 645 du fichier idna_convert.class.php.

Références $_tcount.

Référencé par _nameprep().

{
$sindex = (int) $char - $this->_sbase;
if ($sindex < 0 || $sindex >= $this->_scount) {
return array($char);
}
$result = array();
$result[] = (int) $this->_lbase + $sindex / $this->_ncount;
$result[] = (int) $this->_vbase + ($sindex % $this->_ncount) / $this->_tcount;
$T = intval($this->_tbase + $sindex % $this->_tcount);
if ($T != $this->_tbase) $result[] = $T;
return $result;
}

+ Voici le graphe des appelants de cette fonction :

idna_convert::_nameprep (   $input)

Do Nameprep according to RFC3491 and RFC3454

Paramètres:
arrayUnicode Characters
Renvoie:
string Unicode Characters, Nameprep'd private

Définition à la ligne 561 du fichier idna_convert.class.php.

Références _apply_cannonical_ordering(), _combine(), _error(), _get_combining_class(), _hangul_compose(), et _hangul_decompose().

Référencé par _encode().

{
$output = array();
$error = false;
//
// Mapping
// Walking through the input array, performing the required steps on each of
// the input chars and putting the result into the output array
// While mapping required chars we apply the cannonical ordering
foreach ($input as $v) {
// Map to nothing == skip that code point
if (in_array($v, $this->NP['map_nothing'])) continue;
// Try to find prohibited input
if (in_array($v, $this->NP['prohibit']) || in_array($v, $this->NP['general_prohibited'])) {
$this->_error('NAMEPREP: Prohibited input U+'.sprintf('%08X', $v));
return false;
}
foreach ($this->NP['prohibit_ranges'] as $range) {
if ($range[0] <= $v && $v <= $range[1]) {
$this->_error('NAMEPREP: Prohibited input U+'.sprintf('%08X', $v));
return false;
}
}
//
// Hangul syllable decomposition
if (0xAC00 <= $v && $v <= 0xD7AF) {
foreach ($this->_hangul_decompose($v) as $out) {
$output[] = (int) $out;
}
// There's a decomposition mapping for that code point
} elseif (isset($this->NP['replacemaps'][$v])) {
foreach ($this->_apply_cannonical_ordering($this->NP['replacemaps'][$v]) as $out) {
$output[] = (int) $out;
}
} else {
$output[] = (int) $v;
}
}
// Before applying any Combining, try to rearrange any Hangul syllables
$output = $this->_hangul_compose($output);
//
// Combine code points
//
$last_class = 0;
$last_starter = 0;
$out_len = count($output);
for ($i = 0; $i < $out_len; ++$i) {
$class = $this->_get_combining_class($output[$i]);
if ((!$last_class || $last_class > $class) && $class) {
// Try to match
$seq_len = $i - $last_starter;
$out = $this->_combine(array_slice($output, $last_starter, $seq_len));
// On match: Replace the last starter with the composed character and remove
// the now redundant non-starter(s)
if ($out) {
$output[$last_starter] = $out;
if (count($out) != $seq_len) {
for ($j = $i+1; $j < $out_len; ++$j) {
$output[$j-1] = $output[$j];
}
unset($output[$out_len]);
}
// Rewind the for loop by one, since there can be more possible compositions
$i--;
$out_len--;
$last_class = ($i == $last_starter) ? 0 : $this->_get_combining_class($output[$i-1]);
continue;
}
}
// The current class is 0
if (!$class) $last_starter = $i;
$last_class = $class;
}
return $output;
}

+ Voici le graphe d'appel pour cette fonction :

+ Voici le graphe des appelants de cette fonction :

idna_convert::_ucs4_string_to_ucs4 (   $input)

Convert UCS-4 strin into UCS-4 garray

private

Définition à la ligne 918 du fichier idna_convert.class.php.

Références _error().

Référencé par encode().

{
$output = array();
$inp_len = strlen($input);
// Input length must be dividable by 4
if ($inp_len % 4) {
$this->_error('Input UCS4 string is broken');
return false;
}
// Empty input - return empty output
if (!$inp_len) return $output;
for ($i = 0, $out_len = -1; $i < $inp_len; ++$i) {
// Increment output position every 4 input bytes
if (!($i % 4)) {
$out_len++;
$output[$out_len] = 0;
}
$output[$out_len] += ord($input{$i}) << (8 * (3 - ($i % 4) ) );
}
return $output;
}

+ Voici le graphe d'appel pour cette fonction :

+ Voici le graphe des appelants de cette fonction :

idna_convert::_ucs4_to_ucs4_string (   $input)

Convert UCS-4 array into UCS-4 string

private

Définition à la ligne 902 du fichier idna_convert.class.php.

Référencé par decode().

{
$output = '';
// Take array values and split output to 4 bytes per value
// The bit mask is 255, which reads &11111111
foreach ($input as $v) {
$output .= chr(($v >> 24) & 255).chr(($v >> 16) & 255).chr(($v >> 8) & 255).chr($v & 255);
}
return $output;
}

+ Voici le graphe des appelants de cette fonction :

idna_convert::_ucs4_to_utf8 (   $input)

Convert UCS-4 string into UTF-8 string See _utf8_to_ucs4() for details private

Définition à la ligne 865 du fichier idna_convert.class.php.

Références _error().

Référencé par _decode(), et encode().

{
$output = '';
$k = 0;
foreach ($input as $v) {
++$k;
// $v = ord($v);
if ($v < 128) { // 7bit are transferred literally
$output .= chr($v);
} elseif ($v < (1 << 11)) { // 2 bytes
$output .= chr(192 + ($v >> 6)) . chr(128 + ($v & 63));
} elseif ($v < (1 << 16)) { // 3 bytes
$output .= chr(224 + ($v >> 12)) . chr(128 + (($v >> 6) & 63)) . chr(128 + ($v & 63));
} elseif ($v < (1 << 21)) { // 4 bytes
$output .= chr(240 + ($v >> 18)) . chr(128 + (($v >> 12) & 63))
. chr(128 + (($v >> 6) & 63)) . chr(128 + ($v & 63));
} elseif ($v < (1 << 26)) { // 5 bytes
$output .= chr(248 + ($v >> 24)) . chr(128 + (($v >> 18) & 63))
. chr(128 + (($v >> 12) & 63)) . chr(128 + (($v >> 6) & 63))
. chr(128 + ($v & 63));
} elseif ($v < (1 << 31)) { // 6 bytes
$output .= chr(252 + ($v >> 30)) . chr(128 + (($v >> 24) & 63))
. chr(128 + (($v >> 18) & 63)) . chr(128 + (($v >> 12) & 63))
. chr(128 + (($v >> 6) & 63)) . chr(128 + ($v & 63));
} else {
$this->_error('Conversion from UCS-4 to UTF-8 failed: malformed input at byte '.$k);
return false;
}
}
return $output;
}

+ Voici le graphe d'appel pour cette fonction :

+ Voici le graphe des appelants de cette fonction :

idna_convert::_utf8_to_ucs4 (   $input)

This converts an UTF-8 encoded string to its UCS-4 representation By talking about UCS-4 "strings" we mean arrays of 32bit integers representing each of the "chars". This is due to PHP not being able to handle strings with bit depth different from 8. This apllies to the reverse method _ucs4_to_utf8(), too. The following UTF-8 encodings are supported: bytes bits representation 1 7 0xxxxxxx 2 11 110xxxxx 10xxxxxx 3 16 1110xxxx 10xxxxxx 10xxxxxx 4 21 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx 5 26 111110xx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx 6 31 1111110x 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx Each x represents a bit that can be used to store character data. The five and six byte sequences are part of Annex D of ISO/IEC 10646-1:2000 private

Définition à la ligne 788 du fichier idna_convert.class.php.

Références _error().

Référencé par _encode(), decode(), et encode().

{
$output = array();
$out_len = 0;
$inp_len = strlen($input);
$mode = 'next';
$test = 'none';
for ($k = 0; $k < $inp_len; ++$k) {
$v = ord($input{$k}); // Extract byte from input string
if ($v < 128) { // We found an ASCII char - put into stirng as is
$output[$out_len] = $v;
++$out_len;
if ('add' == $mode) {
$this->_error('Conversion from UTF-8 to UCS-4 failed: malformed input at byte '.$k);
return false;
}
continue;
}
if ('next' == $mode) { // Try to find the next start byte; determine the width of the Unicode char
$start_byte = $v;
$mode = 'add';
$test = 'range';
if ($v >> 5 == 6) { // &110xxxxx 10xxxxx
$next_byte = 0; // Tells, how many times subsequent bitmasks must rotate 6bits to the left
$v = ($v - 192) << 6;
} elseif ($v >> 4 == 14) { // &1110xxxx 10xxxxxx 10xxxxxx
$next_byte = 1;
$v = ($v - 224) << 12;
} elseif ($v >> 3 == 30) { // &11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
$next_byte = 2;
$v = ($v - 240) << 18;
} elseif ($v >> 2 == 62) { // &111110xx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
$next_byte = 3;
$v = ($v - 248) << 24;
} elseif ($v >> 1 == 126) { // &1111110x 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
$next_byte = 4;
$v = ($v - 252) << 30;
} else {
$this->_error('This might be UTF-8, but I don\'t understand it at byte '.$k);
return false;
}
if ('add' == $mode) {
$output[$out_len] = (int) $v;
++$out_len;
continue;
}
}
if ('add' == $mode) {
if (!$this->_allow_overlong && $test == 'range') {
$test = 'none';
if (($v < 0xA0 && $start_byte == 0xE0) || ($v < 0x90 && $start_byte == 0xF0) || ($v > 0x8F && $start_byte == 0xF4)) {
$this->_error('Bogus UTF-8 character detected (out of legal range) at byte '.$k);
return false;
}
}
if ($v >> 6 == 2) { // Bit mask must be 10xxxxxx
$v = ($v - 128) << ($next_byte * 6);
$output[($out_len - 1)] += $v;
--$next_byte;
} else {
$this->_error('Conversion from UTF-8 to UCS-4 failed: malformed input at byte '.$k);
return false;
}
if ($next_byte < 0) {
$mode = 'next';
}
}
} // for
return $output;
}

+ Voici le graphe d'appel pour cette fonction :

+ Voici le graphe des appelants de cette fonction :

idna_convert::decode (   $input,
  $one_time_encoding = false 
)

Decode a given ACE domain name

Paramètres:
stringDomain name (ACE string) [
stringDesired output encoding, see set_parameter]
Renvoie:
string Decoded Domain name (UTF-8 or UCS-4) public

Définition à la ligne 165 du fichier idna_convert.class.php.

Références _decode(), _error(), _ucs4_to_ucs4_string(), et _utf8_to_ucs4().

{
// Optionally set
if ($one_time_encoding) {
switch ($one_time_encoding) {
case 'utf8':
case 'ucs4_string':
case 'ucs4_array':
break;
default:
$this->_error('Unknown encoding '.$one_time_encoding);
return false;
}
}
// Make sure to drop any newline characters around
$input = trim($input);
// Negotiate input and try to determine, whether it is a plain string,
// an email address or something like a complete URL
if (strpos($input, '@')) { // Maybe it is an email address
// No no in strict mode
if ($this->_strict_mode) {
$this->_error('Only simple domain name parts can be handled in strict mode');
return false;
}
list ($email_pref, $input) = explode('@', $input, 2);
$arr = explode('.', $input);
foreach ($arr as $k => $v) {
if (preg_match('!^'.preg_quote($this->_punycode_prefix, '!').'!', $v)) {
$conv = $this->_decode($v);
if ($conv) $arr[$k] = $conv;
}
}
$input = join('.', $arr);
$arr = explode('.', $email_pref);
foreach ($arr as $k => $v) {
if (preg_match('!^'.preg_quote($this->_punycode_prefix, '!').'!', $v)) {
$conv = $this->_decode($v);
if ($conv) $arr[$k] = $conv;
}
}
$email_pref = join('.', $arr);
$return = $email_pref . '@' . $input;
} elseif (preg_match('![:\./]!', $input)) { // Or a complete domain name (with or without paths / parameters)
// No no in strict mode
if ($this->_strict_mode) {
$this->_error('Only simple domain name parts can be handled in strict mode');
return false;
}
$parsed = parse_url($input);
if (isset($parsed['host'])) {
$arr = explode('.', $parsed['host']);
foreach ($arr as $k => $v) {
$conv = $this->_decode($v);
if ($conv) $arr[$k] = $conv;
}
$parsed['host'] = join('.', $arr);
$return =
(empty($parsed['scheme']) ? '' : $parsed['scheme'].(strtolower($parsed['scheme']) == 'mailto' ? ':' : '://'))
.(empty($parsed['user']) ? '' : $parsed['user'].(empty($parsed['pass']) ? '' : ':'.$parsed['pass']).'@')
.$parsed['host']
.(empty($parsed['port']) ? '' : ':'.$parsed['port'])
.(empty($parsed['path']) ? '' : $parsed['path'])
.(empty($parsed['query']) ? '' : '?'.$parsed['query'])
.(empty($parsed['fragment']) ? '' : '#'.$parsed['fragment']);
} else { // parse_url seems to have failed, try without it
$arr = explode('.', $input);
foreach ($arr as $k => $v) {
$conv = $this->_decode($v);
$arr[$k] = ($conv) ? $conv : $v;
}
$return = join('.', $arr);
}
} else { // Otherwise we consider it being a pure domain name string
$return = $this->_decode($input);
if (!$return) $return = $input;
}
// The output is UTF-8 by default, other output formats need conversion here
// If one time encoding is given, use this, else the objects property
switch (($one_time_encoding) ? $one_time_encoding : $this->_api_encoding) {
case 'utf8':
return $return;
break;
case 'ucs4_string':
return $this->_ucs4_to_ucs4_string($this->_utf8_to_ucs4($return));
break;
case 'ucs4_array':
return $this->_utf8_to_ucs4($return);
break;
default:
$this->_error('Unsupported output format');
return false;
}
}

+ Voici le graphe d'appel pour cette fonction :

idna_convert::encode (   $decoded,
  $one_time_encoding = false 
)

Encode a given UTF-8 domain name

Paramètres:
stringDomain name (UTF-8 or UCS-4) [
stringDesired input encoding, see set_parameter]
Renvoie:
string Encoded Domain name (ACE string) public

Définition à la ligne 267 du fichier idna_convert.class.php.

Références _encode(), _error(), _ucs4_string_to_ucs4(), _ucs4_to_utf8(), et _utf8_to_ucs4().

{
// Forcing conversion of input to UCS4 array
// If one time encoding is given, use this, else the objects property
switch ($one_time_encoding ? $one_time_encoding : $this->_api_encoding) {
case 'utf8':
$decoded = $this->_utf8_to_ucs4($decoded);
break;
case 'ucs4_string':
$decoded = $this->_ucs4_string_to_ucs4($decoded);
case 'ucs4_array':
break;
default:
$this->_error('Unsupported input format: '.($one_time_encoding ? $one_time_encoding : $this->_api_encoding));
return false;
}
// No input, no output, what else did you expect?
if (empty($decoded)) return '';
// Anchors for iteration
$last_begin = 0;
// Output string
$output = '';
foreach ($decoded as $k => $v) {
// Make sure to use just the plain dot
switch($v) {
case 0x3002:
case 0xFF0E:
case 0xFF61:
$decoded[$k] = 0x2E;
// Right, no break here, the above are converted to dots anyway
// Stumbling across an anchoring character
case 0x2E:
case 0x2F:
case 0x3A:
case 0x3F:
case 0x40:
// Neither email addresses nor URLs allowed in strict mode
if ($this->_strict_mode) {
$this->_error('Neither email addresses nor URLs are allowed in strict mode.');
return false;
} else {
// Skip first char
if ($k) {
$encoded = '';
$encoded = $this->_encode(array_slice($decoded, $last_begin, (($k)-$last_begin)));
if ($encoded) {
$output .= $encoded;
} else {
$output .= $this->_ucs4_to_utf8(array_slice($decoded, $last_begin, (($k)-$last_begin)));
}
$output .= chr($decoded[$k]);
}
$last_begin = $k + 1;
}
}
}
// Catch the rest of the string
if ($last_begin) {
$inp_len = sizeof($decoded);
$encoded = '';
$encoded = $this->_encode(array_slice($decoded, $last_begin, (($inp_len)-$last_begin)));
if ($encoded) {
$output .= $encoded;
} else {
$output .= $this->_ucs4_to_utf8(array_slice($decoded, $last_begin, (($inp_len)-$last_begin)));
}
return $output;
} else {
if ($output = $this->_encode($decoded)) {
return $output;
} else {
return $this->_ucs4_to_utf8($decoded);
}
}
}

+ Voici le graphe d'appel pour cette fonction :

idna_convert::get_last_error ( )

Use this method to get the last error ocurred

Paramètres:
void
Renvoie:
string The last error, that occured public

Définition à la ligne 351 du fichier idna_convert.class.php.

Références $_error.

{
return $this->_error;
}
idna_convert::idna_convert (   $options = false)

Définition à la ligne 94 du fichier idna_convert.class.php.

Références $_tcount, et set_parameter().

{
$this->slast = $this->_sbase + $this->_lcount * $this->_vcount * $this->_tcount;
if (function_exists('file_get_contents')) {
$this->NP = unserialize(file_get_contents(dirname(__FILE__).'/npdata.ser'));
} else {
$this->NP = unserialize(join('', file(dirname(__FILE__).'/npdata.ser')));
}
// If parameters are given, pass these to the respective method
if (is_array($options)) {
return $this->set_parameter($options);
}
return true;
}

+ Voici le graphe d'appel pour cette fonction :

idna_convert::set_parameter (   $option,
  $value = false 
)

Sets a new option value. Available options and values: [encoding - Use either UTF-8, UCS4 as array or UCS4 as string as input ('utf8' for UTF-8, 'ucs4_string' and 'ucs4_array' respectively for UCS4); The output is always UTF-8] [overlong - Unicode does not allow unnecessarily long encodings of chars, to allow this, set this parameter to true, else to false; default is false.] [strict - true: strict mode, good for registration purposes - Causes errors on failures; false: loose mode, ideal for "wildlife" applications by silently ignoring errors and returning the original input instead

Paramètres:
mixedParameter to set (string: single parameter; array of Parameter => Value pairs)
stringValue to use (if parameter 1 is a string)
Renvoie:
boolean true on success, false otherwise public

Définition à la ligne 125 du fichier idna_convert.class.php.

Références _error().

Référencé par idna_convert().

{
if (!is_array($option)) {
$option = array($option => $value);
}
foreach ($option as $k => $v) {
switch ($k) {
case 'encoding':
switch ($v) {
case 'utf8':
case 'ucs4_string':
case 'ucs4_array':
$this->_api_encoding = $v;
break;
default:
$this->_error('Set Parameter: Unknown parameter '.$v.' for option '.$k);
return false;
}
break;
case 'overlong':
$this->_allow_overlong = ($v) ? true : false;
break;
case 'strict':
$this->_strict_mode = ($v) ? true : false;
break;
default:
$this->_error('Set Parameter: Unknown option '.$k);
return false;
}
}
return true;
}

+ Voici le graphe d'appel pour cette fonction :

+ Voici le graphe des appelants de cette fonction :

Documentation des données membres

idna_convert::$_allow_overlong = false

Définition à la ligne 90 du fichier idna_convert.class.php.

idna_convert::$_api_encoding = 'utf8'

Définition à la ligne 89 du fichier idna_convert.class.php.

idna_convert::$_base = 36

Définition à la ligne 69 du fichier idna_convert.class.php.

Référencé par _adapt(), _decode(), _decode_digit(), et _encode().

idna_convert::$_damp = 700

Définition à la ligne 73 du fichier idna_convert.class.php.

idna_convert::$_error = false

Définition à la ligne 85 du fichier idna_convert.class.php.

Référencé par get_last_error().

idna_convert::$_initial_bias = 72

Définition à la ligne 74 du fichier idna_convert.class.php.

Référencé par _decode(), et _encode().

idna_convert::$_initial_n = 0x80

Définition à la ligne 75 du fichier idna_convert.class.php.

Référencé par _decode(), et _encode().

idna_convert::$_invalid_ucs = 0x80000000

Définition à la ligne 67 du fichier idna_convert.class.php.

idna_convert::$_lbase = 0x1100

Définition à la ligne 77 du fichier idna_convert.class.php.

Référencé par _hangul_compose().

idna_convert::$_lcount = 19

Définition à la ligne 80 du fichier idna_convert.class.php.

idna_convert::$_max_ucs = 0x10FFFF

Définition à la ligne 68 du fichier idna_convert.class.php.

idna_convert::$_ncount = 588

Définition à la ligne 83 du fichier idna_convert.class.php.

idna_convert::$_punycode_prefix = 'xn--'

Définition à la ligne 66 du fichier idna_convert.class.php.

idna_convert::$_sbase = 0xAC00

Définition à la ligne 76 du fichier idna_convert.class.php.

Référencé par _hangul_compose().

idna_convert::$_scount = 11172

Définition à la ligne 84 du fichier idna_convert.class.php.

idna_convert::$_skew = 38

Définition à la ligne 72 du fichier idna_convert.class.php.

idna_convert::$_strict_mode = false

Définition à la ligne 91 du fichier idna_convert.class.php.

idna_convert::$_tbase = 0x11A7

Définition à la ligne 79 du fichier idna_convert.class.php.

Référencé par _hangul_compose().

idna_convert::$_tcount = 28

Définition à la ligne 82 du fichier idna_convert.class.php.

Référencé par _hangul_compose(), _hangul_decompose(), et idna_convert().

idna_convert::$_tmax = 26

Définition à la ligne 71 du fichier idna_convert.class.php.

idna_convert::$_tmin = 1

Définition à la ligne 70 du fichier idna_convert.class.php.

Référencé par _adapt().

idna_convert::$_vbase = 0x1161

Définition à la ligne 78 du fichier idna_convert.class.php.

Référencé par _hangul_compose().

idna_convert::$_vcount = 21

Définition à la ligne 81 du fichier idna_convert.class.php.

idna_convert::$NP = array()

Définition à la ligne 63 du fichier idna_convert.class.php.

La documentation de cette classe a été générée à partir du fichier suivant :