PHP  
 PHP: Test and Code Coverage Analysis
downloads | QA | documentation | faq | getting help | mailing lists | reporting bugs | php.net sites | links | my php.net 
 

LCOV - code coverage report
Current view: top level - ext/calendar - calendar.c (source / functions) Hit Total Coverage
Test: PHP Code Coverage Lines: 212 238 89.1 %
Date: 2014-08-23 Functions: 18 18 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :    +----------------------------------------------------------------------+
       3             :    | PHP Version 5                                                        |
       4             :    +----------------------------------------------------------------------+
       5             :    | Copyright (c) 1997-2014 The PHP Group                                |
       6             :    +----------------------------------------------------------------------+
       7             :    | This source file is subject to version 3.01 of the PHP license,      |
       8             :    | that is bundled with this package in the file LICENSE, and is        |
       9             :    | available through the world-wide-web at the following url:           |
      10             :    | http://www.php.net/license/3_01.txt                                  |
      11             :    | If you did not receive a copy of the PHP license and are unable to   |
      12             :    | obtain it through the world-wide-web, please send a note to          |
      13             :    | license@php.net so we can mail you a copy immediately.               |
      14             :    +----------------------------------------------------------------------+
      15             :    | Authors: Shane Caraveo             <shane@caraveo.com>               | 
      16             :    |          Colin Viebrock            <colin@easydns.com>               |
      17             :    |          Hartmut Holzgraefe        <hholzgra@php.net>                |
      18             :    |          Wez Furlong               <wez@thebrainroom.com>            |
      19             :    +----------------------------------------------------------------------+
      20             :  */
      21             : /* $Id$ */
      22             : 
      23             : #ifdef HAVE_CONFIG_H
      24             : #include "config.h"
      25             : #endif
      26             : 
      27             : #ifdef PHP_WIN32
      28             : #define _WINNLS_
      29             : #endif
      30             : 
      31             : #include "php.h"
      32             : #include "ext/standard/info.h"
      33             : #include "php_calendar.h"
      34             : #include "sdncal.h"
      35             : 
      36             : #include <stdio.h>
      37             : 
      38             : /* {{{ arginfo */
      39             : ZEND_BEGIN_ARG_INFO_EX(arginfo_unixtojd, 0, 0, 0)
      40             :         ZEND_ARG_INFO(0, timestamp)
      41             : ZEND_END_ARG_INFO()
      42             : 
      43             : ZEND_BEGIN_ARG_INFO(arginfo_jdtounix, 0)
      44             :         ZEND_ARG_INFO(0, jday)
      45             : ZEND_END_ARG_INFO()
      46             : 
      47             : ZEND_BEGIN_ARG_INFO_EX(arginfo_cal_info, 0, 0, 0)
      48             :         ZEND_ARG_INFO(0, calendar)
      49             : ZEND_END_ARG_INFO()
      50             : 
      51             : ZEND_BEGIN_ARG_INFO(arginfo_cal_days_in_month, 0)
      52             :         ZEND_ARG_INFO(0, calendar)
      53             :         ZEND_ARG_INFO(0, month)
      54             :         ZEND_ARG_INFO(0, year)
      55             : ZEND_END_ARG_INFO()
      56             : 
      57             : ZEND_BEGIN_ARG_INFO(arginfo_cal_to_jd, 0)
      58             :         ZEND_ARG_INFO(0, calendar)
      59             :         ZEND_ARG_INFO(0, month)
      60             :         ZEND_ARG_INFO(0, day)
      61             :         ZEND_ARG_INFO(0, year)
      62             : ZEND_END_ARG_INFO()
      63             : 
      64             : ZEND_BEGIN_ARG_INFO(arginfo_cal_from_jd, 0)
      65             :         ZEND_ARG_INFO(0, jd)
      66             :         ZEND_ARG_INFO(0, calendar)
      67             : ZEND_END_ARG_INFO()
      68             : 
      69             : ZEND_BEGIN_ARG_INFO(arginfo_jdtogregorian, 0)
      70             :         ZEND_ARG_INFO(0, juliandaycount)
      71             : ZEND_END_ARG_INFO()
      72             : 
      73             : ZEND_BEGIN_ARG_INFO(arginfo_gregoriantojd, 0)
      74             :         ZEND_ARG_INFO(0, month)
      75             :         ZEND_ARG_INFO(0, day)
      76             :         ZEND_ARG_INFO(0, year)
      77             : ZEND_END_ARG_INFO()
      78             : 
      79             : ZEND_BEGIN_ARG_INFO(arginfo_jdtojulian, 0)
      80             :         ZEND_ARG_INFO(0, juliandaycount)
      81             : ZEND_END_ARG_INFO()
      82             : 
      83             : ZEND_BEGIN_ARG_INFO(arginfo_juliantojd, 0)
      84             :         ZEND_ARG_INFO(0, month)
      85             :         ZEND_ARG_INFO(0, day)
      86             :         ZEND_ARG_INFO(0, year)
      87             : ZEND_END_ARG_INFO()
      88             : 
      89             : ZEND_BEGIN_ARG_INFO_EX(arginfo_jdtojewish, 0, 0, 1)
      90             :         ZEND_ARG_INFO(0, juliandaycount)
      91             :         ZEND_ARG_INFO(0, hebrew)
      92             :         ZEND_ARG_INFO(0, fl)
      93             : ZEND_END_ARG_INFO()
      94             : 
      95             : ZEND_BEGIN_ARG_INFO(arginfo_jewishtojd, 0)
      96             :         ZEND_ARG_INFO(0, month)
      97             :         ZEND_ARG_INFO(0, day)
      98             :         ZEND_ARG_INFO(0, year)
      99             : ZEND_END_ARG_INFO()
     100             : 
     101             : ZEND_BEGIN_ARG_INFO(arginfo_jdtofrench, 0)
     102             :         ZEND_ARG_INFO(0, juliandaycount)
     103             : ZEND_END_ARG_INFO()
     104             : 
     105             : ZEND_BEGIN_ARG_INFO(arginfo_frenchtojd, 0)
     106             :         ZEND_ARG_INFO(0, month)
     107             :         ZEND_ARG_INFO(0, day)
     108             :         ZEND_ARG_INFO(0, year)
     109             : ZEND_END_ARG_INFO()
     110             : 
     111             : ZEND_BEGIN_ARG_INFO_EX(arginfo_jddayofweek, 0, 0, 1)
     112             :         ZEND_ARG_INFO(0, juliandaycount)
     113             :         ZEND_ARG_INFO(0, mode)
     114             : ZEND_END_ARG_INFO()
     115             : 
     116             : ZEND_BEGIN_ARG_INFO(arginfo_jdmonthname, 0)
     117             :         ZEND_ARG_INFO(0, juliandaycount)
     118             :         ZEND_ARG_INFO(0, mode)
     119             : ZEND_END_ARG_INFO()
     120             : 
     121             : ZEND_BEGIN_ARG_INFO_EX(arginfo_easter_date, 0, 0, 0)
     122             :         ZEND_ARG_INFO(0, year)
     123             : ZEND_END_ARG_INFO()
     124             : 
     125             : ZEND_BEGIN_ARG_INFO_EX(arginfo_easter_days, 0, 0, 0)
     126             :         ZEND_ARG_INFO(0, year)
     127             :         ZEND_ARG_INFO(0, method)
     128             : ZEND_END_ARG_INFO()
     129             : 
     130             : /* }}} */
     131             : 
     132             : const zend_function_entry calendar_functions[] = {
     133             :         PHP_FE(jdtogregorian, arginfo_jdtogregorian)
     134             :         PHP_FE(gregoriantojd, arginfo_gregoriantojd)
     135             :         PHP_FE(jdtojulian, arginfo_jdtojulian)
     136             :         PHP_FE(juliantojd, arginfo_juliantojd)
     137             :         PHP_FE(jdtojewish, arginfo_jdtojewish)
     138             :         PHP_FE(jewishtojd, arginfo_jewishtojd)
     139             :         PHP_FE(jdtofrench, arginfo_jdtofrench)
     140             :         PHP_FE(frenchtojd, arginfo_frenchtojd)
     141             :         PHP_FE(jddayofweek, arginfo_jddayofweek)
     142             :         PHP_FE(jdmonthname, arginfo_jdmonthname)
     143             :         PHP_FE(easter_date, arginfo_easter_date) 
     144             :         PHP_FE(easter_days, arginfo_easter_days)
     145             :         PHP_FE(unixtojd, arginfo_unixtojd)
     146             :         PHP_FE(jdtounix, arginfo_jdtounix)
     147             :         PHP_FE(cal_to_jd, arginfo_cal_to_jd)
     148             :         PHP_FE(cal_from_jd, arginfo_cal_from_jd)
     149             :         PHP_FE(cal_days_in_month, arginfo_cal_days_in_month)
     150             :         PHP_FE(cal_info, arginfo_cal_info)
     151             :         PHP_FE_END
     152             : };
     153             : 
     154             : 
     155             : zend_module_entry calendar_module_entry = {
     156             :         STANDARD_MODULE_HEADER,
     157             :         "calendar",
     158             :         calendar_functions,
     159             :         PHP_MINIT(calendar),
     160             :         NULL,
     161             :         NULL,
     162             :         NULL,
     163             :         PHP_MINFO(calendar),
     164             :         NO_VERSION_YET,
     165             :         STANDARD_MODULE_PROPERTIES,
     166             : };
     167             : 
     168             : #ifdef COMPILE_DL_CALENDAR
     169             : ZEND_GET_MODULE(calendar)
     170             : #endif
     171             : 
     172             : /* this order must match the conversion table below */
     173             : enum cal_name_type_t {
     174             :         CAL_GREGORIAN = 0,
     175             :         CAL_JULIAN,
     176             :         CAL_JEWISH,
     177             :         CAL_FRENCH,
     178             :         CAL_NUM_CALS
     179             : };
     180             : 
     181             : typedef long int (*cal_to_jd_func_t) (int month, int day, int year);
     182             : typedef void (*cal_from_jd_func_t) (long int jd, int *year, int *month, int *day);
     183             : typedef char *(*cal_as_string_func_t) (int year, int month, int day);
     184             : 
     185             : struct cal_entry_t {
     186             :         char *name;
     187             :         char *symbol;
     188             :         cal_to_jd_func_t to_jd;
     189             :         cal_from_jd_func_t from_jd;
     190             :         int num_months;
     191             :         int max_days_in_month;
     192             :         char **month_name_short;
     193             :         char **month_name_long;
     194             : };
     195             : 
     196             : static struct cal_entry_t cal_conversion_table[CAL_NUM_CALS] = {
     197             :         {"Gregorian", "CAL_GREGORIAN", GregorianToSdn, SdnToGregorian, 12, 31,
     198             :          MonthNameShort, MonthNameLong},
     199             :         {"Julian", "CAL_JULIAN", JulianToSdn, SdnToJulian, 12, 31,
     200             :          MonthNameShort, MonthNameLong},
     201             :         {"Jewish", "CAL_JEWISH", JewishToSdn, SdnToJewish, 13, 30,
     202             :          JewishMonthName, JewishMonthName},
     203             :         {"French", "CAL_FRENCH", FrenchToSdn, SdnToFrench, 13, 30,
     204             :          FrenchMonthName, FrenchMonthName}
     205             : };
     206             : 
     207             : /* For jddayofweek */
     208             : enum { CAL_DOW_DAYNO, CAL_DOW_SHORT, CAL_DOW_LONG };
     209             : 
     210             : /* For jdmonthname */
     211             : enum { CAL_MONTH_GREGORIAN_SHORT, CAL_MONTH_GREGORIAN_LONG,
     212             :         CAL_MONTH_JULIAN_SHORT, CAL_MONTH_JULIAN_LONG, CAL_MONTH_JEWISH,
     213             :         CAL_MONTH_FRENCH
     214             : };
     215             : 
     216             : /* for heb_number_to_chars */
     217             : static char alef_bet[25] = "0אבגדהוזחטיכלמנסעפצקרשת";
     218             : 
     219             : #define CAL_JEWISH_ADD_ALAFIM_GERESH 0x2
     220             : #define CAL_JEWISH_ADD_ALAFIM 0x4
     221             : #define CAL_JEWISH_ADD_GERESHAYIM 0x8
     222             : 
     223       20208 : PHP_MINIT_FUNCTION(calendar)
     224             : {
     225       20208 :         REGISTER_LONG_CONSTANT("CAL_GREGORIAN", CAL_GREGORIAN, CONST_CS | CONST_PERSISTENT);
     226       20208 :         REGISTER_LONG_CONSTANT("CAL_JULIAN", CAL_JULIAN, CONST_CS | CONST_PERSISTENT);
     227       20208 :         REGISTER_LONG_CONSTANT("CAL_JEWISH", CAL_JEWISH, CONST_CS | CONST_PERSISTENT);
     228       20208 :         REGISTER_LONG_CONSTANT("CAL_FRENCH", CAL_FRENCH, CONST_CS | CONST_PERSISTENT);
     229       20208 :         REGISTER_LONG_CONSTANT("CAL_NUM_CALS", CAL_NUM_CALS, CONST_CS | CONST_PERSISTENT);
     230             : /* constants for jddayofweek */
     231       20208 :         REGISTER_LONG_CONSTANT("CAL_DOW_DAYNO", CAL_DOW_DAYNO, CONST_CS | CONST_PERSISTENT);
     232       20208 :         REGISTER_LONG_CONSTANT("CAL_DOW_SHORT", CAL_DOW_SHORT, CONST_CS | CONST_PERSISTENT);
     233       20208 :         REGISTER_LONG_CONSTANT("CAL_DOW_LONG", CAL_DOW_LONG, CONST_CS | CONST_PERSISTENT);
     234             : /* constants for jdmonthname */
     235       20208 :         REGISTER_LONG_CONSTANT("CAL_MONTH_GREGORIAN_SHORT", CAL_MONTH_GREGORIAN_SHORT, CONST_CS | CONST_PERSISTENT);
     236       20208 :         REGISTER_LONG_CONSTANT("CAL_MONTH_GREGORIAN_LONG", CAL_MONTH_GREGORIAN_LONG, CONST_CS | CONST_PERSISTENT);
     237       20208 :         REGISTER_LONG_CONSTANT("CAL_MONTH_JULIAN_SHORT", CAL_MONTH_JULIAN_SHORT, CONST_CS | CONST_PERSISTENT);
     238       20208 :         REGISTER_LONG_CONSTANT("CAL_MONTH_JULIAN_LONG", CAL_MONTH_JULIAN_LONG, CONST_CS | CONST_PERSISTENT);
     239       20208 :         REGISTER_LONG_CONSTANT("CAL_MONTH_JEWISH", CAL_MONTH_JEWISH, CONST_CS | CONST_PERSISTENT);
     240       20208 :         REGISTER_LONG_CONSTANT("CAL_MONTH_FRENCH", CAL_MONTH_FRENCH, CONST_CS | CONST_PERSISTENT);
     241             : /* constants for easter calculation */
     242       20208 :         REGISTER_LONG_CONSTANT("CAL_EASTER_DEFAULT", CAL_EASTER_DEFAULT, CONST_CS | CONST_PERSISTENT);
     243       20208 :         REGISTER_LONG_CONSTANT("CAL_EASTER_ROMAN", CAL_EASTER_ROMAN, CONST_CS | CONST_PERSISTENT);
     244       20208 :         REGISTER_LONG_CONSTANT("CAL_EASTER_ALWAYS_GREGORIAN", CAL_EASTER_ALWAYS_GREGORIAN, CONST_CS | CONST_PERSISTENT);
     245       20208 :         REGISTER_LONG_CONSTANT("CAL_EASTER_ALWAYS_JULIAN", CAL_EASTER_ALWAYS_JULIAN, CONST_CS | CONST_PERSISTENT);
     246             : /* constants for Jewish date formatting */
     247       20208 :         REGISTER_LONG_CONSTANT("CAL_JEWISH_ADD_ALAFIM_GERESH", CAL_JEWISH_ADD_ALAFIM_GERESH, CONST_CS | CONST_PERSISTENT);
     248       20208 :         REGISTER_LONG_CONSTANT("CAL_JEWISH_ADD_ALAFIM", CAL_JEWISH_ADD_ALAFIM, CONST_CS | CONST_PERSISTENT);
     249       20208 :         REGISTER_LONG_CONSTANT("CAL_JEWISH_ADD_GERESHAYIM", CAL_JEWISH_ADD_GERESHAYIM, CONST_CS | CONST_PERSISTENT);
     250       20208 :         return SUCCESS;
     251             : }
     252             : 
     253         148 : PHP_MINFO_FUNCTION(calendar)
     254             : {
     255         148 :         php_info_print_table_start();
     256         148 :         php_info_print_table_row(2, "Calendar support", "enabled");
     257         148 :         php_info_print_table_end();
     258         148 : }
     259             : 
     260           5 : static void _php_cal_info(int cal, zval **ret)
     261             : {
     262             :         zval *months, *smonths;
     263             :         int i;
     264             :         struct cal_entry_t *calendar;
     265             : 
     266           5 :         calendar = &cal_conversion_table[cal];
     267           5 :         array_init(*ret);
     268             : 
     269           5 :         MAKE_STD_ZVAL(months);
     270           5 :         MAKE_STD_ZVAL(smonths);
     271           5 :         array_init(months);
     272           5 :         array_init(smonths);
     273             : 
     274          67 :         for (i = 1; i <= calendar->num_months; i++) {
     275          62 :                 add_index_string(months, i, calendar->month_name_long[i], 1);
     276          62 :                 add_index_string(smonths, i, calendar->month_name_short[i], 1);
     277             :         }
     278           5 :         add_assoc_zval(*ret, "months", months);
     279           5 :         add_assoc_zval(*ret, "abbrevmonths", smonths);
     280           5 :         add_assoc_long(*ret, "maxdaysinmonth", calendar->max_days_in_month);
     281           5 :         add_assoc_string(*ret, "calname", calendar->name, 1);
     282           5 :         add_assoc_string(*ret, "calsymbol", calendar->symbol, 1);
     283             :         
     284           5 : }
     285             : 
     286             : /* {{{ proto array cal_info([int calendar])
     287             :    Returns information about a particular calendar */
     288           3 : PHP_FUNCTION(cal_info)
     289             : {
     290           3 :         long cal = -1;
     291             :         
     292             : 
     293           3 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &cal) == FAILURE) {
     294           0 :                 RETURN_FALSE;
     295             :         }
     296             : 
     297           3 :         if (cal == -1) {
     298             :                 int i;
     299             :                 zval *val;
     300             : 
     301           1 :                 array_init(return_value);
     302             : 
     303           5 :                 for (i = 0; i < CAL_NUM_CALS; i++) {
     304           4 :                         MAKE_STD_ZVAL(val);
     305           4 :                         _php_cal_info(i, &val);
     306           4 :                         add_index_zval(return_value, i, val);
     307             :                 }
     308           1 :                 return;
     309             :         }
     310             : 
     311             : 
     312           2 :         if (cal != -1 && (cal < 0 || cal >= CAL_NUM_CALS)) {
     313           1 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "invalid calendar ID %ld.", cal);
     314           1 :                 RETURN_FALSE;
     315             :         }
     316             : 
     317           1 :         _php_cal_info(cal, &return_value);
     318             : 
     319             : }
     320             : /* }}} */
     321             : 
     322             : /* {{{ proto int cal_days_in_month(int calendar, int month, int year)
     323             :    Returns the number of days in a month for a given year and calendar */
     324           8 : PHP_FUNCTION(cal_days_in_month)
     325             : {
     326             :         long cal, month, year;
     327             :         struct cal_entry_t *calendar;
     328             :         long sdn_start, sdn_next;
     329             : 
     330           8 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lll", &cal, &month, &year) == FAILURE) {
     331           0 :                 RETURN_FALSE;
     332             :         }
     333             : 
     334           8 :         if (cal < 0 || cal >= CAL_NUM_CALS) {
     335           1 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "invalid calendar ID %ld.", cal);
     336           1 :                 RETURN_FALSE;
     337             :         }
     338             : 
     339           7 :         calendar = &cal_conversion_table[cal];
     340             : 
     341           7 :         sdn_start = calendar->to_jd(year, month, 1);
     342             : 
     343           7 :         if (sdn_start == 0) {
     344           1 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "invalid date.");
     345           1 :                 RETURN_FALSE;
     346             :         }
     347             : 
     348           6 :         sdn_next = calendar->to_jd(year, 1 + month, 1);
     349             : 
     350           6 :         if (sdn_next == 0) {
     351             :                 /* If the next month is invalid, then we need to try the first month of
     352             :                  * the next year, bearing in mind that the next year after 1 BCE is
     353             :                  * actually 1 AD and not 0. */
     354           3 :                 if (year == -1) {
     355           2 :                         sdn_next = calendar->to_jd(1, 1, 1);
     356             :                 }
     357             :                 else {
     358           1 :                         sdn_next = calendar->to_jd(year + 1, 1, 1);
     359             :                 }
     360             :         }
     361             : 
     362           6 :         RETURN_LONG(sdn_next - sdn_start);
     363             : }
     364             : /* }}} */
     365             : 
     366             : /* {{{ proto int cal_to_jd(int calendar, int month, int day, int year)
     367             :    Converts from a supported calendar to Julian Day Count */
     368           4 : PHP_FUNCTION(cal_to_jd)
     369             : {
     370             :         long cal, month, day, year;
     371             : 
     372           4 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "llll", &cal, &month, &day, &year) != SUCCESS) {
     373           0 :                 RETURN_FALSE;
     374             :         }
     375             : 
     376           4 :         if (cal < 0 || cal >= CAL_NUM_CALS) {
     377           0 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "invalid calendar ID %ld.", cal);
     378           0 :                 RETURN_FALSE;
     379             :         }
     380             : 
     381           4 :         RETURN_LONG(cal_conversion_table[cal].to_jd(year, month, day));
     382             : }
     383             : /* }}} */
     384             : 
     385             : /* {{{ proto array cal_from_jd(int jd, int calendar)
     386             :    Converts from Julian Day Count to a supported calendar and return extended information */
     387           6 : PHP_FUNCTION(cal_from_jd)
     388             : {
     389             :         long jd, cal;
     390             :         int month, day, year, dow;
     391             :         char date[16];
     392             :         struct cal_entry_t *calendar;
     393             : 
     394           6 :         if (zend_parse_parameters(ZEND_NUM_ARGS()TSRMLS_CC, "ll", &jd, &cal) == FAILURE) {
     395           0 :                 RETURN_FALSE;
     396             :         }
     397             : 
     398           6 :         if (cal < 0 || cal >= CAL_NUM_CALS) {
     399           0 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "invalid calendar ID %ld", cal);
     400           0 :                 RETURN_FALSE;
     401             :         }
     402           6 :         calendar = &cal_conversion_table[cal];
     403             : 
     404           6 :         array_init(return_value);
     405             : 
     406           6 :         calendar->from_jd(jd, &year, &month, &day);
     407             : 
     408           6 :         snprintf(date, sizeof(date), "%i/%i/%i", month, day, year);
     409           6 :         add_assoc_string(return_value, "date", date, 1);
     410             : 
     411           6 :         add_assoc_long(return_value, "month", month);
     412           6 :         add_assoc_long(return_value, "day", day);
     413           6 :         add_assoc_long(return_value, "year", year);
     414             : 
     415             : /* day of week */
     416           6 :         dow = DayOfWeek(jd);
     417           6 :         add_assoc_long(return_value, "dow", dow);
     418           6 :         add_assoc_string(return_value, "abbrevdayname", DayNameShort[dow], 1);
     419           6 :         add_assoc_string(return_value, "dayname", DayNameLong[dow], 1);
     420             : /* month name */
     421           6 :         add_assoc_string(return_value, "abbrevmonth", calendar->month_name_short[month], 1);
     422           6 :         add_assoc_string(return_value, "monthname", calendar->month_name_long[month], 1);
     423             : }
     424             : /* }}} */
     425             : 
     426             : /* {{{ proto string jdtogregorian(int juliandaycount)
     427             :    Converts a julian day count to a gregorian calendar date */
     428           5 : PHP_FUNCTION(jdtogregorian)
     429             : {
     430             :         long julday;
     431             :         int year, month, day;
     432             :         char date[16];
     433             : 
     434           5 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &julday) == FAILURE) {
     435           0 :                 RETURN_FALSE;
     436             :         }
     437             : 
     438           5 :         SdnToGregorian(julday, &year, &month, &day);
     439           5 :         snprintf(date, sizeof(date), "%i/%i/%i", month, day, year);
     440             : 
     441           5 :         RETURN_STRING(date, 1);
     442             : }
     443             : /* }}} */
     444             : 
     445             : /* {{{ proto int gregoriantojd(int month, int day, int year)
     446             :    Converts a gregorian calendar date to julian day count */
     447          15 : PHP_FUNCTION(gregoriantojd)
     448             : {
     449             :         long year, month, day;
     450             : 
     451          15 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lll", &month, &day, &year) == FAILURE) {
     452           0 :                 RETURN_FALSE;
     453             :         }
     454             : 
     455          15 :         RETURN_LONG(GregorianToSdn(year, month, day));
     456             : }
     457             : /* }}} */
     458             : 
     459             : /* {{{ proto string jdtojulian(int juliandaycount)
     460             :    Convert a julian day count to a julian calendar date */
     461           5 : PHP_FUNCTION(jdtojulian)
     462             : {
     463             :         long julday;
     464             :         int year, month, day;
     465             :         char date[16];
     466             : 
     467           5 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &julday) == FAILURE) {
     468           0 :                 RETURN_FALSE;
     469             :         }
     470             : 
     471           5 :         SdnToJulian(julday, &year, &month, &day);
     472           5 :         snprintf(date, sizeof(date), "%i/%i/%i", month, day, year);
     473             : 
     474           5 :         RETURN_STRING(date, 1);
     475             : }
     476             : /* }}} */
     477             : 
     478             : /* {{{ proto int juliantojd(int month, int day, int year)
     479             :    Converts a julian calendar date to julian day count */
     480           5 : PHP_FUNCTION(juliantojd)
     481             : {
     482             :         long year, month, day;
     483             : 
     484           5 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lll", &month, &day, &year) == FAILURE) {
     485           0 :                 RETURN_FALSE;
     486             :         }
     487             : 
     488           5 :         RETURN_LONG(JulianToSdn(year, month, day));
     489             : }
     490             : /* }}} */
     491             : 
     492             : /* {{{ heb_number_to_chars*/
     493             : /*
     494             : caution: the Hebrew format produces non unique result.
     495             : for example both: year '5' and year '5000' produce 'ה'.
     496             : use the numeric one for calculations. 
     497             :  */
     498          18 : static char *heb_number_to_chars(int n, int fl, char **ret)
     499             : {
     500             :         char *p, old[18], *endofalafim;
     501             : 
     502          18 :         p = endofalafim = old;
     503             : /* 
     504             :    prevents the option breaking the jewish beliefs, and some other 
     505             :    critical resources ;)
     506             :  */
     507          18 :         if (n > 9999 || n < 1) {
     508           0 :                 *ret = NULL;
     509           0 :                 return NULL;
     510             :         }       
     511             : 
     512             : /* alafim (thousands) case */
     513          18 :         if (n / 1000) {
     514           9 :                 *p = alef_bet[n / 1000];
     515           9 :                 p++;
     516             : 
     517           9 :                 if (CAL_JEWISH_ADD_ALAFIM_GERESH & fl) {
     518           4 :                         *p = '\'';
     519           4 :                         p++;
     520             :                 }
     521           9 :                 if (CAL_JEWISH_ADD_ALAFIM & fl) {
     522           4 :                         strcpy(p, " אלפים ");
     523           4 :                         p += 7;
     524             :                 }
     525             : 
     526           9 :                 endofalafim = p;
     527           9 :                 n = n % 1000;
     528             :         }
     529             : 
     530             : /* tav-tav (tav=400) case */
     531          45 :         while (n >= 400) {
     532           9 :                 *p = alef_bet[22];
     533           9 :                 p++;
     534           9 :                 n -= 400;
     535             :         }
     536             : 
     537             : /* meot (hundreads) case */
     538          18 :         if (n >= 100) {
     539           9 :                 *p = alef_bet[18 + n / 100];
     540           9 :                 p++;
     541           9 :                 n = n % 100;
     542             :         }
     543             : 
     544             : /* tet-vav & tet-zain case (special case for 15 and 16) */
     545          18 :         if (n == 15 || n == 16) {
     546           0 :                 *p = alef_bet[9];
     547           0 :                 p++;
     548           0 :                 *p = alef_bet[n - 9];
     549           0 :                 p++;
     550             :         } else {
     551             : /* asarot (tens) case */
     552          18 :                 if (n >= 10) {
     553          14 :                         *p = alef_bet[9 + n / 10];
     554          14 :                         p++;
     555          14 :                         n = n % 10;
     556             :                 }
     557             : 
     558             : /* yehidot (ones) case */
     559          18 :                 if (n > 0) {
     560          18 :                         *p = alef_bet[n];
     561          18 :                         p++;
     562             :                 }
     563             :         }
     564             : 
     565          18 :         if (CAL_JEWISH_ADD_GERESHAYIM & fl) {
     566          10 :                 switch (p - endofalafim) {
     567             :                 case 0:
     568           0 :                         break;
     569             :                 case 1:
     570           4 :                         *p = '\'';
     571           4 :                         p++;
     572           4 :                         break;
     573             :                 default:
     574           6 :                         *(p) = *(p - 1);
     575           6 :                         *(p - 1) = '"';
     576           6 :                         p++;
     577             :                 }
     578             :         }
     579             : 
     580          18 :         *p = '\0';
     581          18 :         *ret = estrndup(old, (p - old) + 1);
     582          18 :         p = *ret;
     583          18 :         return p;
     584             : }
     585             : /* }}} */
     586             : 
     587             : /* {{{ proto string jdtojewish(int juliandaycount [, bool hebrew [, int fl]])
     588             :    Converts a julian day count to a jewish calendar date */
     589          14 : PHP_FUNCTION(jdtojewish)
     590             : {
     591          14 :         long julday, fl = 0;
     592          14 :         zend_bool heb   = 0;
     593             :         int year, month, day;
     594             :         char date[16], hebdate[32];
     595             :         char *dayp, *yearp;
     596             : 
     597          14 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l|bl", &julday, &heb, &fl) == FAILURE) {
     598           0 :                 RETURN_FALSE;
     599             :         }
     600             : 
     601          14 :         SdnToJewish(julday, &year, &month, &day);
     602          14 :         if (!heb) {
     603           5 :                 snprintf(date, sizeof(date), "%i/%i/%i", month, day, year);
     604           5 :                 RETURN_STRING(date, 1);
     605             :         } else {
     606           9 :                 if (year <= 0 || year > 9999) {
     607           0 :                         php_error_docref(NULL TSRMLS_CC, E_WARNING, "Year out of range (0-9999).");
     608           0 :                         RETURN_FALSE;
     609             :                 }
     610             : 
     611           9 :                 snprintf(hebdate, sizeof(hebdate), "%s %s %s", heb_number_to_chars(day, fl, &dayp), JewishMonthHebName[month], heb_number_to_chars(year, fl, &yearp));
     612             : 
     613           9 :                 if (dayp) {
     614           9 :                         efree(dayp);
     615             :                 }
     616           9 :                 if (yearp) {
     617           9 :                         efree(yearp);
     618             :                 }
     619             : 
     620           9 :                 RETURN_STRING(hebdate, 1);
     621             : 
     622             :         }
     623             : }
     624             : /* }}} */
     625             : 
     626             : /* {{{ proto int jewishtojd(int month, int day, int year)
     627             :    Converts a jewish calendar date to a julian day count */
     628           4 : PHP_FUNCTION(jewishtojd)
     629             : {
     630             :         long year, month, day;
     631             : 
     632           4 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lll", &month, &day, &year) == FAILURE) {
     633           0 :                 RETURN_FALSE;
     634             :         }
     635             : 
     636           4 :         RETURN_LONG(JewishToSdn(year, month, day));
     637             : }
     638             : /* }}} */
     639             : 
     640             : /* {{{ proto string jdtofrench(int juliandaycount)
     641             :    Converts a julian day count to a french republic calendar date */
     642           6 : PHP_FUNCTION(jdtofrench)
     643             : {
     644             :         long julday;
     645             :         int year, month, day;
     646             :         char date[16];
     647             : 
     648           6 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &julday) == FAILURE) {
     649           0 :                 RETURN_FALSE;
     650             :         }
     651             : 
     652           6 :         SdnToFrench(julday, &year, &month, &day);
     653           6 :         snprintf(date, sizeof(date), "%i/%i/%i", month, day, year);
     654             : 
     655           6 :         RETURN_STRING(date, 1);
     656             : }
     657             : /* }}} */
     658             : 
     659             : /* {{{ proto int frenchtojd(int month, int day, int year)
     660             :    Converts a french republic calendar date to julian day count */
     661           4 : PHP_FUNCTION(frenchtojd)
     662             : {
     663             :         long year, month, day;
     664             : 
     665           4 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lll", &month, &day, &year) == FAILURE) {
     666           0 :                 RETURN_FALSE;
     667             :         }
     668             : 
     669           4 :         RETURN_LONG(FrenchToSdn(year, month, day));
     670             : }
     671             : /* }}} */
     672             : 
     673             : /* {{{ proto mixed jddayofweek(int juliandaycount [, int mode])
     674             :    Returns name or number of day of week from julian day count */
     675          96 : PHP_FUNCTION(jddayofweek)
     676             : {
     677          96 :         long julday, mode = CAL_DOW_DAYNO;
     678             :         int day;
     679             :         char *daynamel, *daynames;
     680             : 
     681          96 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l|l", &julday, &mode) == FAILURE) {
     682           0 :                 RETURN_FALSE;
     683             :         }
     684             : 
     685          96 :         day = DayOfWeek(julday);
     686          96 :         daynamel = DayNameLong[day];
     687          96 :         daynames = DayNameShort[day];
     688             : 
     689          96 :         switch (mode) {
     690             :         case CAL_DOW_SHORT:
     691          32 :                 RETURN_STRING(daynamel, 1);
     692             :                 break;
     693             :         case CAL_DOW_LONG:
     694          32 :                 RETURN_STRING(daynames, 1);
     695             :                 break;
     696             :         case CAL_DOW_DAYNO:
     697             :         default:
     698          32 :                 RETURN_LONG(day);
     699             :                 break;
     700             :         }
     701             : }
     702             : /* }}} */
     703             : 
     704             : /* {{{ proto string jdmonthname(int juliandaycount, int mode)
     705             :    Returns name of month for julian day count */
     706         303 : PHP_FUNCTION(jdmonthname)
     707             : {
     708             :         long julday, mode;
     709         303 :         char *monthname = NULL;
     710             :         int month, day, year;
     711             : 
     712         303 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ll", &julday, &mode) == FAILURE) {
     713           6 :                 RETURN_FALSE;
     714             :         }
     715             : 
     716         297 :         switch (mode) {
     717             :         case CAL_MONTH_GREGORIAN_LONG:  /* gregorian or julian month */
     718          43 :                 SdnToGregorian(julday, &year, &month, &day);
     719          43 :                 monthname = MonthNameLong[month];
     720          43 :                 break;
     721             :         case CAL_MONTH_JULIAN_SHORT:    /* gregorian or julian month */
     722          43 :                 SdnToJulian(julday, &year, &month, &day);
     723          43 :                 monthname = MonthNameShort[month];
     724          43 :                 break;
     725             :         case CAL_MONTH_JULIAN_LONG:     /* gregorian or julian month */
     726          43 :                 SdnToJulian(julday, &year, &month, &day);
     727          43 :                 monthname = MonthNameLong[month];
     728          43 :                 break;
     729             :         case CAL_MONTH_JEWISH:          /* jewish month */
     730          43 :                 SdnToJewish(julday, &year, &month, &day);
     731          43 :                 monthname = JewishMonthName[month];
     732          43 :                 break;
     733             :         case CAL_MONTH_FRENCH:          /* french month */
     734          43 :                 SdnToFrench(julday, &year, &month, &day);
     735          43 :                 monthname = FrenchMonthName[month];
     736          43 :                 break;
     737             :         default:                                        /* default gregorian */
     738             :         case CAL_MONTH_GREGORIAN_SHORT: /* gregorian or julian month */
     739          82 :                 SdnToGregorian(julday, &year, &month, &day);
     740          82 :                 monthname = MonthNameShort[month];
     741             :                 break;
     742             :         }
     743             : 
     744         297 :         RETURN_STRING(monthname, 1);
     745             : }
     746             : /* }}} */
     747             : 
     748             : /*
     749             :  * Local variables:
     750             :  * tab-width: 4
     751             :  * c-basic-offset: 4
     752             :  * End:
     753             :  * vim600: sw=4 ts=4 fdm=marker
     754             :  * vim<600: sw=4 ts=4
     755             :  */

Generated by: LCOV version 1.10

Generated at Sat, 23 Aug 2014 22:39:29 +0000 (3 days ago)

Copyright © 2005-2014 The PHP Group
All rights reserved.