strptime 0.1.6-x64-mingw32 → 0.1.7-x64-mingw32

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 74e748c14431762b3cd13bfb0cb124f916b31df6
-  data.tar.gz: 6cc210c4a25ec8ae9f3ebff7128c1c0ca1dfc1b9
+  metadata.gz: a0930d588aef2111a9cf70eb6aecd0dd23c92e23
+  data.tar.gz: aa6df223de63d228263968d09d1972cb8579893b
 SHA512:
-  metadata.gz: de2d291e7788b4a0f38c9b9e2bb98d4e1e04d5c69a274500aa71839b5df9db2922af8792fe748c1fd4e6e2bb463cfda7d561eed609a4a8b2c12966c52a66209b
-  data.tar.gz: 2f766ea911b3152209fca2ca6aa2bfe528923b9f4147e7d092c6fe7a6b74a6e68519f88bd4361786dc337111839dee1cf0929fef338f527d784e485f1a2f06a9
+  metadata.gz: 9b26352e6e4c0a3c6e63b463ec1f473cfe27fc87622b68c06046501aefdea591c87d21ec3b098ef1261566d76f585a8503d596393624c43d5f0399ad99c35fee
+  data.tar.gz: 57c57935bf779f7762252213441776602e0d460a72223b9678b37eebd36f30da6002e069ef5eda24298109865056afb98c5594a8f1a512a221e3364e371d59aa

data/.travis.yml

@@ -1,12 +1,14 @@
+sudo: false
 language: ruby
 os:
   - linux
-  - osx
 rvm:
   - 2.0.0
   - 2.1
-  - 2.2.3
-  - 2.2.3-clang
+  - 2.2.4
+  - 2.2.4-clang
+  - 2.3.0
+  - 2.3.0-clang
   - ruby-head
 matrix:
   allow_failures:

data/appveyor.yml

@@ -5,7 +5,9 @@ install:
   - gem --version
   - bundle install
 build_script:
-  - bundle exec rake -rdevkit
+  - bundle exec rake -rdevkit build
+test_script:
+  - bundle exec rake -rdevkit spec
 environment:
   matrix:
     - ruby_version: "200"

data/ext/strptime/ruby_time.c

@@ -60,7 +60,7 @@ struct vtm {
 struct time_object {
     wideval_t timew; /* time_t value * TIME_SCALE.  possibly Rational. */
     struct vtm vtm;
-    int gmt; /* 0:utc 1:localtime 2:fixoff */
+    int gmt; /* 0:localtime 1:utc 2:fixoff */
     int tm_got;
 };
 # endif
@@ -114,71 +114,56 @@ rb_timespec_now(struct timespec *ts)
 }
 #endif
 
-/* localtime_with_gmtoff_zone */
-#ifdef HAVE_GMTIME_R
-#define rb_gmtime_r(t, tm) gmtime_r((t), (tm))
-#define rb_localtime_r(t, tm) localtime_r((t), (tm))
-#else
-static inline struct tm *
-rb_gmtime_r(const time_t *tp, struct tm *result)
-{
-    struct tm *t = gmtime(tp);
-    if (t) *result = *t;
-    return t;
-}
-
-static inline struct tm *
-rb_localtime_r(const time_t *tp, struct tm *result)
-{
-    struct tm *t = localtime(tp);
-    if (t) *result = *t;
-    return t;
-}
-#endif
-
 static struct tm *
-rb_localtime_r2(const time_t *t, struct tm *result)
+rb_localtime_r(const time_t *t, struct tm *result)
 {
 #if defined __APPLE__ && defined __LP64__
     if (*t != (time_t)(int)*t) return NULL;
 #endif
-    result = rb_localtime_r(t, result);
+#ifdef HAVE_GMTIME_R
+    result = localtime_r(t, result);
+#else
+    {
+	struct tm *tmp = localtime(t);
+	if (tmp) *result = *tmp;
+    }
+#endif
 #if defined(HAVE_MKTIME) && defined(LOCALTIME_OVERFLOW_PROBLEM)
     if (result) {
-	long gmtoff1 = 0;
-	long gmtoff2 = 0;
-	struct tm tmp = *result;
-	time_t t2;
-#if defined(HAVE_STRUCT_TM_TM_GMTOFF)
-	gmtoff1 = result->tm_gmtoff;
-#endif
-	t2 = mktime(&tmp);
-#if defined(HAVE_STRUCT_TM_TM_GMTOFF)
-	gmtoff2 = tmp.tm_gmtoff;
-#endif
-	if (*t + gmtoff1 != t2 + gmtoff2) result = NULL;
+        long gmtoff1 = 0;
+        long gmtoff2 = 0;
+        struct tm tmp = *result;
+        time_t t2;
+        t2 = mktime(&tmp);
+#  if defined(HAVE_STRUCT_TM_TM_GMTOFF)
+        gmtoff1 = result->tm_gmtoff;
+        gmtoff2 = tmp.tm_gmtoff;
+#  endif
+        if (*t + gmtoff1 != t2 + gmtoff2)
+            result = NULL;
     }
 #endif
     return result;
 }
-#define LOCALTIME(tm, result) (tzset(), rb_localtime_r2((tm), &(result)))
+#define LOCALTIME(tm, result) (tzset(),rb_localtime_r((tm), &(result)))
 
-#if !defined(HAVE_STRUCT_TM_TM_GMTOFF)
 static struct tm *
-rb_gmtime_r2(const time_t *t, struct tm *result)
+rb_gmtime_r(const time_t *t, struct tm *result)
 {
-    result = rb_gmtime_r(t, result);
+#ifdef HAVE_GMTIME_R
+    result = gmtime_r(t, result);
+#else
+    struct tm *tmp = gmtime(t);
+    if (tmp) *result = *tmp;
+#endif
 #if defined(HAVE_TIMEGM) && defined(LOCALTIME_OVERFLOW_PROBLEM)
-    if (result) {
-	struct tm tmp = *result;
-	time_t t2 = timegm(&tmp);
-	if (*t != t2) result = NULL;
+    if (result && *t != timegm(result)) {
+	return NULL;
     }
 #endif
     return result;
 }
-#define GMTIME(tm, result) rb_gmtime_r2((tm), &(result))
-#endif
+#define GMTIME(tm, result) rb_gmtime_r((tm), &(result))
 
 struct tm *
 localtime_with_gmtoff_zone(const time_t *t, struct tm *result, long *gmtoff,
@@ -217,7 +202,9 @@ localtime_with_gmtoff_zone(const time_t *t, struct tm *result, long *gmtoff,
 }
 
 #define NDIV(x,y) (-(-((x)+1)/(y))-1)
+#define NMOD(x,y) ((y)-(-((x)+1)%(y))-1)
 #define DIV(n,d) ((n)<0 ? NDIV((n),(d)) : (n)/(d))
+#define MOD(n,d) ((n)<0 ? NMOD((n),(d)) : (n)%(d))
 
 static int
 leap_year_p(int y)
@@ -263,6 +250,20 @@ static const int leap_year_days_in_month[] = {
     31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
 };
 
+static int
+calc_tm_yday(long tm_year, int tm_mon, int tm_mday)
+{
+    int tm_year_mod400 = (int)MOD(tm_year, 400);
+    int tm_yday = tm_mday;
+
+    if (leap_year_p(tm_year_mod400 + 1900))
+        tm_yday += leap_year_yday_offset[tm_mon];
+    else
+        tm_yday += common_year_yday_offset[tm_mon];
+
+    return tm_yday;
+}
+
 time_t
 timegm_noleapsecond(struct tm *tm)
 {
@@ -287,6 +288,306 @@ timegm_noleapsecond(struct tm *tm)
 		    DIV(tm_year+299,400))*86400;
 }
 
+/* assume time_t is signed */
+#define SIGNED_INTEGER_MAX(sint_type) \
+  (sint_type) \
+  ((((sint_type)1) << (sizeof(sint_type) * CHAR_BIT - 2)) | \
+  ((((sint_type)1) << (sizeof(sint_type) * CHAR_BIT - 2)) - 1))
+#define SIGNED_INTEGER_MIN(sint_type) (-SIGNED_INTEGER_MAX(sint_type)-1)
+# define TIMET_MAX SIGNED_INTEGER_MAX(time_t)
+# define TIMET_MIN SIGNED_INTEGER_MIN(time_t)
+# define DEBUG_FIND_TIME_NUMGUESS_INC
+# define DEBUG_REPORT_GUESSRANGE
+
+static int
+tmcmp(struct tm *a, struct tm *b)
+{
+    if (a->tm_year != b->tm_year)
+        return a->tm_year < b->tm_year ? -1 : 1;
+    else if (a->tm_mon != b->tm_mon)
+        return a->tm_mon < b->tm_mon ? -1 : 1;
+    else if (a->tm_mday != b->tm_mday)
+        return a->tm_mday < b->tm_mday ? -1 : 1;
+    else if (a->tm_hour != b->tm_hour)
+        return a->tm_hour < b->tm_hour ? -1 : 1;
+    else if (a->tm_min != b->tm_min)
+        return a->tm_min < b->tm_min ? -1 : 1;
+    else if (a->tm_sec != b->tm_sec)
+        return a->tm_sec < b->tm_sec ? -1 : 1;
+    else
+        return 0;
+}
+
+const char *
+find_time_t(struct tm *tptr, int utc_p, time_t *tp)
+{
+    time_t guess, guess0, guess_lo, guess_hi;
+    struct tm *tm, tm0, tm_lo, tm_hi;
+    int d;
+    int find_dst;
+    struct tm result;
+    int status;
+    int tptr_tm_yday;
+
+#define GUESS(p) (DEBUG_FIND_TIME_NUMGUESS_INC (utc_p ? rb_gmtime_r((p), &result) : LOCALTIME((p), result)))
+
+    guess_lo = TIMET_MIN;
+    guess_hi = TIMET_MAX;
+
+    find_dst = 0 < tptr->tm_isdst;
+
+#if defined(HAVE_MKTIME)
+    tm0 = *tptr;
+    if (!utc_p && (guess = mktime(&tm0)) != -1) {
+        tm = GUESS(&guess);
+        if (tm && tmcmp(tptr, tm) == 0) {
+            goto found;
+        }
+    }
+#endif
+
+    tm0 = *tptr;
+    if (tm0.tm_mon < 0) {
+	tm0.tm_mon = 0;
+	tm0.tm_mday = 1;
+	tm0.tm_hour = 0;
+	tm0.tm_min = 0;
+	tm0.tm_sec = 0;
+    }
+    else if (11 < tm0.tm_mon) {
+	tm0.tm_mon = 11;
+	tm0.tm_mday = 31;
+	tm0.tm_hour = 23;
+	tm0.tm_min = 59;
+	tm0.tm_sec = 60;
+    }
+    else if (tm0.tm_mday < 1) {
+	tm0.tm_mday = 1;
+	tm0.tm_hour = 0;
+	tm0.tm_min = 0;
+	tm0.tm_sec = 0;
+    }
+    else if ((d = (leap_year_p(1900 + tm0.tm_year) ?
+                   leap_year_days_in_month :
+		   common_year_days_in_month)[tm0.tm_mon]) < tm0.tm_mday) {
+	tm0.tm_mday = d;
+	tm0.tm_hour = 23;
+	tm0.tm_min = 59;
+	tm0.tm_sec = 60;
+    }
+    else if (tm0.tm_hour < 0) {
+	tm0.tm_hour = 0;
+	tm0.tm_min = 0;
+	tm0.tm_sec = 0;
+    }
+    else if (23 < tm0.tm_hour) {
+	tm0.tm_hour = 23;
+	tm0.tm_min = 59;
+	tm0.tm_sec = 60;
+    }
+    else if (tm0.tm_min < 0) {
+	tm0.tm_min = 0;
+	tm0.tm_sec = 0;
+    }
+    else if (59 < tm0.tm_min) {
+	tm0.tm_min = 59;
+	tm0.tm_sec = 60;
+    }
+    else if (tm0.tm_sec < 0) {
+	tm0.tm_sec = 0;
+    }
+    else if (60 < tm0.tm_sec) {
+	tm0.tm_sec = 60;
+    }
+
+    DEBUG_REPORT_GUESSRANGE;
+    guess0 = guess = timegm_noleapsecond(&tm0);
+    tm = GUESS(&guess);
+    if (tm) {
+	d = tmcmp(tptr, tm);
+	if (d == 0) { goto found; }
+	if (d < 0) {
+	    guess_hi = guess;
+	    guess -= 24 * 60 * 60;
+	}
+	else {
+	    guess_lo = guess;
+	    guess += 24 * 60 * 60;
+	}
+        DEBUG_REPORT_GUESSRANGE;
+	if (guess_lo < guess && guess < guess_hi && (tm = GUESS(&guess)) != NULL) {
+	    d = tmcmp(tptr, tm);
+	    if (d == 0) { goto found; }
+	    if (d < 0)
+		guess_hi = guess;
+	    else
+		guess_lo = guess;
+            DEBUG_REPORT_GUESSRANGE;
+	}
+    }
+
+    tm = GUESS(&guess_lo);
+    if (!tm) goto error;
+    d = tmcmp(tptr, tm);
+    if (d < 0) goto out_of_range;
+    if (d == 0) { guess = guess_lo; goto found; }
+    tm_lo = *tm;
+
+    tm = GUESS(&guess_hi);
+    if (!tm) goto error;
+    d = tmcmp(tptr, tm);
+    if (d > 0) goto out_of_range;
+    if (d == 0) { guess = guess_hi; goto found; }
+    tm_hi = *tm;
+
+    DEBUG_REPORT_GUESSRANGE;
+
+    status = 1;
+
+    while (guess_lo + 1 < guess_hi) {
+        if (status == 0) {
+          binsearch:
+            guess = guess_lo / 2 + guess_hi / 2;
+            if (guess <= guess_lo)
+                guess = guess_lo + 1;
+            else if (guess >= guess_hi)
+                guess = guess_hi - 1;
+            status = 1;
+        }
+        else {
+            if (status == 1) {
+                time_t guess0_hi = timegm_noleapsecond(&tm_hi);
+                guess = guess_hi - (guess0_hi - guess0);
+                if (guess == guess_hi) /* hh:mm:60 tends to cause this condition. */
+                    guess--;
+                status = 2;
+            }
+            else if (status == 2) {
+                time_t guess0_lo = timegm_noleapsecond(&tm_lo);
+                guess = guess_lo + (guess0 - guess0_lo);
+                if (guess == guess_lo)
+                    guess++;
+                status = 0;
+            }
+            if (guess <= guess_lo || guess_hi <= guess) {
+                /* Precious guess is invalid. try binary search. */
+#ifdef DEBUG_GUESSRANGE
+                if (guess <= guess_lo) fprintf(stderr, "too small guess: %ld <= %ld\n", guess, guess_lo);
+                if (guess_hi <= guess) fprintf(stderr, "too big guess: %ld <= %ld\n", guess_hi, guess);
+#endif
+                goto binsearch;
+            }
+        }
+
+	tm = GUESS(&guess);
+	if (!tm) goto error;
+
+	d = tmcmp(tptr, tm);
+
+        if (d < 0) {
+            guess_hi = guess;
+            tm_hi = *tm;
+            DEBUG_REPORT_GUESSRANGE;
+        }
+        else if (d > 0) {
+            guess_lo = guess;
+            tm_lo = *tm;
+            DEBUG_REPORT_GUESSRANGE;
+        }
+        else {
+          found:
+	    if (!utc_p) {
+		/* If localtime is nonmonotonic, another result may exist. */
+		time_t guess2;
+		if (find_dst) {
+		    guess2 = guess - 2 * 60 * 60;
+		    tm = LOCALTIME(&guess2, result);
+		    if (tm) {
+			if (tptr->tm_hour != (tm->tm_hour + 2) % 24 ||
+			    tptr->tm_min != tm->tm_min ||
+			    tptr->tm_sec != tm->tm_sec) {
+			    guess2 -= (tm->tm_hour - tptr->tm_hour) * 60 * 60 +
+				      (tm->tm_min - tptr->tm_min) * 60 +
+				      (tm->tm_sec - tptr->tm_sec);
+			    if (tptr->tm_mday != tm->tm_mday)
+				guess2 += 24 * 60 * 60;
+			    if (guess != guess2) {
+				tm = LOCALTIME(&guess2, result);
+				if (tm && tmcmp(tptr, tm) == 0) {
+				    if (guess < guess2)
+					*tp = guess;
+				    else
+					*tp = guess2;
+                                    return NULL;
+				}
+			    }
+			}
+		    }
+		}
+		else {
+		    guess2 = guess + 2 * 60 * 60;
+		    tm = LOCALTIME(&guess2, result);
+		    if (tm) {
+			if ((tptr->tm_hour + 2) % 24 != tm->tm_hour ||
+			    tptr->tm_min != tm->tm_min ||
+			    tptr->tm_sec != tm->tm_sec) {
+			    guess2 -= (tm->tm_hour - tptr->tm_hour) * 60 * 60 +
+				      (tm->tm_min - tptr->tm_min) * 60 +
+				      (tm->tm_sec - tptr->tm_sec);
+			    if (tptr->tm_mday != tm->tm_mday)
+				guess2 -= 24 * 60 * 60;
+			    if (guess != guess2) {
+				tm = LOCALTIME(&guess2, result);
+				if (tm && tmcmp(tptr, tm) == 0) {
+				    if (guess < guess2)
+					*tp = guess2;
+				    else
+					*tp = guess;
+                                    return NULL;
+				}
+			    }
+			}
+		    }
+		}
+	    }
+            *tp = guess;
+            return NULL;
+	}
+    }
+
+    /* Given argument has no corresponding time_t. Let's extrapolate. */
+    /*
+     *  `Seconds Since the Epoch' in SUSv3:
+     *  tm_sec + tm_min*60 + tm_hour*3600 + tm_yday*86400 +
+     *  (tm_year-70)*31536000 + ((tm_year-69)/4)*86400 -
+     *  ((tm_year-1)/100)*86400 + ((tm_year+299)/400)*86400
+     */
+
+    tptr_tm_yday = calc_tm_yday(tptr->tm_year, tptr->tm_mon, tptr->tm_mday);
+
+    *tp = guess_lo +
+          ((tptr->tm_year - tm_lo.tm_year) * 365 +
+           ((tptr->tm_year-69)/4) -
+           ((tptr->tm_year-1)/100) +
+           ((tptr->tm_year+299)/400) -
+           ((tm_lo.tm_year-69)/4) +
+           ((tm_lo.tm_year-1)/100) -
+           ((tm_lo.tm_year+299)/400) +
+           tptr_tm_yday -
+           tm_lo.tm_yday) * 86400 +
+          (tptr->tm_hour - tm_lo.tm_hour) * 3600 +
+          (tptr->tm_min - tm_lo.tm_min) * 60 +
+          (tptr->tm_sec - (tm_lo.tm_sec == 60 ? 59 : tm_lo.tm_sec));
+
+    return NULL;
+
+  out_of_range:
+    return "time out of range";
+
+  error:
+    return "gmtime/localtime error";
+}
+
 void
 tm_add_offset(struct tm *tm, long diff)
 {

data/ext/strptime/strptime.c

@@ -35,7 +35,7 @@ VALUE rb_cStrptime;
     {
 
 #define END_INSNS_DISPATCH()                                                   \
-    rb_bug("unknown insn: %p", GET_CURRENT_INSN());                            \
+    rb_bug("strptime: unknown insn: %p", GET_CURRENT_INSN());                  \
     } /* end of while loop */
 
 #define NEXT_INSN() TC_DISPATCH(__NEXT_INSN__)
@@ -421,31 +421,7 @@ strptime_exec0(void **pc, const char *fmt, const char *str, size_t slen,
 	struct tm tm;
 	time_t t;
 	int gmt = gmtoff >= INT_MAX-1 ? INT_MAX-gmtoff : 2;
-
-	/* get current time with timezone */
-	rb_timespec_now(&ts);
-	{
-	    static time_t ct;
-	    static struct tm ctm;
-	    static long ctmoff;
-	    static long localoff;
-	    if (ct != ts.tv_sec) {
-		ct = ts.tv_sec;
-		localtime_with_gmtoff_zone(&ct, &ctm, &ctmoff, NULL);
-		localoff = ctmoff;
-	    }
-	    if (gmtoff == INT_MAX) {
-		gmtoff = localoff;
-	    }
-	    else if (gmtoff == INT_MAX-1) {
-		gmtoff = 0;
-	    }
-	    if (gmtoff != ctmoff) {
-		tm_add_offset(&ctm, gmtoff - ctmoff);
-		ctmoff = gmtoff;
-	    }
-	    memcpy(&tm, &ctm, sizeof(struct tm));
-	}
+	const char *r;
 
 	/* overwrite time */
 	if (year != INT_MAX) {
@@ -466,6 +442,17 @@ strptime_exec0(void **pc, const char *fmt, const char *str, size_t slen,
 	    tm.tm_sec = sec;
 	}
 	else {
+	    rb_timespec_now(&ts);
+	    if (gmt) {
+		t = ts.tv_sec;
+		if (gmt == 2) t += gmtoff;
+		gmtime_r(&t, &tm);
+	    }
+	    else {
+		long off;
+		localtime_with_gmtoff_zone(&ts.tv_sec, &tm, &off, NULL);
+		gmtoff = (int)off;
+	    }
 	    if (mon != -1) goto setmonth;
 	    if (mday != -1) goto setmday;
 	    if (hour != -1) goto sethour;
@@ -473,8 +460,14 @@ strptime_exec0(void **pc, const char *fmt, const char *str, size_t slen,
 	    if (sec != -1) tm.tm_sec = sec;
 	}
 
-	t = timegm_noleapsecond(&tm);
-	if (gmt != 1) t -= gmtoff;
+	if (gmt) {
+	    t = timegm_noleapsecond(&tm);
+	    if (gmt == 2) t -= gmtoff;
+	}
+	else {
+	    r = find_time_t(&tm, gmt, &t);
+	    if (r) fail();
+	}
 	tsp->tv_sec = t;
 	tsp->tv_nsec = nsec;
 	*gmtoffp = gmtoff;
@@ -484,7 +477,7 @@ strptime_exec0(void **pc, const char *fmt, const char *str, size_t slen,
     END_INSNS_DISPATCH();
 
     /* unreachable */
-    rb_bug("vm_eval: unreachable");
+    rb_bug("strptime_exec0: unreachable");
     UNREACHABLE;
 }
 

data/ext/strptime/strptime.h

@@ -10,6 +10,7 @@ struct tm * localtime_with_gmtoff_zone(const time_t *t, struct tm *result, long
 void rb_timespec_now(struct timespec *ts);
 # endif
 time_t timegm_noleapsecond(struct tm *tm);
+const char *find_time_t(struct tm *tptr, int utc_p, time_t *tp);
 void tm_add_offset(struct tm *tm, long diff);
 
 #endif /* STRPTIME_H */

data/lib/strptime/version.rb

@@ -1,3 +1,3 @@
 class Strptime
-  VERSION = "0.1.6"
+  VERSION = "0.1.7"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: strptime
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.7
 platform: x64-mingw32
 authors:
 - NARUSE, Yui
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-12-17 00:00:00.000000000 Z
+date: 2016-03-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler