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

Documentation generated on Wed, 26 Nov 2014 04:20:39 +0100 by phpDocumentor 1.4.3