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");
}
