date-delay.js.svn-base

Google浏览器V8内核代码

// Copyright 2006-2008 the V8 project authors. All rights reserved.
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
//       notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
//       copyright notice, this list of conditions and the following
//       disclaimer in the documentation and/or other materials provided
//       with the distribution.
//     * Neither the name of Google Inc. nor the names of its
//       contributors may be used to endorse or promote products derived
//       from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


// -------------------------------------------------------------------

// This file contains date support implemented in JavaScript.


// Keep reference to original values of some global properties.  This
// has the added benefit that the code in this file is isolated from
// changes to these properties.
const $Date = global.Date;
const $floor = $Math_floor;
const $abs = $Math_abs;


// ECMA 262 - 15.9.1.2
function Day(time) {
  return $floor(time/msPerDay);
};


// ECMA 262 - 5.2
function Modulo(value, remainder) {
  var mod = value % remainder;
  return mod >= 0 ? mod : mod + remainder;
};


function TimeWithinDay(time) {
  return Modulo(time, msPerDay);
};


// ECMA 262 - 15.9.1.3
function DaysInYear(year) {
  if (year % 4 != 0) return 365;
  if ((year % 100 == 0) && (year % 400 != 0)) return 365;
  return 366;
};


function DayFromYear(year) {
  return 365 * (year-1970)
      + $floor((year-1969)/4)
      - $floor((year-1901)/100)
      + $floor((year-1601)/400);
};


function TimeFromYear(year) {
  return msPerDay * DayFromYear(year);
};


function YearFromTime(time) {
  return FromJulianDay(Day(time) + kDayZeroInJulianDay).year;
};


function InLeapYear(time) {
  return DaysInYear(YearFromTime(time)) == 366 ? 1 : 0;
};


// ECMA 262 - 15.9.1.4
function MonthFromTime(time) {
  return FromJulianDay(Day(time) + kDayZeroInJulianDay).month;
};


function DayWithinYear(time) {
  return Day(time) - DayFromYear(YearFromTime(time));
};


// ECMA 262 - 15.9.1.5
function DateFromTime(time) {
  return FromJulianDay(Day(time) + kDayZeroInJulianDay).date;
};


// ECMA 262 - 15.9.1.9
function EquivalentYear(year) {
  // Returns an equivalent year in the range [1956-2000] matching
  // - leap year.
  // - week day of first day.
  var time = TimeFromYear(year);
  return (InLeapYear(time) == 0 ? 1967 : 1956) + (WeekDay(time) * 12) % 28;
};


function EquivalentTime(t) {
  // The issue here is that some library calls don't work right for dates
  // that cannot be represented using a signed 32 bit integer (measured in
  // whole seconds based on the 1970 epoch).
  // We solve this by mapping the time to a year with same leap-year-ness
  // and same starting day for the year.
  // As an optimization we avoid finding an equivalent year in the common
  // case.  We are measuring in ms here so the 32 bit signed integer range
  // is +-(1<<30)*1000 ie approximately +-2.1e20.
  if (t >= -2.1e12 && t <= 2.1e12) return t;
  var day = MakeDay(EquivalentYear(YearFromTime(t)), MonthFromTime(t), DateFromTime(t));
  return TimeClip(MakeDate(day, TimeWithinDay(t)));
};


var local_time_offset;

function LocalTimeOffset() {
  if (IS_UNDEFINED(local_time_offset)) {
    local_time_offset = %DateLocalTimeOffset();
  }
  return local_time_offset;
};


var daylight_cache_time = $NaN;
var daylight_cache_offset;

function DaylightSavingsOffset(t) {
  if (t == daylight_cache_time) {
    return daylight_cache_offset;
  }
  var offset = %DateDaylightSavingsOffset(EquivalentTime(t));
  daylight_cache_time = t;
  daylight_cache_offset = offset;
  return offset;
};


var timezone_cache_time = $NaN;
var timezone_cache_timezone;

function LocalTimezone(t) {
  if(t == timezone_cache_time) {
    return timezone_cache_timezone;
  }
  var timezone = %DateLocalTimezone(EquivalentTime(t));
  timezone_cache_time = t;
  timezone_cache_timezone = timezone;
  return timezone;
};


function WeekDay(time) {
  return Modulo(Day(time) + 4, 7);
};


function LocalTime(time) {
  if ($isNaN(time)) return time;
  return time + LocalTimeOffset() + DaylightSavingsOffset(time);
};


function UTC(time) {
  if ($isNaN(time)) return time;
  var tmp = time - LocalTimeOffset();
  return tmp - DaylightSavingsOffset(tmp);
};


// ECMA 262 - 15.9.1.10
function HourFromTime(time) {
  return Modulo($floor(time / msPerHour), HoursPerDay);
};


function MinFromTime(time) {
  return Modulo($floor(time / msPerMinute), MinutesPerHour);
};


function SecFromTime(time) {
  return Modulo($floor(time / msPerSecond), SecondsPerMinute);
};


function msFromTime(time) {
  return Modulo(time, msPerSecond);
};


// ECMA 262 - 15.9.1.11
function MakeTime(hour, min, sec, ms) {
  if (!$isFinite(hour)) return $NaN;
  if (!$isFinite(min)) return $NaN;
  if (!$isFinite(sec)) return $NaN;
  if (!$isFinite(ms)) return $NaN;
  return TO_INTEGER(hour) * msPerHour
      + TO_INTEGER(min) * msPerMinute
      + TO_INTEGER(sec) * msPerSecond
      + TO_INTEGER(ms);
};


// ECMA 262 - 15.9.1.12
function TimeInYear(year) {
  return DaysInYear(year) * msPerDay;
};


// Compute modified Julian day from year, month, date.
// The missing days in 1582 are ignored for JavaScript compatibility.
function ToJulianDay(year, month, date) {
  var jy = (month > 1) ? year : year - 1;
  var jm = (month > 1) ? month + 2 : month + 14;
  var ja = $floor(0.01*jy);
  return $floor($floor(365.25*jy) + $floor(30.6001*jm) + date + 1720995) + 2 - ja + $floor(0.25*ja);
};


var four_year_cycle_table;


function CalculateDateTable() {
  var month_lengths = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
  var four_year_cycle_table = new $Array(1461);

  var cumulative = 0;
  var position = 0;
  var leap_position = 0;
  for (var month = 0; month < 12; month++) {
    var length = month_lengths[month];
    for (var day = 1; day <= length; day++) {
      four_year_cycle_table[leap_position] =
        (month << kMonthShift) + day;
      four_year_cycle_table[366 + position] =
        (1 << kYearShift) + (month << kMonthShift) + day;
      four_year_cycle_table[731 + position] =
        (2 << kYearShift) + (month << kMonthShift) + day;
      four_year_cycle_table[1096 + position] =
        (3 << kYearShift) + (month << kMonthShift) + day;
      leap_position++;
      position++;
    }
    if (month == 1) {
      four_year_cycle_table[leap_position++] =
        (month << kMonthShift) + 29;
    }
  }
  return four_year_cycle_table;
};



// Constructor for creating objects holding year, month, and date.
// Introduced to ensure the two return points in FromJulianDay match same map.
function DayTriplet(year, month, date) {
  this.year = year;
  this.month = month;
  this.date = date;
}

// Compute year, month, and day from modified Julian day.
// The missing days in 1582 are ignored for JavaScript compatibility.
function FromJulianDay(julian) {
  // Avoid floating point and non-Smi maths in common case.  This is also a period of
  // time where leap years are very regular.  The range is not too large to avoid overflow
  // when doing the multiply-to-divide trick.
  if (julian > kDayZeroInJulianDay &&
      (julian - kDayZeroInJulianDay) < 40177) { // 1970 - 2080
    if (!four_year_cycle_table)
      four_year_cycle_table = CalculateDateTable();
    var jsimple = (julian - kDayZeroInJulianDay) + 731; // Day 0 is 1st January 1968
    var y = 1968;
    // Divide by 1461 by multiplying with 22967 and shifting down by 25!
    var after_1968 = (jsimple * 22967) >> 25;
    y += after_1968 << 2;
    jsimple -= 1461 * after_1968;
    var four_year_cycle = four_year_cycle_table[jsimple];
    return new DayTriplet(y + (four_year_cycle >> kYearShift),
                           (four_year_cycle & kMonthMask) >> kMonthShift,
                           four_year_cycle & kDayMask);
  }
  var jalpha = $floor((julian - 1867216.25) / 36524.25);
  var jb = julian + 1 + jalpha - $floor(0.25 * jalpha) + 1524;
  var jc = $floor(6680.0 + ((jb-2439870) - 122.1)/365.25);
  var jd = $floor(365 * jc + (0.25 * jc));
  var je = $floor((jb - jd)/30.6001);
  var m = je - 1;
  if (m > 12) m -= 13;
  var y = jc - 4715;
  if (m > 2) { --y; --m; }
  var d = jb - jd - $floor(30.6001 * je);
  return new DayTriplet(y, m, d);
};

// Compute number of days given a year, month, date.
// Note that month and date can lie outside the normal range.
//   For example:
//     MakeDay(2007, -4, 20) --> MakeDay(2006, 8, 20)
//     MakeDay(2007, -33, 1) --> MakeDay(2004, 3, 1)
//     MakeDay(2007, 14, -50) --> MakeDay(2007, 8, 11)
function MakeDay(year, month, date) {
  if (!$isFinite(year) || !$isFinite(month) || !$isFinite(date)) return $NaN;

  // Conversion to integers.
  year = TO_INTEGER(year);
  month = TO_INTEGER(month);
  date = TO_INTEGER(date);

  // Overflow months into year.
  year = year + $floor(month/12);
  month = month % 12;
  if (month < 0) {
    month += 12;
  }

  // Return days relative to Jan 1 1970.
  return ToJulianDay(year, month, date) - kDayZeroInJulianDay;
};


// ECMA 262 - 15.9.1.13
function MakeDate(day, time) {
  if (!$isFinite(day)) return $NaN;
  if (!$isFinite(time)) return $NaN;
  return day * msPerDay + time;
};


// ECMA 262 - 15.9.1.14
function TimeClip(time) {
  if (!$isFinite(time)) return $NaN;
  if ($abs(time) > 8.64E15) return $NaN;
  return TO_INTEGER(time);
};


%SetCode($Date, function(year, month, date, hours, minutes, seconds, ms) {
  if (%IsConstructCall()) {
    // ECMA 262 - 15.9.3
    var argc = %_ArgumentsLength();
    if (argc == 0) {
      %_SetValueOf(this, %DateCurrentTime());
      return;
    }
    if (argc == 1) {
      // According to ECMA 262, no hint should be given for this
      // conversion.  However, ToPrimitive defaults to String Hint
      // for Date objects which will lose precision when the Date
      // constructor is called with another Date object as its
      // argument.  We therefore use Number Hint for the conversion
      // (which is the default for everything else than Date
      // objects).  This makes us behave like KJS and SpiderMonkey.
      var time = ToPrimitive(year, NUMBER_HINT);
      if (IS_STRING(time)) {
        %_SetValueOf(this, DateParse(time));
      } else {
        %_SetValueOf(this, TimeClip(ToNumber(time)));
      }
      return;
    }
    year = ToNumber(year);
    month = ToNumber(month);
    date = argc > 2 ? ToNumber(date) : 1;
    hours = argc > 3 ? ToNumber(hours) : 0;
    minutes = argc > 4 ? ToNumber(minutes) : 0;
    seconds = argc > 5 ? ToNumber(seconds) : 0;
    ms = argc > 6 ? ToNumber(ms) : 0;
    year = (!$isNaN(year) && 0 <= TO_INTEGER(year) && TO_INTEGER(year) <= 99)
        ? 1900 + TO_INTEGER(year) : year;
    var day = MakeDay(year, month, date);
    var time = MakeTime(hours, minutes, seconds, ms);
    %_SetValueOf(this, TimeClip(UTC(MakeDate(day, time))));
  } else {
    // ECMA 262 - 15.9.2
    return (new $Date()).toString();
  }
});


// Helper functions.
function GetTimeFrom(aDate) {
  if (IS_DATE(aDate)) return %_ValueOf(aDate);
  throw new $TypeError('this is not a Date object.');
};


function GetMillisecondsFrom(aDate) {
  var t = GetTimeFrom(aDate);
  if ($isNaN(t)) return t;
  return msFromTime(LocalTime(t));
};


function GetUTCMillisecondsFrom(aDate) {
  var t = GetTimeFrom(aDate);
  if ($isNaN(t)) return t;
  return msFromTime(t);
};


function GetSecondsFrom(aDate) {
  var t = GetTimeFrom(aDate);
  if ($isNaN(t)) return t;
  return SecFromTime(LocalTime(t));
};


function GetUTCSecondsFrom(aDate) {
  var t = GetTimeFrom(aDate);
  if ($isNaN(t)) return t;
  return SecFromTime(t);
};


function GetMinutesFrom(aDate) {
  var t = GetTimeFrom(aDate);
  if ($isNaN(t)) return t;
  return MinFromTime(LocalTime(t));
};


function GetUTCMinutesFrom(aDate) {
  var t = GetTimeFrom(aDate);
  if ($isNaN(t)) return t;
  return MinFromTime(t);
};


function GetHoursFrom(aDate) {
  var t = GetTimeFrom(aDate);
  if ($isNaN(t)) return t;
  return HourFromTime(LocalTime(t));
};


function GetUTCHoursFrom(aDate) {
  var t = GetTimeFrom(aDate);
  if ($isNaN(t)) return t;
  return HourFromTime(t);
};


function GetFullYearFrom(aDate) {
  var t = GetTimeFrom(aDate);
  if ($isNaN(t)) return t;
  return YearFromTime(LocalTime(t));
};


function GetUTCFullYearFrom(aDate) {
  var t = GetTimeFrom(aDate);
  if ($isNaN(t)) return t;
  return YearFromTime(t);
};


function GetMonthFrom(aDate) {
  var t = GetTimeFrom(aDate);
  if ($isNaN(t)) return t;
  return MonthFromTime(LocalTime(t));
};


function GetUTCMonthFrom(aDate) {
  var t = GetTimeFrom(aDate);
  if ($isNaN(t)) return t;
  return MonthFromTime(t);
};


function GetDateFrom(aDate) {
  var t = GetTimeFrom(aDate);
  if ($isNaN(t)) return t;
  return DateFromTime(LocalTime(t));
};