| blob | 0bcbfe2f8d8e7eca32bf31d8e1c71de90b79b854 |
1 <?php
2 /***************************************************************
3 * Copyright notice
4 *
5 * (c) 2003-2011 Kasper Skårhøj (kasperYYYY@typo3.com)
6 * All rights reserved
7 *
8 * This script is part of the Typo3 project. The Typo3 project is
9 * free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 *
14 * The GNU General Public License can be found at
15 * http://www.gnu.org/copyleft/gpl.html.
16 *
17 * This script is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
21 *
22 * This copyright notice MUST APPEAR in all copies of the script!
23 ***************************************************************/
24 /**
25 * Class for conversion between charsets.
26 *
27 * $Id$
28 *
29 * @author Kasper Skårhøj <kasperYYYY@typo3.com>
30 * @author Martin Kutschker <martin.t.kutschker@blackbox.net>
31 */
32 /**
33 * [CLASS/FUNCTION INDEX of SCRIPT]
34 *
35 *
36 *
37 * 136: class t3lib_cs
38 * 488: function parse_charset($charset)
39 * 507: function get_locale_charset($locale)
40 *
41 * SECTION: Charset Conversion functions
42 * 560: function conv($str,$fromCS,$toCS,$useEntityForNoChar=0)
43 * 600: function convArray(&$array,$fromCS,$toCS,$useEntityForNoChar=0)
44 * 617: function utf8_encode($str,$charset)
45 * 663: function utf8_decode($str,$charset,$useEntityForNoChar=0)
46 * 706: function utf8_to_entities($str)
47 * 739: function entities_to_utf8($str,$alsoStdHtmlEnt=0)
48 * 773: function utf8_to_numberarray($str,$convEntities=0,$retChar=0)
49 * 823: function UnumberToChar($cbyte)
50 * 868: function utf8CharToUnumber($str,$hex=0)
51 *
52 * SECTION: Init functions
53 * 911: function initCharset($charset)
54 * 973: function initUnicodeData($mode=null)
55 * 1198: function initCaseFolding($charset)
56 * 1260: function initToASCII($charset)
57 *
58 * SECTION: String operation functions
59 * 1331: function substr($charset,$string,$start,$len=null)
60 * 1384: function strlen($charset,$string)
61 * 1414: function crop($charset,$string,$len,$crop='')
62 * 1467: function strtrunc($charset,$string,$len)
63 * 1501: function conv_case($charset,$string,$case)
64 * 1527: function specCharsToASCII($charset,$string)
65 *
66 * SECTION: Internal string operation functions
67 * 1567: function sb_char_mapping($str,$charset,$mode,$opt='')
68 *
69 * SECTION: Internal UTF-8 string operation functions
70 * 1622: function utf8_substr($str,$start,$len=null)
71 * 1655: function utf8_strlen($str)
72 * 1676: function utf8_strtrunc($str,$len)
73 * 1698: function utf8_strpos($haystack,$needle,$offset=0)
74 * 1723: function utf8_strrpos($haystack,$needle)
75 * 1745: function utf8_char2byte_pos($str,$pos)
76 * 1786: function utf8_byte2char_pos($str,$pos)
77 * 1809: function utf8_char_mapping($str,$mode,$opt='')
78 *
79 * SECTION: Internal EUC string operation functions
80 * 1885: function euc_strtrunc($str,$len,$charset)
81 * 1914: function euc_substr($str,$start,$charset,$len=null)
82 * 1939: function euc_strlen($str,$charset)
83 * 1966: function euc_char2byte_pos($str,$pos,$charset)
84 * 2007: function euc_char_mapping($str,$charset,$mode,$opt='')
85 *
86 * TOTAL FUNCTIONS: 35
87 * (This index is automatically created/updated by the extension "extdeveval")
88 *
89 */
92 /**
93 * Notes on UTF-8
94 *
95 * Functions working on UTF-8 strings:
96 *
97 * - strchr/strstr
98 * - strrchr
99 * - substr_count
100 * - implode/explode/join
101 *
102 * Functions nearly working on UTF-8 strings:
103 *
104 * - strlen: returns the length in BYTES, if you need the length in CHARACTERS use utf8_strlen
105 * - trim/ltrim/rtrim: the second parameter 'charlist' won't work for characters not contained in 7-bit ASCII
106 * - strpos/strrpos: they return the BYTE position, if you need the CHARACTER position use utf8_strpos/utf8_strrpos
107 * - htmlentities: charset support for UTF-8 only since PHP 4.3.0
108 * - preg_*: Support compiled into PHP by default nowadays, but could be unavailable, need to use modifier
109 *
110 * Functions NOT working on UTF-8 strings:
111 *
112 * - str*cmp
113 * - stristr
114 * - stripos
115 * - substr
116 * - strrev
117 * - split/spliti
118 * - ...
119 *
120 */
121 /**
122 * Class for conversion between charsets
123 *
124 * @author Kasper Skårhøj <kasperYYYY@typo3.com>
125 * @author Martin Kutschker <martin.t.kutschker@blackbox.net>
126 * @package TYPO3
127 * @subpackage t3lib
128 */
132 // This is the array where parsed conversion tables are stored (cached)
135 // An array where case folding data will be stored (cached)
138 // An array where charset-to-ASCII mappings are stored (cached)
141 // This tells the converter which charsets has two bytes per char:
144 );
146 // This tells the converter which charsets has four bytes per char:
150 );
152 // This tells the converter which charsets use a scheme like the Extended Unix Code:
157 'shift_jis' => 1, // Japanese - WARNING: Shift-JIS includes half-width katakana single-bytes characters above 0x80!
158 );
160 // see http://developer.apple.com/documentation/macos8/TextIntlSvcs/TextEncodingConversionManager/TEC1.5/TEC.b0.html
161 // http://czyborra.com/charsets/iso8859.html
246 );
248 // mapping of iso-639-1 language codes to script names
250 // iso-639-1 language codes, see http://www.loc.gov/standards/iso639-2/php/code_list.php
299 // MS language codes, see http://msdn.microsoft.com/library/default.asp?url=/library/en-us/vclib/html/_crt_language_strings.asp
300 // http://msdn.microsoft.com/library/default.asp?url=/library/en-us/wceinternational5/html/wce50conLanguageIdentifiersandLocales.asp
360 // English language names
407 );
409 // mapping of language (family) names to charsets on Unix
430 );
432 // mapping of language (family) names to charsets on Windows
453 );
455 // mapping of locale names to charsets
464 );
466 // TYPO3 specific: Array with the system charsets used for each system language in TYPO3:
467 // Empty values means "iso-8859-1"
519 );
521 // TYPO3 specific: Array with the iso names used for each system language in TYPO3:
522 // Missing keys means: same as Typo3
541 );
543 /**
544 * Normalize - changes input character set to lowercase letters.
545 *
546 * @param string Input charset
547 * @return string Normalized charset
548 * @author Martin Kutschker <martin.t.kutschker@blackbox.net>
549 */
554 }
557 }
559 /**
560 * Get the charset of a locale.
561 *
562 * ln language
563 * ln_CN language / country
564 * ln_CN.cs language / country / charset
565 * ln_CN.cs@mod language / country / charset / modifier
566 *
567 * @param string Locale string
568 * @return string Charset resolved for locale string
569 * @author Martin Kutschker <martin.t.kutschker@blackbox.net>
570 */
574 // exact locale specific charset?
577 }
579 // get modifier
582 // locale contains charset: use it
586 }
588 // modifier is 'euro' (after charset check, because of xx.utf-8@euro)
591 }
593 // get language
597 }
600 $cs = $this->script_to_charset_windows[$script] ? $this->script_to_charset_windows[$script] : 'windows-1252';
602 $cs = $this->script_to_charset_unix[$script] ? $this->script_to_charset_unix[$script] : 'iso-8859-1';
603 }
606 }
609 /********************************************
610 *
611 * Charset Conversion functions
612 *
613 ********************************************/
615 /**
616 * Convert from one charset to another charset.
617 *
618 * @param string Input string
619 * @param string From charset (the current charset of the string)
620 * @param string To charset (the output charset wanted)
621 * @param boolean If set, then characters that are not available in the destination character set will be encoded as numeric entities
622 * @return string Converted string
623 * @see convArray()
624 */
628 }
630 // PHP-libs don't support fallback to SGML entities, but UTF-8 handles everything
644 }
651 }
653 }
654 // fallback to TYPO3 conversion
655 }
659 }
662 }
664 }
666 /**
667 * Convert all elements in ARRAY with type string from one charset to another charset.
668 * NOTICE: Array is passed by reference!
669 *
670 * @param string Input array, possibly multidimensional
671 * @param string From charset (the current charset of the string)
672 * @param string To charset (the output charset wanted)
673 * @param boolean If set, then characters that are not available in the destination character set will be encoded as numeric entities
674 * @return void
675 * @see conv()
676 */
683 }
684 }
685 }
687 /**
688 * Converts $str from $charset to UTF-8
689 *
690 * @param string String in local charset to convert to UTF-8
691 * @param string Charset, lowercase. Must be found in csconvtbl/ folder.
692 * @return string Output string, converted to UTF-8
693 */
698 }
700 // Charset is case-insensitive.
712 if (isset($this->parsedCharsets[$charset]['local'][$ord])) { // If the local char-number was found in parsed conv. table then we use that, otherwise 127 (no char?)
719 if (isset($this->eucBasedSets[$charset])) { // EUC uses two-bytes above 127; we get both and advance pointer and make $ord a 16bit int.
720 if ($charset != 'shift_jis' || ($ord < 0xA0 || $ord > 0xDF)) { // Shift-JIS: chars between 160 and 223 are single byte
724 }
725 }
727 if (isset($this->parsedCharsets[$charset]['local'][$ord])) { // If the local char-number was found in parsed conv. table then we use that, otherwise 127 (no char?)
735 }
737 }
738 }
740 /**
741 * Converts $str from UTF-8 to $charset
742 *
743 * @param string String in UTF-8 to convert to local charset
744 * @param string Charset, lowercase. Must be found in csconvtbl/ folder.
745 * @param boolean If set, then characters that are not available in the destination character set will be encoded as numeric entities
746 * @return string Output string, converted to local charset
747 */
752 }
754 // Charset is case-insensitive.
763 if ($ord & 64) { // Since the first byte must have the 7th bit set we check that. Otherwise we might be in the middle of a byte sequence.
768 if ($ord & 128) { // ... and with 8th bit - if that is set, then there are still bytes in sequence.
773 }
774 }
776 if (isset($this->parsedCharsets[$charset]['utf8'][$buf])) { // If the UTF-8 char-sequence is found then...
778 if ($mByte > 255) { // If the local number is greater than 255 we will need to split the byte (16bit word assumed) in two chars.
782 }
794 }
796 }
797 }
799 /**
800 * Converts all chars > 127 to numeric entities.
801 *
802 * @param string Input string
803 * @return string Output string
804 */
813 if ($ord & 64) { // Since the first byte must have the 7th bit set we check that. Otherwise we might be in the middle of a byte sequence.
817 if ($ord & 128) { // ... and with 8th bit - if that is set, then there are still bytes in sequence.
822 }
823 }
832 }
835 }
837 /**
838 * Converts numeric entities (UNICODE, eg. decimal (Ӓ) or hexadecimal ()) to UTF-8 multibyte chars
839 *
840 * @param string Input string, UTF-8
841 * @param boolean If set, then all string-HTML entities (like & or £ will be converted as well)
842 * @return string Output string
843 */
846 $trans_tbl = array_flip(get_html_translation_table(HTML_ENTITIES)); // Getting them in iso-8859-1 - but thats ok since this is observed below.
847 }
850 $parts = explode($token, preg_replace('/(&([#[:alnum:]]*);)/', $token . '${2}' . $token, $str));
858 }
863 }
864 }
865 }
868 }
870 /**
871 * Converts all chars in the input UTF-8 string into integer numbers returned in an array
872 *
873 * @param string Input string, UTF-8
874 * @param boolean If set, then all HTML entities (like & or £ or { or 㽝) will be detected as characters.
875 * @param boolean If set, then instead of integer numbers the real UTF-8 char is returned.
876 * @return array Output array with the char numbers
877 */
879 // If entities must be registered as well...:
882 }
883 // Do conversion:
891 if ($ord & 64) { // Since the first byte must have the 7th bit set we check that. Otherwise we might be in the middle of a byte sequence.
895 if ($ord & 128) { // ... and with 8th bit - if that is set, then there are still bytes in sequence.
900 }
901 }
910 }
913 }
915 /**
916 * Converts a UNICODE number to a UTF-8 multibyte character
917 * Algorithm based on script found at From: http://czyborra.com/utf/
918 * Unit-tested by Kasper
919 *
920 * The binary representation of the character's integer value is thus simply spread across the bytes and the number of high bits set in the lead byte announces the number of bytes in the multibyte sequence:
921 *
922 * bytes | bits | representation
923 * 1 | 7 | 0vvvvvvv
924 * 2 | 11 | 110vvvvv 10vvvvvv
925 * 3 | 16 | 1110vvvv 10vvvvvv 10vvvvvv
926 * 4 | 21 | 11110vvv 10vvvvvv 10vvvvvv 10vvvvvv
927 * 5 | 26 | 111110vv 10vvvvvv 10vvvvvv 10vvvvvv 10vvvvvv
928 * 6 | 31 | 1111110v 10vvvvvv 10vvvvvv 10vvvvvv 10vvvvvv 10vvvvvv
929 *
930 * @param integer UNICODE integer
931 * @return string UTF-8 multibyte character string
932 * @see utf8CharToUnumber()
933 */
971 }
972 }
973 }
974 }
975 }
976 }
978 }
980 /**
981 * Converts a UTF-8 Multibyte character to a UNICODE number
982 * Unit-tested by Kasper
983 *
984 * @param string UTF-8 multibyte character string
985 * @param boolean If set, then a hex. number is returned.
986 * @return integer UNICODE integer
987 * @see UnumberToChar()
988 */
996 if ($ord & 128) { // ... and with 8th bit - if that is set, then there are still bytes in sequence.
1000 }
1001 }
1007 }
1010 }
1013 /********************************************
1014 *
1015 * Init functions
1016 *
1017 ********************************************/
1019 /**
1020 * This will initialize a charset for use if it's defined in the PATH_t3lib.'csconvtbl/' folder
1021 * This function is automatically called by the conversion functions
1022 *
1023 * PLEASE SEE: http://www.unicode.org/Public/MAPPINGS/
1024 *
1025 * @param string The charset to be initialized. Use lowercase charset always (the charset must match exactly with a filename in csconvtbl/ folder ([charset].tbl)
1026 * @return integer Returns '1' if already loaded. Returns FALSE if charset conversion table was not found. Returns '2' if the charset conversion table was found and parsed.
1027 * @access private
1028 */
1030 // Only process if the charset is not yet loaded:
1033 // Conversion table filename:
1036 // If the conversion table is found:
1037 if ($charset && t3lib_div::validPathStr($charsetConvTableFile) && @is_file($charsetConvTableFile)) {
1038 // Cache file for charsets:
1039 // Caching brought parsing time for gb2312 down from 2400 ms to 150 ms. For other charsets we are talking 11 ms down to zero.
1044 // Parse conversion table into lines:
1046 // Initialize the internal variable holding the conv. table:
1048 // traverse the lines:
1053 // Detect type if not done yet: (Done on first real line)
1054 // The "whitespaced" type is on the syntax "0x0A 0x000A #LINE FEED" while "ms-token" is like "B9 = U+00B9 : SUPERSCRIPT ONE"
1056 $detectedType = preg_match('/[[:space:]]*0x([[:alnum:]]*)[[:space:]]+0x([[:alnum:]]*)[[:space:]]+/', $value) ? 'whitespaced' : 'ms-token';
1057 }
1063 preg_match('/[[:space:]]*0x([[:alnum:]]*)[[:space:]]+0x([[:alnum:]]*)[[:space:]]+/', $value, $regA);
1066 }
1071 $this->parsedCharsets[$charset]['utf8'][$this->parsedCharsets[$charset]['local'][$decval]] = $decval;
1072 }
1073 }
1074 }
1077 }
1078 }
1082 }
1085 }
1086 }
1088 /**
1089 * This function initializes all UTF-8 character data tables.
1090 *
1091 * PLEASE SEE: http://www.unicode.org/Public/UNIDATA/
1092 *
1093 * @param string Mode ("case", "ascii", ...)
1094 * @return integer Returns FALSE on error, a TRUE value on success: 1 table already loaded, 2, cached version, 3 table parsed (and cached).
1095 * @access private
1096 */
1098 // cache files
1102 // Only process if the tables are not yet loaded
1107 }
1109 // Use cached version if possible
1113 }
1119 }
1121 // Use cached version if possible
1125 }
1127 }
1129 // process main Unicode data file
1133 }
1138 }
1140 // key = utf8 char (single codepoint), value = utf8 string (codepoint sequence)
1141 // note: we use the UTF-8 characters here and not the Unicode numbers to avoid conversion roundtrip in utf8_strtolower/-upper)
1155 // has a lot of info
1156 list($char, $name, $cat, , , $decomp, , , $num, , , , $upper, $lower, $title,) = explode(';', rtrim($line));
1167 }
1170 }
1171 // store "title" only when different from "upper" (only a few)
1174 }
1184 }
1185 }
1187 // accented Latin letters without "official" decomposition
1193 }
1197 }
1213 }
1216 // ignore Arabic and vertical layout presentation decomposition
1223 }
1225 }
1226 }
1229 // process additional Unicode data for casing (allow folded characters to expand into a sequence)
1245 }
1250 }
1255 }
1256 }
1257 }
1258 }
1260 }
1261 }
1263 // process custom decompositions
1274 }
1277 }
1278 }
1280 }
1281 }
1283 // decompose and remove marks; inspired by unac (Loic Dachary <loic@senga.org>)
1291 }
1294 }
1295 }
1300 }
1301 }
1303 // create ascii only mapping
1314 else
1315 {
1317 }
1318 }
1320 }
1322 // add numeric decompositions
1327 }
1328 }
1332 }
1336 }
1339 }
1341 /**
1342 * This function initializes the folding table for a charset other than UTF-8.
1343 * This function is automatically called by the case folding functions.
1344 *
1345 * @param string Charset for which to initialize case folding.
1346 * @return integer Returns FALSE on error, a TRUE value on success: 1 table already loaded, 2, cached version, 3 table parsed (and cached).
1347 * @access private
1348 */
1350 // Only process if the case table is not yet loaded:
1353 }
1355 // Use cached version if possible
1360 }
1362 // init UTF-8 conversion for this charset
1365 }
1367 // UTF-8 case folding is used as the base conversion table
1370 }
1374 // reconvert to charset (don't use chr() of numeric value, might be muli-byte)
1377 // $cc = $this->conv($this->caseFolding['utf-8']['toUpper'][$utf8], 'utf-8', $charset);
1381 }
1383 // $cc = $this->conv($this->caseFolding['utf-8']['toLower'][$utf8], 'utf-8', $charset);
1387 }
1389 // $cc = $this->conv($this->caseFolding['utf-8']['toTitle'][$utf8], 'utf-8', $charset);
1393 }
1394 }
1396 // add the ASCII case table
1399 }
1402 }
1406 }
1409 }
1411 /**
1412 * This function initializes the to-ASCII conversion table for a charset other than UTF-8.
1413 * This function is automatically called by the ASCII transliteration functions.
1414 *
1415 * @param string Charset for which to initialize conversion.
1416 * @return integer Returns FALSE on error, a TRUE value on success: 1 table already loaded, 2, cached version, 3 table parsed (and cached).
1417 * @access private
1418 */
1420 // Only process if the case table is not yet loaded:
1423 }
1425 // Use cached version if possible
1430 }
1432 // init UTF-8 conversion for this charset
1435 }
1437 // UTF-8/ASCII transliteration is used as the base conversion table
1440 }
1444 // reconvert to charset (don't use chr() of numeric value, might be muli-byte)
1449 }
1450 }
1454 }
1457 }
1460 /********************************************
1461 *
1462 * String operation functions
1463 *
1464 ********************************************/
1466 /**
1467 * Returns a part of a string.
1468 * Unit-tested by Kasper (single byte charsets only)
1469 *
1470 * @param string The character set
1471 * @param string Character string
1472 * @param integer Start position (character position)
1473 * @param integer Length (in characters)
1474 * @return string The substring
1475 * @see substr(), mb_substr()
1476 * @author Martin Kutschker <martin.t.kutschker@blackbox.net>
1477 */
1481 }
1484 // cannot omit $len, when specifying charset
1492 }
1495 }
1497 // cannot omit $len, when specifying charset
1505 }
1508 }
1517 }
1519 // treat everything else as single-byte encoding
1521 }
1523 /**
1524 * Counts the number of characters.
1525 * Unit-tested by Kasper (single byte charsets only)
1526 *
1527 * @param string The character set
1528 * @param string Character string
1529 * @return integer The number of characters
1530 * @see strlen()
1531 * @author Martin Kutschker <martin.t.kutschker@blackbox.net>
1532 */
1546 }
1547 // treat everything else as single-byte encoding
1549 }
1551 /**
1552 * Method to crop strings using the mb_substr function.
1553 *
1554 * @param string The character set
1555 * @param string String to be cropped
1556 * @param integer Crop length (in characters)
1557 * @param string Crop signifier
1558 * @return string The shortened string
1559 * @see mb_strlen(), mb_substr()
1560 */
1564 }
1570 }
1573 }
1575 /**
1576 * Truncates a string and pre-/appends a string.
1577 * Unit tested by Kasper
1578 *
1579 * @param string The character set
1580 * @param string Character string
1581 * @param integer Length (in characters)
1582 * @param string Crop signifier
1583 * @return string The shortened string
1584 * @see substr(), mb_strimwidth()
1585 * @author Martin Kutschker <martin.t.kutschker@blackbox.net>
1586 */
1590 }
1594 }
1607 }
1608 }
1609 }
1618 }
1622 }
1623 }
1625 /*
1626 if (abs($len)<$this->strlen($charset,$string)) { // Has to use ->strlen() - otherwise multibyte strings ending with a multibyte char will return true here (which is not a catastrophe, but...)
1627 if ($len > 0) {
1628 return substr($string,0,$i).$crop;
1629 } else {
1630 return $crop.substr($string,$i);
1631 }
1632 }
1633 */
1634 }
1636 }
1638 /**
1639 * Cuts a string short at a given byte length.
1640 *
1641 * @param string The character set
1642 * @param string Character string
1643 * @param integer The byte length
1644 * @return string The shortened string
1645 * @see mb_strcut()
1646 * @author Martin Kutschker <martin.t.kutschker@blackbox.net>
1647 */
1651 }
1666 }
1667 // treat everything else as single-byte encoding
1669 }
1671 /**
1672 * Translates all characters of a string into their respective case values.
1673 * Unlike strtolower() and strtoupper() this method is locale independent.
1674 * Note that the string length may change!
1675 * eg. lower case German "ß" (sharp S) becomes upper case "SS"
1676 * Unit-tested by Kasper
1677 * Real case folding is language dependent, this method ignores this fact.
1678 *
1679 * @param string Character set of string
1680 * @param string Input string to convert case for
1681 * @param string Case keyword: "toLower" means lowercase conversion, anything else is uppercase (use "toUpper" )
1682 * @return string The converted string
1683 * @author Martin Kutschker <martin.t.kutschker@blackbox.net>
1684 * @see strtolower(), strtoupper()
1685 */
1692 }
1698 // treat everything else as single-byte encoding
1700 }
1703 }
1705 /**
1706 * Converts special chars (like æøåÆØÅ, umlauts etc) to ascii equivalents (usually double-bytes, like æ => ae etc.)
1707 *
1708 * @param string Character set of string
1709 * @param string Input string to convert
1710 * @return string The converted string
1711 */
1718 // treat everything else as single-byte encoding
1720 }
1723 }
1726 /**
1727 * converts the language codes that we get from the client (usually HTTP_ACCEPT_LANGUAGE)
1728 * into a TYPO3-readable language code
1729 * @param $languageCodesList list of language codes. something like 'de,en-us;q=0.9,de-de;q=0.7,es-cl;q=0.6,en;q=0.4,es;q=0.3,zh;q=0.1'
1730 * see http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.4
1731 * @return string a preferred language that TYPO3 supports, or "default" if none found
1732 * @author Benjamin Mack (benni.typo3.org)
1733 */
1738 // get all languages where TYPO3 code is the same as the ISO code
1741 }
1743 // get all languages where TYPO3 code differs from ISO code
1744 // or needs the country part
1745 // the iso codes will here overwrite the default typo3 language in the key
1749 }
1751 // move the iso codes to the (because we're comparing the keys with "isset" later on)
1756 // order the preferred languages after they key
1762 }
1764 }
1766 // loop through the languages, with the highest priority first
1772 }
1774 // strip the country code from the end
1779 }
1780 }
1783 }
1785 }
1788 /********************************************
1789 *
1790 * Internal string operation functions
1791 *
1792 ********************************************/
1794 /**
1795 * Maps all characters of a string in a single byte charset.
1796 *
1797 * @param string the string
1798 * @param string the charset
1799 * @param string mode: 'case' (case folding) or 'ascii' (ASCII transliteration)
1800 * @param string 'case': conversion 'toLower' or 'toUpper'
1801 * @return string the converted string
1802 * @author Martin Kutschker <martin.t.kutschker@blackbox.net>
1803 */
1822 }
1831 }
1832 }
1835 }
1838 /********************************************
1839 *
1840 * Internal UTF-8 string operation functions
1841 *
1842 ********************************************/
1844 /**
1845 * Returns a part of a UTF-8 string.
1846 * Unit-tested by Kasper and works 100% like substr() / mb_substr() for full range of $start/$len
1847 *
1848 * @param string UTF-8 string
1849 * @param integer Start position (character position)
1850 * @param integer Length (in characters)
1851 * @return string The substring
1852 * @see substr()
1853 * @author Martin Kutschker <martin.t.kutschker@blackbox.net>
1854 */
1858 }
1866 }
1867 }
1874 {
1877 else
1878 {
1880 }
1881 }
1884 }
1885 }
1887 /**
1888 * Counts the number of characters of a string in UTF-8.
1889 * Unit-tested by Kasper and works 100% like strlen() / mb_strlen()
1890 *
1891 * @param string UTF-8 multibyte character string
1892 * @return integer The number of characters
1893 * @see strlen()
1894 * @author Martin Kutschker <martin.t.kutschker@blackbox.net>
1895 */
1901 {
1903 }
1905 {
1907 }
1908 }
1910 }
1912 /**
1913 * Truncates a string in UTF-8 short at a given byte length.
1914 *
1915 * @param string UTF-8 multibyte character string
1916 * @param integer the byte length
1917 * @return string the shortened string
1918 * @see mb_strcut()
1919 * @author Martin Kutschker <martin.t.kutschker@blackbox.net>
1920 */
1928 for ($bc = 0, $mbs = ord($str{$i}); $mbs & 0x80; $mbs = $mbs << 1) $bc++; // calculate number of bytes
1931 }
1932 // fallthru: multibyte char fits into length
1933 }
1935 }
1937 /**
1938 * Find position of first occurrence of a string, both arguments are in UTF-8.
1939 *
1940 * @param string UTF-8 string to search in
1941 * @param string UTF-8 string to search for
1942 * @param integer Positition to start the search
1943 * @return integer The character position
1944 * @see strpos()
1945 * @author Martin Kutschker <martin.t.kutschker@blackbox.net>
1946 */
1952 }
1965 }
1967 /**
1968 * Find position of last occurrence of a char in a string, both arguments are in UTF-8.
1969 *
1970 * @param string UTF-8 string to search in
1971 * @param string UTF-8 character to search for (single character)
1972 * @return integer The character position
1973 * @see strrpos()
1974 * @author Martin Kutschker <martin.t.kutschker@blackbox.net>
1975 */
1981 }
1989 }
1991 /**
1992 * Translates a character position into an 'absolute' byte position.
1993 * Unit tested by Kasper.
1994 *
1995 * @param string UTF-8 string
1996 * @param integer Character position (negative values start from the end)
1997 * @return integer Byte position
1998 * @author Martin Kutschker <martin.t.kutschker@blackbox.net>
1999 */
2010 }
2015 {
2017 }
2019 {
2021 }
2022 }
2028 // skip trailing multi-byte data bytes
2031 }
2033 // correct offset
2035 }
2038 }
2040 /**
2041 * Translates an 'absolute' byte position into a character position.
2042 * Unit tested by Kasper.
2043 *
2044 * @param string UTF-8 string
2045 * @param integer byte position
2046 * @return integer character position
2047 * @author Martin Kutschker <martin.t.kutschker@blackbox.net>
2048 */
2054 {
2056 }
2058 {
2060 }
2061 }
2067 }
2069 /**
2070 * Maps all characters of an UTF-8 string.
2071 *
2072 * @param string UTF-8 string
2073 * @param string mode: 'case' (case folding) or 'ascii' (ASCII transliteration)
2074 * @param string 'case': conversion 'toLower' or 'toUpper'
2075 * @return string the converted string
2076 * @author Martin Kutschker <martin.t.kutschker@blackbox.net>
2077 */
2095 }
2100 {
2102 }
2109 }
2115 }
2116 }
2119 }
2122 /********************************************
2123 *
2124 * Internal EUC string operation functions
2125 *
2126 * Extended Unix Code:
2127 * ASCII compatible 7bit single bytes chars
2128 * 8bit two byte chars
2129 *
2130 * Shift-JIS is treated as a special case.
2131 *
2132 ********************************************/
2134 /**
2135 * Cuts a string in the EUC charset family short at a given byte length.
2136 *
2137 * @param string EUC multibyte character string
2138 * @param integer the byte length
2139 * @param string the charset
2140 * @return string the shortened string
2141 * @see mb_strcut()
2142 * @author Martin Kutschker <martin.t.kutschker@blackbox.net>
2143 */
2152 }
2157 }
2158 }
2167 }
2168 }
2170 /**
2171 * Returns a part of a string in the EUC charset family.
2172 *
2173 * @param string EUC multibyte character string
2174 * @param integer start position (character position)
2175 * @param string the charset
2176 * @param integer length (in characters)
2177 * @return string the substring
2178 * @author Martin Kutschker <martin.t.kutschker@blackbox.net>
2179 */
2191 {
2193 }
2194 else
2195 {
2197 }
2198 }
2201 }
2202 }
2204 /**
2205 * Counts the number of characters of a string in the EUC charset family.
2206 *
2207 * @param string EUC multibyte character string
2208 * @param string the charset
2209 * @return integer the number of characters
2210 * @see strlen()
2211 * @author Martin Kutschker <martin.t.kutschker@blackbox.net>
2212 */
2222 }
2227 }
2230 }
2233 }
2235 /**
2236 * Translates a character position into an 'absolute' byte position.
2237 *
2238 * @param string EUC multibyte character string
2239 * @param integer character position (negative values start from the end)
2240 * @param string the charset
2241 * @return integer byte position
2242 * @author Martin Kutschker <martin.t.kutschker@blackbox.net>
2243 */
2255 }
2263 }
2268 }
2271 }
2281 }
2283 /**
2284 * Maps all characters of a string in the EUC charset family.
2285 *
2286 * @param string EUC multibyte character string
2287 * @param string the charset
2288 * @param string mode: 'case' (case folding) or 'ascii' (ASCII transliteration)
2289 * @param string 'case': conversion 'toLower' or 'toUpper'
2290 * @return string the converted string
2291 * @author Martin Kutschker <martin.t.kutschker@blackbox.net>
2292 */
2311 }
2323 }
2324 }
2329 }
2330 }
2336 }
2337 }
2340 }
2342 }
2344 if (defined('TYPO3_MODE') && isset($GLOBALS['TYPO3_CONF_VARS'][TYPO3_MODE]['XCLASS']['t3lib/class.t3lib_cs.php'])) {
2346 }
2348 ?>