PageRenderTime 63ms CodeModel.GetById 27ms RepoModel.GetById 1ms app.codeStats 0ms

/library/Zend/Locale/Format.php

https://github.com/jverkoey/snaapilookup
PHP | 1064 lines | 712 code | 79 blank | 273 comment | 204 complexity | 29177de6eab458c95acf3dceea039316 MD5 | raw file
    

  1. <?php
    2. 

  2. /**
    3. 

  3.  * Zend Framework
    4. 

  4.  *
    5. 

  5.  * LICENSE
    6. 

  6.  *
    7. 

  7.  * This source file is subject to the new BSD license that is bundled
    8. 

  8.  * with this package in the file LICENSE.txt.
    9. 

  9.  * It is also available through the world-wide-web at this URL:
    10. 

  10.  * http://framework.zend.com/license/new-bsd
    11. 

  11.  * If you did not receive a copy of the license and are unable to
    12. 

  12.  * obtain it through the world-wide-web, please send an email
    13. 

  13.  * to license@zend.com so we can send you a copy immediately.
    14. 

  14.  *
    15. 

  15.  * @category   Zend
    16. 

  16.  * @package    Zend_Locale
    17. 

  17.  * @subpackage Format
    18. 

  18.  * @copyright  Copyright (c) 2005-2008 Zend Technologies USA Inc. (http://www.zend.com)
    19. 

  19.  * @version    $Id: Format.php 12057 2008-10-21 17:19:43Z thomas $
    20. 

  20.  * @license    http://framework.zend.com/license/new-bsd     New BSD License
    21. 

  21.  */
    22. 

  22. 

  23. /**
    24. 

  24.  * include needed classes
    25. 

  25.  */
    26. 

  26. require_once 'Zend/Locale/Data.php';
    27. 

  27. 

  28. /**
    29. 

  29.  * @category   Zend
    30. 

  30.  * @package    Zend_Locale
    31. 

  31.  * @subpackage Format
    32. 

  32.  * @copyright  Copyright (c) 2005-2008 Zend Technologies USA Inc. (http://www.zend.com)
    33. 

  33.  * @license    http://framework.zend.com/license/new-bsd     New BSD License
    34. 

  34.  */
    35. 

  35. class Zend_Locale_Format
    36. 

  36. {
    37. 

  37.     const STANDARD   = 'STANDARD';
    38. 

  38. 

  39.     private static $_options = array('date_format'   => null,
    40. 

  40.                                      'number_format' => null,
    41. 

  41.                                      'format_type'   => 'iso',
    42. 

  42.                                      'fix_date'      => false,
    43. 

  43.                                      'locale'        => null,
    44. 

  44.                                      'cache'         => null,
    45. 

  45.                                      'precision'     => null);
    46. 

  46. 

  47.     private static $_signs = array(
    48. 

  48.         'Latn' => array('0', '1', '2', '3', '4', '5', '6', '7', '8', '9'), // Latn - default latin
    49. 

  49.         'Arab' => array( '٠', '١', '٢', '٣', '٤', '٥', '٦', '٧', '٨', '٩'), // 0660 - 0669 arabic
    50. 

  50.         'Deva' => array( '०', '१', '२', '३', '४', '५', '६', '७', '८', '९'), // 0966 - 096F devanagari
    51. 

  51.         'Beng' => array( '০', '১', '২', '৩', '৪', '৫', '৬', '৭', '৮', '৯'), // 09E6 - 09EF bengali
    52. 

  52.         'Guru' => array( '੦', '੧', '੨', '੩', '੪', '੫', '੬', '੭', '੮', '੯'), // 0A66 - 0A6F gurmukhi
    53. 

  53.         'Gujr' => array( '૦', '૧', '૨', '૩', '૪', '૫', '૬', '૭', '૮', '૯'), // 0AE6 - 0AEF gujarati
    54. 

  54.         'Orya' => array( '୦', '୧', '୨', '୩', '୪', '୫', '୬', '୭', '୮', '୯'), // 0B66 - 0B6F orija
    55. 

  55.         'Taml' => array( '௦', '௧', '௨', '௩', '௪', '௫', '௬', '௭', '௮', '௯'), // 0BE6 - 0BEF tamil
    56. 

  56.         'Telu' => array( '౦', '౧', '౨', '౩', '౪', '౫', '౬', '౭', '౮', '౯'), // 0C66 - 0C6F telugu
    57. 

  57.         'Knda' => array( '೦', '೧', '೨', '೩', '೪', '೫', '೬', '೭', '೮', '೯'), // 0CE6 - 0CEF kannada
    58. 

  58.         'Mlym' => array( '൦', '൧', '൨', '൩', '൪', '൫', '൬', '൭', '൮', '൯ '), // 0D66 - 0D6F malayalam
    59. 

  59.         'Tale' => array( '๐', '๑', '๒', '๓', '๔', '๕', '๖', '๗', '๘', '๙ '), // 0E50 - 0E59 thai
    60. 

  60.         'Laoo' => array( '໐', '໑', '໒', '໓', '໔', '໕', '໖', '໗', '໘', '໙'), // 0ED0 - 0ED9 lao
    61. 

  61.         'Tibt' => array( '༠', '༡', '༢', '༣', '༤', '༥', '༦', '༧', '༨', '༩ '), // 0F20 - 0F29 tibetan
    62. 

  62.         'Mymr' => array( '၀', '၁', '၂', '၃', '၄', '၅', '၆', '၇', '၈', '၉'), // 1040 - 1049 myanmar
    63. 

  63.         'Khmr' => array( '០', '១', '២', '៣', '៤', '៥', '៦', '៧', '៨', '៩'), // 17E0 - 17E9 khmer
    64. 

  64.         'Mong' => array( '᠐', '᠑', '᠒', '᠓', '᠔', '᠕', '᠖', '᠗', '᠘', '᠙'), // 1810 - 1819 mongolian
    65. 

  65.         'Limb' => array( '᥆', '᥇', '᥈', '᥉', '᥊', '᥋', '᥌', '᥍', '᥎', '᥏'), // 1946 - 194F limbu
    66. 

  66.         'Talu' => array( '᧐', '᧑', '᧒', '᧓', '᧔', '᧕', '᧖', '᧗', '᧘', '᧙'), // 19D0 - 19D9 tailue
    67. 

  67.         'Bali' => array( '᭐', '᭑', '᭒', '᭓', '᭔', '᭕', '᭖', '᭗', '᭘', '᭙'), // 1B50 - 1B59 balinese
    68. 

  68.         'Nkoo' => array( '߀', '߁', '߂', '߃', '߄', '߅', '߆', '߇', '߈', '߉')  // 07C0 - 07C9 nko
    69. 

  69.     );
    70. 

  70. 

  71.     /**
    72. 

  72.      * Sets class wide options, if no option was given, the actual set options will be returned
    73. 

  73.      * The 'precision' option of a value is used to truncate or stretch extra digits. -1 means not to touch the extra digits.
    74. 

  74.      * The 'locale' option helps when parsing numbers and dates using separators and month names.
    75. 

  75.      * The date format 'format_type' option selects between CLDR/ISO date format specifier tokens and PHP's date() tokens.
    76. 

  76.      * The 'fix_date' option enables or disables heuristics that attempt to correct invalid dates.
    77. 

  77.      * The 'number_format' option can be used to specify a default number format string
    78. 

  78.      * The 'date_format' option can be used to specify a default date format string, but beware of using getDate(),
    79. 

  79.      * checkDateFormat() and getTime() after using setOptions() with a 'format'.  To use these four methods
    80. 

  80.      * with the default date format for a locale, use array('date_format' => null, 'locale' => $locale) for their options.
    81. 

  81.      *
    82. 

  82.      * @param  array  $options  Array of options, keyed by option name: format_type = 'iso' | 'php', fix_date = true | false,
    83. 

  83.      *                          locale = Zend_Locale | locale string, precision = whole number between -1 and 30
    84. 

  84.      * @throws Zend_Locale_Exception
    85. 

  85.      * @return Options array if no option was given
    86. 

  86.      */
    87. 

  87.     public static function setOptions(array $options = array())
    88. 

  88.     {
    89. 

  89.         self::$_options = self::_checkOptions($options) + self::$_options;
    90. 

  90.         return self::$_options;
    91. 

  91.     }
    92. 

  92. 

  93.     /**
    94. 

  94.      * Internal function for checking the options array of proper input values
    95. 

  95.      * See {@link setOptions()} for details.
    96. 

  96.      *
    97. 

  97.      * @param  array  $options  Array of options, keyed by option name: format_type = 'iso' | 'php', fix_date = true | false,
    98. 

  98.      *                          locale = Zend_Locale | locale string, precision = whole number between -1 and 30
    99. 

  99.      * @throws Zend_Locale_Exception
    100. 

  100.      * @return Options array if no option was given
    101. 

  101.      */
    102. 

  102.     private static function _checkOptions(array $options = array())
    103. 

  103.     {
    104. 

  104.         if (count($options) == 0) {
    105. 

  105.             return self::$_options;
    106. 

  106.         }
    107. 

  107.         foreach ($options as $name => $value) {
    108. 

  108.             $name  = strtolower($name);
    109. 

  109.             if ($name !== 'locale') {
    110. 

  110.                 if (gettype($value) === 'string') {
    111. 

  111.                     $value = strtolower($value);
    112. 

  112.                 }
    113. 

  113.             }
    114. 

  114. 

  115.             switch($name) {
    116. 

  116.                 case 'number_format' :
    117. 

  117.                     if ($value == 'standard') {
    118. 

  118.                         $locale = self::$_options['locale'];
    119. 

  119.                         if (isset($options['locale'])) {
    120. 

  120.                             $locale = $options['locale'];
    121. 

  121.                         }
    122. 

  122.                         $options['number_format'] = Zend_Locale_Data::getContent($locale, 'decimalnumber');
    123. 

  123.                     } else if ((gettype($value) !== 'string') and ($value !== NULL)) {
    124. 

  124.                         require_once 'Zend/Locale/Exception.php';
    125. 

  125.                         throw new Zend_Locale_Exception("Unknown number format type '" . gettype($value) . "'. "
    126. 

  126.                             . "Format '$value' must be a valid number format string.");
    127. 

  127.                     }
    128. 

  128.                     break;
    129. 

  129. 

  130.                 case 'date_format' :
    131. 

  131.                     if ($value == 'standard') {
    132. 

  132.                         $locale = self::$_options['locale'];
    133. 

  133.                         if (isset($options['locale'])) {
    134. 

  134.                             $locale = $options['locale'];
    135. 

  135.                         }
    136. 

  136.                         $options['date_format'] = Zend_Locale_Format::getDateFormat($locale);
    137. 

  137.                     } else if ((gettype($value) !== 'string') and ($value !== NULL)) {
    138. 

  138.                         require_once 'Zend/Locale/Exception.php';
    139. 

  139.                         throw new Zend_Locale_Exception("Unknown dateformat type '" . gettype($value) . "'. "
    140. 

  140.                             . "Format '$value' must be a valid ISO or PHP date format string.");
    141. 

  141.                     } else {
    142. 

  142.                         if (((isset($options['format_type']) === true) and ($options['format_type'] == 'php')) or
    143. 

  143.                             ((isset($options['format_type']) === false) and (self::$_options['format_type'] == 'php'))) {
    144. 

  144.                             $options['date_format'] = Zend_Locale_Format::convertPhpToIsoFormat($value);
    145. 

  145.                         }
    146. 

  146.                     }
    147. 

  147.                     break;
    148. 

  148. 

  149.                 case 'format_type' :
    150. 

  150.                     if (($value != 'php') && ($value != 'iso')) {
    151. 

  151.                         require_once 'Zend/Locale/Exception.php';
    152. 

  152.                         throw new Zend_Locale_Exception("Unknown date format type '$value'. Only 'iso' and 'php'"
    153. 

  153.                            . " are supported.");
    154. 

  154.                     }
    155. 

  155.                     break;
    156. 

  156. 

  157.                 case 'fix_date' :
    158. 

  158.                     if (($value !== true) && ($value !== false)) {
    159. 

  159.                         require_once 'Zend/Locale/Exception.php';
    160. 

  160.                         throw new Zend_Locale_Exception("Enabling correction of dates must be either true or false"
    161. 

  161.                             . "(fix_date='$value').");
    162. 

  162.                     }
    163. 

  163.                     break;
    164. 

  164. 

  165.                 case 'locale' :
    166. 

  166.                     if (gettype($value) === 'string' && strtolower($value) == 'standard') {
    167. 

  167.                         $options['locale'] = new Zend_Locale();
    168. 

  168.                     } else if (!empty($value) && (!Zend_Locale::isLocale($value, null, false))) {
    169. 

  169.                         require_once 'Zend/Locale/Exception.php';
    170. 

  170.                         throw new Zend_Locale_Exception("'" .
    171. 

  171.                             (gettype($value) === 'object' ? get_class($value) : $value)
    172. 

  172.                             . "' is not a known locale.");
    173. 

  173.                     }
    174. 

  174.                     break;
    175. 

  175. 

  176.                 case 'cache' :
    177. 

  177.                     if ($value instanceof Zend_Cache_Core) {
    178. 

  178.                         Zend_Locale_Data::setCache($value);
    179. 

  179.                     }
    180. 

  180.                     break;
    181. 

  181. 

  182.                 case 'precision' :
    183. 

  183.                     if ($value === NULL) {
    184. 

  184.                         $value = -1;
    185. 

  185.                     }
    186. 

  186.                     if (($value < -1) || ($value > 30)) {
    187. 

  187.                         require_once 'Zend/Locale/Exception.php';
    188. 

  188.                         throw new Zend_Locale_Exception("'$value' precision is not a whole number less than 30.");
    189. 

  189.                     }
    190. 

  190.                     break;
    191. 

  191. 

  192.                 default:
    193. 

  193.                     require_once 'Zend/Locale/Exception.php';
    194. 

  194.                     throw new Zend_Locale_Exception("Unknown option: '$name' = '$value'");
    195. 

  195.                     break;
    196. 

  196. 

  197.             }
    198. 

  198.         }
    199. 

  199.         return $options;
    200. 

  200.     }
    201. 

  201. 

  202.     /**
    203. 

  203.      * Changes the numbers/digits within a given string from one script to another
    204. 

  204.      * 'Decimal' representated the stardard numbers 0-9, if a script does not exist
    205. 

  205.      * an exception will be thrown.
    206. 

  206.      *
    207. 

  207.      * Examples for conversion from Arabic to Latin numerals:
    208. 

  208.      *   convertNumerals('١١٠ Tests', 'Arab'); -> returns '100 Tests'
    209. 

  209.      * Example for conversion from Latin to Arabic numerals:
    210. 

  210.      *   convertNumerals('100 Tests', 'Latn', 'Arab'); -> returns '١١٠ Tests'
    211. 

  211.      *
    212. 

  212.      * @param  string  $input  String to convert
    213. 

  213.      * @param  string  $from   Script to parse, see {@link Zend_Locale::getScriptList()} for details.
    214. 

  214.      * @param  string  $to     OPTIONAL Script to convert to
    215. 

  215.      * @return string  Returns the converted input
    216. 

  216.      * @throws Zend_Locale_Exception
    217. 

  217.      */
    218. 

  218.     public static function convertNumerals($input, $from, $to = null)
    219. 

  219.     {
    220. 

  220.         if (is_string($from)) {
    221. 

  221.             $from = ucfirst(strtolower($from));
    222. 

  222.         }
    223. 

  223.         if (isset(self::$_signs[$from]) === false) {
    224. 

  224.             require_once 'Zend/Locale/Exception.php';
    225. 

  225.             throw new Zend_Locale_Exception("Unknown script '$from'. Use 'Latn' for digits 0,1,2,3,4,5,6,7,8,9.");
    226. 

  226.         }
    227. 

  227.         if (is_string($to)) {
    228. 

  228.             $to = ucfirst(strtolower($to));
    229. 

  229.         }
    230. 

  230.         if (($to !== null) and (isset(self::$_signs[$to]) === false)) {
    231. 

  231.             require_once 'Zend/Locale/Exception.php';
    232. 

  232.             throw new Zend_Locale_Exception("Unknown script '$to'. Use 'Latn' for digits 0,1,2,3,4,5,6,7,8,9.");
    233. 

  233.         }
    234. 

  234. 

  235.         if (isset(self::$_signs[$from])) {
    236. 

  236.             for ($X = 0; $X < 10; ++$X) {
    237. 

  237.                 $source[$X + 10] = "/" . self::$_signs[$from][$X] . "/u";
    238. 

  238.             }
    239. 

  239.         }
    240. 

  240. 

  241.         if (isset(self::$_signs[$to])) {
    242. 

  242.             for ($X = 0; $X < 10; ++$X) {
    243. 

  243.                 $dest[$X + 10] = self::$_signs[$to][$X];
    244. 

  244.             }
    245. 

  245.         } else {
    246. 

  246.             for ($X = 0; $X < 10; ++$X) {
    247. 

  247.                 $dest[$X + 10] = $X;
    248. 

  248.             }
    249. 

  249.         }
    250. 

  250. 

  251.         return preg_replace($source, $dest, $input);
    252. 

  252.     }
    253. 

  253. 

  254.     /**
    255. 

  255.      * Returns the first found number from an string
    256. 

  256.      * Parsing depends on given locale (grouping and decimal)
    257. 

  257.      *
    258. 

  258.      * Examples for input:
    259. 

  259.      * '  2345.4356,1234' = 23455456.1234
    260. 

  260.      * '+23,3452.123' = 233452.123
    261. 

  261.      * ' 12343 ' = 12343
    262. 

  262.      * '-9456km' = -9456
    263. 

  263.      * '0' = 0
    264. 

  264.      * '(-){0,1}(\d+(\.){0,1})*(\,){0,1})\d+'
    265. 

  265.      * '١١٠ Tests' = 110  call: getNumber($string, 'Arab');
    266. 

  266.      *
    267. 

  267.      * @param  string         $input    Input string to parse for numbers
    268. 

  268.      * @param  array          $options  Options: locale, precision. See {@link setOptions()} for details.
    269. 

  269.      * @return integer|string Returns the extracted number
    270. 

  270.      * @throws Zend_Locale_Exception
    271. 

  271.      */
    272. 

  272.     public static function getNumber($input, array $options = array())
    273. 

  273.     {
    274. 

  274.         $options = self::_checkOptions($options) + self::$_options;
    275. 

  275.         if (!is_string($input)) {
    276. 

  276.             return $input;
    277. 

  277.         }
    278. 

  278. 

  279.         // Get correct signs for this locale
    280. 

  280.         $symbols = Zend_Locale_Data::getList($options['locale'],'symbols');
    281. 

  281. 

  282.         // Parse input locale aware
    283. 

  283.         $regex = '/([' . $symbols['minus'] . '-]){0,1}(\d+(\\' . $symbols['group'] . '){0,1})*(\\' .
    284. 

  284.                         $symbols['decimal'] . '){0,1}\d+/';
    285. 

  285.         preg_match($regex, $input, $found);
    286. 

  286.         if (!isset($found[0])) {
    287. 

  287.             require_once 'Zend/Locale/Exception.php';
    288. 

  288.             throw new Zend_Locale_Exception('No value in ' . $input . ' found');
    289. 

  289.         }
    290. 

  290.         $found = $found[0];
    291. 

  291.         // Change locale input to be standard number
    292. 

  292.         if ($symbols['minus'] != "-")
    293. 

  293.             $found = strtr($found,$symbols['minus'],'-');
    294. 

  294.         $found = str_replace($symbols['group'],'', $found);
    295. 

  295. 

  296.         // Do precision
    297. 

  297.         if (strpos($found, $symbols['decimal']) !== false) {
    298. 

  298.             if ($symbols['decimal'] != '.') {
    299. 

  299.                 $found = str_replace($symbols['decimal'], ".", $found);
    300. 

  300.             }
    301. 

  301. 

  302.             $pre = substr($found, strpos($found, '.') + 1);
    303. 

  303.             if ($options['precision'] === null) {
    304. 

  304.                 $options['precision'] = strlen($pre);
    305. 

  305.             }
    306. 

  306. 

  307.             if (strlen($pre) >= $options['precision']) {
    308. 

  308.                 $found = substr($found, 0, strlen($found) - strlen($pre) + $options['precision']);
    309. 

  309.             }
    310. 

  310.         }
    311. 

  311. 

  312.         return $found;
    313. 

  313.     }
    314. 

  314. 

  315.     /**
    316. 

  316.      * Returns a locale formatted number depending on the given options.
    317. 

  317.      * The seperation and fraction sign is used from the set locale.
    318. 

  318.      * ##0.#  -> 12345.12345 -> 12345.12345
    319. 

  319.      * ##0.00 -> 12345.12345 -> 12345.12
    320. 

  320.      * ##,##0.00 -> 12345.12345 -> 12,345.12
    321. 

  321.      *
    322. 

  322.      * @param   string  $input    Localized number string
    323. 

  323.      * @param   array   $options  Options: number_format, locale, precision. See {@link setOptions()} for details.
    324. 

  324.      * @return  string  locale formatted number
    325. 

  325.      * @throws Zend_Locale_Exception
    326. 

  326.      */
    327. 

  327.     public static function toNumber($value, array $options = array())
    328. 

  328.     {
    329. 

  329.         // load class within method for speed
    330. 

  330.         require_once 'Zend/Locale/Math.php';
    331. 

  331. 

  332.         $value             = Zend_Locale_Math::normalize($value);
    333. 

  333.         $options           = self::_checkOptions($options) + self::$_options;
    334. 

  334.         $options['locale'] = (string) $options['locale'];
    335. 

  335. 

  336.         // Get correct signs for this locale
    337. 

  337.         $symbols = Zend_Locale_Data::getList($options['locale'], 'symbols');
    338. 

  338.         iconv_set_encoding('internal_encoding', 'UTF-8');
    339. 

  339. 

  340.         // Get format
    341. 

  341.         $format = $options['number_format'];
    342. 

  342.         if ($format === null) {
    343. 

  343.             $format  = Zend_Locale_Data::getContent($options['locale'], 'decimalnumber');
    344. 

  344.             if (iconv_strpos($format, ';') !== false) {
    345. 

  345.                 if (call_user_func(Zend_Locale_Math::$comp, $value, 0) < 0) {
    346. 

  346.                     $format = iconv_substr($format, iconv_strpos($format, ';') + 1);
    347. 

  347.                 } else {
    348. 

  348.                     $format = iconv_substr($format, 0, iconv_strpos($format, ';'));
    349. 

  349.                 }
    350. 

  350.             }
    351. 

  351.         } else {
    352. 

  352.             // seperate negative format pattern when available
    353. 

  353.             if (iconv_strpos($format, ';') !== false) {
    354. 

  354.                 if (call_user_func(Zend_Locale_Math::$comp, $value, 0) < 0) {
    355. 

  355.                     $format = iconv_substr($format, iconv_strpos($format, ';') + 1);
    356. 

  356.                 } else {
    357. 

  357.                     $format = iconv_substr($format, 0, iconv_strpos($format, ';'));
    358. 

  358.                 }
    359. 

  359.             }
    360. 

  360. 

  361.             if (strpos($format, '.')) {
    362. 

  362.                 if (is_numeric($options['precision'])) {
    363. 

  363.                     $value = Zend_Locale_Math::round($value, $options['precision']);
    364. 

  364.                 } else {
    365. 

  365.                     if (substr($format, strpos($format, '.') + 1, 3) == '###') {
    366. 

  366.                         $options['precision'] = null;
    367. 

  367.                     } else {
    368. 

  368.                         $options['precision'] = strlen(substr($format, strpos($format, '.') + 1,
    369. 

  369.                                                               strrpos($format, '0') - strpos($format, '.')));
    370. 

  370.                         $format = substr($format, 0, strpos($format, '.') + 1) . '###'
    371. 

  371.                                 . substr($format, strrpos($format, '0') + 1);
    372. 

  372.                     }
    373. 

  373.                 }
    374. 

  374.             } else {
    375. 

  375.                 $value = Zend_Locale_Math::round($value, 0);
    376. 

  376.                 $options['precision'] = 0;
    377. 

  377.             }
    378. 

  378.             $value = Zend_Locale_Math::normalize($value);
    379. 

  379.         }
    380. 

  380.         if (strpos($format, '0') === false) {
    381. 

  381.             require_once 'Zend/Locale/Exception.php';
    382. 

  382.             throw new Zend_Locale_Exception('Wrong format... missing 0');
    383. 

  383.         }
    384. 

  384. 

  385.         // get number parts
    386. 

  386.         if (strlen($value) != strlen(Zend_Locale_Math::round($value, 0))) {
    387. 

  387.             if ($options['precision'] === null) {
    388. 

  388.                 $precstr = iconv_substr($value, strlen(Zend_Locale_Math::round($value, 0)) + 1);
    389. 

  389.             } else {
    390. 

  390.                 $precstr = iconv_substr($value, strlen(Zend_Locale_Math::round($value, 0)) + 1, $options['precision']);
    391. 

  391.                 if (iconv_strlen($precstr) < $options['precision']) {
    392. 

  392.                     $precstr = $precstr . str_pad("0", ($options['precision'] - iconv_strlen($precstr)), "0");
    393. 

  393.                 }
    394. 

  394.             }
    395. 

  395.         } else {
    396. 

  396.             if ($options['precision'] > 0) {
    397. 

  397.                 $precstr = str_pad("0", ($options['precision']), "0");
    398. 

  398.             }
    399. 

  399.         }
    400. 

  400. 

  401.         if ($options['precision'] === null) {
    402. 

  402.             if (isset($precstr)) {
    403. 

  403.                 $options['precision'] = iconv_strlen($precstr);
    404. 

  404.             } else {
    405. 

  405.                 $options['precision'] = 0;
    406. 

  406.             }
    407. 

  407.         }
    408. 

  408. 

  409.         // get fraction and format lengths
    410. 

  410.         if (strpos($value, '.') !== false) {
    411. 

  411.             $number = substr((string) $value, 0, strpos($value, '.'));
    412. 

  412.         } else {
    413. 

  413.             $number = $value;
    414. 

  414.         }
    415. 

  415. 

  416.         $prec = call_user_func(Zend_Locale_Math::$sub, $value, $number, $options['precision']);
    417. 

  417.         $prec = Zend_Locale_Math::normalize($prec);
    418. 

  418.         if (iconv_strpos($prec, '-') !== false) {
    419. 

  419.             $prec = iconv_substr($prec, 1);
    420. 

  420.         }
    421. 

  421.         if (($prec == 0) and ($options['precision'] > 0)) {
    422. 

  422.             $prec = "0.0";
    423. 

  423.         }
    424. 

  424.         if (($options['precision'] + 2) > iconv_strlen($prec)) {
    425. 

  425.             $prec = str_pad((string) $prec, $options['precision'] + 2, "0", STR_PAD_RIGHT);
    426. 

  426.         }
    427. 

  427.         if (iconv_strpos($number, '-') !== false) {
    428. 

  428.             $number = iconv_substr($number, 1);
    429. 

  429.         }
    430. 

  430.         $group  = iconv_strrpos($format, ',');
    431. 

  431.         $group2 = iconv_strpos ($format, ',');
    432. 

  432.         $point  = iconv_strpos ($format, '0');
    433. 

  433.         // Add fraction
    434. 

  434.         $rest = "";
    435. 

  435.         if (($value < 0) && (strpos($format, '.'))) {
    436. 

  436.             $rest   = substr(substr($format, strpos($format, '.') + 1), -1, 1);
    437. 

  437.         }
    438. 

  438.         if ($options['precision'] == '0') {
    439. 

  439.             $format = iconv_substr($format, 0, $point) . iconv_substr($format, iconv_strrpos($format, '#') + 2);
    440. 

  440.         } else {
    441. 

  441.             $format = iconv_substr($format, 0, $point) . $symbols['decimal']
    442. 

  442.                                . iconv_substr($prec, 2) . iconv_substr($format, iconv_strrpos($format, '#') + 2 + strlen($prec) - 2);
    443. 

  443.         }
    444. 

  444.         if (($value < 0) and ($rest != '0') and ($rest != '#')) {
    445. 

  445.             $format .= $rest;
    446. 

  446.         }
    447. 

  447.         // Add seperation
    448. 

  448.         if ($group == 0) {
    449. 

  449.             // no seperation
    450. 

  450.             $format = $number . iconv_substr($format, $point);
    451. 

  451.         } else if ($group == $group2) {
    452. 

  452.             // only 1 seperation
    453. 

  453.             $seperation = ($point - $group);
    454. 

  454.             for ($x = iconv_strlen($number); $x > $seperation; $x -= $seperation) {
    455. 

  455.                 if (iconv_substr($number, 0, $x - $seperation) !== "") {
    456. 

  456.                     $number = iconv_substr($number, 0, $x - $seperation) . $symbols['group']
    457. 

  457.                              . iconv_substr($number, $x - $seperation);
    458. 

  458.                 }
    459. 

  459.             }
    460. 

  460.             $format = iconv_substr($format, 0, iconv_strpos($format, '#')) . $number . iconv_substr($format, $point);
    461. 

  461.         } else {
    462. 

  462. 

  463.             // 2 seperations
    464. 

  464.             if (iconv_strlen($number) > ($point - $group)) {
    465. 

  465.                 $seperation = ($point - $group);
    466. 

  466.                 $number = iconv_substr($number, 0, iconv_strlen($number) - $seperation) . $symbols['group']
    467. 

  467.                         . iconv_substr($number, iconv_strlen($number) - $seperation);
    468. 

  468. 

  469.                 if ((iconv_strlen($number) - 1) > ($point - $group + 1)) {
    470. 

  470.                     $seperation2 = ($group - $group2 - 1);
    471. 

  471. 

  472.                     for ($x = iconv_strlen($number) - $seperation2 - 2; $x > $seperation2; $x -= $seperation2) {
    473. 

  473.                          $number = iconv_substr($number, 0, $x - $seperation2) . $symbols['group']
    474. 

  474.                                  . iconv_substr($number, $x - $seperation2);
    475. 

  475.                     }
    476. 

  476.                 }
    477. 

  477. 

  478.             }
    479. 

  479.             $format = iconv_substr($format, 0, iconv_strpos($format, '#')) . $number . iconv_substr($format, $point);
    480. 

  480.         }
    481. 

  481.         // set negative sign
    482. 

  482.         if (call_user_func(Zend_Locale_Math::$comp, $value, 0) < 0) {
    483. 

  483.             if (iconv_strpos($format, '-') === false) {
    484. 

  484.                 $format = $symbols['minus'] . $format;
    485. 

  485.             } else {
    486. 

  486.                 $format = str_replace('-', $symbols['minus'], $format);
    487. 

  487.             }
    488. 

  488.         }
    489. 

  489.         return (string) $format;
    490. 

  490.     }
    491. 

  491. 

  492.     /**
    493. 

  493.      * Checks if the input contains a normalized or localized number
    494. 

  494.      *
    495. 

  495.      * @param   string  $input    Localized number string
    496. 

  496.      * @param   array   $options  Options: locale. See {@link setOptions()} for details.
    497. 

  497.      * @return  boolean           Returns true if a number was found
    498. 

  498.      */
    499. 

  499.     public static function isNumber($input, array $options = array())
    500. 

  500.     {
    501. 

  501.         $options = self::_checkOptions($options) + self::$_options;
    502. 

  502. 

  503.         // Get correct signs for this locale
    504. 

  504.         $symbols = Zend_Locale_Data::getList($options['locale'],'symbols');
    505. 

  505. 

  506.         // Parse input locale aware
    507. 

  507.         $regex = '/^([' . $symbols['minus'] . '-]){0,1}(\d+(\\' . $symbols['group']
    508. 

  508.             . '){0,1})*(\\' . $symbols['decimal'] . '){0,1}\d+$/';
    509. 

  509.         preg_match($regex, $input, $found);
    510. 

  510. 

  511.         if (!isset($found[0]))
    512. 

  512.             return false;
    513. 

  513.         return true;
    514. 

  514.     }
    515. 

  515. 

  516.     /**
    517. 

  517.      * Alias for getNumber
    518. 

  518.      *
    519. 

  519.      * @param   string  $value    Number to localize
    520. 

  520.      * @param   array   $options  Options: locale, precision. See {@link setOptions()} for details.
    521. 

  521.      * @return  float
    522. 

  522.      */
    523. 

  523.     public static function getFloat($input, array $options = array())
    524. 

  524.     {
    525. 

  525.         return floatval(self::getNumber($input, $options));
    526. 

  526.     }
    527. 

  527. 

  528.     /**
    529. 

  529.      * Returns a locale formatted integer number
    530. 

  530.      * Alias for toNumber()
    531. 

  531.      *
    532. 

  532.      * @param   string  $value    Number to normalize
    533. 

  533.      * @param   array   $options  Options: locale, precision. See {@link setOptions()} for details.
    534. 

  534.      * @return  string  Locale formatted number
    535. 

  535.      */
    536. 

  536.     public static function toFloat($value, array $options = array())
    537. 

  537.     {
    538. 

  538.         $options['number_format'] = 'standard';
    539. 

  539.         return self::toNumber($value, $options);
    540. 

  540.     }
    541. 

  541. 

  542.     /**
    543. 

  543.      * Returns if a float was found
    544. 

  544.      * Alias for isNumber()
    545. 

  545.      *
    546. 

  546.      * @param   string  $input    Localized number string
    547. 

  547.      * @param   array   $options  Options: locale. See {@link setOptions()} for details.
    548. 

  548.      * @return  boolean           Returns true if a number was found
    549. 

  549.      */
    550. 

  550.     public static function isFloat($value, array $options = array())
    551. 

  551.     {
    552. 

  552.         return self::isNumber($value, $options);
    553. 

  553.     }
    554. 

  554. 

  555.     /**
    556. 

  556.      * Returns the first found integer from an string
    557. 

  557.      * Parsing depends on given locale (grouping and decimal)
    558. 

  558.      *
    559. 

  559.      * Examples for input:
    560. 

  560.      * '  2345.4356,1234' = 23455456
    561. 

  561.      * '+23,3452.123' = 233452
    562. 

  562.      * ' 12343 ' = 12343
    563. 

  563.      * '-9456km' = -9456
    564. 

  564.      * '0' = 0
    565. 

  565.      * '(-){0,1}(\d+(\.){0,1})*(\,){0,1})\d+'
    566. 

  566.      *
    567. 

  567.      * @param   string   $input    Input string to parse for numbers
    568. 

  568.      * @param   array    $options  Options: locale. See {@link setOptions()} for details.
    569. 

  569.      * @return  integer            Returns the extracted number
    570. 

  570.      */
    571. 

  571.     public static function getInteger($input, array $options = array())
    572. 

  572.     {
    573. 

  573.         $options['precision'] = 0;
    574. 

  574.         return intval(self::getFloat($input, $options));
    575. 

  575.     }
    576. 

  576. 

  577.     /**
    578. 

  578.      * Returns a localized number
    579. 

  579.      *
    580. 

  580.      * @param   string  $value    Number to normalize
    581. 

  581.      * @param   array   $options  Options: locale. See {@link setOptions()} for details.
    582. 

  582.      * @return  string            Locale formatted number
    583. 

  583.      */
    584. 

  584.     public static function toInteger($value, array $options = array())
    585. 

  585.     {
    586. 

  586.         $options['precision'] = 0;
    587. 

  587.         $options['number_format'] = 'standard';
    588. 

  588.         return self::toNumber($value, $options);
    589. 

  589.     }
    590. 

  590. 

  591.     /**
    592. 

  592.      * Returns if a integer was found
    593. 

  593.      *
    594. 

  594.      * @param   string  $input    Localized number string
    595. 

  595.      * @param   array   $options  Options: locale. See {@link setOptions()} for details.
    596. 

  596.      * @return  boolean           Returns true if a integer was found
    597. 

  597.      */
    598. 

  598.     public static function isInteger($value, array $options = array())
    599. 

  599.     {
    600. 

  600.         $options['precision'] = 0;
    601. 

  601.         return self::isNumber($value, $options);
    602. 

  602.     }
    603. 

  603. 

  604.     /**
    605. 

  605.      * Converts a format string from PHP's date format to ISO format
    606. 

  606.      * Remember that Zend Date always returns localized string, so a month name which returns the english
    607. 

  607.      * month in php's date() will return the translated month name with this function... use 'en' as locale
    608. 

  608.      * if you are in need of the original english names
    609. 

  609.      *
    610. 

  610.      * The conversion has the following restrictions:
    611. 

  611.      * 'a', 'A' - Meridiem is not explicit upper/lowercase, you have to upper/lowercase the translated value yourself
    612. 

  612.      *
    613. 

  613.      * @param  string  $format  Format string in PHP's date format
    614. 

  614.      * @return string           Format string in ISO format
    615. 

  615.      */
    616. 

  616.     public static function convertPhpToIsoFormat($format)
    617. 

  617.     {
    618. 

  618.         $convert = array('d' => 'dd'  , 'D' => 'EE'  , 'j' => 'd'   , 'l' => 'EEEE', 'N' => 'e'   , 'S' => 'SS'  ,
    619. 

  619.                          'w' => 'eee' , 'z' => 'D'   , 'W' => 'w'   , 'F' => 'MMMM', 'm' => 'MM'  , 'M' => 'MMM' ,
    620. 

  620.                          'n' => 'M'   , 't' => 'ddd' , 'L' => 'l'   , 'o' => 'YYYY', 'Y' => 'yyyy', 'y' => 'yy'  ,
    621. 

  621.                          'a' => 'a'   , 'A' => 'a'   , 'B' => 'B'   , 'g' => 'h'   , 'G' => 'H'   , 'h' => 'hh'  ,
    622. 

  622.                          'H' => 'HH'  , 'i' => 'mm'  , 's' => 'ss'  , 'e' => 'zzzz', 'I' => 'I'   , 'O' => 'Z'   ,
    623. 

  623.                          'P' => 'ZZZZ', 'T' => 'z'   , 'Z' => 'X'   , 'c' => 'yyyy-MM-ddTHH:mm:ssZZZZ',
    624. 

  624.                          'r' => 'r'   , 'U' => 'U');
    625. 

  625.         $values = str_split($format);
    626. 

  626.         foreach ($values as $key => $value) {
    627. 

  627.             if (isset($convert[$value]) === true) {
    628. 

  628.                 $values[$key] = $convert[$value];
    629. 

  629.             }
    630. 

  630.         }
    631. 

  631.         return join($values);
    632. 

  632.     }
    633. 

  633. 

  634.     /**
    635. 

  635.      * Parse date and split in named array fields
    636. 

  636.      *
    637. 

  637.      * @param   string  $date     Date string to parse
    638. 

  638.      * @param   array   $options  Options: format_type, fix_date, locale, date_format. See {@link setOptions()} for details.
    639. 

  639.      * @return  array             Possible array members: day, month, year, hour, minute, second, fixed, format
    640. 

  640.      */
    641. 

  641.     private static function _parseDate($date, $options)
    642. 

  642.     {
    643. 

  643.         $options = self::_checkOptions($options) + self::$_options;
    644. 

  644.         $test = array('h', 'H', 'm', 's', 'y', 'Y', 'M', 'd', 'D', 'E', 'S', 'l', 'B', 'I',
    645. 

  645.                        'X', 'r', 'U', 'G', 'w', 'e', 'a', 'A', 'Z', 'z', 'v');
    646. 

  646. 

  647.         $format = $options['date_format'];
    648. 

  648.         foreach (str_split($format) as $splitted) {
    649. 

  649.             if ((!in_array($splitted, $test)) and (ctype_alpha($splitted))) {
    650. 

  650.                 require_once 'Zend/Locale/Exception.php';
    651. 

  651.                 throw new Zend_Locale_Exception("Unable to parse the date format string '" . $format
    652. 

  652.                                               . "' at letter '$splitted'");
    653. 

  653.             }
    654. 

  654.         }
    655. 

  655.         $number = $date; // working copy
    656. 

  656.         $result['date_format'] = $format; // save the format used to normalize $number (convenience)
    657. 

  657.         $result['locale'] = $options['locale']; // save the locale used to normalize $number (convenience)
    658. 

  658. 

  659.         $day   = iconv_strpos($format, 'd');
    660. 

  660.         $month = iconv_strpos($format, 'M');
    661. 

  661.         $year  = iconv_strpos($format, 'y');
    662. 

  662.         $hour  = iconv_strpos($format, 'H');
    663. 

  663.         $min   = iconv_strpos($format, 'm');
    664. 

  664.         $sec   = iconv_strpos($format, 's');
    665. 

  665.         $am    = null;
    666. 

  666.         if ($hour === false) {
    667. 

  667.             $hour = iconv_strpos($format, 'h');
    668. 

  668.         }
    669. 

  669.         if ($year === false) {
    670. 

  670.             $year = iconv_strpos($format, 'Y');
    671. 

  671.         }
    672. 

  672.         if ($day === false) {
    673. 

  673.             $day = iconv_strpos($format, 'E');
    674. 

  674.             if ($day === false) {
    675. 

  675.                 $day = iconv_strpos($format, 'D');
    676. 

  676.             }
    677. 

  677.         }
    678. 

  678. 

  679.         if ($day !== false) {
    680. 

  680.             $parse[$day]   = 'd';
    681. 

  681.             if (!empty($options['locale']) && ($options['locale'] !== 'root') &&
    682. 

  682.                 (!is_object($options['locale']) || ((string) $options['locale'] !== 'root'))) {
    683. 

  683.                 // erase day string
    684. 

  684.                     $daylist = Zend_Locale_Data::getList($options['locale'], 'day');
    685. 

  685.                 foreach($daylist as $key => $name) {
    686. 

  686.                     if (iconv_strpos($number, $name) !== false) {
    687. 

  687.                         $number = str_replace($name, "EEEE", $number);
    688. 

  688.                         break;
    689. 

  689.                     }
    690. 

  690.                 }
    691. 

  691.             }
    692. 

  692.         }
    693. 

  693.         $position = false;
    694. 

  694. 

  695.         if ($month !== false) {
    696. 

  696.             $parse[$month] = 'M';
    697. 

  697.             if (!empty($options['locale']) && ($options['locale'] !== 'root') &&
    698. 

  698.                 (!is_object($options['locale']) || ((string) $options['locale'] !== 'root'))) {
    699. 

  699.                     // prepare to convert month name to their numeric equivalents, if requested,
    700. 

  700.                     // and we have a $options['locale']
    701. 

  701.                     $position = self::_replaceMonth($number, Zend_Locale_Data::getList($options['locale'],
    702. 

  702.                         'month'));
    703. 

  703.                 if ($position === false) {
    704. 

  704.                     $position = self::_replaceMonth($number, Zend_Locale_Data::getList($options['locale'],
    705. 

  705.                         'month', array('gregorian', 'format', 'abbreviated')));
    706. 

  706.                 }
    707. 

  707.             }
    708. 

  708.         }
    709. 

  709.         if ($year !== false) {
    710. 

  710.             $parse[$year]  = 'y';
    711. 

  711.         }
    712. 

  712.         if ($hour !== false) {
    713. 

  713.             $parse[$hour] = 'H';
    714. 

  714.         }
    715. 

  715.         if ($min !== false) {
    716. 

  716.             $parse[$min] = 'm';
    717. 

  717.         }
    718. 

  718.         if ($sec !== false) {
    719. 

  719.             $parse[$sec] = 's';
    720. 

  720.         }
    721. 

  721. 

  722.         if (empty($parse)) {
    723. 

  723.             require_once 'Zend/Locale/Exception.php';
    724. 

  724.             throw new Zend_Locale_Exception("unknown date format, neither date nor time in '" . $format . "' found");
    725. 

  725.         }
    726. 

  726.         ksort($parse);
    727. 

  727. 

  728.         // get daytime
    729. 

  729.         if (iconv_strpos($format, 'a') !== false) {
    730. 

  730.             if (iconv_strpos(strtoupper($number), strtoupper(Zend_Locale_Data::getContent($options['locale'], 'am'))) !== false) {
    731. 

  731.                 $am = true;
    732. 

  732.             } else if (iconv_strpos(strtoupper($number), strtoupper(Zend_Locale_Data::getContent($options['locale'], 'pm'))) !== false) {
    733. 

  733.                 $am = false;
    734. 

  734.             }
    735. 

  735.         }
    736. 

  736. 

  737.         // split number parts
    738. 

  738.         $split = false;
    739. 

  739.         preg_match_all('/\d+/u', $number, $splitted);
    740. 

  740. 

  741.         if (count($splitted[0]) == 0) {
    742. 

  742.             require_once 'Zend/Locale/Exception.php';
    743. 

  743.             throw new Zend_Locale_Exception("No date part in '$date' found.");
    744. 

  744.         }
    745. 

  745.         if (count($splitted[0]) == 1) {
    746. 

  746.             $split = 0;
    747. 

  747.         }
    748. 

  748.         $cnt = 0;
    749. 

  749.         foreach($parse as $key => $value) {
    750. 

  750. 

  751.             switch($value) {
    752. 

  752.                 case 'd':
    753. 

  753.                     if ($split === false) {
    754. 

  754.                         if (count($splitted[0]) > $cnt) {
    755. 

  755.                             $result['day']    = $splitted[0][$cnt];
    756. 

  756.                         }
    757. 

  757.                     } else {
    758. 

  758.                         $result['day'] = iconv_substr($splitted[0][0], $split, 2);
    759. 

  759.                         $split += 2;
    760. 

  760.                     }
    761. 

  761.                     ++$cnt;
    762. 

  762.                     break;
    763. 

  763.                 case 'M':
    764. 

  764.                     if ($split === false) {
    765. 

  765.                         if (count($splitted[0]) > $cnt) {
    766. 

  766.                             $result['month']  = $splitted[0][$cnt];
    767. 

  767.                         }
    768. 

  768.                     } else {
    769. 

  769.                         $result['month'] = iconv_substr($splitted[0][0], $split, 2);
    770. 

  770.                         $split += 2;
    771. 

  771.                     }
    772. 

  772.                     ++$cnt;
    773. 

  773.                     break;
    774. 

  774.                 case 'y':
    775. 

  775.                     $length = 2;
    776. 

  776.                     if ((iconv_substr($format, $year, 4) == 'yyyy')
    777. 

  777.                      || (iconv_substr($format, $year, 4) == 'YYYY')) {
    778. 

  778.                         $length = 4;
    779. 

  779.                     }
    780. 

  780.                     if ($split === false) {
    781. 

  781.                         if (count($splitted[0]) > $cnt) {
    782. 

  782.                             $result['year']   = $splitted[0][$cnt];
    783. 

  783.                         }
    784. 

  784.                     } else {
    785. 

  785.                         $result['year']   = iconv_substr($splitted[0][0], $split, $length);
    786. 

  786.                         $split += $length;
    787. 

  787.                     }
    788. 

  788.                     ++$cnt;
    789. 

  789.                     break;
    790. 

  790.                 case 'H':
    791. 

  791.                     if ($split === false) {
    792. 

  792.                         if (count($splitted[0]) > $cnt) {
    793. 

  793.                             $result['hour']   = $splitted[0][$cnt];
    794. 

  794.                         }
    795. 

  795.                     } else {
    796. 

  796.                         $result['hour']   = iconv_substr($splitted[0][0], $split, 2);
    797. 

  797.                         $split += 2;
    798. 

  798.                     }
    799. 

  799.                     ++$cnt;
    800. 

  800.                     break;
    801. 

  801.                 case 'm':
    802. 

  802.                     if ($split === false) {
    803. 

  803.                         if (count($splitted[0]) > $cnt) {
    804. 

  804.                             $result['minute'] = $splitted[0][$cnt];
    805. 

  805.                         }
    806. 

  806.                     } else {
    807. 

  807.                         $result['minute'] = iconv_substr($splitted[0][0], $split, 2);
    808. 

  808.                         $split += 2;
    809. 

  809.                     }
    810. 

  810.                     ++$cnt;
    811. 

  811.                     break;
    812. 

  812.                 case 's':
    813. 

  813.                     if ($split === false) {
    814. 

  814.                         if (count($splitted[0]) > $cnt) {
    815. 

  815.                             $result['second'] = $splitted[0][$cnt];
    816. 

  816.                         }
    817. 

  817.                     } else {
    818. 

  818.                         $result['second'] = iconv_substr($splitted[0][0], $split, 2);
    819. 

  819.                         $split += 2;
    820. 

  820.                     }
    821. 

  821.                     ++$cnt;
    822. 

  822.                     break;
    823. 

  823.             }
    824. 

  824.         }
    825. 

  825. 

  826.         // AM/PM correction
    827. 

  827.         if ($hour !== false) {
    828. 

  828.             if (($am === true) and ($result['hour'] == 12)){
    829. 

  829.                 $result['hour'] = 0;
    830. 

  830.             } else if (($am === false) and ($result['hour'] != 12)) {
    831. 

  831.                 $result['hour'] += 12;
    832. 

  832.             }
    833. 

  833.         }
    834. 

  834. 

  835.         if ($options['fix_date'] === true) {
    836. 

  836.             $result['fixed'] = 0; // nothing has been "fixed" by swapping date parts around (yet)
    837. 

  837.         }
    838. 

  838. 

  839.         if ($day !== false) {
    840. 

  840.             // fix false month
    841. 

  841.             if (isset($result['day']) and isset($result['month'])) {
    842. 

  842.                 if (($position !== false) and ((iconv_strpos($date, $result['day']) === false) or
    843. 

  843.                                                (isset($result['year']) and (iconv_strpos($date, $result['year']) === false)))) {
    844. 

  844.                     if ($options['fix_date'] !== true) {
    845. 

  845.                         require_once 'Zend/Locale/Exception.php';
    846. 

  846.                         throw new Zend_Locale_Exception("unable to parse date '$date' using '" . $format
    847. 

  847.                             . "' (false month, $position, $month)");
    848. 

  848.                     }
    849. 

  849.                     $temp = $result['day'];
    850. 

  850.                     $result['day']   = $result['month'];
    851. 

  851.                     $result['month'] = $temp;
    852. 

  852.                     $result['fixed'] = 1;
    853. 

  853.                 }
    854. 

  854.             }
    855. 

  855. 

  856.             // fix switched values d <> y
    857. 

  857.             if (isset($result['day']) and isset($result['year'])) {
    858. 

  858.                 if ($result['day'] > 31) {
    859. 

  859.                     if ($options['fix_date'] !== true) {
    860. 

  860.                         require_once 'Zend/Locale/Exception.php';
    861. 

  861.                         throw new Zend_Locale_Exception("unable to parse date '$date' using '"
    862. 

  862.                                                       . $format . "' (d <> y)");
    863. 

  863.                     }
    864. 

  864.                     $temp = $result['year'];
    865. 

  865.                     $result['year'] = $result['day'];
    866. 

  866.                     $result['day']  = $temp;
    867. 

  867.                     $result['fixed'] = 2;
    868. 

  868.                 }
    869. 

  869.             }
    870. 

  870. 

  871.             // fix switched values M <> y
    872. 

  872.             if (isset($result['month']) and isset($result['year'])) {
    873. 

  873.                 if ($result['month'] > 31) {
    874. 

  874.                     if ($options['fix_date'] !== true) {
    875. 

  875.                         require_once 'Zend/Locale/Exception.php';
    876. 

  876.                         throw new Zend_Locale_Exception("unable to parse date '$date' using '"
    877. 

  877.                                                       . $format . "' (M <> y)");
    878. 

  878.                     }
    879. 

  879.                     $temp = $result['year'];
    880. 

  880.                     $result['year']  = $result['month'];
    881. 

  881.                     $result['month'] = $temp;
    882. 

  882.                     $result['fixed'] = 3;
    883. 

  883.                 }
    884. 

  884.             }
    885. 

  885. 

  886.             // fix switched values M <> d
    887. 

  887.             if (isset($result['month']) and isset($result['day'])) {
    888. 

  888.                 if ($result['month'] > 12) {
    889. 

  889.                     if ($options['fix_date'] !== true || $result['month'] > 31) {
    890. 

  890.                         require_once 'Zend/Locale/Exception.php';
    891. 

  891.                         throw new Zend_Locale_Exception("unable to parse date '$date' using '"
    892. 

  892.                                                       . $format . "' (M <> d)");
    893. 

  893.                     }
    894. 

  894.                     $temp = $result['day'];
    895. 

  895.                     $result['day']   = $result['month'];
    896. 

  896.                     $result['month'] = $temp;
    897. 

  897.                     $result['fixed'] = 4;
    898. 

  898.                 }
    899. 

  899.             }
    900. 

  900.         }
    901. 

  901.         return $result;
    902. 

  902.     }
    903. 

  903. 

  904.     /**
    905. 

  905.      * Search $number for a month name found in $monthlist, and replace if found.
    906. 

  906.      *
    907. 

  907.      * @param  string  $number     Date string (modified)
    908. 

  908.      * @param  array   $monthlist  List of month names
    909. 

  909.      *
    910. 

  910.      * @return int|false           Position of replaced string (false if nothing replaced)
    911. 

  911.      */
    912. 

  912.     protected static function _replaceMonth(&$number, $monthlist)
    913. 

  913.     {
    914. 

  914.         // If $locale was invalid, $monthlist will default to a "root" identity
    915. 

  915.         // mapping for each month number from 1 to 12.
    916. 

  916.         // If no $locale was given, or $locale was invalid, do not use this identity mapping to normalize.
    917. 

  917.         // Otherwise, translate locale aware month names in $number to their numeric equivalents.
    918. 

  918.         $position = false;
    919. 

  919.         if ($monthlist && $monthlist[1] != 1) {
    920. 

  920.             foreach($monthlist as $key => $name) {
    921. 

  921.                 if (($position = iconv_strpos($number, $name)) !== false) {
    922. 

  922.                     $number   = str_ireplace($name, $key, $number);
    923. 

  923.                     return $position;
    924. 

  924.                 }
    925. 

  925.             }
    926. 

  926.         }
    927. 

  927.         return false;
    928. 

  928.     }
    929. 

  929. 

  930.     /**
    931. 

  931.      * Returns the default date format for $locale.
    932. 

  932.      *
    933. 

  933.      * @param  string|Zend_Locale  $locale  OPTIONAL Locale of $number, possibly in string form (e.g. 'de_AT')
    934. 

  934.      * @return string  format
    935. 

  935.      * @throws Zend_Locale_Exception  throws an exception when locale data is broken
    936. 

  936.      */
    937. 

  937.     public static function getDateFormat($locale = null)
    938. 

  938.     {
    939. 

  939.         $format = Zend_Locale_Data::getContent($locale, 'date');
    940. 

  940.         if (empty($format)) {
    941. 

  941.             require_once 'Zend/Locale/Exception.php';
    942. 

  942.             throw new Zend_Locale_Exception("failed to receive data from locale $locale");
    943. 

  943.         }
    944. 

  944.         return $format;
    945. 

  945.     }
    946. 

  946. 

  947.     /**
    948. 

  948.      * Returns an array with the normalized date from an locale date
    949. 

  949.      * a input of 10.01.2006 without a $locale would return:
    950. 

  950.      * array ('day' => 10, 'month' => 1, 'year' => 2006)
    951. 

  951.      * The 'locale' option is only used to convert human readable day
    952. 

  952.      * and month names to their numeric equivalents.
    953. 

  953.      * The 'format' option allows specification of self-defined date formats,
    954. 

  954.      * when not using the default format for the 'locale'.
    955. 

  955.      *
    956. 

  956.      * @param   string  $date     Date string
    957. 

  957.      * @param   array   $options  Options: format_type, fix_date, locale, date_format. See {@link setOptions()} for details.
    958. 

  958.      * @return  array             Possible array members: day, month, year, hour, minute, second, fixed, format
    959. 

  959.      */
    960. 

  960.     public static function getDate($date, array $options = array())
    961. 

  961.     {
    962. 

  962.         $options = self::_checkOptions($options) + self::$_options;
    963. 

  963.         if (empty($options['date_format'])) {
    964. 

  964.             $options['format_type'] = 'iso';
    965. 

  965.             $options['date_format'] = self::getDateFormat($options['locale']);
    966. 

  966.         }
    967. 

  967.         return self::_parseDate($date, $options);
    968. 

  968.     }
    969. 

  969. 

  970.     /**
    971. 

  971.      * Returns if the given datestring contains all date parts from the given format.
    972. 

  972.      * If no format is given, the standard date format from the locale is used
    973. 

  973.      * If you want to check if the date is a proper date you should use Zend_Date::isDate()
    974. 

  974.      *
    975. 

  975.      * @param   string  $date     Date string
    976. 

  976.      * @param   array   $options  Options: format_type, fix_date, locale, date_format. See {@link setOptions()} for details.
    977. 

  977.      * @return  boolean
    978. 

  978.      */
    979. 

  979.     public static function checkDateFormat($date, array $options = array())
    980. 

  980.     {
    981. 

  981.         try {
    982. 

  982.             $date = self::getDate($date, $options);
    983. 

  983.         } catch (Exception $e) {
    984. 

  984.             return false;
    985. 

  985.         }
    986. 

  986. 

  987.         if (empty($options['date_format'])) {
    988. 

  988.             $options['format_type'] = 'iso';
    989. 

  989.             $options['date_format'] = self::getDateFormat($options['locale']);
    990. 

  990.         }
    991. 

  991.         $options = self::_checkOptions($options) + self::$_options;
    992. 

  992. 

  993.         // day expected but not parsed
    994. 

  994.         if ((iconv_strpos($options['date_format'], 'd') !== false) and (!isset($date['day']) or ($date['day'] == ""))) {
    995. 

  995.             return false;
    996. 

  996.         }
    997. 

  997. 

  998.         // month expected but not parsed
    999. 

  999.         if ((iconv_strpos($options['date_format'], 'M') !== false) and (!isset($date['month']) or ($date['month'] == ""))) {
    1000. 

  1000.             return false;
    1001. 

  1001.         }
    1002. 

  1002. 

  1003.         // year expected but not parsed
    1004. 

  1004.         if (((iconv_strpos($options['date_format'], 'Y') !== false) or
    1005. 

  1005.              (iconv_strpos($options['date_format'], 'y') !== false)) and (!isset($date['year']) or ($date['year'] == ""))) {
    1006. 

  1006.             return false;
    1007. 

  1007.         }
    1008. 

  1008. 

  1009.         // second expected but not parsed
    1010. 

  1010.         if ((iconv_strpos($options['date_format'], 's') !== false) and (!isset($date['second']) or ($date['second'] == ""))) {
    1011. 

  1011.             return false;
    1012. 

  1012.         }
    1013. 

  1013. 

  1014.         // minute expected but not parsed
    1015. 

  1015.         if ((iconv_strpos($options['date_format'], 'm') !== false) and (!isset($date['minute']) or ($date['minute'] == ""))) {
    1016. 

  1016.             return false;
    1017. 

  1017.         }
    1018. 

  1018. 

  1019.         // hour expected but not parsed
    1020. 

  1020.         if (((iconv_strpos($options['date_format'], 'H') !== false) or
    1021. 

  1021.              (iconv_strpos($options['date_format'], 'h') !== false)) and (!isset($date['hour']) or ($date['hour'] == ""))) {
    1022. 

  1022.             return false;
    1023. 

  1023.         }
    1024. 

  1024.         return true;
    1025. 

  1025.     }
    1026. 

  1026. 

  1027.     /**
    1028. 

  1028.      * Returns the default time format for $locale.
    1029. 

  1029.      *
    1030. 

  1030.      * @param  string|Zend_Locale  $locale  OPTIONAL Locale of $number, possibly in string form (e.g. 'de_AT')
    1031. 

  1031.      * @return string  format
    1032. 

  1032.      */
    1033. 

  1033.     public static function getTimeFormat($locale = null)
    1034. 

  1034.     {
    1035. 

  1035.         $format = Zend_Locale_Data::getContent($locale, 'time');
    1036. 

  1036.         if (empty($format)) {
    1037. 

  1037.             require_once 'Zend/Locale/Exception.php';
    1038. 

  1038.             throw new Zend_Locale_Exception("failed to receive data from locale $locale");
    1039. 

  1039.         }
    1040. 

  1040.         return $format;
    1041. 

  1041.     }
    1042. 

  1042. 

  1043.     /**
    1044. 

  1044.      * Returns an array with 'hour', 'minute', and 'second' elements extracted from $time
    1045. 

  1045.      * according to the order described in $format.  For a format of 'H:m:s', and
    1046. 

  1046.      * an input of 11:20:55, getTime() would return:
    1047. 

  1047.      * array ('hour' => 11, 'minute' => 20, 'second' => 55)
    1048. 

  1048.      * The optional $locale parameter may be used to help extract times from strings
    1049. 

  1049.      * containing both a time and a day or month name.
    1050. 

  1050.      *
    1051. 

  1051.      * @param   string  $time     Time string
    1052. 

  1052.      * @param   array   $options  Options: format_type, fix_date, locale, date_format. See {@link setOptions()} for details.
    1053. 

  1053.      * @return  array             Possible array members: day, month, year, hour, minute, second, fixed, format
    1054. 

  1054.      */
    1055. 

  1055.     public static function getTime($time, array $options = array())
    1056. 

  1056.     {
    1057. 

  1057.         $options = self::_checkOptions($options) + self::$_options;
    1058. 

  1058.         if (empty($options['date_format'])) {
    1059. 

  1059.             $options['format_type'] = 'iso';
    1060. 

  1060.             $options['date_format'] = self::getTimeFormat($options['locale']);
    1061. 

  1061.         }
    1062. 

  1062.         return self::_parseDate($time, $options);
    1063. 

  1063.     }
    1064. 

  1064. }
    1065. 

  1065.