From fcbf63e62c627deae76c1b8cb8c0876c536ed811 Mon Sep 17 00:00:00 2001 From: Jari Vetoniemi Date: Mon, 16 Mar 2020 18:49:26 +0900 Subject: Fresh start --- jni/ruby/ext/date/Makefile | 333 ++ jni/ruby/ext/date/date_core.c | 9573 +++++++++++++++++++++++++++++++++++++ jni/ruby/ext/date/date_parse.c | 3128 ++++++++++++ jni/ruby/ext/date/date_strftime.c | 633 +++ jni/ruby/ext/date/date_strptime.c | 701 +++ jni/ruby/ext/date/date_tmx.h | 56 + jni/ruby/ext/date/depend | 53 + jni/ruby/ext/date/extconf.h | 3 + jni/ruby/ext/date/extconf.rb | 5 + jni/ruby/ext/date/lib/date.rb | 60 + 10 files changed, 14545 insertions(+) create mode 100644 jni/ruby/ext/date/Makefile create mode 100644 jni/ruby/ext/date/date_core.c create mode 100644 jni/ruby/ext/date/date_parse.c create mode 100644 jni/ruby/ext/date/date_strftime.c create mode 100644 jni/ruby/ext/date/date_strptime.c create mode 100644 jni/ruby/ext/date/date_tmx.h create mode 100644 jni/ruby/ext/date/depend create mode 100644 jni/ruby/ext/date/extconf.h create mode 100644 jni/ruby/ext/date/extconf.rb create mode 100644 jni/ruby/ext/date/lib/date.rb (limited to 'jni/ruby/ext/date') diff --git a/jni/ruby/ext/date/Makefile b/jni/ruby/ext/date/Makefile new file mode 100644 index 0000000..066cc6a --- /dev/null +++ b/jni/ruby/ext/date/Makefile @@ -0,0 +1,333 @@ + +SHELL = /bin/sh + +# V=0 quiet, V=1 verbose. other values don't work. +V = 0 +Q1 = $(V:1=) +Q = $(Q1:0=@) +ECHO1 = $(V:1=@:) +ECHO = $(ECHO1:0=@echo) +NULLCMD = : + +#### Start of system configuration section. #### +top_srcdir = $(topdir)/. +srcdir = $(top_srcdir)/ext/date +topdir = ../.. +hdrdir = $(top_srcdir)/include +arch_hdrdir = $(extout)/include/$(arch) +PATH_SEPARATOR = : +VPATH = $(srcdir):$(arch_hdrdir)/ruby:$(hdrdir)/ruby +RUBYLIB = +RUBYOPT = - +prefix = $(DESTDIR)/usr/local +rubysitearchprefix = $(rubylibprefix)/$(sitearch) +rubyarchprefix = $(rubylibprefix)/$(arch) +rubylibprefix = $(libdir)/$(RUBY_BASE_NAME) +exec_prefix = $(prefix) +vendorarchhdrdir = $(vendorhdrdir)/$(sitearch) +sitearchhdrdir = $(sitehdrdir)/$(sitearch) +rubyarchhdrdir = $(rubyhdrdir)/$(arch) +vendorhdrdir = $(rubyhdrdir)/vendor_ruby +sitehdrdir = $(rubyhdrdir)/site_ruby +rubyhdrdir = $(includedir)/$(RUBY_VERSION_NAME) +vendorarchdir = $(vendorlibdir)/$(sitearch) +vendorlibdir = $(vendordir)/$(ruby_version) +vendordir = $(rubylibprefix)/vendor_ruby +sitearchdir = $(sitelibdir)/$(sitearch) +sitelibdir = $(sitedir)/$(ruby_version) +sitedir = $(rubylibprefix)/site_ruby +rubyarchdir = $(rubylibdir)/$(arch) +rubylibdir = $(rubylibprefix)/$(ruby_version) +sitearchincludedir = $(includedir)/$(sitearch) +archincludedir = $(includedir)/$(arch) +sitearchlibdir = $(libdir)/$(sitearch) +archlibdir = $(libdir)/$(arch) +ridir = $(datarootdir)/$(RI_BASE_NAME) +mandir = $(datarootdir)/man +localedir = $(datarootdir)/locale +libdir = $(exec_prefix)/lib +psdir = $(docdir) +pdfdir = $(docdir) +dvidir = $(docdir) +htmldir = $(docdir) +infodir = $(datarootdir)/info +docdir = $(datarootdir)/doc/$(PACKAGE) +oldincludedir = $(DESTDIR)/usr/include +includedir = $(prefix)/include +localstatedir = $(prefix)/var +sharedstatedir = $(prefix)/com +sysconfdir = $(prefix)/etc +datadir = $(datarootdir) +datarootdir = $(prefix)/share +libexecdir = $(exec_prefix)/libexec +sbindir = $(exec_prefix)/sbin +bindir = $(exec_prefix)/bin +archdir = $(rubyarchdir) + + +CC = gcc +CXX = g++ +LIBRUBY = $(LIBRUBY_SO) +LIBRUBY_A = lib$(RUBY_SO_NAME)-static.a +LIBRUBYARG_SHARED = -Wl,-R$(libdir) -L$(libdir) -l$(RUBY_SO_NAME) +LIBRUBYARG_STATIC = -Wl,-R$(libdir) -L$(libdir) -l$(RUBY_SO_NAME)-static +empty = +OUTFLAG = -o $(empty) +COUTFLAG = -o $(empty) + +RUBY_EXTCONF_H = extconf.h +cflags = $(optflags) $(debugflags) $(warnflags) +optflags = -O3 -fno-fast-math +debugflags = -ggdb3 +warnflags = -Wall -Wextra -Wno-unused-parameter -Wno-parentheses -Wno-long-long -Wno-missing-field-initializers -Wunused-variable -Wpointer-arith -Wwrite-strings -Wdeclaration-after-statement -Wimplicit-function-declaration -Wdeprecated-declarations -Wno-packed-bitfield-compat +CCDLFLAGS = -fPIC +CFLAGS = $(CCDLFLAGS) $(cflags) -fPIC -std=iso9899:1999 $(ARCH_FLAG) +INCFLAGS = -I. -I$(arch_hdrdir) -I$(hdrdir) -I$(srcdir) +DEFS = +CPPFLAGS = -DRUBY_EXTCONF_H=\"$(RUBY_EXTCONF_H)\" $(DEFS) $(cppflags) +CXXFLAGS = $(CCDLFLAGS) $(cxxflags) $(ARCH_FLAG) +ldflags = -L. -fstack-protector -rdynamic -Wl,-export-dynamic +dldflags = +ARCH_FLAG = +DLDFLAGS = $(ldflags) $(dldflags) $(ARCH_FLAG) +LDSHARED = $(CC) -shared +LDSHAREDXX = $(CXX) -shared +AR = ar +EXEEXT = + +RUBY_INSTALL_NAME = $(RUBY_BASE_NAME) +RUBY_SO_NAME = ruby +RUBYW_INSTALL_NAME = +RUBY_VERSION_NAME = $(RUBY_BASE_NAME)-$(ruby_version) +RUBYW_BASE_NAME = rubyw +RUBY_BASE_NAME = ruby + +arch = x86_64-linux +sitearch = $(arch) +ruby_version = 2.2.0 +ruby = $(topdir)/miniruby -I'$(topdir)' -I'$(top_srcdir)/lib' -I'$(extout)/$(arch)' -I'$(extout)/common' +RUBY = $(ruby) +ruby_headers = $(hdrdir)/ruby.h $(hdrdir)/ruby/ruby.h $(hdrdir)/ruby/defines.h $(hdrdir)/ruby/missing.h $(hdrdir)/ruby/intern.h $(hdrdir)/ruby/st.h $(hdrdir)/ruby/subst.h $(arch_hdrdir)/ruby/config.h $(RUBY_EXTCONF_H) + +RM = rm -f +RM_RF = $(RUBY) -run -e rm -- -rf +RMDIRS = rmdir --ignore-fail-on-non-empty -p +MAKEDIRS = /bin/mkdir -p +INSTALL = /usr/bin/install -c +INSTALL_PROG = $(INSTALL) -m 0755 +INSTALL_DATA = $(INSTALL) -m 644 +COPY = cp +TOUCH = exit > + +#### End of system configuration section. #### + +preload = + +libpath = . $(topdir) +LIBPATH = -L. -L$(topdir) +DEFFILE = + +CLEANFILES = mkmf.log +DISTCLEANFILES = +DISTCLEANDIRS = + +extout = $(topdir)/.ext +extout_prefix = $(extout)$(target_prefix)/ +target_prefix = +LOCAL_LIBS = +LIBS = $(LIBRUBYARG_SHARED) -lpthread -lgmp -ldl -lcrypt -lm -lc +ORIG_SRCS = date_parse.c date_core.c date_strftime.c date_strptime.c +SRCS = $(ORIG_SRCS) +OBJS = date_parse.o date_core.o date_strftime.o date_strptime.o +HDRS = $(srcdir)/extconf.h $(srcdir)/date_tmx.h +TARGET = date_core +TARGET_NAME = date_core +TARGET_ENTRY = Init_$(TARGET_NAME) +DLLIB = $(TARGET).so +EXTSTATIC = +STATIC_LIB = $(TARGET).a + +TIMESTAMP_DIR = $(extout)/.timestamp +BINDIR = $(extout)/bin +RUBYCOMMONDIR = $(extout)/common +RUBYLIBDIR = $(RUBYCOMMONDIR)$(target_prefix) +RUBYARCHDIR = $(extout)/$(arch)$(target_prefix) +HDRDIR = $(extout)/include/ruby$(target_prefix) +ARCHHDRDIR = $(extout)/include/$(arch)/ruby$(target_prefix) + +TARGET_SO = $(RUBYARCHDIR)/$(DLLIB) +CLEANLIBS = $(RUBYARCHDIR)/$(TARGET).so +CLEANOBJS = *.o *.bak + +all: install +static: all +.PHONY: all install static install-so install-rb +.PHONY: clean clean-so clean-static clean-rb + +clean-static:: +clean-rb-default:: +clean-rb:: +clean-so:: +clean: clean-so clean-static clean-rb-default clean-rb + -$(Q)$(RM) $(CLEANLIBS) $(CLEANOBJS) $(CLEANFILES) .*.time + +distclean-rb-default:: +distclean-rb:: +distclean-so:: +distclean-static:: +distclean: clean distclean-so distclean-static distclean-rb-default distclean-rb + -$(Q)$(RM) Makefile $(RUBY_EXTCONF_H) conftest.* mkmf.log + -$(Q)$(RM) core ruby$(EXEEXT) *~ $(DISTCLEANFILES) + -$(Q)$(RMDIRS) $(DISTCLEANDIRS) 2> /dev/null || true + +realclean: distclean +install: install-so install-rb + +install-so: $(RUBYARCHDIR)/$(DLLIB) +clean-so:: + -$(Q)$(RM) $(RUBYARCHDIR)/$(DLLIB) + -$(Q)$(RMDIRS) $(RUBYARCHDIR) 2> /dev/null || true +clean-static:: + -$(Q)$(RM) $(STATIC_LIB) +install-rb: pre-install-rb install-rb-default +install-rb-default: pre-install-rb-default +pre-install-rb: Makefile +pre-install-rb-default: Makefile +pre-install-rb-default: $(TIMESTAMP_DIR)/.RUBYLIBDIR.time +install-rb-default: $(RUBYLIBDIR)/date.rb +$(RUBYLIBDIR)/date.rb: $(srcdir)/lib/date.rb $(TIMESTAMP_DIR)/.RUBYLIBDIR.time + $(Q) $(COPY) $(srcdir)/lib/date.rb $(@D) +clean-rb-default:: + -$(Q)$(RM) $(RUBYLIBDIR)/date.rb +pre-install-rb-default: + $(ECHO) installing default date_core libraries +clean-rb-default:: + -$(Q)$(RMDIRS) $(RUBYLIBDIR) 2> /dev/null || true +$(TIMESTAMP_DIR)/.RUBYARCHDIR.time: + $(Q) $(MAKEDIRS) $(@D) $(RUBYARCHDIR) + $(Q) $(TOUCH) $@ +$(TIMESTAMP_DIR)/.RUBYLIBDIR.time: + $(Q) $(MAKEDIRS) $(@D) $(RUBYLIBDIR) + $(Q) $(TOUCH) $@ + +site-install: site-install-so site-install-rb +site-install-so: install-so +site-install-rb: install-rb + +.SUFFIXES: .c .m .cc .mm .cxx .cpp .o .S + +.cc.o: + $(ECHO) compiling $(<) + $(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $< + +.cc.S: + $(ECHO) translating $(<) + $(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -S $< + +.mm.o: + $(ECHO) compiling $(<) + $(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $< + +.mm.S: + $(ECHO) translating $(<) + $(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -S $< + +.cxx.o: + $(ECHO) compiling $(<) + $(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $< + +.cxx.S: + $(ECHO) translating $(<) + $(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -S $< + +.cpp.o: + $(ECHO) compiling $(<) + $(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $< + +.cpp.S: + $(ECHO) translating $(<) + $(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -S $< + +.c.o: + $(ECHO) compiling $(<) + $(Q) $(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) $(COUTFLAG)$@ -c $< + +.c.S: + $(ECHO) translating $(<) + $(Q) $(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) $(COUTFLAG)$@ -S $< + +.m.o: + $(ECHO) compiling $(<) + $(Q) $(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) $(COUTFLAG)$@ -c $< + +.m.S: + $(ECHO) translating $(<) + $(Q) $(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) $(COUTFLAG)$@ -S $< + +$(RUBYARCHDIR)/$(DLLIB): $(OBJS) Makefile $(TIMESTAMP_DIR)/.RUBYARCHDIR.time + $(ECHO) linking shared-object $(DLLIB) + -$(Q)$(RM) $(@) + $(Q) $(LDSHARED) -o $@ $(OBJS) $(LIBPATH) $(DLDFLAGS) $(LOCAL_LIBS) $(LIBS) + +$(STATIC_LIB): $(OBJS) + -$(Q)$(RM) $(@) + $(ECHO) linking static-library $(@) + $(Q) $(AR) cru $@ $(OBJS) + -$(Q)ranlib $(@) 2> /dev/null || true + +### +$(OBJS): $(RUBY_EXTCONF_H) + +# AUTOGENERATED DEPENDENCIES START +date_core.o: $(RUBY_EXTCONF_H) +date_core.o: $(arch_hdrdir)/ruby/config.h +date_core.o: $(hdrdir)/ruby/defines.h +date_core.o: $(hdrdir)/ruby/encoding.h +date_core.o: $(hdrdir)/ruby/intern.h +date_core.o: $(hdrdir)/ruby/missing.h +date_core.o: $(hdrdir)/ruby/oniguruma.h +date_core.o: $(hdrdir)/ruby/ruby.h +date_core.o: $(hdrdir)/ruby/st.h +date_core.o: $(hdrdir)/ruby/subst.h +date_core.o: $(top_srcdir)/include/ruby.h +date_core.o: date_core.c +date_core.o: date_tmx.h +date_parse.o: $(RUBY_EXTCONF_H) +date_parse.o: $(arch_hdrdir)/ruby/config.h +date_parse.o: $(hdrdir)/ruby/defines.h +date_parse.o: $(hdrdir)/ruby/encoding.h +date_parse.o: $(hdrdir)/ruby/intern.h +date_parse.o: $(hdrdir)/ruby/missing.h +date_parse.o: $(hdrdir)/ruby/oniguruma.h +date_parse.o: $(hdrdir)/ruby/re.h +date_parse.o: $(hdrdir)/ruby/regex.h +date_parse.o: $(hdrdir)/ruby/ruby.h +date_parse.o: $(hdrdir)/ruby/st.h +date_parse.o: $(hdrdir)/ruby/subst.h +date_parse.o: $(top_srcdir)/include/ruby.h +date_parse.o: date_parse.c +date_strftime.o: $(RUBY_EXTCONF_H) +date_strftime.o: $(arch_hdrdir)/ruby/config.h +date_strftime.o: $(hdrdir)/ruby/defines.h +date_strftime.o: $(hdrdir)/ruby/intern.h +date_strftime.o: $(hdrdir)/ruby/missing.h +date_strftime.o: $(hdrdir)/ruby/ruby.h +date_strftime.o: $(hdrdir)/ruby/st.h +date_strftime.o: $(hdrdir)/ruby/subst.h +date_strftime.o: date_strftime.c +date_strftime.o: date_tmx.h +date_strptime.o: $(RUBY_EXTCONF_H) +date_strptime.o: $(arch_hdrdir)/ruby/config.h +date_strptime.o: $(hdrdir)/ruby/defines.h +date_strptime.o: $(hdrdir)/ruby/encoding.h +date_strptime.o: $(hdrdir)/ruby/intern.h +date_strptime.o: $(hdrdir)/ruby/missing.h +date_strptime.o: $(hdrdir)/ruby/oniguruma.h +date_strptime.o: $(hdrdir)/ruby/re.h +date_strptime.o: $(hdrdir)/ruby/regex.h +date_strptime.o: $(hdrdir)/ruby/ruby.h +date_strptime.o: $(hdrdir)/ruby/st.h +date_strptime.o: $(hdrdir)/ruby/subst.h +date_strptime.o: $(top_srcdir)/include/ruby.h +date_strptime.o: date_strptime.c +# AUTOGENERATED DEPENDENCIES END diff --git a/jni/ruby/ext/date/date_core.c b/jni/ruby/ext/date/date_core.c new file mode 100644 index 0000000..07b65a7 --- /dev/null +++ b/jni/ruby/ext/date/date_core.c @@ -0,0 +1,9573 @@ +/* + date_core.c: Coded by Tadayoshi Funaba 2010-2014 +*/ + +#include "ruby.h" +#include "ruby/encoding.h" +#include +#include +#if defined(HAVE_SYS_TIME_H) +#include +#endif + +#define NDEBUG +#include + +#ifdef RUBY_EXTCONF_H +#include RUBY_EXTCONF_H +#endif + +#define USE_PACK + +static ID id_cmp, id_le_p, id_ge_p, id_eqeq_p; +static VALUE cDate, cDateTime; +static VALUE half_days_in_day, day_in_nanoseconds; +static double positive_inf, negative_inf; + +#define f_boolcast(x) ((x) ? Qtrue : Qfalse) + +#define f_abs(x) rb_funcall(x, rb_intern("abs"), 0) +#define f_negate(x) rb_funcall(x, rb_intern("-@"), 0) +#define f_add(x,y) rb_funcall(x, '+', 1, y) +#define f_sub(x,y) rb_funcall(x, '-', 1, y) +#define f_mul(x,y) rb_funcall(x, '*', 1, y) +#define f_div(x,y) rb_funcall(x, '/', 1, y) +#define f_quo(x,y) rb_funcall(x, rb_intern("quo"), 1, y) +#define f_idiv(x,y) rb_funcall(x, rb_intern("div"), 1, y) +#define f_mod(x,y) rb_funcall(x, '%', 1, y) +#define f_remainder(x,y) rb_funcall(x, rb_intern("remainder"), 1, y) +#define f_expt(x,y) rb_funcall(x, rb_intern("**"), 1, y) +#define f_floor(x) rb_funcall(x, rb_intern("floor"), 0) +#define f_ceil(x) rb_funcall(x, rb_intern("ceil"), 0) +#define f_truncate(x) rb_funcall(x, rb_intern("truncate"), 0) +#define f_round(x) rb_funcall(x, rb_intern("round"), 0) + +#define f_to_i(x) rb_funcall(x, rb_intern("to_i"), 0) +#define f_to_r(x) rb_funcall(x, rb_intern("to_r"), 0) +#define f_to_s(x) rb_funcall(x, rb_intern("to_s"), 0) +#define f_inspect(x) rb_funcall(x, rb_intern("inspect"), 0) + +#define f_add3(x,y,z) f_add(f_add(x, y), z) +#define f_sub3(x,y,z) f_sub(f_sub(x, y), z) + +inline static VALUE +f_cmp(VALUE x, VALUE y) +{ + if (FIXNUM_P(x) && FIXNUM_P(y)) { + long c = FIX2LONG(x) - FIX2LONG(y); + if (c > 0) + c = 1; + else if (c < 0) + c = -1; + return INT2FIX(c); + } + return rb_funcall(x, id_cmp, 1, y); +} + +inline static VALUE +f_lt_p(VALUE x, VALUE y) +{ + if (FIXNUM_P(x) && FIXNUM_P(y)) + return f_boolcast(FIX2LONG(x) < FIX2LONG(y)); + return rb_funcall(x, '<', 1, y); +} + +inline static VALUE +f_gt_p(VALUE x, VALUE y) +{ + if (FIXNUM_P(x) && FIXNUM_P(y)) + return f_boolcast(FIX2LONG(x) > FIX2LONG(y)); + return rb_funcall(x, '>', 1, y); +} + +inline static VALUE +f_le_p(VALUE x, VALUE y) +{ + if (FIXNUM_P(x) && FIXNUM_P(y)) + return f_boolcast(FIX2LONG(x) <= FIX2LONG(y)); + return rb_funcall(x, id_le_p, 1, y); +} + +inline static VALUE +f_ge_p(VALUE x, VALUE y) +{ + if (FIXNUM_P(x) && FIXNUM_P(y)) + return f_boolcast(FIX2LONG(x) >= FIX2LONG(y)); + return rb_funcall(x, rb_intern(">="), 1, y); +} + +inline static VALUE +f_eqeq_p(VALUE x, VALUE y) +{ + if (FIXNUM_P(x) && FIXNUM_P(y)) + return f_boolcast(FIX2LONG(x) == FIX2LONG(y)); + return rb_funcall(x, rb_intern("=="), 1, y); +} + +inline static VALUE +f_zero_p(VALUE x) +{ + switch (TYPE(x)) { + case T_FIXNUM: + return f_boolcast(FIX2LONG(x) == 0); + case T_BIGNUM: + return Qfalse; + case T_RATIONAL: + { + VALUE num = rb_rational_num(x); + return f_boolcast(FIXNUM_P(num) && FIX2LONG(num) == 0); + } + } + return rb_funcall(x, id_eqeq_p, 1, INT2FIX(0)); +} + +#define f_nonzero_p(x) (!f_zero_p(x)) + +inline static VALUE +f_negative_p(VALUE x) +{ + if (FIXNUM_P(x)) + return f_boolcast(FIX2LONG(x) < 0); + return rb_funcall(x, '<', 1, INT2FIX(0)); +} + +#define f_positive_p(x) (!f_negative_p(x)) + +#define f_ajd(x) rb_funcall(x, rb_intern("ajd"), 0) +#define f_jd(x) rb_funcall(x, rb_intern("jd"), 0) +#define f_year(x) rb_funcall(x, rb_intern("year"), 0) +#define f_mon(x) rb_funcall(x, rb_intern("mon"), 0) +#define f_mday(x) rb_funcall(x, rb_intern("mday"), 0) +#define f_wday(x) rb_funcall(x, rb_intern("wday"), 0) +#define f_hour(x) rb_funcall(x, rb_intern("hour"), 0) +#define f_min(x) rb_funcall(x, rb_intern("min"), 0) +#define f_sec(x) rb_funcall(x, rb_intern("sec"), 0) + +/* copied from time.c */ +#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)) + +#define HAVE_JD (1 << 0) +#define HAVE_DF (1 << 1) +#define HAVE_CIVIL (1 << 2) +#define HAVE_TIME (1 << 3) +#define COMPLEX_DAT (1 << 7) + +#define have_jd_p(x) ((x)->flags & HAVE_JD) +#define have_df_p(x) ((x)->flags & HAVE_DF) +#define have_civil_p(x) ((x)->flags & HAVE_CIVIL) +#define have_time_p(x) ((x)->flags & HAVE_TIME) +#define complex_dat_p(x) ((x)->flags & COMPLEX_DAT) +#define simple_dat_p(x) (!complex_dat_p(x)) + +#define ITALY 2299161 /* 1582-10-15 */ +#define ENGLAND 2361222 /* 1752-09-14 */ +#define JULIAN positive_inf +#define GREGORIAN negative_inf +#define DEFAULT_SG ITALY + +#define UNIX_EPOCH_IN_CJD INT2FIX(2440588) /* 1970-01-01 */ + +#define MINUTE_IN_SECONDS 60 +#define HOUR_IN_SECONDS 3600 +#define DAY_IN_SECONDS 86400 +#define SECOND_IN_MILLISECONDS 1000 +#define SECOND_IN_NANOSECONDS 1000000000 + +#define JC_PERIOD0 1461 /* 365.25 * 4 */ +#define GC_PERIOD0 146097 /* 365.2425 * 400 */ +#define CM_PERIOD0 71149239 /* (lcm 7 1461 146097) */ +#define CM_PERIOD (0xfffffff / CM_PERIOD0 * CM_PERIOD0) +#define CM_PERIOD_JCY (CM_PERIOD / JC_PERIOD0 * 4) +#define CM_PERIOD_GCY (CM_PERIOD / GC_PERIOD0 * 400) + +#define REFORM_BEGIN_YEAR 1582 +#define REFORM_END_YEAR 1930 +#define REFORM_BEGIN_JD 2298874 /* ns 1582-01-01 */ +#define REFORM_END_JD 2426355 /* os 1930-12-31 */ + +#ifdef USE_PACK +#define SEC_WIDTH 6 +#define MIN_WIDTH 6 +#define HOUR_WIDTH 5 +#define MDAY_WIDTH 5 +#define MON_WIDTH 4 + +#define SEC_SHIFT 0 +#define MIN_SHIFT SEC_WIDTH +#define HOUR_SHIFT (MIN_WIDTH + SEC_WIDTH) +#define MDAY_SHIFT (HOUR_WIDTH + MIN_WIDTH + SEC_WIDTH) +#define MON_SHIFT (MDAY_WIDTH + HOUR_WIDTH + MIN_WIDTH + SEC_WIDTH) + +#define PK_MASK(x) ((1 << (x)) - 1) + +#define EX_SEC(x) (((x) >> SEC_SHIFT) & PK_MASK(SEC_WIDTH)) +#define EX_MIN(x) (((x) >> MIN_SHIFT) & PK_MASK(MIN_WIDTH)) +#define EX_HOUR(x) (((x) >> HOUR_SHIFT) & PK_MASK(HOUR_WIDTH)) +#define EX_MDAY(x) (((x) >> MDAY_SHIFT) & PK_MASK(MDAY_WIDTH)) +#define EX_MON(x) (((x) >> MON_SHIFT) & PK_MASK(MON_WIDTH)) + +#define PACK5(m,d,h,min,s) \ + (((m) << MON_SHIFT) | ((d) << MDAY_SHIFT) |\ + ((h) << HOUR_SHIFT) | ((min) << MIN_SHIFT) | ((s) << SEC_SHIFT)) + +#define PACK2(m,d) \ + (((m) << MON_SHIFT) | ((d) << MDAY_SHIFT)) +#endif + +#ifdef HAVE_FLOAT_H +#include +#endif + +#if defined(FLT_RADIX) && defined(FLT_MANT_DIG) && FLT_RADIX == 2 && FLT_MANT_DIG > 22 +#define date_sg_t float +#else +#define date_sg_t double +#endif + +/* A set of nth, jd, df and sf denote ajd + 1/2. Each ajd begin at + * noon of GMT (assume equal to UTC). However, this begins at + * midnight. + */ + +struct SimpleDateData +{ + unsigned flags; + VALUE nth; /* not always canonicalized */ + int jd; /* as utc */ + /* df is zero */ + /* sf is zero */ + /* of is zero */ + date_sg_t sg; /* 2298874..2426355 or -/+oo -- at most 22 bits */ + /* decoded as utc=local */ + int year; /* truncated */ +#ifndef USE_PACK + int mon; + int mday; + /* hour is zero */ + /* min is zero */ + /* sec is zero */ +#else + /* packed civil */ + unsigned pc; +#endif +}; + +struct ComplexDateData +{ + unsigned flags; + VALUE nth; /* not always canonicalized */ + int jd; /* as utc */ + int df; /* as utc, in secs */ + VALUE sf; /* in nano secs */ + int of; /* in secs */ + date_sg_t sg; /* 2298874..2426355 or -/+oo -- at most 22 bits */ + /* decoded as local */ + int year; /* truncated */ +#ifndef USE_PACK + int mon; + int mday; + int hour; + int min; + int sec; +#else + /* packed civil */ + unsigned pc; +#endif +}; + +union DateData { + unsigned flags; + struct SimpleDateData s; + struct ComplexDateData c; +}; + +#define get_d1(x)\ + union DateData *dat;\ + TypedData_Get_Struct(x, union DateData, &d_lite_type, dat); + +#define get_d1a(x)\ + union DateData *adat;\ + TypedData_Get_Struct(x, union DateData, &d_lite_type, adat); + +#define get_d1b(x)\ + union DateData *bdat;\ + TypedData_Get_Struct(x, union DateData, &d_lite_type, bdat); + +#define get_d2(x,y)\ + union DateData *adat, *bdat;\ + TypedData_Get_Struct(x, union DateData, &d_lite_type, adat);\ + TypedData_Get_Struct(y, union DateData, &d_lite_type, bdat); + +inline static VALUE +canon(VALUE x) +{ + if (RB_TYPE_P(x, T_RATIONAL)) { + VALUE den = rb_rational_den(x); + if (FIXNUM_P(den) && FIX2LONG(den) == 1) + return rb_rational_num(x); + } + return x; +} + +#ifndef USE_PACK +#define set_to_simple(obj, x, _nth, _jd ,_sg, _year, _mon, _mday, _flags) \ +{\ + RB_OBJ_WRITE((obj), &(x)->nth, canon(_nth)); \ + (x)->jd = _jd;\ + (x)->sg = (date_sg_t)(_sg);\ + (x)->year = _year;\ + (x)->mon = _mon;\ + (x)->mday = _mday;\ + (x)->flags = _flags;\ +} +#else +#define set_to_simple(obj, x, _nth, _jd ,_sg, _year, _mon, _mday, _flags) \ +{\ + RB_OBJ_WRITE((obj), &(x)->nth, canon(_nth)); \ + (x)->jd = _jd;\ + (x)->sg = (date_sg_t)(_sg);\ + (x)->year = _year;\ + (x)->pc = PACK2(_mon, _mday);\ + (x)->flags = _flags;\ +} +#endif + +#ifndef USE_PACK +#define set_to_complex(obj, x, _nth, _jd ,_df, _sf, _of, _sg,\ +_year, _mon, _mday, _hour, _min, _sec, _flags) \ +{\ + RB_OBJ_WRITE((obj), &(x)->nth, canon(_nth));\ + (x)->jd = _jd;\ + (x)->df = _df;\ + RB_OBJ_WRITE((obj), &(x)->sf, canon(_sf));\ + (x)->of = _of;\ + (x)->sg = (date_sg_t)(_sg);\ + (x)->year = _year;\ + (x)->mon = _mon;\ + (x)->mday = _mday;\ + (x)->hour = _hour;\ + (x)->min = _min;\ + (x)->sec = _sec;\ + (x)->flags = _flags;\ +} +#else +#define set_to_complex(obj, x, _nth, _jd ,_df, _sf, _of, _sg,\ +_year, _mon, _mday, _hour, _min, _sec, _flags) \ +{\ + RB_OBJ_WRITE((obj), &(x)->nth, canon(_nth));\ + (x)->jd = _jd;\ + (x)->df = _df;\ + RB_OBJ_WRITE((obj), &(x)->sf, canon(_sf));\ + (x)->of = _of;\ + (x)->sg = (date_sg_t)(_sg);\ + (x)->year = _year;\ + (x)->pc = PACK5(_mon, _mday, _hour, _min, _sec);\ + (x)->flags = _flags;\ +} +#endif + +#ifndef USE_PACK +#define copy_simple_to_complex(obj, x, y) \ +{\ + RB_OBJ_WRITE((obj), &(x)->nth, (y)->nth);\ + (x)->jd = (y)->jd;\ + (x)->df = 0;\ + (x)->sf = INT2FIX(0);\ + (x)->of = 0;\ + (x)->sg = (date_sg_t)((y)->sg);\ + (x)->year = (y)->year;\ + (x)->mon = (y)->mon;\ + (x)->mday = (y)->mday;\ + (x)->hour = 0;\ + (x)->min = 0;\ + (x)->sec = 0;\ + (x)->flags = (y)->flags;\ +} +#else +#define copy_simple_to_complex(obj, x, y) \ +{\ + RB_OBJ_WRITE((obj), &(x)->nth, (y)->nth);\ + (x)->jd = (y)->jd;\ + (x)->df = 0;\ + RB_OBJ_WRITE((obj), &(x)->sf, INT2FIX(0));\ + (x)->of = 0;\ + (x)->sg = (date_sg_t)((y)->sg);\ + (x)->year = (y)->year;\ + (x)->pc = PACK5(EX_MON((y)->pc), EX_MDAY((y)->pc), 0, 0, 0);\ + (x)->flags = (y)->flags;\ +} +#endif + +#ifndef USE_PACK +#define copy_complex_to_simple(obj, x, y) \ +{\ + RB_OBJ_WRITE((obj), &(x)->nth, (y)->nth);\ + (x)->jd = (y)->jd;\ + (x)->sg = (date_sg_t)((y)->sg);\ + (x)->year = (y)->year;\ + (x)->mon = (y)->mon;\ + (x)->mday = (y)->mday;\ + (x)->flags = (y)->flags;\ +} +#else +#define copy_complex_to_simple(obj, x, y) \ +{\ + RB_OBJ_WRITE((obj), &(x)->nth, (y)->nth);\ + (x)->jd = (y)->jd;\ + (x)->sg = (date_sg_t)((y)->sg);\ + (x)->year = (y)->year;\ + (x)->pc = PACK2(EX_MON((y)->pc), EX_MDAY((y)->pc));\ + (x)->flags = (y)->flags;\ +} +#endif + +/* base */ + +static int c_valid_civil_p(int, int, int, double, + int *, int *, int *, int *); + +static int +c_find_fdoy(int y, double sg, int *rjd, int *ns) +{ + int d, rm, rd; + + for (d = 1; d < 31; d++) + if (c_valid_civil_p(y, 1, d, sg, &rm, &rd, rjd, ns)) + return 1; + return 0; +} + +static int +c_find_ldoy(int y, double sg, int *rjd, int *ns) +{ + int i, rm, rd; + + for (i = 0; i < 30; i++) + if (c_valid_civil_p(y, 12, 31 - i, sg, &rm, &rd, rjd, ns)) + return 1; + return 0; +} + +#ifndef NDEBUG +static int +c_find_fdom(int y, int m, double sg, int *rjd, int *ns) +{ + int d, rm, rd; + + for (d = 1; d < 31; d++) + if (c_valid_civil_p(y, m, d, sg, &rm, &rd, rjd, ns)) + return 1; + return 0; +} +#endif + +static int +c_find_ldom(int y, int m, double sg, int *rjd, int *ns) +{ + int i, rm, rd; + + for (i = 0; i < 30; i++) + if (c_valid_civil_p(y, m, 31 - i, sg, &rm, &rd, rjd, ns)) + return 1; + return 0; +} + +static void +c_civil_to_jd(int y, int m, int d, double sg, int *rjd, int *ns) +{ + double a, b, jd; + + if (m <= 2) { + y -= 1; + m += 12; + } + a = floor(y / 100.0); + b = 2 - a + floor(a / 4.0); + jd = floor(365.25 * (y + 4716)) + + floor(30.6001 * (m + 1)) + + d + b - 1524; + if (jd < sg) { + jd -= b; + *ns = 0; + } + else + *ns = 1; + + *rjd = (int)jd; +} + +static void +c_jd_to_civil(int jd, double sg, int *ry, int *rm, int *rdom) +{ + double x, a, b, c, d, e, y, m, dom; + + if (jd < sg) + a = jd; + else { + x = floor((jd - 1867216.25) / 36524.25); + a = jd + 1 + x - floor(x / 4.0); + } + b = a + 1524; + c = floor((b - 122.1) / 365.25); + d = floor(365.25 * c); + e = floor((b - d) / 30.6001); + dom = b - d - floor(30.6001 * e); + if (e <= 13) { + m = e - 1; + y = c - 4716; + } + else { + m = e - 13; + y = c - 4715; + } + + *ry = (int)y; + *rm = (int)m; + *rdom = (int)dom; +} + +static void +c_ordinal_to_jd(int y, int d, double sg, int *rjd, int *ns) +{ + int ns2; + + c_find_fdoy(y, sg, rjd, &ns2); + *rjd += d - 1; + *ns = (*rjd < sg) ? 0 : 1; +} + +static void +c_jd_to_ordinal(int jd, double sg, int *ry, int *rd) +{ + int rm2, rd2, rjd, ns; + + c_jd_to_civil(jd, sg, ry, &rm2, &rd2); + c_find_fdoy(*ry, sg, &rjd, &ns); + *rd = (jd - rjd) + 1; +} + +static void +c_commercial_to_jd(int y, int w, int d, double sg, int *rjd, int *ns) +{ + int rjd2, ns2; + + c_find_fdoy(y, sg, &rjd2, &ns2); + rjd2 += 3; + *rjd = + (rjd2 - MOD((rjd2 - 1) + 1, 7)) + + 7 * (w - 1) + + (d - 1); + *ns = (*rjd < sg) ? 0 : 1; +} + +static void +c_jd_to_commercial(int jd, double sg, int *ry, int *rw, int *rd) +{ + int ry2, rm2, rd2, a, rjd2, ns2; + + c_jd_to_civil(jd - 3, sg, &ry2, &rm2, &rd2); + a = ry2; + c_commercial_to_jd(a + 1, 1, 1, sg, &rjd2, &ns2); + if (jd >= rjd2) + *ry = a + 1; + else { + c_commercial_to_jd(a, 1, 1, sg, &rjd2, &ns2); + *ry = a; + } + *rw = 1 + DIV(jd - rjd2, 7); + *rd = MOD(jd + 1, 7); + if (*rd == 0) + *rd = 7; +} + +static void +c_weeknum_to_jd(int y, int w, int d, int f, double sg, int *rjd, int *ns) +{ + int rjd2, ns2; + + c_find_fdoy(y, sg, &rjd2, &ns2); + rjd2 += 6; + *rjd = (rjd2 - MOD(((rjd2 - f) + 1), 7) - 7) + 7 * w + d; + *ns = (*rjd < sg) ? 0 : 1; +} + +static void +c_jd_to_weeknum(int jd, int f, double sg, int *ry, int *rw, int *rd) +{ + int rm, rd2, rjd, ns, j; + + c_jd_to_civil(jd, sg, ry, &rm, &rd2); + c_find_fdoy(*ry, sg, &rjd, &ns); + rjd += 6; + j = jd - (rjd - MOD((rjd - f) + 1, 7)) + 7; + *rw = (int)DIV(j, 7); + *rd = (int)MOD(j, 7); +} + +#ifndef NDEBUG +static void +c_nth_kday_to_jd(int y, int m, int n, int k, double sg, int *rjd, int *ns) +{ + int rjd2, ns2; + + if (n > 0) { + c_find_fdom(y, m, sg, &rjd2, &ns2); + rjd2 -= 1; + } + else { + c_find_ldom(y, m, sg, &rjd2, &ns2); + rjd2 += 7; + } + *rjd = (rjd2 - MOD((rjd2 - k) + 1, 7)) + 7 * n; + *ns = (*rjd < sg) ? 0 : 1; +} +#endif + +inline static int +c_jd_to_wday(int jd) +{ + return MOD(jd + 1, 7); +} + +#ifndef NDEBUG +static void +c_jd_to_nth_kday(int jd, double sg, int *ry, int *rm, int *rn, int *rk) +{ + int rd, rjd, ns2; + + c_jd_to_civil(jd, sg, ry, rm, &rd); + c_find_fdom(*ry, *rm, sg, &rjd, &ns2); + *rn = DIV(jd - rjd, 7) + 1; + *rk = c_jd_to_wday(jd); +} +#endif + +static int +c_valid_ordinal_p(int y, int d, double sg, + int *rd, int *rjd, int *ns) +{ + int ry2, rd2; + + if (d < 0) { + int rjd2, ns2; + + if (!c_find_ldoy(y, sg, &rjd2, &ns2)) + return 0; + c_jd_to_ordinal(rjd2 + d + 1, sg, &ry2, &rd2); + if (ry2 != y) + return 0; + d = rd2; + } + c_ordinal_to_jd(y, d, sg, rjd, ns); + c_jd_to_ordinal(*rjd, sg, &ry2, &rd2); + if (ry2 != y || rd2 != d) + return 0; + return 1; +} + +static const int monthtab[2][13] = { + { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }, + { 0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 } +}; + +inline static int +c_julian_leap_p(int y) +{ + return MOD(y, 4) == 0; +} + +inline static int +c_gregorian_leap_p(int y) +{ + return (MOD(y, 4) == 0 && y % 100 != 0) || MOD(y, 400) == 0; +} + +static int +c_julian_last_day_of_month(int y, int m) +{ + assert(m >= 1 && m <= 12); + return monthtab[c_julian_leap_p(y) ? 1 : 0][m]; +} + +static int +c_gregorian_last_day_of_month(int y, int m) +{ + assert(m >= 1 && m <= 12); + return monthtab[c_gregorian_leap_p(y) ? 1 : 0][m]; +} + +static int +c_valid_julian_p(int y, int m, int d, int *rm, int *rd) +{ + int last; + + if (m < 0) + m += 13; + if (m < 1 || m > 12) + return 0; + last = c_julian_last_day_of_month(y, m); + if (d < 0) + d = last + d + 1; + if (d < 1 || d > last) + return 0; + *rm = m; + *rd = d; + return 1; +} + +static int +c_valid_gregorian_p(int y, int m, int d, int *rm, int *rd) +{ + int last; + + if (m < 0) + m += 13; + if (m < 1 || m > 12) + return 0; + last = c_gregorian_last_day_of_month(y, m); + if (d < 0) + d = last + d + 1; + if (d < 1 || d > last) + return 0; + *rm = m; + *rd = d; + return 1; +} + +static int +c_valid_civil_p(int y, int m, int d, double sg, + int *rm, int *rd, int *rjd, int *ns) +{ + int ry; + + if (m < 0) + m += 13; + if (d < 0) { + if (!c_find_ldom(y, m, sg, rjd, ns)) + return 0; + c_jd_to_civil(*rjd + d + 1, sg, &ry, rm, rd); + if (ry != y || *rm != m) + return 0; + d = *rd; + } + c_civil_to_jd(y, m, d, sg, rjd, ns); + c_jd_to_civil(*rjd, sg, &ry, rm, rd); + if (ry != y || *rm != m || *rd != d) + return 0; + return 1; +} + +static int +c_valid_commercial_p(int y, int w, int d, double sg, + int *rw, int *rd, int *rjd, int *ns) +{ + int ns2, ry2, rw2, rd2; + + if (d < 0) + d += 8; + if (w < 0) { + int rjd2; + + c_commercial_to_jd(y + 1, 1, 1, sg, &rjd2, &ns2); + c_jd_to_commercial(rjd2 + w * 7, sg, &ry2, &rw2, &rd2); + if (ry2 != y) + return 0; + w = rw2; + } + c_commercial_to_jd(y, w, d, sg, rjd, ns); + c_jd_to_commercial(*rjd, sg, &ry2, rw, rd); + if (y != ry2 || w != *rw || d != *rd) + return 0; + return 1; +} + +static int +c_valid_weeknum_p(int y, int w, int d, int f, double sg, + int *rw, int *rd, int *rjd, int *ns) +{ + int ns2, ry2, rw2, rd2; + + if (d < 0) + d += 7; + if (w < 0) { + int rjd2; + + c_weeknum_to_jd(y + 1, 1, f, f, sg, &rjd2, &ns2); + c_jd_to_weeknum(rjd2 + w * 7, f, sg, &ry2, &rw2, &rd2); + if (ry2 != y) + return 0; + w = rw2; + } + c_weeknum_to_jd(y, w, d, f, sg, rjd, ns); + c_jd_to_weeknum(*rjd, f, sg, &ry2, rw, rd); + if (y != ry2 || w != *rw || d != *rd) + return 0; + return 1; +} + +#ifndef NDEBUG +static int +c_valid_nth_kday_p(int y, int m, int n, int k, double sg, + int *rm, int *rn, int *rk, int *rjd, int *ns) +{ + int ns2, ry2, rm2, rn2, rk2; + + if (k < 0) + k += 7; + if (n < 0) { + int t, ny, nm, rjd2; + + t = y * 12 + m; + ny = DIV(t, 12); + nm = MOD(t, 12) + 1; + + c_nth_kday_to_jd(ny, nm, 1, k, sg, &rjd2, &ns2); + c_jd_to_nth_kday(rjd2 + n * 7, sg, &ry2, &rm2, &rn2, &rk2); + if (ry2 != y || rm2 != m) + return 0; + n = rn2; + } + c_nth_kday_to_jd(y, m, n, k, sg, rjd, ns); + c_jd_to_nth_kday(*rjd, sg, &ry2, rm, rn, rk); + if (y != ry2 || m != *rm || n != *rn || k != *rk) + return 0; + return 1; +} +#endif + +static int +c_valid_time_p(int h, int min, int s, int *rh, int *rmin, int *rs) +{ + if (h < 0) + h += 24; + if (min < 0) + min += 60; + if (s < 0) + s += 60; + *rh = h; + *rmin = min; + *rs = s; + return !(h < 0 || h > 24 || + min < 0 || min > 59 || + s < 0 || s > 59 || + (h == 24 && (min > 0 || s > 0))); +} + +inline static int +c_valid_start_p(double sg) +{ + if (isnan(sg)) + return 0; + if (isinf(sg)) + return 1; + if (sg < REFORM_BEGIN_JD || sg > REFORM_END_JD) + return 0; + return 1; +} + +inline static int +df_local_to_utc(int df, int of) +{ + df -= of; + if (df < 0) + df += DAY_IN_SECONDS; + else if (df >= DAY_IN_SECONDS) + df -= DAY_IN_SECONDS; + return df; +} + +inline static int +df_utc_to_local(int df, int of) +{ + df += of; + if (df < 0) + df += DAY_IN_SECONDS; + else if (df >= DAY_IN_SECONDS) + df -= DAY_IN_SECONDS; + return df; +} + +inline static int +jd_local_to_utc(int jd, int df, int of) +{ + df -= of; + if (df < 0) + jd -= 1; + else if (df >= DAY_IN_SECONDS) + jd += 1; + return jd; +} + +inline static int +jd_utc_to_local(int jd, int df, int of) +{ + df += of; + if (df < 0) + jd -= 1; + else if (df >= DAY_IN_SECONDS) + jd += 1; + return jd; +} + +inline static int +time_to_df(int h, int min, int s) +{ + return h * HOUR_IN_SECONDS + min * MINUTE_IN_SECONDS + s; +} + +inline static void +df_to_time(int df, int *h, int *min, int *s) +{ + *h = df / HOUR_IN_SECONDS; + df %= HOUR_IN_SECONDS; + *min = df / MINUTE_IN_SECONDS; + *s = df % MINUTE_IN_SECONDS; +} + +static VALUE +sec_to_day(VALUE s) +{ + if (FIXNUM_P(s)) + return rb_rational_new2(s, INT2FIX(DAY_IN_SECONDS)); + return f_quo(s, INT2FIX(DAY_IN_SECONDS)); +} + +inline static VALUE +isec_to_day(int s) +{ + return sec_to_day(INT2FIX(s)); +} + +static VALUE +ns_to_day(VALUE n) +{ + if (FIXNUM_P(n)) + return rb_rational_new2(n, day_in_nanoseconds); + return f_quo(n, day_in_nanoseconds); +} + +#ifndef NDEBUG +static VALUE +ms_to_sec(VALUE m) +{ + if (FIXNUM_P(m)) + return rb_rational_new2(m, INT2FIX(SECOND_IN_MILLISECONDS)); + return f_quo(m, INT2FIX(SECOND_IN_MILLISECONDS)); +} +#endif + +static VALUE +ns_to_sec(VALUE n) +{ + if (FIXNUM_P(n)) + return rb_rational_new2(n, INT2FIX(SECOND_IN_NANOSECONDS)); + return f_quo(n, INT2FIX(SECOND_IN_NANOSECONDS)); +} + +#ifndef NDEBUG +inline static VALUE +ins_to_day(int n) +{ + return ns_to_day(INT2FIX(n)); +} +#endif + +static int +safe_mul_p(VALUE x, long m) +{ + long ix; + + if (!FIXNUM_P(x)) + return 0; + ix = FIX2LONG(x); + if (ix < 0) { + if (ix <= (FIXNUM_MIN / m)) + return 0; + } + else { + if (ix >= (FIXNUM_MAX / m)) + return 0; + } + return 1; +} + +static VALUE +day_to_sec(VALUE d) +{ + if (safe_mul_p(d, DAY_IN_SECONDS)) + return LONG2FIX(FIX2LONG(d) * DAY_IN_SECONDS); + return f_mul(d, INT2FIX(DAY_IN_SECONDS)); +} + +#ifndef NDEBUG +static VALUE +day_to_ns(VALUE d) +{ + return f_mul(d, day_in_nanoseconds); +} +#endif + +static VALUE +sec_to_ms(VALUE s) +{ + if (safe_mul_p(s, SECOND_IN_MILLISECONDS)) + return LONG2FIX(FIX2LONG(s) * SECOND_IN_MILLISECONDS); + return f_mul(s, INT2FIX(SECOND_IN_MILLISECONDS)); +} + +static VALUE +sec_to_ns(VALUE s) +{ + if (safe_mul_p(s, SECOND_IN_NANOSECONDS)) + return LONG2FIX(FIX2LONG(s) * SECOND_IN_NANOSECONDS); + return f_mul(s, INT2FIX(SECOND_IN_NANOSECONDS)); +} + +#ifndef NDEBUG +static VALUE +isec_to_ns(int s) +{ + return sec_to_ns(INT2FIX(s)); +} +#endif + +static VALUE +div_day(VALUE d, VALUE *f) +{ + if (f) + *f = f_mod(d, INT2FIX(1)); + return f_floor(d); +} + +static VALUE +div_df(VALUE d, VALUE *f) +{ + VALUE s = day_to_sec(d); + + if (f) + *f = f_mod(s, INT2FIX(1)); + return f_floor(s); +} + +#ifndef NDEBUG +static VALUE +div_sf(VALUE s, VALUE *f) +{ + VALUE n = sec_to_ns(s); + + if (f) + *f = f_mod(n, INT2FIX(1)); + return f_floor(n); +} +#endif + +static void +decode_day(VALUE d, VALUE *jd, VALUE *df, VALUE *sf) +{ + VALUE f; + + *jd = div_day(d, &f); + *df = div_df(f, &f); + *sf = sec_to_ns(f); +} + +inline static double +s_virtual_sg(union DateData *x) +{ + if (isinf(x->s.sg)) + return x->s.sg; + if (f_zero_p(x->s.nth)) + return x->s.sg; + else if (f_negative_p(x->s.nth)) + return positive_inf; + return negative_inf; +} + +inline static double +c_virtual_sg(union DateData *x) +{ + if (isinf(x->c.sg)) + return x->c.sg; + if (f_zero_p(x->c.nth)) + return x->c.sg; + else if (f_negative_p(x->c.nth)) + return positive_inf; + return negative_inf; +} + +inline static double +m_virtual_sg(union DateData *x) +{ + if (simple_dat_p(x)) + return s_virtual_sg(x); + else + return c_virtual_sg(x); +} + +#define canonicalize_jd(_nth, _jd) \ +{\ + if (_jd < 0) {\ + _nth = f_sub(_nth, INT2FIX(1));\ + _jd += CM_PERIOD;\ + }\ + if (_jd >= CM_PERIOD) {\ + _nth = f_add(_nth, INT2FIX(1));\ + _jd -= CM_PERIOD;\ + }\ +} + +inline static void +canonicalize_s_jd(VALUE obj, union DateData *x) +{ + int j = x->s.jd; + VALUE nth = x->s.nth; + assert(have_jd_p(x)); + canonicalize_jd(nth, x->s.jd); + RB_OBJ_WRITE(obj, &x->s.nth, nth); + if (x->s.jd != j) + x->flags &= ~HAVE_CIVIL; +} + +inline static void +get_s_jd(union DateData *x) +{ + assert(simple_dat_p(x)); + if (!have_jd_p(x)) { + int jd, ns; + + assert(have_civil_p(x)); +#ifndef USE_PACK + c_civil_to_jd(x->s.year, x->s.mon, x->s.mday, + s_virtual_sg(x), &jd, &ns); +#else + c_civil_to_jd(x->s.year, EX_MON(x->s.pc), EX_MDAY(x->s.pc), + s_virtual_sg(x), &jd, &ns); +#endif + x->s.jd = jd; + x->s.flags |= HAVE_JD; + } +} + +inline static void +get_s_civil(union DateData *x) +{ + assert(simple_dat_p(x)); + if (!have_civil_p(x)) { + int y, m, d; + + assert(have_jd_p(x)); + c_jd_to_civil(x->s.jd, s_virtual_sg(x), &y, &m, &d); + x->s.year = y; +#ifndef USE_PACK + x->s.mon = m; + x->s.mday = d; +#else + x->s.pc = PACK2(m, d); +#endif + x->s.flags |= HAVE_CIVIL; + } +} + +inline static void +get_c_df(union DateData *x) +{ + assert(complex_dat_p(x)); + if (!have_df_p(x)) { + assert(have_time_p(x)); +#ifndef USE_PACK + x->c.df = df_local_to_utc(time_to_df(x->c.hour, x->c.min, x->c.sec), + x->c.of); +#else + x->c.df = df_local_to_utc(time_to_df(EX_HOUR(x->c.pc), + EX_MIN(x->c.pc), + EX_SEC(x->c.pc)), + x->c.of); +#endif + x->c.flags |= HAVE_DF; + } +} + +inline static void +get_c_time(union DateData *x) +{ + assert(complex_dat_p(x)); + if (!have_time_p(x)) { +#ifndef USE_PACK + int r; + assert(have_df_p(x)); + r = df_utc_to_local(x->c.df, x->c.of); + df_to_time(r, &x->c.hour, &x->c.min, &x->c.sec); + x->c.flags |= HAVE_TIME; +#else + int r, m, d, h, min, s; + + assert(have_df_p(x)); + m = EX_MON(x->c.pc); + d = EX_MDAY(x->c.pc); + r = df_utc_to_local(x->c.df, x->c.of); + df_to_time(r, &h, &min, &s); + x->c.pc = PACK5(m, d, h, min, s); + x->c.flags |= HAVE_TIME; +#endif + } +} + +inline static void +canonicalize_c_jd(VALUE obj, union DateData *x) +{ + int j = x->c.jd; + VALUE nth = x->c.nth; + assert(have_jd_p(x)); + canonicalize_jd(nth, x->c.jd); + RB_OBJ_WRITE(obj, &x->c.nth, nth); + if (x->c.jd != j) + x->flags &= ~HAVE_CIVIL; +} + +inline static void +get_c_jd(union DateData *x) +{ + assert(complex_dat_p(x)); + if (!have_jd_p(x)) { + int jd, ns; + + assert(have_civil_p(x)); +#ifndef USE_PACK + c_civil_to_jd(x->c.year, x->c.mon, x->c.mday, + c_virtual_sg(x), &jd, &ns); +#else + c_civil_to_jd(x->c.year, EX_MON(x->c.pc), EX_MDAY(x->c.pc), + c_virtual_sg(x), &jd, &ns); +#endif + + get_c_time(x); +#ifndef USE_PACK + x->c.jd = jd_local_to_utc(jd, + time_to_df(x->c.hour, x->c.min, x->c.sec), + x->c.of); +#else + x->c.jd = jd_local_to_utc(jd, + time_to_df(EX_HOUR(x->c.pc), + EX_MIN(x->c.pc), + EX_SEC(x->c.pc)), + x->c.of); +#endif + x->c.flags |= HAVE_JD; + } +} + +inline static void +get_c_civil(union DateData *x) +{ + assert(complex_dat_p(x)); + if (!have_civil_p(x)) { +#ifndef USE_PACK + int jd, y, m, d; +#else + int jd, y, m, d, h, min, s; +#endif + + assert(have_jd_p(x)); + get_c_df(x); + jd = jd_utc_to_local(x->c.jd, x->c.df, x->c.of); + c_jd_to_civil(jd, c_virtual_sg(x), &y, &m, &d); + x->c.year = y; +#ifndef USE_PACK + x->c.mon = m; + x->c.mday = d; +#else + h = EX_HOUR(x->c.pc); + min = EX_MIN(x->c.pc); + s = EX_SEC(x->c.pc); + x->c.pc = PACK5(m, d, h, min, s); +#endif + x->c.flags |= HAVE_CIVIL; + } +} + +inline static int +local_jd(union DateData *x) +{ + assert(complex_dat_p(x)); + assert(have_jd_p(x)); + assert(have_df_p(x)); + return jd_utc_to_local(x->c.jd, x->c.df, x->c.of); +} + +inline static int +local_df(union DateData *x) +{ + assert(complex_dat_p(x)); + assert(have_df_p(x)); + return df_utc_to_local(x->c.df, x->c.of); +} + +static void +decode_year(VALUE y, double style, + VALUE *nth, int *ry) +{ + int period; + VALUE t; + + period = (style < 0) ? + CM_PERIOD_GCY : + CM_PERIOD_JCY; + if (FIXNUM_P(y)) { + long iy, it, inth; + + iy = FIX2LONG(y); + if (iy >= (FIXNUM_MAX - 4712)) + goto big; + it = iy + 4712; /* shift */ + inth = DIV(it, ((long)period)); + *nth = LONG2FIX(inth); + if (inth) + it = MOD(it, ((long)period)); + *ry = (int)it - 4712; /* unshift */ + return; + } + big: + t = f_add(y, INT2FIX(4712)); /* shift */ + *nth = f_idiv(t, INT2FIX(period)); + if (f_nonzero_p(*nth)) + t = f_mod(t, INT2FIX(period)); + *ry = FIX2INT(t) - 4712; /* unshift */ +} + +static void +encode_year(VALUE nth, int y, double style, + VALUE *ry) +{ + int period; + VALUE t; + + period = (style < 0) ? + CM_PERIOD_GCY : + CM_PERIOD_JCY; + if (f_zero_p(nth)) + *ry = INT2FIX(y); + else { + t = f_mul(INT2FIX(period), nth); + t = f_add(t, INT2FIX(y)); + *ry = t; + } +} + +static void +decode_jd(VALUE jd, VALUE *nth, int *rjd) +{ + assert(FIXNUM_P(jd) || RB_TYPE_P(jd, T_BIGNUM)); + *nth = f_idiv(jd, INT2FIX(CM_PERIOD)); + if (f_zero_p(*nth)) { + assert(FIXNUM_P(jd)); + *rjd = FIX2INT(jd); + return; + } + *rjd = FIX2INT(f_mod(jd, INT2FIX(CM_PERIOD))); +} + +static void +encode_jd(VALUE nth, int jd, VALUE *rjd) +{ + if (f_zero_p(nth)) { + *rjd = INT2FIX(jd); + return; + } + *rjd = f_add(f_mul(INT2FIX(CM_PERIOD), nth), INT2FIX(jd)); +} + +inline static double +guess_style(VALUE y, double sg) /* -/+oo or zero */ +{ + double style = 0; + + if (isinf(sg)) + style = sg; + else if (!FIXNUM_P(y)) + style = f_positive_p(y) ? negative_inf : positive_inf; + else { + long iy = FIX2LONG(y); + + assert(FIXNUM_P(y)); + if (iy < REFORM_BEGIN_YEAR) + style = positive_inf; + else if (iy > REFORM_END_YEAR) + style = negative_inf; + } + return style; +} + +inline static void +m_canonicalize_jd(VALUE obj, union DateData *x) +{ + if (simple_dat_p(x)) { + get_s_jd(x); + canonicalize_s_jd(obj, x); + } + else { + get_c_jd(x); + canonicalize_c_jd(obj, x); + } +} + +inline static VALUE +m_nth(union DateData *x) +{ + if (simple_dat_p(x)) + return x->s.nth; + else { + get_c_civil(x); + return x->c.nth; + } +} + +inline static int +m_jd(union DateData *x) +{ + if (simple_dat_p(x)) { + get_s_jd(x); + return x->s.jd; + } + else { + get_c_jd(x); + return x->c.jd; + } +} + +static VALUE +m_real_jd(union DateData *x) +{ + VALUE nth, rjd; + int jd; + + nth = m_nth(x); + jd = m_jd(x); + + encode_jd(nth, jd, &rjd); + return rjd; +} + +static int +m_local_jd(union DateData *x) +{ + if (simple_dat_p(x)) { + get_s_jd(x); + return x->s.jd; + } + else { + get_c_jd(x); + get_c_df(x); + return local_jd(x); + } +} + +static VALUE +m_real_local_jd(union DateData *x) +{ + VALUE nth, rjd; + int jd; + + nth = m_nth(x); + jd = m_local_jd(x); + + encode_jd(nth, jd, &rjd); + return rjd; +} + +inline static int +m_df(union DateData *x) +{ + if (simple_dat_p(x)) + return 0; + else { + get_c_df(x); + return x->c.df; + } +} + +#ifndef NDEBUG +static VALUE +m_df_in_day(union DateData *x) +{ + return isec_to_day(m_df(x)); +} +#endif + +static int +m_local_df(union DateData *x) +{ + if (simple_dat_p(x)) + return 0; + else { + get_c_df(x); + return local_df(x); + } +} + +#ifndef NDEBUG +static VALUE +m_local_df_in_day(union DateData *x) +{ + return isec_to_day(m_local_df(x)); +} +#endif + +inline static VALUE +m_sf(union DateData *x) +{ + if (simple_dat_p(x)) + return INT2FIX(0); + else + return x->c.sf; +} + +#ifndef NDEBUG +static VALUE +m_sf_in_day(union DateData *x) +{ + return ns_to_day(m_sf(x)); +} +#endif + +static VALUE +m_sf_in_sec(union DateData *x) +{ + return ns_to_sec(m_sf(x)); +} + +static VALUE +m_fr(union DateData *x) +{ + if (simple_dat_p(x)) + return INT2FIX(0); + else { + int df; + VALUE sf, fr; + + df = m_local_df(x); + sf = m_sf(x); + fr = isec_to_day(df); + if (f_nonzero_p(sf)) + fr = f_add(fr, ns_to_day(sf)); + return fr; + } +} + +#define HALF_DAYS_IN_SECONDS (DAY_IN_SECONDS / 2) + +static VALUE +m_ajd(union DateData *x) +{ + VALUE r, sf; + int df; + + if (simple_dat_p(x)) { + r = m_real_jd(x); + if (FIXNUM_P(r) && FIX2LONG(r) <= (FIXNUM_MAX / 2)) { + long ir = FIX2LONG(r); + ir = ir * 2 - 1; + return rb_rational_new2(LONG2FIX(ir), INT2FIX(2)); + } + else + return rb_rational_new2(f_sub(f_mul(r, + INT2FIX(2)), + INT2FIX(1)), + INT2FIX(2)); + } + + r = m_real_jd(x); + df = m_df(x); + df -= HALF_DAYS_IN_SECONDS; + if (df) + r = f_add(r, isec_to_day(df)); + sf = m_sf(x); + if (f_nonzero_p(sf)) + r = f_add(r, ns_to_day(sf)); + + return r; +} + +static VALUE +m_amjd(union DateData *x) +{ + VALUE r, sf; + int df; + + r = m_real_jd(x); + if (FIXNUM_P(r) && FIX2LONG(r) >= (FIXNUM_MIN + 2400001)) { + long ir = FIX2LONG(r); + ir -= 2400001; + r = rb_rational_new1(LONG2FIX(ir)); + } + else + r = rb_rational_new1(f_sub(m_real_jd(x), + INT2FIX(2400001))); + + if (simple_dat_p(x)) + return r; + + df = m_df(x); + if (df) + r = f_add(r, isec_to_day(df)); + sf = m_sf(x); + if (f_nonzero_p(sf)) + r = f_add(r, ns_to_day(sf)); + + return r; +} + +inline static int +m_of(union DateData *x) +{ + if (simple_dat_p(x)) + return 0; + else { + get_c_jd(x); + return x->c.of; + } +} + +static VALUE +m_of_in_day(union DateData *x) +{ + return isec_to_day(m_of(x)); +} + +inline static double +m_sg(union DateData *x) +{ + if (simple_dat_p(x)) + return x->s.sg; + else { + get_c_jd(x); + return x->c.sg; + } +} + +static int +m_julian_p(union DateData *x) +{ + int jd; + double sg; + + if (simple_dat_p(x)) { + get_s_jd(x); + jd = x->s.jd; + sg = s_virtual_sg(x); + } + else { + get_c_jd(x); + jd = x->c.jd; + sg = c_virtual_sg(x); + } + if (isinf(sg)) + return sg == positive_inf; + return jd < sg; +} + +inline static int +m_gregorian_p(union DateData *x) +{ + return !m_julian_p(x); +} + +inline static int +m_proleptic_julian_p(union DateData *x) +{ + double sg; + + sg = m_sg(x); + if (isinf(sg) && sg > 0) + return 1; + return 0; +} + +inline static int +m_proleptic_gregorian_p(union DateData *x) +{ + double sg; + + sg = m_sg(x); + if (isinf(sg) && sg < 0) + return 1; + return 0; +} + +inline static int +m_year(union DateData *x) +{ + if (simple_dat_p(x)) { + get_s_civil(x); + return x->s.year; + } + else { + get_c_civil(x); + return x->c.year; + } +} + +static VALUE +m_real_year(union DateData *x) +{ + VALUE nth, ry; + int year; + + nth = m_nth(x); + year = m_year(x); + + if (f_zero_p(nth)) + return INT2FIX(year); + + encode_year(nth, year, + m_gregorian_p(x) ? -1 : +1, + &ry); + return ry; +} + +inline static int +m_mon(union DateData *x) +{ + if (simple_dat_p(x)) { + get_s_civil(x); +#ifndef USE_PACK + return x->s.mon; +#else + return EX_MON(x->s.pc); +#endif + } + else { + get_c_civil(x); +#ifndef USE_PACK + return x->c.mon; +#else + return EX_MON(x->c.pc); +#endif + } +} + +inline static int +m_mday(union DateData *x) +{ + if (simple_dat_p(x)) { + get_s_civil(x); +#ifndef USE_PACK + return x->s.mday; +#else + return EX_MDAY(x->s.pc); +#endif + } + else { + get_c_civil(x); +#ifndef USE_PACK + return x->c.mday; +#else + return EX_MDAY(x->c.pc); +#endif + } +} + +static const int yeartab[2][13] = { + { 0, 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 }, + { 0, 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335 } +}; + +static int +c_julian_to_yday(int y, int m, int d) +{ + assert(m >= 1 && m <= 12); + return yeartab[c_julian_leap_p(y) ? 1 : 0][m] + d; +} + +static int +c_gregorian_to_yday(int y, int m, int d) +{ + assert(m >= 1 && m <= 12); + return yeartab[c_gregorian_leap_p(y) ? 1 : 0][m] + d; +} + +static int +m_yday(union DateData *x) +{ + int jd, ry, rd; + double sg; + + jd = m_local_jd(x); + sg = m_virtual_sg(x); /* !=m_sg() */ + + if (m_proleptic_gregorian_p(x) || + (jd - sg) > 366) + return c_gregorian_to_yday(m_year(x), m_mon(x), m_mday(x)); + if (m_proleptic_julian_p(x)) + return c_julian_to_yday(m_year(x), m_mon(x), m_mday(x)); + c_jd_to_ordinal(jd, sg, &ry, &rd); + return rd; +} + +static int +m_wday(union DateData *x) +{ + return c_jd_to_wday(m_local_jd(x)); +} + +static int +m_cwyear(union DateData *x) +{ + int ry, rw, rd; + + c_jd_to_commercial(m_local_jd(x), m_virtual_sg(x), /* !=m_sg() */ + &ry, &rw, &rd); + return ry; +} + +static VALUE +m_real_cwyear(union DateData *x) +{ + VALUE nth, ry; + int year; + + nth = m_nth(x); + year = m_cwyear(x); + + if (f_zero_p(nth)) + return INT2FIX(year); + + encode_year(nth, year, + m_gregorian_p(x) ? -1 : +1, + &ry); + return ry; +} + +static int +m_cweek(union DateData *x) +{ + int ry, rw, rd; + + c_jd_to_commercial(m_local_jd(x), m_virtual_sg(x), /* !=m_sg() */ + &ry, &rw, &rd); + return rw; +} + +static int +m_cwday(union DateData *x) +{ + int w; + + w = m_wday(x); + if (w == 0) + w = 7; + return w; +} + +static int +m_wnumx(union DateData *x, int f) +{ + int ry, rw, rd; + + c_jd_to_weeknum(m_local_jd(x), f, m_virtual_sg(x), /* !=m_sg() */ + &ry, &rw, &rd); + return rw; +} + +static int +m_wnum0(union DateData *x) +{ + return m_wnumx(x, 0); +} + +static int +m_wnum1(union DateData *x) +{ + return m_wnumx(x, 1); +} + +inline static int +m_hour(union DateData *x) +{ + if (simple_dat_p(x)) + return 0; + else { + get_c_time(x); +#ifndef USE_PACK + return x->c.hour; +#else + return EX_HOUR(x->c.pc); +#endif + } +} + +inline static int +m_min(union DateData *x) +{ + if (simple_dat_p(x)) + return 0; + else { + get_c_time(x); +#ifndef USE_PACK + return x->c.min; +#else + return EX_MIN(x->c.pc); +#endif + } +} + +inline static int +m_sec(union DateData *x) +{ + if (simple_dat_p(x)) + return 0; + else { + get_c_time(x); +#ifndef USE_PACK + return x->c.sec; +#else + return EX_SEC(x->c.pc); +#endif + } +} + +#define decode_offset(of,s,h,m)\ +{\ + int a;\ + s = (of < 0) ? '-' : '+';\ + a = (of < 0) ? -of : of;\ + h = a / HOUR_IN_SECONDS;\ + m = a % HOUR_IN_SECONDS / MINUTE_IN_SECONDS;\ +} + +static VALUE +of2str(int of) +{ + int s, h, m; + + decode_offset(of, s, h, m); + return rb_enc_sprintf(rb_usascii_encoding(), "%c%02d:%02d", s, h, m); +} + +static VALUE +m_zone(union DateData *x) +{ + if (simple_dat_p(x)) + return rb_usascii_str_new2("+00:00"); + return of2str(m_of(x)); +} + +inline static VALUE +f_kind_of_p(VALUE x, VALUE c) +{ + return rb_obj_is_kind_of(x, c); +} + +inline static VALUE +k_date_p(VALUE x) +{ + return f_kind_of_p(x, cDate); +} + +inline static VALUE +k_numeric_p(VALUE x) +{ + return f_kind_of_p(x, rb_cNumeric); +} + +inline static VALUE +k_rational_p(VALUE x) +{ + return f_kind_of_p(x, rb_cRational); +} + +#ifndef NDEBUG +static void +civil_to_jd(VALUE y, int m, int d, double sg, + VALUE *nth, int *ry, + int *rjd, + int *ns) +{ + double style = guess_style(y, sg); + + if (style == 0) { + int jd; + + c_civil_to_jd(FIX2INT(y), m, d, sg, &jd, ns); + decode_jd(INT2FIX(jd), nth, rjd); + if (f_zero_p(*nth)) + *ry = FIX2INT(y); + else { + VALUE nth2; + decode_year(y, *ns ? -1 : +1, &nth2, ry); + } + } + else { + decode_year(y, style, nth, ry); + c_civil_to_jd(*ry, m, d, style, rjd, ns); + } +} + +static void +jd_to_civil(VALUE jd, double sg, + VALUE *nth, int *rjd, + int *ry, int *rm, int *rd) +{ + decode_jd(jd, nth, rjd); + c_jd_to_civil(*rjd, sg, ry, rm, rd); +} + +static void +ordinal_to_jd(VALUE y, int d, double sg, + VALUE *nth, int *ry, + int *rjd, + int *ns) +{ + double style = guess_style(y, sg); + + if (style == 0) { + int jd; + + c_ordinal_to_jd(FIX2INT(y), d, sg, &jd, ns); + decode_jd(INT2FIX(jd), nth, rjd); + if (f_zero_p(*nth)) + *ry = FIX2INT(y); + else { + VALUE nth2; + decode_year(y, *ns ? -1 : +1, &nth2, ry); + } + } + else { + decode_year(y, style, nth, ry); + c_ordinal_to_jd(*ry, d, style, rjd, ns); + } +} + +static void +jd_to_ordinal(VALUE jd, double sg, + VALUE *nth, int *rjd, + int *ry, int *rd) +{ + decode_jd(jd, nth, rjd); + c_jd_to_ordinal(*rjd, sg, ry, rd); +} + +static void +commercial_to_jd(VALUE y, int w, int d, double sg, + VALUE *nth, int *ry, + int *rjd, + int *ns) +{ + double style = guess_style(y, sg); + + if (style == 0) { + int jd; + + c_commercial_to_jd(FIX2INT(y), w, d, sg, &jd, ns); + decode_jd(INT2FIX(jd), nth, rjd); + if (f_zero_p(*nth)) + *ry = FIX2INT(y); + else { + VALUE nth2; + decode_year(y, *ns ? -1 : +1, &nth2, ry); + } + } + else { + decode_year(y, style, nth, ry); + c_commercial_to_jd(*ry, w, d, style, rjd, ns); + } +} + +static void +jd_to_commercial(VALUE jd, double sg, + VALUE *nth, int *rjd, + int *ry, int *rw, int *rd) +{ + decode_jd(jd, nth, rjd); + c_jd_to_commercial(*rjd, sg, ry, rw, rd); +} + +static void +weeknum_to_jd(VALUE y, int w, int d, int f, double sg, + VALUE *nth, int *ry, + int *rjd, + int *ns) +{ + double style = guess_style(y, sg); + + if (style == 0) { + int jd; + + c_weeknum_to_jd(FIX2INT(y), w, d, f, sg, &jd, ns); + decode_jd(INT2FIX(jd), nth, rjd); + if (f_zero_p(*nth)) + *ry = FIX2INT(y); + else { + VALUE nth2; + decode_year(y, *ns ? -1 : +1, &nth2, ry); + } + } + else { + decode_year(y, style, nth, ry); + c_weeknum_to_jd(*ry, w, d, f, style, rjd, ns); + } +} + +static void +jd_to_weeknum(VALUE jd, int f, double sg, + VALUE *nth, int *rjd, + int *ry, int *rw, int *rd) +{ + decode_jd(jd, nth, rjd); + c_jd_to_weeknum(*rjd, f, sg, ry, rw, rd); +} + +static void +nth_kday_to_jd(VALUE y, int m, int n, int k, double sg, + VALUE *nth, int *ry, + int *rjd, + int *ns) +{ + double style = guess_style(y, sg); + + if (style == 0) { + int jd; + + c_nth_kday_to_jd(FIX2INT(y), m, n, k, sg, &jd, ns); + decode_jd(INT2FIX(jd), nth, rjd); + if (f_zero_p(*nth)) + *ry = FIX2INT(y); + else { + VALUE nth2; + decode_year(y, *ns ? -1 : +1, &nth2, ry); + } + } + else { + decode_year(y, style, nth, ry); + c_nth_kday_to_jd(*ry, m, n, k, style, rjd, ns); + } +} + +static void +jd_to_nth_kday(VALUE jd, double sg, + VALUE *nth, int *rjd, + int *ry, int *rm, int *rn, int *rk) +{ + decode_jd(jd, nth, rjd); + c_jd_to_nth_kday(*rjd, sg, ry, rm, rn, rk); +} +#endif + +static int +valid_ordinal_p(VALUE y, int d, double sg, + VALUE *nth, int *ry, + int *rd, int *rjd, + int *ns) +{ + double style = guess_style(y, sg); + int r; + + if (style == 0) { + int jd; + + r = c_valid_ordinal_p(FIX2INT(y), d, sg, rd, &jd, ns); + if (!r) + return 0; + decode_jd(INT2FIX(jd), nth, rjd); + if (f_zero_p(*nth)) + *ry = FIX2INT(y); + else { + VALUE nth2; + decode_year(y, *ns ? -1 : +1, &nth2, ry); + } + } + else { + decode_year(y, style, nth, ry); + r = c_valid_ordinal_p(*ry, d, style, rd, rjd, ns); + } + return r; +} + +static int +valid_gregorian_p(VALUE y, int m, int d, + VALUE *nth, int *ry, + int *rm, int *rd) +{ + decode_year(y, -1, nth, ry); + return c_valid_gregorian_p(*ry, m, d, rm, rd); +} + +static int +valid_civil_p(VALUE y, int m, int d, double sg, + VALUE *nth, int *ry, + int *rm, int *rd, int *rjd, + int *ns) +{ + double style = guess_style(y, sg); + int r; + + if (style == 0) { + int jd; + + r = c_valid_civil_p(FIX2INT(y), m, d, sg, rm, rd, &jd, ns); + if (!r) + return 0; + decode_jd(INT2FIX(jd), nth, rjd); + if (f_zero_p(*nth)) + *ry = FIX2INT(y); + else { + VALUE nth2; + decode_year(y, *ns ? -1 : +1, &nth2, ry); + } + } + else { + decode_year(y, style, nth, ry); + if (style < 0) + r = c_valid_gregorian_p(*ry, m, d, rm, rd); + else + r = c_valid_julian_p(*ry, m, d, rm, rd); + if (!r) + return 0; + c_civil_to_jd(*ry, *rm, *rd, style, rjd, ns); + } + return r; +} + +static int +valid_commercial_p(VALUE y, int w, int d, double sg, + VALUE *nth, int *ry, + int *rw, int *rd, int *rjd, + int *ns) +{ + double style = guess_style(y, sg); + int r; + + if (style == 0) { + int jd; + + r = c_valid_commercial_p(FIX2INT(y), w, d, sg, rw, rd, &jd, ns); + if (!r) + return 0; + decode_jd(INT2FIX(jd), nth, rjd); + if (f_zero_p(*nth)) + *ry = FIX2INT(y); + else { + VALUE nth2; + decode_year(y, *ns ? -1 : +1, &nth2, ry); + } + } + else { + decode_year(y, style, nth, ry); + r = c_valid_commercial_p(*ry, w, d, style, rw, rd, rjd, ns); + } + return r; +} + +static int +valid_weeknum_p(VALUE y, int w, int d, int f, double sg, + VALUE *nth, int *ry, + int *rw, int *rd, int *rjd, + int *ns) +{ + double style = guess_style(y, sg); + int r; + + if (style == 0) { + int jd; + + r = c_valid_weeknum_p(FIX2INT(y), w, d, f, sg, rw, rd, &jd, ns); + if (!r) + return 0; + decode_jd(INT2FIX(jd), nth, rjd); + if (f_zero_p(*nth)) + *ry = FIX2INT(y); + else { + VALUE nth2; + decode_year(y, *ns ? -1 : +1, &nth2, ry); + } + } + else { + decode_year(y, style, nth, ry); + r = c_valid_weeknum_p(*ry, w, d, f, style, rw, rd, rjd, ns); + } + return r; +} + +#ifndef NDEBUG +static int +valid_nth_kday_p(VALUE y, int m, int n, int k, double sg, + VALUE *nth, int *ry, + int *rm, int *rn, int *rk, int *rjd, + int *ns) +{ + double style = guess_style(y, sg); + int r; + + if (style == 0) { + int jd; + + r = c_valid_nth_kday_p(FIX2INT(y), m, n, k, sg, rm, rn, rk, &jd, ns); + if (!r) + return 0; + decode_jd(INT2FIX(jd), nth, rjd); + if (f_zero_p(*nth)) + *ry = FIX2INT(y); + else { + VALUE nth2; + decode_year(y, *ns ? -1 : +1, &nth2, ry); + } + } + else { + decode_year(y, style, nth, ry); + r = c_valid_nth_kday_p(*ry, m, n, k, style, rm, rn, rk, rjd, ns); + } + return r; +} +#endif + +VALUE date_zone_to_diff(VALUE); + +static int +offset_to_sec(VALUE vof, int *rof) +{ + switch (TYPE(vof)) { + case T_FIXNUM: + { + long n; + + n = FIX2LONG(vof); + if (n != -1 && n != 0 && n != 1) + return 0; + *rof = (int)n * DAY_IN_SECONDS; + return 1; + } + case T_FLOAT: + { + double n; + + n = RFLOAT_VALUE(vof) * DAY_IN_SECONDS; + if (n < -DAY_IN_SECONDS || n > DAY_IN_SECONDS) + return 0; + *rof = (int)round(n); + if (*rof != n) + rb_warning("fraction of offset is ignored"); + return 1; + } + default: + if (!k_numeric_p(vof)) + rb_raise(rb_eTypeError, "expected numeric"); + vof = f_to_r(vof); +#ifdef CANONICALIZATION_FOR_MATHN + if (!k_rational_p(vof)) + return offset_to_sec(vof, rof); +#endif + /* fall through */ + case T_RATIONAL: + { + VALUE vs, vn, vd; + long n; + + vs = day_to_sec(vof); + +#ifdef CANONICALIZATION_FOR_MATHN + if (!k_rational_p(vs)) { + if (!FIXNUM_P(vs)) + return 0; + n = FIX2LONG(vs); + if (n < -DAY_IN_SECONDS || n > DAY_IN_SECONDS) + return 0; + *rof = (int)n; + return 1; + } +#endif + vn = rb_rational_num(vs); + vd = rb_rational_den(vs); + + if (FIXNUM_P(vn) && FIXNUM_P(vd) && (FIX2LONG(vd) == 1)) + n = FIX2LONG(vn); + else { + vn = f_round(vs); + if (!f_eqeq_p(vn, vs)) + rb_warning("fraction of offset is ignored"); + if (!FIXNUM_P(vn)) + return 0; + n = FIX2LONG(vn); + if (n < -DAY_IN_SECONDS || n > DAY_IN_SECONDS) + return 0; + } + *rof = (int)n; + return 1; + } + case T_STRING: + { + VALUE vs = date_zone_to_diff(vof); + long n; + + if (!FIXNUM_P(vs)) + return 0; + n = FIX2LONG(vs); + if (n < -DAY_IN_SECONDS || n > DAY_IN_SECONDS) + return 0; + *rof = (int)n; + return 1; + } + } + return 0; +} + +/* date */ + +#define valid_sg(sg) \ +{\ + if (!c_valid_start_p(sg)) {\ + sg = 0;\ + rb_warning("invalid start is ignored");\ + }\ +} + +static VALUE +valid_jd_sub(int argc, VALUE *argv, VALUE klass, int need_jd) +{ + double sg = NUM2DBL(argv[1]); + valid_sg(sg); + return argv[0]; +} + +#ifndef NDEBUG +static VALUE +date_s__valid_jd_p(int argc, VALUE *argv, VALUE klass) +{ + VALUE vjd, vsg; + VALUE argv2[2]; + + rb_scan_args(argc, argv, "11", &vjd, &vsg); + + argv2[0] = vjd; + if (argc < 2) + argv2[1] = DBL2NUM(GREGORIAN); + else + argv2[1] = vsg; + + return valid_jd_sub(2, argv2, klass, 1); +} +#endif + +/* + * call-seq: + * Date.valid_jd?(jd[, start=Date::ITALY]) -> bool + * + * Just returns true. It's nonsense, but is for symmetry. + * + * Date.valid_jd?(2451944) #=> true + * + * See also jd. + */ +static VALUE +date_s_valid_jd_p(int argc, VALUE *argv, VALUE klass) +{ + VALUE vjd, vsg; + VALUE argv2[2]; + + rb_scan_args(argc, argv, "11", &vjd, &vsg); + + argv2[0] = vjd; + if (argc < 2) + argv2[1] = INT2FIX(DEFAULT_SG); + else + argv2[1] = vsg; + + if (NIL_P(valid_jd_sub(2, argv2, klass, 0))) + return Qfalse; + return Qtrue; +} + +static VALUE +valid_civil_sub(int argc, VALUE *argv, VALUE klass, int need_jd) +{ + VALUE nth, y; + int m, d, ry, rm, rd; + double sg; + + y = argv[0]; + m = NUM2INT(argv[1]); + d = NUM2INT(argv[2]); + sg = NUM2DBL(argv[3]); + + valid_sg(sg); + + if (!need_jd && (guess_style(y, sg) < 0)) { + if (!valid_gregorian_p(y, m, d, + &nth, &ry, + &rm, &rd)) + return Qnil; + return INT2FIX(0); /* dummy */ + } + else { + int rjd, ns; + VALUE rjd2; + + if (!valid_civil_p(y, m, d, sg, + &nth, &ry, + &rm, &rd, &rjd, + &ns)) + return Qnil; + if (!need_jd) + return INT2FIX(0); /* dummy */ + encode_jd(nth, rjd, &rjd2); + return rjd2; + } +} + +#ifndef NDEBUG +static VALUE +date_s__valid_civil_p(int argc, VALUE *argv, VALUE klass) +{ + VALUE vy, vm, vd, vsg; + VALUE argv2[4]; + + rb_scan_args(argc, argv, "31", &vy, &vm, &vd, &vsg); + + argv2[0] = vy; + argv2[1] = vm; + argv2[2] = vd; + if (argc < 4) + argv2[3] = DBL2NUM(GREGORIAN); + else + argv2[3] = vsg; + + return valid_civil_sub(4, argv2, klass, 1); +} +#endif + +/* + * call-seq: + * Date.valid_civil?(year, month, mday[, start=Date::ITALY]) -> bool + * Date.valid_date?(year, month, mday[, start=Date::ITALY]) -> bool + * + * Returns true if the given calendar date is valid, and false if not. + * + * Date.valid_date?(2001,2,3) #=> true + * Date.valid_date?(2001,2,29) #=> false + * + * See also jd and civil. + */ +static VALUE +date_s_valid_civil_p(int argc, VALUE *argv, VALUE klass) +{ + VALUE vy, vm, vd, vsg; + VALUE argv2[4]; + + rb_scan_args(argc, argv, "31", &vy, &vm, &vd, &vsg); + + argv2[0] = vy; + argv2[1] = vm; + argv2[2] = vd; + if (argc < 4) + argv2[3] = INT2FIX(DEFAULT_SG); + else + argv2[3] = vsg; + + if (NIL_P(valid_civil_sub(4, argv2, klass, 0))) + return Qfalse; + return Qtrue; +} + +static VALUE +valid_ordinal_sub(int argc, VALUE *argv, VALUE klass, int need_jd) +{ + VALUE nth, y; + int d, ry, rd; + double sg; + + y = argv[0]; + d = NUM2INT(argv[1]); + sg = NUM2DBL(argv[2]); + + valid_sg(sg); + + { + int rjd, ns; + VALUE rjd2; + + if (!valid_ordinal_p(y, d, sg, + &nth, &ry, + &rd, &rjd, + &ns)) + return Qnil; + if (!need_jd) + return INT2FIX(0); /* dummy */ + encode_jd(nth, rjd, &rjd2); + return rjd2; + } +} + +#ifndef NDEBUG +static VALUE +date_s__valid_ordinal_p(int argc, VALUE *argv, VALUE klass) +{ + VALUE vy, vd, vsg; + VALUE argv2[3]; + + rb_scan_args(argc, argv, "21", &vy, &vd, &vsg); + + argv2[0] = vy; + argv2[1] = vd; + if (argc < 3) + argv2[2] = DBL2NUM(GREGORIAN); + else + argv2[2] = vsg; + + return valid_ordinal_sub(3, argv2, klass, 1); +} +#endif + +/* + * call-seq: + * Date.valid_ordinal?(year, yday[, start=Date::ITALY]) -> bool + * + * Returns true if the given ordinal date is valid, and false if not. + * + * Date.valid_ordinal?(2001,34) #=> true + * Date.valid_ordinal?(2001,366) #=> false + * + * See also jd and ordinal. + */ +static VALUE +date_s_valid_ordinal_p(int argc, VALUE *argv, VALUE klass) +{ + VALUE vy, vd, vsg; + VALUE argv2[3]; + + rb_scan_args(argc, argv, "21", &vy, &vd, &vsg); + + argv2[0] = vy; + argv2[1] = vd; + if (argc < 3) + argv2[2] = INT2FIX(DEFAULT_SG); + else + argv2[2] = vsg; + + if (NIL_P(valid_ordinal_sub(3, argv2, klass, 0))) + return Qfalse; + return Qtrue; +} + +static VALUE +valid_commercial_sub(int argc, VALUE *argv, VALUE klass, int need_jd) +{ + VALUE nth, y; + int w, d, ry, rw, rd; + double sg; + + y = argv[0]; + w = NUM2INT(argv[1]); + d = NUM2INT(argv[2]); + sg = NUM2DBL(argv[3]); + + valid_sg(sg); + + { + int rjd, ns; + VALUE rjd2; + + if (!valid_commercial_p(y, w, d, sg, + &nth, &ry, + &rw, &rd, &rjd, + &ns)) + return Qnil; + if (!need_jd) + return INT2FIX(0); /* dummy */ + encode_jd(nth, rjd, &rjd2); + return rjd2; + } +} + +#ifndef NDEBUG +static VALUE +date_s__valid_commercial_p(int argc, VALUE *argv, VALUE klass) +{ + VALUE vy, vw, vd, vsg; + VALUE argv2[4]; + + rb_scan_args(argc, argv, "31", &vy, &vw, &vd, &vsg); + + argv2[0] = vy; + argv2[1] = vw; + argv2[2] = vd; + if (argc < 4) + argv2[3] = DBL2NUM(GREGORIAN); + else + argv2[3] = vsg; + + return valid_commercial_sub(4, argv2, klass, 1); +} +#endif + +/* + * call-seq: + * Date.valid_commercial?(cwyear, cweek, cwday[, start=Date::ITALY]) -> bool + * + * Returns true if the given week date is valid, and false if not. + * + * Date.valid_commercial?(2001,5,6) #=> true + * Date.valid_commercial?(2001,5,8) #=> false + * + * See also jd and commercial. + */ +static VALUE +date_s_valid_commercial_p(int argc, VALUE *argv, VALUE klass) +{ + VALUE vy, vw, vd, vsg; + VALUE argv2[4]; + + rb_scan_args(argc, argv, "31", &vy, &vw, &vd, &vsg); + + argv2[0] = vy; + argv2[1] = vw; + argv2[2] = vd; + if (argc < 4) + argv2[3] = INT2FIX(DEFAULT_SG); + else + argv2[3] = vsg; + + if (NIL_P(valid_commercial_sub(4, argv2, klass, 0))) + return Qfalse; + return Qtrue; +} + +#ifndef NDEBUG +static VALUE +valid_weeknum_sub(int argc, VALUE *argv, VALUE klass, int need_jd) +{ + VALUE nth, y; + int w, d, f, ry, rw, rd; + double sg; + + y = argv[0]; + w = NUM2INT(argv[1]); + d = NUM2INT(argv[2]); + f = NUM2INT(argv[3]); + sg = NUM2DBL(argv[4]); + + valid_sg(sg); + + { + int rjd, ns; + VALUE rjd2; + + if (!valid_weeknum_p(y, w, d, f, sg, + &nth, &ry, + &rw, &rd, &rjd, + &ns)) + return Qnil; + if (!need_jd) + return INT2FIX(0); /* dummy */ + encode_jd(nth, rjd, &rjd2); + return rjd2; + } +} + +static VALUE +date_s__valid_weeknum_p(int argc, VALUE *argv, VALUE klass) +{ + VALUE vy, vw, vd, vf, vsg; + VALUE argv2[5]; + + rb_scan_args(argc, argv, "41", &vy, &vw, &vd, &vf, &vsg); + + argv2[0] = vy; + argv2[1] = vw; + argv2[2] = vd; + argv2[3] = vf; + if (argc < 5) + argv2[4] = DBL2NUM(GREGORIAN); + else + argv2[4] = vsg; + + return valid_weeknum_sub(5, argv2, klass, 1); +} + +static VALUE +date_s_valid_weeknum_p(int argc, VALUE *argv, VALUE klass) +{ + VALUE vy, vw, vd, vf, vsg; + VALUE argv2[5]; + + rb_scan_args(argc, argv, "41", &vy, &vw, &vd, &vf, &vsg); + + argv2[0] = vy; + argv2[1] = vw; + argv2[2] = vd; + argv2[3] = vf; + if (argc < 5) + argv2[4] = INT2FIX(DEFAULT_SG); + else + argv2[4] = vsg; + + if (NIL_P(valid_weeknum_sub(5, argv2, klass, 0))) + return Qfalse; + return Qtrue; +} + +static VALUE +valid_nth_kday_sub(int argc, VALUE *argv, VALUE klass, int need_jd) +{ + VALUE nth, y; + int m, n, k, ry, rm, rn, rk; + double sg; + + y = argv[0]; + m = NUM2INT(argv[1]); + n = NUM2INT(argv[2]); + k = NUM2INT(argv[3]); + sg = NUM2DBL(argv[4]); + + { + int rjd, ns; + VALUE rjd2; + + if (!valid_nth_kday_p(y, m, n, k, sg, + &nth, &ry, + &rm, &rn, &rk, &rjd, + &ns)) + return Qnil; + if (!need_jd) + return INT2FIX(0); /* dummy */ + encode_jd(nth, rjd, &rjd2); + return rjd2; + } +} + +static VALUE +date_s__valid_nth_kday_p(int argc, VALUE *argv, VALUE klass) +{ + VALUE vy, vm, vn, vk, vsg; + VALUE argv2[5]; + + rb_scan_args(argc, argv, "41", &vy, &vm, &vn, &vk, &vsg); + + argv2[0] = vy; + argv2[1] = vm; + argv2[2] = vn; + argv2[3] = vk; + if (argc < 5) + argv2[4] = DBL2NUM(GREGORIAN); + else + argv2[4] = vsg; + + return valid_nth_kday_sub(5, argv2, klass, 1); +} + +static VALUE +date_s_valid_nth_kday_p(int argc, VALUE *argv, VALUE klass) +{ + VALUE vy, vm, vn, vk, vsg; + VALUE argv2[5]; + + rb_scan_args(argc, argv, "41", &vy, &vm, &vn, &vk, &vsg); + + argv2[0] = vy; + argv2[1] = vm; + argv2[2] = vn; + argv2[3] = vk; + if (argc < 5) + argv2[4] = INT2FIX(DEFAULT_SG); + else + argv2[4] = vsg; + + if (NIL_P(valid_nth_kday_sub(5, argv2, klass, 0))) + return Qfalse; + return Qtrue; +} + +static VALUE +date_s_zone_to_diff(VALUE klass, VALUE str) +{ + return date_zone_to_diff(str); +} +#endif + +/* + * call-seq: + * Date.julian_leap?(year) -> bool + * + * Returns true if the given year is a leap year of the proleptic + * Julian calendar. + * + * Date.julian_leap?(1900) #=> true + * Date.julian_leap?(1901) #=> false + */ +static VALUE +date_s_julian_leap_p(VALUE klass, VALUE y) +{ + VALUE nth; + int ry; + + decode_year(y, +1, &nth, &ry); + return f_boolcast(c_julian_leap_p(ry)); +} + +/* + * call-seq: + * Date.gregorian_leap?(year) -> bool + * Date.leap?(year) -> bool + * + * Returns true if the given year is a leap year of the proleptic + * Gregorian calendar. + * + * Date.gregorian_leap?(1900) #=> false + * Date.gregorian_leap?(2000) #=> true + */ +static VALUE +date_s_gregorian_leap_p(VALUE klass, VALUE y) +{ + VALUE nth; + int ry; + + decode_year(y, -1, &nth, &ry); + return f_boolcast(c_gregorian_leap_p(ry)); +} + +static void +d_lite_gc_mark(void *ptr) +{ + union DateData *dat = ptr; + if (simple_dat_p(dat)) + rb_gc_mark(dat->s.nth); + else { + rb_gc_mark(dat->c.nth); + rb_gc_mark(dat->c.sf); + } +} + +static size_t +d_lite_memsize(const void *ptr) +{ + const union DateData *dat = ptr; + return complex_dat_p(dat) ? sizeof(struct ComplexDateData) : sizeof(struct SimpleDateData); +} + +static const rb_data_type_t d_lite_type = { + "Date", + {d_lite_gc_mark, RUBY_TYPED_DEFAULT_FREE, d_lite_memsize,}, + 0, 0, + RUBY_TYPED_FREE_IMMEDIATELY|RUBY_TYPED_WB_PROTECTED, +}; + +inline static VALUE +d_simple_new_internal(VALUE klass, + VALUE nth, int jd, + double sg, + int y, int m, int d, + unsigned flags) +{ + struct SimpleDateData *dat; + VALUE obj; + + obj = TypedData_Make_Struct(klass, struct SimpleDateData, + &d_lite_type, dat); + set_to_simple(obj, dat, nth, jd, sg, y, m, d, flags & ~COMPLEX_DAT); + + assert(have_jd_p(dat) || have_civil_p(dat)); + + return obj; +} + +inline static VALUE +d_complex_new_internal(VALUE klass, + VALUE nth, int jd, + int df, VALUE sf, + int of, double sg, + int y, int m, int d, + int h, int min, int s, + unsigned flags) +{ + struct ComplexDateData *dat; + VALUE obj; + + obj = TypedData_Make_Struct(klass, struct ComplexDateData, + &d_lite_type, dat); + set_to_complex(obj, dat, nth, jd, df, sf, of, sg, + y, m, d, h, min, s, flags | COMPLEX_DAT); + + assert(have_jd_p(dat) || have_civil_p(dat)); + assert(have_df_p(dat) || have_time_p(dat)); + + return obj; +} + +static VALUE +d_lite_s_alloc_simple(VALUE klass) +{ + return d_simple_new_internal(klass, + INT2FIX(0), 0, + DEFAULT_SG, + 0, 0, 0, + HAVE_JD); +} + +static VALUE +d_lite_s_alloc_complex(VALUE klass) +{ + return d_complex_new_internal(klass, + INT2FIX(0), 0, + 0, INT2FIX(0), + 0, DEFAULT_SG, + 0, 0, 0, + 0, 0, 0, + HAVE_JD | HAVE_DF); +} + +static VALUE +d_lite_s_alloc(VALUE klass) +{ + return d_lite_s_alloc_complex(klass); +} + +static void +old_to_new(VALUE ajd, VALUE of, VALUE sg, + VALUE *rnth, int *rjd, int *rdf, VALUE *rsf, + int *rof, double *rsg) +{ + VALUE jd, df, sf, of2, t; + + decode_day(f_add(ajd, half_days_in_day), + &jd, &df, &sf); + t = day_to_sec(of); + of2 = f_round(t); + + if (!f_eqeq_p(of2, t)) + rb_warning("fraction of offset is ignored"); + + decode_jd(jd, rnth, rjd); + + *rdf = NUM2INT(df); + *rsf = sf; + *rof = NUM2INT(of2); + *rsg = NUM2DBL(sg); + + if (*rdf < 0 || *rdf >= DAY_IN_SECONDS) + rb_raise(rb_eArgError, "invalid day fraction"); + + if (f_lt_p(*rsf, INT2FIX(0)) || + f_ge_p(*rsf, INT2FIX(SECOND_IN_NANOSECONDS))) + + if (*rof < -DAY_IN_SECONDS || *rof > DAY_IN_SECONDS) { + *rof = 0; + rb_warning("invalid offset is ignored"); + } + + if (!c_valid_start_p(*rsg)) { + *rsg = DEFAULT_SG; + rb_warning("invalid start is ignored"); + } +} + +#ifndef NDEBUG +static VALUE +date_s_new_bang(int argc, VALUE *argv, VALUE klass) +{ + VALUE ajd, of, sg, nth, sf; + int jd, df, rof; + double rsg; + + rb_scan_args(argc, argv, "03", &ajd, &of, &sg); + + switch (argc) { + case 0: + ajd = INT2FIX(0); + case 1: + of = INT2FIX(0); + case 2: + sg = INT2FIX(DEFAULT_SG); + } + + old_to_new(ajd, of, sg, + &nth, &jd, &df, &sf, &rof, &rsg); + + if (!df && f_zero_p(sf) && !rof) + return d_simple_new_internal(klass, + nth, jd, + rsg, + 0, 0, 0, + HAVE_JD); + else + return d_complex_new_internal(klass, + nth, jd, + df, sf, + rof, rsg, + 0, 0, 0, + 0, 0, 0, + HAVE_JD | HAVE_DF); +} +#endif + +inline static int +wholenum_p(VALUE x) +{ + if (FIXNUM_P(x)) + return 1; + switch (TYPE(x)) { + case T_BIGNUM: + return 1; + case T_FLOAT: + { + double d = RFLOAT_VALUE(x); + return round(d) == d; + } + break; + case T_RATIONAL: + { + VALUE den = rb_rational_den(x); + return FIXNUM_P(den) && FIX2LONG(den) == 1; + } + break; + } + return 0; +} + +inline static VALUE +to_integer(VALUE x) +{ + if (FIXNUM_P(x) || RB_TYPE_P(x, T_BIGNUM)) + return x; + return f_to_i(x); +} + +inline static VALUE +d_trunc(VALUE d, VALUE *fr) +{ + VALUE rd; + + if (wholenum_p(d)) { + rd = to_integer(d); + *fr = INT2FIX(0); + } + else { + rd = f_idiv(d, INT2FIX(1)); + *fr = f_mod(d, INT2FIX(1)); + } + return rd; +} + +#define jd_trunc d_trunc +#define k_trunc d_trunc + +inline static VALUE +h_trunc(VALUE h, VALUE *fr) +{ + VALUE rh; + + if (wholenum_p(h)) { + rh = to_integer(h); + *fr = INT2FIX(0); + } + else { + rh = f_idiv(h, INT2FIX(1)); + *fr = f_mod(h, INT2FIX(1)); + *fr = f_quo(*fr, INT2FIX(24)); + } + return rh; +} + +inline static VALUE +min_trunc(VALUE min, VALUE *fr) +{ + VALUE rmin; + + if (wholenum_p(min)) { + rmin = to_integer(min); + *fr = INT2FIX(0); + } + else { + rmin = f_idiv(min, INT2FIX(1)); + *fr = f_mod(min, INT2FIX(1)); + *fr = f_quo(*fr, INT2FIX(1440)); + } + return rmin; +} + +inline static VALUE +s_trunc(VALUE s, VALUE *fr) +{ + VALUE rs; + + if (wholenum_p(s)) { + rs = to_integer(s); + *fr = INT2FIX(0); + } + else { + rs = f_idiv(s, INT2FIX(1)); + *fr = f_mod(s, INT2FIX(1)); + *fr = f_quo(*fr, INT2FIX(86400)); + } + return rs; +} + +#define num2num_with_frac(s,n) \ +{\ + s = s##_trunc(v##s, &fr);\ + if (f_nonzero_p(fr)) {\ + if (argc > n)\ + rb_raise(rb_eArgError, "invalid fraction");\ + fr2 = fr;\ + }\ +} + +#define num2int_with_frac(s,n) \ +{\ + s = NUM2INT(s##_trunc(v##s, &fr));\ + if (f_nonzero_p(fr)) {\ + if (argc > n)\ + rb_raise(rb_eArgError, "invalid fraction");\ + fr2 = fr;\ + }\ +} + +#define canon24oc() \ +{\ + if (rh == 24) {\ + rh = 0;\ + fr2 = f_add(fr2, INT2FIX(1));\ + }\ +} + +#define add_frac() \ +{\ + if (f_nonzero_p(fr2))\ + ret = d_lite_plus(ret, fr2);\ +} + +#define val2sg(vsg,dsg) \ +{\ + dsg = NUM2DBL(vsg);\ + if (!c_valid_start_p(dsg)) {\ + dsg = DEFAULT_SG;\ + rb_warning("invalid start is ignored");\ + }\ +} + +static VALUE d_lite_plus(VALUE, VALUE); + +/* + * call-seq: + * Date.jd([jd=0[, start=Date::ITALY]]) -> date + * + * Creates a date object denoting the given chronological Julian day + * number. + * + * Date.jd(2451944) #=> # + * Date.jd(2451945) #=> # + * Date.jd(0) #=> # + * + * See also new. + */ +static VALUE +date_s_jd(int argc, VALUE *argv, VALUE klass) +{ + VALUE vjd, vsg, jd, fr, fr2, ret; + double sg; + + rb_scan_args(argc, argv, "02", &vjd, &vsg); + + jd = INT2FIX(0); + fr2 = INT2FIX(0); + sg = DEFAULT_SG; + + switch (argc) { + case 2: + val2sg(vsg, sg); + case 1: + num2num_with_frac(jd, positive_inf); + } + + { + VALUE nth; + int rjd; + + decode_jd(jd, &nth, &rjd); + ret = d_simple_new_internal(klass, + nth, rjd, + sg, + 0, 0, 0, + HAVE_JD); + } + add_frac(); + return ret; +} + +/* + * call-seq: + * Date.ordinal([year=-4712[, yday=1[, start=Date::ITALY]]]) -> date + * + * Creates a date object denoting the given ordinal date. + * + * The day of year should be a negative or a positive number (as a + * relative day from the end of year when negative). It should not be + * zero. + * + * Date.ordinal(2001) #=> # + * Date.ordinal(2001,34) #=> # + * Date.ordinal(2001,-1) #=> # + * + * See also jd and new. + */ +static VALUE +date_s_ordinal(int argc, VALUE *argv, VALUE klass) +{ + VALUE vy, vd, vsg, y, fr, fr2, ret; + int d; + double sg; + + rb_scan_args(argc, argv, "03", &vy, &vd, &vsg); + + y = INT2FIX(-4712); + d = 1; + fr2 = INT2FIX(0); + sg = DEFAULT_SG; + + switch (argc) { + case 3: + val2sg(vsg, sg); + case 2: + num2int_with_frac(d, positive_inf); + case 1: + y = vy; + } + + { + VALUE nth; + int ry, rd, rjd, ns; + + if (!valid_ordinal_p(y, d, sg, + &nth, &ry, + &rd, &rjd, + &ns)) + rb_raise(rb_eArgError, "invalid date"); + + ret = d_simple_new_internal(klass, + nth, rjd, + sg, + 0, 0, 0, + HAVE_JD); + } + add_frac(); + return ret; +} + +/* + * call-seq: + * Date.civil([year=-4712[, month=1[, mday=1[, start=Date::ITALY]]]]) -> date + * Date.new([year=-4712[, month=1[, mday=1[, start=Date::ITALY]]]]) -> date + * + * Creates a date object denoting the given calendar date. + * + * In this class, BCE years are counted astronomically. Thus, the + * year before the year 1 is the year zero, and the year preceding the + * year zero is the year -1. The month and the day of month should be + * a negative or a positive number (as a relative month/day from the + * end of year/month when negative). They should not be zero. + * + * The last argument should be a Julian day number which denotes the + * day of calendar reform. Date::ITALY (2299161=1582-10-15), + * Date::ENGLAND (2361222=1752-09-14), Date::GREGORIAN (the proleptic + * Gregorian calendar) and Date::JULIAN (the proleptic Julian + * calendar) can be specified as a day of calendar reform. + * + * Date.new(2001) #=> # + * Date.new(2001,2,3) #=> # + * Date.new(2001,2,-1) #=> # + * + * See also jd. + */ +static VALUE +date_s_civil(int argc, VALUE *argv, VALUE klass) +{ + VALUE vy, vm, vd, vsg, y, fr, fr2, ret; + int m, d; + double sg; + + rb_scan_args(argc, argv, "04", &vy, &vm, &vd, &vsg); + + y = INT2FIX(-4712); + m = 1; + d = 1; + fr2 = INT2FIX(0); + sg = DEFAULT_SG; + + switch (argc) { + case 4: + val2sg(vsg, sg); + case 3: + num2int_with_frac(d, positive_inf); + case 2: + m = NUM2INT(vm); + case 1: + y = vy; + } + + if (guess_style(y, sg) < 0) { + VALUE nth; + int ry, rm, rd; + + if (!valid_gregorian_p(y, m, d, + &nth, &ry, + &rm, &rd)) + rb_raise(rb_eArgError, "invalid date"); + + ret = d_simple_new_internal(klass, + nth, 0, + sg, + ry, rm, rd, + HAVE_CIVIL); + } + else { + VALUE nth; + int ry, rm, rd, rjd, ns; + + if (!valid_civil_p(y, m, d, sg, + &nth, &ry, + &rm, &rd, &rjd, + &ns)) + rb_raise(rb_eArgError, "invalid date"); + + ret = d_simple_new_internal(klass, + nth, rjd, + sg, + ry, rm, rd, + HAVE_JD | HAVE_CIVIL); + } + add_frac(); + return ret; +} + +/* + * call-seq: + * Date.commercial([cwyear=-4712[, cweek=1[, cwday=1[, start=Date::ITALY]]]]) -> date + * + * Creates a date object denoting the given week date. + * + * The week and the day of week should be a negative or a positive + * number (as a relative week/day from the end of year/week when + * negative). They should not be zero. + * + * Date.commercial(2001) #=> # + * Date.commercial(2002) #=> # + * Date.commercial(2001,5,6) #=> # + * + * See also jd and new. + */ +static VALUE +date_s_commercial(int argc, VALUE *argv, VALUE klass) +{ + VALUE vy, vw, vd, vsg, y, fr, fr2, ret; + int w, d; + double sg; + + rb_scan_args(argc, argv, "04", &vy, &vw, &vd, &vsg); + + y = INT2FIX(-4712); + w = 1; + d = 1; + fr2 = INT2FIX(0); + sg = DEFAULT_SG; + + switch (argc) { + case 4: + val2sg(vsg, sg); + case 3: + num2int_with_frac(d, positive_inf); + case 2: + w = NUM2INT(vw); + case 1: + y = vy; + } + + { + VALUE nth; + int ry, rw, rd, rjd, ns; + + if (!valid_commercial_p(y, w, d, sg, + &nth, &ry, + &rw, &rd, &rjd, + &ns)) + rb_raise(rb_eArgError, "invalid date"); + + ret = d_simple_new_internal(klass, + nth, rjd, + sg, + 0, 0, 0, + HAVE_JD); + } + add_frac(); + return ret; +} + +#ifndef NDEBUG +static VALUE +date_s_weeknum(int argc, VALUE *argv, VALUE klass) +{ + VALUE vy, vw, vd, vf, vsg, y, fr, fr2, ret; + int w, d, f; + double sg; + + rb_scan_args(argc, argv, "05", &vy, &vw, &vd, &vf, &vsg); + + y = INT2FIX(-4712); + w = 0; + d = 1; + f = 0; + fr2 = INT2FIX(0); + sg = DEFAULT_SG; + + switch (argc) { + case 5: + val2sg(vsg, sg); + case 4: + f = NUM2INT(vf); + case 3: + num2int_with_frac(d, positive_inf); + case 2: + w = NUM2INT(vw); + case 1: + y = vy; + } + + { + VALUE nth; + int ry, rw, rd, rjd, ns; + + if (!valid_weeknum_p(y, w, d, f, sg, + &nth, &ry, + &rw, &rd, &rjd, + &ns)) + rb_raise(rb_eArgError, "invalid date"); + + ret = d_simple_new_internal(klass, + nth, rjd, + sg, + 0, 0, 0, + HAVE_JD); + } + add_frac(); + return ret; +} + +static VALUE +date_s_nth_kday(int argc, VALUE *argv, VALUE klass) +{ + VALUE vy, vm, vn, vk, vsg, y, fr, fr2, ret; + int m, n, k; + double sg; + + rb_scan_args(argc, argv, "05", &vy, &vm, &vn, &vk, &vsg); + + y = INT2FIX(-4712); + m = 1; + n = 1; + k = 1; + fr2 = INT2FIX(0); + sg = DEFAULT_SG; + + switch (argc) { + case 5: + val2sg(vsg, sg); + case 4: + num2int_with_frac(k, positive_inf); + case 3: + n = NUM2INT(vn); + case 2: + m = NUM2INT(vm); + case 1: + y = vy; + } + + { + VALUE nth; + int ry, rm, rn, rk, rjd, ns; + + if (!valid_nth_kday_p(y, m, n, k, sg, + &nth, &ry, + &rm, &rn, &rk, &rjd, + &ns)) + rb_raise(rb_eArgError, "invalid date"); + + ret = d_simple_new_internal(klass, + nth, rjd, + sg, + 0, 0, 0, + HAVE_JD); + } + add_frac(); + return ret; +} +#endif + +#if !defined(HAVE_GMTIME_R) +static struct tm* +gmtime_r(const time_t *t, struct tm *tm) +{ + auto struct tm *tmp = gmtime(t); + if (tmp) + *tm = *tmp; + return tmp; +} + +static struct tm* +localtime_r(const time_t *t, struct tm *tm) +{ + auto struct tm *tmp = localtime(t); + if (tmp) + *tm = *tmp; + return tmp; +} +#endif + +static void set_sg(union DateData *, double); + +/* + * call-seq: + * Date.today([start=Date::ITALY]) -> date + * + * Date.today #=> # + * + * Creates a date object denoting the present day. + */ +static VALUE +date_s_today(int argc, VALUE *argv, VALUE klass) +{ + VALUE vsg, nth, ret; + double sg; + time_t t; + struct tm tm; + int y, ry, m, d; + + rb_scan_args(argc, argv, "01", &vsg); + + if (argc < 1) + sg = DEFAULT_SG; + else + val2sg(vsg, sg); + + if (time(&t) == -1) + rb_sys_fail("time"); + tzset(); + if (!localtime_r(&t, &tm)) + rb_sys_fail("localtime"); + + y = tm.tm_year + 1900; + m = tm.tm_mon + 1; + d = tm.tm_mday; + + decode_year(INT2FIX(y), -1, &nth, &ry); + + ret = d_simple_new_internal(klass, + nth, 0, + GREGORIAN, + ry, m, d, + HAVE_CIVIL); + { + get_d1(ret); + set_sg(dat, sg); + } + return ret; +} + +#define set_hash0(k,v) rb_hash_aset(hash, k, v) +#define ref_hash0(k) rb_hash_aref(hash, k) +#define del_hash0(k) rb_hash_delete(hash, k) + +#define set_hash(k,v) rb_hash_aset(hash, ID2SYM(rb_intern(k)), v) +#define ref_hash(k) rb_hash_aref(hash, ID2SYM(rb_intern(k))) +#define del_hash(k) rb_hash_delete(hash, ID2SYM(rb_intern(k))) + +static VALUE +rt_rewrite_frags(VALUE hash) +{ + VALUE seconds; + + seconds = ref_hash("seconds"); + if (!NIL_P(seconds)) { + VALUE offset, d, h, min, s, fr; + + offset = ref_hash("offset"); + if (!NIL_P(offset)) + seconds = f_add(seconds, offset); + + d = f_idiv(seconds, INT2FIX(DAY_IN_SECONDS)); + fr = f_mod(seconds, INT2FIX(DAY_IN_SECONDS)); + + h = f_idiv(fr, INT2FIX(HOUR_IN_SECONDS)); + fr = f_mod(fr, INT2FIX(HOUR_IN_SECONDS)); + + min = f_idiv(fr, INT2FIX(MINUTE_IN_SECONDS)); + fr = f_mod(fr, INT2FIX(MINUTE_IN_SECONDS)); + + s = f_idiv(fr, INT2FIX(1)); + fr = f_mod(fr, INT2FIX(1)); + + set_hash("jd", f_add(UNIX_EPOCH_IN_CJD, d)); + set_hash("hour", h); + set_hash("min", min); + set_hash("sec", s); + set_hash("sec_fraction", fr); + del_hash("seconds"); + } + return hash; +} + +#define sym(x) ID2SYM(rb_intern(x)) + +static VALUE d_lite_year(VALUE); +static VALUE d_lite_wday(VALUE); +static VALUE d_lite_jd(VALUE); + +static VALUE +rt_complete_frags(VALUE klass, VALUE hash) +{ + static VALUE tab = Qnil; + int g, e; + VALUE k, a, d; + + if (NIL_P(tab)) { + tab = rb_ary_new3(11, + rb_ary_new3(2, + sym("time"), + rb_ary_new3(3, + sym("hour"), + sym("min"), + sym("sec"))), + rb_ary_new3(2, + Qnil, + rb_ary_new3(1, + sym("jd"))), + rb_ary_new3(2, + sym("ordinal"), + rb_ary_new3(5, + sym("year"), + sym("yday"), + sym("hour"), + sym("min"), + sym("sec"))), + rb_ary_new3(2, + sym("civil"), + rb_ary_new3(6, + sym("year"), + sym("mon"), + sym("mday"), + sym("hour"), + sym("min"), + sym("sec"))), + rb_ary_new3(2, + sym("commercial"), + rb_ary_new3(6, + sym("cwyear"), + sym("cweek"), + sym("cwday"), + sym("hour"), + sym("min"), + sym("sec"))), + rb_ary_new3(2, + sym("wday"), + rb_ary_new3(4, + sym("wday"), + sym("hour"), + sym("min"), + sym("sec"))), + rb_ary_new3(2, + sym("wnum0"), + rb_ary_new3(6, + sym("year"), + sym("wnum0"), + sym("wday"), + sym("hour"), + sym("min"), + sym("sec"))), + rb_ary_new3(2, + sym("wnum1"), + rb_ary_new3(6, + sym("year"), + sym("wnum1"), + sym("wday"), + sym("hour"), + sym("min"), + sym("sec"))), + rb_ary_new3(2, + Qnil, + rb_ary_new3(6, + sym("cwyear"), + sym("cweek"), + sym("wday"), + sym("hour"), + sym("min"), + sym("sec"))), + rb_ary_new3(2, + Qnil, + rb_ary_new3(6, + sym("year"), + sym("wnum0"), + sym("cwday"), + sym("hour"), + sym("min"), + sym("sec"))), + rb_ary_new3(2, + Qnil, + rb_ary_new3(6, + sym("year"), + sym("wnum1"), + sym("cwday"), + sym("hour"), + sym("min"), + sym("sec")))); + rb_gc_register_mark_object(tab); + } + + { + int i, eno = 0, idx = 0; + + for (i = 0; i < RARRAY_LENINT(tab); i++) { + VALUE x, a; + + x = RARRAY_PTR(tab)[i]; + a = RARRAY_PTR(x)[1]; + + { + int j, n = 0; + + for (j = 0; j < RARRAY_LENINT(a); j++) + if (!NIL_P(ref_hash0(RARRAY_PTR(a)[j]))) + n++; + if (n > eno) { + eno = n; + idx = i; + } + } + } + if (eno == 0) + g = 0; + else { + g = 1; + k = RARRAY_PTR(RARRAY_PTR(tab)[idx])[0]; + a = RARRAY_PTR(RARRAY_PTR(tab)[idx])[1]; + e = eno; + } + } + + d = Qnil; + + if (g && !NIL_P(k) && (RARRAY_LENINT(a) - e)) { + if (k == sym("ordinal")) { + if (NIL_P(ref_hash("year"))) { + if (NIL_P(d)) + d = date_s_today(0, (VALUE *)0, cDate); + set_hash("year", d_lite_year(d)); + } + if (NIL_P(ref_hash("yday"))) + set_hash("yday", INT2FIX(1)); + } + else if (k == sym("civil")) { + int i; + + for (i = 0; i < RARRAY_LENINT(a); i++) { + VALUE e = RARRAY_PTR(a)[i]; + + if (!NIL_P(ref_hash0(e))) + break; + if (NIL_P(d)) + d = date_s_today(0, (VALUE *)0, cDate); + set_hash0(e, rb_funcall(d, SYM2ID(e), 0)); + } + if (NIL_P(ref_hash("mon"))) + set_hash("mon", INT2FIX(1)); + if (NIL_P(ref_hash("mday"))) + set_hash("mday", INT2FIX(1)); + } + else if (k == sym("commercial")) { + int i; + + for (i = 0; i < RARRAY_LENINT(a); i++) { + VALUE e = RARRAY_PTR(a)[i]; + + if (!NIL_P(ref_hash0(e))) + break; + if (NIL_P(d)) + d = date_s_today(0, (VALUE *)0, cDate); + set_hash0(e, rb_funcall(d, SYM2ID(e), 0)); + } + if (NIL_P(ref_hash("cweek"))) + set_hash("cweek", INT2FIX(1)); + if (NIL_P(ref_hash("cwday"))) + set_hash("cwday", INT2FIX(1)); + } + else if (k == sym("wday")) { + if (NIL_P(d)) + d = date_s_today(0, (VALUE *)0, cDate); + set_hash("jd", d_lite_jd(f_add(f_sub(d, + d_lite_wday(d)), + ref_hash("wday")))); + } + else if (k == sym("wnum0")) { + int i; + + for (i = 0; i < RARRAY_LENINT(a); i++) { + VALUE e = RARRAY_PTR(a)[i]; + + if (!NIL_P(ref_hash0(e))) + break; + if (NIL_P(d)) + d = date_s_today(0, (VALUE *)0, cDate); + set_hash0(e, rb_funcall(d, SYM2ID(e), 0)); + } + if (NIL_P(ref_hash("wnum0"))) + set_hash("wnum0", INT2FIX(0)); + if (NIL_P(ref_hash("wday"))) + set_hash("wday", INT2FIX(0)); + } + else if (k == sym("wnum1")) { + int i; + + for (i = 0; i < RARRAY_LENINT(a); i++) { + VALUE e = RARRAY_PTR(a)[i]; + + if (!NIL_P(ref_hash0(e))) + break; + if (NIL_P(d)) + d = date_s_today(0, (VALUE *)0, cDate); + set_hash0(e, rb_funcall(d, SYM2ID(e), 0)); + } + if (NIL_P(ref_hash("wnum1"))) + set_hash("wnum1", INT2FIX(0)); + if (NIL_P(ref_hash("wday"))) + set_hash("wday", INT2FIX(1)); + } + } + + if (g && k == sym("time")) { + if (f_le_p(klass, cDateTime)) { + if (NIL_P(d)) + d = date_s_today(0, (VALUE *)0, cDate); + if (NIL_P(ref_hash("jd"))) + set_hash("jd", d_lite_jd(d)); + } + } + + if (NIL_P(ref_hash("hour"))) + set_hash("hour", INT2FIX(0)); + if (NIL_P(ref_hash("min"))) + set_hash("min", INT2FIX(0)); + if (NIL_P(ref_hash("sec"))) + set_hash("sec", INT2FIX(0)); + else if (f_gt_p(ref_hash("sec"), INT2FIX(59))) + set_hash("sec", INT2FIX(59)); + + return hash; +} + +static VALUE +rt__valid_jd_p(VALUE jd, VALUE sg) +{ + return jd; +} + +static VALUE +rt__valid_ordinal_p(VALUE y, VALUE d, VALUE sg) +{ + VALUE nth, rjd2; + int ry, rd, rjd, ns; + + if (!valid_ordinal_p(y, NUM2INT(d), NUM2DBL(sg), + &nth, &ry, + &rd, &rjd, + &ns)) + return Qnil; + encode_jd(nth, rjd, &rjd2); + return rjd2; +} + +static VALUE +rt__valid_civil_p(VALUE y, VALUE m, VALUE d, VALUE sg) +{ + VALUE nth, rjd2; + int ry, rm, rd, rjd, ns; + + if (!valid_civil_p(y, NUM2INT(m), NUM2INT(d), NUM2DBL(sg), + &nth, &ry, + &rm, &rd, &rjd, + &ns)) + return Qnil; + encode_jd(nth, rjd, &rjd2); + return rjd2; +} + +static VALUE +rt__valid_commercial_p(VALUE y, VALUE w, VALUE d, VALUE sg) +{ + VALUE nth, rjd2; + int ry, rw, rd, rjd, ns; + + if (!valid_commercial_p(y, NUM2INT(w), NUM2INT(d), NUM2DBL(sg), + &nth, &ry, + &rw, &rd, &rjd, + &ns)) + return Qnil; + encode_jd(nth, rjd, &rjd2); + return rjd2; +} + +static VALUE +rt__valid_weeknum_p(VALUE y, VALUE w, VALUE d, VALUE f, VALUE sg) +{ + VALUE nth, rjd2; + int ry, rw, rd, rjd, ns; + + if (!valid_weeknum_p(y, NUM2INT(w), NUM2INT(d), NUM2INT(f), NUM2DBL(sg), + &nth, &ry, + &rw, &rd, &rjd, + &ns)) + return Qnil; + encode_jd(nth, rjd, &rjd2); + return rjd2; +} + +static VALUE +rt__valid_date_frags_p(VALUE hash, VALUE sg) +{ + { + VALUE vjd; + + if (!NIL_P(vjd = ref_hash("jd"))) { + VALUE jd = rt__valid_jd_p(vjd, sg); + if (!NIL_P(jd)) + return jd; + } + } + + { + VALUE year, yday; + + if (!NIL_P(yday = ref_hash("yday")) && + !NIL_P(year = ref_hash("year"))) { + VALUE jd = rt__valid_ordinal_p(year, yday, sg); + if (!NIL_P(jd)) + return jd; + } + } + + { + VALUE year, mon, mday; + + if (!NIL_P(mday = ref_hash("mday")) && + !NIL_P(mon = ref_hash("mon")) && + !NIL_P(year = ref_hash("year"))) { + VALUE jd = rt__valid_civil_p(year, mon, mday, sg); + if (!NIL_P(jd)) + return jd; + } + } + + { + VALUE year, week, wday; + + wday = ref_hash("cwday"); + if (NIL_P(wday)) { + wday = ref_hash("wday"); + if (!NIL_P(wday)) + if (f_zero_p(wday)) + wday = INT2FIX(7); + } + + if (!NIL_P(wday) && + !NIL_P(week = ref_hash("cweek")) && + !NIL_P(year = ref_hash("cwyear"))) { + VALUE jd = rt__valid_commercial_p(year, week, wday, sg); + if (!NIL_P(jd)) + return jd; + } + } + + { + VALUE year, week, wday; + + wday = ref_hash("wday"); + if (NIL_P(wday)) { + wday = ref_hash("cwday"); + if (!NIL_P(wday)) + if (f_eqeq_p(wday, INT2FIX(7))) + wday = INT2FIX(0); + } + + if (!NIL_P(wday) && + !NIL_P(week = ref_hash("wnum0")) && + !NIL_P(year = ref_hash("year"))) { + VALUE jd = rt__valid_weeknum_p(year, week, wday, INT2FIX(0), sg); + if (!NIL_P(jd)) + return jd; + } + } + + { + VALUE year, week, wday; + + wday = ref_hash("wday"); + if (NIL_P(wday)) + wday = ref_hash("cwday"); + if (!NIL_P(wday)) + wday = f_mod(f_sub(wday, INT2FIX(1)), + INT2FIX(7)); + + if (!NIL_P(wday) && + !NIL_P(week = ref_hash("wnum1")) && + !NIL_P(year = ref_hash("year"))) { + VALUE jd = rt__valid_weeknum_p(year, week, wday, INT2FIX(1), sg); + if (!NIL_P(jd)) + return jd; + } + } + return Qnil; +} + +static VALUE +d_new_by_frags(VALUE klass, VALUE hash, VALUE sg) +{ + VALUE jd; + + if (!c_valid_start_p(NUM2DBL(sg))) { + sg = INT2FIX(DEFAULT_SG); + rb_warning("invalid start is ignored"); + } + + if (NIL_P(hash)) + rb_raise(rb_eArgError, "invalid date"); + + if (NIL_P(ref_hash("jd")) && + NIL_P(ref_hash("yday")) && + !NIL_P(ref_hash("year")) && + !NIL_P(ref_hash("mon")) && + !NIL_P(ref_hash("mday"))) + jd = rt__valid_civil_p(ref_hash("year"), + ref_hash("mon"), + ref_hash("mday"), sg); + else { + hash = rt_rewrite_frags(hash); + hash = rt_complete_frags(klass, hash); + jd = rt__valid_date_frags_p(hash, sg); + } + + if (NIL_P(jd)) + rb_raise(rb_eArgError, "invalid date"); + { + VALUE nth; + int rjd; + + decode_jd(jd, &nth, &rjd); + return d_simple_new_internal(klass, + nth, rjd, + NUM2DBL(sg), + 0, 0, 0, + HAVE_JD); + } +} + +VALUE date__strptime(const char *str, size_t slen, + const char *fmt, size_t flen, VALUE hash); + +static VALUE +date_s__strptime_internal(int argc, VALUE *argv, VALUE klass, + const char *default_fmt) +{ + VALUE vstr, vfmt, hash; + const char *str, *fmt; + size_t slen, flen; + + rb_scan_args(argc, argv, "11", &vstr, &vfmt); + + StringValue(vstr); + if (!rb_enc_str_asciicompat_p(vstr)) + rb_raise(rb_eArgError, + "string should have ASCII compatible encoding"); + str = RSTRING_PTR(vstr); + slen = RSTRING_LEN(vstr); + if (argc < 2) { + fmt = default_fmt; + flen = strlen(default_fmt); + } + else { + StringValue(vfmt); + if (!rb_enc_str_asciicompat_p(vfmt)) + rb_raise(rb_eArgError, + "format should have ASCII compatible encoding"); + fmt = RSTRING_PTR(vfmt); + flen = RSTRING_LEN(vfmt); + } + hash = rb_hash_new(); + if (NIL_P(date__strptime(str, slen, fmt, flen, hash))) + return Qnil; + + { + VALUE zone = ref_hash("zone"); + VALUE left = ref_hash("leftover"); + + if (!NIL_P(zone)) { + rb_enc_copy(zone, vstr); + OBJ_INFECT(zone, vstr); + set_hash("zone", zone); + } + if (!NIL_P(left)) { + rb_enc_copy(left, vstr); + OBJ_INFECT(left, vstr); + set_hash("leftover", left); + } + } + + return hash; +} + +/* + * call-seq: + * Date._strptime(string[, format='%F']) -> hash + * + * Parses the given representation of date and time with the given + * template, and returns a hash of parsed elements. _strptime does + * not support specification of flags and width unlike strftime. + * + * Date._strptime('2001-02-03', '%Y-%m-%d') + * #=> {:year=>2001, :mon=>2, :mday=>3} + * + * See also strptime(3) and strftime. + */ +static VALUE +date_s__strptime(int argc, VALUE *argv, VALUE klass) +{ + return date_s__strptime_internal(argc, argv, klass, "%F"); +} + +/* + * call-seq: + * Date.strptime([string='-4712-01-01'[, format='%F'[, start=ITALY]]]) -> date + * + * Parses the given representation of date and time with the given + * template, and creates a date object. strptime does not support + * specification of flags and width unlike strftime. + * + * Date.strptime('2001-02-03', '%Y-%m-%d') #=> # + * Date.strptime('03-02-2001', '%d-%m-%Y') #=> # + * Date.strptime('2001-034', '%Y-%j') #=> # + * Date.strptime('2001-W05-6', '%G-W%V-%u') #=> # + * Date.strptime('2001 04 6', '%Y %U %w') #=> # + * Date.strptime('2001 05 6', '%Y %W %u') #=> # + * Date.strptime('sat3feb01', '%a%d%b%y') #=> # + * + * See also strptime(3) and strftime. + */ +static VALUE +date_s_strptime(int argc, VALUE *argv, VALUE klass) +{ + VALUE str, fmt, sg; + + rb_scan_args(argc, argv, "03", &str, &fmt, &sg); + + switch (argc) { + case 0: + str = rb_str_new2("-4712-01-01"); + case 1: + fmt = rb_str_new2("%F"); + case 2: + sg = INT2FIX(DEFAULT_SG); + } + + { + VALUE argv2[2], hash; + + argv2[0] = str; + argv2[1] = fmt; + hash = date_s__strptime(2, argv2, klass); + return d_new_by_frags(klass, hash, sg); + } +} + +VALUE date__parse(VALUE str, VALUE comp); + +static VALUE +date_s__parse_internal(int argc, VALUE *argv, VALUE klass) +{ + VALUE vstr, vcomp, hash; + + rb_scan_args(argc, argv, "11", &vstr, &vcomp); + StringValue(vstr); + if (!rb_enc_str_asciicompat_p(vstr)) + rb_raise(rb_eArgError, + "string should have ASCII compatible encoding"); + if (argc < 2) + vcomp = Qtrue; + + hash = date__parse(vstr, vcomp); + + { + VALUE zone = ref_hash("zone"); + + if (!NIL_P(zone)) { + rb_enc_copy(zone, vstr); + OBJ_INFECT(zone, vstr); + set_hash("zone", zone); + } + } + + return hash; +} + +/* + * call-seq: + * Date._parse(string[, comp=true]) -> hash + * + * Parses the given representation of date and time, and returns a + * hash of parsed elements. This method does not function as a + * validator. + * + * If the optional second argument is true and the detected year is in + * the range "00" to "99", considers the year a 2-digit form and makes + * it full. + * + * Date._parse('2001-02-03') #=> {:year=>2001, :mon=>2, :mday=>3} + */ +static VALUE +date_s__parse(int argc, VALUE *argv, VALUE klass) +{ + return date_s__parse_internal(argc, argv, klass); +} + +/* + * call-seq: + * Date.parse(string='-4712-01-01'[, comp=true[, start=ITALY]]) -> date + * + * Parses the given representation of date and time, and creates a + * date object. This method does not function as a validator. + * + * If the optional second argument is true and the detected year is in + * the range "00" to "99", considers the year a 2-digit form and makes + * it full. + * + * Date.parse('2001-02-03') #=> # + * Date.parse('20010203') #=> # + * Date.parse('3rd Feb 2001') #=> # + */ +static VALUE +date_s_parse(int argc, VALUE *argv, VALUE klass) +{ + VALUE str, comp, sg; + + rb_scan_args(argc, argv, "03", &str, &comp, &sg); + + switch (argc) { + case 0: + str = rb_str_new2("-4712-01-01"); + case 1: + comp = Qtrue; + case 2: + sg = INT2FIX(DEFAULT_SG); + } + + { + VALUE argv2[2], hash; + + argv2[0] = str; + argv2[1] = comp; + hash = date_s__parse(2, argv2, klass); + return d_new_by_frags(klass, hash, sg); + } +} + +VALUE date__iso8601(VALUE); +VALUE date__rfc3339(VALUE); +VALUE date__xmlschema(VALUE); +VALUE date__rfc2822(VALUE); +VALUE date__httpdate(VALUE); +VALUE date__jisx0301(VALUE); + +/* + * call-seq: + * Date._iso8601(string) -> hash + * + * Returns a hash of parsed elements. + */ +static VALUE +date_s__iso8601(VALUE klass, VALUE str) +{ + return date__iso8601(str); +} + +/* + * call-seq: + * Date.iso8601(string='-4712-01-01'[, start=ITALY]) -> date + * + * Creates a new Date object by parsing from a string according to + * some typical ISO 8601 formats. + * + * Date.iso8601('2001-02-03') #=> # + * Date.iso8601('20010203') #=> # + * Date.iso8601('2001-W05-6') #=> # + */ +static VALUE +date_s_iso8601(int argc, VALUE *argv, VALUE klass) +{ + VALUE str, sg; + + rb_scan_args(argc, argv, "02", &str, &sg); + + switch (argc) { + case 0: + str = rb_str_new2("-4712-01-01"); + case 1: + sg = INT2FIX(DEFAULT_SG); + } + + { + VALUE hash = date_s__iso8601(klass, str); + return d_new_by_frags(klass, hash, sg); + } +} + +/* + * call-seq: + * Date._rfc3339(string) -> hash + * + * Returns a hash of parsed elements. + */ +static VALUE +date_s__rfc3339(VALUE klass, VALUE str) +{ + return date__rfc3339(str); +} + +/* + * call-seq: + * Date.rfc3339(string='-4712-01-01T00:00:00+00:00'[, start=ITALY]) -> date + * + * Creates a new Date object by parsing from a string according to + * some typical RFC 3339 formats. + * + * Date.rfc3339('2001-02-03T04:05:06+07:00') #=> # + */ +static VALUE +date_s_rfc3339(int argc, VALUE *argv, VALUE klass) +{ + VALUE str, sg; + + rb_scan_args(argc, argv, "02", &str, &sg); + + switch (argc) { + case 0: + str = rb_str_new2("-4712-01-01T00:00:00+00:00"); + case 1: + sg = INT2FIX(DEFAULT_SG); + } + + { + VALUE hash = date_s__rfc3339(klass, str); + return d_new_by_frags(klass, hash, sg); + } +} + +/* + * call-seq: + * Date._xmlschema(string) -> hash + * + * Returns a hash of parsed elements. + */ +static VALUE +date_s__xmlschema(VALUE klass, VALUE str) +{ + return date__xmlschema(str); +} + +/* + * call-seq: + * Date.xmlschema(string='-4712-01-01'[, start=ITALY]) -> date + * + * Creates a new Date object by parsing from a string according to + * some typical XML Schema formats. + * + * Date.xmlschema('2001-02-03') #=> # + */ +static VALUE +date_s_xmlschema(int argc, VALUE *argv, VALUE klass) +{ + VALUE str, sg; + + rb_scan_args(argc, argv, "02", &str, &sg); + + switch (argc) { + case 0: + str = rb_str_new2("-4712-01-01"); + case 1: + sg = INT2FIX(DEFAULT_SG); + } + + { + VALUE hash = date_s__xmlschema(klass, str); + return d_new_by_frags(klass, hash, sg); + } +} + +/* + * call-seq: + * Date._rfc2822(string) -> hash + * Date._rfc822(string) -> hash + * + * Returns a hash of parsed elements. + */ +static VALUE +date_s__rfc2822(VALUE klass, VALUE str) +{ + return date__rfc2822(str); +} + +/* + * call-seq: + * Date.rfc2822(string='Mon, 1 Jan -4712 00:00:00 +0000'[, start=ITALY]) -> date + * Date.rfc822(string='Mon, 1 Jan -4712 00:00:00 +0000'[, start=ITALY]) -> date + * + * Creates a new Date object by parsing from a string according to + * some typical RFC 2822 formats. + * + * Date.rfc2822('Sat, 3 Feb 2001 00:00:00 +0000') + * #=> # + */ +static VALUE +date_s_rfc2822(int argc, VALUE *argv, VALUE klass) +{ + VALUE str, sg; + + rb_scan_args(argc, argv, "02", &str, &sg); + + switch (argc) { + case 0: + str = rb_str_new2("Mon, 1 Jan -4712 00:00:00 +0000"); + case 1: + sg = INT2FIX(DEFAULT_SG); + } + + { + VALUE hash = date_s__rfc2822(klass, str); + return d_new_by_frags(klass, hash, sg); + } +} + +/* + * call-seq: + * Date._httpdate(string) -> hash + * + * Returns a hash of parsed elements. + */ +static VALUE +date_s__httpdate(VALUE klass, VALUE str) +{ + return date__httpdate(str); +} + +/* + * call-seq: + * Date.httpdate(string='Mon, 01 Jan -4712 00:00:00 GMT'[, start=ITALY]) -> date + * + * Creates a new Date object by parsing from a string according to + * some RFC 2616 format. + * + * Date.httpdate('Sat, 03 Feb 2001 00:00:00 GMT') + * #=> # + */ +static VALUE +date_s_httpdate(int argc, VALUE *argv, VALUE klass) +{ + VALUE str, sg; + + rb_scan_args(argc, argv, "02", &str, &sg); + + switch (argc) { + case 0: + str = rb_str_new2("Mon, 01 Jan -4712 00:00:00 GMT"); + case 1: + sg = INT2FIX(DEFAULT_SG); + } + + { + VALUE hash = date_s__httpdate(klass, str); + return d_new_by_frags(klass, hash, sg); + } +} + +/* + * call-seq: + * Date._jisx0301(string) -> hash + * + * Returns a hash of parsed elements. + */ +static VALUE +date_s__jisx0301(VALUE klass, VALUE str) +{ + return date__jisx0301(str); +} + +/* + * call-seq: + * Date.jisx0301(string='-4712-01-01'[, start=ITALY]) -> date + * + * Creates a new Date object by parsing from a string according to + * some typical JIS X 0301 formats. + * + * Date.jisx0301('H13.02.03') #=> # + */ +static VALUE +date_s_jisx0301(int argc, VALUE *argv, VALUE klass) +{ + VALUE str, sg; + + rb_scan_args(argc, argv, "02", &str, &sg); + + switch (argc) { + case 0: + str = rb_str_new2("-4712-01-01"); + case 1: + sg = INT2FIX(DEFAULT_SG); + } + + { + VALUE hash = date_s__jisx0301(klass, str); + return d_new_by_frags(klass, hash, sg); + } +} + +static VALUE +dup_obj(VALUE self) +{ + get_d1a(self); + + if (simple_dat_p(adat)) { + VALUE new = d_lite_s_alloc_simple(rb_obj_class(self)); + { + get_d1b(new); + bdat->s = adat->s; + RB_OBJ_WRITTEN(new, Qundef, bdat->s.nth); + return new; + } + } + else { + VALUE new = d_lite_s_alloc_complex(rb_obj_class(self)); + { + get_d1b(new); + bdat->c = adat->c; + RB_OBJ_WRITTEN(new, Qundef, bdat->c.nth); + RB_OBJ_WRITTEN(new, Qundef, bdat->c.sf); + return new; + } + } +} + +static VALUE +dup_obj_as_complex(VALUE self) +{ + get_d1a(self); + + if (simple_dat_p(adat)) { + VALUE new = d_lite_s_alloc_complex(rb_obj_class(self)); + { + get_d1b(new); + copy_simple_to_complex(new, &bdat->c, &adat->s); + bdat->c.flags |= HAVE_DF | COMPLEX_DAT; + return new; + } + } + else { + VALUE new = d_lite_s_alloc_complex(rb_obj_class(self)); + { + get_d1b(new); + bdat->c = adat->c; + RB_OBJ_WRITTEN(new, Qundef, bdat->c.nth); + RB_OBJ_WRITTEN(new, Qundef, bdat->c.sf); + return new; + } + } +} + +#define val2off(vof,iof) \ +{\ + if (!offset_to_sec(vof, &iof)) {\ + iof = 0;\ + rb_warning("invalid offset is ignored");\ + }\ +} + +#ifndef NDEBUG +static VALUE +d_lite_initialize(int argc, VALUE *argv, VALUE self) +{ + VALUE jd, vjd, vdf, sf, vsf, vof, vsg; + int df, of; + double sg; + + rb_check_frozen(self); + rb_check_trusted(self); + + rb_scan_args(argc, argv, "05", &vjd, &vdf, &vsf, &vof, &vsg); + + jd = INT2FIX(0); + df = 0; + sf = INT2FIX(0); + of = 0; + sg = DEFAULT_SG; + + switch (argc) { + case 5: + val2sg(vsg, sg); + case 4: + val2off(vof, of); + case 3: + sf = vsf; + if (f_lt_p(sf, INT2FIX(0)) || + f_ge_p(sf, INT2FIX(SECOND_IN_NANOSECONDS))) + rb_raise(rb_eArgError, "invalid second fraction"); + case 2: + df = NUM2INT(vdf); + if (df < 0 || df >= DAY_IN_SECONDS) + rb_raise(rb_eArgError, "invalid day fraction"); + case 1: + jd = vjd; + } + + { + VALUE nth; + int rjd; + + get_d1(self); + + decode_jd(jd, &nth, &rjd); + if (!df && f_zero_p(sf) && !of) { + set_to_simple(self, &dat->s, nth, rjd, sg, 0, 0, 0, HAVE_JD); + } + else { + if (!complex_dat_p(dat)) + rb_raise(rb_eArgError, + "cannot load complex into simple"); + + set_to_complex(&dat->c, nth, rjd, df, sf, of, sg, + 0, 0, 0, 0, 0, 0, HAVE_JD | HAVE_DF | COMPLEX_DAT); + } + } + return self; +} +#endif + +/* :nodoc: */ +static VALUE +d_lite_initialize_copy(VALUE copy, VALUE date) +{ + rb_check_frozen(copy); + rb_check_trusted(copy); + + if (copy == date) + return copy; + { + get_d2(copy, date); + if (simple_dat_p(bdat)) { + adat->s = bdat->s; + adat->s.flags &= ~COMPLEX_DAT; + } + else { + if (!complex_dat_p(adat)) + rb_raise(rb_eArgError, + "cannot load complex into simple"); + + adat->c = bdat->c; + adat->c.flags |= COMPLEX_DAT; + } + } + return copy; +} + +#ifndef NDEBUG +static VALUE +d_lite_fill(VALUE self) +{ + get_d1(self); + + if (simple_dat_p(dat)) { + get_s_jd(dat); + get_s_civil(dat); + } + else { + get_c_jd(dat); + get_c_civil(dat); + get_c_df(dat); + get_c_time(dat); + } + return self; +} +#endif + +/* + * call-seq: + * d.ajd -> rational + * + * Returns the astronomical Julian day number. This is a fractional + * number, which is not adjusted by the offset. + * + * DateTime.new(2001,2,3,4,5,6,'+7').ajd #=> (11769328217/4800) + * DateTime.new(2001,2,2,14,5,6,'-7').ajd #=> (11769328217/4800) + */ +static VALUE +d_lite_ajd(VALUE self) +{ + get_d1(self); + return m_ajd(dat); +} + +/* + * call-seq: + * d.amjd -> rational + * + * Returns the astronomical modified Julian day number. This is + * a fractional number, which is not adjusted by the offset. + * + * DateTime.new(2001,2,3,4,5,6,'+7').amjd #=> (249325817/4800) + * DateTime.new(2001,2,2,14,5,6,'-7').amjd #=> (249325817/4800) + */ +static VALUE +d_lite_amjd(VALUE self) +{ + get_d1(self); + return m_amjd(dat); +} + +/* + * call-seq: + * d.jd -> integer + * + * Returns the Julian day number. This is a whole number, which is + * adjusted by the offset as the local time. + * + * DateTime.new(2001,2,3,4,5,6,'+7').jd #=> 2451944 + * DateTime.new(2001,2,3,4,5,6,'-7').jd #=> 2451944 + */ +static VALUE +d_lite_jd(VALUE self) +{ + get_d1(self); + return m_real_local_jd(dat); +} + +/* + * call-seq: + * d.mjd -> integer + * + * Returns the modified Julian day number. This is a whole number, + * which is adjusted by the offset as the local time. + * + * DateTime.new(2001,2,3,4,5,6,'+7').mjd #=> 51943 + * DateTime.new(2001,2,3,4,5,6,'-7').mjd #=> 51943 + */ +static VALUE +d_lite_mjd(VALUE self) +{ + get_d1(self); + return f_sub(m_real_local_jd(dat), INT2FIX(2400001)); +} + +/* + * call-seq: + * d.ld -> integer + * + * Returns the Lilian day number. This is a whole number, which is + * adjusted by the offset as the local time. + * + * Date.new(2001,2,3).ld #=> 152784 + */ +static VALUE +d_lite_ld(VALUE self) +{ + get_d1(self); + return f_sub(m_real_local_jd(dat), INT2FIX(2299160)); +} + +/* + * call-seq: + * d.year -> integer + * + * Returns the year. + * + * Date.new(2001,2,3).year #=> 2001 + * (Date.new(1,1,1) - 1).year #=> 0 + */ +static VALUE +d_lite_year(VALUE self) +{ + get_d1(self); + return m_real_year(dat); +} + +/* + * call-seq: + * d.yday -> fixnum + * + * Returns the day of the year (1-366). + * + * Date.new(2001,2,3).yday #=> 34 + */ +static VALUE +d_lite_yday(VALUE self) +{ + get_d1(self); + return INT2FIX(m_yday(dat)); +} + +/* + * call-seq: + * d.mon -> fixnum + * d.month -> fixnum + * + * Returns the month (1-12). + * + * Date.new(2001,2,3).mon #=> 2 + */ +static VALUE +d_lite_mon(VALUE self) +{ + get_d1(self); + return INT2FIX(m_mon(dat)); +} + +/* + * call-seq: + * d.mday -> fixnum + * d.day -> fixnum + * + * Returns the day of the month (1-31). + * + * Date.new(2001,2,3).mday #=> 3 + */ +static VALUE +d_lite_mday(VALUE self) +{ + get_d1(self); + return INT2FIX(m_mday(dat)); +} + +/* + * call-seq: + * d.day_fraction -> rational + * + * Returns the fractional part of the day. + * + * DateTime.new(2001,2,3,12).day_fraction #=> (1/2) + */ +static VALUE +d_lite_day_fraction(VALUE self) +{ + get_d1(self); + if (simple_dat_p(dat)) + return INT2FIX(0); + return m_fr(dat); +} + +/* + * call-seq: + * d.cwyear -> integer + * + * Returns the calendar week based year. + * + * Date.new(2001,2,3).cwyear #=> 2001 + * Date.new(2000,1,1).cwyear #=> 1999 + */ +static VALUE +d_lite_cwyear(VALUE self) +{ + get_d1(self); + return m_real_cwyear(dat); +} + +/* + * call-seq: + * d.cweek -> fixnum + * + * Returns the calendar week number (1-53). + * + * Date.new(2001,2,3).cweek #=> 5 + */ +static VALUE +d_lite_cweek(VALUE self) +{ + get_d1(self); + return INT2FIX(m_cweek(dat)); +} + +/* + * call-seq: + * d.cwday -> fixnum + * + * Returns the day of calendar week (1-7, Monday is 1). + * + * Date.new(2001,2,3).cwday #=> 6 + */ +static VALUE +d_lite_cwday(VALUE self) +{ + get_d1(self); + return INT2FIX(m_cwday(dat)); +} + +#ifndef NDEBUG +static VALUE +d_lite_wnum0(VALUE self) +{ + get_d1(self); + return INT2FIX(m_wnum0(dat)); +} + +static VALUE +d_lite_wnum1(VALUE self) +{ + get_d1(self); + return INT2FIX(m_wnum1(dat)); +} +#endif + +/* + * call-seq: + * d.wday -> fixnum + * + * Returns the day of week (0-6, Sunday is zero). + * + * Date.new(2001,2,3).wday #=> 6 + */ +static VALUE +d_lite_wday(VALUE self) +{ + get_d1(self); + return INT2FIX(m_wday(dat)); +} + +/* + * call-seq: + * d.sunday? -> bool + * + * Returns true if the date is Sunday. + */ +static VALUE +d_lite_sunday_p(VALUE self) +{ + get_d1(self); + return f_boolcast(m_wday(dat) == 0); +} + +/* + * call-seq: + * d.monday? -> bool + * + * Returns true if the date is Monday. + */ +static VALUE +d_lite_monday_p(VALUE self) +{ + get_d1(self); + return f_boolcast(m_wday(dat) == 1); +} + +/* + * call-seq: + * d.tuesday? -> bool + * + * Returns true if the date is Tuesday. + */ +static VALUE +d_lite_tuesday_p(VALUE self) +{ + get_d1(self); + return f_boolcast(m_wday(dat) == 2); +} + +/* + * call-seq: + * d.wednesday? -> bool + * + * Returns true if the date is Wednesday. + */ +static VALUE +d_lite_wednesday_p(VALUE self) +{ + get_d1(self); + return f_boolcast(m_wday(dat) == 3); +} + +/* + * call-seq: + * d.thursday? -> bool + * + * Returns true if the date is Thursday. + */ +static VALUE +d_lite_thursday_p(VALUE self) +{ + get_d1(self); + return f_boolcast(m_wday(dat) == 4); +} + +/* + * call-seq: + * d.friday? -> bool + * + * Returns true if the date is Friday. + */ +static VALUE +d_lite_friday_p(VALUE self) +{ + get_d1(self); + return f_boolcast(m_wday(dat) == 5); +} + +/* + * call-seq: + * d.saturday? -> bool + * + * Returns true if the date is Saturday. + */ +static VALUE +d_lite_saturday_p(VALUE self) +{ + get_d1(self); + return f_boolcast(m_wday(dat) == 6); +} + +#ifndef NDEBUG +static VALUE +d_lite_nth_kday_p(VALUE self, VALUE n, VALUE k) +{ + int rjd, ns; + + get_d1(self); + + if (NUM2INT(k) != m_wday(dat)) + return Qfalse; + + c_nth_kday_to_jd(m_year(dat), m_mon(dat), + NUM2INT(n), NUM2INT(k), m_virtual_sg(dat), /* !=m_sg() */ + &rjd, &ns); + if (m_local_jd(dat) != rjd) + return Qfalse; + return Qtrue; +} +#endif + +/* + * call-seq: + * d.hour -> fixnum + * + * Returns the hour (0-23). + * + * DateTime.new(2001,2,3,4,5,6).hour #=> 4 + */ +static VALUE +d_lite_hour(VALUE self) +{ + get_d1(self); + return INT2FIX(m_hour(dat)); +} + +/* + * call-seq: + * d.min -> fixnum + * d.minute -> fixnum + * + * Returns the minute (0-59). + * + * DateTime.new(2001,2,3,4,5,6).min #=> 5 + */ +static VALUE +d_lite_min(VALUE self) +{ + get_d1(self); + return INT2FIX(m_min(dat)); +} + +/* + * call-seq: + * d.sec -> fixnum + * d.second -> fixnum + * + * Returns the second (0-59). + * + * DateTime.new(2001,2,3,4,5,6).sec #=> 6 + */ +static VALUE +d_lite_sec(VALUE self) +{ + get_d1(self); + return INT2FIX(m_sec(dat)); +} + +/* + * call-seq: + * d.sec_fraction -> rational + * d.second_fraction -> rational + * + * Returns the fractional part of the second. + * + * DateTime.new(2001,2,3,4,5,6.5).sec_fraction #=> (1/2) + */ +static VALUE +d_lite_sec_fraction(VALUE self) +{ + get_d1(self); + return m_sf_in_sec(dat); +} + +/* + * call-seq: + * d.offset -> rational + * + * Returns the offset. + * + * DateTime.parse('04pm+0730').offset #=> (5/16) + */ +static VALUE +d_lite_offset(VALUE self) +{ + get_d1(self); + return m_of_in_day(dat); +} + +/* + * call-seq: + * d.zone -> string + * + * Returns the timezone. + * + * DateTime.parse('04pm+0730').zone #=> "+07:30" + */ +static VALUE +d_lite_zone(VALUE self) +{ + get_d1(self); + return m_zone(dat); +} + +/* + * call-seq: + * d.julian? -> bool + * + * Retruns true if the date is before the day of calendar reform. + * + * Date.new(1582,10,15).julian? #=> false + * (Date.new(1582,10,15) - 1).julian? #=> true + */ +static VALUE +d_lite_julian_p(VALUE self) +{ + get_d1(self); + return f_boolcast(m_julian_p(dat)); +} + +/* + * call-seq: + * d.gregorian? -> bool + * + * Retunrs true if the date is on or after the day of calendar reform. + * + * Date.new(1582,10,15).gregorian? #=> true + * (Date.new(1582,10,15) - 1).gregorian? #=> false + */ +static VALUE +d_lite_gregorian_p(VALUE self) +{ + get_d1(self); + return f_boolcast(m_gregorian_p(dat)); +} + +/* + * call-seq: + * d.leap? -> bool + * + * Returns true if the year is a leap year. + * + * Date.new(2000).leap? #=> true + * Date.new(2001).leap? #=> false + */ +static VALUE +d_lite_leap_p(VALUE self) +{ + int rjd, ns, ry, rm, rd; + + get_d1(self); + if (m_gregorian_p(dat)) + return f_boolcast(c_gregorian_leap_p(m_year(dat))); + + c_civil_to_jd(m_year(dat), 3, 1, m_virtual_sg(dat), + &rjd, &ns); + c_jd_to_civil(rjd - 1, m_virtual_sg(dat), &ry, &rm, &rd); + return f_boolcast(rd == 29); +} + +/* + * call-seq: + * d.start -> float + * + * Returns the Julian day number denoting the day of calendar reform. + * + * Date.new(2001,2,3).start #=> 2299161.0 + * Date.new(2001,2,3,Date::GREGORIAN).start #=> -Infinity + */ +static VALUE +d_lite_start(VALUE self) +{ + get_d1(self); + return DBL2NUM(m_sg(dat)); +} + +static void +clear_civil(union DateData *x) +{ + if (simple_dat_p(x)) { + x->s.year = 0; +#ifndef USE_PACK + x->s.mon = 0; + x->s.mday = 0; +#else + x->s.pc = 0; +#endif + x->s.flags &= ~HAVE_CIVIL; + } + else { + x->c.year = 0; +#ifndef USE_PACK + x->c.mon = 0; + x->c.mday = 0; + x->c.hour = 0; + x->c.min = 0; + x->c.sec = 0; +#else + x->c.pc = 0; +#endif + x->c.flags &= ~(HAVE_CIVIL | HAVE_TIME); + } +} + +static void +set_sg(union DateData *x, double sg) +{ + if (simple_dat_p(x)) { + get_s_jd(x); + clear_civil(x); + x->s.sg = (date_sg_t)sg; + } else { + get_c_jd(x); + get_c_df(x); + clear_civil(x); + x->c.sg = (date_sg_t)sg; + } +} + +static VALUE +dup_obj_with_new_start(VALUE obj, double sg) +{ + volatile VALUE dup = dup_obj(obj); + { + get_d1(dup); + set_sg(dat, sg); + } + return dup; +} + +/* + * call-seq: + * d.new_start([start=Date::ITALY]) -> date + * + * Duplicates self and resets its the day of calendar reform. + * + * d = Date.new(1582,10,15) + * d.new_start(Date::JULIAN) #=> # + */ +static VALUE +d_lite_new_start(int argc, VALUE *argv, VALUE self) +{ + VALUE vsg; + double sg; + + rb_scan_args(argc, argv, "01", &vsg); + + sg = DEFAULT_SG; + if (argc >= 1) + val2sg(vsg, sg); + + return dup_obj_with_new_start(self, sg); +} + +/* + * call-seq: + * d.italy -> date + * + * This method is equivalent to new_start(Date::ITALY). + */ +static VALUE +d_lite_italy(VALUE self) +{ + return dup_obj_with_new_start(self, ITALY); +} + +/* + * call-seq: + * d.england -> date + * + * This method is equivalent to new_start(Date::ENGLAND). + */ +static VALUE +d_lite_england(VALUE self) +{ + return dup_obj_with_new_start(self, ENGLAND); +} + +/* + * call-seq: + * d.julian -> date + * + * This method is equivalent to new_start(Date::JULIAN). + */ +static VALUE +d_lite_julian(VALUE self) +{ + return dup_obj_with_new_start(self, JULIAN); +} + +/* + * call-seq: + * d.gregorian -> date + * + * This method is equivalent to new_start(Date::GREGORIAN). + */ +static VALUE +d_lite_gregorian(VALUE self) +{ + return dup_obj_with_new_start(self, GREGORIAN); +} + +static void +set_of(union DateData *x, int of) +{ + assert(complex_dat_p(x)); + get_c_jd(x); + get_c_df(x); + clear_civil(x); + x->c.of = of; +} + +static VALUE +dup_obj_with_new_offset(VALUE obj, int of) +{ + volatile VALUE dup = dup_obj_as_complex(obj); + { + get_d1(dup); + set_of(dat, of); + } + return dup; +} + +/* + * call-seq: + * d.new_offset([offset=0]) -> date + * + * Duplicates self and resets its offset. + * + * d = DateTime.new(2001,2,3,4,5,6,'-02:00') + * #=> # + * d.new_offset('+09:00') #=> # + */ +static VALUE +d_lite_new_offset(int argc, VALUE *argv, VALUE self) +{ + VALUE vof; + int rof; + + rb_scan_args(argc, argv, "01", &vof); + + rof = 0; + if (argc >= 1) + val2off(vof, rof); + + return dup_obj_with_new_offset(self, rof); +} + +/* + * call-seq: + * d + other -> date + * + * Returns a date object pointing other days after self. The other + * should be a numeric value. If the other is flonum, assumes its + * precision is at most nanosecond. + * + * Date.new(2001,2,3) + 1 #=> # + * DateTime.new(2001,2,3) + Rational(1,2) + * #=> # + * DateTime.new(2001,2,3) + Rational(-1,2) + * #=> # + * DateTime.jd(0,12) + DateTime.new(2001,2,3).ajd + * #=> # + */ +static VALUE +d_lite_plus(VALUE self, VALUE other) +{ + get_d1(self); + + switch (TYPE(other)) { + case T_FIXNUM: + { + VALUE nth; + long t; + int jd; + + nth = m_nth(dat); + t = FIX2LONG(other); + if (DIV(t, CM_PERIOD)) { + nth = f_add(nth, INT2FIX(DIV(t, CM_PERIOD))); + t = MOD(t, CM_PERIOD); + } + + if (!t) + jd = m_jd(dat); + else { + jd = m_jd(dat) + (int)t; + canonicalize_jd(nth, jd); + } + + if (simple_dat_p(dat)) + return d_simple_new_internal(rb_obj_class(self), + nth, jd, + dat->s.sg, + 0, 0, 0, + (dat->s.flags | HAVE_JD) & + ~HAVE_CIVIL); + else + return d_complex_new_internal(rb_obj_class(self), + nth, jd, + dat->c.df, dat->c.sf, + dat->c.of, dat->c.sg, + 0, 0, 0, +#ifndef USE_PACK + dat->c.hour, + dat->c.min, + dat->c.sec, +#else + EX_HOUR(dat->c.pc), + EX_MIN(dat->c.pc), + EX_SEC(dat->c.pc), +#endif + (dat->c.flags | HAVE_JD) & + ~HAVE_CIVIL); + } + break; + case T_BIGNUM: + { + VALUE nth; + int jd, s; + + if (f_positive_p(other)) + s = +1; + else { + s = -1; + other = f_negate(other); + } + + nth = f_idiv(other, INT2FIX(CM_PERIOD)); + jd = FIX2INT(f_mod(other, INT2FIX(CM_PERIOD))); + + if (s < 0) { + nth = f_negate(nth); + jd = -jd; + } + + if (!jd) + jd = m_jd(dat); + else { + jd = m_jd(dat) + jd; + canonicalize_jd(nth, jd); + } + + if (f_zero_p(nth)) + nth = m_nth(dat); + else + nth = f_add(m_nth(dat), nth); + + if (simple_dat_p(dat)) + return d_simple_new_internal(rb_obj_class(self), + nth, jd, + dat->s.sg, + 0, 0, 0, + (dat->s.flags | HAVE_JD) & + ~HAVE_CIVIL); + else + return d_complex_new_internal(rb_obj_class(self), + nth, jd, + dat->c.df, dat->c.sf, + dat->c.of, dat->c.sg, + 0, 0, 0, +#ifndef USE_PACK + dat->c.hour, + dat->c.min, + dat->c.sec, +#else + EX_HOUR(dat->c.pc), + EX_MIN(dat->c.pc), + EX_SEC(dat->c.pc), +#endif + (dat->c.flags | HAVE_JD) & + ~HAVE_CIVIL); + } + break; + case T_FLOAT: + { + double jd, o, tmp; + int s, df; + VALUE nth, sf; + + o = RFLOAT_VALUE(other); + + if (o > 0) + s = +1; + else { + s = -1; + o = -o; + } + + o = modf(o, &tmp); + + if (!floor(tmp / CM_PERIOD)) { + nth = INT2FIX(0); + jd = (int)tmp; + } + else { + double i, f; + + f = modf(tmp / CM_PERIOD, &i); + nth = f_floor(DBL2NUM(i)); + jd = (int)(f * CM_PERIOD); + } + + o *= DAY_IN_SECONDS; + o = modf(o, &tmp); + df = (int)tmp; + o *= SECOND_IN_NANOSECONDS; + sf = INT2FIX((int)round(o)); + + if (s < 0) { + jd = -jd; + df = -df; + sf = f_negate(sf); + } + + if (f_zero_p(sf)) + sf = m_sf(dat); + else { + sf = f_add(m_sf(dat), sf); + if (f_lt_p(sf, INT2FIX(0))) { + df -= 1; + sf = f_add(sf, INT2FIX(SECOND_IN_NANOSECONDS)); + } + else if (f_ge_p(sf, INT2FIX(SECOND_IN_NANOSECONDS))) { + df += 1; + sf = f_sub(sf, INT2FIX(SECOND_IN_NANOSECONDS)); + } + } + + if (!df) + df = m_df(dat); + else { + df = m_df(dat) + df; + if (df < 0) { + jd -= 1; + df += DAY_IN_SECONDS; + } + else if (df >= DAY_IN_SECONDS) { + jd += 1; + df -= DAY_IN_SECONDS; + } + } + + if (!jd) + jd = m_jd(dat); + else { + jd = m_jd(dat) + jd; + canonicalize_jd(nth, jd); + } + + if (f_zero_p(nth)) + nth = m_nth(dat); + else + nth = f_add(m_nth(dat), nth); + + if (!df && f_zero_p(sf) && !m_of(dat)) + return d_simple_new_internal(rb_obj_class(self), + nth, (int)jd, + m_sg(dat), + 0, 0, 0, + (dat->s.flags | HAVE_JD) & + ~(HAVE_CIVIL | HAVE_TIME | + COMPLEX_DAT)); + else + return d_complex_new_internal(rb_obj_class(self), + nth, (int)jd, + df, sf, + m_of(dat), m_sg(dat), + 0, 0, 0, + 0, 0, 0, + (dat->c.flags | + HAVE_JD | HAVE_DF) & + ~(HAVE_CIVIL | HAVE_TIME)); + } + break; + default: + if (!k_numeric_p(other)) + rb_raise(rb_eTypeError, "expected numeric"); + other = f_to_r(other); +#ifdef CANONICALIZATION_FOR_MATHN + if (!k_rational_p(other)) + return d_lite_plus(self, other); +#endif + /* fall through */ + case T_RATIONAL: + { + VALUE nth, sf, t; + int jd, df, s; + + if (wholenum_p(other)) + return d_lite_plus(self, rb_rational_num(other)); + + if (f_positive_p(other)) + s = +1; + else { + s = -1; + other = f_negate(other); + } + + nth = f_idiv(other, INT2FIX(CM_PERIOD)); + t = f_mod(other, INT2FIX(CM_PERIOD)); + + jd = FIX2INT(f_idiv(t, INT2FIX(1))); + t = f_mod(t, INT2FIX(1)); + + t = f_mul(t, INT2FIX(DAY_IN_SECONDS)); + df = FIX2INT(f_idiv(t, INT2FIX(1))); + t = f_mod(t, INT2FIX(1)); + + sf = f_mul(t, INT2FIX(SECOND_IN_NANOSECONDS)); + + if (s < 0) { + nth = f_negate(nth); + jd = -jd; + df = -df; + sf = f_negate(sf); + } + + if (f_zero_p(sf)) + sf = m_sf(dat); + else { + sf = f_add(m_sf(dat), sf); + if (f_lt_p(sf, INT2FIX(0))) { + df -= 1; + sf = f_add(sf, INT2FIX(SECOND_IN_NANOSECONDS)); + } + else if (f_ge_p(sf, INT2FIX(SECOND_IN_NANOSECONDS))) { + df += 1; + sf = f_sub(sf, INT2FIX(SECOND_IN_NANOSECONDS)); + } + } + + if (!df) + df = m_df(dat); + else { + df = m_df(dat) + df; + if (df < 0) { + jd -= 1; + df += DAY_IN_SECONDS; + } + else if (df >= DAY_IN_SECONDS) { + jd += 1; + df -= DAY_IN_SECONDS; + } + } + + if (!jd) + jd = m_jd(dat); + else { + jd = m_jd(dat) + jd; + canonicalize_jd(nth, jd); + } + + if (f_zero_p(nth)) + nth = m_nth(dat); + else + nth = f_add(m_nth(dat), nth); + + if (!df && f_zero_p(sf) && !m_of(dat)) + return d_simple_new_internal(rb_obj_class(self), + nth, jd, + m_sg(dat), + 0, 0, 0, + (dat->s.flags | HAVE_JD) & + ~(HAVE_CIVIL | HAVE_TIME | + COMPLEX_DAT)); + else + return d_complex_new_internal(rb_obj_class(self), + nth, jd, + df, sf, + m_of(dat), m_sg(dat), + 0, 0, 0, + 0, 0, 0, + (dat->c.flags | + HAVE_JD | HAVE_DF) & + ~(HAVE_CIVIL | HAVE_TIME)); + } + break; + } +} + +static VALUE +minus_dd(VALUE self, VALUE other) +{ + get_d2(self, other); + + { + int d, df; + VALUE n, sf, r; + + n = f_sub(m_nth(adat), m_nth(bdat)); + d = m_jd(adat) - m_jd(bdat); + df = m_df(adat) - m_df(bdat); + sf = f_sub(m_sf(adat), m_sf(bdat)); + canonicalize_jd(n, d); + + if (df < 0) { + d -= 1; + df += DAY_IN_SECONDS; + } + else if (df >= DAY_IN_SECONDS) { + d += 1; + df -= DAY_IN_SECONDS; + } + + if (f_lt_p(sf, INT2FIX(0))) { + df -= 1; + sf = f_add(sf, INT2FIX(SECOND_IN_NANOSECONDS)); + } + else if (f_ge_p(sf, INT2FIX(SECOND_IN_NANOSECONDS))) { + df += 1; + sf = f_sub(sf, INT2FIX(SECOND_IN_NANOSECONDS)); + } + + if (f_zero_p(n)) + r = INT2FIX(0); + else + r = f_mul(n, INT2FIX(CM_PERIOD)); + + if (d) + r = f_add(r, rb_rational_new1(INT2FIX(d))); + if (df) + r = f_add(r, isec_to_day(df)); + if (f_nonzero_p(sf)) + r = f_add(r, ns_to_day(sf)); + + if (RB_TYPE_P(r, T_RATIONAL)) + return r; + return rb_rational_new1(r); + } +} + +/* + * call-seq: + * d - other -> date or rational + * + * Returns the difference between the two dates if the other is a date + * object. If the other is a numeric value, returns a date object + * pointing other days before self. If the other is flonum, assumes + * its precision is at most nanosecond. + * + * Date.new(2001,2,3) - 1 #=> # + * DateTime.new(2001,2,3) - Rational(1,2) + * #=> # + * Date.new(2001,2,3) - Date.new(2001) + * #=> (33/1) + * DateTime.new(2001,2,3) - DateTime.new(2001,2,2,12) + * #=> (1/2) + */ +static VALUE +d_lite_minus(VALUE self, VALUE other) +{ + if (k_date_p(other)) + return minus_dd(self, other); + + switch (TYPE(other)) { + case T_FIXNUM: + return d_lite_plus(self, LONG2NUM(-FIX2LONG(other))); + case T_FLOAT: + return d_lite_plus(self, DBL2NUM(-RFLOAT_VALUE(other))); + default: + if (!k_numeric_p(other)) + rb_raise(rb_eTypeError, "expected numeric"); + /* fall through */ + case T_BIGNUM: + case T_RATIONAL: + return d_lite_plus(self, f_negate(other)); + } +} + +/* + * call-seq: + * d.next_day([n=1]) -> date + * + * This method is equivalent to d + n. + */ +static VALUE +d_lite_next_day(int argc, VALUE *argv, VALUE self) +{ + VALUE n; + + rb_scan_args(argc, argv, "01", &n); + if (argc < 1) + n = INT2FIX(1); + return d_lite_plus(self, n); +} + +/* + * call-seq: + * d.prev_day([n=1]) -> date + * + * This method is equivalent to d - n. + */ +static VALUE +d_lite_prev_day(int argc, VALUE *argv, VALUE self) +{ + VALUE n; + + rb_scan_args(argc, argv, "01", &n); + if (argc < 1) + n = INT2FIX(1); + return d_lite_minus(self, n); +} + +/* + * call-seq: + * d.succ -> date + * d.next -> date + * + * Returns a date object denoting the following day. + */ +static VALUE +d_lite_next(VALUE self) +{ + return d_lite_next_day(0, (VALUE *)NULL, self); +} + +/* + * call-seq: + * d >> n -> date + * + * Returns a date object pointing n months after self. The n should + * be a numeric value. + * + * Date.new(2001,2,3) >> 1 #=> # + * Date.new(2001,1,31) >> 1 #=> # + * Date.new(2001,2,3) >> -2 #=> # + */ +static VALUE +d_lite_rshift(VALUE self, VALUE other) +{ + VALUE t, y, nth, rjd2; + int m, d, rjd; + double sg; + + get_d1(self); + t = f_add3(f_mul(m_real_year(dat), INT2FIX(12)), + INT2FIX(m_mon(dat) - 1), + other); + if (FIXNUM_P(t)) { + long it = FIX2LONG(t); + y = LONG2NUM(DIV(it, 12)); + it = MOD(it, 12); + m = (int)it + 1; + } + else { + y = f_idiv(t, INT2FIX(12)); + t = f_mod(t, INT2FIX(12)); + m = FIX2INT(t) + 1; + } + d = m_mday(dat); + sg = m_sg(dat); + + while (1) { + int ry, rm, rd, ns; + + if (valid_civil_p(y, m, d, sg, + &nth, &ry, + &rm, &rd, &rjd, &ns)) + break; + if (--d < 1) + rb_raise(rb_eArgError, "invalid date"); + } + encode_jd(nth, rjd, &rjd2); + return d_lite_plus(self, f_sub(rjd2, m_real_local_jd(dat))); +} + +/* + * call-seq: + * d << n -> date + * + * Returns a date object pointing n months before self. The n should + * be a numeric value. + * + * Date.new(2001,2,3) << 1 #=> # + * Date.new(2001,1,31) << 11 #=> # + * Date.new(2001,2,3) << -1 #=> # + */ +static VALUE +d_lite_lshift(VALUE self, VALUE other) +{ + return d_lite_rshift(self, f_negate(other)); +} + +/* + * call-seq: + * d.next_month([n=1]) -> date + * + * This method is equivalent to d >> n + */ +static VALUE +d_lite_next_month(int argc, VALUE *argv, VALUE self) +{ + VALUE n; + + rb_scan_args(argc, argv, "01", &n); + if (argc < 1) + n = INT2FIX(1); + return d_lite_rshift(self, n); +} + +/* + * call-seq: + * d.prev_month([n=1]) -> date + * + * This method is equivalent to d << n + */ +static VALUE +d_lite_prev_month(int argc, VALUE *argv, VALUE self) +{ + VALUE n; + + rb_scan_args(argc, argv, "01", &n); + if (argc < 1) + n = INT2FIX(1); + return d_lite_lshift(self, n); +} + +/* + * call-seq: + * d.next_year([n=1]) -> date + * + * This method is equivalent to d >> (n * 12) + */ +static VALUE +d_lite_next_year(int argc, VALUE *argv, VALUE self) +{ + VALUE n; + + rb_scan_args(argc, argv, "01", &n); + if (argc < 1) + n = INT2FIX(1); + return d_lite_rshift(self, f_mul(n, INT2FIX(12))); +} + +/* + * call-seq: + * d.prev_year([n=1]) -> date + * + * This method is equivalent to d << (n * 12) + */ +static VALUE +d_lite_prev_year(int argc, VALUE *argv, VALUE self) +{ + VALUE n; + + rb_scan_args(argc, argv, "01", &n); + if (argc < 1) + n = INT2FIX(1); + return d_lite_lshift(self, f_mul(n, INT2FIX(12))); +} + +static VALUE d_lite_cmp(VALUE, VALUE); + +/* + * call-seq: + * d.step(limit[, step=1]) -> enumerator + * d.step(limit[, step=1]){|date| ...} -> self + * + * Iterates evaluation of the given block, which takes a date object. + * The limit should be a date object. + * + * Date.new(2001).step(Date.new(2001,-1,-1)).select{|d| d.sunday?}.size + * #=> 52 + */ +static VALUE +d_lite_step(int argc, VALUE *argv, VALUE self) +{ + VALUE limit, step, date; + + rb_scan_args(argc, argv, "11", &limit, &step); + + if (argc < 2) + step = INT2FIX(1); + +#if 0 + if (f_zero_p(step)) + rb_raise(rb_eArgError, "step can't be 0"); +#endif + + RETURN_ENUMERATOR(self, argc, argv); + + date = self; + switch (FIX2INT(f_cmp(step, INT2FIX(0)))) { + case -1: + while (FIX2INT(d_lite_cmp(date, limit)) >= 0) { + rb_yield(date); + date = d_lite_plus(date, step); + } + break; + case 0: + while (1) + rb_yield(date); + break; + case 1: + while (FIX2INT(d_lite_cmp(date, limit)) <= 0) { + rb_yield(date); + date = d_lite_plus(date, step); + } + break; + default: + abort(); + } + return self; +} + +/* + * call-seq: + * d.upto(max) -> enumerator + * d.upto(max){|date| ...} -> self + * + * This method is equivalent to step(max, 1){|date| ...}. + */ +static VALUE +d_lite_upto(VALUE self, VALUE max) +{ + VALUE date; + + RETURN_ENUMERATOR(self, 1, &max); + + date = self; + while (FIX2INT(d_lite_cmp(date, max)) <= 0) { + rb_yield(date); + date = d_lite_plus(date, INT2FIX(1)); + } + return self; +} + +/* + * call-seq: + * d.downto(min) -> enumerator + * d.downto(min){|date| ...} -> self + * + * This method is equivalent to step(min, -1){|date| ...}. + */ +static VALUE +d_lite_downto(VALUE self, VALUE min) +{ + VALUE date; + + RETURN_ENUMERATOR(self, 1, &min); + + date = self; + while (FIX2INT(d_lite_cmp(date, min)) >= 0) { + rb_yield(date); + date = d_lite_plus(date, INT2FIX(-1)); + } + return self; +} + +static VALUE +cmp_gen(VALUE self, VALUE other) +{ + get_d1(self); + + if (k_numeric_p(other)) + return f_cmp(m_ajd(dat), other); + else if (k_date_p(other)) + return f_cmp(m_ajd(dat), f_ajd(other)); + return rb_num_coerce_cmp(self, other, rb_intern("<=>")); +} + +static VALUE +cmp_dd(VALUE self, VALUE other) +{ + get_d2(self, other); + + { + VALUE a_nth, b_nth, + a_sf, b_sf; + int a_jd, b_jd, + a_df, b_df; + + m_canonicalize_jd(self, adat); + m_canonicalize_jd(other, bdat); + a_nth = m_nth(adat); + b_nth = m_nth(bdat); + if (f_eqeq_p(a_nth, b_nth)) { + a_jd = m_jd(adat); + b_jd = m_jd(bdat); + if (a_jd == b_jd) { + a_df = m_df(adat); + b_df = m_df(bdat); + if (a_df == b_df) { + a_sf = m_sf(adat); + b_sf = m_sf(bdat); + if (f_eqeq_p(a_sf, b_sf)) { + return INT2FIX(0); + } + else if (f_lt_p(a_sf, b_sf)) { + return INT2FIX(-1); + } + else { + return INT2FIX(1); + } + } + else if (a_df < b_df) { + return INT2FIX(-1); + } + else { + return INT2FIX(1); + } + } + else if (a_jd < b_jd) { + return INT2FIX(-1); + } + else { + return INT2FIX(1); + } + } + else if (f_lt_p(a_nth, b_nth)) { + return INT2FIX(-1); + } + else { + return INT2FIX(1); + } + } +} + +/* + * call-seq: + * d <=> other -> -1, 0, +1 or nil + * + * Compares the two dates and returns -1, zero, 1 or nil. The other + * should be a date object or a numeric value as an astronomical + * Julian day number. + * + * Date.new(2001,2,3) <=> Date.new(2001,2,4) #=> -1 + * Date.new(2001,2,3) <=> Date.new(2001,2,3) #=> 0 + * Date.new(2001,2,3) <=> Date.new(2001,2,2) #=> 1 + * Date.new(2001,2,3) <=> Object.new #=> nil + * Date.new(2001,2,3) <=> Rational(4903887,2)#=> 0 + * + * See also Comparable. + */ +static VALUE +d_lite_cmp(VALUE self, VALUE other) +{ + if (!k_date_p(other)) + return cmp_gen(self, other); + + { + get_d2(self, other); + + if (!(simple_dat_p(adat) && simple_dat_p(bdat) && + m_gregorian_p(adat) == m_gregorian_p(bdat))) + return cmp_dd(self, other); + + { + VALUE a_nth, b_nth; + int a_jd, b_jd; + + m_canonicalize_jd(self, adat); + m_canonicalize_jd(other, bdat); + a_nth = m_nth(adat); + b_nth = m_nth(bdat); + if (f_eqeq_p(a_nth, b_nth)) { + a_jd = m_jd(adat); + b_jd = m_jd(bdat); + if (a_jd == b_jd) { + return INT2FIX(0); + } + else if (a_jd < b_jd) { + return INT2FIX(-1); + } + else { + return INT2FIX(1); + } + } + else if (f_lt_p(a_nth, b_nth)) { + return INT2FIX(-1); + } + else { + return INT2FIX(1); + } + } + } +} + +static VALUE +equal_gen(VALUE self, VALUE other) +{ + get_d1(self); + + if (k_numeric_p(other)) + return f_eqeq_p(m_real_local_jd(dat), other); + else if (k_date_p(other)) + return f_eqeq_p(m_real_local_jd(dat), f_jd(other)); + return rb_num_coerce_cmp(self, other, rb_intern("==")); +} + +/* + * call-seq: + * d === other -> bool + * + * Returns true if they are the same day. + * + * Date.new(2001,2,3) === Date.new(2001,2,3) + * #=> true + * Date.new(2001,2,3) === Date.new(2001,2,4) + * #=> false + * DateTime.new(2001,2,3) === DateTime.new(2001,2,3,12) + * #=> true + * DateTime.new(2001,2,3) === DateTime.new(2001,2,3,0,0,0,'+24:00') + * #=> true + * DateTime.new(2001,2,3) === DateTime.new(2001,2,4,0,0,0,'+24:00') + * #=> false + */ +static VALUE +d_lite_equal(VALUE self, VALUE other) +{ + if (!k_date_p(other)) + return equal_gen(self, other); + + { + get_d2(self, other); + + if (!(m_gregorian_p(adat) == m_gregorian_p(bdat))) + return equal_gen(self, other); + + { + VALUE a_nth, b_nth; + int a_jd, b_jd; + + m_canonicalize_jd(self, adat); + m_canonicalize_jd(other, bdat); + a_nth = m_nth(adat); + b_nth = m_nth(bdat); + a_jd = m_local_jd(adat); + b_jd = m_local_jd(bdat); + if (f_eqeq_p(a_nth, b_nth) && + a_jd == b_jd) + return Qtrue; + return Qfalse; + } + } +} + +/* :nodoc: */ +static VALUE +d_lite_eql_p(VALUE self, VALUE other) +{ + if (!k_date_p(other)) + return Qfalse; + return f_zero_p(d_lite_cmp(self, other)); +} + +/* :nodoc: */ +static VALUE +d_lite_hash(VALUE self) +{ + st_index_t v, h[4]; + + get_d1(self); + h[0] = m_nth(dat); + h[1] = m_jd(dat); + h[2] = m_df(dat); + h[3] = m_sf(dat); + v = rb_memhash(h, sizeof(h)); + return LONG2FIX(v); +} + +#include "date_tmx.h" +static void set_tmx(VALUE, struct tmx *); +static VALUE strftimev(const char *, VALUE, + void (*)(VALUE, struct tmx *)); + +/* + * call-seq: + * d.to_s -> string + * + * Returns a string in an ISO 8601 format (This method doesn't use the + * expanded representations). + * + * Date.new(2001,2,3).to_s #=> "2001-02-03" + */ +static VALUE +d_lite_to_s(VALUE self) +{ + return strftimev("%Y-%m-%d", self, set_tmx); +} + +#ifndef NDEBUG +static VALUE +mk_inspect_flags(union DateData *x) +{ + return rb_enc_sprintf(rb_usascii_encoding(), + "%c%c%c%c%c", + (x->flags & COMPLEX_DAT) ? 'C' : 'S', + (x->flags & HAVE_JD) ? 'j' : '-', + (x->flags & HAVE_DF) ? 'd' : '-', + (x->flags & HAVE_CIVIL) ? 'c' : '-', + (x->flags & HAVE_TIME) ? 't' : '-'); +} + +static VALUE +mk_inspect_raw(union DateData *x, const char *klass) +{ + if (simple_dat_p(x)) { + VALUE nth, flags; + + RB_GC_GUARD(nth) = f_inspect(x->s.nth); + RB_GC_GUARD(flags) = mk_inspect_flags(x); + + return rb_enc_sprintf(rb_usascii_encoding(), + "#<%s: " + "(%sth,%dj),+0s,%.0fj; " + "%dy%dm%dd; %s>", + klass ? klass : "?", + RSTRING_PTR(nth), x->s.jd, x->s.sg, +#ifndef USE_PACK + x->s.year, x->s.mon, x->s.mday, +#else + x->s.year, + EX_MON(x->s.pc), EX_MDAY(x->s.pc), +#endif + RSTRING_PTR(flags)); + } + else { + VALUE nth, sf, flags; + + RB_GC_GUARD(nth) = f_inspect(x->c.nth); + RB_GC_GUARD(sf) = f_inspect(x->c.sf); + RB_GC_GUARD(flags) = mk_inspect_flags(x); + + return rb_enc_sprintf(rb_usascii_encoding(), + "#<%s: " + "(%sth,%dj,%ds,%sn),%+ds,%.0fj; " + "%dy%dm%dd %dh%dm%ds; %s>", + klass ? klass : "?", + RSTRING_PTR(nth), x->c.jd, x->c.df, + RSTRING_PTR(sf), + x->c.of, x->c.sg, +#ifndef USE_PACK + x->c.year, x->c.mon, x->c.mday, + x->c.hour, x->c.min, x->c.sec, +#else + x->c.year, + EX_MON(x->c.pc), EX_MDAY(x->c.pc), + EX_HOUR(x->c.pc), EX_MIN(x->c.pc), + EX_SEC(x->c.pc), +#endif + RSTRING_PTR(flags)); + } +} + +static VALUE +d_lite_inspect_raw(VALUE self) +{ + get_d1(self); + return mk_inspect_raw(dat, rb_obj_classname(self)); +} +#endif + +static VALUE +mk_inspect(union DateData *x, const char *klass, const char *to_s) +{ + VALUE jd, sf; + + RB_GC_GUARD(jd) = f_inspect(m_real_jd(x)); + RB_GC_GUARD(sf) = f_inspect(m_sf(x)); + + return rb_enc_sprintf(rb_usascii_encoding(), + "#<%s: %s ((%sj,%ds,%sn),%+ds,%.0fj)>", + klass ? klass : "?", + to_s ? to_s : "?", + RSTRING_PTR(jd), m_df(x), RSTRING_PTR(sf), + m_of(x), m_sg(x)); +} + +/* + * call-seq: + * d.inspect -> string + * + * Returns the value as a string for inspection. + * + * Date.new(2001,2,3).inspect + * #=> "#" + * DateTime.new(2001,2,3,4,5,6,'-7').inspect + * #=> "#" + */ +static VALUE +d_lite_inspect(VALUE self) +{ + get_d1(self); + { + VALUE to_s; + + RB_GC_GUARD(to_s) = f_to_s(self); + return mk_inspect(dat, rb_obj_classname(self), RSTRING_PTR(to_s)); + } +} + +#include +#include "date_tmx.h" + +size_t date_strftime(char *s, size_t maxsize, const char *format, + const struct tmx *tmx); + +#define SMALLBUF 100 +static size_t +date_strftime_alloc(char **buf, const char *format, + struct tmx *tmx) +{ + size_t size, len, flen; + + (*buf)[0] = '\0'; + flen = strlen(format); + if (flen == 0) { + return 0; + } + errno = 0; + len = date_strftime(*buf, SMALLBUF, format, tmx); + if (len != 0 || (**buf == '\0' && errno != ERANGE)) return len; + for (size=1024; ; size*=2) { + *buf = xmalloc(size); + (*buf)[0] = '\0'; + len = date_strftime(*buf, size, format, tmx); + /* + * buflen can be zero EITHER because there's not enough + * room in the string, or because the control command + * goes to the empty string. Make a reasonable guess that + * if the buffer is 1024 times bigger than the length of the + * format string, it's not failing for lack of room. + */ + if (len > 0) break; + xfree(*buf); + if (size >= 1024 * flen) { + rb_sys_fail(format); + break; + } + } + return len; +} + +static VALUE +tmx_m_secs(union DateData *x) +{ + VALUE s; + int df; + + s = day_to_sec(f_sub(m_real_jd(x), + UNIX_EPOCH_IN_CJD)); + if (simple_dat_p(x)) + return s; + df = m_df(x); + if (df) + s = f_add(s, INT2FIX(df)); + return s; +} + +#define MILLISECOND_IN_NANOSECONDS 1000000 + +static VALUE +tmx_m_msecs(union DateData *x) +{ + VALUE s, sf; + + s = sec_to_ms(tmx_m_secs(x)); + if (simple_dat_p(x)) + return s; + sf = m_sf(x); + if (f_nonzero_p(sf)) + s = f_add(s, f_div(sf, INT2FIX(MILLISECOND_IN_NANOSECONDS))); + return s; +} + +static int +tmx_m_of(union DateData *x) +{ + return m_of(x); +} + +static char * +tmx_m_zone(union DateData *x) +{ + return RSTRING_PTR(m_zone(x)); +} + +static struct tmx_funcs tmx_funcs = { + (VALUE (*)(void *))m_real_year, + (int (*)(void *))m_yday, + (int (*)(void *))m_mon, + (int (*)(void *))m_mday, + (VALUE (*)(void *))m_real_cwyear, + (int (*)(void *))m_cweek, + (int (*)(void *))m_cwday, + (int (*)(void *))m_wnum0, + (int (*)(void *))m_wnum1, + (int (*)(void *))m_wday, + (int (*)(void *))m_hour, + (int (*)(void *))m_min, + (int (*)(void *))m_sec, + (VALUE (*)(void *))m_sf_in_sec, + (VALUE (*)(void *))tmx_m_secs, + (VALUE (*)(void *))tmx_m_msecs, + (int (*)(void *))tmx_m_of, + (char *(*)(void *))tmx_m_zone +}; + +static void +set_tmx(VALUE self, struct tmx *tmx) +{ + get_d1(self); + tmx->dat = (void *)dat; + tmx->funcs = &tmx_funcs; +} + +static VALUE +date_strftime_internal(int argc, VALUE *argv, VALUE self, + const char *default_fmt, + void (*func)(VALUE, struct tmx *)) +{ + VALUE vfmt; + const char *fmt; + long len; + char buffer[SMALLBUF], *buf = buffer; + struct tmx tmx; + VALUE str; + + rb_scan_args(argc, argv, "01", &vfmt); + + if (argc < 1) + vfmt = rb_usascii_str_new2(default_fmt); + else { + StringValue(vfmt); + if (!rb_enc_str_asciicompat_p(vfmt)) { + rb_raise(rb_eArgError, + "format should have ASCII compatible encoding"); + } + } + fmt = RSTRING_PTR(vfmt); + len = RSTRING_LEN(vfmt); + (*func)(self, &tmx); + if (memchr(fmt, '\0', len)) { + /* Ruby string may contain \0's. */ + const char *p = fmt, *pe = fmt + len; + + str = rb_str_new(0, 0); + while (p < pe) { + len = date_strftime_alloc(&buf, p, &tmx); + rb_str_cat(str, buf, len); + p += strlen(p); + if (buf != buffer) { + xfree(buf); + buf = buffer; + } + for (fmt = p; p < pe && !*p; ++p); + if (p > fmt) rb_str_cat(str, fmt, p - fmt); + } + rb_enc_copy(str, vfmt); + OBJ_INFECT(str, vfmt); + return str; + } + else + len = date_strftime_alloc(&buf, fmt, &tmx); + + str = rb_str_new(buf, len); + if (buf != buffer) xfree(buf); + rb_enc_copy(str, vfmt); + OBJ_INFECT(str, vfmt); + return str; +} + +/* + * call-seq: + * d.strftime([format='%F']) -> string + * + * Formats date according to the directives in the given format + * string. + * The directives begins with a percent (%) character. + * Any text not listed as a directive will be passed through to the + * output string. + * + * The directive consists of a percent (%) character, + * zero or more flags, optional minimum field width, + * optional modifier and a conversion specifier + * as follows. + * + * % + * + * Flags: + * - don't pad a numerical output. + * _ use spaces for padding. + * 0 use zeros for padding. + * ^ upcase the result string. + * # change case. + * + * The minimum field width specifies the minimum width. + * + * The modifiers are "E", "O", ":", "::" and ":::". + * "E" and "O" are ignored. No effect to result currently. + * + * Format directives: + * + * Date (Year, Month, Day): + * %Y - Year with century (can be negative, 4 digits at least) + * -0001, 0000, 1995, 2009, 14292, etc. + * %C - year / 100 (round down. 20 in 2009) + * %y - year % 100 (00..99) + * + * %m - Month of the year, zero-padded (01..12) + * %_m blank-padded ( 1..12) + * %-m no-padded (1..12) + * %B - The full month name (``January'') + * %^B uppercased (``JANUARY'') + * %b - The abbreviated month name (``Jan'') + * %^b uppercased (``JAN'') + * %h - Equivalent to %b + * + * %d - Day of the month, zero-padded (01..31) + * %-d no-padded (1..31) + * %e - Day of the month, blank-padded ( 1..31) + * + * %j - Day of the year (001..366) + * + * Time (Hour, Minute, Second, Subsecond): + * %H - Hour of the day, 24-hour clock, zero-padded (00..23) + * %k - Hour of the day, 24-hour clock, blank-padded ( 0..23) + * %I - Hour of the day, 12-hour clock, zero-padded (01..12) + * %l - Hour of the day, 12-hour clock, blank-padded ( 1..12) + * %P - Meridian indicator, lowercase (``am'' or ``pm'') + * %p - Meridian indicator, uppercase (``AM'' or ``PM'') + * + * %M - Minute of the hour (00..59) + * + * %S - Second of the minute (00..59) + * + * %L - Millisecond of the second (000..999) + * %N - Fractional seconds digits, default is 9 digits (nanosecond) + * %3N millisecond (3 digits) %15N femtosecond (15 digits) + * %6N microsecond (6 digits) %18N attosecond (18 digits) + * %9N nanosecond (9 digits) %21N zeptosecond (21 digits) + * %12N picosecond (12 digits) %24N yoctosecond (24 digits) + * + * Time zone: + * %z - Time zone as hour and minute offset from UTC (e.g. +0900) + * %:z - hour and minute offset from UTC with a colon (e.g. +09:00) + * %::z - hour, minute and second offset from UTC (e.g. +09:00:00) + * %:::z - hour, minute and second offset from UTC + * (e.g. +09, +09:30, +09:30:30) + * %Z - Time zone abbreviation name or something similar information. + * + * Weekday: + * %A - The full weekday name (``Sunday'') + * %^A uppercased (``SUNDAY'') + * %a - The abbreviated name (``Sun'') + * %^a uppercased (``SUN'') + * %u - Day of the week (Monday is 1, 1..7) + * %w - Day of the week (Sunday is 0, 0..6) + * + * ISO 8601 week-based year and week number: + * The week 1 of YYYY starts with a Monday and includes YYYY-01-04. + * The days in the year before the first week are in the last week of + * the previous year. + * %G - The week-based year + * %g - The last 2 digits of the week-based year (00..99) + * %V - Week number of the week-based year (01..53) + * + * Week number: + * The week 1 of YYYY starts with a Sunday or Monday (according to %U + * or %W). The days in the year before the first week are in week 0. + * %U - Week number of the year. The week starts with Sunday. (00..53) + * %W - Week number of the year. The week starts with Monday. (00..53) + * + * Seconds since the Unix Epoch: + * %s - Number of seconds since 1970-01-01 00:00:00 UTC. + * %Q - Number of milliseconds since 1970-01-01 00:00:00 UTC. + * + * Literal string: + * %n - Newline character (\n) + * %t - Tab character (\t) + * %% - Literal ``%'' character + * + * Combination: + * %c - date and time (%a %b %e %T %Y) + * %D - Date (%m/%d/%y) + * %F - The ISO 8601 date format (%Y-%m-%d) + * %v - VMS date (%e-%b-%Y) + * %x - Same as %D + * %X - Same as %T + * %r - 12-hour time (%I:%M:%S %p) + * %R - 24-hour time (%H:%M) + * %T - 24-hour time (%H:%M:%S) + * %+ - date(1) (%a %b %e %H:%M:%S %Z %Y) + * + * This method is similar to strftime() function defined in ISO C and POSIX. + * Several directives (%a, %A, %b, %B, %c, %p, %r, %x, %X, %E*, %O* and %Z) + * are locale dependent in the function. + * However this method is locale independent. + * So, the result may differ even if a same format string is used in other + * systems such as C. + * It is good practice to avoid %x and %X because there are corresponding + * locale independent representations, %D and %T. + * + * Examples: + * + * d = DateTime.new(2007,11,19,8,37,48,"-06:00") + * #=> # + * d.strftime("Printed on %m/%d/%Y") #=> "Printed on 11/19/2007" + * d.strftime("at %I:%M%p") #=> "at 08:37AM" + * + * Various ISO 8601 formats: + * %Y%m%d => 20071119 Calendar date (basic) + * %F => 2007-11-19 Calendar date (extended) + * %Y-%m => 2007-11 Calendar date, reduced accuracy, specific month + * %Y => 2007 Calendar date, reduced accuracy, specific year + * %C => 20 Calendar date, reduced accuracy, specific century + * %Y%j => 2007323 Ordinal date (basic) + * %Y-%j => 2007-323 Ordinal date (extended) + * %GW%V%u => 2007W471 Week date (basic) + * %G-W%V-%u => 2007-W47-1 Week date (extended) + * %GW%V => 2007W47 Week date, reduced accuracy, specific week (basic) + * %G-W%V => 2007-W47 Week date, reduced accuracy, specific week (extended) + * %H%M%S => 083748 Local time (basic) + * %T => 08:37:48 Local time (extended) + * %H%M => 0837 Local time, reduced accuracy, specific minute (basic) + * %H:%M => 08:37 Local time, reduced accuracy, specific minute (extended) + * %H => 08 Local time, reduced accuracy, specific hour + * %H%M%S,%L => 083748,000 Local time with decimal fraction, comma as decimal sign (basic) + * %T,%L => 08:37:48,000 Local time with decimal fraction, comma as decimal sign (extended) + * %H%M%S.%L => 083748.000 Local time with decimal fraction, full stop as decimal sign (basic) + * %T.%L => 08:37:48.000 Local time with decimal fraction, full stop as decimal sign (extended) + * %H%M%S%z => 083748-0600 Local time and the difference from UTC (basic) + * %T%:z => 08:37:48-06:00 Local time and the difference from UTC (extended) + * %Y%m%dT%H%M%S%z => 20071119T083748-0600 Date and time of day for calendar date (basic) + * %FT%T%:z => 2007-11-19T08:37:48-06:00 Date and time of day for calendar date (extended) + * %Y%jT%H%M%S%z => 2007323T083748-0600 Date and time of day for ordinal date (basic) + * %Y-%jT%T%:z => 2007-323T08:37:48-06:00 Date and time of day for ordinal date (extended) + * %GW%V%uT%H%M%S%z => 2007W471T083748-0600 Date and time of day for week date (basic) + * %G-W%V-%uT%T%:z => 2007-W47-1T08:37:48-06:00 Date and time of day for week date (extended) + * %Y%m%dT%H%M => 20071119T0837 Calendar date and local time (basic) + * %FT%R => 2007-11-19T08:37 Calendar date and local time (extended) + * %Y%jT%H%MZ => 2007323T0837Z Ordinal date and UTC of day (basic) + * %Y-%jT%RZ => 2007-323T08:37Z Ordinal date and UTC of day (extended) + * %GW%V%uT%H%M%z => 2007W471T0837-0600 Week date and local time and difference from UTC (basic) + * %G-W%V-%uT%R%:z => 2007-W47-1T08:37-06:00 Week date and local time and difference from UTC (extended) + * + * See also strftime(3) and strptime. + */ +static VALUE +d_lite_strftime(int argc, VALUE *argv, VALUE self) +{ + return date_strftime_internal(argc, argv, self, + "%Y-%m-%d", set_tmx); +} + +static VALUE +strftimev(const char *fmt, VALUE self, + void (*func)(VALUE, struct tmx *)) +{ + char buffer[SMALLBUF], *buf = buffer; + struct tmx tmx; + long len; + VALUE str; + + (*func)(self, &tmx); + len = date_strftime_alloc(&buf, fmt, &tmx); + str = rb_usascii_str_new(buf, len); + if (buf != buffer) xfree(buf); + return str; +} + +/* + * call-seq: + * d.asctime -> string + * d.ctime -> string + * + * Returns a string in asctime(3) format (but without "\n\0" at the + * end). This method is equivalent to strftime('%c'). + * + * See also asctime(3) or ctime(3). + */ +static VALUE +d_lite_asctime(VALUE self) +{ + return strftimev("%a %b %e %H:%M:%S %Y", self, set_tmx); +} + +/* + * call-seq: + * d.iso8601 -> string + * d.xmlschema -> string + * + * This method is equivalent to strftime('%F'). + */ +static VALUE +d_lite_iso8601(VALUE self) +{ + return strftimev("%Y-%m-%d", self, set_tmx); +} + +/* + * call-seq: + * d.rfc3339 -> string + * + * This method is equivalent to strftime('%FT%T%:z'). + */ +static VALUE +d_lite_rfc3339(VALUE self) +{ + return strftimev("%Y-%m-%dT%H:%M:%S%:z", self, set_tmx); +} + +/* + * call-seq: + * d.rfc2822 -> string + * d.rfc822 -> string + * + * This method is equivalent to strftime('%a, %-d %b %Y %T %z'). + */ +static VALUE +d_lite_rfc2822(VALUE self) +{ + return strftimev("%a, %-d %b %Y %T %z", self, set_tmx); +} + +/* + * call-seq: + * d.httpdate -> string + * + * This method is equivalent to strftime('%a, %d %b %Y %T GMT'). + * See also RFC 2616. + */ +static VALUE +d_lite_httpdate(VALUE self) +{ + volatile VALUE dup = dup_obj_with_new_offset(self, 0); + return strftimev("%a, %d %b %Y %T GMT", dup, set_tmx); +} + +static VALUE +jisx0301_date(VALUE jd, VALUE y) +{ + VALUE a[2]; + + if (f_lt_p(jd, INT2FIX(2405160))) + return rb_usascii_str_new2("%Y-%m-%d"); + if (f_lt_p(jd, INT2FIX(2419614))) { + a[0] = rb_usascii_str_new2("M%02d" ".%%m.%%d"); + a[1] = f_sub(y, INT2FIX(1867)); + } + else if (f_lt_p(jd, INT2FIX(2424875))) { + a[0] = rb_usascii_str_new2("T%02d" ".%%m.%%d"); + a[1] = f_sub(y, INT2FIX(1911)); + } + else if (f_lt_p(jd, INT2FIX(2447535))) { + a[0] = rb_usascii_str_new2("S%02d" ".%%m.%%d"); + a[1] = f_sub(y, INT2FIX(1925)); + } + else { + a[0] = rb_usascii_str_new2("H%02d" ".%%m.%%d"); + a[1] = f_sub(y, INT2FIX(1988)); + } + return rb_f_sprintf(2, a); +} + +/* + * call-seq: + * d.jisx0301 -> string + * + * Returns a string in a JIS X 0301 format. + * + * Date.new(2001,2,3).jisx0301 #=> "H13.02.03" + */ +static VALUE +d_lite_jisx0301(VALUE self) +{ + VALUE s; + + get_d1(self); + s = jisx0301_date(m_real_local_jd(dat), + m_real_year(dat)); + return strftimev(RSTRING_PTR(s), self, set_tmx); +} + +#ifndef NDEBUG +static VALUE +d_lite_marshal_dump_old(VALUE self) +{ + VALUE a; + + get_d1(self); + + a = rb_ary_new3(3, + m_ajd(dat), + m_of_in_day(dat), + DBL2NUM(m_sg(dat))); + + if (FL_TEST(self, FL_EXIVAR)) { + rb_copy_generic_ivar(a, self); + FL_SET(a, FL_EXIVAR); + } + + return a; +} +#endif + +/* :nodoc: */ +static VALUE +d_lite_marshal_dump(VALUE self) +{ + VALUE a; + + get_d1(self); + + a = rb_ary_new3(6, + m_nth(dat), + INT2FIX(m_jd(dat)), + INT2FIX(m_df(dat)), + m_sf(dat), + INT2FIX(m_of(dat)), + DBL2NUM(m_sg(dat))); + + if (FL_TEST(self, FL_EXIVAR)) { + rb_copy_generic_ivar(a, self); + FL_SET(a, FL_EXIVAR); + } + + return a; +} + +/* :nodoc: */ +static VALUE +d_lite_marshal_load(VALUE self, VALUE a) +{ + get_d1(self); + + rb_check_frozen(self); + rb_check_trusted(self); + + if (!RB_TYPE_P(a, T_ARRAY)) + rb_raise(rb_eTypeError, "expected an array"); + + switch (RARRAY_LEN(a)) { + case 2: /* 1.6.x */ + case 3: /* 1.8.x, 1.9.2 */ + { + VALUE ajd, of, sg, nth, sf; + int jd, df, rof; + double rsg; + + + if (RARRAY_LEN(a) == 2) { + ajd = f_sub(RARRAY_PTR(a)[0], half_days_in_day); + of = INT2FIX(0); + sg = RARRAY_PTR(a)[1]; + if (!k_numeric_p(sg)) + sg = DBL2NUM(RTEST(sg) ? GREGORIAN : JULIAN); + } + else { + ajd = RARRAY_PTR(a)[0]; + of = RARRAY_PTR(a)[1]; + sg = RARRAY_PTR(a)[2]; + } + + old_to_new(ajd, of, sg, + &nth, &jd, &df, &sf, &rof, &rsg); + + if (!df && f_zero_p(sf) && !rof) { + set_to_simple(self, &dat->s, nth, jd, rsg, 0, 0, 0, HAVE_JD); + } else { + if (!complex_dat_p(dat)) + rb_raise(rb_eArgError, + "cannot load complex into simple"); + + set_to_complex(self, &dat->c, nth, jd, df, sf, rof, rsg, + 0, 0, 0, 0, 0, 0, + HAVE_JD | HAVE_DF | COMPLEX_DAT); + } + } + break; + case 6: + { + VALUE nth, sf; + int jd, df, of; + double sg; + + nth = RARRAY_PTR(a)[0]; + jd = NUM2INT(RARRAY_PTR(a)[1]); + df = NUM2INT(RARRAY_PTR(a)[2]); + sf = RARRAY_PTR(a)[3]; + of = NUM2INT(RARRAY_PTR(a)[4]); + sg = NUM2DBL(RARRAY_PTR(a)[5]); + if (!df && f_zero_p(sf) && !of) { + set_to_simple(self, &dat->s, nth, jd, sg, 0, 0, 0, HAVE_JD); + } else { + if (!complex_dat_p(dat)) + rb_raise(rb_eArgError, + "cannot load complex into simple"); + + set_to_complex(self, &dat->c, nth, jd, df, sf, of, sg, + 0, 0, 0, 0, 0, 0, + HAVE_JD | HAVE_DF | COMPLEX_DAT); + } + } + break; + default: + rb_raise(rb_eTypeError, "invalid size"); + break; + } + + if (FL_TEST(a, FL_EXIVAR)) { + rb_copy_generic_ivar(self, a); + FL_SET(self, FL_EXIVAR); + } + + return self; +} + +/* :nodoc: */ +static VALUE +date_s__load(VALUE klass, VALUE s) +{ + VALUE a, obj; + + a = rb_marshal_load(s); + obj = d_lite_s_alloc(klass); + return d_lite_marshal_load(obj, a); +} + +/* datetime */ + +/* + * call-seq: + * DateTime.jd([jd=0[, hour=0[, minute=0[, second=0[, offset=0[, start=Date::ITALY]]]]]]) -> datetime + * + * Creates a datetime object denoting the given chronological Julian + * day number. + * + * DateTime.jd(2451944) #=> # + * DateTime.jd(2451945) #=> # + * DateTime.jd(Rational('0.5')) + * #=> # + */ +static VALUE +datetime_s_jd(int argc, VALUE *argv, VALUE klass) +{ + VALUE vjd, vh, vmin, vs, vof, vsg, jd, fr, fr2, ret; + int h, min, s, rof; + double sg; + + rb_scan_args(argc, argv, "06", &vjd, &vh, &vmin, &vs, &vof, &vsg); + + jd = INT2FIX(0); + + h = min = s = 0; + fr2 = INT2FIX(0); + rof = 0; + sg = DEFAULT_SG; + + switch (argc) { + case 6: + val2sg(vsg, sg); + case 5: + val2off(vof, rof); + case 4: + num2int_with_frac(s, positive_inf); + case 3: + num2int_with_frac(min, 3); + case 2: + num2int_with_frac(h, 2); + case 1: + num2num_with_frac(jd, 1); + } + + { + VALUE nth; + int rh, rmin, rs, rjd, rjd2; + + if (!c_valid_time_p(h, min, s, &rh, &rmin, &rs)) + rb_raise(rb_eArgError, "invalid date"); + canon24oc(); + + decode_jd(jd, &nth, &rjd); + rjd2 = jd_local_to_utc(rjd, + time_to_df(rh, rmin, rs), + rof); + + ret = d_complex_new_internal(klass, + nth, rjd2, + 0, INT2FIX(0), + rof, sg, + 0, 0, 0, + rh, rmin, rs, + HAVE_JD | HAVE_TIME); + } + add_frac(); + return ret; +} + +/* + * call-seq: + * DateTime.ordinal([year=-4712[, yday=1[, hour=0[, minute=0[, second=0[, offset=0[, start=Date::ITALY]]]]]]]) -> datetime + * + * Creates a date-time object denoting the given ordinal date. + * + * DateTime.ordinal(2001,34) #=> # + * DateTime.ordinal(2001,34,4,5,6,'+7') + * #=> # + * DateTime.ordinal(2001,-332,-20,-55,-54,'+7') + * #=> # + */ +static VALUE +datetime_s_ordinal(int argc, VALUE *argv, VALUE klass) +{ + VALUE vy, vd, vh, vmin, vs, vof, vsg, y, fr, fr2, ret; + int d, h, min, s, rof; + double sg; + + rb_scan_args(argc, argv, "07", &vy, &vd, &vh, &vmin, &vs, &vof, &vsg); + + y = INT2FIX(-4712); + d = 1; + + h = min = s = 0; + fr2 = INT2FIX(0); + rof = 0; + sg = DEFAULT_SG; + + switch (argc) { + case 7: + val2sg(vsg, sg); + case 6: + val2off(vof, rof); + case 5: + num2int_with_frac(s, positive_inf); + case 4: + num2int_with_frac(min, 4); + case 3: + num2int_with_frac(h, 3); + case 2: + num2int_with_frac(d, 2); + case 1: + y = vy; + } + + { + VALUE nth; + int ry, rd, rh, rmin, rs, rjd, rjd2, ns; + + if (!valid_ordinal_p(y, d, sg, + &nth, &ry, + &rd, &rjd, + &ns)) + rb_raise(rb_eArgError, "invalid date"); + if (!c_valid_time_p(h, min, s, &rh, &rmin, &rs)) + rb_raise(rb_eArgError, "invalid date"); + canon24oc(); + + rjd2 = jd_local_to_utc(rjd, + time_to_df(rh, rmin, rs), + rof); + + ret = d_complex_new_internal(klass, + nth, rjd2, + 0, INT2FIX(0), + rof, sg, + 0, 0, 0, + rh, rmin, rs, + HAVE_JD | HAVE_TIME); + } + add_frac(); + return ret; +} + +/* + * call-seq: + * DateTime.civil([year=-4712[, month=1[, mday=1[, hour=0[, minute=0[, second=0[, offset=0[, start=Date::ITALY]]]]]]]]) -> datetime + * DateTime.new([year=-4712[, month=1[, mday=1[, hour=0[, minute=0[, second=0[, offset=0[, start=Date::ITALY]]]]]]]]) -> datetime + * + * Creates a date-time object denoting the given calendar date. + * + * DateTime.new(2001,2,3) #=> # + * DateTime.new(2001,2,3,4,5,6,'+7') + * #=> # + * DateTime.new(2001,-11,-26,-20,-55,-54,'+7') + * #=> # + */ +static VALUE +datetime_s_civil(int argc, VALUE *argv, VALUE klass) +{ + VALUE vy, vm, vd, vh, vmin, vs, vof, vsg, y, fr, fr2, ret; + int m, d, h, min, s, rof; + double sg; + + rb_scan_args(argc, argv, "08", &vy, &vm, &vd, &vh, &vmin, &vs, &vof, &vsg); + + y = INT2FIX(-4712); + m = 1; + d = 1; + + h = min = s = 0; + fr2 = INT2FIX(0); + rof = 0; + sg = DEFAULT_SG; + + switch (argc) { + case 8: + val2sg(vsg, sg); + case 7: + val2off(vof, rof); + case 6: + num2int_with_frac(s, positive_inf); + case 5: + num2int_with_frac(min, 5); + case 4: + num2int_with_frac(h, 4); + case 3: + num2int_with_frac(d, 3); + case 2: + m = NUM2INT(vm); + case 1: + y = vy; + } + + if (guess_style(y, sg) < 0) { + VALUE nth; + int ry, rm, rd, rh, rmin, rs; + + if (!valid_gregorian_p(y, m, d, + &nth, &ry, + &rm, &rd)) + rb_raise(rb_eArgError, "invalid date"); + if (!c_valid_time_p(h, min, s, &rh, &rmin, &rs)) + rb_raise(rb_eArgError, "invalid date"); + canon24oc(); + + ret = d_complex_new_internal(klass, + nth, 0, + 0, INT2FIX(0), + rof, sg, + ry, rm, rd, + rh, rmin, rs, + HAVE_CIVIL | HAVE_TIME); + } + else { + VALUE nth; + int ry, rm, rd, rh, rmin, rs, rjd, rjd2, ns; + + if (!valid_civil_p(y, m, d, sg, + &nth, &ry, + &rm, &rd, &rjd, + &ns)) + rb_raise(rb_eArgError, "invalid date"); + if (!c_valid_time_p(h, min, s, &rh, &rmin, &rs)) + rb_raise(rb_eArgError, "invalid date"); + canon24oc(); + + rjd2 = jd_local_to_utc(rjd, + time_to_df(rh, rmin, rs), + rof); + + ret = d_complex_new_internal(klass, + nth, rjd2, + 0, INT2FIX(0), + rof, sg, + ry, rm, rd, + rh, rmin, rs, + HAVE_JD | HAVE_CIVIL | HAVE_TIME); + } + add_frac(); + return ret; +} + +/* + * call-seq: + * DateTime.commercial([cwyear=-4712[, cweek=1[, cwday=1[, hour=0[, minute=0[, second=0[, offset=0[, start=Date::ITALY]]]]]]]]) -> datetime + * + * Creates a date-time object denoting the given week date. + * + * DateTime.commercial(2001) #=> # + * DateTime.commercial(2002) #=> # + * DateTime.commercial(2001,5,6,4,5,6,'+7') + * #=> # + */ +static VALUE +datetime_s_commercial(int argc, VALUE *argv, VALUE klass) +{ + VALUE vy, vw, vd, vh, vmin, vs, vof, vsg, y, fr, fr2, ret; + int w, d, h, min, s, rof; + double sg; + + rb_scan_args(argc, argv, "08", &vy, &vw, &vd, &vh, &vmin, &vs, &vof, &vsg); + + y = INT2FIX(-4712); + w = 1; + d = 1; + + h = min = s = 0; + fr2 = INT2FIX(0); + rof = 0; + sg = DEFAULT_SG; + + switch (argc) { + case 8: + val2sg(vsg, sg); + case 7: + val2off(vof, rof); + case 6: + num2int_with_frac(s, positive_inf); + case 5: + num2int_with_frac(min, 5); + case 4: + num2int_with_frac(h, 4); + case 3: + num2int_with_frac(d, 3); + case 2: + w = NUM2INT(vw); + case 1: + y = vy; + } + + { + VALUE nth; + int ry, rw, rd, rh, rmin, rs, rjd, rjd2, ns; + + if (!valid_commercial_p(y, w, d, sg, + &nth, &ry, + &rw, &rd, &rjd, + &ns)) + rb_raise(rb_eArgError, "invalid date"); + if (!c_valid_time_p(h, min, s, &rh, &rmin, &rs)) + rb_raise(rb_eArgError, "invalid date"); + canon24oc(); + + rjd2 = jd_local_to_utc(rjd, + time_to_df(rh, rmin, rs), + rof); + + ret = d_complex_new_internal(klass, + nth, rjd2, + 0, INT2FIX(0), + rof, sg, + 0, 0, 0, + rh, rmin, rs, + HAVE_JD | HAVE_TIME); + } + add_frac(); + return ret; +} + +#ifndef NDEBUG +static VALUE +datetime_s_weeknum(int argc, VALUE *argv, VALUE klass) +{ + VALUE vy, vw, vd, vf, vh, vmin, vs, vof, vsg, y, fr, fr2, ret; + int w, d, f, h, min, s, rof; + double sg; + + rb_scan_args(argc, argv, "09", &vy, &vw, &vd, &vf, + &vh, &vmin, &vs, &vof, &vsg); + + y = INT2FIX(-4712); + w = 0; + d = 1; + f = 0; + + h = min = s = 0; + fr2 = INT2FIX(0); + rof = 0; + sg = DEFAULT_SG; + + switch (argc) { + case 9: + val2sg(vsg, sg); + case 8: + val2off(vof, rof); + case 7: + num2int_with_frac(s, positive_inf); + case 6: + num2int_with_frac(min, 6); + case 5: + num2int_with_frac(h, 5); + case 4: + f = NUM2INT(vf); + case 3: + num2int_with_frac(d, 4); + case 2: + w = NUM2INT(vw); + case 1: + y = vy; + } + + { + VALUE nth; + int ry, rw, rd, rh, rmin, rs, rjd, rjd2, ns; + + if (!valid_weeknum_p(y, w, d, f, sg, + &nth, &ry, + &rw, &rd, &rjd, + &ns)) + rb_raise(rb_eArgError, "invalid date"); + if (!c_valid_time_p(h, min, s, &rh, &rmin, &rs)) + rb_raise(rb_eArgError, "invalid date"); + canon24oc(); + + rjd2 = jd_local_to_utc(rjd, + time_to_df(rh, rmin, rs), + rof); + ret = d_complex_new_internal(klass, + nth, rjd2, + 0, INT2FIX(0), + rof, sg, + 0, 0, 0, + rh, rmin, rs, + HAVE_JD | HAVE_TIME); + } + add_frac(); + return ret; +} + +static VALUE +datetime_s_nth_kday(int argc, VALUE *argv, VALUE klass) +{ + VALUE vy, vm, vn, vk, vh, vmin, vs, vof, vsg, y, fr, fr2, ret; + int m, n, k, h, min, s, rof; + double sg; + + rb_scan_args(argc, argv, "09", &vy, &vm, &vn, &vk, + &vh, &vmin, &vs, &vof, &vsg); + + y = INT2FIX(-4712); + m = 1; + n = 1; + k = 1; + + h = min = s = 0; + fr2 = INT2FIX(0); + rof = 0; + sg = DEFAULT_SG; + + switch (argc) { + case 9: + val2sg(vsg, sg); + case 8: + val2off(vof, rof); + case 7: + num2int_with_frac(s, positive_inf); + case 6: + num2int_with_frac(min, 6); + case 5: + num2int_with_frac(h, 5); + case 4: + num2int_with_frac(k, 4); + case 3: + n = NUM2INT(vn); + case 2: + m = NUM2INT(vm); + case 1: + y = vy; + } + + { + VALUE nth; + int ry, rm, rn, rk, rh, rmin, rs, rjd, rjd2, ns; + + if (!valid_nth_kday_p(y, m, n, k, sg, + &nth, &ry, + &rm, &rn, &rk, &rjd, + &ns)) + rb_raise(rb_eArgError, "invalid date"); + if (!c_valid_time_p(h, min, s, &rh, &rmin, &rs)) + rb_raise(rb_eArgError, "invalid date"); + canon24oc(); + + rjd2 = jd_local_to_utc(rjd, + time_to_df(rh, rmin, rs), + rof); + ret = d_complex_new_internal(klass, + nth, rjd2, + 0, INT2FIX(0), + rof, sg, + 0, 0, 0, + rh, rmin, rs, + HAVE_JD | HAVE_TIME); + } + add_frac(); + return ret; +} +#endif + +/* + * call-seq: + * DateTime.now([start=Date::ITALY]) -> datetime + * + * Creates a date-time object denoting the present time. + * + * DateTime.now #=> # + */ +static VALUE +datetime_s_now(int argc, VALUE *argv, VALUE klass) +{ + VALUE vsg, nth, ret; + double sg; +#ifdef HAVE_CLOCK_GETTIME + struct timespec ts; +#else + struct timeval tv; +#endif + time_t sec; + struct tm tm; + long sf, of; + int y, ry, m, d, h, min, s; + + rb_scan_args(argc, argv, "01", &vsg); + + if (argc < 1) + sg = DEFAULT_SG; + else + sg = NUM2DBL(vsg); + +#ifdef HAVE_CLOCK_GETTIME + if (clock_gettime(CLOCK_REALTIME, &ts) == -1) + rb_sys_fail("clock_gettime"); + sec = ts.tv_sec; +#else + if (gettimeofday(&tv, NULL) == -1) + rb_sys_fail("gettimeofday"); + sec = tv.tv_sec; +#endif + tzset(); + if (!localtime_r(&sec, &tm)) + rb_sys_fail("localtime"); + + y = tm.tm_year + 1900; + m = tm.tm_mon + 1; + d = tm.tm_mday; + h = tm.tm_hour; + min = tm.tm_min; + s = tm.tm_sec; + if (s == 60) + s = 59; +#ifdef HAVE_STRUCT_TM_TM_GMTOFF + of = tm.tm_gmtoff; +#elif defined(HAVE_VAR_TIMEZONE) +#ifdef HAVE_VAR_ALTZONE + of = (long)-((tm.tm_isdst > 0) ? altzone : timezone); +#else + of = (long)-timezone; + if (tm.tm_isdst) { + time_t sec2; + + tm.tm_isdst = 0; + sec2 = mktime(&tm); + of += (long)difftime(sec2, sec); + } +#endif +#elif defined(HAVE_TIMEGM) + { + time_t sec2; + + sec2 = timegm(&tm); + of = (long)difftime(sec2, sec); + } +#else + { + struct tm tm2; + time_t sec2; + + if (!gmtime_r(&sec, &tm2)) + rb_sys_fail("gmtime"); + tm2.tm_isdst = tm.tm_isdst; + sec2 = mktime(&tm2); + of = (long)difftime(sec, sec2); + } +#endif +#ifdef HAVE_CLOCK_GETTIME + sf = ts.tv_nsec; +#else + sf = tv.tv_usec * 1000; +#endif + + if (of < -DAY_IN_SECONDS || of > DAY_IN_SECONDS) { + of = 0; + rb_warning("invalid offset is ignored"); + } + + decode_year(INT2FIX(y), -1, &nth, &ry); + + ret = d_complex_new_internal(klass, + nth, 0, + 0, LONG2NUM(sf), + (int)of, GREGORIAN, + ry, m, d, + h, min, s, + HAVE_CIVIL | HAVE_TIME); + { + get_d1(ret); + set_sg(dat, sg); + } + return ret; +} + +static VALUE +dt_new_by_frags(VALUE klass, VALUE hash, VALUE sg) +{ + VALUE jd, sf, t; + int df, of; + + if (!c_valid_start_p(NUM2DBL(sg))) { + sg = INT2FIX(DEFAULT_SG); + rb_warning("invalid start is ignored"); + } + + if (NIL_P(hash)) + rb_raise(rb_eArgError, "invalid date"); + + if (NIL_P(ref_hash("jd")) && + NIL_P(ref_hash("yday")) && + !NIL_P(ref_hash("year")) && + !NIL_P(ref_hash("mon")) && + !NIL_P(ref_hash("mday"))) { + jd = rt__valid_civil_p(ref_hash("year"), + ref_hash("mon"), + ref_hash("mday"), sg); + + if (NIL_P(ref_hash("hour"))) + set_hash("hour", INT2FIX(0)); + if (NIL_P(ref_hash("min"))) + set_hash("min", INT2FIX(0)); + if (NIL_P(ref_hash("sec"))) + set_hash("sec", INT2FIX(0)); + else if (f_eqeq_p(ref_hash("sec"), INT2FIX(60))) + set_hash("sec", INT2FIX(59)); + } + else { + hash = rt_rewrite_frags(hash); + hash = rt_complete_frags(klass, hash); + jd = rt__valid_date_frags_p(hash, sg); + } + + if (NIL_P(jd)) + rb_raise(rb_eArgError, "invalid date"); + + { + int rh, rmin, rs; + + if (!c_valid_time_p(NUM2INT(ref_hash("hour")), + NUM2INT(ref_hash("min")), + NUM2INT(ref_hash("sec")), + &rh, &rmin, &rs)) + rb_raise(rb_eArgError, "invalid date"); + + df = time_to_df(rh, rmin, rs); + } + + t = ref_hash("sec_fraction"); + if (NIL_P(t)) + sf = INT2FIX(0); + else + sf = sec_to_ns(t); + + t = ref_hash("offset"); + if (NIL_P(t)) + of = 0; + else { + of = NUM2INT(t); + if (of < -DAY_IN_SECONDS || of > DAY_IN_SECONDS) { + of = 0; + rb_warning("invalid offset is ignored"); + } + } + { + VALUE nth; + int rjd, rjd2; + + decode_jd(jd, &nth, &rjd); + rjd2 = jd_local_to_utc(rjd, df, of); + df = df_local_to_utc(df, of); + + return d_complex_new_internal(klass, + nth, rjd2, + df, sf, + of, NUM2DBL(sg), + 0, 0, 0, + 0, 0, 0, + HAVE_JD | HAVE_DF); + } +} + +/* + * call-seq: + * DateTime._strptime(string[, format='%FT%T%z']) -> hash + * + * Parses the given representation of date and time with the given + * template, and returns a hash of parsed elements. _strptime does + * not support specification of flags and width unlike strftime. + * + * See also strptime(3) and strftime. + */ +static VALUE +datetime_s__strptime(int argc, VALUE *argv, VALUE klass) +{ + return date_s__strptime_internal(argc, argv, klass, "%FT%T%z"); +} + +/* + * call-seq: + * DateTime.strptime([string='-4712-01-01T00:00:00+00:00'[, format='%FT%T%z'[ ,start=ITALY]]]) -> datetime + * + * Parses the given representation of date and time with the given + * template, and creates a date object. strptime does not support + * specification of flags and width unlike strftime. + * + * DateTime.strptime('2001-02-03T04:05:06+07:00', '%Y-%m-%dT%H:%M:%S%z') + * #=> # + * DateTime.strptime('03-02-2001 04:05:06 PM', '%d-%m-%Y %I:%M:%S %p') + * #=> # + * DateTime.strptime('2001-W05-6T04:05:06+07:00', '%G-W%V-%uT%H:%M:%S%z') + * #=> # + * DateTime.strptime('2001 04 6 04 05 06 +7', '%Y %U %w %H %M %S %z') + * #=> # + * DateTime.strptime('2001 05 6 04 05 06 +7', '%Y %W %u %H %M %S %z') + * #=> # + * DateTime.strptime('-1', '%s') + * #=> # + * DateTime.strptime('-1000', '%Q') + * #=> # + * DateTime.strptime('sat3feb014pm+7', '%a%d%b%y%H%p%z') + * #=> # + * + * See also strptime(3) and strftime. + */ +static VALUE +datetime_s_strptime(int argc, VALUE *argv, VALUE klass) +{ + VALUE str, fmt, sg; + + rb_scan_args(argc, argv, "03", &str, &fmt, &sg); + + switch (argc) { + case 0: + str = rb_str_new2("-4712-01-01T00:00:00+00:00"); + case 1: + fmt = rb_str_new2("%FT%T%z"); + case 2: + sg = INT2FIX(DEFAULT_SG); + } + + { + VALUE argv2[2], hash; + + argv2[0] = str; + argv2[1] = fmt; + hash = date_s__strptime(2, argv2, klass); + return dt_new_by_frags(klass, hash, sg); + } +} + +/* + * call-seq: + * DateTime.parse(string='-4712-01-01T00:00:00+00:00'[, comp=true[, start=ITALY]]) -> datetime + * + * Parses the given representation of date and time, and creates a + * date object. This method does not function as a validator. + * + * If the optional second argument is true and the detected year is in + * the range "00" to "99", makes it full. + * + * DateTime.parse('2001-02-03T04:05:06+07:00') + * #=> # + * DateTime.parse('20010203T040506+0700') + * #=> # + * DateTime.parse('3rd Feb 2001 04:05:06 PM') + * #=> # + */ +static VALUE +datetime_s_parse(int argc, VALUE *argv, VALUE klass) +{ + VALUE str, comp, sg; + + rb_scan_args(argc, argv, "03", &str, &comp, &sg); + + switch (argc) { + case 0: + str = rb_str_new2("-4712-01-01T00:00:00+00:00"); + case 1: + comp = Qtrue; + case 2: + sg = INT2FIX(DEFAULT_SG); + } + + { + VALUE argv2[2], hash; + + argv2[0] = str; + argv2[1] = comp; + hash = date_s__parse(2, argv2, klass); + return dt_new_by_frags(klass, hash, sg); + } +} + +/* + * call-seq: + * DateTime.iso8601(string='-4712-01-01T00:00:00+00:00'[, start=ITALY]) -> datetime + * + * Creates a new Date object by parsing from a string according to + * some typical ISO 8601 formats. + * + * DateTime.iso8601('2001-02-03T04:05:06+07:00') + * #=> # + * DateTime.iso8601('20010203T040506+0700') + * #=> # + * DateTime.iso8601('2001-W05-6T04:05:06+07:00') + * #=> # + */ +static VALUE +datetime_s_iso8601(int argc, VALUE *argv, VALUE klass) +{ + VALUE str, sg; + + rb_scan_args(argc, argv, "02", &str, &sg); + + switch (argc) { + case 0: + str = rb_str_new2("-4712-01-01T00:00:00+00:00"); + case 1: + sg = INT2FIX(DEFAULT_SG); + } + + { + VALUE hash = date_s__iso8601(klass, str); + return dt_new_by_frags(klass, hash, sg); + } +} + +/* + * call-seq: + * DateTime.rfc3339(string='-4712-01-01T00:00:00+00:00'[, start=ITALY]) -> datetime + * + * Creates a new Date object by parsing from a string according to + * some typical RFC 3339 formats. + * + * DateTime.rfc3339('2001-02-03T04:05:06+07:00') + * #=> # + */ +static VALUE +datetime_s_rfc3339(int argc, VALUE *argv, VALUE klass) +{ + VALUE str, sg; + + rb_scan_args(argc, argv, "02", &str, &sg); + + switch (argc) { + case 0: + str = rb_str_new2("-4712-01-01T00:00:00+00:00"); + case 1: + sg = INT2FIX(DEFAULT_SG); + } + + { + VALUE hash = date_s__rfc3339(klass, str); + return dt_new_by_frags(klass, hash, sg); + } +} + +/* + * call-seq: + * DateTime.xmlschema(string='-4712-01-01T00:00:00+00:00'[, start=ITALY]) -> datetime + * + * Creates a new Date object by parsing from a string according to + * some typical XML Schema formats. + * + * DateTime.xmlschema('2001-02-03T04:05:06+07:00') + * #=> # + */ +static VALUE +datetime_s_xmlschema(int argc, VALUE *argv, VALUE klass) +{ + VALUE str, sg; + + rb_scan_args(argc, argv, "02", &str, &sg); + + switch (argc) { + case 0: + str = rb_str_new2("-4712-01-01T00:00:00+00:00"); + case 1: + sg = INT2FIX(DEFAULT_SG); + } + + { + VALUE hash = date_s__xmlschema(klass, str); + return dt_new_by_frags(klass, hash, sg); + } +} + +/* + * call-seq: + * DateTime.rfc2822(string='Mon, 1 Jan -4712 00:00:00 +0000'[, start=ITALY]) -> datetime + * DateTime.rfc822(string='Mon, 1 Jan -4712 00:00:00 +0000'[, start=ITALY]) -> datetime + * + * Creates a new Date object by parsing from a string according to + * some typical RFC 2822 formats. + * + * DateTime.rfc2822('Sat, 3 Feb 2001 04:05:06 +0700') + * #=> # + */ +static VALUE +datetime_s_rfc2822(int argc, VALUE *argv, VALUE klass) +{ + VALUE str, sg; + + rb_scan_args(argc, argv, "02", &str, &sg); + + switch (argc) { + case 0: + str = rb_str_new2("Mon, 1 Jan -4712 00:00:00 +0000"); + case 1: + sg = INT2FIX(DEFAULT_SG); + } + + { + VALUE hash = date_s__rfc2822(klass, str); + return dt_new_by_frags(klass, hash, sg); + } +} + +/* + * call-seq: + * DateTime.httpdate(string='Mon, 01 Jan -4712 00:00:00 GMT'[, start=ITALY]) -> datetime + * + * Creates a new Date object by parsing from a string according to + * some RFC 2616 format. + * + * DateTime.httpdate('Sat, 03 Feb 2001 04:05:06 GMT') + * #=> # + */ +static VALUE +datetime_s_httpdate(int argc, VALUE *argv, VALUE klass) +{ + VALUE str, sg; + + rb_scan_args(argc, argv, "02", &str, &sg); + + switch (argc) { + case 0: + str = rb_str_new2("Mon, 01 Jan -4712 00:00:00 GMT"); + case 1: + sg = INT2FIX(DEFAULT_SG); + } + + { + VALUE hash = date_s__httpdate(klass, str); + return dt_new_by_frags(klass, hash, sg); + } +} + +/* + * call-seq: + * DateTime.jisx0301(string='-4712-01-01T00:00:00+00:00'[, start=ITALY]) -> datetime + * + * Creates a new Date object by parsing from a string according to + * some typical JIS X 0301 formats. + * + * DateTime.jisx0301('H13.02.03T04:05:06+07:00') + * #=> # + */ +static VALUE +datetime_s_jisx0301(int argc, VALUE *argv, VALUE klass) +{ + VALUE str, sg; + + rb_scan_args(argc, argv, "02", &str, &sg); + + switch (argc) { + case 0: + str = rb_str_new2("-4712-01-01T00:00:00+00:00"); + case 1: + sg = INT2FIX(DEFAULT_SG); + } + + { + VALUE hash = date_s__jisx0301(klass, str); + return dt_new_by_frags(klass, hash, sg); + } +} + +/* + * call-seq: + * dt.to_s -> string + * + * Returns a string in an ISO 8601 format (This method doesn't use the + * expanded representations). + * + * DateTime.new(2001,2,3,4,5,6,'-7').to_s + * #=> "2001-02-03T04:05:06-07:00" + */ +static VALUE +dt_lite_to_s(VALUE self) +{ + return strftimev("%Y-%m-%dT%H:%M:%S%:z", self, set_tmx); +} + +/* + * call-seq: + * dt.strftime([format='%FT%T%:z']) -> string + * + * Formats date according to the directives in the given format + * string. + * The directives begins with a percent (%) character. + * Any text not listed as a directive will be passed through to the + * output string. + * + * The directive consists of a percent (%) character, + * zero or more flags, optional minimum field width, + * optional modifier and a conversion specifier + * as follows. + * + * % + * + * Flags: + * - don't pad a numerical output. + * _ use spaces for padding. + * 0 use zeros for padding. + * ^ upcase the result string. + * # change case. + * : use colons for %z. + * + * The minimum field width specifies the minimum width. + * + * The modifier is "E" and "O". + * They are ignored. + * + * Format directives: + * + * Date (Year, Month, Day): + * %Y - Year with century (can be negative, 4 digits at least) + * -0001, 0000, 1995, 2009, 14292, etc. + * %C - year / 100 (round down. 20 in 2009) + * %y - year % 100 (00..99) + * + * %m - Month of the year, zero-padded (01..12) + * %_m blank-padded ( 1..12) + * %-m no-padded (1..12) + * %B - The full month name (``January'') + * %^B uppercased (``JANUARY'') + * %b - The abbreviated month name (``Jan'') + * %^b uppercased (``JAN'') + * %h - Equivalent to %b + * + * %d - Day of the month, zero-padded (01..31) + * %-d no-padded (1..31) + * %e - Day of the month, blank-padded ( 1..31) + * + * %j - Day of the year (001..366) + * + * Time (Hour, Minute, Second, Subsecond): + * %H - Hour of the day, 24-hour clock, zero-padded (00..23) + * %k - Hour of the day, 24-hour clock, blank-padded ( 0..23) + * %I - Hour of the day, 12-hour clock, zero-padded (01..12) + * %l - Hour of the day, 12-hour clock, blank-padded ( 1..12) + * %P - Meridian indicator, lowercase (``am'' or ``pm'') + * %p - Meridian indicator, uppercase (``AM'' or ``PM'') + * + * %M - Minute of the hour (00..59) + * + * %S - Second of the minute (00..59) + * + * %L - Millisecond of the second (000..999) + * %N - Fractional seconds digits, default is 9 digits (nanosecond) + * %3N millisecond (3 digits) %15N femtosecond (15 digits) + * %6N microsecond (6 digits) %18N attosecond (18 digits) + * %9N nanosecond (9 digits) %21N zeptosecond (21 digits) + * %12N picosecond (12 digits) %24N yoctosecond (24 digits) + * + * Time zone: + * %z - Time zone as hour and minute offset from UTC (e.g. +0900) + * %:z - hour and minute offset from UTC with a colon (e.g. +09:00) + * %::z - hour, minute and second offset from UTC (e.g. +09:00:00) + * %:::z - hour, minute and second offset from UTC + * (e.g. +09, +09:30, +09:30:30) + * %Z - Time zone abbreviation name or something similar information. + * + * Weekday: + * %A - The full weekday name (``Sunday'') + * %^A uppercased (``SUNDAY'') + * %a - The abbreviated name (``Sun'') + * %^a uppercased (``SUN'') + * %u - Day of the week (Monday is 1, 1..7) + * %w - Day of the week (Sunday is 0, 0..6) + * + * ISO 8601 week-based year and week number: + * The week 1 of YYYY starts with a Monday and includes YYYY-01-04. + * The days in the year before the first week are in the last week of + * the previous year. + * %G - The week-based year + * %g - The last 2 digits of the week-based year (00..99) + * %V - Week number of the week-based year (01..53) + * + * Week number: + * The week 1 of YYYY starts with a Sunday or Monday (according to %U + * or %W). The days in the year before the first week are in week 0. + * %U - Week number of the year. The week starts with Sunday. (00..53) + * %W - Week number of the year. The week starts with Monday. (00..53) + * + * Seconds since the Unix Epoch: + * %s - Number of seconds since 1970-01-01 00:00:00 UTC. + * %Q - Number of milliseconds since 1970-01-01 00:00:00 UTC. + * + * Literal string: + * %n - Newline character (\n) + * %t - Tab character (\t) + * %% - Literal ``%'' character + * + * Combination: + * %c - date and time (%a %b %e %T %Y) + * %D - Date (%m/%d/%y) + * %F - The ISO 8601 date format (%Y-%m-%d) + * %v - VMS date (%e-%b-%Y) + * %x - Same as %D + * %X - Same as %T + * %r - 12-hour time (%I:%M:%S %p) + * %R - 24-hour time (%H:%M) + * %T - 24-hour time (%H:%M:%S) + * %+ - date(1) (%a %b %e %H:%M:%S %Z %Y) + * + * This method is similar to strftime() function defined in ISO C and POSIX. + * Several directives (%a, %A, %b, %B, %c, %p, %r, %x, %X, %E*, %O* and %Z) + * are locale dependent in the function. + * However this method is locale independent. + * So, the result may differ even if a same format string is used in other + * systems such as C. + * It is good practice to avoid %x and %X because there are corresponding + * locale independent representations, %D and %T. + * + * Examples: + * + * d = DateTime.new(2007,11,19,8,37,48,"-06:00") + * #=> # + * d.strftime("Printed on %m/%d/%Y") #=> "Printed on 11/19/2007" + * d.strftime("at %I:%M%p") #=> "at 08:37AM" + * + * Various ISO 8601 formats: + * %Y%m%d => 20071119 Calendar date (basic) + * %F => 2007-11-19 Calendar date (extended) + * %Y-%m => 2007-11 Calendar date, reduced accuracy, specific month + * %Y => 2007 Calendar date, reduced accuracy, specific year + * %C => 20 Calendar date, reduced accuracy, specific century + * %Y%j => 2007323 Ordinal date (basic) + * %Y-%j => 2007-323 Ordinal date (extended) + * %GW%V%u => 2007W471 Week date (basic) + * %G-W%V-%u => 2007-W47-1 Week date (extended) + * %GW%V => 2007W47 Week date, reduced accuracy, specific week (basic) + * %G-W%V => 2007-W47 Week date, reduced accuracy, specific week (extended) + * %H%M%S => 083748 Local time (basic) + * %T => 08:37:48 Local time (extended) + * %H%M => 0837 Local time, reduced accuracy, specific minute (basic) + * %H:%M => 08:37 Local time, reduced accuracy, specific minute (extended) + * %H => 08 Local time, reduced accuracy, specific hour + * %H%M%S,%L => 083748,000 Local time with decimal fraction, comma as decimal sign (basic) + * %T,%L => 08:37:48,000 Local time with decimal fraction, comma as decimal sign (extended) + * %H%M%S.%L => 083748.000 Local time with decimal fraction, full stop as decimal sign (basic) + * %T.%L => 08:37:48.000 Local time with decimal fraction, full stop as decimal sign (extended) + * %H%M%S%z => 083748-0600 Local time and the difference from UTC (basic) + * %T%:z => 08:37:48-06:00 Local time and the difference from UTC (extended) + * %Y%m%dT%H%M%S%z => 20071119T083748-0600 Date and time of day for calendar date (basic) + * %FT%T%:z => 2007-11-19T08:37:48-06:00 Date and time of day for calendar date (extended) + * %Y%jT%H%M%S%z => 2007323T083748-0600 Date and time of day for ordinal date (basic) + * %Y-%jT%T%:z => 2007-323T08:37:48-06:00 Date and time of day for ordinal date (extended) + * %GW%V%uT%H%M%S%z => 2007W471T083748-0600 Date and time of day for week date (basic) + * %G-W%V-%uT%T%:z => 2007-W47-1T08:37:48-06:00 Date and time of day for week date (extended) + * %Y%m%dT%H%M => 20071119T0837 Calendar date and local time (basic) + * %FT%R => 2007-11-19T08:37 Calendar date and local time (extended) + * %Y%jT%H%MZ => 2007323T0837Z Ordinal date and UTC of day (basic) + * %Y-%jT%RZ => 2007-323T08:37Z Ordinal date and UTC of day (extended) + * %GW%V%uT%H%M%z => 2007W471T0837-0600 Week date and local time and difference from UTC (basic) + * %G-W%V-%uT%R%:z => 2007-W47-1T08:37-06:00 Week date and local time and difference from UTC (extended) + * + * See also strftime(3) and strptime. + */ +static VALUE +dt_lite_strftime(int argc, VALUE *argv, VALUE self) +{ + return date_strftime_internal(argc, argv, self, + "%Y-%m-%dT%H:%M:%S%:z", set_tmx); +} + +static VALUE +iso8601_timediv(VALUE self, VALUE n) +{ + VALUE fmt; + + n = to_integer(n); + fmt = rb_usascii_str_new2("T%H:%M:%S"); + if (f_gt_p(n, INT2FIX(0))) { + VALUE argv[3]; + + get_d1(self); + + argv[0] = rb_usascii_str_new2(".%0*d"); + argv[1] = n; + argv[2] = f_round(f_quo(m_sf_in_sec(dat), + f_quo(INT2FIX(1), + f_expt(INT2FIX(10), n)))); + rb_str_append(fmt, rb_f_sprintf(3, argv)); + } + rb_str_append(fmt, rb_usascii_str_new2("%:z")); + return strftimev(RSTRING_PTR(fmt), self, set_tmx); +} + +/* + * call-seq: + * dt.iso8601([n=0]) -> string + * dt.xmlschema([n=0]) -> string + * + * This method is equivalent to strftime('%FT%T'). The optional + * argument n is length of fractional seconds. + * + * DateTime.parse('2001-02-03T04:05:06.123456789+07:00').iso8601(9) + * #=> "2001-02-03T04:05:06.123456789+07:00" + */ +static VALUE +dt_lite_iso8601(int argc, VALUE *argv, VALUE self) +{ + VALUE n; + + rb_scan_args(argc, argv, "01", &n); + + if (argc < 1) + n = INT2FIX(0); + + return f_add(strftimev("%Y-%m-%d", self, set_tmx), + iso8601_timediv(self, n)); +} + +/* + * call-seq: + * dt.rfc3339([n=0]) -> string + * + * This method is equivalent to strftime('%FT%T'). The optional + * argument n is length of fractional seconds. + * + * DateTime.parse('2001-02-03T04:05:06.123456789+07:00').rfc3339(9) + * #=> "2001-02-03T04:05:06.123456789+07:00" + */ +static VALUE +dt_lite_rfc3339(int argc, VALUE *argv, VALUE self) +{ + return dt_lite_iso8601(argc, argv, self); +} + +/* + * call-seq: + * dt.jisx0301([n=0]) -> string + * + * Returns a string in a JIS X 0301 format. The optional argument n + * is length of fractional seconds. + * + * DateTime.parse('2001-02-03T04:05:06.123456789+07:00').jisx0301(9) + * #=> "H13.02.03T04:05:06.123456789+07:00" + */ +static VALUE +dt_lite_jisx0301(int argc, VALUE *argv, VALUE self) +{ + VALUE n, s; + + rb_scan_args(argc, argv, "01", &n); + + if (argc < 1) + n = INT2FIX(0); + + { + get_d1(self); + s = jisx0301_date(m_real_local_jd(dat), + m_real_year(dat)); + return rb_str_append(strftimev(RSTRING_PTR(s), self, set_tmx), + iso8601_timediv(self, n)); + } +} + +/* conversions */ + +#define f_getlocal(x) rb_funcall(x, rb_intern("getlocal"), 0) +#define f_subsec(x) rb_funcall(x, rb_intern("subsec"), 0) +#define f_utc_offset(x) rb_funcall(x, rb_intern("utc_offset"), 0) +#define f_local3(x,y,m,d) rb_funcall(x, rb_intern("local"), 3, y, m, d) +#define f_utc6(x,y,m,d,h,min,s) rb_funcall(x, rb_intern("utc"), 6,\ + y, m, d, h, min, s) + +/* + * call-seq: + * t.to_time -> time + * + * Returns a copy of self as local mode. + */ +static VALUE +time_to_time(VALUE self) +{ + return f_getlocal(self); +} + +/* + * call-seq: + * t.to_date -> date + * + * Returns a Date object which denotes self. + */ +static VALUE +time_to_date(VALUE self) +{ + VALUE y, nth, ret; + int ry, m, d; + + y = f_year(self); + m = FIX2INT(f_mon(self)); + d = FIX2INT(f_mday(self)); + + decode_year(y, -1, &nth, &ry); + + ret = d_simple_new_internal(cDate, + nth, 0, + GREGORIAN, + ry, m, d, + HAVE_CIVIL); + { + get_d1(ret); + set_sg(dat, DEFAULT_SG); + } + return ret; +} + +/* + * call-seq: + * t.to_datetime -> datetime + * + * Returns a DateTime object which denotes self. + */ +static VALUE +time_to_datetime(VALUE self) +{ + VALUE y, sf, nth, ret; + int ry, m, d, h, min, s, of; + + y = f_year(self); + m = FIX2INT(f_mon(self)); + d = FIX2INT(f_mday(self)); + + h = FIX2INT(f_hour(self)); + min = FIX2INT(f_min(self)); + s = FIX2INT(f_sec(self)); + if (s == 60) + s = 59; + + sf = sec_to_ns(f_subsec(self)); + of = FIX2INT(f_utc_offset(self)); + + decode_year(y, -1, &nth, &ry); + + ret = d_complex_new_internal(cDateTime, + nth, 0, + 0, sf, + of, DEFAULT_SG, + ry, m, d, + h, min, s, + HAVE_CIVIL | HAVE_TIME); + { + get_d1(ret); + set_sg(dat, DEFAULT_SG); + } + return ret; +} + +/* + * call-seq: + * d.to_time -> time + * + * Returns a Time object which denotes self. + */ +static VALUE +date_to_time(VALUE self) +{ + get_d1(self); + + return f_local3(rb_cTime, + m_real_year(dat), + INT2FIX(m_mon(dat)), + INT2FIX(m_mday(dat))); +} + +/* + * call-seq: + * d.to_date -> self + * + * Returns self; + */ +static VALUE +date_to_date(VALUE self) +{ + return self; +} + +/* + * call-seq: + * d.to_datetime -> datetime + * + * Returns a DateTime object which denotes self. + */ +static VALUE +date_to_datetime(VALUE self) +{ + get_d1a(self); + + if (simple_dat_p(adat)) { + VALUE new = d_lite_s_alloc_simple(cDateTime); + { + get_d1b(new); + bdat->s = adat->s; + return new; + } + } + else { + VALUE new = d_lite_s_alloc_complex(cDateTime); + { + get_d1b(new); + bdat->c = adat->c; + bdat->c.df = 0; + RB_OBJ_WRITE(new, &bdat->c.sf, INT2FIX(0)); +#ifndef USE_PACK + bdat->c.hour = 0; + bdat->c.min = 0; + bdat->c.sec = 0; +#else + bdat->c.pc = PACK5(EX_MON(adat->c.pc), EX_MDAY(adat->c.pc), + 0, 0, 0); + bdat->c.flags |= HAVE_DF | HAVE_TIME; +#endif + return new; + } + } +} + +/* + * call-seq: + * dt.to_time -> time + * + * Returns a Time object which denotes self. + */ +static VALUE +datetime_to_time(VALUE self) +{ + volatile VALUE dup = dup_obj_with_new_offset(self, 0); + { + VALUE t; + + get_d1(dup); + + t = f_utc6(rb_cTime, + m_real_year(dat), + INT2FIX(m_mon(dat)), + INT2FIX(m_mday(dat)), + INT2FIX(m_hour(dat)), + INT2FIX(m_min(dat)), + f_add(INT2FIX(m_sec(dat)), + m_sf_in_sec(dat))); + return f_getlocal(t); + } +} + +/* + * call-seq: + * dt.to_date -> date + * + * Returns a Date object which denotes self. + */ +static VALUE +datetime_to_date(VALUE self) +{ + get_d1a(self); + + if (simple_dat_p(adat)) { + VALUE new = d_lite_s_alloc_simple(cDate); + { + get_d1b(new); + bdat->s = adat->s; + bdat->s.jd = m_local_jd(adat); + return new; + } + } + else { + VALUE new = d_lite_s_alloc_simple(cDate); + { + get_d1b(new); + copy_complex_to_simple(new, &bdat->s, &adat->c) + bdat->s.jd = m_local_jd(adat); + bdat->s.flags &= ~(HAVE_DF | HAVE_TIME | COMPLEX_DAT); + return new; + } + } +} + +/* + * call-seq: + * dt.to_datetime -> self + * + * Returns self. + */ +static VALUE +datetime_to_datetime(VALUE self) +{ + return self; +} + +#ifndef NDEBUG +/* tests */ + +#define MIN_YEAR -4713 +#define MAX_YEAR 1000000 +#define MIN_JD -327 +#define MAX_JD 366963925 + +static int +test_civil(int from, int to, double sg) +{ + int j; + + fprintf(stderr, "test_civil: %d...%d (%d) - %.0f\n", + from, to, to - from, sg); + for (j = from; j <= to; j++) { + int y, m, d, rj, ns; + + c_jd_to_civil(j, sg, &y, &m, &d); + c_civil_to_jd(y, m, d, sg, &rj, &ns); + if (j != rj) { + fprintf(stderr, "%d != %d\n", j, rj); + return 0; + } + } + return 1; +} + +static VALUE +date_s_test_civil(VALUE klass) +{ + if (!test_civil(MIN_JD, MIN_JD + 366, GREGORIAN)) + return Qfalse; + if (!test_civil(2305814, 2598007, GREGORIAN)) + return Qfalse; + if (!test_civil(MAX_JD - 366, MAX_JD, GREGORIAN)) + return Qfalse; + + if (!test_civil(MIN_JD, MIN_JD + 366, ITALY)) + return Qfalse; + if (!test_civil(2305814, 2598007, ITALY)) + return Qfalse; + if (!test_civil(MAX_JD - 366, MAX_JD, ITALY)) + return Qfalse; + + return Qtrue; +} + +static int +test_ordinal(int from, int to, double sg) +{ + int j; + + fprintf(stderr, "test_ordinal: %d...%d (%d) - %.0f\n", + from, to, to - from, sg); + for (j = from; j <= to; j++) { + int y, d, rj, ns; + + c_jd_to_ordinal(j, sg, &y, &d); + c_ordinal_to_jd(y, d, sg, &rj, &ns); + if (j != rj) { + fprintf(stderr, "%d != %d\n", j, rj); + return 0; + } + } + return 1; +} + +static VALUE +date_s_test_ordinal(VALUE klass) +{ + if (!test_ordinal(MIN_JD, MIN_JD + 366, GREGORIAN)) + return Qfalse; + if (!test_ordinal(2305814, 2598007, GREGORIAN)) + return Qfalse; + if (!test_ordinal(MAX_JD - 366, MAX_JD, GREGORIAN)) + return Qfalse; + + if (!test_ordinal(MIN_JD, MIN_JD + 366, ITALY)) + return Qfalse; + if (!test_ordinal(2305814, 2598007, ITALY)) + return Qfalse; + if (!test_ordinal(MAX_JD - 366, MAX_JD, ITALY)) + return Qfalse; + + return Qtrue; +} + +static int +test_commercial(int from, int to, double sg) +{ + int j; + + fprintf(stderr, "test_commercial: %d...%d (%d) - %.0f\n", + from, to, to - from, sg); + for (j = from; j <= to; j++) { + int y, w, d, rj, ns; + + c_jd_to_commercial(j, sg, &y, &w, &d); + c_commercial_to_jd(y, w, d, sg, &rj, &ns); + if (j != rj) { + fprintf(stderr, "%d != %d\n", j, rj); + return 0; + } + } + return 1; +} + +static VALUE +date_s_test_commercial(VALUE klass) +{ + if (!test_commercial(MIN_JD, MIN_JD + 366, GREGORIAN)) + return Qfalse; + if (!test_commercial(2305814, 2598007, GREGORIAN)) + return Qfalse; + if (!test_commercial(MAX_JD - 366, MAX_JD, GREGORIAN)) + return Qfalse; + + if (!test_commercial(MIN_JD, MIN_JD + 366, ITALY)) + return Qfalse; + if (!test_commercial(2305814, 2598007, ITALY)) + return Qfalse; + if (!test_commercial(MAX_JD - 366, MAX_JD, ITALY)) + return Qfalse; + + return Qtrue; +} + +static int +test_weeknum(int from, int to, int f, double sg) +{ + int j; + + fprintf(stderr, "test_weeknum: %d...%d (%d) - %.0f\n", + from, to, to - from, sg); + for (j = from; j <= to; j++) { + int y, w, d, rj, ns; + + c_jd_to_weeknum(j, f, sg, &y, &w, &d); + c_weeknum_to_jd(y, w, d, f, sg, &rj, &ns); + if (j != rj) { + fprintf(stderr, "%d != %d\n", j, rj); + return 0; + } + } + return 1; +} + +static VALUE +date_s_test_weeknum(VALUE klass) +{ + int f; + + for (f = 0; f <= 1; f++) { + if (!test_weeknum(MIN_JD, MIN_JD + 366, f, GREGORIAN)) + return Qfalse; + if (!test_weeknum(2305814, 2598007, f, GREGORIAN)) + return Qfalse; + if (!test_weeknum(MAX_JD - 366, MAX_JD, f, GREGORIAN)) + return Qfalse; + + if (!test_weeknum(MIN_JD, MIN_JD + 366, f, ITALY)) + return Qfalse; + if (!test_weeknum(2305814, 2598007, f, ITALY)) + return Qfalse; + if (!test_weeknum(MAX_JD - 366, MAX_JD, f, ITALY)) + return Qfalse; + } + + return Qtrue; +} + +static int +test_nth_kday(int from, int to, double sg) +{ + int j; + + fprintf(stderr, "test_nth_kday: %d...%d (%d) - %.0f\n", + from, to, to - from, sg); + for (j = from; j <= to; j++) { + int y, m, n, k, rj, ns; + + c_jd_to_nth_kday(j, sg, &y, &m, &n, &k); + c_nth_kday_to_jd(y, m, n, k, sg, &rj, &ns); + if (j != rj) { + fprintf(stderr, "%d != %d\n", j, rj); + return 0; + } + } + return 1; +} + +static VALUE +date_s_test_nth_kday(VALUE klass) +{ + if (!test_nth_kday(MIN_JD, MIN_JD + 366, GREGORIAN)) + return Qfalse; + if (!test_nth_kday(2305814, 2598007, GREGORIAN)) + return Qfalse; + if (!test_nth_kday(MAX_JD - 366, MAX_JD, GREGORIAN)) + return Qfalse; + + if (!test_nth_kday(MIN_JD, MIN_JD + 366, ITALY)) + return Qfalse; + if (!test_nth_kday(2305814, 2598007, ITALY)) + return Qfalse; + if (!test_nth_kday(MAX_JD - 366, MAX_JD, ITALY)) + return Qfalse; + + return Qtrue; +} + +static int +test_unit_v2v(VALUE i, + VALUE (* conv1)(VALUE), + VALUE (* conv2)(VALUE)) +{ + VALUE c, o; + c = (*conv1)(i); + o = (*conv2)(c); + return f_eqeq_p(o, i); +} + +static int +test_unit_v2v_iter2(VALUE (* conv1)(VALUE), + VALUE (* conv2)(VALUE)) +{ + if (!test_unit_v2v(INT2FIX(0), conv1, conv2)) + return 0; + if (!test_unit_v2v(INT2FIX(1), conv1, conv2)) + return 0; + if (!test_unit_v2v(INT2FIX(2), conv1, conv2)) + return 0; + if (!test_unit_v2v(INT2FIX(3), conv1, conv2)) + return 0; + if (!test_unit_v2v(INT2FIX(11), conv1, conv2)) + return 0; + if (!test_unit_v2v(INT2FIX(65535), conv1, conv2)) + return 0; + if (!test_unit_v2v(INT2FIX(1073741823), conv1, conv2)) + return 0; + if (!test_unit_v2v(INT2NUM(1073741824), conv1, conv2)) + return 0; + if (!test_unit_v2v(rb_rational_new2(INT2FIX(0), INT2FIX(1)), conv1, conv2)) + return 0; + if (!test_unit_v2v(rb_rational_new2(INT2FIX(1), INT2FIX(1)), conv1, conv2)) + return 0; + if (!test_unit_v2v(rb_rational_new2(INT2FIX(1), INT2FIX(2)), conv1, conv2)) + return 0; + if (!test_unit_v2v(rb_rational_new2(INT2FIX(2), INT2FIX(3)), conv1, conv2)) + return 0; + return 1; +} + +static int +test_unit_v2v_iter(VALUE (* conv1)(VALUE), + VALUE (* conv2)(VALUE)) +{ + if (!test_unit_v2v_iter2(conv1, conv2)) + return 0; + if (!test_unit_v2v_iter2(conv2, conv1)) + return 0; + return 1; +} + +static VALUE +date_s_test_unit_conv(VALUE klass) +{ + if (!test_unit_v2v_iter(sec_to_day, day_to_sec)) + return Qfalse; + if (!test_unit_v2v_iter(ms_to_sec, sec_to_ms)) + return Qfalse; + if (!test_unit_v2v_iter(ns_to_day, day_to_ns)) + return Qfalse; + if (!test_unit_v2v_iter(ns_to_sec, sec_to_ns)) + return Qfalse; + return Qtrue; +} + +static VALUE +date_s_test_all(VALUE klass) +{ + if (date_s_test_civil(klass) == Qfalse) + return Qfalse; + if (date_s_test_ordinal(klass) == Qfalse) + return Qfalse; + if (date_s_test_commercial(klass) == Qfalse) + return Qfalse; + if (date_s_test_weeknum(klass) == Qfalse) + return Qfalse; + if (date_s_test_nth_kday(klass) == Qfalse) + return Qfalse; + if (date_s_test_unit_conv(klass) == Qfalse) + return Qfalse; + return Qtrue; +} +#endif + +static const char *monthnames[] = { + NULL, + "January", "February", "March", + "April", "May", "June", + "July", "August", "September", + "October", "November", "December" +}; + +static const char *abbr_monthnames[] = { + NULL, + "Jan", "Feb", "Mar", "Apr", + "May", "Jun", "Jul", "Aug", + "Sep", "Oct", "Nov", "Dec" +}; + +static const char *daynames[] = { + "Sunday", "Monday", "Tuesday", "Wednesday", + "Thursday", "Friday", "Saturday" +}; + +static const char *abbr_daynames[] = { + "Sun", "Mon", "Tue", "Wed", + "Thu", "Fri", "Sat" +}; + +static VALUE +mk_ary_of_str(long len, const char *a[]) +{ + VALUE o; + long i; + + o = rb_ary_new2(len); + for (i = 0; i < len; i++) { + VALUE e; + + if (!a[i]) + e = Qnil; + else { + e = rb_usascii_str_new2(a[i]); + rb_obj_freeze(e); + } + rb_ary_push(o, e); + } + rb_obj_freeze(o); + return o; +} + +void +Init_date_core(void) +{ +#undef rb_intern +#define rb_intern(str) rb_intern_const(str) + + assert(fprintf(stderr, "assert() is now active\n")); + + id_cmp = rb_intern("<=>"); + id_le_p = rb_intern("<="); + id_ge_p = rb_intern(">="); + id_eqeq_p = rb_intern("=="); + + half_days_in_day = rb_rational_new2(INT2FIX(1), INT2FIX(2)); + +#if (LONG_MAX / DAY_IN_SECONDS) > SECOND_IN_NANOSECONDS + day_in_nanoseconds = LONG2NUM((long)DAY_IN_SECONDS * + SECOND_IN_NANOSECONDS); +#elif defined HAVE_LONG_LONG + day_in_nanoseconds = LL2NUM((LONG_LONG)DAY_IN_SECONDS * + SECOND_IN_NANOSECONDS); +#else + day_in_nanoseconds = f_mul(INT2FIX(DAY_IN_SECONDS), + INT2FIX(SECOND_IN_NANOSECONDS)); +#endif + + rb_gc_register_mark_object(half_days_in_day); + rb_gc_register_mark_object(day_in_nanoseconds); + + positive_inf = +INFINITY; + negative_inf = -INFINITY; + + /* + * date and datetime class - Tadayoshi Funaba 1998-2011 + * + * 'date' provides two classes Date and DateTime. + * + * == Terms and definitions + * + * Some terms and definitions are based on ISO 8601 and JIS X 0301. + * + * === calendar date + * + * The calendar date is a particular day of a calendar year, + * identified by its ordinal number within a calendar month within + * that year. + * + * In those classes, this is so-called "civil". + * + * === ordinal date + * + * The ordinal date is a particular day of a calendar year identified + * by its ordinal number within the year. + * + * In those classes, this is so-called "ordinal". + * + * === week date + * + * The week date is a date identified by calendar week and day numbers. + * + * The calendar week is a seven day period within a calendar year, + * starting on a Monday and identified by its ordinal number within + * the year; the first calendar week of the year is the one that + * includes the first Thursday of that year. In the Gregorian + * calendar, this is equivalent to the week which includes January 4. + * + * In those classes, this so-called "commercial". + * + * === julian day number + * + * The Julian day number is in elapsed days since noon (Greenwich mean + * time) on January 1, 4713 BCE (in the Julian calendar). + * + * In this document, the astronomical Julian day number is same as the + * original Julian day number. And the chronological Julian day + * number is a variation of the Julian day number. Its days begin at + * midnight on local time. + * + * In this document, when the term "Julian day number" simply appears, + * it just refers to "chronological Julian day number", not the + * original. + * + * In those classes, those are so-called "ajd" and "jd". + * + * === modified julian day number + * + * The modified Julian day number is in elapsed days since midnight + * (Coordinated universal time) on November 17, 1858 CE (in the + * Gregorian calendar). + * + * In this document, the astronomical modified Julian day number is + * same as the original modified Julian day number. And the + * chronological modified Julian day number is a variation of the + * modified Julian day number. Its days begin at midnight on local + * time. + * + * In this document, when the term "modified Julian day number" simply + * appears, it just refers to "chronological modified Julian day + * number", not the original. + * + * In those classes, this is so-called "mjd". + * + * == Date + * + * A subclass of Object that includes Comparable module and easily handles + * date. + * + * Date object is created with Date::new, Date::jd, Date::ordinal, + * Date::commercial, Date::parse, Date::strptime, Date::today, + * Time#to_date or etc. + * + * require 'date' + * + * Date.new(2001,2,3) + * #=> # + * Date.jd(2451944) + * #=> # + * Date.ordinal(2001,34) + * #=> # + * Date.commercial(2001,5,6) + * #=> # + * Date.parse('2001-02-03') + * #=> # + * Date.strptime('03-02-2001', '%d-%m-%Y') + * #=> # + * Time.new(2001,2,3).to_date + * #=> # + * + * All date objects are immutable; hence cannot modify themselves. + * + * The concept of this date object can be represented as a tuple + * of the day count, the offset and the day of calendar reform. + * + * The day count denotes the absolute position of a temporal + * dimension. The offset is relative adjustment, which determines + * decoded local time with the day count. The day of calendar + * reform denotes the start day of the new style. The old style + * of the West is the Julian calendar which was adopted by + * Caesar. The new style is the Gregorian calendar, which is the + * current civil calendar of many countries. + * + * The day count is virtually the astronomical Julian day number. + * The offset in this class is usually zero, and cannot be + * specified directly. + * + * An optional argument the day of calendar reform (start) as a + * Julian day number, which should be 2298874 to 2426355 or -/+oo. + * The default value is Date::ITALY (2299161=1582-10-15). See + * also sample/cal.rb. + * + * $ ruby sample/cal.rb -c it 10 1582 + * October 1582 + * S M Tu W Th F S + * 1 2 3 4 15 16 + * 17 18 19 20 21 22 23 + * 24 25 26 27 28 29 30 + * 31 + * + * $ ruby sample/cal.rb -c gb 9 1752 + * September 1752 + * S M Tu W Th F S + * 1 2 14 15 16 + * 17 18 19 20 21 22 23 + * 24 25 26 27 28 29 30 + * + * Date object has various methods. See each reference. + * + * d = Date.parse('3rd Feb 2001') + * #=> # + * d.year #=> 2001 + * d.mon #=> 2 + * d.mday #=> 3 + * d.wday #=> 6 + * d += 1 #=> # + * d.strftime('%a %d %b %Y') #=> "Sun 04 Feb 2001" + * + * + * == DateTime + * + * A subclass of Date that easily handles date, hour, minute, second and + * offset. + * + * DateTime does not consider any leap seconds, does not track + * any summer time rules. + * + * DateTime object is created with DateTime::new, DateTime::jd, + * DateTime::ordinal, DateTime::commercial, DateTime::parse, + * DateTime::strptime, DateTime::now, Time#to_datetime or etc. + * + * require 'date' + * + * DateTime.new(2001,2,3,4,5,6) + * #=> # + * + * The last element of day, hour, minute or second can be + * fractional number. The fractional number's precision is assumed + * at most nanosecond. + * + * DateTime.new(2001,2,3.5) + * #=> # + * + * An optional argument the offset indicates the difference + * between the local time and UTC. For example, Rational(3,24) + * represents ahead of 3 hours of UTC, Rational(-5,24) represents + * behind of 5 hours of UTC. The offset should be -1 to +1, and + * its precision is assumed at most second. The default value is + * zero(equals to UTC). + * + * DateTime.new(2001,2,3,4,5,6,Rational(3,24)) + * #=> # + * + * also accepts string form. + * + * DateTime.new(2001,2,3,4,5,6,'+03:00') + * #=> # + * + * An optional argument the day of calendar reform (start) denotes + * a Julian day number, which should be 2298874 to 2426355 or + * -/+oo. The default value is Date::ITALY (2299161=1582-10-15). + * + * DateTime object has various methods. See each reference. + * + * d = DateTime.parse('3rd Feb 2001 04:05:06+03:30') + * #=> # + * d.hour #=> 4 + * d.min #=> 5 + * d.sec #=> 6 + * d.offset #=> (7/48) + * d.zone #=> "+03:30" + * d += Rational('1.5') + * #=> # + * d = d.new_offset('+09:00') + * #=> # + * d.strftime('%I:%M:%S %p') + * #=> "09:35:06 PM" + * d > DateTime.new(1999) + * #=> true + */ + cDate = rb_define_class("Date", rb_cObject); + + rb_include_module(cDate, rb_mComparable); + + /* An array of strings of full month names in English. The first + * element is nil. + */ + rb_define_const(cDate, "MONTHNAMES", mk_ary_of_str(13, monthnames)); + + /* An array of strings of abbreviated month names in English. The + * first element is nil. + */ + rb_define_const(cDate, "ABBR_MONTHNAMES", + mk_ary_of_str(13, abbr_monthnames)); + + /* An array of strings of the full names of days of the week in English. + * The first is "Sunday". + */ + rb_define_const(cDate, "DAYNAMES", mk_ary_of_str(7, daynames)); + + /* An array of strings of abbreviated day names in English. The + * first is "Sun". + */ + rb_define_const(cDate, "ABBR_DAYNAMES", mk_ary_of_str(7, abbr_daynames)); + + /* The Julian day number of the day of calendar reform for Italy + * and some catholic countries. + */ + rb_define_const(cDate, "ITALY", INT2FIX(ITALY)); + + /* The Julian day number of the day of calendar reform for England + * and her colonies. + */ + rb_define_const(cDate, "ENGLAND", INT2FIX(ENGLAND)); + + /* The Julian day number of the day of calendar reform for the + * proleptic Julian calendar + */ + rb_define_const(cDate, "JULIAN", DBL2NUM(JULIAN)); + + /* The Julian day number of the day of calendar reform for the + * proleptic Gregorian calendar + */ + rb_define_const(cDate, "GREGORIAN", DBL2NUM(GREGORIAN)); + + rb_define_alloc_func(cDate, d_lite_s_alloc); + +#ifndef NDEBUG +#define de_define_private_method rb_define_private_method + de_define_private_method(CLASS_OF(cDate), "_valid_jd?", + date_s__valid_jd_p, -1); + de_define_private_method(CLASS_OF(cDate), "_valid_ordinal?", + date_s__valid_ordinal_p, -1); + de_define_private_method(CLASS_OF(cDate), "_valid_civil?", + date_s__valid_civil_p, -1); + de_define_private_method(CLASS_OF(cDate), "_valid_date?", + date_s__valid_civil_p, -1); + de_define_private_method(CLASS_OF(cDate), "_valid_commercial?", + date_s__valid_commercial_p, -1); + de_define_private_method(CLASS_OF(cDate), "_valid_weeknum?", + date_s__valid_weeknum_p, -1); + de_define_private_method(CLASS_OF(cDate), "_valid_nth_kday?", + date_s__valid_nth_kday_p, -1); +#endif + + rb_define_singleton_method(cDate, "valid_jd?", date_s_valid_jd_p, -1); + rb_define_singleton_method(cDate, "valid_ordinal?", + date_s_valid_ordinal_p, -1); + rb_define_singleton_method(cDate, "valid_civil?", date_s_valid_civil_p, -1); + rb_define_singleton_method(cDate, "valid_date?", date_s_valid_civil_p, -1); + rb_define_singleton_method(cDate, "valid_commercial?", + date_s_valid_commercial_p, -1); + +#ifndef NDEBUG + de_define_private_method(CLASS_OF(cDate), "valid_weeknum?", + date_s_valid_weeknum_p, -1); + de_define_private_method(CLASS_OF(cDate), "valid_nth_kday?", + date_s_valid_nth_kday_p, -1); + de_define_private_method(CLASS_OF(cDate), "zone_to_diff", + date_s_zone_to_diff, 1); +#endif + + rb_define_singleton_method(cDate, "julian_leap?", date_s_julian_leap_p, 1); + rb_define_singleton_method(cDate, "gregorian_leap?", + date_s_gregorian_leap_p, 1); + rb_define_singleton_method(cDate, "leap?", + date_s_gregorian_leap_p, 1); + +#ifndef NDEBUG +#define de_define_singleton_method rb_define_singleton_method +#define de_define_alias rb_define_alias + de_define_singleton_method(cDate, "new!", date_s_new_bang, -1); + de_define_alias(rb_singleton_class(cDate), "new_l!", "new"); +#endif + + rb_define_singleton_method(cDate, "jd", date_s_jd, -1); + rb_define_singleton_method(cDate, "ordinal", date_s_ordinal, -1); + rb_define_singleton_method(cDate, "civil", date_s_civil, -1); + rb_define_singleton_method(cDate, "new", date_s_civil, -1); + rb_define_singleton_method(cDate, "commercial", date_s_commercial, -1); + +#ifndef NDEBUG + de_define_singleton_method(cDate, "weeknum", date_s_weeknum, -1); + de_define_singleton_method(cDate, "nth_kday", date_s_nth_kday, -1); +#endif + + rb_define_singleton_method(cDate, "today", date_s_today, -1); + rb_define_singleton_method(cDate, "_strptime", date_s__strptime, -1); + rb_define_singleton_method(cDate, "strptime", date_s_strptime, -1); + rb_define_singleton_method(cDate, "_parse", date_s__parse, -1); + rb_define_singleton_method(cDate, "parse", date_s_parse, -1); + rb_define_singleton_method(cDate, "_iso8601", date_s__iso8601, 1); + rb_define_singleton_method(cDate, "iso8601", date_s_iso8601, -1); + rb_define_singleton_method(cDate, "_rfc3339", date_s__rfc3339, 1); + rb_define_singleton_method(cDate, "rfc3339", date_s_rfc3339, -1); + rb_define_singleton_method(cDate, "_xmlschema", date_s__xmlschema, 1); + rb_define_singleton_method(cDate, "xmlschema", date_s_xmlschema, -1); + rb_define_singleton_method(cDate, "_rfc2822", date_s__rfc2822, 1); + rb_define_singleton_method(cDate, "_rfc822", date_s__rfc2822, 1); + rb_define_singleton_method(cDate, "rfc2822", date_s_rfc2822, -1); + rb_define_singleton_method(cDate, "rfc822", date_s_rfc2822, -1); + rb_define_singleton_method(cDate, "_httpdate", date_s__httpdate, 1); + rb_define_singleton_method(cDate, "httpdate", date_s_httpdate, -1); + rb_define_singleton_method(cDate, "_jisx0301", date_s__jisx0301, 1); + rb_define_singleton_method(cDate, "jisx0301", date_s_jisx0301, -1); + +#ifndef NDEBUG +#define de_define_method rb_define_method + de_define_method(cDate, "initialize", d_lite_initialize, -1); +#endif + rb_define_method(cDate, "initialize_copy", d_lite_initialize_copy, 1); + +#ifndef NDEBUG + de_define_method(cDate, "fill", d_lite_fill, 0); +#endif + + rb_define_method(cDate, "ajd", d_lite_ajd, 0); + rb_define_method(cDate, "amjd", d_lite_amjd, 0); + rb_define_method(cDate, "jd", d_lite_jd, 0); + rb_define_method(cDate, "mjd", d_lite_mjd, 0); + rb_define_method(cDate, "ld", d_lite_ld, 0); + + rb_define_method(cDate, "year", d_lite_year, 0); + rb_define_method(cDate, "yday", d_lite_yday, 0); + rb_define_method(cDate, "mon", d_lite_mon, 0); + rb_define_method(cDate, "month", d_lite_mon, 0); + rb_define_method(cDate, "mday", d_lite_mday, 0); + rb_define_method(cDate, "day", d_lite_mday, 0); + rb_define_method(cDate, "day_fraction", d_lite_day_fraction, 0); + + rb_define_method(cDate, "cwyear", d_lite_cwyear, 0); + rb_define_method(cDate, "cweek", d_lite_cweek, 0); + rb_define_method(cDate, "cwday", d_lite_cwday, 0); + +#ifndef NDEBUG + de_define_private_method(cDate, "wnum0", d_lite_wnum0, 0); + de_define_private_method(cDate, "wnum1", d_lite_wnum1, 0); +#endif + + rb_define_method(cDate, "wday", d_lite_wday, 0); + + rb_define_method(cDate, "sunday?", d_lite_sunday_p, 0); + rb_define_method(cDate, "monday?", d_lite_monday_p, 0); + rb_define_method(cDate, "tuesday?", d_lite_tuesday_p, 0); + rb_define_method(cDate, "wednesday?", d_lite_wednesday_p, 0); + rb_define_method(cDate, "thursday?", d_lite_thursday_p, 0); + rb_define_method(cDate, "friday?", d_lite_friday_p, 0); + rb_define_method(cDate, "saturday?", d_lite_saturday_p, 0); + +#ifndef NDEBUG + de_define_method(cDate, "nth_kday?", d_lite_nth_kday_p, 2); +#endif + + rb_define_private_method(cDate, "hour", d_lite_hour, 0); + rb_define_private_method(cDate, "min", d_lite_min, 0); + rb_define_private_method(cDate, "minute", d_lite_min, 0); + rb_define_private_method(cDate, "sec", d_lite_sec, 0); + rb_define_private_method(cDate, "second", d_lite_sec, 0); + rb_define_private_method(cDate, "sec_fraction", d_lite_sec_fraction, 0); + rb_define_private_method(cDate, "second_fraction", d_lite_sec_fraction, 0); + rb_define_private_method(cDate, "offset", d_lite_offset, 0); + rb_define_private_method(cDate, "zone", d_lite_zone, 0); + + rb_define_method(cDate, "julian?", d_lite_julian_p, 0); + rb_define_method(cDate, "gregorian?", d_lite_gregorian_p, 0); + rb_define_method(cDate, "leap?", d_lite_leap_p, 0); + + rb_define_method(cDate, "start", d_lite_start, 0); + rb_define_method(cDate, "new_start", d_lite_new_start, -1); + rb_define_method(cDate, "italy", d_lite_italy, 0); + rb_define_method(cDate, "england", d_lite_england, 0); + rb_define_method(cDate, "julian", d_lite_julian, 0); + rb_define_method(cDate, "gregorian", d_lite_gregorian, 0); + + rb_define_private_method(cDate, "new_offset", d_lite_new_offset, -1); + + rb_define_method(cDate, "+", d_lite_plus, 1); + rb_define_method(cDate, "-", d_lite_minus, 1); + + rb_define_method(cDate, "next_day", d_lite_next_day, -1); + rb_define_method(cDate, "prev_day", d_lite_prev_day, -1); + rb_define_method(cDate, "next", d_lite_next, 0); + rb_define_method(cDate, "succ", d_lite_next, 0); + + rb_define_method(cDate, ">>", d_lite_rshift, 1); + rb_define_method(cDate, "<<", d_lite_lshift, 1); + + rb_define_method(cDate, "next_month", d_lite_next_month, -1); + rb_define_method(cDate, "prev_month", d_lite_prev_month, -1); + rb_define_method(cDate, "next_year", d_lite_next_year, -1); + rb_define_method(cDate, "prev_year", d_lite_prev_year, -1); + + rb_define_method(cDate, "step", d_lite_step, -1); + rb_define_method(cDate, "upto", d_lite_upto, 1); + rb_define_method(cDate, "downto", d_lite_downto, 1); + + rb_define_method(cDate, "<=>", d_lite_cmp, 1); + rb_define_method(cDate, "===", d_lite_equal, 1); + rb_define_method(cDate, "eql?", d_lite_eql_p, 1); + rb_define_method(cDate, "hash", d_lite_hash, 0); + + rb_define_method(cDate, "to_s", d_lite_to_s, 0); +#ifndef NDEBUG + de_define_method(cDate, "inspect_raw", d_lite_inspect_raw, 0); +#endif + rb_define_method(cDate, "inspect", d_lite_inspect, 0); + + rb_define_method(cDate, "strftime", d_lite_strftime, -1); + + rb_define_method(cDate, "asctime", d_lite_asctime, 0); + rb_define_method(cDate, "ctime", d_lite_asctime, 0); + rb_define_method(cDate, "iso8601", d_lite_iso8601, 0); + rb_define_method(cDate, "xmlschema", d_lite_iso8601, 0); + rb_define_method(cDate, "rfc3339", d_lite_rfc3339, 0); + rb_define_method(cDate, "rfc2822", d_lite_rfc2822, 0); + rb_define_method(cDate, "rfc822", d_lite_rfc2822, 0); + rb_define_method(cDate, "httpdate", d_lite_httpdate, 0); + rb_define_method(cDate, "jisx0301", d_lite_jisx0301, 0); + +#ifndef NDEBUG + de_define_method(cDate, "marshal_dump_old", d_lite_marshal_dump_old, 0); +#endif + rb_define_method(cDate, "marshal_dump", d_lite_marshal_dump, 0); + rb_define_method(cDate, "marshal_load", d_lite_marshal_load, 1); + rb_define_singleton_method(cDate, "_load", date_s__load, 1); + + /* datetime */ + + cDateTime = rb_define_class("DateTime", cDate); + + rb_define_singleton_method(cDateTime, "jd", datetime_s_jd, -1); + rb_define_singleton_method(cDateTime, "ordinal", datetime_s_ordinal, -1); + rb_define_singleton_method(cDateTime, "civil", datetime_s_civil, -1); + rb_define_singleton_method(cDateTime, "new", datetime_s_civil, -1); + rb_define_singleton_method(cDateTime, "commercial", + datetime_s_commercial, -1); + +#ifndef NDEBUG + de_define_singleton_method(cDateTime, "weeknum", + datetime_s_weeknum, -1); + de_define_singleton_method(cDateTime, "nth_kday", + datetime_s_nth_kday, -1); +#endif + + rb_undef_method(CLASS_OF(cDateTime), "today"); + + rb_define_singleton_method(cDateTime, "now", datetime_s_now, -1); + rb_define_singleton_method(cDateTime, "_strptime", + datetime_s__strptime, -1); + rb_define_singleton_method(cDateTime, "strptime", + datetime_s_strptime, -1); + rb_define_singleton_method(cDateTime, "parse", + datetime_s_parse, -1); + rb_define_singleton_method(cDateTime, "iso8601", + datetime_s_iso8601, -1); + rb_define_singleton_method(cDateTime, "rfc3339", + datetime_s_rfc3339, -1); + rb_define_singleton_method(cDateTime, "xmlschema", + datetime_s_xmlschema, -1); + rb_define_singleton_method(cDateTime, "rfc2822", + datetime_s_rfc2822, -1); + rb_define_singleton_method(cDateTime, "rfc822", + datetime_s_rfc2822, -1); + rb_define_singleton_method(cDateTime, "httpdate", + datetime_s_httpdate, -1); + rb_define_singleton_method(cDateTime, "jisx0301", + datetime_s_jisx0301, -1); + +#define f_public(m,s) rb_funcall(m, rb_intern("public"), 1,\ + ID2SYM(rb_intern(s))) + + f_public(cDateTime, "hour"); + f_public(cDateTime, "min"); + f_public(cDateTime, "minute"); + f_public(cDateTime, "sec"); + f_public(cDateTime, "second"); + f_public(cDateTime, "sec_fraction"); + f_public(cDateTime, "second_fraction"); + f_public(cDateTime, "offset"); + f_public(cDateTime, "zone"); + f_public(cDateTime, "new_offset"); + + rb_define_method(cDateTime, "to_s", dt_lite_to_s, 0); + + rb_define_method(cDateTime, "strftime", dt_lite_strftime, -1); + + rb_define_method(cDateTime, "iso8601", dt_lite_iso8601, -1); + rb_define_method(cDateTime, "xmlschema", dt_lite_iso8601, -1); + rb_define_method(cDateTime, "rfc3339", dt_lite_rfc3339, -1); + rb_define_method(cDateTime, "jisx0301", dt_lite_jisx0301, -1); + + /* conversions */ + + rb_define_method(rb_cTime, "to_time", time_to_time, 0); + rb_define_method(rb_cTime, "to_date", time_to_date, 0); + rb_define_method(rb_cTime, "to_datetime", time_to_datetime, 0); + + rb_define_method(cDate, "to_time", date_to_time, 0); + rb_define_method(cDate, "to_date", date_to_date, 0); + rb_define_method(cDate, "to_datetime", date_to_datetime, 0); + + rb_define_method(cDateTime, "to_time", datetime_to_time, 0); + rb_define_method(cDateTime, "to_date", datetime_to_date, 0); + rb_define_method(cDateTime, "to_datetime", datetime_to_datetime, 0); + +#ifndef NDEBUG + /* tests */ + + de_define_singleton_method(cDate, "test_civil", date_s_test_civil, 0); + de_define_singleton_method(cDate, "test_ordinal", date_s_test_ordinal, 0); + de_define_singleton_method(cDate, "test_commercial", + date_s_test_commercial, 0); + de_define_singleton_method(cDate, "test_weeknum", date_s_test_weeknum, 0); + de_define_singleton_method(cDate, "test_nth_kday", date_s_test_nth_kday, 0); + de_define_singleton_method(cDate, "test_unit_conv", + date_s_test_unit_conv, 0); + de_define_singleton_method(cDate, "test_all", date_s_test_all, 0); +#endif +} + +/* +Local variables: +c-file-style: "ruby" +End: +*/ diff --git a/jni/ruby/ext/date/date_parse.c b/jni/ruby/ext/date/date_parse.c new file mode 100644 index 0000000..239e264 --- /dev/null +++ b/jni/ruby/ext/date/date_parse.c @@ -0,0 +1,3128 @@ +/* + date_parse.c: Coded by Tadayoshi Funaba 2011,2012 +*/ + +#include "ruby.h" +#include "ruby/encoding.h" +#include "ruby/re.h" +#include + +/* #define TIGHT_PARSER */ + +#define sizeof_array(o) (sizeof o / sizeof o[0]) + +#define f_negate(x) rb_funcall(x, rb_intern("-@"), 0) +#define f_add(x,y) rb_funcall(x, '+', 1, y) +#define f_sub(x,y) rb_funcall(x, '-', 1, y) +#define f_mul(x,y) rb_funcall(x, '*', 1, y) +#define f_div(x,y) rb_funcall(x, '/', 1, y) +#define f_idiv(x,y) rb_funcall(x, rb_intern("div"), 1, y) +#define f_mod(x,y) rb_funcall(x, '%', 1, y) +#define f_expt(x,y) rb_funcall(x, rb_intern("**"), 1, y) + +#define f_lt_p(x,y) rb_funcall(x, '<', 1, y) +#define f_gt_p(x,y) rb_funcall(x, '>', 1, y) +#define f_le_p(x,y) rb_funcall(x, rb_intern("<="), 1, y) +#define f_ge_p(x,y) rb_funcall(x, rb_intern(">="), 1, y) + +#define f_to_s(x) rb_funcall(x, rb_intern("to_s"), 0) + +#define f_match(r,s) rb_funcall(r, rb_intern("match"), 1, s) +#define f_aref(o,i) rb_funcall(o, rb_intern("[]"), 1, i) +#define f_aref2(o,i,j) rb_funcall(o, rb_intern("[]"), 2, i, j) +#define f_begin(o,i) rb_funcall(o, rb_intern("begin"), 1, i) +#define f_end(o,i) rb_funcall(o, rb_intern("end"), 1, i) +#define f_aset(o,i,v) rb_funcall(o, rb_intern("[]="), 2, i, v) +#define f_aset2(o,i,j,v) rb_funcall(o, rb_intern("[]="), 3, i, j, v) +#define f_sub_bang(s,r,x) rb_funcall(s, rb_intern("sub!"), 2, r, x) +#define f_gsub_bang(s,r,x) rb_funcall(s, rb_intern("gsub!"), 2, r, x) + +#define set_hash(k,v) rb_hash_aset(hash, ID2SYM(rb_intern(k)), v) +#define ref_hash(k) rb_hash_aref(hash, ID2SYM(rb_intern(k))) +#define del_hash(k) rb_hash_delete(hash, ID2SYM(rb_intern(k))) + +#define cstr2num(s) rb_cstr_to_inum(s, 10, 0) +#define str2num(s) rb_str_to_inum(s, 10, 0) + +static const char *abbr_days[] = { + "sun", "mon", "tue", "wed", + "thu", "fri", "sat" +}; + +static const char *abbr_months[] = { + "jan", "feb", "mar", "apr", "may", "jun", + "jul", "aug", "sep", "oct", "nov", "dec" +}; + +#define issign(c) ((c) == '-' || (c) == '+') +#define asp_string() rb_str_new(" ", 1) +#ifdef TIGHT_PARSER +#define asuba_string() rb_str_new("\001", 1) +#define asubb_string() rb_str_new("\002", 1) +#define asubw_string() rb_str_new("\027", 1) +#define asubt_string() rb_str_new("\024", 1) +#endif + +#define DECDIGIT "0123456789" + +static void +s3e(VALUE hash, VALUE y, VALUE m, VALUE d, int bc) +{ + VALUE c = Qnil; + + if (!RB_TYPE_P(m, T_STRING)) + m = f_to_s(m); + + if (!NIL_P(y) && !NIL_P(m) && NIL_P(d)) { + VALUE oy = y; + VALUE om = m; + VALUE od = d; + + y = od; + m = oy; + d = om; + } + + if (NIL_P(y)) { + if (!NIL_P(d) && RSTRING_LEN(d) > 2) { + y = d; + d = Qnil; + } + if (!NIL_P(d) && *RSTRING_PTR(d) == '\'') { + y = d; + d = Qnil; + } + } + + if (!NIL_P(y)) { + const char *s, *bp, *ep; + size_t l; + + s = RSTRING_PTR(y); + while (!issign((unsigned char)*s) && !isdigit((unsigned char)*s)) + s++; + bp = s; + if (issign((unsigned char)*s)) + s++; + l = strspn(s, DECDIGIT); + ep = s + l; + if (*ep) { + y = d; + d = rb_str_new(bp, ep - bp); + } + } + + if (!NIL_P(m)) { + const char *s; + + s = RSTRING_PTR(m); + if (*s == '\'' || RSTRING_LEN(m) > 2) { + /* us -> be */ + VALUE oy = y; + VALUE om = m; + VALUE od = d; + + y = om; + m = od; + d = oy; + } + } + + if (!NIL_P(d)) { + const char *s; + + s = RSTRING_PTR(d); + if (*s == '\'' || RSTRING_LEN(d) > 2) { + VALUE oy = y; + VALUE od = d; + + y = od; + d = oy; + } + } + + if (!NIL_P(y)) { + const char *s, *bp, *ep; + int sign = 0; + size_t l; + VALUE iy; + + s = RSTRING_PTR(y); + while (!issign((unsigned char)*s) && !isdigit((unsigned char)*s)) + s++; + bp = s; + if (issign(*s)) { + s++; + sign = 1; + } + if (sign) + c = Qfalse; + l = strspn(s, DECDIGIT); + ep = s + l; + if (l > 2) + c = Qfalse; + { + char *buf; + + buf = ALLOCA_N(char, ep - bp + 1); + memcpy(buf, bp, ep - bp); + buf[ep - bp] = '\0'; + iy = cstr2num(buf); + } + set_hash("year", iy); + } + + if (bc) + set_hash("_bc", Qtrue); + + if (!NIL_P(m)) { + const char *s, *bp, *ep; + size_t l; + VALUE im; + + s = RSTRING_PTR(m); + while (!isdigit((unsigned char)*s)) + s++; + bp = s; + l = strspn(s, DECDIGIT); + ep = s + l; + { + char *buf; + + buf = ALLOCA_N(char, ep - bp + 1); + memcpy(buf, bp, ep - bp); + buf[ep - bp] = '\0'; + im = cstr2num(buf); + } + set_hash("mon", im); + } + + if (!NIL_P(d)) { + const char *s, *bp, *ep; + size_t l; + VALUE id; + + s = RSTRING_PTR(d); + while (!isdigit((unsigned char)*s)) + s++; + bp = s; + l = strspn(s, DECDIGIT); + ep = s + l; + { + char *buf; + + buf = ALLOCA_N(char, ep - bp + 1); + memcpy(buf, bp, ep - bp); + buf[ep - bp] = '\0'; + id = cstr2num(buf); + } + set_hash("mday", id); + } + + if (!NIL_P(c)) + set_hash("_comp", c); +} + +#define DAYS "sunday|monday|tuesday|wednesday|thursday|friday|saturday" +#define MONTHS "january|february|march|april|may|june|july|august|september|october|november|december" +#define ABBR_DAYS "sun|mon|tue|wed|thu|fri|sat" +#define ABBR_MONTHS "jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec" + +#ifdef TIGHT_PARSER +#define VALID_DAYS "(?:" DAYS ")" "|(?:tues|wednes|thurs|thur|" ABBR_DAYS ")\\.?" +#define VALID_MONTHS "(?:" MONTHS ")" "|(?:sept|" ABBR_MONTHS ")\\.?" +#define DOTLESS_VALID_MONTHS "(?:" MONTHS ")" "|(?:sept|" ABBR_MONTHS ")" +#define BOS "\\A\\s*" +#define FPA "\\001" +#define FPB "\\002" +#define FPW "\\027" +#define FPT "\\024" +#define FPW_COM "\\s*(?:" FPW "\\s*,?)?\\s*" +#define FPT_COM "\\s*(?:" FPT "\\s*,?)?\\s*" +#define COM_FPW "\\s*(?:,?\\s*" FPW ")?\\s*" +#define COM_FPT "\\s*(?:,?\\s*(?:@|\\b[aA][tT]\\b)?\\s*" FPT ")?\\s*" +#define TEE_FPT "\\s*(?:[tT]?" FPT ")?" +#define EOS "\\s*\\z" +#endif + +static VALUE +regcomp(const char *source, long len, int opt) +{ + VALUE pat; + + pat = rb_reg_new(source, len, opt); + rb_gc_register_mark_object(pat); + return pat; +} + +#define REGCOMP(pat,opt) \ +{ \ + if (NIL_P(pat)) \ + pat = regcomp(pat##_source, sizeof pat##_source - 1, opt); \ +} + +#define REGCOMP_0(pat) REGCOMP(pat, 0) +#define REGCOMP_I(pat) REGCOMP(pat, ONIG_OPTION_IGNORECASE) + +#define MATCH(s,p,c) \ +{ \ + return match(s, p, hash, c); \ +} + +static int +match(VALUE str, VALUE pat, VALUE hash, int (*cb)(VALUE, VALUE)) +{ + VALUE m; + + m = f_match(pat, str); + + if (NIL_P(m)) + return 0; + + (*cb)(m, hash); + + return 1; +} + +static int +subx(VALUE str, VALUE rep, VALUE pat, VALUE hash, int (*cb)(VALUE, VALUE)) +{ + VALUE m; + + m = f_match(pat, str); + + if (NIL_P(m)) + return 0; + + { + VALUE be, en; + + be = f_begin(m, INT2FIX(0)); + en = f_end(m, INT2FIX(0)); + f_aset2(str, be, LONG2NUM(NUM2LONG(en) - NUM2LONG(be)), rep); + (*cb)(m, hash); + } + + return 1; +} + +#define SUBS(s,p,c) \ +{ \ + return subx(s, asp_string(), p, hash, c); \ +} + +#ifdef TIGHT_PARSER +#define SUBA(s,p,c) \ +{ \ + return subx(s, asuba_string(), p, hash, c); \ +} + +#define SUBB(s,p,c) \ +{ \ + return subx(s, asubb_string(), p, hash, c); \ +} + +#define SUBW(s,p,c) \ +{ \ + return subx(s, asubw_string(), p, hash, c); \ +} + +#define SUBT(s,p,c) \ +{ \ + return subx(s, asubt_string(), p, hash, c); \ +} +#endif + +struct zone { + const char *name; + int offset; +}; + +static struct zone zones_source[] = { + {"ut", 0*3600}, {"gmt", 0*3600}, {"est", -5*3600}, {"edt", -4*3600}, + {"cst", -6*3600}, {"cdt", -5*3600}, {"mst", -7*3600}, {"mdt", -6*3600}, + {"pst", -8*3600}, {"pdt", -7*3600}, + {"a", 1*3600}, {"b", 2*3600}, {"c", 3*3600}, {"d", 4*3600}, + {"e", 5*3600}, {"f", 6*3600}, {"g", 7*3600}, {"h", 8*3600}, + {"i", 9*3600}, {"k", 10*3600}, {"l", 11*3600}, {"m", 12*3600}, + {"n", -1*3600}, {"o", -2*3600}, {"p", -3*3600}, {"q", -4*3600}, + {"r", -5*3600}, {"s", -6*3600}, {"t", -7*3600}, {"u", -8*3600}, + {"v", -9*3600}, {"w", -10*3600}, {"x", -11*3600}, {"y", -12*3600}, + {"z", 0*3600}, + + {"utc", 0*3600}, {"wet", 0*3600}, + {"at", -2*3600}, {"brst",-2*3600}, {"ndt", -(2*3600+1800)}, + {"art", -3*3600}, {"adt", -3*3600}, {"brt", -3*3600}, {"clst",-3*3600}, + {"nst", -(3*3600+1800)}, + {"ast", -4*3600}, {"clt", -4*3600}, + {"akdt",-8*3600}, {"ydt", -8*3600}, + {"akst",-9*3600}, {"hadt",-9*3600}, {"hdt", -9*3600}, {"yst", -9*3600}, + {"ahst",-10*3600},{"cat",-10*3600}, {"hast",-10*3600},{"hst",-10*3600}, + {"nt", -11*3600}, + {"idlw",-12*3600}, + {"bst", 1*3600}, {"cet", 1*3600}, {"fwt", 1*3600}, {"met", 1*3600}, + {"mewt", 1*3600}, {"mez", 1*3600}, {"swt", 1*3600}, {"wat", 1*3600}, + {"west", 1*3600}, + {"cest", 2*3600}, {"eet", 2*3600}, {"fst", 2*3600}, {"mest", 2*3600}, + {"mesz", 2*3600}, {"sast", 2*3600}, {"sst", 2*3600}, + {"bt", 3*3600}, {"eat", 3*3600}, {"eest", 3*3600}, {"msk", 3*3600}, + {"msd", 4*3600}, {"zp4", 4*3600}, + {"zp5", 5*3600}, {"ist", (5*3600+1800)}, + {"zp6", 6*3600}, + {"wast", 7*3600}, + {"cct", 8*3600}, {"sgt", 8*3600}, {"wadt", 8*3600}, + {"jst", 9*3600}, {"kst", 9*3600}, + {"east",10*3600}, {"gst", 10*3600}, + {"eadt",11*3600}, + {"idle",12*3600}, {"nzst",12*3600}, {"nzt", 12*3600}, + {"nzdt",13*3600}, + + {"afghanistan", 16200}, {"alaskan", -32400}, + {"arab", 10800}, {"arabian", 14400}, + {"arabic", 10800}, {"atlantic", -14400}, + {"aus central", 34200}, {"aus eastern", 36000}, + {"azores", -3600}, {"canada central", -21600}, + {"cape verde", -3600}, {"caucasus", 14400}, + {"cen. australia", 34200}, {"central america", -21600}, + {"central asia", 21600}, {"central europe", 3600}, + {"central european", 3600}, {"central pacific", 39600}, + {"central", -21600}, {"china", 28800}, + {"dateline", -43200}, {"e. africa", 10800}, + {"e. australia", 36000}, {"e. europe", 7200}, + {"e. south america", -10800}, {"eastern", -18000}, + {"egypt", 7200}, {"ekaterinburg", 18000}, + {"fiji", 43200}, {"fle", 7200}, + {"greenland", -10800}, {"greenwich", 0}, + {"gtb", 7200}, {"hawaiian", -36000}, + {"india", 19800}, {"iran", 12600}, + {"jerusalem", 7200}, {"korea", 32400}, + {"mexico", -21600}, {"mid-atlantic", -7200}, + {"mountain", -25200}, {"myanmar", 23400}, + {"n. central asia", 21600}, {"nepal", 20700}, + {"new zealand", 43200}, {"newfoundland", -12600}, + {"north asia east", 28800}, {"north asia", 25200}, + {"pacific sa", -14400}, {"pacific", -28800}, + {"romance", 3600}, {"russian", 10800}, + {"sa eastern", -10800}, {"sa pacific", -18000}, + {"sa western", -14400}, {"samoa", -39600}, + {"se asia", 25200}, {"malay peninsula", 28800}, + {"south africa", 7200}, {"sri lanka", 21600}, + {"taipei", 28800}, {"tasmania", 36000}, + {"tokyo", 32400}, {"tonga", 46800}, + {"us eastern", -18000}, {"us mountain", -25200}, + {"vladivostok", 36000}, {"w. australia", 28800}, + {"w. central africa", 3600}, {"w. europe", 3600}, + {"west asia", 18000}, {"west pacific", 36000}, + {"yakutsk", 32400} +}; + +VALUE +date_zone_to_diff(VALUE str) +{ + VALUE offset = Qnil; + + long l, i; + char *s, *dest, *d; + int sp = 1; + + l = RSTRING_LEN(str); + s = RSTRING_PTR(str); + + dest = d = ALLOCA_N(char, l + 1); + + for (i = 0; i < l; i++) { + if (isspace((unsigned char)s[i]) || s[i] == '\0') { + if (!sp) + *d++ = ' '; + sp = 1; + } + else { + if (isalpha((unsigned char)s[i])) + *d++ = tolower((unsigned char)s[i]); + else + *d++ = s[i]; + sp = 0; + } + } + if (d > dest) { + if (*(d - 1) == ' ') + --d; + *d = '\0'; + } + str = rb_str_new2(dest); + { +#define STD " standard time" +#define DST " daylight time" + char *ss, *ds; + long sl, dl; + int dst = 0; + + sl = RSTRING_LEN(str) - (sizeof STD - 1); + ss = RSTRING_PTR(str) + sl; + dl = RSTRING_LEN(str) - (sizeof DST - 1); + ds = RSTRING_PTR(str) + dl; + + if (sl >= 0 && strcmp(ss, STD) == 0) { + str = rb_str_new(RSTRING_PTR(str), sl); + } + else if (dl >= 0 && strcmp(ds, DST) == 0) { + str = rb_str_new(RSTRING_PTR(str), dl); + dst = 1; + } +#undef STD +#undef DST + else { +#define DST " dst" + char *ds; + long dl; + + dl = RSTRING_LEN(str) - (sizeof DST - 1); + ds = RSTRING_PTR(str) + dl; + + if (dl >= 0 && strcmp(ds, DST) == 0) { + str = rb_str_new(RSTRING_PTR(str), dl); + dst = 1; + } +#undef DST + } + { + static VALUE zones = Qnil; + + if (NIL_P(zones)) { + int i; + + zones = rb_hash_new(); + rb_gc_register_mark_object(zones); + for (i = 0; i < (int)sizeof_array(zones_source); i++) { + VALUE name = rb_str_new2(zones_source[i].name); + VALUE offset = INT2FIX(zones_source[i].offset); + rb_hash_aset(zones, name, offset); + } + } + + offset = f_aref(zones, str); + if (!NIL_P(offset)) { + if (dst) + offset = f_add(offset, INT2FIX(3600)); + goto ok; + } + } + { + char *s, *p; + VALUE sign; + VALUE hour = Qnil, min = Qnil, sec = Qnil; + VALUE str_orig; + + s = RSTRING_PTR(str); + str_orig = str; + + if (strncmp(s, "gmt", 3) == 0 || + strncmp(s, "utc", 3) == 0) + s += 3; + if (issign(*s)) { + sign = rb_str_new(s, 1); + s++; + + str = rb_str_new2(s); + + if (p = strchr(s, ':')) { + hour = rb_str_new(s, p - s); + s = ++p; + if (p = strchr(s, ':')) { + min = rb_str_new(s, p - s); + s = ++p; + if (p = strchr(s, ':')) { + sec = rb_str_new(s, p - s); + } + else + sec = rb_str_new2(s); + } + else + min = rb_str_new2(s); + RB_GC_GUARD(str_orig); + goto num; + } + if (strpbrk(RSTRING_PTR(str), ",.")) { + char *a, *b; + + a = ALLOCA_N(char, RSTRING_LEN(str) + 1); + strcpy(a, RSTRING_PTR(str)); + b = strpbrk(a, ",."); + *b = '\0'; + b++; + + hour = cstr2num(a); + min = f_mul(rb_rational_new2 + (cstr2num(b), + f_expt(INT2FIX(10), + LONG2NUM((long)strlen(b)))), + INT2FIX(60)); + goto num; + } + { + const char *cs = RSTRING_PTR(str); + long cl = RSTRING_LEN(str); + + if (cl % 2) { + if (cl >= 1) + hour = rb_str_new(&cs[0], 1); + if (cl >= 3) + min = rb_str_new(&cs[1], 2); + if (cl >= 5) + sec = rb_str_new(&cs[3], 2); + } + else { + if (cl >= 2) + hour = rb_str_new(&cs[0], 2); + if (cl >= 4) + min = rb_str_new(&cs[2], 2); + if (cl >= 6) + sec = rb_str_new(&cs[4], 2); + } + goto num; + } + num: + if (NIL_P(hour)) + offset = INT2FIX(0); + else { + if (RB_TYPE_P(hour, T_STRING)) + hour = str2num(hour); + offset = f_mul(hour, INT2FIX(3600)); + } + if (!NIL_P(min)) { + if (RB_TYPE_P(min, T_STRING)) + min = str2num(min); + offset = f_add(offset, f_mul(min, INT2FIX(60))); + } + if (!NIL_P(sec)) + offset = f_add(offset, str2num(sec)); + if (!NIL_P(sign) && + RSTRING_LEN(sign) == 1 && + *RSTRING_PTR(sign) == '-') + offset = f_negate(offset); + } + } + } + RB_GC_GUARD(str); + ok: + return offset; +} + +static int +day_num(VALUE s) +{ + int i; + + for (i = 0; i < (int)sizeof_array(abbr_days); i++) + if (strncasecmp(abbr_days[i], RSTRING_PTR(s), 3) == 0) + break; + return i; +} + +static int +mon_num(VALUE s) +{ + int i; + + for (i = 0; i < (int)sizeof_array(abbr_months); i++) + if (strncasecmp(abbr_months[i], RSTRING_PTR(s), 3) == 0) + break; + return i + 1; +} + +static int +parse_day_cb(VALUE m, VALUE hash) +{ + VALUE s; + + s = rb_reg_nth_match(1, m); + set_hash("wday", INT2FIX(day_num(s))); + return 1; +} + +static int +parse_day(VALUE str, VALUE hash) +{ + static const char pat_source[] = +#ifndef TIGHT_PARSER + "\\b(" ABBR_DAYS ")[^-/\\d\\s]*" +#else + "(" VALID_DAYS ")" +#endif + ; + static VALUE pat = Qnil; + + REGCOMP_I(pat); +#ifndef TIGHT_PARSER + SUBS(str, pat, parse_day_cb); +#else + SUBW(str, pat, parse_day_cb); +#endif +} + +static int +parse_time2_cb(VALUE m, VALUE hash) +{ + VALUE h, min, s, f, p; + + h = rb_reg_nth_match(1, m); + h = str2num(h); + + min = rb_reg_nth_match(2, m); + if (!NIL_P(min)) + min = str2num(min); + + s = rb_reg_nth_match(3, m); + if (!NIL_P(s)) + s = str2num(s); + + f = rb_reg_nth_match(4, m); + + if (!NIL_P(f)) + f = rb_rational_new2(str2num(f), + f_expt(INT2FIX(10), LONG2NUM(RSTRING_LEN(f)))); + + p = rb_reg_nth_match(5, m); + + if (!NIL_P(p)) { + int ih = NUM2INT(h); + ih %= 12; + if (*RSTRING_PTR(p) == 'P' || *RSTRING_PTR(p) == 'p') + ih += 12; + h = INT2FIX(ih); + } + + set_hash("hour", h); + if (!NIL_P(min)) + set_hash("min", min); + if (!NIL_P(s)) + set_hash("sec", s); + if (!NIL_P(f)) + set_hash("sec_fraction", f); + + return 1; +} + +static int +parse_time_cb(VALUE m, VALUE hash) +{ + static const char pat_source[] = + "\\A(\\d+)h?" + "(?:\\s*:?\\s*(\\d+)m?" + "(?:" + "\\s*:?\\s*(\\d+)(?:[,.](\\d+))?s?" + ")?" + ")?" + "(?:\\s*([ap])(?:m\\b|\\.m\\.))?"; + static VALUE pat = Qnil; + VALUE s1, s2; + + s1 = rb_reg_nth_match(1, m); + s2 = rb_reg_nth_match(2, m); + + if (!NIL_P(s2)) + set_hash("zone", s2); + + REGCOMP_I(pat); + + { + VALUE m = f_match(pat, s1); + + if (NIL_P(m)) + return 0; + parse_time2_cb(m, hash); + } + + return 1; +} + +static int +parse_time(VALUE str, VALUE hash) +{ + static const char pat_source[] = + "(" + "(?:" + "\\d+\\s*:\\s*\\d+" + "(?:" +#ifndef TIGHT_PARSER + "\\s*:\\s*\\d+(?:[,.]\\d*)?" +#else + "\\s*:\\s*\\d+(?:[,.]\\d+)?" +#endif + ")?" + "|" + "\\d+\\s*h(?:\\s*\\d+m?(?:\\s*\\d+s?)?)?" + ")" + "(?:" + "\\s*" + "[ap](?:m\\b|\\.m\\.)" + ")?" + "|" + "\\d+\\s*[ap](?:m\\b|\\.m\\.)" + ")" + "(?:" + "\\s*" + "(" + "(?:gmt|utc?)?[-+]\\d+(?:[,.:]\\d+(?::\\d+)?)?" + "|" + "(?-i:[[:alpha:].\\s]+)(?:standard|daylight)\\stime\\b" + "|" + "(?-i:[[:alpha:]]+)(?:\\sdst)?\\b" + ")" + ")?"; + static VALUE pat = Qnil; + + REGCOMP_I(pat); +#ifndef TIGHT_PARSER + SUBS(str, pat, parse_time_cb); +#else + SUBT(str, pat, parse_time_cb); +#endif +} + +#ifdef TIGHT_PARSER +static int +parse_era1_cb(VALUE m, VALUE hash) +{ + return 1; +} + +static int +parse_era1(VALUE str, VALUE hash) +{ + static const char pat_source[] = + "(a(?:d|\\.d\\.))"; + static VALUE pat = Qnil; + + REGCOMP_I(pat); + SUBA(str, pat, parse_era1_cb); +} + +static int +parse_era2_cb(VALUE m, VALUE hash) +{ + VALUE b; + + b = rb_reg_nth_match(1, m); + if (*RSTRING_PTR(b) == 'B' || + *RSTRING_PTR(b) == 'b') + set_hash("_bc", Qtrue); + return 1; +} + +static int +parse_era2(VALUE str, VALUE hash) +{ + static const char pat_source[] = + "(c(?:e|\\.e\\.)|b(?:ce|\\.c\\.e\\.)|b(?:c|\\.c\\.))"; + static VALUE pat = Qnil; + + REGCOMP_I(pat); + SUBB(str, pat, parse_era2_cb); +} + +static int +parse_era(VALUE str, VALUE hash) +{ + if (parse_era1(str, hash)) /* pre */ + goto ok; + if (parse_era2(str, hash)) /* post */ + goto ok; + return 0; + ok: + return 1; +} +#endif + +#ifdef TIGHT_PARSER +static int +check_year_width(VALUE y) +{ + char *s; + size_t l; + + s = RSTRING_PTR(y); + l = strcspn(s, DECDIGIT); + s += l; + l = strspn(s, DECDIGIT); + if (l != 2) + return 0; + return 1; +} + +static int +check_apost(VALUE a, VALUE b, VALUE c) +{ + int f = 0; + + if (!NIL_P(a) && *RSTRING_PTR(a) == '\'') { + if (!check_year_width(a)) + return 0; + f++; + } + if (!NIL_P(b) && *RSTRING_PTR(b) == '\'') { + if (!check_year_width(b)) + return 0; + if (!NIL_P(c)) + return 0; + f++; + } + if (!NIL_P(c) && *RSTRING_PTR(c) == '\'') { + if (!check_year_width(c)) + return 0; + f++; + } + if (f > 1) + return 0; + return 1; +} +#endif + +static int +parse_eu_cb(VALUE m, VALUE hash) +{ +#ifndef TIGHT_PARSER + VALUE y, mon, d, b; + + d = rb_reg_nth_match(1, m); + mon = rb_reg_nth_match(2, m); + b = rb_reg_nth_match(3, m); + y = rb_reg_nth_match(4, m); + + mon = INT2FIX(mon_num(mon)); + + s3e(hash, y, mon, d, !NIL_P(b) && + (*RSTRING_PTR(b) == 'B' || + *RSTRING_PTR(b) == 'b')); +#else + VALUE y, mon, d; + + d = rb_reg_nth_match(1, m); + mon = rb_reg_nth_match(2, m); + y = rb_reg_nth_match(3, m); + + if (!check_apost(d, mon, y)) + return 0; + + mon = INT2FIX(mon_num(mon)); + + s3e(hash, y, mon, d, 0); +#endif + return 1; +} + +static int +parse_eu(VALUE str, VALUE hash) +{ + static const char pat_source[] = +#ifdef TIGHT_PARSER + BOS + FPW_COM FPT_COM +#endif +#ifndef TIGHT_PARSER + "('?\\d+)[^-\\d\\s]*" +#else + "(\\d+)(?:(?:st|nd|rd|th)\\b)?" +#endif + "\\s*" +#ifndef TIGHT_PARSER + "(" ABBR_MONTHS ")[^-\\d\\s']*" +#else + "(" VALID_MONTHS ")" +#endif + "(?:" + "\\s*" +#ifndef TIGHT_PARSER + "(c(?:e|\\.e\\.)|b(?:ce|\\.c\\.e\\.)|a(?:d|\\.d\\.)|b(?:c|\\.c\\.))?" + "\\s*" + "('?-?\\d+(?:(?:st|nd|rd|th)\\b)?)" +#else + "(?:" FPA ")?" + "\\s*" + "([-']?\\d+)" + "\\s*" + "(?:" FPA "|" FPB ")?" +#endif + ")?" +#ifdef TIGHT_PARSER + COM_FPT COM_FPW + EOS +#endif + ; + static VALUE pat = Qnil; + + REGCOMP_I(pat); + SUBS(str, pat, parse_eu_cb); +} + +static int +parse_us_cb(VALUE m, VALUE hash) +{ +#ifndef TIGHT_PARSER + VALUE y, mon, d, b; + + mon = rb_reg_nth_match(1, m); + d = rb_reg_nth_match(2, m); + + b = rb_reg_nth_match(3, m); + y = rb_reg_nth_match(4, m); + + mon = INT2FIX(mon_num(mon)); + + s3e(hash, y, mon, d, !NIL_P(b) && + (*RSTRING_PTR(b) == 'B' || + *RSTRING_PTR(b) == 'b')); +#else + VALUE y, mon, d; + + mon = rb_reg_nth_match(1, m); + d = rb_reg_nth_match(2, m); + y = rb_reg_nth_match(3, m); + + if (!check_apost(mon, d, y)) + return 0; + + mon = INT2FIX(mon_num(mon)); + + s3e(hash, y, mon, d, 0); +#endif + return 1; +} + +static int +parse_us(VALUE str, VALUE hash) +{ + static const char pat_source[] = +#ifdef TIGHT_PARSER + BOS + FPW_COM FPT_COM +#endif +#ifndef TIGHT_PARSER + "\\b(" ABBR_MONTHS ")[^-\\d\\s']*" +#else + "\\b(" VALID_MONTHS ")" +#endif + "\\s*" +#ifndef TIGHT_PARSER + "('?\\d+)[^-\\d\\s']*" +#else + "('?\\d+)(?:(?:st|nd|rd|th)\\b)?" + COM_FPT +#endif + "(?:" + "\\s*,?" + "\\s*" +#ifndef TIGHT_PARSER + "(c(?:e|\\.e\\.)|b(?:ce|\\.c\\.e\\.)|a(?:d|\\.d\\.)|b(?:c|\\.c\\.))?" + "\\s*" + "('?-?\\d+)" +#else + "(?:" FPA ")?" + "\\s*" + "([-']?\\d+)" + "\\s*" + "(?:" FPA "|" FPB ")?" +#endif + ")?" +#ifdef TIGHT_PARSER + COM_FPT COM_FPW + EOS +#endif + ; + static VALUE pat = Qnil; + + REGCOMP_I(pat); + SUBS(str, pat, parse_us_cb); +} + +static int +parse_iso_cb(VALUE m, VALUE hash) +{ + VALUE y, mon, d; + + y = rb_reg_nth_match(1, m); + mon = rb_reg_nth_match(2, m); + d = rb_reg_nth_match(3, m); + +#ifdef TIGHT_PARSER + if (!check_apost(y, mon, d)) + return 0; +#endif + + s3e(hash, y, mon, d, 0); + return 1; +} + +static int +parse_iso(VALUE str, VALUE hash) +{ + static const char pat_source[] = +#ifndef TIGHT_PARSER + "('?[-+]?\\d+)-(\\d+)-('?-?\\d+)" +#else + BOS + FPW_COM FPT_COM + "([-+']?\\d+)-(\\d+)-([-']?\\d+)" + TEE_FPT COM_FPW + EOS +#endif + ; + static VALUE pat = Qnil; + + REGCOMP_0(pat); + SUBS(str, pat, parse_iso_cb); +} + +static int +parse_iso21_cb(VALUE m, VALUE hash) +{ + VALUE y, w, d; + + y = rb_reg_nth_match(1, m); + w = rb_reg_nth_match(2, m); + d = rb_reg_nth_match(3, m); + + if (!NIL_P(y)) + set_hash("cwyear", str2num(y)); + set_hash("cweek", str2num(w)); + if (!NIL_P(d)) + set_hash("cwday", str2num(d)); + + return 1; +} + +static int +parse_iso21(VALUE str, VALUE hash) +{ + static const char pat_source[] = +#ifndef TIGHT_PARSER + "\\b(\\d{2}|\\d{4})?-?w(\\d{2})(?:-?(\\d))?\\b" +#else + BOS + FPW_COM FPT_COM + "(\\d{2}|\\d{4})?-?w(\\d{2})(?:-?(\\d))?" + TEE_FPT COM_FPW + EOS +#endif + ; + static VALUE pat = Qnil; + + REGCOMP_I(pat); + SUBS(str, pat, parse_iso21_cb); +} + +static int +parse_iso22_cb(VALUE m, VALUE hash) +{ + VALUE d; + + d = rb_reg_nth_match(1, m); + set_hash("cwday", str2num(d)); + return 1; +} + +static int +parse_iso22(VALUE str, VALUE hash) +{ + static const char pat_source[] = +#ifndef TIGHT_PARSER + "-w-(\\d)\\b" +#else + BOS + FPW_COM FPT_COM + "-w-(\\d)" + TEE_FPT COM_FPW + EOS +#endif + ; + static VALUE pat = Qnil; + + REGCOMP_I(pat); + SUBS(str, pat, parse_iso22_cb); +} + +static int +parse_iso23_cb(VALUE m, VALUE hash) +{ + VALUE mon, d; + + mon = rb_reg_nth_match(1, m); + d = rb_reg_nth_match(2, m); + + if (!NIL_P(mon)) + set_hash("mon", str2num(mon)); + set_hash("mday", str2num(d)); + + return 1; +} + +static int +parse_iso23(VALUE str, VALUE hash) +{ + static const char pat_source[] = +#ifndef TIGHT_PARSER + "--(\\d{2})?-(\\d{2})\\b" +#else + BOS + FPW_COM FPT_COM + "--(\\d{2})?-(\\d{2})" + TEE_FPT COM_FPW + EOS +#endif + ; + static VALUE pat = Qnil; + + REGCOMP_0(pat); + SUBS(str, pat, parse_iso23_cb); +} + +static int +parse_iso24_cb(VALUE m, VALUE hash) +{ + VALUE mon, d; + + mon = rb_reg_nth_match(1, m); + d = rb_reg_nth_match(2, m); + + set_hash("mon", str2num(mon)); + if (!NIL_P(d)) + set_hash("mday", str2num(d)); + + return 1; +} + +static int +parse_iso24(VALUE str, VALUE hash) +{ + static const char pat_source[] = +#ifndef TIGHT_PARSER + "--(\\d{2})(\\d{2})?\\b" +#else + BOS + FPW_COM FPT_COM + "--(\\d{2})(\\d{2})?" + TEE_FPT COM_FPW + EOS +#endif + ; + static VALUE pat = Qnil; + + REGCOMP_0(pat); + SUBS(str, pat, parse_iso24_cb); +} + +static int +parse_iso25_cb(VALUE m, VALUE hash) +{ + VALUE y, d; + + y = rb_reg_nth_match(1, m); + d = rb_reg_nth_match(2, m); + + set_hash("year", str2num(y)); + set_hash("yday", str2num(d)); + + return 1; +} + +static int +parse_iso25(VALUE str, VALUE hash) +{ + static const char pat0_source[] = +#ifndef TIGHT_PARSER + "[,.](\\d{2}|\\d{4})-\\d{3}\\b" +#else + BOS + FPW_COM FPT_COM + "[,.](\\d{2}|\\d{4})-\\d{3}" + TEE_FPT COM_FPW + EOS +#endif + ; + static VALUE pat0 = Qnil; + static const char pat_source[] = +#ifndef TIGHT_PARSER + "\\b(\\d{2}|\\d{4})-(\\d{3})\\b" +#else + BOS + FPW_COM FPT_COM + "(\\d{2}|\\d{4})-(\\d{3})" + TEE_FPT COM_FPW + EOS +#endif + ; + static VALUE pat = Qnil; + + REGCOMP_0(pat0); + REGCOMP_0(pat); + + if (!NIL_P(f_match(pat0, str))) + return 0; + SUBS(str, pat, parse_iso25_cb); +} + +static int +parse_iso26_cb(VALUE m, VALUE hash) +{ + VALUE d; + + d = rb_reg_nth_match(1, m); + set_hash("yday", str2num(d)); + + return 1; +} +static int +parse_iso26(VALUE str, VALUE hash) +{ + static const char pat0_source[] = +#ifndef TIGHT_PARSER + "\\d-\\d{3}\\b" +#else + BOS + FPW_COM FPT_COM + "\\d-\\d{3}" + TEE_FPT COM_FPW + EOS +#endif + ; + static VALUE pat0 = Qnil; + static const char pat_source[] = +#ifndef TIGHT_PARSER + "\\b-(\\d{3})\\b" +#else + BOS + FPW_COM FPT_COM + "-(\\d{3})" + TEE_FPT COM_FPW + EOS +#endif + ; + static VALUE pat = Qnil; + + REGCOMP_0(pat0); + REGCOMP_0(pat); + + if (!NIL_P(f_match(pat0, str))) + return 0; + SUBS(str, pat, parse_iso26_cb); +} + +static int +parse_iso2(VALUE str, VALUE hash) +{ + if (parse_iso21(str, hash)) + goto ok; + if (parse_iso22(str, hash)) + goto ok; + if (parse_iso23(str, hash)) + goto ok; + if (parse_iso24(str, hash)) + goto ok; + if (parse_iso25(str, hash)) + goto ok; + if (parse_iso26(str, hash)) + goto ok; + return 0; + + ok: + return 1; +} + +static int +gengo(int c) +{ + int e; + + switch (c) { + case 'M': case 'm': e = 1867; break; + case 'T': case 't': e = 1911; break; + case 'S': case 's': e = 1925; break; + case 'H': case 'h': e = 1988; break; + default: e = 0; break; + } + return e; +} + +static int +parse_jis_cb(VALUE m, VALUE hash) +{ + VALUE e, y, mon, d; + int ep; + + e = rb_reg_nth_match(1, m); + y = rb_reg_nth_match(2, m); + mon = rb_reg_nth_match(3, m); + d = rb_reg_nth_match(4, m); + + ep = gengo(*RSTRING_PTR(e)); + + set_hash("year", f_add(str2num(y), INT2FIX(ep))); + set_hash("mon", str2num(mon)); + set_hash("mday", str2num(d)); + + return 1; +} + +static int +parse_jis(VALUE str, VALUE hash) +{ + static const char pat_source[] = +#ifndef TIGHT_PARSER + "\\b([mtsh])(\\d+)\\.(\\d+)\\.(\\d+)" +#else + BOS + FPW_COM FPT_COM + "([mtsh])(\\d+)\\.(\\d+)\\.(\\d+)" + TEE_FPT COM_FPW + EOS +#endif + ; + static VALUE pat = Qnil; + + REGCOMP_I(pat); + SUBS(str, pat, parse_jis_cb); +} + +static int +parse_vms11_cb(VALUE m, VALUE hash) +{ + VALUE y, mon, d; + + d = rb_reg_nth_match(1, m); + mon = rb_reg_nth_match(2, m); + y = rb_reg_nth_match(3, m); + +#ifdef TIGHT_PARSER + if (!check_apost(d, mon, y)) + return 0; +#endif + + mon = INT2FIX(mon_num(mon)); + + s3e(hash, y, mon, d, 0); + return 1; +} + +static int +parse_vms11(VALUE str, VALUE hash) +{ + static const char pat_source[] = +#ifndef TIGHT_PARSER + "('?-?\\d+)-(" ABBR_MONTHS ")[^-/.]*" + "-('?-?\\d+)" +#else + BOS + FPW_COM FPT_COM + "([-']?\\d+)-(" DOTLESS_VALID_MONTHS ")" + "-([-']?\\d+)" + COM_FPT COM_FPW + EOS +#endif + ; + static VALUE pat = Qnil; + + REGCOMP_I(pat); + SUBS(str, pat, parse_vms11_cb); +} + +static int +parse_vms12_cb(VALUE m, VALUE hash) +{ + VALUE y, mon, d; + + mon = rb_reg_nth_match(1, m); + d = rb_reg_nth_match(2, m); + y = rb_reg_nth_match(3, m); + +#ifdef TIGHT_PARSER + if (!check_apost(mon, d, y)) + return 0; +#endif + + mon = INT2FIX(mon_num(mon)); + + s3e(hash, y, mon, d, 0); + return 1; +} + +static int +parse_vms12(VALUE str, VALUE hash) +{ + static const char pat_source[] = +#ifndef TIGHT_PARSER + "\\b(" ABBR_MONTHS ")[^-/.]*" + "-('?-?\\d+)(?:-('?-?\\d+))?" +#else + BOS + FPW_COM FPT_COM + "(" DOTLESS_VALID_MONTHS ")" + "-([-']?\\d+)(?:-([-']?\\d+))?" + COM_FPT COM_FPW + EOS +#endif + ; + static VALUE pat = Qnil; + + REGCOMP_I(pat); + SUBS(str, pat, parse_vms12_cb); +} + +static int +parse_vms(VALUE str, VALUE hash) +{ + if (parse_vms11(str, hash)) + goto ok; + if (parse_vms12(str, hash)) + goto ok; + return 0; + + ok: + return 1; +} + +static int +parse_sla_cb(VALUE m, VALUE hash) +{ + VALUE y, mon, d; + + y = rb_reg_nth_match(1, m); + mon = rb_reg_nth_match(2, m); + d = rb_reg_nth_match(3, m); + +#ifdef TIGHT_PARSER + if (!check_apost(y, mon, d)) + return 0; +#endif + + s3e(hash, y, mon, d, 0); + return 1; +} + +static int +parse_sla(VALUE str, VALUE hash) +{ + static const char pat_source[] = +#ifndef TIGHT_PARSER + "('?-?\\d+)/\\s*('?\\d+)(?:\\D\\s*('?-?\\d+))?" +#else + BOS + FPW_COM FPT_COM + "([-']?\\d+)/\\s*('?\\d+)(?:(?:[-/]|\\s+)\\s*([-']?\\d+))?" + COM_FPT COM_FPW + EOS +#endif + ; + static VALUE pat = Qnil; + + REGCOMP_I(pat); + SUBS(str, pat, parse_sla_cb); +} + +#ifdef TIGHT_PARSER +static int +parse_sla2_cb(VALUE m, VALUE hash) +{ + VALUE y, mon, d; + + d = rb_reg_nth_match(1, m); + mon = rb_reg_nth_match(2, m); + y = rb_reg_nth_match(3, m); + + if (!check_apost(d, mon, y)) + return 0; + + mon = INT2FIX(mon_num(mon)); + + s3e(hash, y, mon, d, 0); + return 1; +} + +static int +parse_sla2(VALUE str, VALUE hash) +{ + static const char pat_source[] = + BOS + FPW_COM FPT_COM + "([-']?\\d+)/\\s*(" DOTLESS_VALID_MONTHS ")(?:(?:[-/]|\\s+)\\s*([-']?\\d+))?" + COM_FPT COM_FPW + EOS + ; + static VALUE pat = Qnil; + + REGCOMP_I(pat); + SUBS(str, pat, parse_sla2_cb); +} + +static int +parse_sla3_cb(VALUE m, VALUE hash) +{ + VALUE y, mon, d; + + mon = rb_reg_nth_match(1, m); + d = rb_reg_nth_match(2, m); + y = rb_reg_nth_match(3, m); + + if (!check_apost(mon, d, y)) + return 0; + + mon = INT2FIX(mon_num(mon)); + + s3e(hash, y, mon, d, 0); + return 1; +} + +static int +parse_sla3(VALUE str, VALUE hash) +{ + static const char pat_source[] = + BOS + FPW_COM FPT_COM + "(" DOTLESS_VALID_MONTHS ")/\\s*([-']?\\d+)(?:(?:[-/]|\\s+)\\s*([-']?\\d+))?" + COM_FPT COM_FPW + EOS + ; + static VALUE pat = Qnil; + + REGCOMP_I(pat); + SUBS(str, pat, parse_sla3_cb); +} +#endif + +static int +parse_dot_cb(VALUE m, VALUE hash) +{ + VALUE y, mon, d; + + y = rb_reg_nth_match(1, m); + mon = rb_reg_nth_match(2, m); + d = rb_reg_nth_match(3, m); + +#ifdef TIGHT_PARSER + if (!check_apost(y, mon, d)) + return 0; +#endif + + s3e(hash, y, mon, d, 0); + return 1; +} + +static int +parse_dot(VALUE str, VALUE hash) +{ + static const char pat_source[] = +#ifndef TIGHT_PARSER + "('?-?\\d+)\\.\\s*('?\\d+)\\.\\s*('?-?\\d+)" +#else + BOS + FPW_COM FPT_COM + "([-']?\\d+)\\.\\s*(\\d+)\\.\\s*([-']?\\d+)" + COM_FPT COM_FPW + EOS +#endif + ; + static VALUE pat = Qnil; + + REGCOMP_I(pat); + SUBS(str, pat, parse_dot_cb); +} + +#ifdef TIGHT_PARSER +static int +parse_dot2_cb(VALUE m, VALUE hash) +{ + VALUE y, mon, d; + + d = rb_reg_nth_match(1, m); + mon = rb_reg_nth_match(2, m); + y = rb_reg_nth_match(3, m); + + if (!check_apost(d, mon, y)) + return 0; + + mon = INT2FIX(mon_num(mon)); + + s3e(hash, y, mon, d, 0); + return 1; +} + +static int +parse_dot2(VALUE str, VALUE hash) +{ + static const char pat_source[] = + BOS + FPW_COM FPT_COM + "([-']?\\d+)\\.\\s*(" DOTLESS_VALID_MONTHS ")(?:(?:[./])\\s*([-']?\\d+))?" + COM_FPT COM_FPW + EOS + ; + static VALUE pat = Qnil; + + REGCOMP_I(pat); + SUBS(str, pat, parse_dot2_cb); +} + +static int +parse_dot3_cb(VALUE m, VALUE hash) +{ + VALUE y, mon, d; + + mon = rb_reg_nth_match(1, m); + d = rb_reg_nth_match(2, m); + y = rb_reg_nth_match(3, m); + + if (!check_apost(mon, d, y)) + return 0; + + mon = INT2FIX(mon_num(mon)); + + s3e(hash, y, mon, d, 0); + return 1; +} + +static int +parse_dot3(VALUE str, VALUE hash) +{ + static const char pat_source[] = + BOS + FPW_COM FPT_COM + "(" DOTLESS_VALID_MONTHS ")\\.\\s*([-']?\\d+)(?:(?:[./])\\s*([-']?\\d+))?" + COM_FPT COM_FPW + EOS + ; + static VALUE pat = Qnil; + + REGCOMP_I(pat); + SUBS(str, pat, parse_dot3_cb); +} +#endif + +static int +parse_year_cb(VALUE m, VALUE hash) +{ + VALUE y; + + y = rb_reg_nth_match(1, m); + set_hash("year", str2num(y)); + return 1; +} + +static int +parse_year(VALUE str, VALUE hash) +{ + static const char pat_source[] = +#ifndef TIGHT_PARSER + "'(\\d+)\\b" +#else + BOS + FPW_COM FPT_COM + "'(\\d+)" + COM_FPT COM_FPW + EOS +#endif + ; + static VALUE pat = Qnil; + + REGCOMP_0(pat); + SUBS(str, pat, parse_year_cb); +} + +static int +parse_mon_cb(VALUE m, VALUE hash) +{ + VALUE mon; + + mon = rb_reg_nth_match(1, m); + set_hash("mon", INT2FIX(mon_num(mon))); + return 1; +} + +static int +parse_mon(VALUE str, VALUE hash) +{ + static const char pat_source[] = +#ifndef TIGHT_PARSER + "\\b(" ABBR_MONTHS ")\\S*" +#else + BOS + FPW_COM FPT_COM + "(" VALID_MONTHS ")" + COM_FPT COM_FPW + EOS +#endif + ; + static VALUE pat = Qnil; + + REGCOMP_I(pat); + SUBS(str, pat, parse_mon_cb); +} + +static int +parse_mday_cb(VALUE m, VALUE hash) +{ + VALUE d; + + d = rb_reg_nth_match(1, m); + set_hash("mday", str2num(d)); + return 1; +} + +static int +parse_mday(VALUE str, VALUE hash) +{ + static const char pat_source[] = +#ifndef TIGHT_PARSER + "(\\d+)(st|nd|rd|th)\\b" +#else + BOS + FPW_COM FPT_COM + "(\\d+)(st|nd|rd|th)" + COM_FPT COM_FPW + EOS +#endif + ; + static VALUE pat = Qnil; + + REGCOMP_I(pat); + SUBS(str, pat, parse_mday_cb); +} + +static int +n2i(const char *s, long f, long w) +{ + long e, i; + int v; + + e = f + w; + v = 0; + for (i = f; i < e; i++) { + v *= 10; + v += s[i] - '0'; + } + return v; +} + +static int +parse_ddd_cb(VALUE m, VALUE hash) +{ + VALUE s1, s2, s3, s4, s5; + const char *cs2, *cs3, *cs5; + long l2, l3, l4, l5; + + s1 = rb_reg_nth_match(1, m); + s2 = rb_reg_nth_match(2, m); + s3 = rb_reg_nth_match(3, m); + s4 = rb_reg_nth_match(4, m); + s5 = rb_reg_nth_match(5, m); + + cs2 = RSTRING_PTR(s2); + l2 = RSTRING_LEN(s2); + + switch (l2) { + case 2: + if (NIL_P(s3) && !NIL_P(s4)) + set_hash("sec", INT2FIX(n2i(cs2, l2-2, 2))); + else + set_hash("mday", INT2FIX(n2i(cs2, 0, 2))); + break; + case 4: + if (NIL_P(s3) && !NIL_P(s4)) { + set_hash("sec", INT2FIX(n2i(cs2, l2-2, 2))); + set_hash("min", INT2FIX(n2i(cs2, l2-4, 2))); + } + else { + set_hash("mon", INT2FIX(n2i(cs2, 0, 2))); + set_hash("mday", INT2FIX(n2i(cs2, 2, 2))); + } + break; + case 6: + if (NIL_P(s3) && !NIL_P(s4)) { + set_hash("sec", INT2FIX(n2i(cs2, l2-2, 2))); + set_hash("min", INT2FIX(n2i(cs2, l2-4, 2))); + set_hash("hour", INT2FIX(n2i(cs2, l2-6, 2))); + } + else { + int y = n2i(cs2, 0, 2); + if (!NIL_P(s1) && *RSTRING_PTR(s1) == '-') + y = -y; + set_hash("year", INT2FIX(y)); + set_hash("mon", INT2FIX(n2i(cs2, 2, 2))); + set_hash("mday", INT2FIX(n2i(cs2, 4, 2))); + } + break; + case 8: + case 10: + case 12: + case 14: + if (NIL_P(s3) && !NIL_P(s4)) { + set_hash("sec", INT2FIX(n2i(cs2, l2-2, 2))); + set_hash("min", INT2FIX(n2i(cs2, l2-4, 2))); + set_hash("hour", INT2FIX(n2i(cs2, l2-6, 2))); + set_hash("mday", INT2FIX(n2i(cs2, l2-8, 2))); + if (l2 >= 10) + set_hash("mon", INT2FIX(n2i(cs2, l2-10, 2))); + if (l2 == 12) { + int y = n2i(cs2, l2-12, 2); + if (!NIL_P(s1) && *RSTRING_PTR(s1) == '-') + y = -y; + set_hash("year", INT2FIX(y)); + } + if (l2 == 14) { + int y = n2i(cs2, l2-14, 4); + if (!NIL_P(s1) && *RSTRING_PTR(s1) == '-') + y = -y; + set_hash("year", INT2FIX(y)); + set_hash("_comp", Qfalse); + } + } + else { + int y = n2i(cs2, 0, 4); + if (!NIL_P(s1) && *RSTRING_PTR(s1) == '-') + y = -y; + set_hash("year", INT2FIX(y)); + set_hash("mon", INT2FIX(n2i(cs2, 4, 2))); + set_hash("mday", INT2FIX(n2i(cs2, 6, 2))); + if (l2 >= 10) + set_hash("hour", INT2FIX(n2i(cs2, 8, 2))); + if (l2 >= 12) + set_hash("min", INT2FIX(n2i(cs2, 10, 2))); + if (l2 >= 14) + set_hash("sec", INT2FIX(n2i(cs2, 12, 2))); + set_hash("_comp", Qfalse); + } + break; + case 3: + if (NIL_P(s3) && !NIL_P(s4)) { + set_hash("sec", INT2FIX(n2i(cs2, l2-2, 2))); + set_hash("min", INT2FIX(n2i(cs2, l2-3, 1))); + } + else + set_hash("yday", INT2FIX(n2i(cs2, 0, 3))); + break; + case 5: + if (NIL_P(s3) && !NIL_P(s4)) { + set_hash("sec", INT2FIX(n2i(cs2, l2-2, 2))); + set_hash("min", INT2FIX(n2i(cs2, l2-4, 2))); + set_hash("hour", INT2FIX(n2i(cs2, l2-5, 1))); + } + else { + int y = n2i(cs2, 0, 2); + if (!NIL_P(s1) && *RSTRING_PTR(s1) == '-') + y = -y; + set_hash("year", INT2FIX(y)); + set_hash("yday", INT2FIX(n2i(cs2, 2, 3))); + } + break; + case 7: + if (NIL_P(s3) && !NIL_P(s4)) { + set_hash("sec", INT2FIX(n2i(cs2, l2-2, 2))); + set_hash("min", INT2FIX(n2i(cs2, l2-4, 2))); + set_hash("hour", INT2FIX(n2i(cs2, l2-6, 2))); + set_hash("mday", INT2FIX(n2i(cs2, l2-7, 1))); + } + else { + int y = n2i(cs2, 0, 4); + if (!NIL_P(s1) && *RSTRING_PTR(s1) == '-') + y = -y; + set_hash("year", INT2FIX(y)); + set_hash("yday", INT2FIX(n2i(cs2, 4, 3))); + } + break; + } + RB_GC_GUARD(s2); + if (!NIL_P(s3)) { + cs3 = RSTRING_PTR(s3); + l3 = RSTRING_LEN(s3); + + if (!NIL_P(s4)) { + switch (l3) { + case 2: + case 4: + case 6: + set_hash("sec", INT2FIX(n2i(cs3, l3-2, 2))); + if (l3 >= 4) + set_hash("min", INT2FIX(n2i(cs3, l3-4, 2))); + if (l3 >= 6) + set_hash("hour", INT2FIX(n2i(cs3, l3-6, 2))); + break; + } + } + else { + switch (l3) { + case 2: + case 4: + case 6: + set_hash("hour", INT2FIX(n2i(cs3, 0, 2))); + if (l3 >= 4) + set_hash("min", INT2FIX(n2i(cs3, 2, 2))); + if (l3 >= 6) + set_hash("sec", INT2FIX(n2i(cs3, 4, 2))); + break; + } + } + RB_GC_GUARD(s3); + } + if (!NIL_P(s4)) { + l4 = RSTRING_LEN(s4); + + set_hash("sec_fraction", + rb_rational_new2(str2num(s4), + f_expt(INT2FIX(10), LONG2NUM(l4)))); + } + if (!NIL_P(s5)) { + cs5 = RSTRING_PTR(s5); + l5 = RSTRING_LEN(s5); + + set_hash("zone", s5); + + if (*cs5 == '[') { + char *buf = ALLOCA_N(char, l5 + 1); + char *s1, *s2, *s3; + VALUE zone; + + memcpy(buf, cs5, l5); + buf[l5 - 1] = '\0'; + + s1 = buf + 1; + s2 = strchr(buf, ':'); + if (s2) { + *s2 = '\0'; + s2++; + } + if (s2) + s3 = s2; + else + s3 = s1; + zone = rb_str_new2(s3); + set_hash("zone", zone); + if (isdigit((unsigned char)*s1)) + *--s1 = '+'; + set_hash("offset", date_zone_to_diff(rb_str_new2(s1))); + } + RB_GC_GUARD(s5); + } + + return 1; +} + +static int +parse_ddd(VALUE str, VALUE hash) +{ + static const char pat_source[] = +#ifdef TIGHT_PARSER + BOS +#endif + "([-+]?)(\\d{2,14})" + "(?:" + "\\s*" + "t?" + "\\s*" + "(\\d{2,6})?(?:[,.](\\d*))?" + ")?" + "(?:" + "\\s*" + "(" + "z\\b" + "|" + "[-+]\\d{1,4}\\b" + "|" + "\\[[-+]?\\d[^\\]]*\\]" + ")" + ")?" +#ifdef TIGHT_PARSER + EOS +#endif + ; + static VALUE pat = Qnil; + + REGCOMP_I(pat); + SUBS(str, pat, parse_ddd_cb); +} + +#ifndef TIGHT_PARSER +static int +parse_bc_cb(VALUE m, VALUE hash) +{ + set_hash("_bc", Qtrue); + return 1; +} + +static int +parse_bc(VALUE str, VALUE hash) +{ + static const char pat_source[] = + "\\b(bc\\b|bce\\b|b\\.c\\.|b\\.c\\.e\\.)"; + static VALUE pat = Qnil; + + REGCOMP_I(pat); + SUBS(str, pat, parse_bc_cb); +} + +static int +parse_frag_cb(VALUE m, VALUE hash) +{ + VALUE s, n; + + s = rb_reg_nth_match(1, m); + + if (!NIL_P(ref_hash("hour")) && NIL_P(ref_hash("mday"))) { + n = str2num(s); + if (f_ge_p(n, INT2FIX(1)) && + f_le_p(n, INT2FIX(31))) + set_hash("mday", n); + } + if (!NIL_P(ref_hash("mday")) && NIL_P(ref_hash("hour"))) { + n = str2num(s); + if (f_ge_p(n, INT2FIX(0)) && + f_le_p(n, INT2FIX(24))) + set_hash("hour", n); + } + + return 1; +} + +static int +parse_frag(VALUE str, VALUE hash) +{ + static const char pat_source[] = "\\A\\s*(\\d{1,2})\\s*\\z"; + static VALUE pat = Qnil; + + REGCOMP_I(pat); + SUBS(str, pat, parse_frag_cb); +} +#endif + +#ifdef TIGHT_PARSER +static int +parse_dummy_cb(VALUE m, VALUE hash) +{ + return 1; +} + +static int +parse_wday_only(VALUE str, VALUE hash) +{ + static const char pat_source[] = "\\A\\s*" FPW "\\s*\\z"; + static VALUE pat = Qnil; + + REGCOMP_0(pat); + SUBS(str, pat, parse_dummy_cb); +} + +static int +parse_time_only(VALUE str, VALUE hash) +{ + static const char pat_source[] = "\\A\\s*" FPT "\\s*\\z"; + static VALUE pat = Qnil; + + REGCOMP_0(pat); + SUBS(str, pat, parse_dummy_cb); +} + +static int +parse_wday_and_time(VALUE str, VALUE hash) +{ + static const char pat_source[] = "\\A\\s*(" FPW "\\s+" FPT "|" FPT "\\s+" FPW ")\\s*\\z"; + static VALUE pat = Qnil; + + REGCOMP_0(pat); + SUBS(str, pat, parse_dummy_cb); +} + +static unsigned +have_invalid_char_p(VALUE s) +{ + long i; + + for (i = 0; i < RSTRING_LEN(s); i++) + if (iscntrl((unsigned char)RSTRING_PTR(s)[i]) && + !isspace((unsigned char)RSTRING_PTR(s)[i])) + return 1; + return 0; +} +#endif + +#define HAVE_ALPHA (1<<0) +#define HAVE_DIGIT (1<<1) +#define HAVE_DASH (1<<2) +#define HAVE_DOT (1<<3) +#define HAVE_SLASH (1<<4) + +static unsigned +check_class(VALUE s) +{ + unsigned flags; + long i; + + flags = 0; + for (i = 0; i < RSTRING_LEN(s); i++) { + if (isalpha((unsigned char)RSTRING_PTR(s)[i])) + flags |= HAVE_ALPHA; + if (isdigit((unsigned char)RSTRING_PTR(s)[i])) + flags |= HAVE_DIGIT; + if (RSTRING_PTR(s)[i] == '-') + flags |= HAVE_DASH; + if (RSTRING_PTR(s)[i] == '.') + flags |= HAVE_DOT; + if (RSTRING_PTR(s)[i] == '/') + flags |= HAVE_SLASH; + } + return flags; +} + +#define HAVE_ELEM_P(x) ((check_class(str) & (x)) == (x)) + +#ifdef TIGHT_PARSER +#define PARSER_ERROR return rb_hash_new() +#endif + +VALUE +date__parse(VALUE str, VALUE comp) +{ + VALUE backref, hash; + +#ifdef TIGHT_PARSER + if (have_invalid_char_p(str)) + PARSER_ERROR; +#endif + + backref = rb_backref_get(); + rb_match_busy(backref); + + { + static const char pat_source[] = +#ifndef TIGHT_PARSER + "[^-+',./:@[:alnum:]\\[\\]]+" +#else + "[^[:graph:]]+" +#endif + ; + static VALUE pat = Qnil; + + REGCOMP_0(pat); + str = rb_str_dup(str); + f_gsub_bang(str, pat, asp_string()); + } + + hash = rb_hash_new(); + set_hash("_comp", comp); + + if (HAVE_ELEM_P(HAVE_ALPHA)) + parse_day(str, hash); + if (HAVE_ELEM_P(HAVE_DIGIT)) + parse_time(str, hash); + +#ifdef TIGHT_PARSER + if (HAVE_ELEM_P(HAVE_ALPHA)) + parse_era(str, hash); +#endif + + if (HAVE_ELEM_P(HAVE_ALPHA|HAVE_DIGIT)) { + if (parse_eu(str, hash)) + goto ok; + if (parse_us(str, hash)) + goto ok; + } + if (HAVE_ELEM_P(HAVE_DIGIT|HAVE_DASH)) + if (parse_iso(str, hash)) + goto ok; + if (HAVE_ELEM_P(HAVE_DIGIT|HAVE_DOT)) + if (parse_jis(str, hash)) + goto ok; + if (HAVE_ELEM_P(HAVE_ALPHA|HAVE_DIGIT|HAVE_DASH)) + if (parse_vms(str, hash)) + goto ok; + if (HAVE_ELEM_P(HAVE_DIGIT|HAVE_SLASH)) + if (parse_sla(str, hash)) + goto ok; +#ifdef TIGHT_PARSER + if (HAVE_ELEM_P(HAVE_ALPHA|HAVE_DIGIT|HAVE_SLASH)) { + if (parse_sla2(str, hash)) + goto ok; + if (parse_sla3(str, hash)) + goto ok; + } +#endif + if (HAVE_ELEM_P(HAVE_DIGIT|HAVE_DOT)) + if (parse_dot(str, hash)) + goto ok; +#ifdef TIGHT_PARSER + if (HAVE_ELEM_P(HAVE_ALPHA|HAVE_DIGIT|HAVE_DOT)) { + if (parse_dot2(str, hash)) + goto ok; + if (parse_dot3(str, hash)) + goto ok; + } +#endif + if (HAVE_ELEM_P(HAVE_DIGIT)) + if (parse_iso2(str, hash)) + goto ok; + if (HAVE_ELEM_P(HAVE_DIGIT)) + if (parse_year(str, hash)) + goto ok; + if (HAVE_ELEM_P(HAVE_ALPHA)) + if (parse_mon(str, hash)) + goto ok; + if (HAVE_ELEM_P(HAVE_DIGIT)) + if (parse_mday(str, hash)) + goto ok; + if (HAVE_ELEM_P(HAVE_DIGIT)) + if (parse_ddd(str, hash)) + goto ok; + +#ifdef TIGHT_PARSER + if (parse_wday_only(str, hash)) + goto ok; + if (parse_time_only(str, hash)) + goto ok; + if (parse_wday_and_time(str, hash)) + goto ok; + + PARSER_ERROR; /* not found */ +#endif + + ok: +#ifndef TIGHT_PARSER + if (HAVE_ELEM_P(HAVE_ALPHA)) + parse_bc(str, hash); + if (HAVE_ELEM_P(HAVE_DIGIT)) + parse_frag(str, hash); +#endif + + { + if (RTEST(ref_hash("_bc"))) { + VALUE y; + + y = ref_hash("cwyear"); + if (!NIL_P(y)) { + y = f_add(f_negate(y), INT2FIX(1)); + set_hash("cwyear", y); + } + y = ref_hash("year"); + if (!NIL_P(y)) { + y = f_add(f_negate(y), INT2FIX(1)); + set_hash("year", y); + } + } + + if (RTEST(ref_hash("_comp"))) { + VALUE y; + + y = ref_hash("cwyear"); + if (!NIL_P(y)) + if (f_ge_p(y, INT2FIX(0)) && f_le_p(y, INT2FIX(99))) { + if (f_ge_p(y, INT2FIX(69))) + set_hash("cwyear", f_add(y, INT2FIX(1900))); + else + set_hash("cwyear", f_add(y, INT2FIX(2000))); + } + y = ref_hash("year"); + if (!NIL_P(y)) + if (f_ge_p(y, INT2FIX(0)) && f_le_p(y, INT2FIX(99))) { + if (f_ge_p(y, INT2FIX(69))) + set_hash("year", f_add(y, INT2FIX(1900))); + else + set_hash("year", f_add(y, INT2FIX(2000))); + } + } + + } + + del_hash("_bc"); + del_hash("_comp"); + + { + VALUE zone = ref_hash("zone"); + if (!NIL_P(zone) && NIL_P(ref_hash("offset"))) + set_hash("offset", date_zone_to_diff(zone)); + } + + rb_backref_set(backref); + + return hash; +} + +static VALUE +comp_year69(VALUE y) +{ + if (f_ge_p(y, INT2FIX(69))) + return f_add(y, INT2FIX(1900)); + return f_add(y, INT2FIX(2000)); +} + +static VALUE +comp_year50(VALUE y) +{ + if (f_ge_p(y, INT2FIX(50))) + return f_add(y, INT2FIX(1900)); + return f_add(y, INT2FIX(2000)); +} + +static VALUE +sec_fraction(VALUE f) +{ + return rb_rational_new2(str2num(f), + f_expt(INT2FIX(10), + LONG2NUM(RSTRING_LEN(f)))); +} + +#define SNUM 14 + +static int +iso8601_ext_datetime_cb(VALUE m, VALUE hash) +{ + VALUE s[SNUM + 1], y; + + { + int i; + s[0] = Qnil; + for (i = 1; i <= SNUM; i++) + s[i] = rb_reg_nth_match(i, m); + } + + if (!NIL_P(s[3])) { + set_hash("mday", str2num(s[3])); + if (strcmp(RSTRING_PTR(s[1]), "-") != 0) { + y = str2num(s[1]); + if (RSTRING_LEN(s[1]) < 4) + y = comp_year69(y); + set_hash("year", y); + } + if (NIL_P(s[2])) { + if (strcmp(RSTRING_PTR(s[1]), "-") != 0) + return 0; + } + else + set_hash("mon", str2num(s[2])); + } + else if (!NIL_P(s[5])) { + set_hash("yday", str2num(s[5])); + if (!NIL_P(s[4])) { + y = str2num(s[4]); + if (RSTRING_LEN(s[4]) < 4) + y = comp_year69(y); + set_hash("year", y); + } + } + else if (!NIL_P(s[8])) { + set_hash("cweek", str2num(s[7])); + set_hash("cwday", str2num(s[8])); + if (!NIL_P(s[6])) { + y = str2num(s[6]); + if (RSTRING_LEN(s[6]) < 4) + y = comp_year69(y); + set_hash("cwyear", y); + } + } + else if (!NIL_P(s[9])) { + set_hash("cwday", str2num(s[9])); + } + if (!NIL_P(s[10])) { + set_hash("hour", str2num(s[10])); + set_hash("min", str2num(s[11])); + if (!NIL_P(s[12])) + set_hash("sec", str2num(s[12])); + } + if (!NIL_P(s[13])) { + set_hash("sec_fraction", sec_fraction(s[13])); + } + if (!NIL_P(s[14])) { + set_hash("zone", s[14]); + set_hash("offset", date_zone_to_diff(s[14])); + } + + return 1; +} + +static int +iso8601_ext_datetime(VALUE str, VALUE hash) +{ + static const char pat_source[] = + "\\A\\s*(?:([-+]?\\d{2,}|-)-(\\d{2})?-(\\d{2})|" + "([-+]?\\d{2,})?-(\\d{3})|" + "(\\d{4}|\\d{2})?-w(\\d{2})-(\\d)|" + "-w-(\\d))" + "(?:t" + "(\\d{2}):(\\d{2})(?::(\\d{2})(?:[,.](\\d+))?)?" + "(z|[-+]\\d{2}(?::?\\d{2})?)?)?\\s*\\z"; + static VALUE pat = Qnil; + + REGCOMP_I(pat); + MATCH(str, pat, iso8601_ext_datetime_cb); +} + +#undef SNUM +#define SNUM 17 + +static int +iso8601_bas_datetime_cb(VALUE m, VALUE hash) +{ + VALUE s[SNUM + 1], y; + + { + int i; + s[0] = Qnil; + for (i = 1; i <= SNUM; i++) + s[i] = rb_reg_nth_match(i, m); + } + + if (!NIL_P(s[3])) { + set_hash("mday", str2num(s[3])); + if (strcmp(RSTRING_PTR(s[1]), "--") != 0) { + y = str2num(s[1]); + if (RSTRING_LEN(s[1]) < 4) + y = comp_year69(y); + set_hash("year", y); + } + if (*RSTRING_PTR(s[2]) == '-') { + if (strcmp(RSTRING_PTR(s[1]), "--") != 0) + return 0; + } + else + set_hash("mon", str2num(s[2])); + } + else if (!NIL_P(s[5])) { + set_hash("yday", str2num(s[5])); + y = str2num(s[4]); + if (RSTRING_LEN(s[4]) < 4) + y = comp_year69(y); + set_hash("year", y); + } + else if (!NIL_P(s[6])) { + set_hash("yday", str2num(s[6])); + } + else if (!NIL_P(s[9])) { + set_hash("cweek", str2num(s[8])); + set_hash("cwday", str2num(s[9])); + y = str2num(s[7]); + if (RSTRING_LEN(s[7]) < 4) + y = comp_year69(y); + set_hash("cwyear", y); + } + else if (!NIL_P(s[11])) { + set_hash("cweek", str2num(s[10])); + set_hash("cwday", str2num(s[11])); + } + else if (!NIL_P(s[12])) { + set_hash("cwday", str2num(s[12])); + } + if (!NIL_P(s[13])) { + set_hash("hour", str2num(s[13])); + set_hash("min", str2num(s[14])); + if (!NIL_P(s[15])) + set_hash("sec", str2num(s[15])); + } + if (!NIL_P(s[16])) { + set_hash("sec_fraction", sec_fraction(s[16])); + } + if (!NIL_P(s[17])) { + set_hash("zone", s[17]); + set_hash("offset", date_zone_to_diff(s[17])); + } + + return 1; +} + +static int +iso8601_bas_datetime(VALUE str, VALUE hash) +{ + static const char pat_source[] = + "\\A\\s*(?:([-+]?(?:\\d{4}|\\d{2})|--)(\\d{2}|-)(\\d{2})|" + "([-+]?(?:\\d{4}|\\d{2}))(\\d{3})|" + "-(\\d{3})|" + "(\\d{4}|\\d{2})w(\\d{2})(\\d)|" + "-w(\\d{2})(\\d)|" + "-w-(\\d))" + "(?:t?" + "(\\d{2})(\\d{2})(?:(\\d{2})(?:[,.](\\d+))?)?" + "(z|[-+]\\d{2}(?:\\d{2})?)?)?\\s*\\z"; + static VALUE pat = Qnil; + + REGCOMP_I(pat); + MATCH(str, pat, iso8601_bas_datetime_cb); +} + +#undef SNUM +#define SNUM 5 + +static int +iso8601_ext_time_cb(VALUE m, VALUE hash) +{ + VALUE s[SNUM + 1]; + + { + int i; + s[0] = Qnil; + for (i = 1; i <= SNUM; i++) + s[i] = rb_reg_nth_match(i, m); + } + + set_hash("hour", str2num(s[1])); + set_hash("min", str2num(s[2])); + if (!NIL_P(s[3])) + set_hash("sec", str2num(s[3])); + if (!NIL_P(s[4])) + set_hash("sec_fraction", sec_fraction(s[4])); + if (!NIL_P(s[5])) { + set_hash("zone", s[5]); + set_hash("offset", date_zone_to_diff(s[5])); + } + + return 1; +} + +#define iso8601_bas_time_cb iso8601_ext_time_cb + +static int +iso8601_ext_time(VALUE str, VALUE hash) +{ + static const char pat_source[] = + "\\A\\s*(\\d{2}):(\\d{2})(?::(\\d{2})(?:[,.](\\d+))?" + "(z|[-+]\\d{2}(:?\\d{2})?)?)?\\s*\\z"; + static VALUE pat = Qnil; + + REGCOMP_I(pat); + MATCH(str, pat, iso8601_ext_time_cb); +} + +static int +iso8601_bas_time(VALUE str, VALUE hash) +{ + static const char pat_source[] = + "\\A\\s*(\\d{2})(\\d{2})(?:(\\d{2})(?:[,.](\\d+))?" + "(z|[-+]\\d{2}(\\d{2})?)?)?\\s*\\z"; + static VALUE pat = Qnil; + + REGCOMP_I(pat); + MATCH(str, pat, iso8601_bas_time_cb); +} + +VALUE +date__iso8601(VALUE str) +{ + VALUE backref, hash; + + backref = rb_backref_get(); + rb_match_busy(backref); + + hash = rb_hash_new(); + + if (iso8601_ext_datetime(str, hash)) + goto ok; + if (iso8601_bas_datetime(str, hash)) + goto ok; + if (iso8601_ext_time(str, hash)) + goto ok; + if (iso8601_bas_time(str, hash)) + goto ok; + + ok: + rb_backref_set(backref); + + return hash; +} + +#undef SNUM +#define SNUM 8 + +static int +rfc3339_cb(VALUE m, VALUE hash) +{ + VALUE s[SNUM + 1]; + + { + int i; + s[0] = Qnil; + for (i = 1; i <= SNUM; i++) + s[i] = rb_reg_nth_match(i, m); + } + + set_hash("year", str2num(s[1])); + set_hash("mon", str2num(s[2])); + set_hash("mday", str2num(s[3])); + set_hash("hour", str2num(s[4])); + set_hash("min", str2num(s[5])); + set_hash("sec", str2num(s[6])); + set_hash("zone", s[8]); + set_hash("offset", date_zone_to_diff(s[8])); + if (!NIL_P(s[7])) + set_hash("sec_fraction", sec_fraction(s[7])); + + return 1; +} + +static int +rfc3339(VALUE str, VALUE hash) +{ + static const char pat_source[] = + "\\A\\s*(-?\\d{4})-(\\d{2})-(\\d{2})" + "(?:t|\\s)" + "(\\d{2}):(\\d{2}):(\\d{2})(?:\\.(\\d+))?" + "(z|[-+]\\d{2}:\\d{2})\\s*\\z"; + static VALUE pat = Qnil; + + REGCOMP_I(pat); + MATCH(str, pat, rfc3339_cb); +} + +VALUE +date__rfc3339(VALUE str) +{ + VALUE backref, hash; + + backref = rb_backref_get(); + rb_match_busy(backref); + + hash = rb_hash_new(); + rfc3339(str, hash); + rb_backref_set(backref); + return hash; +} + +#undef SNUM +#define SNUM 8 + +static int +xmlschema_datetime_cb(VALUE m, VALUE hash) +{ + VALUE s[SNUM + 1]; + + { + int i; + s[0] = Qnil; + for (i = 1; i <= SNUM; i++) + s[i] = rb_reg_nth_match(i, m); + } + + set_hash("year", str2num(s[1])); + if (!NIL_P(s[2])) + set_hash("mon", str2num(s[2])); + if (!NIL_P(s[3])) + set_hash("mday", str2num(s[3])); + if (!NIL_P(s[4])) + set_hash("hour", str2num(s[4])); + if (!NIL_P(s[5])) + set_hash("min", str2num(s[5])); + if (!NIL_P(s[6])) + set_hash("sec", str2num(s[6])); + if (!NIL_P(s[7])) + set_hash("sec_fraction", sec_fraction(s[7])); + if (!NIL_P(s[8])) { + set_hash("zone", s[8]); + set_hash("offset", date_zone_to_diff(s[8])); + } + + return 1; +} + +static int +xmlschema_datetime(VALUE str, VALUE hash) +{ + static const char pat_source[] = + "\\A\\s*(-?\\d{4,})(?:-(\\d{2})(?:-(\\d{2}))?)?" + "(?:t" + "(\\d{2}):(\\d{2}):(\\d{2})(?:\\.(\\d+))?)?" + "(z|[-+]\\d{2}:\\d{2})?\\s*\\z"; + static VALUE pat = Qnil; + + REGCOMP_I(pat); + MATCH(str, pat, xmlschema_datetime_cb); +} + +#undef SNUM +#define SNUM 5 + +static int +xmlschema_time_cb(VALUE m, VALUE hash) +{ + VALUE s[SNUM + 1]; + + { + int i; + s[0] = Qnil; + for (i = 1; i <= SNUM; i++) + s[i] = rb_reg_nth_match(i, m); + } + + set_hash("hour", str2num(s[1])); + set_hash("min", str2num(s[2])); + if (!NIL_P(s[3])) + set_hash("sec", str2num(s[3])); + if (!NIL_P(s[4])) + set_hash("sec_fraction", sec_fraction(s[4])); + if (!NIL_P(s[5])) { + set_hash("zone", s[5]); + set_hash("offset", date_zone_to_diff(s[5])); + } + + return 1; +} + +static int +xmlschema_time(VALUE str, VALUE hash) +{ + static const char pat_source[] = + "\\A\\s*(\\d{2}):(\\d{2}):(\\d{2})(?:\\.(\\d+))?" + "(z|[-+]\\d{2}:\\d{2})?\\s*\\z"; + static VALUE pat = Qnil; + + REGCOMP_I(pat); + MATCH(str, pat, xmlschema_time_cb); +} + +#undef SNUM +#define SNUM 4 + +static int +xmlschema_trunc_cb(VALUE m, VALUE hash) +{ + VALUE s[SNUM + 1]; + + { + int i; + s[0] = Qnil; + for (i = 1; i <= SNUM; i++) + s[i] = rb_reg_nth_match(i, m); + } + + if (!NIL_P(s[1])) + set_hash("mon", str2num(s[1])); + if (!NIL_P(s[2])) + set_hash("mday", str2num(s[2])); + if (!NIL_P(s[3])) + set_hash("mday", str2num(s[3])); + if (!NIL_P(s[4])) { + set_hash("zone", s[4]); + set_hash("offset", date_zone_to_diff(s[4])); + } + + return 1; +} + +static int +xmlschema_trunc(VALUE str, VALUE hash) +{ + static const char pat_source[] = + "\\A\\s*(?:--(\\d{2})(?:-(\\d{2}))?|---(\\d{2}))" + "(z|[-+]\\d{2}:\\d{2})?\\s*\\z"; + static VALUE pat = Qnil; + + REGCOMP_I(pat); + MATCH(str, pat, xmlschema_trunc_cb); +} + +VALUE +date__xmlschema(VALUE str) +{ + VALUE backref, hash; + + backref = rb_backref_get(); + rb_match_busy(backref); + + hash = rb_hash_new(); + + if (xmlschema_datetime(str, hash)) + goto ok; + if (xmlschema_time(str, hash)) + goto ok; + if (xmlschema_trunc(str, hash)) + goto ok; + + ok: + rb_backref_set(backref); + + return hash; +} + +#undef SNUM +#define SNUM 8 + +static int +rfc2822_cb(VALUE m, VALUE hash) +{ + VALUE s[SNUM + 1], y; + + { + int i; + s[0] = Qnil; + for (i = 1; i <= SNUM; i++) + s[i] = rb_reg_nth_match(i, m); + } + + if (!NIL_P(s[1])) { + set_hash("wday", INT2FIX(day_num(s[1]))); + } + set_hash("mday", str2num(s[2])); + set_hash("mon", INT2FIX(mon_num(s[3]))); + y = str2num(s[4]); + if (RSTRING_LEN(s[4]) < 4) + y = comp_year50(y); + set_hash("year", y); + set_hash("hour", str2num(s[5])); + set_hash("min", str2num(s[6])); + if (!NIL_P(s[7])) + set_hash("sec", str2num(s[7])); + set_hash("zone", s[8]); + set_hash("offset", date_zone_to_diff(s[8])); + + return 1; +} + +static int +rfc2822(VALUE str, VALUE hash) +{ + static const char pat_source[] = + "\\A\\s*(?:(" ABBR_DAYS ")\\s*,\\s+)?" + "(\\d{1,2})\\s+" + "(" ABBR_MONTHS ")\\s+" + "(-?\\d{2,})\\s+" + "(\\d{2}):(\\d{2})(?::(\\d{2}))?\\s*" + "([-+]\\d{4}|ut|gmt|e[sd]t|c[sd]t|m[sd]t|p[sd]t|[a-ik-z])\\s*\\z"; + static VALUE pat = Qnil; + + REGCOMP_I(pat); + MATCH(str, pat, rfc2822_cb); +} + +VALUE +date__rfc2822(VALUE str) +{ + VALUE backref, hash; + + backref = rb_backref_get(); + rb_match_busy(backref); + + hash = rb_hash_new(); + rfc2822(str, hash); + rb_backref_set(backref); + return hash; +} + +#undef SNUM +#define SNUM 8 + +static int +httpdate_type1_cb(VALUE m, VALUE hash) +{ + VALUE s[SNUM + 1]; + + { + int i; + s[0] = Qnil; + for (i = 1; i <= SNUM; i++) + s[i] = rb_reg_nth_match(i, m); + } + + set_hash("wday", INT2FIX(day_num(s[1]))); + set_hash("mday", str2num(s[2])); + set_hash("mon", INT2FIX(mon_num(s[3]))); + set_hash("year", str2num(s[4])); + set_hash("hour", str2num(s[5])); + set_hash("min", str2num(s[6])); + set_hash("sec", str2num(s[7])); + set_hash("zone", s[8]); + set_hash("offset", INT2FIX(0)); + + return 1; +} + +static int +httpdate_type1(VALUE str, VALUE hash) +{ + static const char pat_source[] = + "\\A\\s*(" ABBR_DAYS ")\\s*,\\s+" + "(\\d{2})\\s+" + "(" ABBR_MONTHS ")\\s+" + "(-?\\d{4})\\s+" + "(\\d{2}):(\\d{2}):(\\d{2})\\s+" + "(gmt)\\s*\\z"; + static VALUE pat = Qnil; + + REGCOMP_I(pat); + MATCH(str, pat, httpdate_type1_cb); +} + +#undef SNUM +#define SNUM 8 + +static int +httpdate_type2_cb(VALUE m, VALUE hash) +{ + VALUE s[SNUM + 1], y; + + { + int i; + s[0] = Qnil; + for (i = 1; i <= SNUM; i++) + s[i] = rb_reg_nth_match(i, m); + } + + set_hash("wday", INT2FIX(day_num(s[1]))); + set_hash("mday", str2num(s[2])); + set_hash("mon", INT2FIX(mon_num(s[3]))); + y = str2num(s[4]); + if (f_ge_p(y, INT2FIX(0)) && f_le_p(y, INT2FIX(99))) + y = comp_year69(y); + set_hash("year", y); + set_hash("hour", str2num(s[5])); + set_hash("min", str2num(s[6])); + set_hash("sec", str2num(s[7])); + set_hash("zone", s[8]); + set_hash("offset", INT2FIX(0)); + + return 1; +} + +static int +httpdate_type2(VALUE str, VALUE hash) +{ + static const char pat_source[] = + "\\A\\s*(" DAYS ")\\s*,\\s+" + "(\\d{2})\\s*-\\s*" + "(" ABBR_MONTHS ")\\s*-\\s*" + "(\\d{2})\\s+" + "(\\d{2}):(\\d{2}):(\\d{2})\\s+" + "(gmt)\\s*\\z"; + static VALUE pat = Qnil; + + REGCOMP_I(pat); + MATCH(str, pat, httpdate_type2_cb); +} + +#undef SNUM +#define SNUM 7 + +static int +httpdate_type3_cb(VALUE m, VALUE hash) +{ + VALUE s[SNUM + 1]; + + { + int i; + s[0] = Qnil; + for (i = 1; i <= SNUM; i++) + s[i] = rb_reg_nth_match(i, m); + } + + set_hash("wday", INT2FIX(day_num(s[1]))); + set_hash("mon", INT2FIX(mon_num(s[2]))); + set_hash("mday", str2num(s[3])); + set_hash("hour", str2num(s[4])); + set_hash("min", str2num(s[5])); + set_hash("sec", str2num(s[6])); + set_hash("year", str2num(s[7])); + + return 1; +} + +static int +httpdate_type3(VALUE str, VALUE hash) +{ + static const char pat_source[] = + "\\A\\s*(" ABBR_DAYS ")\\s+" + "(" ABBR_MONTHS ")\\s+" + "(\\d{1,2})\\s+" + "(\\d{2}):(\\d{2}):(\\d{2})\\s+" + "(\\d{4})\\s*\\z"; + static VALUE pat = Qnil; + + REGCOMP_I(pat); + MATCH(str, pat, httpdate_type3_cb); +} + +VALUE +date__httpdate(VALUE str) +{ + VALUE backref, hash; + + backref = rb_backref_get(); + rb_match_busy(backref); + + hash = rb_hash_new(); + + if (httpdate_type1(str, hash)) + goto ok; + if (httpdate_type2(str, hash)) + goto ok; + if (httpdate_type3(str, hash)) + goto ok; + + ok: + rb_backref_set(backref); + + return hash; +} + +#undef SNUM +#define SNUM 9 + +static int +jisx0301_cb(VALUE m, VALUE hash) +{ + VALUE s[SNUM + 1]; + int ep; + + { + int i; + s[0] = Qnil; + for (i = 1; i <= SNUM; i++) + s[i] = rb_reg_nth_match(i, m); + } + + ep = gengo(NIL_P(s[1]) ? 'h' : *RSTRING_PTR(s[1])); + set_hash("year", f_add(str2num(s[2]), INT2FIX(ep))); + set_hash("mon", str2num(s[3])); + set_hash("mday", str2num(s[4])); + if (!NIL_P(s[5])) { + set_hash("hour", str2num(s[5])); + if (!NIL_P(s[6])) + set_hash("min", str2num(s[6])); + if (!NIL_P(s[7])) + set_hash("sec", str2num(s[7])); + } + if (!NIL_P(s[8])) + set_hash("sec_fraction", sec_fraction(s[8])); + if (!NIL_P(s[9])) { + set_hash("zone", s[9]); + set_hash("offset", date_zone_to_diff(s[9])); + } + + return 1; +} + +static int +jisx0301(VALUE str, VALUE hash) +{ + static const char pat_source[] = + "\\A\\s*([mtsh])?(\\d{2})\\.(\\d{2})\\.(\\d{2})" + "(?:t" + "(?:(\\d{2}):(\\d{2})(?::(\\d{2})(?:[,.](\\d*))?)?" + "(z|[-+]\\d{2}(?::?\\d{2})?)?)?)?\\s*\\z"; + static VALUE pat = Qnil; + + REGCOMP_I(pat); + MATCH(str, pat, jisx0301_cb); +} + +VALUE +date__jisx0301(VALUE str) +{ + VALUE backref, hash; + + backref = rb_backref_get(); + rb_match_busy(backref); + + hash = rb_hash_new(); + if (jisx0301(str, hash)) + goto ok; + hash = date__iso8601(str); + + ok: + rb_backref_set(backref); + return hash; +} + +/* +Local variables: +c-file-style: "ruby" +End: +*/ diff --git a/jni/ruby/ext/date/date_strftime.c b/jni/ruby/ext/date/date_strftime.c new file mode 100644 index 0000000..20931a3 --- /dev/null +++ b/jni/ruby/ext/date/date_strftime.c @@ -0,0 +1,633 @@ +/* + date_strftime.c: based on a public-domain implementation of ANSI C + library routine strftime, which is originally written by Arnold + Robbins. + */ + +#include "ruby/ruby.h" +#include "date_tmx.h" + +#include +#include +#include +#include + +#if defined(HAVE_SYS_TIME_H) +#include +#endif + +#undef strchr /* avoid AIX weirdness */ + +#define range(low, item, hi) (item) + +#define add(x,y) (rb_funcall((x), '+', 1, (y))) +#define sub(x,y) (rb_funcall((x), '-', 1, (y))) +#define mul(x,y) (rb_funcall((x), '*', 1, (y))) +#define quo(x,y) (rb_funcall((x), rb_intern("quo"), 1, (y))) +#define div(x,y) (rb_funcall((x), rb_intern("div"), 1, (y))) +#define mod(x,y) (rb_funcall((x), '%', 1, (y))) + +static void +upcase(char *s, size_t i) +{ + do { + if (ISLOWER(*s)) + *s = TOUPPER(*s); + } while (s++, --i); +} + +static void +downcase(char *s, size_t i) +{ + do { + if (ISUPPER(*s)) + *s = TOLOWER(*s); + } while (s++, --i); +} + +/* strftime --- produce formatted time */ + +static size_t +date_strftime_with_tmx(char *s, size_t maxsize, const char *format, + const struct tmx *tmx) +{ + char *endp = s + maxsize; + char *start = s; + const char *sp, *tp; + auto char tbuf[100]; + ptrdiff_t i; + int v, w; + size_t colons; + int precision, flags; + char padding; + /* LOCALE_[OE] and COLONS are actually modifiers, not flags */ + enum {LEFT, CHCASE, LOWER, UPPER, LOCALE_O, LOCALE_E, COLONS}; +#define BIT_OF(n) (1U<<(n)) + + /* various tables for locale C */ + static const char days_l[][10] = { + "Sunday", "Monday", "Tuesday", "Wednesday", + "Thursday", "Friday", "Saturday", + }; + static const char months_l[][10] = { + "January", "February", "March", "April", + "May", "June", "July", "August", "September", + "October", "November", "December", + }; + static const char ampm[][3] = { "AM", "PM", }; + + if (s == NULL || format == NULL || tmx == NULL || maxsize == 0) + return 0; + + /* quick check if we even need to bother */ + if (strchr(format, '%') == NULL && strlen(format) + 1 >= maxsize) { + err: + errno = ERANGE; + return 0; + } + + for (; *format && s < endp - 1; format++) { +#define FLAG_FOUND() do { \ + if (precision > 0 || flags & (BIT_OF(LOCALE_E) | BIT_OF(LOCALE_O) | BIT_OF(COLONS))) \ + goto unknown; \ + } while (0) +#define NEEDS(n) do if (s >= endp || (n) >= endp - s - 1) goto err; while (0) +#define FILL_PADDING(i) do { \ + if (!(flags & BIT_OF(LEFT)) && precision > (i)) { \ + NEEDS(precision); \ + memset(s, padding ? padding : ' ', precision - (i)); \ + s += precision - (i); \ + } \ + else { \ + NEEDS(i); \ + } \ + } while (0); +#define FMT(def_pad, def_prec, fmt, val) \ + do { \ + int l; \ + if (precision <= 0) precision = (def_prec); \ + if (flags & BIT_OF(LEFT)) precision = 1; \ + l = snprintf(s, endp - s, \ + ((padding == '0' || (!padding && (def_pad) == '0')) ? \ + "%0*"fmt : "%*"fmt), \ + precision, (val)); \ + if (l < 0) goto err; \ + s += l; \ + } while (0) +#define STRFTIME(fmt) \ + do { \ + i = date_strftime_with_tmx(s, endp - s, (fmt), tmx); \ + if (!i) return 0; \ + if (flags & BIT_OF(UPPER)) \ + upcase(s, i); \ + if (!(flags & BIT_OF(LEFT)) && precision > i) { \ + if (start + maxsize < s + precision) { \ + errno = ERANGE; \ + return 0; \ + } \ + memmove(s + precision - i, s, i); \ + memset(s, padding ? padding : ' ', precision - i); \ + s += precision; \ + } \ + else s += i; \ + } while (0) +#define FMTV(def_pad, def_prec, fmt, val) \ + do { \ + VALUE tmp = (val); \ + if (FIXNUM_P(tmp)) { \ + FMT((def_pad), (def_prec), "l"fmt, FIX2LONG(tmp)); \ + } \ + else { \ + VALUE args[2], result; \ + size_t l; \ + if (precision <= 0) precision = (def_prec); \ + if (flags & BIT_OF(LEFT)) precision = 1; \ + args[0] = INT2FIX(precision); \ + args[1] = (val); \ + if (padding == '0' || (!padding && (def_pad) == '0')) \ + result = rb_str_format(2, args, rb_str_new2("%0*"fmt)); \ + else \ + result = rb_str_format(2, args, rb_str_new2("%*"fmt)); \ + l = strlcpy(s, StringValueCStr(result), endp - s); \ + if ((size_t)(endp - s) <= l) \ + goto err; \ + s += l; \ + } \ + } while (0) + + if (*format != '%') { + *s++ = *format; + continue; + } + tp = tbuf; + sp = format; + precision = -1; + flags = 0; + padding = 0; + colons = 0; + again: + switch (*++format) { + case '\0': + format--; + goto unknown; + + case 'A': /* full weekday name */ + case 'a': /* abbreviated weekday name */ + if (flags & BIT_OF(CHCASE)) { + flags &= ~(BIT_OF(LOWER) | BIT_OF(CHCASE)); + flags |= BIT_OF(UPPER); + } + { + int wday = tmx_wday; + if (wday < 0 || wday > 6) + i = 1, tp = "?"; + else { + if (*format == 'A') + i = strlen(tp = days_l[wday]); + else + i = 3, tp = days_l[wday]; + } + } + break; + + case 'B': /* full month name */ + case 'b': /* abbreviated month name */ + case 'h': /* same as %b */ + if (flags & BIT_OF(CHCASE)) { + flags &= ~(BIT_OF(LOWER) | BIT_OF(CHCASE)); + flags |= BIT_OF(UPPER); + } + { + int mon = tmx_mon; + if (mon < 1 || mon > 12) + i = 1, tp = "?"; + else { + if (*format == 'B') + i = strlen(tp = months_l[mon - 1]); + else + i = 3, tp = months_l[mon - 1]; + } + } + break; + + case 'C': /* century (year/100) */ + FMTV('0', 2, "d", div(tmx_year, INT2FIX(100))); + continue; + + case 'c': /* appropriate date and time representation */ + STRFTIME("%a %b %e %H:%M:%S %Y"); + continue; + + case 'D': + STRFTIME("%m/%d/%y"); + continue; + + case 'd': /* day of the month, 01 - 31 */ + case 'e': /* day of month, blank padded */ + v = range(1, tmx_mday, 31); + FMT((*format == 'd') ? '0' : ' ', 2, "d", v); + continue; + + case 'F': + STRFTIME("%Y-%m-%d"); + continue; + + case 'G': /* year of ISO week with century */ + case 'Y': /* year with century */ + { + VALUE year = (*format == 'G') ? tmx_cwyear : tmx_year; + if (FIXNUM_P(year)) { + long y = FIX2LONG(year); + FMT('0', 0 <= y ? 4 : 5, "ld", y); + } + else { + FMTV('0', 4, "d", year); + } + } + continue; + + case 'g': /* year of ISO week without a century */ + case 'y': /* year without a century */ + v = NUM2INT(mod((*format == 'g') ? tmx_cwyear : tmx_year, INT2FIX(100))); + FMT('0', 2, "d", v); + continue; + + case 'H': /* hour, 24-hour clock, 00 - 23 */ + case 'k': /* hour, 24-hour clock, blank pad */ + v = range(0, tmx_hour, 23); + FMT((*format == 'H') ? '0' : ' ', 2, "d", v); + continue; + + case 'I': /* hour, 12-hour clock, 01 - 12 */ + case 'l': /* hour, 12-hour clock, 1 - 12, blank pad */ + v = range(0, tmx_hour, 23); + if (v == 0) + v = 12; + else if (v > 12) + v -= 12; + FMT((*format == 'I') ? '0' : ' ', 2, "d", v); + continue; + + case 'j': /* day of the year, 001 - 366 */ + v = range(1, tmx_yday, 366); + FMT('0', 3, "d", v); + continue; + + case 'L': /* millisecond */ + case 'N': /* nanosecond */ + if (*format == 'L') + w = 3; + else + w = 9; + if (precision <= 0) + precision = w; + NEEDS(precision); + + { + VALUE subsec = tmx_sec_fraction; + int ww; + long n; + + ww = precision; + while (9 <= ww) { + subsec = mul(subsec, INT2FIX(1000000000)); + ww -= 9; + } + n = 1; + for (; 0 < ww; ww--) + n *= 10; + if (n != 1) + subsec = mul(subsec, INT2FIX(n)); + subsec = div(subsec, INT2FIX(1)); + + if (FIXNUM_P(subsec)) { + (void)snprintf(s, endp - s, "%0*ld", + precision, FIX2LONG(subsec)); + s += precision; + } + else { + VALUE args[2], result; + args[0] = INT2FIX(precision); + args[1] = subsec; + result = rb_str_format(2, args, rb_str_new2("%0*d")); + (void)strlcpy(s, StringValueCStr(result), endp - s); + s += precision; + } + } + continue; + + case 'M': /* minute, 00 - 59 */ + v = range(0, tmx_min, 59); + FMT('0', 2, "d", v); + continue; + + case 'm': /* month, 01 - 12 */ + v = range(1, tmx_mon, 12); + FMT('0', 2, "d", v); + continue; + + case 'n': /* same as \n */ + FILL_PADDING(1); + *s++ = '\n'; + continue; + + case 't': /* same as \t */ + FILL_PADDING(1); + *s++ = '\t'; + continue; + + case 'P': /* am or pm based on 12-hour clock */ + case 'p': /* AM or PM based on 12-hour clock */ + if ((*format == 'p' && (flags & BIT_OF(CHCASE))) || + (*format == 'P' && !(flags & (BIT_OF(CHCASE) | BIT_OF(UPPER))))) { + flags &= ~(BIT_OF(UPPER) | BIT_OF(CHCASE)); + flags |= BIT_OF(LOWER); + } + v = range(0, tmx_hour, 23); + if (v < 12) + tp = ampm[0]; + else + tp = ampm[1]; + i = 2; + break; + + case 'Q': /* milliseconds since Unix epoch */ + FMTV('0', 1, "d", tmx_msecs); + continue; + + case 'R': + STRFTIME("%H:%M"); + continue; + + case 'r': + STRFTIME("%I:%M:%S %p"); + continue; + + case 'S': /* second, 00 - 59 */ + v = range(0, tmx_sec, 59); + FMT('0', 2, "d", v); + continue; + + case 's': /* seconds since Unix epoch */ + FMTV('0', 1, "d", tmx_secs); + continue; + + case 'T': + STRFTIME("%H:%M:%S"); + continue; + + case 'U': /* week of year, Sunday is first day of week */ + case 'W': /* week of year, Monday is first day of week */ + v = range(0, (*format == 'U') ? tmx_wnum0 : tmx_wnum1, 53); + FMT('0', 2, "d", v); + continue; + + case 'u': /* weekday, Monday == 1, 1 - 7 */ + v = range(1, tmx_cwday, 7); + FMT('0', 1, "d", v); + continue; + + case 'V': /* week of year according ISO 8601 */ + v = range(1, tmx_cweek, 53); + FMT('0', 2, "d", v); + continue; + + case 'v': + STRFTIME("%e-%b-%Y"); + continue; + + case 'w': /* weekday, Sunday == 0, 0 - 6 */ + v = range(0, tmx_wday, 6); + FMT('0', 1, "d", v); + continue; + + case 'X': /* appropriate time representation */ + STRFTIME("%H:%M:%S"); + continue; + + case 'x': /* appropriate date representation */ + STRFTIME("%m/%d/%y"); + continue; + + case 'Z': /* time zone name or abbreviation */ + if (flags & BIT_OF(CHCASE)) { + flags &= ~(BIT_OF(UPPER) | BIT_OF(CHCASE)); + flags |= BIT_OF(LOWER); + } + { + char *zone = tmx_zone; + if (zone == NULL) + tp = ""; + else + tp = zone; + i = strlen(tp); + } + break; + + case 'z': /* offset from UTC */ + { + long off, aoff; + int hl, hw; + + off = tmx_offset; + aoff = off; + if (aoff < 0) + aoff = -off; + + if ((aoff / 3600) < 10) + hl = 1; + else + hl = 2; + hw = 2; + if (flags & BIT_OF(LEFT) && hl == 1) + hw = 1; + + switch (colons) { + case 0: /* %z -> +hhmm */ + precision = precision <= (3 + hw) ? hw : precision - 3; + NEEDS(precision + 3); + break; + + case 1: /* %:z -> +hh:mm */ + precision = precision <= (4 + hw) ? hw : precision - 4; + NEEDS(precision + 4); + break; + + case 2: /* %::z -> +hh:mm:ss */ + precision = precision <= (7 + hw) ? hw : precision - 7; + NEEDS(precision + 7); + break; + + case 3: /* %:::z -> +hh[:mm[:ss]] */ + { + if (aoff % 3600 == 0) { + precision = precision <= (1 + hw) ? + hw : precision - 1; + NEEDS(precision + 3); + } + else if (aoff % 60 == 0) { + precision = precision <= (4 + hw) ? + hw : precision - 4; + NEEDS(precision + 4); + } + else { + precision = precision <= (7 + hw) ? + hw : precision - 7; + NEEDS(precision + 7); + } + } + break; + + default: + format--; + goto unknown; + } + if (padding == ' ' && precision > hl) { + i = snprintf(s, endp - s, "%*s", precision - hl, ""); + precision = hl; + if (i < 0) goto err; + s += i; + } + if (off < 0) { + off = -off; + *s++ = '-'; + } else { + *s++ = '+'; + } + i = snprintf(s, endp - s, "%.*ld", precision, off / 3600); + if (i < 0) goto err; + s += i; + off = off % 3600; + if (colons == 3 && off == 0) + continue; + if (1 <= colons) + *s++ = ':'; + i = snprintf(s, endp - s, "%02d", (int)(off / 60)); + if (i < 0) goto err; + s += i; + off = off % 60; + if (colons == 3 && off == 0) + continue; + if (2 <= colons) { + *s++ = ':'; + i = snprintf(s, endp - s, "%02d", (int)off); + if (i < 0) goto err; + s += i; + } + } + continue; + + case '+': + STRFTIME("%a %b %e %H:%M:%S %Z %Y"); + continue; + + case 'E': + /* POSIX locale extensions, ignored for now */ + flags |= BIT_OF(LOCALE_E); + if (*(format + 1) && strchr("cCxXyY", *(format + 1))) + goto again; + goto unknown; + case 'O': + /* POSIX locale extensions, ignored for now */ + flags |= BIT_OF(LOCALE_O); + if (*(format + 1) && strchr("deHkIlmMSuUVwWy", *(format + 1))) + goto again; + goto unknown; + + case ':': + flags |= BIT_OF(COLONS); + { + size_t l = strspn(format, ":"); + format += l; + if (*format == 'z') { + colons = l; + format--; + goto again; + } + format -= l; + } + goto unknown; + + case '_': + FLAG_FOUND(); + padding = ' '; + goto again; + + case '-': + FLAG_FOUND(); + flags |= BIT_OF(LEFT); + goto again; + + case '^': + FLAG_FOUND(); + flags |= BIT_OF(UPPER); + goto again; + + case '#': + FLAG_FOUND(); + flags |= BIT_OF(CHCASE); + goto again; + + case '0': + FLAG_FOUND(); + padding = '0'; + case '1': case '2': case '3': case '4': + case '5': case '6': case '7': case '8': case '9': + { + char *e; + precision = (int)strtoul(format, &e, 10); + format = e - 1; + goto again; + } + + case '%': + FILL_PADDING(1); + *s++ = '%'; + continue; + + default: + unknown: + i = format - sp + 1; + tp = sp; + precision = -1; + flags = 0; + padding = 0; + colons = 0; + break; + } + if (i) { + FILL_PADDING(i); + memcpy(s, tp, i); + switch (flags & (BIT_OF(UPPER) | BIT_OF(LOWER))) { + case BIT_OF(UPPER): + upcase(s, i); + break; + case BIT_OF(LOWER): + downcase(s, i); + break; + } + s += i; + } + } + if (s >= endp) { + goto err; + } + if (*format == '\0') { + *s = '\0'; + return (s - start); + } + return 0; +} + +size_t +date_strftime(char *s, size_t maxsize, const char *format, + const struct tmx *tmx) +{ + return date_strftime_with_tmx(s, maxsize, format, tmx); +} + +/* +Local variables: +c-file-style: "ruby" +End: +*/ diff --git a/jni/ruby/ext/date/date_strptime.c b/jni/ruby/ext/date/date_strptime.c new file mode 100644 index 0000000..e318af1 --- /dev/null +++ b/jni/ruby/ext/date/date_strptime.c @@ -0,0 +1,701 @@ +/* + date_strptime.c: Coded by Tadayoshi Funaba 2011,2012 +*/ + +#include "ruby.h" +#include "ruby/encoding.h" +#include "ruby/re.h" +#include + +static const char *day_names[] = { + "Sunday", "Monday", "Tuesday", "Wednesday", + "Thursday", "Friday", "Saturday", + "Sun", "Mon", "Tue", "Wed", + "Thu", "Fri", "Sat" +}; + +static const char *month_names[] = { + "January", "February", "March", "April", + "May", "June", "July", "August", "September", + "October", "November", "December", + "Jan", "Feb", "Mar", "Apr", "May", "Jun", + "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" +}; + +static const char *merid_names[] = { + "am", "pm", + "a.m.", "p.m." +}; + +static const char *extz_pats[] = { + ":z", + "::z", + ":::z" +}; + +#define sizeof_array(o) (sizeof o / sizeof o[0]) + +#define f_negate(x) rb_funcall(x, rb_intern("-@"), 0) +#define f_add(x,y) rb_funcall(x, '+', 1, y) +#define f_sub(x,y) rb_funcall(x, '-', 1, y) +#define f_mul(x,y) rb_funcall(x, '*', 1, y) +#define f_div(x,y) rb_funcall(x, '/', 1, y) +#define f_idiv(x,y) rb_funcall(x, rb_intern("div"), 1, y) +#define f_mod(x,y) rb_funcall(x, '%', 1, y) +#define f_expt(x,y) rb_funcall(x, rb_intern("**"), 1, y) + +#define f_lt_p(x,y) rb_funcall(x, '<', 1, y) +#define f_gt_p(x,y) rb_funcall(x, '>', 1, y) +#define f_le_p(x,y) rb_funcall(x, rb_intern("<="), 1, y) +#define f_ge_p(x,y) rb_funcall(x, rb_intern(">="), 1, y) + +#define f_match(r,s) rb_funcall(r, rb_intern("match"), 1, s) +#define f_aref(o,i) rb_funcall(o, rb_intern("[]"), 1, i) +#define f_end(o,i) rb_funcall(o, rb_intern("end"), 1, i) + +#define issign(c) ((c) == '-' || (c) == '+') + +static int +num_pattern_p(const char *s) +{ + if (isdigit((unsigned char)*s)) + return 1; + if (*s == '%') { + s++; + if (*s == 'E' || *s == 'O') + s++; + if (*s && + (strchr("CDdeFGgHIjkLlMmNQRrSsTUuVvWwXxYy", *s) || + isdigit((unsigned char)*s))) + return 1; + } + return 0; +} + +#define NUM_PATTERN_P() num_pattern_p(&fmt[fi + 1]) + +static long +read_digits(const char *s, VALUE *n, size_t width) +{ + size_t l; + + l = strspn(s, "0123456789"); + + if (l == 0) + return 0; + + if (width < l) + l = width; + + if ((4 * l * sizeof(char)) <= (sizeof(long)*CHAR_BIT)) { + const char *os = s; + long v; + + v = 0; + while ((size_t)(s - os) < l) { + v *= 10; + v += *s - '0'; + s++; + } + if (os == s) + return 0; + *n = LONG2NUM(v); + return l; + } + else { + char *s2 = ALLOCA_N(char, l + 1); + memcpy(s2, s, l); + s2[l] = '\0'; + *n = rb_cstr_to_inum(s2, 10, 0); + return l; + } +} + +#define set_hash(k,v) rb_hash_aset(hash, ID2SYM(rb_intern(k)), v) +#define ref_hash(k) rb_hash_aref(hash, ID2SYM(rb_intern(k))) +#define del_hash(k) rb_hash_delete(hash, ID2SYM(rb_intern(k))) + +#define fail() \ +{ \ + set_hash("_fail", Qtrue); \ + return 0; \ +} + +#define fail_p() (!NIL_P(ref_hash("_fail"))) + +#define READ_DIGITS(n,w) \ +{ \ + size_t l; \ + l = read_digits(&str[si], &n, w); \ + if (l == 0) \ + fail(); \ + si += l; \ +} + +#define READ_DIGITS_MAX(n) READ_DIGITS(n, LONG_MAX) + +static int +valid_range_p(VALUE v, int a, int b) +{ + if (FIXNUM_P(v)) { + int vi = FIX2INT(v); + return !(vi < a || vi > b); + } + return !(f_lt_p(v, INT2NUM(a)) || f_gt_p(v, INT2NUM(b))); +} + +#define recur(fmt) \ +{ \ + size_t l; \ + l = date__strptime_internal(&str[si], slen - si, \ + fmt, sizeof fmt - 1, hash); \ + if (fail_p()) \ + return 0; \ + si += l; \ +} + +VALUE date_zone_to_diff(VALUE); + +static size_t +date__strptime_internal(const char *str, size_t slen, + const char *fmt, size_t flen, VALUE hash) +{ + size_t si, fi; + int c; + + si = fi = 0; + + while (fi < flen) { + + switch (fmt[fi]) { + case '%': + + again: + fi++; + c = fmt[fi]; + + switch (c) { + case 'E': + if (fmt[fi + 1] && strchr("cCxXyY", fmt[fi + 1])) + goto again; + fi--; + goto ordinal; + case 'O': + if (fmt[fi + 1] && strchr("deHImMSuUVwWy", fmt[fi + 1])) + goto again; + fi--; + goto ordinal; + case ':': + { + int i; + + for (i = 0; i < (int)sizeof_array(extz_pats); i++) + if (strncmp(extz_pats[i], &fmt[fi], + strlen(extz_pats[i])) == 0) { + fi += i; + goto again; + } + fail(); + } + + case 'A': + case 'a': + { + int i; + + for (i = 0; i < (int)sizeof_array(day_names); i++) { + size_t l = strlen(day_names[i]); + if (strncasecmp(day_names[i], &str[si], l) == 0) { + si += l; + set_hash("wday", INT2FIX(i % 7)); + goto matched; + } + } + fail(); + } + case 'B': + case 'b': + case 'h': + { + int i; + + for (i = 0; i < (int)sizeof_array(month_names); i++) { + size_t l = strlen(month_names[i]); + if (strncasecmp(month_names[i], &str[si], l) == 0) { + si += l; + set_hash("mon", INT2FIX((i % 12) + 1)); + goto matched; + } + } + fail(); + } + + case 'C': + { + VALUE n; + + if (NUM_PATTERN_P()) + READ_DIGITS(n, 2) + else + READ_DIGITS_MAX(n) + set_hash("_cent", n); + goto matched; + } + + case 'c': + recur("%a %b %e %H:%M:%S %Y"); + goto matched; + + case 'D': + recur("%m/%d/%y"); + goto matched; + + case 'd': + case 'e': + { + VALUE n; + + if (str[si] == ' ') { + si++; + READ_DIGITS(n, 1); + } else { + READ_DIGITS(n, 2); + } + if (!valid_range_p(n, 1, 31)) + fail(); + set_hash("mday", n); + goto matched; + } + + case 'F': + recur("%Y-%m-%d"); + goto matched; + + case 'G': + { + VALUE n; + + if (NUM_PATTERN_P()) + READ_DIGITS(n, 4) + else + READ_DIGITS_MAX(n) + set_hash("cwyear", n); + goto matched; + } + + case 'g': + { + VALUE n; + + READ_DIGITS(n, 2); + if (!valid_range_p(n, 0, 99)) + fail(); + set_hash("cwyear",n); + if (NIL_P(ref_hash("_cent"))) + set_hash("_cent", + INT2FIX(f_ge_p(n, INT2FIX(69)) ? 19 : 20)); + goto matched; + } + + case 'H': + case 'k': + { + VALUE n; + + if (str[si] == ' ') { + si++; + READ_DIGITS(n, 1); + } else { + READ_DIGITS(n, 2); + } + if (!valid_range_p(n, 0, 24)) + fail(); + set_hash("hour", n); + goto matched; + } + + case 'I': + case 'l': + { + VALUE n; + + if (str[si] == ' ') { + si++; + READ_DIGITS(n, 1); + } else { + READ_DIGITS(n, 2); + } + if (!valid_range_p(n, 1, 12)) + fail(); + set_hash("hour", n); + goto matched; + } + + case 'j': + { + VALUE n; + + READ_DIGITS(n, 3); + if (!valid_range_p(n, 1, 366)) + fail(); + set_hash("yday", n); + goto matched; + } + + case 'L': + case 'N': + { + VALUE n; + int sign = 1; + size_t osi; + + if (issign(str[si])) { + if (str[si] == '-') + sign = -1; + si++; + } + osi = si; + if (NUM_PATTERN_P()) + READ_DIGITS(n, c == 'L' ? 3 : 9) + else + READ_DIGITS_MAX(n) + if (sign == -1) + n = f_negate(n); + set_hash("sec_fraction", + rb_rational_new2(n, + f_expt(INT2FIX(10), + ULONG2NUM(si - osi)))); + goto matched; + } + + case 'M': + { + VALUE n; + + READ_DIGITS(n, 2); + if (!valid_range_p(n, 0, 59)) + fail(); + set_hash("min", n); + goto matched; + } + + case 'm': + { + VALUE n; + + READ_DIGITS(n, 2); + if (!valid_range_p(n, 1, 12)) + fail(); + set_hash("mon", n); + goto matched; + } + + case 'n': + case 't': + recur(" "); + goto matched; + + case 'P': + case 'p': + { + int i; + + for (i = 0; i < 4; i++) { + size_t l = strlen(merid_names[i]); + if (strncasecmp(merid_names[i], &str[si], l) == 0) { + si += l; + set_hash("_merid", INT2FIX((i % 2) == 0 ? 0 : 12)); + goto matched; + } + } + fail(); + } + + case 'Q': + { + VALUE n; + int sign = 1; + + if (str[si] == '-') { + sign = -1; + si++; + } + READ_DIGITS_MAX(n); + if (sign == -1) + n = f_negate(n); + set_hash("seconds", + rb_rational_new2(n, + f_expt(INT2FIX(10), + INT2FIX(3)))); + goto matched; + } + + case 'R': + recur("%H:%M"); + goto matched; + + case 'r': + recur("%I:%M:%S %p"); + goto matched; + + case 'S': + { + VALUE n; + + READ_DIGITS(n, 2); + if (!valid_range_p(n, 0, 60)) + fail(); + set_hash("sec", n); + goto matched; + } + + case 's': + { + VALUE n; + int sign = 1; + + if (str[si] == '-') { + sign = -1; + si++; + } + READ_DIGITS_MAX(n); + if (sign == -1) + n = f_negate(n); + set_hash("seconds", n); + goto matched; + } + + case 'T': + recur("%H:%M:%S"); + goto matched; + + case 'U': + case 'W': + { + VALUE n; + + READ_DIGITS(n, 2); + if (!valid_range_p(n, 0, 53)) + fail(); + set_hash(c == 'U' ? "wnum0" : "wnum1", n); + goto matched; + } + + case 'u': + { + VALUE n; + + READ_DIGITS(n, 1); + if (!valid_range_p(n, 1, 7)) + fail(); + set_hash("cwday", n); + goto matched; + } + + case 'V': + { + VALUE n; + + READ_DIGITS(n, 2); + if (!valid_range_p(n, 1, 53)) + fail(); + set_hash("cweek", n); + goto matched; + } + + case 'v': + recur("%e-%b-%Y"); + goto matched; + + case 'w': + { + VALUE n; + + READ_DIGITS(n, 1); + if (!valid_range_p(n, 0, 6)) + fail(); + set_hash("wday", n); + goto matched; + } + + case 'X': + recur("%H:%M:%S"); + goto matched; + + case 'x': + recur("%m/%d/%y"); + goto matched; + + case 'Y': + { + VALUE n; + int sign = 1; + + if (issign(str[si])) { + if (str[si] == '-') + sign = -1; + si++; + } + if (NUM_PATTERN_P()) + READ_DIGITS(n, 4) + else + READ_DIGITS_MAX(n) + if (sign == -1) + n = f_negate(n); + set_hash("year", n); + goto matched; + } + + case 'y': + { + VALUE n; + int sign = 1; + + READ_DIGITS(n, 2); + if (!valid_range_p(n, 0, 99)) + fail(); + if (sign == -1) + n = f_negate(n); + set_hash("year", n); + if (NIL_P(ref_hash("_cent"))) + set_hash("_cent", + INT2FIX(f_ge_p(n, INT2FIX(69)) ? 19 : 20)); + goto matched; + } + + case 'Z': + case 'z': + { + static const char pat_source[] = + "\\A(" + "(?:gmt|utc?)?[-+]\\d+(?:[,.:]\\d+(?::\\d+)?)?" + "|(?-i:[[:alpha:].\\s]+)(?:standard|daylight)\\s+time\\b" + "|(?-i:[[:alpha:]]+)(?:\\s+dst)?\\b" + ")"; + static VALUE pat = Qnil; + VALUE m, b; + + if (NIL_P(pat)) { + pat = rb_reg_new(pat_source, sizeof pat_source - 1, + ONIG_OPTION_IGNORECASE); + rb_gc_register_mark_object(pat); + } + + b = rb_backref_get(); + rb_match_busy(b); + m = f_match(pat, rb_usascii_str_new2(&str[si])); + + if (!NIL_P(m)) { + VALUE s, l, o; + + s = rb_reg_nth_match(1, m); + l = f_end(m, INT2FIX(0)); + o = date_zone_to_diff(s); + si += NUM2LONG(l); + set_hash("zone", s); + set_hash("offset", o); + rb_backref_set(b); + goto matched; + } + rb_backref_set(b); + fail(); + } + + case '%': + if (str[si] != '%') + fail(); + si++; + goto matched; + + case '+': + recur("%a %b %e %H:%M:%S %Z %Y"); + goto matched; + + default: + if (str[si] != '%') + fail(); + si++; + if (fi < flen) + if (str[si] != fmt[fi]) + fail(); + si++; + goto matched; + } + case ' ': + case '\t': + case '\n': + case '\v': + case '\f': + case '\r': + while (isspace((unsigned char)str[si])) + si++; + fi++; + break; + default: + ordinal: + if (str[si] != fmt[fi]) + fail(); + si++; + fi++; + break; + matched: + fi++; + break; + } + } + + return si; +} + +VALUE +date__strptime(const char *str, size_t slen, + const char *fmt, size_t flen, VALUE hash) +{ + size_t si; + VALUE cent, merid; + + si = date__strptime_internal(str, slen, fmt, flen, hash); + + if (slen > si) { + VALUE s; + + s = rb_usascii_str_new(&str[si], slen - si); + set_hash("leftover", s); + } + + if (fail_p()) + return Qnil; + + cent = ref_hash("_cent"); + if (!NIL_P(cent)) { + VALUE year; + + year = ref_hash("cwyear"); + if (!NIL_P(year)) + set_hash("cwyear", f_add(year, f_mul(cent, INT2FIX(100)))); + year = ref_hash("year"); + if (!NIL_P(year)) + set_hash("year", f_add(year, f_mul(cent, INT2FIX(100)))); + del_hash("_cent"); + } + + merid = ref_hash("_merid"); + if (!NIL_P(merid)) { + VALUE hour; + + hour = ref_hash("hour"); + if (!NIL_P(hour)) { + hour = f_mod(hour, INT2FIX(12)); + set_hash("hour", f_add(hour, merid)); + } + del_hash("_merid"); + } + + return hash; +} + +/* +Local variables: +c-file-style: "ruby" +End: +*/ diff --git a/jni/ruby/ext/date/date_tmx.h b/jni/ruby/ext/date/date_tmx.h new file mode 100644 index 0000000..ed06501 --- /dev/null +++ b/jni/ruby/ext/date/date_tmx.h @@ -0,0 +1,56 @@ +#ifndef DATE_TMX_H +#define DATE_TMX_H + +struct tmx_funcs { + VALUE (*year)(void *dat); + int (*yday)(void *dat); + int (*mon)(void *dat); + int (*mday)(void *dat); + VALUE (*cwyear)(void *dat); + int (*cweek)(void *dat); + int (*cwday)(void *dat); + int (*wnum0)(void *dat); + int (*wnum1)(void *dat); + int (*wday)(void *dat); + int (*hour)(void *dat); + int (*min)(void *dat); + int (*sec)(void *dat); + VALUE (*sec_fraction)(void *dat); + VALUE (*secs)(void *dat); + VALUE (*msecs)(void *dat); + int (*offset)(void *dat); + char *(*zone)(void *dat); +}; +struct tmx { + void *dat; + struct tmx_funcs *funcs; +}; + +#define tmx_attr(x) (tmx->funcs->x)(tmx->dat) + +#define tmx_year tmx_attr(year) +#define tmx_yday tmx_attr(yday) +#define tmx_mon tmx_attr(mon) +#define tmx_mday tmx_attr(mday) +#define tmx_cwyear tmx_attr(cwyear) +#define tmx_cweek tmx_attr(cweek) +#define tmx_cwday tmx_attr(cwday) +#define tmx_wnum0 tmx_attr(wnum0) +#define tmx_wnum1 tmx_attr(wnum1) +#define tmx_wday tmx_attr(wday) +#define tmx_hour tmx_attr(hour) +#define tmx_min tmx_attr(min) +#define tmx_sec tmx_attr(sec) +#define tmx_sec_fraction tmx_attr(sec_fraction) +#define tmx_secs tmx_attr(secs) +#define tmx_msecs tmx_attr(msecs) +#define tmx_offset tmx_attr(offset) +#define tmx_zone tmx_attr(zone) + +#endif + +/* +Local variables: +c-file-style: "ruby" +End: +*/ diff --git a/jni/ruby/ext/date/depend b/jni/ruby/ext/date/depend new file mode 100644 index 0000000..a5444e3 --- /dev/null +++ b/jni/ruby/ext/date/depend @@ -0,0 +1,53 @@ +# AUTOGENERATED DEPENDENCIES START +date_core.o: $(RUBY_EXTCONF_H) +date_core.o: $(arch_hdrdir)/ruby/config.h +date_core.o: $(hdrdir)/ruby/defines.h +date_core.o: $(hdrdir)/ruby/encoding.h +date_core.o: $(hdrdir)/ruby/intern.h +date_core.o: $(hdrdir)/ruby/missing.h +date_core.o: $(hdrdir)/ruby/oniguruma.h +date_core.o: $(hdrdir)/ruby/ruby.h +date_core.o: $(hdrdir)/ruby/st.h +date_core.o: $(hdrdir)/ruby/subst.h +date_core.o: $(top_srcdir)/include/ruby.h +date_core.o: date_core.c +date_core.o: date_tmx.h +date_parse.o: $(RUBY_EXTCONF_H) +date_parse.o: $(arch_hdrdir)/ruby/config.h +date_parse.o: $(hdrdir)/ruby/defines.h +date_parse.o: $(hdrdir)/ruby/encoding.h +date_parse.o: $(hdrdir)/ruby/intern.h +date_parse.o: $(hdrdir)/ruby/missing.h +date_parse.o: $(hdrdir)/ruby/oniguruma.h +date_parse.o: $(hdrdir)/ruby/re.h +date_parse.o: $(hdrdir)/ruby/regex.h +date_parse.o: $(hdrdir)/ruby/ruby.h +date_parse.o: $(hdrdir)/ruby/st.h +date_parse.o: $(hdrdir)/ruby/subst.h +date_parse.o: $(top_srcdir)/include/ruby.h +date_parse.o: date_parse.c +date_strftime.o: $(RUBY_EXTCONF_H) +date_strftime.o: $(arch_hdrdir)/ruby/config.h +date_strftime.o: $(hdrdir)/ruby/defines.h +date_strftime.o: $(hdrdir)/ruby/intern.h +date_strftime.o: $(hdrdir)/ruby/missing.h +date_strftime.o: $(hdrdir)/ruby/ruby.h +date_strftime.o: $(hdrdir)/ruby/st.h +date_strftime.o: $(hdrdir)/ruby/subst.h +date_strftime.o: date_strftime.c +date_strftime.o: date_tmx.h +date_strptime.o: $(RUBY_EXTCONF_H) +date_strptime.o: $(arch_hdrdir)/ruby/config.h +date_strptime.o: $(hdrdir)/ruby/defines.h +date_strptime.o: $(hdrdir)/ruby/encoding.h +date_strptime.o: $(hdrdir)/ruby/intern.h +date_strptime.o: $(hdrdir)/ruby/missing.h +date_strptime.o: $(hdrdir)/ruby/oniguruma.h +date_strptime.o: $(hdrdir)/ruby/re.h +date_strptime.o: $(hdrdir)/ruby/regex.h +date_strptime.o: $(hdrdir)/ruby/ruby.h +date_strptime.o: $(hdrdir)/ruby/st.h +date_strptime.o: $(hdrdir)/ruby/subst.h +date_strptime.o: $(top_srcdir)/include/ruby.h +date_strptime.o: date_strptime.c +# AUTOGENERATED DEPENDENCIES END diff --git a/jni/ruby/ext/date/extconf.h b/jni/ruby/ext/date/extconf.h new file mode 100644 index 0000000..cda0cc8 --- /dev/null +++ b/jni/ruby/ext/date/extconf.h @@ -0,0 +1,3 @@ +#ifndef EXTCONF_H +#define EXTCONF_H +#endif diff --git a/jni/ruby/ext/date/extconf.rb b/jni/ruby/ext/date/extconf.rb new file mode 100644 index 0000000..6f479ea --- /dev/null +++ b/jni/ruby/ext/date/extconf.rb @@ -0,0 +1,5 @@ +require 'mkmf' +if try_cflags("-std=iso9899:1999") + $CFLAGS += " " << "-std=iso9899:1999" +end +create_makefile('date_core') diff --git a/jni/ruby/ext/date/lib/date.rb b/jni/ruby/ext/date/lib/date.rb new file mode 100644 index 0000000..4268661 --- /dev/null +++ b/jni/ruby/ext/date/lib/date.rb @@ -0,0 +1,60 @@ +# date.rb: Written by Tadayoshi Funaba 1998-2011 + +require 'date_core' + +class Date + + class Infinity < Numeric # :nodoc: + + include Comparable + + def initialize(d=1) @d = d <=> 0 end + + def d() @d end + + protected :d + + def zero? () false end + def finite? () false end + def infinite? () d.nonzero? end + def nan? () d.zero? end + + def abs() self.class.new end + + def -@ () self.class.new(-d) end + def +@ () self.class.new(+d) end + + def <=> (other) + case other + when Infinity; return d <=> other.d + when Numeric; return d + else + begin + l, r = other.coerce(self) + return l <=> r + rescue NoMethodError + end + end + nil + end + + def coerce(other) + case other + when Numeric; return -d, d + else + super + end + end + + def to_f + return 0 if @d == 0 + if @d > 0 + Float::INFINITY + else + -Float::INFINITY + end + end + + end + +end -- cgit v1.2.3