Upgrade to Encode-2.29.

[p5sagit/p5-mst-13.2.git] / time64.c

diff --git a/time64.c b/time64.c
old mode 100644 (file)
new mode 100755 (executable)
index 21fe116..0f58812
--- a/time64.c
+++ b/time64.c
@@ -108,18 +108,23 @@ static const int dow_year_start[SOLAR_CYCLE_LENGTH] = {
 #    define SHOULD_USE_SYSTEM_GMTIME(a)         (0)
 #endif
 
+/* Multi varadic macros are a C99 thing, alas */
 #ifdef TIME_64_DEBUG
-#    define TRACE(format, ...)    (fprintf(stderr, format, __VA_ARGS__))
-#    define TRACE_NO_VARS(format) (fprintf(stderr, format))
+#    define TRACE(format) (fprintf(stderr, format))
+#    define TRACE1(format, var1)    (fprintf(stderr, format, var1))
+#    define TRACE2(format, var1, var2)    (fprintf(stderr, format, var1, var2))
+#    define TRACE3(format, var1, var2, var3)    (fprintf(stderr, format, var1, var2, var3))
 #else
-#    define TRACE(format, ...)    ((void)0)
-#    define TRACE_NO_VARS(format) ((void)0)
+#    define TRACE(format) ((void)0)
+#    define TRACE1(format, var1) ((void)0)
+#    define TRACE2(format, var1, var2) ((void)0)
+#    define TRACE3(format, var1, var2, var3) ((void)0)
 #endif
 
 static int is_exception_century(Year year)
 {
     int is_exception = ((year % 100 == 0) && !(year % 400 == 0));
-    TRACE("# is_exception_century: %s\n", is_exception ? "yes" : "no");
+    TRACE1("# is_exception_century: %s\n", is_exception ? "yes" : "no");
 
     return(is_exception);
 }
@@ -160,6 +165,7 @@ Time64_T timegm64(struct TM *date) {
 }
 
 
+#ifdef DEBUGGING
 static int check_tm(struct TM *tm)
 {
     /* Don't forget leap seconds */
@@ -191,6 +197,7 @@ static int check_tm(struct TM *tm)
 
     return 1;
 }
+#endif
 
 
 /* The exceptional centuries without leap years cause the cycle to
@@ -208,7 +215,7 @@ static Year cycle_offset(Year year)
     exceptions  = year_diff / 100;
     exceptions -= year_diff / 400;
 
-    TRACE("# year: %lld, exceptions: %lld, year_diff: %lld\n",
+    TRACE3("# year: %lld, exceptions: %lld, year_diff: %lld\n",
           year, exceptions, year_diff);
 
     return exceptions * 16;
@@ -254,14 +261,14 @@ static int safe_year(Year year)
 
     assert(safe_year <= 2037 && safe_year >= 2010);
 
-    TRACE("# year: %lld, year_cycle: %lld, safe_year: %d\n",
+    TRACE3("# year: %lld, year_cycle: %lld, safe_year: %d\n",
           year, year_cycle, safe_year);
 
     return safe_year;
 }
 
 
-void copy_tm_to_TM(const struct tm *src, struct TM *dest) {
+void copy_little_tm_to_big_TM(const struct tm *src, struct TM *dest) {
     if( src == NULL ) {
         memset(dest, 0, sizeof(*dest));
     }
@@ -293,7 +300,7 @@ void copy_tm_to_TM(const struct tm *src, struct TM *dest) {
 }
 
 
-void copy_TM_to_tm(const struct TM *src, struct tm *dest) {
+void copy_big_TM_to_little_tm(const struct TM *src, struct tm *dest) {
     if( src == NULL ) {
         memset(dest, 0, sizeof(*dest));
     }
@@ -327,6 +334,7 @@ void copy_TM_to_tm(const struct TM *src, struct tm *dest) {
 
 /* Simulate localtime_r() to the best of our ability */
 struct tm * fake_localtime_r(const time_t *clock, struct tm *result) {
+    dTHX;    /* in case the following is defined as Perl_my_localtime(aTHX_ ...) */
     const struct tm *static_result = localtime(clock);
 
     assert(result != NULL);
@@ -344,6 +352,7 @@ struct tm * fake_localtime_r(const time_t *clock, struct tm *result) {
 
 /* Simulate gmtime_r() to the best of our ability */
 struct tm * fake_gmtime_r(const time_t *clock, struct tm *result) {
+    dTHX;    /* in case the following is defined as Perl_my_gmtime(aTHX_ ...) */
     const struct tm *static_result = gmtime(clock);
 
     assert(result != NULL);
@@ -373,11 +382,11 @@ struct TM *gmtime64_r (const Time64_T *in_time, struct TM *p)
 
     /* Use the system gmtime() if time_t is small enough */
     if( SHOULD_USE_SYSTEM_GMTIME(*in_time) ) {
-        time_t safe_time = *in_time;
+        time_t safe_time = (time_t)*in_time;
         struct tm safe_date;
         GMTIME_R(&safe_time, &safe_date);
 
-        copy_tm_to_TM(&safe_date, p);
+        copy_little_tm_to_big_TM(&safe_date, p);
         assert(check_tm(p));
 
         return p;
@@ -498,20 +507,20 @@ struct TM *localtime64_r (const Time64_T *time, struct TM *local_tm)
 
     /* Use the system localtime() if time_t is small enough */
     if( SHOULD_USE_SYSTEM_LOCALTIME(*time) ) {
-        safe_time = *time;
+        safe_time = (time_t)*time;
 
-        TRACE("Using system localtime for %lld\n", *time);
+        TRACE1("Using system localtime for %lld\n", *time);
 
         LOCALTIME_R(&safe_time, &safe_date);
 
-        copy_tm_to_TM(&safe_date, local_tm);
+        copy_little_tm_to_big_TM(&safe_date, local_tm);
         assert(check_tm(local_tm));
 
         return local_tm;
     }
 
     if( gmtime64_r(time, &gm_tm) == NULL ) {
-        TRACE("gmtime64_r returned null for %lld\n", *time);
+        TRACE1("gmtime64_r returned null for %lld\n", *time);
         return NULL;
     }
 
@@ -521,21 +530,21 @@ struct TM *localtime64_r (const Time64_T *time, struct TM *local_tm)
         gm_tm.tm_year < (1970 - 1900)
        )
     {
-        TRACE("Mapping tm_year %lld to safe_year\n", (Year)gm_tm.tm_year);
+        TRACE1("Mapping tm_year %lld to safe_year\n", (Year)gm_tm.tm_year);
         gm_tm.tm_year = safe_year((Year)(gm_tm.tm_year + 1900)) - 1900;
     }
 
-    safe_time = timegm64(&gm_tm);
+    safe_time = (time_t)timegm64(&gm_tm);
     if( LOCALTIME_R(&safe_time, &safe_date) == NULL ) {
-        TRACE("localtime_r(%d) returned NULL\n", (int)safe_time);
+        TRACE1("localtime_r(%d) returned NULL\n", (int)safe_time);
         return NULL;
     }
 
-    copy_tm_to_TM(&safe_date, local_tm);
+    copy_little_tm_to_big_TM(&safe_date, local_tm);
 
     local_tm->tm_year = orig_year;
     if( local_tm->tm_year != orig_year ) {
-        TRACE("tm_year overflow: tm_year %lld, orig_year %lld\n",
+        TRACE2("tm_year overflow: tm_year %lld, orig_year %lld\n",
               (Year)local_tm->tm_year, (Year)orig_year);
 
 #ifdef EOVERFLOW