Source for file date.php

Documentation is available at date.php

  1. <?php
  2.  
  3. /**
  4.  * date.php
  5.  *
  6.  * Takes a date and parses it into a usable format.  The form that a
  7.  * date SHOULD arrive in is:
  8.  *       <Tue,> 29 Jun 1999 09:52:11 -0500 (EDT)
  9.  * (as specified in RFC 822) -- 'Tue' is optional
  10.  *
  11.  * @copyright 1999-2014 The SquirrelMail Project Team
  12.  * @license http://opensource.org/licenses/gpl-license.php GNU Public License
  13.  * @version $Id: date.php 14420 2014-01-01 20:33:20Z pdontthink $
  14.  * @package squirrelmail
  15.  * @subpackage date
  16.  */
  17.  
  18. /**
  19.  * dependency information
  20.  * - none
  21.  */
  22.  
  23. /**
  24.  * Corrects a time stamp to be the local time.
  25.  *
  26.  * @param int stamp the timestamp to adjust
  27.  * @param string tzc the timezone correction
  28.  * @return int the corrected timestamp
  29.  */
  30. function getGMTSeconds($stamp$tzc{
  31.     /* date couldn't be parsed */
  32.     if ($stamp == -1{
  33.         return -1;
  34.     }
  35.     /* timezone correction, expressed as `shhmm' */
  36.     switch($tzc)
  37.     {
  38.         case 'Pacific':
  39.         case 'PST':
  40.             $tzc '-0800';
  41.             break;
  42.         case 'Mountain':
  43.         case 'MST':
  44.         case 'PDT':
  45.             $tzc '-0700';
  46.             break;
  47.         case 'Central':
  48.         case 'CST':
  49.         case 'MDT':
  50.             $tzc '-0600';
  51.             break;
  52.         case 'Eastern':
  53.         case 'EST':
  54.         case 'CDT':
  55.             $tzc '-0500';
  56.             break;
  57.         case 'EDT':
  58.             $tzc '-0400';
  59.             break;
  60.         case 'GMT':
  61.             $tzc '+0000';
  62.             break;
  63.         case 'BST':
  64.         case 'MET':
  65.         case 'CET':
  66.             $tzc '+0100';
  67.             break;
  68.         case 'EET':
  69.         case 'IST':
  70.         case 'MET DST':
  71.         case 'METDST':
  72.     case 'MEST':
  73.     case 'CEST':
  74.             $tzc '+0200';
  75.             break;
  76.         case 'HKT':
  77.             $tzc '+0800';
  78.             break;
  79.         case 'JST':
  80.         case 'KST':
  81.             $tzc '+0900';
  82.             break;
  83.     }
  84.     $neg false;
  85.     if (substr($tzc01== '-'{
  86.         $neg true;
  87.     else if (substr($tzc01!= '+'{
  88.         $tzc '+'.$tzc;
  89.     }
  90.     $hh substr($tzc,1,2);
  91.     $mm substr($tzc,3,2);
  92.     $iTzc ($hh 60 $mm60;
  93.     if ($neg$iTzc = -* (int) $iTzc;
  94.     /* stamp in gmt */
  95.     $stamp -= $iTzc;
  96.     /* now find what the server is at */
  97.     $current date('Z'time());
  98.     /* stamp in local timezone */
  99.     $stamp += $current;
  100.  
  101.     return $stamp;
  102. }
  103.  
  104. /**
  105.  * Returns the (localized) string for a given day number.
  106.  * Switch system has been intentionaly chosen for the
  107.  * internationalization of month and day names. The reason
  108.  * is to make sure that _("") strings will go into the
  109.  * main po.
  110.  *
  111.  * @param int day_number the day number
  112.  * @return string the day in human readable form
  113.  */
  114. function getDayName$day_number {
  115.  
  116.     switch$day_number {
  117.     case 0:
  118.         $ret _("Sunday");
  119.         break;
  120.     case 1:
  121.         $ret _("Monday");
  122.         break;
  123.     case 2:
  124.         $ret _("Tuesday");
  125.         break;
  126.     case 3:
  127.         $ret _("Wednesday");
  128.         break;
  129.     case 4:
  130.         $ret _("Thursday");
  131.         break;
  132.     case 5:
  133.         $ret _("Friday");
  134.         break;
  135.     case 6:
  136.         $ret _("Saturday");
  137.         break;
  138.     default:
  139.         $ret '';
  140.     }
  141.     return$ret );
  142. }
  143.  
  144. /**
  145.  * Like getDayName, but returns the short form
  146.  * @param int day_number the day number
  147.  * @return string the day in short human readable form
  148.  */
  149. function getDayAbrv$day_number {
  150.  
  151.     switch$day_number {
  152.     case 0:
  153.         $ret _("Sun");
  154.         break;
  155.     case 1:
  156.         $ret _("Mon");
  157.         break;
  158.     case 2:
  159.         $ret _("Tue");
  160.         break;
  161.     case 3:
  162.         $ret _("Wed");
  163.         break;
  164.     case 4:
  165.         $ret _("Thu");
  166.         break;
  167.     case 5:
  168.         $ret _("Fri");
  169.         break;
  170.     case 6:
  171.         $ret _("Sat");
  172.         break;
  173.     default:
  174.         $ret '';
  175.     }
  176.     return$ret );
  177. }
  178.  
  179.  
  180. /**
  181.  * Returns the (localized) string for a given month number.
  182.  *
  183.  * @param string month_number the month number (01..12)
  184.  * @return string the month name in human readable form
  185.  */
  186. function getMonthName$month_number {
  187.     switch$month_number {
  188.      case '01':
  189.         $ret _("January");
  190.         break;
  191.      case '02':
  192.         $ret _("February");
  193.         break;
  194.      case '03':
  195.         $ret _("March");
  196.         break;
  197.      case '04':
  198.         $ret _("April");
  199.         break;
  200.      case '05':
  201.         $ret _("May");
  202.         break;
  203.      case '06':
  204.         $ret _("June");
  205.         break;
  206.      case '07':
  207.         $ret _("July");
  208.         break;
  209.      case '08':
  210.         $ret _("August");
  211.         break;
  212.      case '09':
  213.         $ret _("September");
  214.         break;
  215.      case '10':
  216.         $ret _("October");
  217.         break;
  218.      case '11':
  219.         $ret _("November");
  220.         break;
  221.      case '12':
  222.         $ret _("December");
  223.         break;
  224.      default:
  225.         $ret '';
  226.     }
  227.     return$ret );
  228. }
  229.  
  230. /**
  231.  * Returns the (localized) string for a given month number,
  232.  * short representation.
  233.  *
  234.  * @param string month_number the month number (01..12)
  235.  * @return string the shortened month in human readable form
  236.  */
  237. function getMonthAbrv$month_number {
  238.     switch$month_number {
  239.      case '01':
  240.         $ret _("Jan");
  241.         break;
  242.      case '02':
  243.         $ret _("Feb");
  244.         break;
  245.      case '03':
  246.         $ret _("Mar");
  247.         break;
  248.      case '04':
  249.         $ret _("Apr");
  250.         break;
  251.      case '05':
  252.         $ret _("Ma&#121;");
  253.         break;
  254.      case '06':
  255.         $ret _("Jun");
  256.         break;
  257.      case '07':
  258.         $ret _("Jul");
  259.         break;
  260.      case '08':
  261.         $ret _("Aug");
  262.         break;
  263.      case '09':
  264.         $ret _("Sep");
  265.         break;
  266.      case '10':
  267.         $ret _("Oct");
  268.         break;
  269.      case '11':
  270.         $ret _("Nov");
  271.         break;
  272.      case '12':
  273.         $ret _("Dec");
  274.         break;
  275.      default:
  276.         $ret '';
  277.     }
  278.     return$ret );
  279. }
  280.  
  281. /**
  282.  * Returns the localized representation of the date/time.
  283.  *
  284.  * @param string date_format The format for the date, like the input for the PHP date() function.
  285.  * @param int stamp the timestamp to convert
  286.  * @return string a full date representation
  287.  */
  288. function date_intl$date_format$stamp {
  289.     $ret str_replacearray('D','F','l','M')array('$1','$2','$3','$4')$date_format );
  290.     // to reduce the date calls we retrieve m and w in the same call
  291.     $ret date('w#m#'$ret$stamp );
  292.     // extract day and month in order to replace later by intl day and month
  293.     $aParts explode('#',$ret);
  294.     $ret str_replace(array('$1','$4','$2','$3',)
  295.                        array(getDayAbrv($aParts[0]),
  296.                              getMonthAbrv($aParts[1]),
  297.                              getMonthName($aParts[1]),
  298.                              getDayName($aParts[0])),
  299.                        $aParts[2]);
  300.     return$ret );
  301. }
  302.  
  303. /**
  304.  * This returns a date of the format "Wed, Oct 29, 2003 9:52 am",
  305.  * or the same in 24H format (depending on the user's settings),
  306.  * and taking localization into accout.
  307.  *
  308.  * @param int stamp the timestamp
  309.  * @param string fallback string to use when stamp not valid
  310.  * @return string the long date string
  311.  */
  312. function getLongDateString$stamp$fallback '' {
  313.  
  314.     global $hour_format;
  315.  
  316.     if ($stamp == -1{
  317.         return $fallback;
  318.     }
  319.  
  320.     if $hour_format == SMPREF_TIME_12HR {
  321.         $date_format _("D, F j, Y g:i a");
  322.     else {
  323.         $date_format _("D, F j, Y H:i");
  324.     }
  325.  
  326.     returndate_intl$date_format$stamp ) );
  327.  
  328. }
  329.  
  330. /**
  331.  * Returns a short representation of the date,
  332.  * taking timezones and localization into account.
  333.  * Depending on user's settings, this string can be
  334.  * of the form: "14:23" or "Jun 14, 2003" depending
  335.  * on whether the stamp is "today" or not.
  336.  *
  337.  * @param int $stamp The timestamp
  338.  * @param boolean $return_full_date_and_time When TRUE,
  339.  *                                            ignore all
  340.  *                                            user settings
  341.  *                                            and use full
  342.  *                                            date and time
  343.  *                                            (OPTIONAL;
  344.  *                                            default FALSE)
  345.  * @return string the date string
  346.  */
  347. function getDateString$stamp$return_full_date_and_time=FALSE {
  348.  
  349.     global $invert_time$hour_format$show_full_date$custom_date_format;
  350.  
  351.     if $stamp == -{
  352.        return '';
  353.     }
  354.  
  355.     $now time();
  356.  
  357.     $dateZ date('Z'$now );
  358.  
  359.     // FIXME: isn't this obsolete and introduced as a terrible workaround
  360.     // for bugs at other places which are fixed a long time ago?
  361.     if ($invert_time{
  362.         $dateZ = - $dateZ;
  363.     }
  364.  
  365.     // calculate when it was midnight and when it will be,
  366.     // in order to display dates differently if they're 'today'
  367.     $midnight $now ($now 86400$dateZ;
  368.     // this is to correct if after calculations midnight is more than
  369.     // one whole day away.
  370.     if ($now $midnight 86400{
  371.         $midnight += 86400;
  372.     }
  373.     $nextmid $midnight 86400;
  374.  
  375.     $custom_date_format trim($custom_date_format);
  376.  
  377.     if ($return_full_date_and_time{
  378.         if $hour_format == SMPREF_TIME_12HR {
  379.             $date_format _("D, F j, Y g:i a");
  380.         else {
  381.             $date_format _("D, F j, Y H:i");
  382.         }
  383.     else if (!empty($custom_date_format)) {
  384.         $date_format $custom_date_format;
  385.     else if ($show_full_date == || $nextmid $stamp{
  386.         $date_format _("M j, Y");
  387.     else if ($midnight $stamp{
  388.         /* Today */
  389.         if $hour_format == SMPREF_TIME_12HR {
  390.             $date_format _("g:i a");
  391.         else {
  392.             $date_format _("H:i");
  393.         }
  394.     else if ($midnight 518400 $stamp{
  395.         /* This week */
  396.         if $hour_format == SMPREF_TIME_12HR {
  397.             $date_format _("D, g:i a");
  398.         else {
  399.             $date_format _("D, H:i");
  400.         }
  401.     else {
  402.         /* before this week */
  403.         $date_format _("M j, Y");
  404.     }
  405.  
  406.     returndate_intl$date_format$stamp ) );
  407. }
  408.  
  409. /**
  410.  * Decodes a RFC 822 Date-header into a timestamp
  411.  *
  412.  * @param array dateParts the Date-header split by whitespace
  413.  * @return int the timestamp calculated from the header
  414.  */
  415. function getTimeStamp($dateParts{
  416.     /* $dateParts[0] == <day of week>   Mon, Tue, Wed
  417.      * $dateParts[1] == <day of month>  23
  418.      * $dateParts[2] == <month>         Jan, Feb, Mar
  419.      * $dateParts[3] == <year>          1999
  420.      * $dateParts[4] == <time>          18:54:23 (HH:MM:SS)
  421.      * $dateParts[5] == <from GMT>      +0100
  422.      * $dateParts[6] == <zone>          (EDT)
  423.      *
  424.      * NOTE:  In RFC 822, it states that <day of week> is optional.
  425.      *        In that case, dateParts[0] would be the <day of month>
  426.      *        and everything would be bumped up one.
  427.      */
  428.  
  429.     if (count($dateParts<2{
  430.         return -1;
  431.     else if (count($dateParts==3{
  432.         if (substr_count($dateParts[0],'-'== &&
  433.             substr_count($dateParts[1],':'== 2{
  434.             //  dd-Month-yyyy 23:19:05 +0200
  435.             //  redefine the date
  436.             $aDate explode('-',$dateParts[0]);
  437.             $newDate array($aDate[0],$aDate[1],$aDate[2],$dateParts[1],$dateParts[2]);
  438.             $dateParts $newDate;
  439.         }
  440.     }
  441.  
  442.     /*
  443.      * Simply check to see if the first element in the dateParts
  444.      * array is an integer or not.
  445.      * Since the day of week is optional, this check is needed.
  446.      */
  447.     if (!is_numeric(trim($dateParts[0]))) {
  448.         /* cope with broken mailers that send "Tue,23" without space */
  449.         if preg_match ('/^\w+,(\d{1,2})$/'$dateParts[0]$match) ) {
  450.             /* replace Tue,23 with 23 */
  451.             $dateParts[0$match[1];
  452.         else {
  453.             /* just drop the day of week */
  454.             array_shift($dateParts);
  455.         }
  456.     }
  457.  
  458.     /* calculate timestamp separated from the zone and obs-zone */
  459.     $stamp strtotime(implode (' 'array_splice ($dateParts,0,4)));
  460.     if (!isset($dateParts[0])) {
  461.         $dateParts[0'+0000';
  462.     }
  463.  
  464.     if (!preg_match('/^[+-]{1}[0-9]{4}$/',$dateParts[0])) {
  465.         /* zone in obs-zone format */
  466.         if (preg_match('/\((.+)\)/',$dateParts[0],$regs)) {
  467.             $obs_zone $regs[1];
  468.         else {
  469.             $obs_zone $dateParts[0];
  470.         }
  471.         return getGMTSeconds($stamp$obs_zone);
  472.     else {
  473.         return getGMTSeconds($stamp$dateParts[0]);
  474.     }
  475. }

Documentation generated on Thu, 31 Jul 2014 04:17:37 +0200 by phpDocumentor 1.4.3