Support Joomla!

Joomla! 1.5 Documentation

Packages

Package: Unknown

Developer Network License

The Joomla! Developer Network content is © copyright 2006 by the individual contributors and can be used in accordance with the Creative Commons License, Attribution- NonCommercial- ShareAlike 2.5
Source code for file /simplepie/idn/idna_convert.class.php

Documentation is available at idna_convert.class.php

  1. <?php
  2. /* ------------------------------------------------------------------------- */
  3. /* idna_convert.class.php - Encode / Decode Internationalized Domain Names   */
  4. /* (c) 2004-2005 phlyLabs, Berlin (http://phlylabs.de)                       */
  5. /* All rights reserved                                                       */
  6. /* v0.4.2                                                                    */
  7. /* ------------------------------------------------------------------------- */
  8.  
  9. // {{{ license
  10.  
  11. /* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4 foldmethod=marker: */
  12. //
  13. // +----------------------------------------------------------------------+
  14. // | This library is free software; you can redistribute it and/or modify |
  15. // | it under the terms of the GNU Lesser General Public License as       |
  16. // | published by the Free Software Foundation; either version 2.1 of the |
  17. // | License, or (at your option) any later version.                      |
  18. // |                                                                      |
  19. // | This library is distributed in the hope that it will be useful, but  |
  20. // | WITHOUT ANY WARRANTY; without even the implied warranty of           |
  21. // | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU    |
  22. // | Lesser General Public License for more details.                      |
  23. // |                                                                      |
  24. // | You should have received a copy of the GNU Lesser General Public     |
  25. // | License along with this library; if not, write to the Free Software  |
  26. // | Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 |
  27. // | USA.                                                                 |
  28. // +----------------------------------------------------------------------+
  29. //
  30.  
  31. // }}}
  32.  
  33. /**
  34.  * Encode/decode Internationalized Domain Names.
  35.  *
  36.  * The class allows to convert internationalized domain names
  37.  * (see RFC 3490 for details) as they can be used with various registries worldwide
  38.  * to be translated between their original (localized) form and their encoded form
  39.  * as it will be used in the DNS (Domain Name System).
  40.  *
  41.  * The class provides two public methods, encode() and decode(), which do exactly
  42.  * what you would expect them to do. You are allowed to use complete domain names,
  43.  * simple strings and complete email addresses as well. That means, that you might
  44.  * use any of the following notations:
  45.  *
  46.  * - www.nörgler.com
  47.  * - xn--nrgler-wxa
  48.  * - xn--brse-5qa.xn--knrz-1ra.info
  49.  *
  50.  * Unicode input might be given as either UTF-8 string, UCS-4 string or UCS-4
  51.  * array. Unicode output is available in the same formats.
  52.  * You can select your preferred format via {@link set_paramter()}.
  53.  *
  54.  * ACE input and output is always expected to be ASCII.
  55.  *
  56.  * @author  Matthias Sommerfeld <[email protected]>
  57.  * @version 0.4.2
  58.  *
  59.  */
  60.  
  61. class idna_convert
  62. {
  63.     // {{{ npdata
  64.         /**
  65.      * Holds all relevant mapping tables, loaded from a seperate file on construct
  66.      * See RFC3454 for details
  67.      *
  68.      * @var array 
  69.      * @access private
  70.      */
  71.     var $_np_ = array();
  72.     // }}}
  73.  
  74.  
  75.     // Internal settings, do not mess with them
  76.         var $_punycode_prefix = 'xn--';
  77.     var $_invalid_ucs =     0x80000000;
  78.     var $_max_ucs =         0x10FFFF;
  79.     var $_base =            36;
  80.     var $_tmin =            1;
  81.     var $_tmax =            26;
  82.     var $_skew =            38;
  83.     var $_damp =            700;
  84.     var $_initial_bias =    72;
  85.     var $_initial_n =       0x80;
  86.     var $_sbase =           0xAC00;
  87.     var $_lbase =           0x1100;
  88.     var $_vbase =           0x1161;
  89.     var $_tbase =           0x11a7;
  90.     var $_lcount =          19;
  91.     var $_vcount =          21;
  92.     var $_tcount =          28;
  93.     var $_ncount =          588;   // _vcount * _tcount
  94.         var $_scount =          11172; // _lcount * _tcount * _vcount
  95.         var $_error =           false;
  96.  
  97.     // See set_parameter() for details of how to change the following settings
  98.     // from within your script / application
  99.         var $_api_encoding   =  'utf8'; // Default input charset is UTF-8
  100.         var $_allow_overlong =  false;  // Overlong UTF-8 encodings are forbidden
  101.         var $_strict_mode    =  false;  // Behave strict or not
  102.  
  103.     // The constructor
  104.         function idna_convert($options = false)
  105.     {
  106.         $this->slast = $this->_sbase + $this->_lcount * $this->_vcount * $this->_tcount;
  107.         if (function_exists('file_get_contents')) {
  108.             $this->_np_ = unserialize(file_get_contents(dirname(__FILE__).'/npdata.ser'));
  109.         } else {
  110.             $this->_np_ = unserialize(join('', file(dirname(__FILE__).'/npdata.ser')));
  111.         }
  112.         // If parameters are given, pass these to the respective method
  113.         if (is_array($options)) {
  114.             return $this->set_parameter($options);
  115.         }
  116.         return true;
  117.     }
  118.  
  119.     /**
  120.     * Sets a new option value. Available options and values:
  121.     * [encoding - Use either UTF-8, UCS4 as array or UCS4 as string as input ('utf8' for UTF-8,
  122.     *         'ucs4_string' and 'ucs4_array' respectively for UCS4); The output is always UTF-8]
  123.     * [overlong - Unicode does not allow unnecessarily long encodings of chars,
  124.     *             to allow this, set this parameter to true, else to false;
  125.     *             default is false.]
  126.     * [strict - true: strict mode, good for registration purposes - Causes errors
  127.     *           on failures; false: loose mode, ideal for "wildlife" applications
  128.     *           by silently ignoring errors and returning the original input instead
  129.     *
  130.     * @param    mixed     Parameter to set (string: single parameter; array of Parameter => Value pairs)
  131.     * @param    string    Value to use (if parameter 1 is a string)
  132.     * @return   boolean   true on success, false otherwise
  133.     * @access   public
  134.     */
  135.     function set_parameter($option, $value = false)
  136.     {
  137.         if (!is_array($option)) {
  138.             $option = array($option => $value);
  139.         }
  140.         foreach ($option as $k => $v) {
  141.             switch ($k) {
  142.             case 'encoding':
  143.                 switch ($v) {
  144.                 case 'utf8':
  145.                 case 'ucs4_string':
  146.                 case 'ucs4_array':
  147.                     $this->_api_encoding = $v;
  148.                     break;
  149.                 default:
  150.                     $this->_error('Set Parameter: Unknown parameter '.$v.' for option '.$k);
  151.                     return false;
  152.                 }
  153.                 break;
  154.             case 'overlong':
  155.                 $this->_allow_overlong = ($v) ? true : false;
  156.                 break;
  157.             case 'strict':
  158.                 $this->_strict_mode = ($v) ? true : false;
  159.                 break;
  160.             default:
  161.                 $this->_error('Set Parameter: Unknown option '.$k);
  162.                 return false;
  163.             }
  164.         }
  165.         return true;
  166.     }
  167.  
  168.     /**
  169.     * Decode a given ACE domain name
  170.     * @param    string   Domain name (ACE string)
  171.     *  [@param    string   Desired output encoding, see {@link set_parameter}]
  172.     * @return   string   Decoded Domain name (UTF-8 or UCS-4)
  173.     * @access   public
  174.     */
  175.     function decode($input, $one_time_encoding = false)
  176.     {
  177.         // Optionally set
  178.         if ($one_time_encoding) {
  179.             switch ($one_time_encoding) {
  180.             case 'utf8':
  181.             case 'ucs4_string':
  182.             case 'ucs4_array':
  183.                 break;
  184.             default:
  185.                 $this->_error('Unknown encoding '.$one_time_encoding);
  186.                 return false;
  187.             }
  188.         }
  189.         // Make sure to drop any newline characters around
  190.         $input = trim($input);
  191.  
  192.         // Negotiate input and try to determine, wether it is a plain string,
  193.         // an email address or something like a complete URL
  194.         if (strpos($input, '@')) { // Maybe it is an email address
  195.             // No no in strict mode
  196.             if ($this->_strict_mode) {
  197.                 $this->_error('Only simple domain name parts can be handled in strict mode');
  198.                 return false;
  199.             }
  200.             list($email_pref, $input) = explode('@', $input, 2);
  201.             $arr = explode('.', $input);
  202.             foreach ($arr as $k => $v) {
  203.                 $conv = $this->_decode($v);
  204.                 if ($conv) $arr[$k] = $conv;
  205.             }
  206.             $return = $email_pref . '@' . join('.', $arr);
  207.         } elseif (preg_match('![:\./]!', $input)) { // Or a complete domain name (with or without paths / parameters)
  208.             // No no in strict mode
  209.             if ($this->_strict_mode) {
  210.                 $this->_error('Only simple domain name parts can be handled in strict mode');
  211.                 return false;
  212.             }
  213.             $parsed = parse_url($input);
  214.             if (isset($parsed['host'])) {
  215.                 $arr = explode('.', $parsed['host']);
  216.                 foreach ($arr as $k => $v) {
  217.                     $conv = $this->_decode($v);
  218.                     if ($conv) $arr[$k] = $conv;
  219.                 }
  220.                 $parsed['host'] = join('.', $arr);
  221.                 $return =
  222.                         (empty($parsed['scheme']) ? '' : $parsed['scheme'].(strtolower($parsed['scheme']) == 'mailto' ? ':' : '://'))
  223.                         .(empty($parsed['user']) ? '' : $parsed['user'].(empty($parsed['pass']) ? '' : ':'.$parsed['pass']).'@')
  224.                         .$parsed['host']
  225.                         .(empty($parsed['port']) ? '' : ':'.$parsed['port'])
  226.                         .$parsed['path']
  227.                         .(empty($parsed['query']) ? '' : '?'.$parsed['query'])
  228.                         .(empty($parsed['fragment']) ? '' : '#'.$parsed['fragment']);
  229.             } else { // parse_url seems to have failed, try without it
  230.                 $arr = explode('.', $input);
  231.                 foreach ($arr as $k => $v) {
  232.                     $conv = $this->_decode($v);
  233.                     if ($conv) $arr[$k] = $conv;
  234.                 }
  235.                 $return = join('.', $arr);
  236.             }
  237.         } else { // Otherwise we consider it being a pure domain name string
  238.             $return = $this->_decode($input);
  239.         }
  240.         // The output is UTF-8 by default, other output formats need conversion here
  241.         // If one time encoding is given, use this, else the objects property
  242.         switch (($one_time_encoding) ? $one_time_encoding : $this->_api_encoding) {
  243.         case 'utf8':
  244.             return $return;
  245.             break;
  246.         case 'ucs4_string':
  247.            return $this->_ucs4_to_ucs4_string($this->_utf8_to_ucs4($return));
  248.            break;
  249.         case 'ucs4_array':
  250.             return $this->_utf8_to_ucs4($return);
  251.             break;
  252.         default:
  253.             $this->_error('Unsupported output format');
  254.             return false;
  255.         }
  256.     }
  257.  
  258.     /**
  259.     * Encode a given UTF-8 domain name
  260.     * @param    string   Domain name (UTF-8 or UCS-4)
  261.     *  [@param    string   Desired input encoding, see {@link set_parameter}]
  262.     * @return   string   Encoded Domain name (ACE string)
  263.     * @access   public
  264.     */
  265.     function encode($decoded, $one_time_encoding = false)
  266.     {
  267.         // Forcing conversion of input to UCS4 array
  268.         // If one time encoding is given, use this, else the objects property
  269.         switch (($one_time_encoding) ? $one_time_encoding : $this->_api_encoding) {
  270.         case 'utf8':
  271.             $decoded = $this->_utf8_to_ucs4($decoded);
  272.             break;
  273.         case 'ucs4_string':
  274.            $decoded = $this->_ucs4_string_to_ucs4($decoded);
  275.         case 'ucs4_array':
  276.            break;
  277.         default:
  278.             // $this->_error('Unsupported input format: '.$this->_api_encoding);
  279.             $this->_error('Unsupported input format');
  280.             return false;
  281.         }
  282.  
  283.         // No input, no output, what else did you expect?
  284.         if (empty($decoded)) return '';
  285.  
  286.         // Anchors for iteration
  287.         $last_begin = 0;
  288.         // Output string
  289.         $output = '';
  290.         foreach ($decoded as $k => $v) {
  291.             // Make sure to use just the plain dot
  292.             switch($v) {
  293.             case 0x3002:
  294.             case 0xFF0E:
  295.             case 0xFF61:
  296.                 $decoded[$k] = 0x2E;
  297.                 // It's right, no break here
  298.                 // The codepoints above have to be converted to dots anyway
  299.  
  300.             // Stumbling across an anchoring character
  301.             case 0x2E:
  302.             case 0x2F:
  303.             case 0x3A:
  304.             case 0x3F:
  305.             case 0x40:
  306.                 // Neither email addresses nor URLs allowed in strict mode
  307.                 if ($this->_strict_mode) {
  308.                    $this->_error('Neither email addresses nor URLs are allowed in strict mode.');
  309.                    return false;
  310.                 } else {
  311.                     // Skip first char
  312.                     if ($k) {
  313.                         $encoded = '';
  314.                         $encoded = $this->_encode(array_slice($decoded, $last_begin, (($k)-$last_begin)));
  315.                         if ($encoded) {
  316.                             $output .= $encoded;
  317.                         } else {
  318.                             $output .= $this->_ucs4_to_utf8(array_slice($decoded, $last_begin, (($k)-$last_begin)));
  319.                         }
  320.                         $output .= chr($decoded[$k]);
  321.                     }
  322.                     $last_begin = $k + 1;
  323.                 }
  324.             }
  325.         }
  326.         // Catch the rest of the string
  327.         if ($last_begin) {
  328.             $inp_len = sizeof($decoded);
  329.             $encoded = '';
  330.             $encoded = $this->_encode(array_slice($decoded, $last_begin, (($inp_len)-$last_begin)));
  331.             if ($encoded) {
  332.                 $output .= $encoded;
  333.             } else {
  334.                 $output .= $this->_ucs4_to_utf8(array_slice($decoded, $last_begin, (($inp_len)-$last_begin)));
  335.             }
  336.             return $output;
  337.         } else {
  338.             if ($output = $this->_encode($decoded)) {
  339.                 return $output;
  340.             } else {
  341.                 return $this->_ucs4_to_utf8($decoded);
  342.             }
  343.         }
  344.     }
  345.  
  346.     /**
  347.     * Use this method to get the last error ocurred
  348.     * @param    void 
  349.     * @return   string   The last error, that occured
  350.     * @access   public
  351.     */
  352.     function get_last_error()
  353.     {
  354.         return $this->_error;
  355.     }
  356.  
  357.     /**
  358.     * The actual decoding algorithm
  359.     * @access   private
  360.     */
  361.     function _decode($encoded)
  362.     {
  363.         // We do need to find the Punycode prefix
  364.         if (!preg_match('!^'.preg_quote($this->_punycode_prefix, '!').'!', $encoded)) {
  365.             $this->_error('This is not a punycode string');
  366.             return false;
  367.         }
  368.         $encode_test = preg_replace('!^'.preg_quote($this->_punycode_prefix, '!').'!', '', $encoded);
  369.         // If nothing left after removing the prefix, it is hopeless
  370.         if (!$encode_test) {
  371.             $this->_error('The given encoded string was empty');
  372.             return false;
  373.         }
  374.         // Find last occurence of the delimiter
  375.         $delim_pos = strrpos($encoded, '-');
  376.         if ($delim_pos > strlen($this->_punycode_prefix)) {
  377.             for ($k = strlen($this->_punycode_prefix); $k < $delim_pos; ++$k) {
  378.                 $decoded[] = ord($encoded{$k});
  379.             }
  380.         } else {
  381.             $decoded = array();
  382.         }
  383.         $deco_len = count($decoded);
  384.         $enco_len = strlen($encoded);
  385.  
  386.         // Wandering through the strings; init
  387.         $is_first = true;
  388.         $bias     = $this->_initial_bias;
  389.         $idx      = 0;
  390.         $char     = $this->_initial_n;
  391.  
  392.         for ($enco_idx = ($delim_pos) ? ($delim_pos + 1) : 0; $enco_idx < $enco_len; ++$deco_len) {
  393.             for ($old_idx = $idx, $w = 1, $k = $this->_base; 1 ; $k += $this->_base) {
  394.                 $digit = $this->_decode_digit($encoded{$enco_idx++});
  395.                 $idx += $digit * $w;
  396.                 $t = ($k <= $bias) ? $this->_tmin :
  397.                         (($k >= $bias + $this->_tmax) ? $this->_tmax : ($k - $bias));
  398.                 if ($digit < $t) break;
  399.                 $w = (int) ($w * ($this->_base - $t));
  400.             }
  401.             $bias = $this->_adapt($idx - $old_idx, $deco_len + 1, $is_first);
  402.             $is_first = false;
  403.             $char += (int) ($idx / ($deco_len + 1));
  404.             $idx %= ($deco_len + 1);
  405.             if ($deco_len > 0) {
  406.                 // Make room for the decoded char
  407.                 for ($i = $deco_len; $i > $idx; $i--) {
  408.                     $decoded[$i] = $decoded[($i - 1)];
  409.                 }
  410.             }
  411.             $decoded[$idx++] = $char;
  412.         }
  413.         return $this->_ucs4_to_utf8($decoded);
  414.     }
  415.  
  416.     /**
  417.     * The actual encoding algorithm
  418.     * @access   private
  419.     */
  420.     function _encode($decoded)
  421.     {
  422.         // We cannot encode a domain name containing the Punycode prefix
  423.         $extract = strlen($this->_punycode_prefix);
  424.         $check_pref = $this->_utf8_to_ucs4($this->_punycode_prefix);
  425.         $check_deco = array_slice($decoded, 0, $extract);
  426.  
  427.         if ($check_pref == $check_deco) {
  428.             $this->_error('This is already a punycode string');
  429.             return false;
  430.         }
  431.         // We will not try to encode strings consisting of basic code points only
  432.         $encodable = false;
  433.         foreach ($decoded as $k => $v) {
  434.             if ($v > 0x7a) {
  435.                 $encodable = true;
  436.                 break;
  437.             }
  438.         }
  439.         if (!$encodable) {
  440.             $this->_error('The given string does not contain encodable chars');
  441.             return false;
  442.         }
  443.  
  444.         // Do NAMEPREP
  445.         $decoded = $this->_nameprep($decoded);
  446.         if (!$decoded || !is_array($decoded)) return false; // NAMEPREP failed
  447.  
  448.         $deco_len  = count($decoded);
  449.         if (!$deco_len) return false; // Empty array
  450.  
  451.         $codecount = 0; // How many chars have been consumed
  452.  
  453.         $encoded = '';
  454.         // Copy all basic code points to output
  455.         for ($i = 0; $i < $deco_len; ++$i) {
  456.             $test = $decoded[$i];
  457.             // Will match [0-9a-zA-Z-]
  458.             if ((0x2F < $test && $test < 0x40)
  459.                     || (0x40 < $test && $test < 0x5B)
  460.                     || (0x60 < $test && $test <= 0x7B)
  461.                     || (0x2D == $test)) {
  462.                 $encoded .= chr($decoded[$i]);
  463.                 $codecount++;
  464.             }
  465.         }
  466.         if ($codecount == $deco_len) return $encoded; // All codepoints were basic ones
  467.  
  468.         // Start with the prefix; copy it to output
  469.         $encoded = $this->_punycode_prefix.$encoded;
  470.  
  471.         // If we have basic code points in output, add an hyphen to the end
  472.         if ($codecount) $encoded .= '-';
  473.  
  474.         // Now find and encode all non-basic code points
  475.         $is_first  = true;
  476.         $cur_code  = $this->_initial_n;
  477.         $bias      = $this->_initial_bias;
  478.         $delta     = 0;
  479.         while ($codecount < $deco_len) {
  480.             // Find the smallest code point >= the current code point and
  481.             // remember the last ouccrence of it in the input
  482.             for ($i = 0, $next_code = $this->_max_ucs; $i < $deco_len; $i++) {
  483.                 if ($decoded[$i] >= $cur_code && $decoded[$i] <= $next_code) {
  484.                     $next_code = $decoded[$i];
  485.                 }
  486.             }
  487.  
  488.             $delta += ($next_code - $cur_code) * ($codecount + 1);
  489.             $cur_code = $next_code;
  490.  
  491.             // Scan input again and encode all characters whose code point is $cur_code
  492.             for ($i = 0; $i < $deco_len; $i++) {
  493.                 if ($decoded[$i] < $cur_code) {
  494.                     $delta++;
  495.                 } elseif ($decoded[$i] == $cur_code) {
  496.                     for ($q = $delta, $k = $this->_base; 1; $k += $this->_base) {
  497.                         $t = ($k <= $bias) ? $this->_tmin :
  498.                                 (($k >= $bias + $this->_tmax) ? $this->_tmax : $k - $bias);
  499.                         if ($q < $t) break;
  500.                         $encoded .= $this->_encode_digit(ceil($t + (($q - $t) % ($this->_base - $t))));
  501.                         $q = ($q - $t) / ($this->_base - $t);
  502.                     }
  503.                     $encoded .= $this->_encode_digit($q);
  504.                     $bias = $this->_adapt($delta, $codecount+1, $is_first);
  505.                     $codecount++;
  506.                     $delta = 0;
  507.                     $is_first = false;
  508.                 }
  509.             }
  510.             $delta++;
  511.             $cur_code++;
  512.         }
  513.         return $encoded;
  514.     }
  515.  
  516.     /**
  517.     * Adapt the bias according to the current code point and position
  518.     * @access   private
  519.     */
  520.     function _adapt($delta, $npoints, $is_first)
  521.     {
  522.         $delta = (int) ($is_first ? ($delta / $this->_damp) : ($delta / 2));
  523.         $delta += (int) ($delta / $npoints);
  524.         for ($k = 0; $delta > (($this->_base - $this->_tmin) * $this->_tmax) / 2; $k += $this->_base) {
  525.             $delta = (int) ($delta / ($this->_base - $this->_tmin));
  526.         }
  527.         return (int) ($k + ($this->_base - $this->_tmin + 1) * $delta / ($delta + $this->_skew));
  528.     }
  529.  
  530.     /**
  531.     * Encoding a certain digit
  532.     * @access   private
  533.     */
  534.     function _encode_digit($d)
  535.     {
  536.         return chr($d + 22 + 75 * ($d < 26));
  537.     }
  538.  
  539.     /**
  540.     * Decode a certain digit
  541.     * @access   private
  542.     */
  543.     function _decode_digit($cp)
  544.     {
  545.         $cp = ord($cp);
  546.         return ($cp - 48 < 10) ? $cp - 22 : (($cp - 65 < 26) ? $cp - 65 : (($cp - 97 < 26) ? $cp - 97 : $this->_base));
  547.     }
  548.  
  549.     /**
  550.     * Internal error handling method
  551.     * @access   private
  552.     */
  553.     function _error($error = '')
  554.     {
  555.         $this->_error = $error;
  556.     }
  557.  
  558.     /**
  559.     * Do Nameprep according to RFC3491 and RFC3454
  560.     * @param    array    Unicode Characters
  561.     * @return   string   Unicode Characters, Nameprep'd
  562.     * @access   private
  563.     */
  564.     function _nameprep($input)
  565.     {
  566.         $output = array();
  567.         $error = false;
  568.         //
  569.         // Mapping
  570.         // Walking through the input array, performing the required steps on each of
  571.         // the input chars and putting the result into the output array
  572.         // While mapping required chars we apply the cannonical ordering
  573.  
  574.         // $this->_show_hex($input);
  575.         foreach ($input as $v) {
  576.             // Map to nothing == skip that code point
  577.             if (in_array($v, $this->_np_['map_nothing'])) continue;
  578.  
  579.             // Try to find prohibited input
  580.             if (in_array($v, $this->_np_['prohibit']) || in_array($v, $this->_np_['general_prohibited'])) {
  581.                 $this->_error('NAMEPREP: Prohibited input U+'.sprintf('%08X', $v));
  582.                 return false;
  583.             }
  584.             foreach ($this->_np_['prohibit_ranges'] as $range) {
  585.                 if ($range[0] <= $v && $v <= $range[1]) {
  586.                     $this->_error('NAMEPREP: Prohibited input U+'.sprintf('%08X', $v));
  587.                     return false;
  588.                 }
  589.             }
  590.             //
  591.             // Hangul syllable decomposition
  592.             if (0xAC00 <= $v && $v <= 0xD7AF) {
  593.                 foreach ($this->_hangul_decompose($v) as $out) {
  594.                     $output[] = $out;
  595.                 }
  596.             // There's a decomposition mapping for that code point
  597.             } elseif (isset($this->_np_['replacemaps'][$v])) {
  598.                 foreach ($this->_apply_cannonical_ordering($this->_np_['replacemaps'][$v]) as $out) {
  599.                     $output[] = $out;
  600.                 }
  601.             } else {
  602.                 $output[] = $v;
  603.             }
  604.         }
  605.         //
  606.         // Combine code points
  607.         //
  608.         $last_class   = 0;
  609.         $last_starter = 0;
  610.         $out_len      = count($output);
  611.         for ($i = 0; $i < $out_len; ++$i) {
  612.             $class = $this->_get_combining_class($output[$i]);
  613.             if ((!$last_class || $last_class != $class) && $class) {
  614.                 // Try to match
  615.                 $seq_len = $i - $last_starter;
  616.                 $out = $this->_combine(array_slice($output, $last_starter, $seq_len));
  617.                 // On match: Replace the last starter with the composed character and remove
  618.                 // the now redundant non-starter(s)
  619.                 if ($out) {
  620.                     $output[$last_starter] = $out;
  621.                     if (count($out) != $seq_len) {
  622.                         for ($j = $i+1; $j < $out_len; ++$j) {
  623.                             $output[$j-1] = $output[$j];
  624.                         }
  625.                         unset($output[$out_len]);
  626.                     }
  627.                     // Rewind the for loop by one, since there can be more possible compositions
  628.                     $i--;
  629.                     $out_len--;
  630.                     $last_class = ($i == $last_starter) ? 0 : $this->_get_combining_class($output[$i-1]);
  631.                     continue;
  632.                 }
  633.             }
  634.             if (!$class) { // The current class is 0
  635.                 $last_starter = $i;
  636.             }
  637.             $last_class = $class;
  638.         }
  639.         return $output;
  640.     }
  641.  
  642.     /**
  643.     * Decomposes a Hangul syllable
  644.     * (see http://www.unicode.org/unicode/reports/tr15/#Hangul
  645.     * @param    integer  32bit UCS4 code point
  646.     * @return   array    Either Hangul Syllable decomposed or original 32bit value as one value array
  647.     * @access   private
  648.     */
  649.     function _hangul_decompose($char)
  650.     {
  651.         $sindex = $char - $this->_sbase;
  652.         if ($sindex < 0 || $sindex >= $this->_scount) {
  653.             return array($char);
  654.         }
  655.         $result = array();
  656.         $T = $this->_tbase + $sindex % $this->_tcount;
  657.         $result[] = (int) ($this->_lbase + $sindex / $this->_ncount);
  658.         $result[] = (int) ($this->_vbase + ($sindex % $this->_ncount) / $this->_tcount);
  659.         if ($T != $this->_tbase) $result[] = $T;
  660.         return $result;
  661.     }
  662.  
  663.     /**
  664.     * Ccomposes a Hangul syllable
  665.     * (see http://www.unicode.org/unicode/reports/tr15/#Hangul
  666.     * @param    array    Decomposed UCS4 sequence
  667.     * @return   array    UCS4 sequence with syllables composed
  668.     * @access   private
  669.     */
  670.     function _hangul_compose($input)
  671.     {
  672.         $inp_len = count($input);
  673.         if (!$inp_len) return array();
  674.         $result = array();
  675.         $last = $input[0];
  676.         $result[] = $last; // copy first char from input to output
  677.  
  678.         for ($i = 1; $i < $inp_len; ++$i) {
  679.             $char = $input[$i];
  680.  
  681.             // Find out, wether two current characters from L and V
  682.             $lindex = $last - $this->_lbase;
  683.             if (0 <= $lindex && $lindex < $this->_lcount) {
  684.                 $vindex = $char - $this->_vbase;
  685.                 if (0 <= $vindex && $vindex < $this->_vcount) {
  686.                     // create syllable of form LV
  687.                     $last = ($this->_sbase + ($lindex * $this->_vcount + $vindex) * $this->_tcount);
  688.                     $out_off = count($result) - 1;
  689.                     $result[$out_off] = $last; // reset last
  690.                     continue; // discard char
  691.                 }
  692.             }
  693.  
  694.             // Find out, wether two current characters are LV and T
  695.             $sindex = $last - $this->_sbase;
  696.             if (0 <= $sindex && $sindex < $this->_scount && ($sindex % $this->_tcount) == 0) {
  697.                 $tindex = $char - $this->_tbase;
  698.                 if (0 <= $tindex && $tindex <= $this->_tcount) {
  699.                     // create syllable of form LVT
  700.                     $last += $tindex;
  701.                     $out_off = count($result) - 1;
  702.                     $result[$out_off] = $last; // reset last
  703.                     continue; // discard char
  704.                 }
  705.             }
  706.             // if neither case was true, just add the character
  707.             $last = $char;
  708.             $result[] = $char;
  709.         }
  710.         return $result;
  711.     }
  712.  
  713.     /**
  714.     * Returns the combining class of a certain wide char
  715.     * @param    integer    Wide char to check (32bit integer)
  716.     * @return   integer    Combining class if found, else 0
  717.     * @access   private
  718.     */
  719.     function _get_combining_class($char)
  720.     {
  721.         return isset($this->_np_['norm_combcls'][$char]) ? $this->_np_['norm_combcls'][$char] : 0;
  722.     }
  723.  
  724.     /**
  725.     * Apllies the cannonical ordering of a decomposed UCS4 sequence
  726.     * @param    array      Decomposed UCS4 sequence
  727.     * @return   array      Ordered USC4 sequence
  728.     * @access   private
  729.     */
  730.     function _apply_cannonical_ordering($input)
  731.     {
  732.         $swap = true;
  733.         $size = count($input);
  734.         while ($swap) {
  735.             $swap = false;
  736.             $last = $this->_get_combining_class($input[0]);
  737.             for ($i = 0; $i < $size - 1; ++$i) {
  738.                 $next = $this->_get_combining_class($input[$i+1]);
  739.                 if ($next != 0 && $last > $next) {
  740.                     // Move item leftward until it fits
  741.                     for ($j = $i + 1; $j > 0; --$j) {
  742.                         if ($this->_get_combining_class($input[$j - 1]) <= $next) break;
  743.                         $t = $input[$j];
  744.                         $input[$j] = $input[$j - 1];
  745.                         $input[$j - 1] = $t;
  746.                         $swap = 1;
  747.                     }
  748.                     // Reentering the loop looking at the old character again
  749.                     $next = $last;
  750.                 }
  751.                 $last = $next;
  752.             }
  753.         }
  754.         return $input;
  755.     }
  756.  
  757.     /**
  758.     * Do composition of a sequence of starter and non-starter
  759.     * @param    array      UCS4 Decomposed sequence
  760.     * @return   array      Ordered USC4 sequence
  761.     * @access   private
  762.     */
  763.     function _combine($input)
  764.     {
  765.         $inp_len = count($input);
  766.         // Is it a Hangul syllable?
  767.         if (1 != $inp_len) {
  768.             $hangul = $this->_hangul_compose($input);
  769.             if (count($hangul) != $inp_len) return $hangul; // This place is probably wrong
  770.         }
  771.         foreach ($this->_np_['replacemaps'] as $np_src => $np_target) {
  772.             if ($np_target[0] != $input[0]) continue;
  773.             if (count($np_target) != $inp_len) continue;
  774.             $hit = false;
  775.             foreach ($input as $k2 => $v2) {
  776.                 if ($v2 == $np_target[$k2]) {
  777.                     $hit = true;
  778.                 } else {
  779.                     $hit = false;
  780.                     break;
  781.                 }
  782.             }
  783.             if ($hit) return $np_src;
  784.         }
  785.         return false;
  786.     }
  787.  
  788.     /**
  789.     * This converts an UTF-8 encoded string to its UCS-4 representation
  790.     * By talking about UCS-4 "strings" we mean arrays of 32bit integers representing
  791.     * each of the "chars". This is due to PHP not being able to handle strings with
  792.     * bit depth different from 8. This apllies to the reverse method _ucs4_to_utf8(), too.
  793.     * The following UTF-8 encodings are supported:
  794.     * bytes bits  representation
  795.     * 1        7  0xxxxxxx
  796.     * 2       11  110xxxxx 10xxxxxx
  797.     * 3       16  1110xxxx 10xxxxxx 10xxxxxx
  798.     * 4       21  11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
  799.     * 5       26  111110xx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
  800.     * 6       31  1111110x 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
  801.     * Each x represents a bit that can be used to store character data.
  802.     * The five and six byte sequences are part of Annex D of ISO/IEC 10646-1:2000
  803.     * @access   private
  804.     */
  805.     function _utf8_to_ucs4($input)
  806.     {
  807.         $output = array();
  808.         $out_len = 0;
  809.         $inp_len = strlen($input);
  810.         $mode = 'next';
  811.         $test = 'none';
  812.         for ($k = 0; $k < $inp_len; ++$k) {
  813.             $v = ord($input{$k}); // Extract byte from input string
  814.  
  815.             if ($v < 128) { // We found an ASCII char - put into stirng as is
  816.                 $output[$out_len] = $v;
  817.                 ++$out_len;
  818.                 if ('add' == $mode) {
  819.                     $this->_error('Conversion from UTF-8 to UCS-4 failed: malformed input at byte '.$k);
  820.                     return false;
  821.                 }
  822.                 continue;
  823.             }
  824.             if ('next' == $mode) { // Try to find the next start byte; determine the width of the Unicode char
  825.                 $start_byte = $v;
  826.                 $mode = 'add';
  827.                 $test = 'range';
  828.                 if ($v >> 5 == 6) { // &110xxxxx 10xxxxx
  829.                     $next_byte = 0; // Tells, how many times subsequent bitmasks must rotate 6bits to the left
  830.                     $v = ($v - 192) << 6;
  831.                 } elseif ($v >> 4 == 14) { // &1110xxxx 10xxxxxx 10xxxxxx
  832.                     $next_byte = 1;
  833.                     $v = ($v - 224) << 12;
  834.                 } elseif ($v >> 3 == 30) { // &11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
  835.                     $next_byte = 2;
  836.                     $v = ($v - 240) << 18;
  837.                 } elseif ($v >> 2 == 62) { // &111110xx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
  838.                     $next_byte = 3;
  839.                     $v = ($v - 248) << 24;
  840.                 } elseif ($v >> 1 == 126) { // &1111110x 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
  841.                     $next_byte = 4;
  842.                     $v = ($v - 252) << 30;
  843.                 } else {
  844.                     $this->_error('This might be UTF-8, but I don\'t understand it at byte '.$k);
  845.                     return false;
  846.                 }
  847.                 if ('add' == $mode) {
  848.                     $output[$out_len] = (int) $v;
  849.                     ++$out_len;
  850.                     continue;
  851.                 }
  852.             }
  853.             if ('add' == $mode) {
  854.                 if (!$this->_allow_overlong && $test == 'range') {
  855.                     $test = 'none';
  856.                     if (($v < 0xA0 && $start_byte == 0xE0) || ($v < 0x90 && $start_byte == 0xF0) || ($v > 0x8F && $start_byte == 0xF4)) {
  857.                         $this->_error('Bogus UTF-8 character detected (out of legal range) at byte '.$k);
  858.                         return false;
  859.                     }
  860.                 }
  861.                 if ($v >> 6 == 2) { // Bit mask must be 10xxxxxx
  862.                     $v = ($v - 128) << ($next_byte * 6);
  863.                     $output[($out_len - 1)] += $v;
  864.                     --$next_byte;
  865.                 } else {
  866.                     $this->_error('Conversion from UTF-8 to UCS-4 failed: malformed input at byte '.$k);
  867.                     return false;
  868.                 }
  869.                 if ($next_byte < 0) {
  870.                     $mode = 'next';
  871.                 }
  872.             }
  873.         } // for
  874.         return $output;
  875.     }
  876.  
  877.     /**
  878.     * Convert UCS-4 string into UTF-8 string
  879.     * See _utf8_to_ucs4() for details
  880.     * @access   private
  881.     */
  882.     function _ucs4_to_utf8($input)
  883.     {
  884.         $output = '';
  885.         foreach ($input as $v) {
  886.             // $v = ord($v);
  887.             if ($v < 128) { // 7bit are transferred literally
  888.                 $output .= chr($v);
  889.             } elseif ($v < (1 << 11)) { // 2 bytes
  890.                 $output .= chr(192 + ($v >> 6)) . chr(128 + ($v & 63));
  891.             } elseif ($v < (1 << 16)) { // 3 bytes
  892.                 $output .= chr(224 + ($v >> 12)) . chr(128 + (($v >> 6) & 63)) . chr(128 + ($v & 63));
  893.             } elseif ($v < (1 << 21)) { // 4 bytes
  894.                 $output .= chr(240 + ($v >> 18)) . chr(128 + (($v >> 12) & 63))
  895.                          . chr(128 + (($v >> 6) & 63)) . chr(128 + ($v & 63));
  896.             } elseif ($v < (1 << 26)) { // 5 bytes
  897.                 $output .= chr(248 + ($v >> 24)) . chr(128 + (($v >> 18) & 63))
  898.                          . chr(128 + (($v >> 12) & 63)) . chr(128 + (($v >> 6) & 63))
  899.                          . chr(128 + ($v & 63));
  900.             } elseif ($v < (1 << 31)) { // 6 bytes
  901.                 $output .= chr(252 + ($v >> 30)) . chr(128 + (($v >> 24) & 63))
  902.                          . chr(128 + (($v >> 18) & 63)) . chr(128 + (($v >> 12) & 63))
  903.                          . chr(128 + (($v >> 6) & 63)) . chr(128 + ($v & 63));
  904.             } else {
  905.                 $this->_error('Conversion from UCS-4 to UTF-8 failed: malformed input at byte '.$k);
  906.                 return false;
  907.             }
  908.         }
  909.         return $output;
  910.     }
  911.  
  912.     /**
  913.      * Convert UCS-4 array into UCS-4 string
  914.      *
  915.      * @access   private
  916.      */
  917.     function _ucs4_to_ucs4_string($input)
  918.     {
  919.         $output = '';
  920.         // Take array values and split output to 4 bytes per value
  921.         // The bit mask is 255, which reads &11111111
  922.         foreach ($input as $v) {
  923.             $output .= chr(($v >> 24) & 255)
  924.                      . chr(($v >> 16) & 255)
  925.                      . chr(($v >> 8) & 255)
  926.                      . chr($v & 255);
  927.         }
  928.         return $output;
  929.     }
  930.  
  931.     /**
  932.      * Convert UCS-4 strin into UCS-4 garray
  933.      *
  934.      * @access   private
  935.      */
  936.     function _ucs4_string_to_ucs4($input)
  937.     {
  938.         $output = array();
  939.  
  940.         $inp_len = strlen($input);
  941.         // Input length must be dividable by 4
  942.         if ($inp_len % 4) {
  943.             $this->_error('Input UCS4 string is broken');
  944.             return false;
  945.         }
  946.  
  947.         // Empty input - return empty output
  948.         if (!$inp_len) return $output;
  949.  
  950.         for ($i = 0, $out_len = -1; $i < $inp_len; ++$i) {
  951.             // Increment output position every 4 input bytes
  952.             if (!($i % 4)) {
  953.                 $out_len++;
  954.                 $output[$out_len] = 0;
  955.             }
  956.             $output[$out_len] += ord($input{$i}) << (8 * (3 - ($i % 4) ) );
  957.         }
  958.         return $output;
  959.     }
  960. }
  961.  
  962. /**
  963. * Adapter class for aligning the API of idna_convert with that of
  964. * Net_IDNA
  965. * @author  Matthias Sommerfeld <[email protected]>
  966. */
  967. class Net_IDNA_php4 extends idna_convert
  968. {
  969.     /**
  970.     * Sets a new option value. Available options and values:
  971.     * [encoding - Use either UTF-8, UCS4 as array or UCS4 as string as input ('utf8' for UTF-8,
  972.     *         'ucs4_string' and 'ucs4_array' respectively for UCS4); The output is always UTF-8]
  973.     * [overlong - Unicode does not allow unnecessarily long encodings of chars,
  974.     *             to allow this, set this parameter to true, else to false;
  975.     *             default is false.]
  976.     * [strict - true: strict mode, good for registration purposes - Causes errors
  977.     *           on failures; false: loose mode, ideal for "wildlife" applications
  978.     *           by silently ignoring errors and returning the original input instead
  979.     *
  980.     * @param    mixed     Parameter to set (string: single parameter; array of Parameter => Value pairs)
  981.     * @param    string    Value to use (if parameter 1 is a string)
  982.     * @return   boolean   true on success, false otherwise
  983.     * @access   public
  984.     */
  985.     function setParams($option, $param = false)
  986.     {
  987.         return $this->IC->set_parameters($option, $param);
  988.     }
  989. }
  990.  
  991. ?>
Documentation generated on Mon, 05 Mar 2007 21:07:30 +0000 by phpDocumentor 1.3.1