Hi,
with this commit I think that things are definitely better than before:
http://github.com/nrk/ironruby/commit/e880c0cffa337bffa31ed317ca673f8be7dd5795
It also fixes Time to behave just like MRI under circumstances similar
to the following ones:
irb(main):001:0> Time.local(2009,12,31,23,59,60)
=> Fri Jan 01 00:00:00 +0100 2010
irb(main):002:0> Time.local(2009,9,31,23,59,60)
=> Fri Oct 02 00:00:00 +0200 2009
irb(main):003:0> Time.local(2009,0,0)
ArgumentError: argument out of range
from (irb):3:in `local'
from (irb):3
irb(main):004:0> Time.local(20009)
ArgumentError: time out of range
from (irb):4:in `local'
from (irb):4
The attached diff includes this commit and the previous one.
Thanks,
Daniele
On Mon, Aug 24, 2009 at 09:01, Daniele Alessandri<[email protected]> wrote:
> The int,int,int,int,int,int,object,object,object,object overloads are
> there just to skip the (relative) complexity of CreateTime when you
> pass 10 arguments to local/utc and all the relevant arguments are
> integers, e.g. when you do Time.local(*Time.now.to_a). The last four
> arguments are typed as object just because in the MRI you can pass
> whatever you want, they are totally ignored anyways. As for the double
> variant... well yeah, it might be superfluous and I guess it would be
> rarely used, so I will remove it.
>
> By the way the cast double -> int cast is admittedly wrong, that
> scenario under the MRI throws a RangeError:
>
> irb(main):001:0>
> Time.local(0,0,0,24,8,1_000_000_000_000_000_000.0,nil,nil,nil,nil)
> RangeError: float 1e+018 out of range of integer
> from (irb):1:in `local'
> from (irb):1
> from :0
>
> I was going to use RubyOps.ConvertDoubleToFixnum(double) for that one,
> but I noticed that when it catches an overflow the message for
> RangeError is a little bit different (Fixnum instead of integer) and I
> was wondering if this difference was intentional or what. But then, I
> blatantly forgot to check it out and ask on the list... :-)
>
> As for Create(object,long,long) I can fix it while I am at it, I just
> committed the same change introduced in Create(object,double) but had
> not investigated other issues.
>
> Thanks,
> Daniele
>
>
> On Sun, Aug 23, 2009 at 23:58, Tomas
> Matousek<[email protected]> wrote:
>> What are overloads like this:
>> ...(int second, int minute, int hour, int day, int month, int year, object
>> wday, object yday, object isdst, object zone)
>> good for?
>>
>> It seems that the parameters typed to object are not used. Also when you
>> cast double to int it might overflow. What should happen if a big integer is
>> passed in?
>>
>> This is also suspicious:
>>
>> public static DateTime Create(object/*!*/ self, long seconds, long
>> microseconds)
>>
>> MRI actually uses a default protocol for Fixnum for the parameters:
>>
>> class C
>> def respond_to? name
>> puts name
>> true
>> end
>>
>> def to_int
>> 123
>> end
>> end
>>
>> Time.at(C.new, 1.2) #=> to_int
>> Time.at(C.new, 1000000000) #=> to_int
>>
>> Tomas
>>
>>
>> -----Original Message-----
>> From: [email protected]
>> [mailto:[email protected]] On Behalf Of Daniele Alessandri
>> Sent: Sunday, August 23, 2009 1:20 PM
>> To: [email protected]
>> Subject: Re: [Ironruby-core] Core Review: Time and IO#open fixes
>>
>> On Sun, Aug 23, 2009 at 15:15, Daniele Alessandri<[email protected]>
>> wrote:
>>
>> [...]
>>> *
>>> http://github.com/nrk/ironruby/commit/48a4a02b5b47d61f2f7a3f3887ea4bf02d63edb4
>>> Miscellaneous fixes to Time:
>> [...]
>>
>> Just noticed the wrong link :-/ Here is the correct one:
>> http://github.com/nrk/ironruby/commit/fb55ffcfb7193eba537eb4aba98c3d55871006d6
>>
>> --
>> Daniele Alessandri
>> http://www.clorophilla.net/blog/
>> http://twitter.com/JoL1hAHN
>> _______________________________________________
>> Ironruby-core mailing list
>> [email protected]
>> http://rubyforge.org/mailman/listinfo/ironruby-core
>>
>> _______________________________________________
>> Ironruby-core mailing list
>> [email protected]
>> http://rubyforge.org/mailman/listinfo/ironruby-core
>>
>
>
>
> --
> Daniele Alessandri
> http://www.clorophilla.net/blog/
> http://twitter.com/JoL1hAHN
>
--
Daniele Alessandri
http://www.clorophilla.net/blog/
http://twitter.com/JoL1hAHN
diff --git
a/Merlin/External.LCA_RESTRICTED/Languages/IronRuby/mspec/ironruby-tags/core/time/local_tags.txt
b/Merlin/External.LCA_RESTRICTED/Languages/IronRuby/mspec/ironruby-tags/core/time/local_tags.txt
index 3ad8a21..22df910 100644
---
a/Merlin/External.LCA_RESTRICTED/Languages/IronRuby/mspec/ironruby-tags/core/time/local_tags.txt
+++
b/Merlin/External.LCA_RESTRICTED/Languages/IronRuby/mspec/ironruby-tags/core/time/local_tags.txt
@@ -1,8 +1,4 @@
fails:Time.local creates a time based on given values, interpreted in the
local time zone
fails:Time.local creates a time based on given C-style gmtime arguments,
interpreted in the local time zone
-fails:Time.local handles string-like second argument
-fails:Time.local handles string arguments
-fails:Time.local handles float arguments
fails:Time.local should accept various year ranges
fails:Time.local throws ArgumentError for out of range values
-fails:Time.local throws ArgumentError for invalid number of arguments
diff --git
a/Merlin/External.LCA_RESTRICTED/Languages/IronRuby/mspec/ironruby-tags/core/time/utc_tags.txt
b/Merlin/External.LCA_RESTRICTED/Languages/IronRuby/mspec/ironruby-tags/core/time/utc_tags.txt
index e8e7bdd..c6fa1a0 100644
---
a/Merlin/External.LCA_RESTRICTED/Languages/IronRuby/mspec/ironruby-tags/core/time/utc_tags.txt
+++
b/Merlin/External.LCA_RESTRICTED/Languages/IronRuby/mspec/ironruby-tags/core/time/utc_tags.txt
@@ -1,9 +1,5 @@
fails:Time.utc creates a time based on given values, interpreted as UTC (GMT)
fails:Time.utc creates a time based on given C-style gmtime arguments,
interpreted as UTC (GMT)
-fails:Time.utc handles string-like second argument
-fails:Time.utc handles string arguments
-fails:Time.utc handles float arguments
fails:Time.utc should accept various year ranges
fails:Time.utc throws ArgumentError for out of range values
-fails:Time.utc throws ArgumentError for invalid number of arguments
fails:Time#utc returns the utc representation of time
diff --git
a/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Builtins/TimeOps.cs
b/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Builtins/TimeOps.cs
index 18e1d84..529cf04 100644
--- a/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Builtins/TimeOps.cs
+++ b/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Builtins/TimeOps.cs
@@ -27,201 +27,299 @@ namespace IronRuby.Builtins {
[RubyClass("Time", Extends = typeof(DateTime), Inherits = typeof(Object)),
Includes(typeof(Comparable))]
public static class TimeOps {
readonly static DateTime epoch = new DateTime(1970, 1, 1, 0, 0, 0,
DateTimeKind.Utc); //January 1, 1970 00:00 UTC
[RubyConstructor]
public static DateTime Create(RubyClass/*!*/ self) {
return DateTime.Now;
}
// TODO: I removed all of the constructor overloads since Ruby doesn't
define any non-default constructors for Time.
// In the future, however, we need to fix this problem per RubyForge
bug #20035
#region "Singleton Methods"
- #region at
+ #region at
private static long microsecondsToTicks(long microseconds) {
return microseconds * 10;
}
private static long secondsToTicks(long seconds) {
return seconds * 10000000;
}
[RubyMethod("at", RubyMethodAttributes.PublicSingleton)]
public static DateTime Create(object/*!*/ self, DateTime other) {
return new DateTime(other.Ticks, other.Kind);
}
[RubyMethod("at", RubyMethodAttributes.PublicSingleton)]
public static DateTime Create(object/*!*/ self, double seconds) {
- return epoch.ToLocalTime().AddSeconds(seconds);
+ return epoch.AddSeconds(seconds).ToLocalTime();
}
-
+
[RubyMethod("at", RubyMethodAttributes.PublicSingleton)]
public static DateTime Create(object/*!*/ self, long seconds, long
microseconds) {
- long ticks = epoch.ToLocalTime().Ticks + secondsToTicks(seconds) +
microsecondsToTicks(microseconds);
- return new DateTime(ticks);
+ long ticks = epoch.Ticks + secondsToTicks(seconds) +
microsecondsToTicks(microseconds);
+ return new DateTime(ticks).ToLocalTime();
}
#endregion
[RubyMethod("now", RubyMethodAttributes.PublicSingleton)]
public static DateTime CreateTime(object/*!*/ self) {
return DateTime.Now;
}
[RubyMethod("today", RubyMethodAttributes.PublicSingleton)]
public static DateTime Today(object self) {
return DateTime.Today;
}
+
+ #region helpers for local, mktime, utc, gmt
+
+ private static int GetComponent(ConversionStorage<IntegerValue>/*!*/
conversionStorage, ConversionStorage<MutableString>/*!*/ stringCast,
+ object[]/*!*/ components, int index, int defValue, bool isMonth) {
+
+ if (index >= components.Length || components[index] == null) {
+ return defValue;
+ }
+
+ if (components[index] is int) {
+ return (int)components[index];
+ }
+
+ if (components[index] is double) {
+ return
RubyOps.ConvertDoubleToFixnum((double)components[index]);
+ }
+
+ if (!isMonth) {
+ IntegerValue componentValue = components[index] is
MutableString
+ ? Protocols.ConvertToInteger(conversionStorage,
components[index])
+ : Protocols.CastToInteger(conversionStorage,
components[index]);
+
+ if (!componentValue.IsFixnum) {
+ throw RubyExceptions.CreateArgumentError("argument out of
range");
+ }
+
+ return componentValue.Fixnum;
+ } else {
+ // month is treated in a different way
+
+ DateTime parsed;
+ MutableString month = components[index] is MutableString
+ ? components[index] as MutableString
+ : Protocols.CastToString(stringCast, components[index]);
+
+ if (DateTime.TryParseExact(month.ToString(), "%M",
CultureInfo.InvariantCulture, DateTimeStyles.None, out parsed)) {
+ return parsed.Month;
+ }
+ if (DateTime.TryParseExact(month.ToString(), "MMM",
CultureInfo.InvariantCulture, DateTimeStyles.None, out parsed)) {
+ return parsed.Month;
+ }
+
+ throw RubyExceptions.CreateArgumentError("argument out of
range");
+ }
+ }
+
+ private static DateTime CreateTime(object/*!*/ self, int year, int
month, int day, int hour, int minute, int second, int microsecond, DateTimeKind
kind) {
+ if (month < 1 || month > 12) {
+ throw RubyExceptions.CreateArgumentError("argument out of
range");
+ }
+
+ if (day < 1 || day > 31) {
+ throw RubyExceptions.CreateArgumentError("argument out of
range");
+ }
+
+ if (hour < 0 || hour > 23) {
+ throw RubyExceptions.CreateArgumentError("argument out of
range");
+ }
+
+ if (minute < 0 || minute > 59) {
+ throw RubyExceptions.CreateArgumentError("argument out of
range");
+ }
+
+ if (second < 0 || second > 60) {
+ throw RubyExceptions.CreateArgumentError("argument out of
range");
+ }
+
+ try {
+ return new DateTime(year, month, 1, hour, minute, 0,
kind).AddDays(day - 1).AddSeconds(second).AddTicks(microsecond * 10);
+ } catch (ArgumentOutOfRangeException) {
+ throw RubyExceptions.CreateArgumentError("time out of range");
+ }
+ }
+
+ private static DateTime
CreateTime(ConversionStorage<IntegerValue>/*!*/ conversionStorage,
ConversionStorage<MutableString>/*!*/ stringCast,
+ object/*!*/ self, DateTimeKind kind, object[]/*!*/ components) {
+
+ if (components.Length == 10) {
+ return CreateTime(self,
+ GetComponent(conversionStorage, stringCast, components, 5,
0, false),
+ GetComponent(conversionStorage, stringCast, components, 4,
0, true),
+ GetComponent(conversionStorage, stringCast, components, 3,
0, false),
+ GetComponent(conversionStorage, stringCast, components, 2,
1, false),
+ GetComponent(conversionStorage, stringCast, components, 1,
1, false),
+ GetComponent(conversionStorage, stringCast, components, 0,
0, false),
+ 0, kind
+ );
+ } else {
+ if (components.Length > 7 || components.Length == 0) {
+ throw
RubyExceptions.CreateArgumentError(String.Format("wrong number of arguments
({0} for 7)", components.Length));
+ }
+
+ return CreateTime(self,
+ GetComponent(conversionStorage, stringCast, components, 0,
0, false),
+ GetComponent(conversionStorage, stringCast, components, 1,
1, true),
+ GetComponent(conversionStorage, stringCast, components, 2,
1, false),
+ GetComponent(conversionStorage, stringCast, components, 3,
0, false),
+ GetComponent(conversionStorage, stringCast, components, 4,
0, false),
+ GetComponent(conversionStorage, stringCast, components, 5,
0, false),
+ GetComponent(conversionStorage, stringCast, components, 6,
0, false),
+ kind
+ );
+ }
+ }
+
+ #endregion
+
#region local, mktime
[RubyMethod("local", RubyMethodAttributes.PublicSingleton)]
[RubyMethod("mktime", RubyMethodAttributes.PublicSingleton)]
public static DateTime CreateLocalTime(object/*!*/ self, int year) {
- return new DateTime(year, 1, 1);
+ return CreateTime(self, year, 1, 1, 0, 0, 0, 0,
DateTimeKind.Local);
}
[RubyMethod("local", RubyMethodAttributes.PublicSingleton)]
[RubyMethod("mktime", RubyMethodAttributes.PublicSingleton)]
public static DateTime CreateLocalTime(object/*!*/ self, int year, int
month) {
- return new DateTime(year, month, 1);
+ return CreateTime(self, year, month, 1, 0, 0, 0, 0,
DateTimeKind.Local);
}
[RubyMethod("local", RubyMethodAttributes.PublicSingleton)]
[RubyMethod("mktime", RubyMethodAttributes.PublicSingleton)]
public static DateTime CreateLocalTime(object/*!*/ self, int year, int
month, int day) {
- return new DateTime(year, month, day);
+ return CreateTime(self, year, month, day, 0, 0, 0, 0,
DateTimeKind.Local);
}
[RubyMethod("local", RubyMethodAttributes.PublicSingleton)]
[RubyMethod("mktime", RubyMethodAttributes.PublicSingleton)]
public static DateTime CreateLocalTime(object/*!*/ self, int year, int
month, int day, int hour) {
- return new DateTime(year, month, day, hour, 0, 0);
+ return CreateTime(self, year, month, day, hour, 0, 0, 0,
DateTimeKind.Local);
}
[RubyMethod("local", RubyMethodAttributes.PublicSingleton)]
[RubyMethod("mktime", RubyMethodAttributes.PublicSingleton)]
public static DateTime CreateLocalTime(object/*!*/ self, int year, int
month, int day, int hour, int minute) {
- return new DateTime(year, month, day, hour, minute, 0);
+ return CreateTime(self, year, month, day, hour, minute, 0, 0,
DateTimeKind.Local);
}
[RubyMethod("local", RubyMethodAttributes.PublicSingleton)]
[RubyMethod("mktime", RubyMethodAttributes.PublicSingleton)]
public static DateTime CreateLocalTime(object/*!*/ self, int year, int
month, int day, int hour, int minute, int second) {
- return new DateTime(year, month, day, hour, minute, second);
+ return CreateTime(self, year, month, day, hour, minute, second, 0,
DateTimeKind.Local);
}
[RubyMethod("local", RubyMethodAttributes.PublicSingleton)]
[RubyMethod("mktime", RubyMethodAttributes.PublicSingleton)]
public static DateTime CreateLocalTime(object/*!*/ self, int year, int
month, int day, int hour, int minute, int second, int microsecond) {
- return new DateTime(year, month, day, hour, minute,
second).AddTicks(microsecond*10);
+ return CreateTime(self, year, month, day, hour, minute, second,
microsecond, DateTimeKind.Local);
}
- private static int GetComponent(ConversionStorage<int>/*!*/
conversionStorage, object[] components, int index, int defValue) {
- if (index >= components.Length || components[index] == null) {
- return defValue;
- }
- return Protocols.CastToFixnum(conversionStorage,
components[index]);
+ [RubyMethod("local", RubyMethodAttributes.PublicSingleton)]
+ [RubyMethod("mktime", RubyMethodAttributes.PublicSingleton)]
+ public static DateTime CreateLocalTime(object/*!*/ self, int second,
int minute, int hour, int day, int month, int year,
+ object wday, object yday, object isdst, object zone) {
+
+ // wday, yday, isdst and zone are ignored
+ return CreateTime(self, year, month, day, hour, minute, second, 0,
DateTimeKind.Local);
}
[RubyMethod("local", RubyMethodAttributes.PublicSingleton)]
[RubyMethod("mktime", RubyMethodAttributes.PublicSingleton)]
- public static DateTime CreateLocalTime(ConversionStorage<int>/*!*/
conversionStorage, object/*!*/ self, [NotNull]params object[]/*!*/ components) {
+ public static DateTime
CreateLocalTime(ConversionStorage<IntegerValue>/*!*/ conversionStorage,
ConversionStorage<MutableString>/*!*/ stringCast,
+ object/*!*/ self, [NotNull]params object[]/*!*/ components) {
- if (components.Length > 7 || components.Length == 0) {
- throw RubyExceptions.CreateArgumentError(String.Format("wrong
number of arguments ({0} for 7)", components.Length));
- }
-
- return new DateTime(Protocols.CastToFixnum(conversionStorage,
components[0]),
- GetComponent(conversionStorage, components, 1, 1),
- GetComponent(conversionStorage, components, 2, 1),
- GetComponent(conversionStorage, components, 3, 0),
- GetComponent(conversionStorage, components, 4, 0),
- GetComponent(conversionStorage, components, 5, 0),
- GetComponent(conversionStorage, components, 6, 0)
- );
+ return CreateTime(conversionStorage, stringCast, self,
DateTimeKind.Local, components);
}
#endregion
#region utc, gm
[RubyMethod("utc", RubyMethodAttributes.PublicSingleton)]
[RubyMethod("gm", RubyMethodAttributes.PublicSingleton)]
public static DateTime CreateGmtTime(object/*!*/ self, int year) {
- return new DateTime(year, 1, 1, 0, 0, 0, DateTimeKind.Utc);
+ return CreateTime(self, year, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc);
}
[RubyMethod("utc", RubyMethodAttributes.PublicSingleton)]
[RubyMethod("gm", RubyMethodAttributes.PublicSingleton)]
public static DateTime CreateGmtTime(object/*!*/ self, int year, int
month) {
- return new DateTime(year, month, 1, 0, 0, 0, DateTimeKind.Utc);
+ return CreateTime(self, year, month, 1, 0, 0, 0, 0,
DateTimeKind.Utc);
}
[RubyMethod("utc", RubyMethodAttributes.PublicSingleton)]
[RubyMethod("gm", RubyMethodAttributes.PublicSingleton)]
public static DateTime CreateGmtTime(object/*!*/ self, int year, int
month, int day) {
- return new DateTime(year, month, day, 0, 0, 0, DateTimeKind.Utc);
+ return CreateTime(self, year, month, day, 0, 0, 0, 0,
DateTimeKind.Utc);
}
[RubyMethod("utc", RubyMethodAttributes.PublicSingleton)]
[RubyMethod("gm", RubyMethodAttributes.PublicSingleton)]
public static DateTime CreateGmtTime(object/*!*/ self, int year, int
month, int day, int hour) {
- return new DateTime(year, month, day, hour, 0, 0,
DateTimeKind.Utc);
+ return CreateTime(self, year, month, day, hour, 0, 0, 0,
DateTimeKind.Utc);
}
[RubyMethod("utc", RubyMethodAttributes.PublicSingleton)]
[RubyMethod("gm", RubyMethodAttributes.PublicSingleton)]
public static DateTime CreateGmtTime(object/*!*/ self, int year, int
month, int day, int hour, int minute) {
- return new DateTime(year, month, day, hour, minute, 0,
DateTimeKind.Utc);
+ return CreateTime(self, year, month, day, hour, minute, 0, 0,
DateTimeKind.Utc);
}
[RubyMethod("utc", RubyMethodAttributes.PublicSingleton)]
[RubyMethod("gm", RubyMethodAttributes.PublicSingleton)]
public static DateTime CreateGmtTime(object/*!*/ self, int year, int
month, int day, int hour, int minute, int second) {
- return new DateTime(year, month, day, hour, minute, second,
DateTimeKind.Utc);
+ return CreateTime(self, year, month, day, hour, minute, second, 0,
DateTimeKind.Utc);
}
[RubyMethod("utc", RubyMethodAttributes.PublicSingleton)]
[RubyMethod("gm", RubyMethodAttributes.PublicSingleton)]
public static DateTime CreateGmtTime(object/*!*/ self, int year, int
month, int day, int hour, int minute, int second, int microsecond) {
- return new DateTime(year, month, day, hour, minute, second,
DateTimeKind.Utc).AddTicks(microsecond * 10);
+ return CreateTime(self, year, month, day, hour, minute, second,
microsecond, DateTimeKind.Utc);
}
[RubyMethod("utc", RubyMethodAttributes.PublicSingleton)]
[RubyMethod("gm", RubyMethodAttributes.PublicSingleton)]
- public static DateTime CreateGmtTime(ConversionStorage<int>/*!*/
conversionStorage, RubyContext/*!*/ context, object/*!*/ self,
- [NotNull]params object[]/*!*/ components) {
+ public static DateTime CreateGmtTime(object/*!*/ self, int second, int
minute, int hour, int day, int month, int year,
+ object wday, object yday, object isdst, object zone) {
- if (components.Length > 7 || components.Length == 0) {
- throw RubyExceptions.CreateArgumentError(String.Format("wrong
number of arguments ({0} for 7)", components.Length));
- }
- return new DateTime(
- Protocols.CastToFixnum(conversionStorage, components[0]),
- GetComponent(conversionStorage, components, 1, 1),
- GetComponent(conversionStorage, components, 2, 1),
- GetComponent(conversionStorage, components, 3, 0),
- GetComponent(conversionStorage, components, 4, 0),
- GetComponent(conversionStorage, components, 5, 0),
DateTimeKind.Utc).AddTicks(
- GetComponent(conversionStorage, components, 6, 0) * 10
- );
+ // wday, yday, isdst and zone are ignored
+ return CreateTime(self, year, month, day, hour, minute, second, 0,
DateTimeKind.Utc);
+ }
+
+ [RubyMethod("utc", RubyMethodAttributes.PublicSingleton)]
+ [RubyMethod("gm", RubyMethodAttributes.PublicSingleton)]
+ public static DateTime
CreateGmtTime(ConversionStorage<IntegerValue>/*!*/ conversionStorage,
ConversionStorage<MutableString>/*!*/ stringCast,
+ object/*!*/ self, [NotNull]params object[]/*!*/ components) {
+
+ return CreateTime(conversionStorage, stringCast, self,
DateTimeKind.Utc, components);
}
#endregion
#endregion "Singleton Methods"
#region _dump, _load
[RubyMethod("_dump")]
public static MutableString/*!*/ Dump(RubyContext/*!*/ context,
DateTime self, [Optional]int depth) {
if (self.Year < 1900) {
throw RubyExceptions.CreateTypeError("unable to marshal time");
}
uint dword1 = 0x80000000;
@@ -255,32 +353,32 @@ namespace IronRuby.Builtins {
[RubyMethod("_load", RubyMethodAttributes.PublicSingleton)]
public static DateTime Load(RubyContext/*!*/ context, object/*!*/
self, [NotNull]MutableString time) {
byte[] data = time.ConvertToBytes();
if (data.Length != 8 || (data[3] & 0x80) != 0x80) {
throw RubyExceptions.CreateTypeError("marshaled time format
differ");
}
bool isUtc = (data[3] & 0x40) != 0;
uint dword1 = GetUint(data, 0);
int year = 1900 + (int)((dword1 >> 14) & 0xffff);
int month = 1 + (int)((dword1 >> 10) & 0x0f);
int day = (int)((dword1 >> 5) & 0x01f);
int hour = (int)(dword1 & 0x01f);
uint dword2 = GetUint(data, 4);
- int minute = (int)((dword2 >> 26) & 0x2f);
- int second = (int)((dword2 >> 20) & 0x2f);
+ int minute = (int)((dword2 >> 26) & 0x3f);
+ int second = (int)((dword2 >> 20) & 0x3f);
int usec = (int)(dword2 & 0xfffff);
try {
DateTime result = new DateTime(year, month, day, hour, minute,
second, DateTimeKind.Utc);
result = result.AddTicks(usec * 10L);
if (!isUtc) {
result = result.ToLocalTime();
}
return result;
} catch (ArgumentOutOfRangeException) {
throw RubyExceptions.CreateTypeError("marshaled time format
differ");
}
}
#endregion _dump, _load
@@ -554,31 +652,31 @@ namespace IronRuby.Builtins {
[RubyMethod("to_a")]
public static RubyArray ToArray(DateTime/*!*/ self) {
RubyArray result = new RubyArray();
result.Add(self.Second);
result.Add(self.Minute);
result.Add(self.Hour);
result.Add(self.Day);
result.Add(self.Month);
result.Add(self.Year);
result.Add((int)self.DayOfWeek);
result.Add(self.DayOfYear);
result.Add(self.IsDaylightSavingTime());
result.Add(GetZone(self));
return result;
- }
+ }
[RubyMethod("wday")]
public static int DayOfWeek(DateTime/*!*/ self) {
return (int)self.DayOfWeek;
}
[RubyMethod("hash")]
public static int GetHash(DateTime/*!*/ self) {
return self.GetHashCode();
}
[RubyMethod("zone")]
public static MutableString/*!*/ GetZone(DateTime/*!*/ self) {
// TODO:
return MutableString.CreateAscii("UTC");
diff --git
a/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Initializers.Generated.cs
b/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Initializers.Generated.cs
index 25951a0..353626e 100644
---
a/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Initializers.Generated.cs
+++
b/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Initializers.Generated.cs
@@ -6052,72 +6052,76 @@ namespace IronRuby.Builtins {
module.DefineLibraryMethod("at", 0x61,
new System.Func<System.Object, System.DateTime,
System.DateTime>(IronRuby.Builtins.TimeOps.Create),
new System.Func<System.Object, System.Double,
System.DateTime>(IronRuby.Builtins.TimeOps.Create),
new System.Func<System.Object, System.Int64, System.Int64,
System.DateTime>(IronRuby.Builtins.TimeOps.Create)
);
module.DefineLibraryMethod("gm", 0x61,
new System.Func<System.Object, System.Int32,
System.DateTime>(IronRuby.Builtins.TimeOps.CreateGmtTime),
new System.Func<System.Object, System.Int32, System.Int32,
System.DateTime>(IronRuby.Builtins.TimeOps.CreateGmtTime),
new System.Func<System.Object, System.Int32, System.Int32,
System.Int32, System.DateTime>(IronRuby.Builtins.TimeOps.CreateGmtTime),
new System.Func<System.Object, System.Int32, System.Int32,
System.Int32, System.Int32,
System.DateTime>(IronRuby.Builtins.TimeOps.CreateGmtTime),
new System.Func<System.Object, System.Int32, System.Int32,
System.Int32, System.Int32, System.Int32,
System.DateTime>(IronRuby.Builtins.TimeOps.CreateGmtTime),
new System.Func<System.Object, System.Int32, System.Int32,
System.Int32, System.Int32, System.Int32, System.Int32,
System.DateTime>(IronRuby.Builtins.TimeOps.CreateGmtTime),
new System.Func<System.Object, System.Int32, System.Int32,
System.Int32, System.Int32, System.Int32, System.Int32, System.Int32,
System.DateTime>(IronRuby.Builtins.TimeOps.CreateGmtTime),
- new
System.Func<IronRuby.Runtime.ConversionStorage<System.Int32>,
IronRuby.Runtime.RubyContext, System.Object, System.Object[],
System.DateTime>(IronRuby.Builtins.TimeOps.CreateGmtTime)
+ new System.Func<System.Object, System.Int32, System.Int32,
System.Int32, System.Int32, System.Int32, System.Int32, System.Object,
System.Object, System.Object, System.Object,
System.DateTime>(IronRuby.Builtins.TimeOps.CreateGmtTime),
+ new
System.Func<IronRuby.Runtime.ConversionStorage<IronRuby.Runtime.IntegerValue>,
IronRuby.Runtime.ConversionStorage<IronRuby.Builtins.MutableString>,
System.Object, System.Object[],
System.DateTime>(IronRuby.Builtins.TimeOps.CreateGmtTime)
);
module.DefineLibraryMethod("local", 0x61,
new System.Func<System.Object, System.Int32,
System.DateTime>(IronRuby.Builtins.TimeOps.CreateLocalTime),
new System.Func<System.Object, System.Int32, System.Int32,
System.DateTime>(IronRuby.Builtins.TimeOps.CreateLocalTime),
new System.Func<System.Object, System.Int32, System.Int32,
System.Int32, System.DateTime>(IronRuby.Builtins.TimeOps.CreateLocalTime),
new System.Func<System.Object, System.Int32, System.Int32,
System.Int32, System.Int32,
System.DateTime>(IronRuby.Builtins.TimeOps.CreateLocalTime),
new System.Func<System.Object, System.Int32, System.Int32,
System.Int32, System.Int32, System.Int32,
System.DateTime>(IronRuby.Builtins.TimeOps.CreateLocalTime),
new System.Func<System.Object, System.Int32, System.Int32,
System.Int32, System.Int32, System.Int32, System.Int32,
System.DateTime>(IronRuby.Builtins.TimeOps.CreateLocalTime),
new System.Func<System.Object, System.Int32, System.Int32,
System.Int32, System.Int32, System.Int32, System.Int32, System.Int32,
System.DateTime>(IronRuby.Builtins.TimeOps.CreateLocalTime),
- new
System.Func<IronRuby.Runtime.ConversionStorage<System.Int32>, System.Object,
System.Object[], System.DateTime>(IronRuby.Builtins.TimeOps.CreateLocalTime)
+ new System.Func<System.Object, System.Int32, System.Int32,
System.Int32, System.Int32, System.Int32, System.Int32, System.Object,
System.Object, System.Object, System.Object,
System.DateTime>(IronRuby.Builtins.TimeOps.CreateLocalTime),
+ new
System.Func<IronRuby.Runtime.ConversionStorage<IronRuby.Runtime.IntegerValue>,
IronRuby.Runtime.ConversionStorage<IronRuby.Builtins.MutableString>,
System.Object, System.Object[],
System.DateTime>(IronRuby.Builtins.TimeOps.CreateLocalTime)
);
module.DefineLibraryMethod("mktime", 0x61,
new System.Func<System.Object, System.Int32,
System.DateTime>(IronRuby.Builtins.TimeOps.CreateLocalTime),
new System.Func<System.Object, System.Int32, System.Int32,
System.DateTime>(IronRuby.Builtins.TimeOps.CreateLocalTime),
new System.Func<System.Object, System.Int32, System.Int32,
System.Int32, System.DateTime>(IronRuby.Builtins.TimeOps.CreateLocalTime),
new System.Func<System.Object, System.Int32, System.Int32,
System.Int32, System.Int32,
System.DateTime>(IronRuby.Builtins.TimeOps.CreateLocalTime),
new System.Func<System.Object, System.Int32, System.Int32,
System.Int32, System.Int32, System.Int32,
System.DateTime>(IronRuby.Builtins.TimeOps.CreateLocalTime),
new System.Func<System.Object, System.Int32, System.Int32,
System.Int32, System.Int32, System.Int32, System.Int32,
System.DateTime>(IronRuby.Builtins.TimeOps.CreateLocalTime),
new System.Func<System.Object, System.Int32, System.Int32,
System.Int32, System.Int32, System.Int32, System.Int32, System.Int32,
System.DateTime>(IronRuby.Builtins.TimeOps.CreateLocalTime),
- new
System.Func<IronRuby.Runtime.ConversionStorage<System.Int32>, System.Object,
System.Object[], System.DateTime>(IronRuby.Builtins.TimeOps.CreateLocalTime)
+ new System.Func<System.Object, System.Int32, System.Int32,
System.Int32, System.Int32, System.Int32, System.Int32, System.Object,
System.Object, System.Object, System.Object,
System.DateTime>(IronRuby.Builtins.TimeOps.CreateLocalTime),
+ new
System.Func<IronRuby.Runtime.ConversionStorage<IronRuby.Runtime.IntegerValue>,
IronRuby.Runtime.ConversionStorage<IronRuby.Builtins.MutableString>,
System.Object, System.Object[],
System.DateTime>(IronRuby.Builtins.TimeOps.CreateLocalTime)
);
module.DefineLibraryMethod("now", 0x61,
new System.Func<System.Object,
System.DateTime>(IronRuby.Builtins.TimeOps.CreateTime)
);
module.DefineLibraryMethod("today", 0x61,
new System.Func<System.Object,
System.DateTime>(IronRuby.Builtins.TimeOps.Today)
);
module.DefineLibraryMethod("utc", 0x61,
new System.Func<System.Object, System.Int32,
System.DateTime>(IronRuby.Builtins.TimeOps.CreateGmtTime),
new System.Func<System.Object, System.Int32, System.Int32,
System.DateTime>(IronRuby.Builtins.TimeOps.CreateGmtTime),
new System.Func<System.Object, System.Int32, System.Int32,
System.Int32, System.DateTime>(IronRuby.Builtins.TimeOps.CreateGmtTime),
new System.Func<System.Object, System.Int32, System.Int32,
System.Int32, System.Int32,
System.DateTime>(IronRuby.Builtins.TimeOps.CreateGmtTime),
new System.Func<System.Object, System.Int32, System.Int32,
System.Int32, System.Int32, System.Int32,
System.DateTime>(IronRuby.Builtins.TimeOps.CreateGmtTime),
new System.Func<System.Object, System.Int32, System.Int32,
System.Int32, System.Int32, System.Int32, System.Int32,
System.DateTime>(IronRuby.Builtins.TimeOps.CreateGmtTime),
new System.Func<System.Object, System.Int32, System.Int32,
System.Int32, System.Int32, System.Int32, System.Int32, System.Int32,
System.DateTime>(IronRuby.Builtins.TimeOps.CreateGmtTime),
- new
System.Func<IronRuby.Runtime.ConversionStorage<System.Int32>,
IronRuby.Runtime.RubyContext, System.Object, System.Object[],
System.DateTime>(IronRuby.Builtins.TimeOps.CreateGmtTime)
+ new System.Func<System.Object, System.Int32, System.Int32,
System.Int32, System.Int32, System.Int32, System.Int32, System.Object,
System.Object, System.Object, System.Object,
System.DateTime>(IronRuby.Builtins.TimeOps.CreateGmtTime),
+ new
System.Func<IronRuby.Runtime.ConversionStorage<IronRuby.Runtime.IntegerValue>,
IronRuby.Runtime.ConversionStorage<IronRuby.Builtins.MutableString>,
System.Object, System.Object[],
System.DateTime>(IronRuby.Builtins.TimeOps.CreateGmtTime)
);
}
private static void
LoadTrueClass_Instance(IronRuby.Builtins.RubyModule/*!*/ module) {
module.DefineLibraryMethod("&", 0x51,
new System.Func<System.Boolean, System.Object,
System.Boolean>(IronRuby.Builtins.TrueClass.And),
new System.Func<System.Boolean, System.Boolean,
System.Boolean>(IronRuby.Builtins.TrueClass.And)
);
module.DefineLibraryMethod("^", 0x51,
new System.Func<System.Boolean, System.Object,
System.Boolean>(IronRuby.Builtins.TrueClass.Xor),
new System.Func<System.Boolean, System.Boolean,
System.Boolean>(IronRuby.Builtins.TrueClass.Xor)
);
_______________________________________________
Ironruby-core mailing list
[email protected]
http://rubyforge.org/mailman/listinfo/ironruby-core
