strptime 0.1.9-x64-mingw32 → 0.2.1-x64-mingw32

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 87b7e4d6f0044905e518c093138d21e538af7f23
-  data.tar.gz: 772e0fbc7837a84fbee99fd598ace9b64b31e622
+  metadata.gz: da9b5b737ae895af93e98cc6a5d267e134e36cef
+  data.tar.gz: ff65ec6bdc06e6f0b202bb8a91594e50f83d6483
 SHA512:
-  metadata.gz: 152d8f0198b22f65929cc6fd3503bde2898758ea5eb21d932d9fc8d8a183b3f9520222a30ce055dc7eab68ac93703c963d76c22eed5b701d31c84c1feb769f6f
-  data.tar.gz: 306be2bad64761df3f8d4345b319d20cbb129c1d454ac8a6fee04f38809fa20f95b4f250457d1fbf83f4b1224ba562967708edebe39996cbd8b4440911924a68
+  metadata.gz: 9a16feb8a8146c3d0ae99880f6b9be74fad1049de1413446faa81072bba597d61c9dd15afdf73625f792f49cadbd2a57b9a52515d2c03a2984429477eb7484d5
+  data.tar.gz: 149c4fdc38c93bf6389d2cb4733c4745eb422b70a46dcc0b767bb61cf7ff14ab0f2018abbe916d4e572f08d26ed497841e4c024cea61cacd2aac6f8b98d215ed

data/ext/strptime/extconf.rb

@@ -2,5 +2,6 @@ require "mkmf"
 
 have_func('rb_timespec_now')
 have_func('rb_time_timespec_new')
+have_func('rb_time_utc_offset')
 
 create_makefile("strptime/strptime")

data/ext/strptime/ruby_time.c

@@ -147,7 +147,7 @@ rb_localtime_r(const time_t *t, struct tm *result)
 }
 #define LOCALTIME(tm, result) (tzset(),rb_localtime_r((tm), &(result)))
 
-static struct tm *
+struct tm *
 rb_gmtime_r(const time_t *t, struct tm *result)
 {
 #ifdef HAVE_GMTIME_R

data/ext/strptime/strftime.c

@@ -0,0 +1,495 @@
+#include "../strptime/strptime.h"
+#include "ruby/encoding.h"
+#include <time.h>
+
+VALUE rb_cStrftime;
+#ifndef HAVE_RB_TIME_UTC_OFFSET
+static ID id_gmtoff;
+#endif
+
+#define GetStrftimeval(obj, tobj) ((tobj) = get_strftimeval(obj))
+#define GetNewStrftimeval(obj, tobj) ((tobj) = get_new_strftimeval(obj))
+#define StrfTIME_INIT_P(tobj) ((tobj)->isns)
+
+#define LIKELY(x) (__builtin_expect((x), 1))
+#define UNLIKELY(x) (__builtin_expect((x), 0))
+
+#define REG_PC (pc)
+#define GET_PC() REG_PC
+#define SET_PC(x) (REG_PC = (x))
+#define GET_CURRENT_INSN() (*GET_PC())
+#define GET_OPERAND(n) (GET_PC()[(n)])
+#define ADD_PC(n) (SET_PC(REG_PC + (n)))
+
+#define JUMP(dst) (REG_PC += (dst))
+
+#define LABEL(x) INSN_LABEL_##x
+#define ELABEL(x) INSN_ELABEL_##x
+#define LABEL_PTR(x) &&LABEL(x)
+
+#define INSN_ENTRY(insn) LABEL(insn) :
+
+#define TC_DISPATCH(insn)                                                      \
+    goto *(void const *)GET_CURRENT_INSN();                                    \
+    ;
+#define END_INSN(insn) TC_DISPATCH(insn);
+
+#define INSN_DISPATCH()                                                        \
+    TC_DISPATCH(__START__)                                                     \
+    {
+
+#define END_INSNS_DISPATCH()                                                   \
+    rb_bug("strptime: unknown insn: %p", GET_CURRENT_INSN());                  \
+    } /* end of while loop */
+
+#define NEXT_INSN() TC_DISPATCH(__NEXT_INSN__)
+
+
+
+static VALUE
+strftime_exec0(void **pc, VALUE fmt, struct timespec *tsp, int gmtoff, size_t result_length)
+{
+    VALUE result;
+    struct tm tm;
+    char *p;
+    if (UNLIKELY(tsp == NULL)) {
+	static const void *const insns_address_table[] = {
+	    NULL, NULL, NULL, NULL,
+	    NULL, NULL, NULL, LABEL_PTR(H),
+	    NULL, NULL, NULL, LABEL_PTR(L),
+	    LABEL_PTR(M), LABEL_PTR(N), NULL, NULL,
+	    NULL, NULL, LABEL_PTR(S), NULL,
+	    NULL, NULL, NULL, NULL,
+	    LABEL_PTR(Y), NULL, NULL, NULL,
+	    NULL, NULL, LABEL_PTR(_5f), LABEL_PTR(_60),
+	    NULL, NULL, NULL, LABEL_PTR(d),
+	    LABEL_PTR(d), NULL, NULL, NULL,
+	    NULL, NULL, NULL, NULL,
+	    LABEL_PTR(m), NULL, NULL, NULL,
+	    NULL, NULL, NULL, NULL,
+	    NULL, NULL, NULL, NULL,
+	    LABEL_PTR(y), LABEL_PTR(z),
+	};
+	*pc = (void *)insns_address_table;
+	return Qnil;
+    }
+
+    result = rb_str_new(NULL, result_length);
+    p = RSTRING_PTR(result);
+
+    tsp->tv_sec += gmtoff;
+    rb_gmtime_r(&tsp->tv_sec, &tm);
+
+    INSN_DISPATCH();
+    INSN_ENTRY(H)
+    {
+	*p++ = '0' + (tm.tm_hour / 10);
+	*p++ = '0' + (tm.tm_hour % 10);
+	ADD_PC(1);
+	END_INSN(H)
+    }
+    INSN_ENTRY(L)
+    {
+	int msec = tsp->tv_nsec / 1000000;
+	p[2] = '0' + (msec % 10);
+	msec /= 10;
+	p[1] = '0' + (msec % 10);
+	p[0] = '0' + (msec / 10);
+	p += 3;
+	ADD_PC(1);
+	END_INSN(L)
+    }
+    INSN_ENTRY(M)
+    {
+	*p++ = '0' + (tm.tm_min / 10);
+	*p++ = '0' + (tm.tm_min % 10);
+	ADD_PC(1);
+	END_INSN(M)
+    }
+    INSN_ENTRY(N)
+    {
+	int len = 9;
+	int i;
+	int base = 1;
+	int subsec = tsp->tv_nsec;
+	for (i=0; i < 9-len; i++) {
+	    base *= 10;
+	}
+	subsec /= base;
+	for (i=0; i < len; i++) {
+	    p[len-i-1] = '0' + subsec % 10;
+	    subsec /= 10;
+	}
+	p += len;
+	ADD_PC(1);
+	END_INSN(N)
+    }
+    INSN_ENTRY(S)
+    {
+	*p++ = '0' + (tm.tm_sec / 10);
+	*p++ = '0' + (tm.tm_sec % 10);
+	ADD_PC(1);
+	END_INSN(S)
+    }
+    INSN_ENTRY(Y)
+    {
+	// TODO: Y10K
+	int i, y = tm.tm_year;
+	y += y < 69 ? 2000 : 1900;
+	for (i = 0; i < 4; i++) {
+	    p[3-i] = '0' + y % 10;
+	    y /= 10;
+	}
+	p += 4;
+	ADD_PC(1);
+	END_INSN(Y)
+    }
+    INSN_ENTRY(d)
+    {
+	*p++ = '0' + (tm.tm_mday / 10);
+	*p++ = '0' + (tm.tm_mday % 10);
+	ADD_PC(1);
+	END_INSN(d)
+    }
+    INSN_ENTRY(m)
+    {
+	int mon = tm.tm_mon + 1;
+	*p++ = '0' + (mon / 10);
+	*p++ = '0' + (mon % 10);
+	ADD_PC(1);
+	END_INSN(m)
+    }
+    INSN_ENTRY(y)
+    {
+	int y = tm.tm_year % 100;
+	*p++ = '0' + (y / 10);
+	*p++ = '0' + (y % 10);
+	ADD_PC(1);
+	END_INSN(y)
+    }
+    INSN_ENTRY(z)
+    {
+	int h, m, tmp=gmtoff;
+	if (gmtoff >= 0) {
+	    *p++ = '+';
+	} else {
+	    *p++ = '-';
+	    tmp = -tmp;
+	}
+	tmp /= 60;
+	h = (tmp / 60)&15; /* ignore too large offset */
+	m = tmp % 60;
+	*p++ = '0' + (h / 10);
+	*p++ = '0' + (h % 10);
+	*p++ = '0' + (m / 10);
+	*p++ = '0' + (m % 10);
+	ADD_PC(1);
+	END_INSN(y)
+    }
+    INSN_ENTRY(_60)
+    {
+	size_t v = (size_t)GET_OPERAND(1);
+	size_t off = v & 0xFFFF;
+	size_t len = v >> 16;
+	memcpy(p, RSTRING_PTR(fmt) + off, len);
+	p += len;
+	pc += 2;
+	END_INSN(_60)
+    }
+    INSN_ENTRY(_5f)
+    {
+	return result;
+	END_INSN(_5f)
+    }
+    END_INSNS_DISPATCH();
+
+    /* unreachable */
+    rb_bug("strftime_exec0: unreachable");
+    UNREACHABLE;
+}
+
+static void **
+strftime_compile(const char *fmt, size_t flen, size_t *rlenp)
+{
+    size_t fi = 0, rlen = 0;
+    char c;
+    void **isns0, **isns;
+    void **insns_address_table;
+    void *tmp;
+    strftime_exec0((void **)&insns_address_table, Qnil, NULL, 0, 0);
+
+    if (flen > 65535) {
+	rb_raise(rb_eArgError, "too long format string (>65335)");
+    }
+    isns0 = ALLOC_N(void *, flen + 2);
+    isns = isns0;
+
+    while (fi < flen) {
+	switch (fmt[fi]) {
+	case '%':
+	    fi++;
+	    c = fmt[fi];
+	    switch (c) {
+	    case 'H':
+	      rlen += 2;
+	      goto accept_format;
+	    case 'L':
+	      rlen += 3;
+	      goto accept_format;
+	    case 'M':
+	      rlen += 2;
+	      goto accept_format;
+	    case 'N':
+	      rlen += 9;
+	      goto accept_format;
+	    case 'S':
+	      rlen += 2;
+	      goto accept_format;
+	    case 'Y':
+	      rlen += 4;
+	      goto accept_format;
+	    case 'd':
+	      rlen += 2;
+	      goto accept_format;
+	    case 'm':
+	      rlen += 2;
+	      goto accept_format;
+	    case 'y':
+	      rlen += 2;
+	      goto accept_format;
+	    case 'z':
+	      rlen += 5;
+	      goto accept_format;
+accept_format:
+		tmp = insns_address_table[c - 'A'];
+		if (tmp) {
+		    *isns++ = tmp;
+		    fi++;
+		    continue;
+		}
+	    default:
+		xfree(isns0);
+		rb_raise(rb_eArgError, "invalid format");
+		break;
+	    }
+	default: {
+	    const char *p0 = fmt + fi, *p = p0, *pe = fmt + flen;
+	    size_t v = fi;
+	    while (p < pe && *p != '%')
+		p++;
+	    v += (p - p0) << 16;
+	    fi += p - p0;
+	    rlen += p - p0;
+	    *isns++ = insns_address_table['`' - 'A'];
+	    *isns++ = (void *)v;
+	} break;
+	}
+    }
+    *isns++ = insns_address_table['_' - 'A'];
+    REALLOC_N(isns0, void *, isns - isns0);
+    *rlenp = rlen;
+    return isns0;
+}
+
+struct strftime_object {
+    void **isns;
+    size_t result_length;
+    VALUE fmt;
+};
+
+static void
+strftime_mark(void *ptr)
+{
+    struct strftime_object *tobj = ptr;
+    rb_gc_mark(tobj->fmt);
+}
+
+static void
+strftime_free(void *ptr)
+{
+    struct strftime_object *tobj = ptr;
+    if (tobj->isns) ruby_xfree(tobj->isns);
+}
+
+static size_t
+strftime_memsize(const void *tobj)
+{
+    return sizeof(struct strftime_object);
+}
+
+static const rb_data_type_t strftime_data_type = {
+    "strftime",
+    {
+	strftime_mark, strftime_free, strftime_memsize,
+    },
+#ifdef RUBY_TYPED_FREE_IMMEDIATELY
+    0,
+    0,
+    RUBY_TYPED_FREE_IMMEDIATELY
+#endif
+};
+
+static VALUE
+strftime_s_alloc(VALUE klass)
+{
+    VALUE obj;
+    struct strftime_object *tobj;
+
+    obj = TypedData_Make_Struct(klass, struct strftime_object,
+				&strftime_data_type, tobj);
+
+    return obj;
+}
+
+static struct strftime_object *
+get_strftimeval(VALUE obj)
+{
+    struct strftime_object *tobj;
+    TypedData_Get_Struct(obj, struct strftime_object, &strftime_data_type,
+			 tobj);
+    if (!StrfTIME_INIT_P(tobj)) {
+	rb_raise(rb_eTypeError, "uninitialized %" PRIsVALUE, rb_obj_class(obj));
+    }
+    return tobj;
+}
+
+static struct strftime_object *
+get_new_strftimeval(VALUE obj)
+{
+    struct strftime_object *tobj;
+    TypedData_Get_Struct(obj, struct strftime_object, &strftime_data_type,
+			 tobj);
+    if (StrfTIME_INIT_P(tobj)) {
+	rb_raise(rb_eTypeError, "already initialized %" PRIsVALUE,
+		 rb_obj_class(obj));
+    }
+    return tobj;
+}
+
+/*
+ * @overload new(format)
+ *   @param format [String] strftime(3) style format string.
+ *
+ * returns generator object
+ */
+static VALUE
+strftime_init(VALUE self, VALUE fmt)
+{
+    struct strftime_object *tobj;
+    void **isns;
+    size_t rlen;
+    StringValueCStr(fmt);
+    TypedData_Get_Struct(self, struct strftime_object, &strftime_data_type,
+			 tobj);
+    isns = strftime_compile(RSTRING_PTR(fmt), RSTRING_LEN(fmt), &rlen);
+    tobj->isns = isns;
+    tobj->fmt = rb_str_new_frozen(fmt);
+    tobj->result_length = rlen;
+    return self;
+}
+
+/* @api private
+ * For Ruby VM internal.
+ */
+static VALUE
+strftime_init_copy(VALUE copy, VALUE self)
+{
+    struct strftime_object *tobj, *tcopy;
+
+    if (!OBJ_INIT_COPY(copy, self)) return copy;
+    GetStrftimeval(self, tobj);
+    GetNewStrftimeval(copy, tcopy);
+    MEMCPY(tcopy, tobj, struct strftime_object, 1);
+
+    return copy;
+}
+
+/*
+ * @overload exec(str)
+ *   @param str [String] string to parse
+ * @return [Time] the time object given string means
+ *
+ * Return a formatted datetime string
+ *
+ */
+static VALUE
+strftime_exec(VALUE self, VALUE time)
+{
+    struct strftime_object *sobj;
+    struct timespec ts = rb_time_timespec(time);
+#ifdef HAVE_RB_TIME_UTC_OFFSET
+    int gmtoff = FIX2INT(rb_time_utc_offset(time));
+#else
+    int gmtoff = NUM2INT(rb_funcall(time, id_gmtoff, 0));
+#endif
+    GetStrftimeval(self, sobj);
+
+    return strftime_exec0(sobj->isns, sobj->fmt, &ts, gmtoff, sobj->result_length);
+}
+
+/*
+ * @overload execi(epoch)
+ *   @param epoch [Integer] Unix epoch
+ * @return [String] the formatted datetime string
+ *
+ * Return a formatted datetime string
+ *
+ */
+static VALUE
+strftime_execi(VALUE self, VALUE epoch)
+{
+    struct strftime_object *tobj;
+    struct timespec ts;
+    GetStrftimeval(self, tobj);
+
+    if (RB_INTEGER_TYPE_P(epoch)) {
+	ts.tv_sec = NUM2TIMET(epoch);
+	ts.tv_nsec = 0;
+    } else if (RB_FLOAT_TYPE_P(epoch)) {
+	double d = NUM2DBL(epoch);
+	ts.tv_sec = (time_t)d;
+	ts.tv_nsec = (int)((int64_t)(d * 1000000000) % 1000000000);
+    } else if (RB_TYPE_P(epoch, T_RATIONAL)) {
+	ts.tv_sec = NUM2TIMET(epoch);
+	ts.tv_nsec = NUM2INT(rb_funcall(rb_funcall(epoch, '*', 1, INT2FIX(1000000000)), '%', 1, INT2FIX(1000000000)));
+    }
+
+    return strftime_exec0(tobj->isns, tobj->fmt, &ts, 0, tobj->result_length);
+}
+
+/*
+ * @overload source
+ * @return [String] source format string
+ */
+static VALUE
+strftime_source(VALUE self)
+{
+    struct strftime_object *tobj;
+    GetStrftimeval(self, tobj);
+
+    return tobj->fmt;
+}
+
+
+/*
+ * Document-class: Strftime
+ *
+ * Strftime is a faster way to format time string like strftime(3).
+ *
+ * @example
+ *    generator = Strftime.new('%Y-%m-%dT%H:%M:%S%z')
+ *    generator.source #=> "%Y-%m-%dT%H:%M:%S%z"
+ *    generator.exec(Time.now) #=> 2017-12-25T12:34:56+09:00
+ */
+void
+Init_strftime(void)
+{
+    rb_cStrftime = rb_define_class("Strftime", rb_cObject);
+    rb_define_alloc_func(rb_cStrftime, strftime_s_alloc);
+    rb_define_method(rb_cStrftime, "initialize", strftime_init, 1);
+    rb_define_method(rb_cStrftime, "initialize_copy", strftime_init_copy, 1);
+    rb_define_method(rb_cStrftime, "exec", strftime_exec, 1);
+    rb_define_method(rb_cStrftime, "execi", strftime_execi, 1);
+    rb_define_method(rb_cStrftime, "source", strftime_source, 0);
+    id_gmtoff = rb_intern("gmtoff");
+}

data/ext/strptime/strptime.c

@@ -481,7 +481,7 @@ strptime_exec0(void **pc, const char *fmt, const char *str, size_t slen,
     UNREACHABLE;
 }
 
-void **
+static void **
 strptime_compile(const char *fmt, size_t flen)
 {
     size_t fi = 0;
@@ -518,7 +518,10 @@ strptime_compile(const char *fmt, size_t flen)
 		    fi++;
 		    continue;
 		}
-	    default: rb_raise(rb_eArgError, "invalid format"); break;
+	    default:
+		xfree(isns0);
+		rb_raise(rb_eArgError, "invalid format");
+		break;
 	    }
 	case ' ':
 	case '\t':
@@ -562,7 +565,7 @@ static void
 strptime_free(void *ptr)
 {
     struct strptime_object *tobj = ptr;
-    ruby_xfree(tobj->isns);
+    if (tobj->isns) ruby_xfree(tobj->isns);
 }
 
 static size_t
@@ -735,4 +738,5 @@ Init_strptime(void)
     rb_define_method(rb_cStrptime, "exec", strptime_exec, 1);
     rb_define_method(rb_cStrptime, "execi", strptime_execi, 1);
     rb_define_method(rb_cStrptime, "source", strptime_source, 0);
+    Init_strftime();
 }

data/ext/strptime/strptime.h

@@ -12,5 +12,18 @@ void rb_timespec_now(struct timespec *ts);
 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);
+struct tm *rb_gmtime_r(const time_t *t, struct tm *result);
+void Init_strftime(void);
+
+#ifndef RB_INTEGER_TYPE_P
+#define RB_INTEGER_TYPE_P(obj) rb_integer_type_p(obj)
+static inline int
+rb_integer_type_p(VALUE obj)
+{
+    return (FIXNUM_P(obj) ||
+	    (!SPECIAL_CONST_P(obj) &&
+	     BUILTIN_TYPE(obj) == RUBY_T_BIGNUM));
+}
+#endif
 
 #endif /* STRPTIME_H */

data/lib/strptime/version.rb

@@ -1,3 +1,3 @@
 class Strptime
-  VERSION = "0.1.9"
+  VERSION = "0.2.1"
 end

data/strptime.gemspec

@@ -9,8 +9,8 @@ Gem::Specification.new do |spec|
   spec.authors       = ["NARUSE, Yui"]
   spec.email         = ["naruse@airemix.jp"]
 
-  spec.summary       = %q{a fast strptime engine.}
-  spec.description   = %q{a fast strptime engine which uses VM.}
+  spec.summary       = %q{a fast strptime/strftime engine.}
+  spec.description   = %q{a fast strptime/strftime engine which uses VM.}
   spec.homepage      = "https://github.com/nurse/strptime"
   spec.license       = "BSD-2-Clause"
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: strptime
 version: !ruby/object:Gem::Version
-  version: 0.1.9
+  version: 0.2.1
 platform: x64-mingw32
 authors:
 - NARUSE, Yui
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-01-11 00:00:00.000000000 Z
+date: 2017-12-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -94,7 +94,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: a fast strptime engine which uses VM.
+description: a fast strptime/strftime engine which uses VM.
 email:
 - naruse@airemix.jp
 executables: []
@@ -114,6 +114,7 @@ files:
 - bin/setup
 - ext/strptime/extconf.rb
 - ext/strptime/ruby_time.c
+- ext/strptime/strftime.c
 - ext/strptime/strptime.c
 - ext/strptime/strptime.h
 - lib/strptime.rb
@@ -150,5 +151,5 @@ rubyforge_project:
 rubygems_version: 2.6.8
 signing_key: 
 specification_version: 4
-summary: a fast strptime engine.
+summary: a fast strptime/strftime engine.
 test_files: []