int main() { Gloam greg(3, "Greg"); greg.tell(); return 0; }
CString XMLRestriction::CheckGregMD(CString p_value) { // Try to convert to GregorianMD at least once XMLGregorianMD greg(p_value); return CheckRangeGregMD(p_value); }
long ISO8601Calendar::DWYToJulianDay( int day, int week, long year ) { GregorianDate greg( 28, GregorianCalendar::December, year - 1 ); greg.Increment( WesternWeek::Sunday, (week - 1) ); return greg.JulianDay() + day; }
CString XMLRestriction::CheckGregYM(CString p_value) { // Try to convert to GregorianYM at least once XMLGregorianYM greg(p_value); // Check ranges return CheckRangeGregYM(p_value); }
void CssmUniformDate::convertTo(CssmOwnedData &data) const { Gregorian greg(mTime); char str[20]; if (19 != snprintf(str, 20, "%4.4d-%2.2d-%2.2d_%2.2d:%2.2d:%2.2d", int(greg.year), greg.month, greg.day, greg.hour, greg.minute, int(greg.second))) CssmError::throwMe(CSSM_ERRCODE_UNKNOWN_FORMAT); data = CssmData(str, 19); }
void CssmUniformDate::convertTo(char *dst, size_t length) const { if (length < 14) CssmError::throwMe(CSSMERR_CSSM_BUFFER_TOO_SMALL); Gregorian greg(mTime); char str[15]; if (14 != snprintf(str, 15, "%4.4d%2.2d%2.2d%2.2d%2.2d%2.2d", int(greg.year), greg.month, greg.day, greg.hour, greg.minute, int(greg.second))) CssmError::throwMe(CSSM_ERRCODE_UNKNOWN_FORMAT); memcpy(dst, str, length == 14 ? 14 : 15); // null terminate if there's room }
//------------------------------------------------------ // Class: TChineseCalendar // Function: ChineseNewYear // Arguments: TInt // // Comments: Determines the chinese new year // // Return: TReal - Julian day of the start of the given year //------------------------------------------------------ TReal TChineseCalendar::ChineseNewYear(TInt aYear) const { TGregorianCalendar greg(iJulianDay); TArithmeticalDate date; TReal solarTerm1; TReal solarTerm2; TReal newMoon1; TReal newMoon2; TReal newMoon3; TReal rtn; TBool majorSolarTerm1; TBool majorSolarTerm2; TReal tempReal; TInt tempInt; // get solar term 1 date.iDay = KFifteenth; date.iMonth = EDecember + KCalConvMonthOffsetByOne; date.iYear = aYear - KCalConvYearOffsetByOne; solarTerm1 = greg.GregToJulianDay(date); solarTerm1 = MajorSolarTermOnOrAfter(solarTerm1); // get solar term 2 date.iDay = KFifteenth; date.iMonth = EDecember + KCalConvMonthOffsetByOne; date.iYear = aYear; solarTerm2 = greg.GregToJulianDay(date); solarTerm2 = MajorSolarTermOnOrAfter(solarTerm2); // get new moon 1 newMoon1 = ChineseNewMoonOnOrAfter(solarTerm1 + KCalConvDayOffsetByOne); // get new moon 2 newMoon2 = ChineseNewMoonOnOrAfter(newMoon1 + KCalConvDayOffsetByOne); // get new moon 3 newMoon3 = ChineseNewMoonBefore(solarTerm2 + KCalConvDayOffsetByOne); // perform chinese new year calculation tempReal = (newMoon3 - newMoon1) / KMeanSynodicMonth; Round(tempInt,tempReal); majorSolarTerm1 = NoMajorSolarTerm(newMoon1); majorSolarTerm2 = NoMajorSolarTerm(newMoon2); if((tempInt == KMonthsInYear) && (majorSolarTerm1 || majorSolarTerm2)) { rtn = ChineseNewMoonOnOrAfter(newMoon2 + KCalConvDayOffsetByOne); } else { rtn = newMoon2; } return rtn; }
//------------------------------------------------------ // Class: TChineseCalendar // Function: ChineseToDateTime // Arguments: TDateTime & // // Comments: This function converts the date held within // the TChineseCalendar class to a TDateTime format and // places it in the TDateTime class provided. // // Return: void //------------------------------------------------------ EXPORT_C void TChineseCalendar::ChineseToDateTime(TDateTime &aDT) { TArithmeticalDate gregDate; TGregorianCalendar greg(iJulianDay); greg.GregFromJulianDay(gregDate,iJulianDay); aDT.SetMicroSecond(0); aDT.SetSecond(0); aDT.SetMinute(0); aDT.SetHour(0); aDT.SetMonth((TMonth)(gregDate.iMonth - KCalConvMonthOffsetByOne)); aDT.SetDay(gregDate.iDay - KCalConvMonthOffsetByOne); aDT.SetYear(gregDate.iYear); }
//------------------------------------------------------ // Class: TChineseCalendar // Function: ChineseTimeZone // Arguments: TReal // // Comments: Determines which time zone to use // // Return: TReal - time zone //------------------------------------------------------ TReal TChineseCalendar::ChineseTimeZone(const TReal& aJulianDay) const { TReal result; TGregorianCalendar greg(aJulianDay); TArithmeticalDate date; greg.GetDate(date); if(date.iYear < 1929) { result = 465.0 + (40.0 / 60.0); } else { result = 480.0; } return result; }
CssmUniformDate::operator CssmDate () const { Gregorian greg(mTime); return CssmDate(greg.year, greg.month, greg.day); }
//------------------------------------------------------ // Class: TChineseCalendar // Function: ChineseFromFixed // Arguments: TChineseDate &, TReal // // Comments: this function converts a julian day value to // a chinese date in the form TChineseDate // // Return: None //------------------------------------------------------ void TChineseCalendar::ChineseFromFixed(TChineseDate &aDate, const TReal& aJulianDay) const { TGregorianCalendar greg(aJulianDay); TArithmeticalDate date; TReal solarTerm1; TReal solarTerm2; TReal lunarTerm1; TReal lunarTerm2; TReal lunarTerm3; TInt leapYear; TInt year; TInt elapsedYears; TBool majorSolarTerm; TReal tempReal; TInt tempInt; // get the Gregorian date greg.GetDate(date); year = date.iYear; // get solar term 1 date.iDay = KFifteenth; date.iMonth = EDecember + KCalConvMonthOffsetByOne; date.iYear = year - KCalConvYearOffsetByOne; solarTerm1 = greg.GregToJulianDay(date); solarTerm1 = MajorSolarTermOnOrAfter(solarTerm1); // get solar term 2 date.iDay = KFifteenth; date.iMonth = EDecember + KCalConvMonthOffsetByOne; date.iYear = year; solarTerm2 = greg.GregToJulianDay(date); solarTerm2 = MajorSolarTermOnOrAfter(solarTerm2); // get lunar term 1 if((solarTerm1 <= aJulianDay) && (aJulianDay < solarTerm2)) { lunarTerm1 = solarTerm1 + KCalConvDayOffsetByOne; } else { lunarTerm1 = solarTerm2 + KCalConvDayOffsetByOne; } lunarTerm1 = ChineseNewMoonOnOrAfter(lunarTerm1); // get lunar term 2 if((solarTerm1 <= aJulianDay) && (aJulianDay < solarTerm2)) { lunarTerm2 = solarTerm2 + KCalConvDayOffsetByOne; } else { date.iDay = KFifteenth; date.iMonth = EDecember + KCalConvMonthOffsetByOne; date.iYear = year + KCalConvYearOffsetByOne; lunarTerm2 = greg.GregToJulianDay(date); lunarTerm2 = MajorSolarTermOnOrAfter(lunarTerm2) + KCalConvDayOffsetByOne; } lunarTerm2 = ChineseNewMoonBefore(lunarTerm2); // get Lunar term 3 lunarTerm3 = aJulianDay + KCalConvDayOffsetByOne; lunarTerm3 = ChineseNewMoonBefore(lunarTerm3); // get leap year tempReal = ((lunarTerm2 - lunarTerm1) / KMeanSynodicMonth); Round(tempInt,tempReal); if(tempInt == KMonthsInYear) { leapYear = ETrue; } else { leapYear = EFalse; } // get month tempReal = ((lunarTerm3 - lunarTerm1) / KMeanSynodicMonth); Round(tempInt,tempReal); if(leapYear && PriorLeapMonth(lunarTerm1,lunarTerm3)) { tempInt--; } Amod(tempReal,tempInt,KMonthsInYear); Round(aDate.iMonth,tempReal); // get leap month majorSolarTerm = NoMajorSolarTerm(lunarTerm3); if((leapYear) && majorSolarTerm && (!PriorLeapMonth(lunarTerm1,ChineseNewMoonBefore(lunarTerm3)))) { aDate.iLeapMonth = ETrue; } else { aDate.iLeapMonth = EFalse; } // get elapsed years elapsedYears = year - KFirstChinYear; date.iDay = KCalConvFirstDay; date.iMonth = EJuly + KCalConvMonthOffsetByOne; date.iYear = year; tempReal = greg.GregToJulianDay(date); if((aDate.iMonth < (ENovember + KCalConvMonthOffsetByOne)) || (aJulianDay > tempReal)) { elapsedYears++; } // get cycle tempReal = (elapsedYears - KCalConvYearOffsetByOne) / KYearsInChinCycle; Floor(aDate.iCycle,tempReal); aDate.iCycle++; // get year Amod(tempReal,elapsedYears,KYearsInChinCycle); Round(aDate.iYear,tempReal); // get day Floor(tempInt,aJulianDay); aDate.iDay = tempInt; Floor(tempInt,lunarTerm3); aDate.iDay -= tempInt; aDate.iDay += KCalConvDayOffsetByOne; }
void CalendarLimitTest::doLimitsTest(Calendar& cal, const int32_t* fieldsToTest, UDate startDate, int32_t testDuration) { static const int32_t FIELDS[] = { UCAL_ERA, UCAL_YEAR, UCAL_MONTH, UCAL_WEEK_OF_YEAR, UCAL_WEEK_OF_MONTH, UCAL_DAY_OF_MONTH, UCAL_DAY_OF_YEAR, UCAL_DAY_OF_WEEK_IN_MONTH, UCAL_YEAR_WOY, UCAL_EXTENDED_YEAR, -1, }; static const char* FIELD_NAME[] = { "ERA", "YEAR", "MONTH", "WEEK_OF_YEAR", "WEEK_OF_MONTH", "DAY_OF_MONTH", "DAY_OF_YEAR", "DAY_OF_WEEK", "DAY_OF_WEEK_IN_MONTH", "AM_PM", "HOUR", "HOUR_OF_DAY", "MINUTE", "SECOND", "MILLISECOND", "ZONE_OFFSET", "DST_OFFSET", "YEAR_WOY", "DOW_LOCAL", "EXTENDED_YEAR", "JULIAN_DAY", "MILLISECONDS_IN_DAY", "IS_LEAP_MONTH" }; UErrorCode status = U_ZERO_ERROR; int32_t i, j; UnicodeString ymd; GregorianCalendar greg(status); if (failure(status, "new GregorianCalendar")) { return; } greg.setTime(startDate, status); if (failure(status, "GregorianCalendar::setTime")) { return; } logln((UnicodeString)"Start: " + startDate); if (fieldsToTest == NULL) { fieldsToTest = FIELDS; } // Keep a record of minima and maxima that we actually see. // These are kept in an array of arrays of hashes. int32_t limits[UCAL_FIELD_COUNT][4]; for (j = 0; j < UCAL_FIELD_COUNT; j++) { limits[j][0] = INT32_MAX; limits[j][1] = INT32_MIN; limits[j][2] = INT32_MAX; limits[j][3] = INT32_MIN; } // This test can run for a long time; show progress. UDate millis = ucal_getNow(); UDate mark = millis + 5000; // 5 sec millis -= testDuration * 1000; // stop time if testDuration<0 for (i = 0; testDuration > 0 ? i < testDuration : ucal_getNow() < millis; ++i) { if (ucal_getNow() >= mark) { logln((UnicodeString)"(" + i + " days)"); mark += 5000; // 5 sec } UDate testMillis = greg.getTime(status); cal.setTime(testMillis, status); cal.setMinimalDaysInFirstWeek(1); if (failure(status, "Calendar set/getTime")) { return; } for (j = 0; fieldsToTest[j] >= 0; ++j) { UCalendarDateFields f = (UCalendarDateFields)fieldsToTest[j]; int32_t v = cal.get(f, status); int32_t minActual = cal.getActualMinimum(f, status); int32_t maxActual = cal.getActualMaximum(f, status); int32_t minLow = cal.getMinimum(f); int32_t minHigh = cal.getGreatestMinimum(f); int32_t maxLow = cal.getLeastMaximum(f); int32_t maxHigh = cal.getMaximum(f); if (limits[j][0] > minActual) { // the minimum limits[j][0] = minActual; } if (limits[j][1] < minActual) { // the greatest minimum limits[j][1] = minActual; } if (limits[j][2] > maxActual) { // the least maximum limits[j][2] = maxActual; } if (limits[j][3] < maxActual) { // the maximum limits[j][3] = maxActual; } if (minActual < minLow || minActual > minHigh) { errln((UnicodeString)"Fail: [" + cal.getType() + "] " + ymdToString(cal, ymd) + " Range for min of " + FIELD_NAME[f] + "(" + f + ")=" + minLow + ".." + minHigh + ", actual_min=" + minActual); } if (maxActual < maxLow || maxActual > maxHigh) { if ( uprv_strcmp(cal.getType(), "chinese") == 0 && testMillis >= 2842992000000.0 && testMillis <= 2906668800000.0 && logKnownIssue("12620", "chinese calendar failures for some actualMax tests")) { logln((UnicodeString)"KnownFail: [" + cal.getType() + "] " + ymdToString(cal, ymd) + " Range for max of " + FIELD_NAME[f] + "(" + f + ")=" + maxLow + ".." + maxHigh + ", actual_max=" + maxActual); } else { errln((UnicodeString)"Fail: [" + cal.getType() + "] " + ymdToString(cal, ymd) + " Range for max of " + FIELD_NAME[f] + "(" + f + ")=" + maxLow + ".." + maxHigh + ", actual_max=" + maxActual); } } if (v < minActual || v > maxActual) { // timebomb per #9967, fix with #9972 if ( uprv_strcmp(cal.getType(), "dangi") == 0 && testMillis >= 1865635198000.0 && logKnownIssue("9972", "as per #9967")) { // Feb 2029 gregorian, end of dangi 4361 logln((UnicodeString)"KnownFail: [" + cal.getType() + "] " + ymdToString(cal, ymd) + " " + FIELD_NAME[f] + "(" + f + ")=" + v + ", actual=" + minActual + ".." + maxActual + ", allowed=(" + minLow + ".." + minHigh + ")..(" + maxLow + ".." + maxHigh + ")"); } else if ( uprv_strcmp(cal.getType(), "chinese") == 0 && testMillis >= 2842992000000.0 && testMillis <= 2906668800000.0 && logKnownIssue("12620", "chinese calendar failures for some actualMax tests")) { logln((UnicodeString)"KnownFail: [" + cal.getType() + "] " + ymdToString(cal, ymd) + " " + FIELD_NAME[f] + "(" + f + ")=" + v + ", actual=" + minActual + ".." + maxActual + ", allowed=(" + minLow + ".." + minHigh + ")..(" + maxLow + ".." + maxHigh + ")"); } else { errln((UnicodeString)"Fail: [" + cal.getType() + "] " + ymdToString(cal, ymd) + " " + FIELD_NAME[f] + "(" + f + ")=" + v + ", actual=" + minActual + ".." + maxActual + ", allowed=(" + minLow + ".." + minHigh + ")..(" + maxLow + ".." + maxHigh + ")"); } } } greg.add(UCAL_DAY_OF_YEAR, 1, status); if (failure(status, "Calendar::add")) { return; } } // Check actual maxima and minima seen against ranges returned // by API. UnicodeString buf; for (j = 0; fieldsToTest[j] >= 0; ++j) { int32_t rangeLow, rangeHigh; UBool fullRangeSeen = TRUE; UCalendarDateFields f = (UCalendarDateFields)fieldsToTest[j]; buf.remove(); buf.append((UnicodeString)"[" + cal.getType() + "] " + FIELD_NAME[f]); // Minumum rangeLow = cal.getMinimum(f); rangeHigh = cal.getGreatestMinimum(f); if (limits[j][0] != rangeLow || limits[j][1] != rangeHigh) { fullRangeSeen = FALSE; } buf.append((UnicodeString)" minima range=" + rangeLow + ".." + rangeHigh); buf.append((UnicodeString)" minima actual=" + limits[j][0] + ".." + limits[j][1]); // Maximum rangeLow = cal.getLeastMaximum(f); rangeHigh = cal.getMaximum(f); if (limits[j][2] != rangeLow || limits[j][3] != rangeHigh) { fullRangeSeen = FALSE; } buf.append((UnicodeString)" maxima range=" + rangeLow + ".." + rangeHigh); buf.append((UnicodeString)" maxima actual=" + limits[j][2] + ".." + limits[j][3]); if (fullRangeSeen) { logln((UnicodeString)"OK: " + buf); } else { // This may or may not be an error -- if the range of dates // we scan over doesn't happen to contain a minimum or // maximum, it doesn't mean some other range won't. logln((UnicodeString)"Warning: " + buf); } } logln((UnicodeString)"End: " + greg.getTime(status)); }
void procinit(int pid) { char *p; Segment *s; int n, m, sg, i; ulong vastart, vaend; char mfile[128], tfile[128], sfile[1024]; sprint(mfile, "/proc/%d/mem", pid); sprint(tfile, "/proc/%d/text", pid); sprint(sfile, "/proc/%d/segment", pid); text = open(tfile, OREAD); if(text < 0) fatal(1, "open text %s", tfile); inithdr(text); sg = open(sfile, OREAD); if(sg < 0) fatal(1, "open text %s", sfile); n = read(sg, sfile, sizeof(sfile)); if(n >= sizeof(sfile)) fatal(0, "segment file buffer too small"); close(sg); m = open(mfile, OREAD); if(m < 0) fatal(1, "open %s", mfile); initmap(); p = strstr(sfile, "Data"); if(p == 0) fatal(0, "no data"); vastart = strtoul(p+9, 0, 16); vaend = strtoul(p+18, 0, 16); s = &memory.seg[Data]; if(s->base != vastart || s->end != vaend) { s->base = vastart; s->end = vaend; free(s->table); s->table = malloc(((s->end-s->base)/BY2PG)*sizeof(uchar*)); } seginit(m, s, 0, vastart, vaend); p = strstr(sfile, "Bss"); if(p == 0) fatal(0, "no bss"); vastart = strtoul(p+9, 0, 16); vaend = strtoul(p+18, 0, 16); s = &memory.seg[Bss]; if(s->base != vastart || s->end != vaend) { s->base = vastart; s->end = vaend; free(s->table); s->table = malloc(((s->end-s->base)/BY2PG)*sizeof(uchar*)); } seginit(m, s, 0, vastart, vaend); reg.pc = greg(m, REGOFF(pc)); reg.r[1] = greg(m, REGOFF(sp)); reg.r[2] = greg(m, REGOFF(r2)); reg.r[30] = greg(m, REGOFF(r30)); reg.r[31] = greg(m, REGOFF(r31)); for(i = 0; i < 32; i++) reg.r[i] = greg(m, roff[i-1]); s = &memory.seg[Stack]; vastart = reg.r[1] & ~(BY2PG-1); seginit(m, s, (vastart-s->base)/BY2PG, vastart, STACKTOP); close(m); Bprint(bioout, "qi\n"); }