// TimeConvB.bcpl -- conversion between packed and unpacked representations. // Requires companion module TimeConvA.asm // Copyright Xerox Corporation 1979 // Last modified December 31, 1977 7:05 PM get "AltoDefs.d" get "Time.d" external [ // Outgoing procedures UNPACKDT; PACKDT; WEEKDAY // Incoming procedures TimeDiv; TimeMul MoveBlock; ReadCalendar; DoubleAdd; SysErr // Incoming statics monthTable; OsVersion ] // The internal format for a calendar date and time // (or simply "daytime") is a 32-bit integer (PTV, packed time vector) // representing seconds relative to midnight, January 1, 1901 GMT. // There is an unpacked format (UTV, unpacked time vector, defined in Time.d) // more suitable for person-oriented I/O: a 7-word vector containing year, // month (January=0), day (first day of month=1), hour, minute, // second, day of week, daylight saving time flag, and time zone information. // Conversion between the two forms is not trivial, since it must deal with // leap years, daylight time, time zones, and lengths of months. // Notes: // (1) This implementation does not need to know the Gregorian calendar // rule whereby years divisible by 100 aren't leap years unless also divisible // by 400. This is because the Alto calendar only spans the years // 1901 to 2036, and the year 2000 is a leap year. // (2) This version of the code is intended to work whether or not the // local time parameters are available. If they aren't, // we assume that the local time zone is 8 (Pacific Standard). This // compatibility code should be removed eventually. It is marked by "****". //---------------------------------------------------------------------------- structure ULT: // Unpacked Local Time information //---------------------------------------------------------------------------- // UNPACKDT and PACKDT know about the order of these words. Beware! [ beginDST word // Day of year on or before which DST starts endDST word // Day of year on or before which DST ends zone: // Local time zone -- format same as in UTV structure [ blank bit 5 sign bit 1 hour bit 4 minute bit 6 ] compZone word // Composite zone: minutes west (+) or east (-) of GMT ] manifest ecOSVersion = 2900 // Error code for OS older than version 14 //---------------------------------------------------------------------------- let UNPACKDT(ptv, utv) = valof //---------------------------------------------------------------------------- // Unpacks 32-bit time at ptv into UTV structure (see Time.d). // If ptv is 0, uses current date and time. [ // Set up local time parameters let beginDST, endDST, zone, compZone = nil, nil, nil, nil SetupULT(lv beginDST, 0) utv>>UTV.word6 = 0 utv>>UTV.zone = zone // Get or default packed time let pv = vec 2 test ptv eq 0 ifso ReadCalendar(pv) ifnot MoveBlock(pv, ptv, 2) // Unpack second straightforwardly utv>>UTV.second = TimeDiv(pv, 60, pv) // pv now has number of minutes since Jan 1, 1901. // At this point, apply the local time zone by subtracting it from pv. // Since this may cause the result to underflow, also add 4 years' worth // of minutes so as to make it positive again, thereby making day zero be // Jan 1, 1897. (We ignore the fact that 1900 was not a leap year). // Note that compZone is in the range [-720..720] let tv = vec 2 tv!0, tv!1 = 32, 6688-compZone // 4 years = 2103840 = 32*2^16 + 6688 minutes DoubleAdd(pv, tv) // Now unpack minute utv>>UTV.minute = TimeDiv(pv, 60, pv) // Go around this loop twice if daylight savings time must be applied. for i = 0 to 1 do [ // Now unpack hour in day let pv2 = vec 2 utv>>UTV.hour = TimeDiv(pv, 24, pv2) // pv2!1 has days since Jan 1, 1897. Compute day of week. // Jan 1, 1897 would have been a Thursday (=3) if 1900 were a leap year. tv!0, tv!1 = 0, pv2!1 + 3 utv>>UTV.weekday = TimeDiv(tv, 7, tv) // Unpack 4-year cycles and day within cycle, and normalize day to // 366-day years. let day = TimeDiv(pv2, 3*365+366, pv2) day = day + (day ge 3*365+31+28? 3, (day+(365-31-28))/365) // pv2!1 now has number of 4-year cycles since Jan 1, 1897. // Compute real year and day in year. utv>>UTV.year = 1897 + 4*pv2!1 + day/366 day = day rem 366 // Compute month and day in month let month = 0 while day ge monthTable!(month+1) do month = month+1 utv>>UTV.month = month utv>>UTV.day = day - monthTable!month +1 // If daylight savings time applies, add one hour and go around // the loop again. Note that daylight savings time goes into effect at // 2 AM standard time and out of effect at 2 AM daylight time, which is // 1 AM standard time (standard time is what utv presently contains). if not CheckDateGE(utv, beginDST, 2) % CheckDateGE(utv, endDST, 1) break utv>>UTV.daylight = true DoubleAdd(pv, table [ 0; 1 ]) ] resultis utv ] //---------------------------------------------------------------------------- and PACKDT(utv, ptv, useWord6; numargs na) = valof //---------------------------------------------------------------------------- // Packs the time described by utv into a 32-bit time, returning zero if // successful and the index of the incorrect UTV cell if unsuccessful. // If useWord6 then uses the zone and daylight information in word 6 of utv; // otherwise ignores it and uses the local time zone and computes DST on the // basis of the date in utv. Recomputes the weekday field unconditionally. [ if na ls 3 then useWord6 = false // Setup local time parameters let beginDST, endDST, zone, compZone = nil, nil, nil, nil SetupULT(lv beginDST, (useWord6? utv, 0)) // Test validity of unpacked form let year, month, day = utv>>UTV.year-1901, utv>>UTV.month, utv>>UTV.day let hour, minute, second = utv>>UTV.hour, utv>>UTV.minute, utv>>UTV.second if year ls 0 % year ge 136 resultis iYear let year4 = year & 3 // year rem 4 -- position in 4-year cycle if month ls 0 % month ge 12 resultis iMonth if day ls 1 % day gr monthTable!(month+1)-monthTable!month % (month eq 1 & day eq 29 & year4 ne 3) resultis iDay if hour ls 0 % hour ge 24 resultis iHour if minute ls 0 % minute ge 60 resultis iMinute if second ls 0 % second ge 60 resultis iSecond // Compute days since January 1, 1897, local time. It will be corrected to // January 1, 1901 later (see below for reason). day = ((year+4)/4)*(3*365+366) + // Days in previous 4-year cycles 365*year4 + // Days in this 4-year cycle monthTable!month + // Days in previous months this year day - // Days in this month (year4 ne 3 & month ge 2? 2, 1) // Correction for leap year // Compute weekday for DST check. // Note that January 1, 1897 was a Thursday (=3). ptv!0, ptv!1 = 0, day+3 let tv = vec 2 utv>>UTV.weekday = TimeDiv(ptv, 7, tv) // Compute minutes since January 1, 1897, local time. ptv!1 = day TimeMul(hour, 24, ptv) TimeMul(minute, 60, ptv) // Apply time zone correction (convert to GMT) by adding local time zone. // Simultaneously, subtract 4 years' worth of minutes to correct the origin // from 1897 to 1901. This forces the sign of the added quantity always // to be negative. Note that compZone is in the range [-720..720] tv!0, tv!1 = -32-1, compZone-6688 // High part must be ones-complement // If daylight savings time is now applicable, subtract one hour to convert // to standard time. if (useWord6? utv>>UTV.daylight, CheckDateGE(utv, beginDST, 2) & not CheckDateGE(utv, endDST, 2)) then tv!1 = tv!1 -60 DoubleAdd(ptv, tv) // Pack seconds and we are finished TimeMul(second, 60, ptv) resultis 0 ] //---------------------------------------------------------------------------- and WEEKDAY(ptv) = valof //---------------------------------------------------------------------------- // Returns the day of week of the packed daytime in ptv. [ let utv = vec lenUTV UNPACKDT(ptv, utv) resultis utv>>UTV.weekday ] //---------------------------------------------------------------------------- and CheckDateGE(utv, dstDay, dstHour) = valof //---------------------------------------------------------------------------- // Returns true if the current time is greater than or equal to the // specified DST time and false otherwise. // utv = unpacked time vector describing current date and time // (month, day, hour, and weekday fields must be valid) // dstDay = day on or before which DST switch occurs // dstHour = hour at which DST switch occurs [ let day = monthTable!(utv>>UTV.month) + utv>>UTV.day let weekday = utv>>UTV.weekday resultis (day ls dstDay-6? false, day gr dstDay? true, weekday eq 6? utv>>UTV.hour ge dstHour, day-weekday gr dstDay-6) ] //---------------------------------------------------------------------------- and SetupULT(ult, utv) be //---------------------------------------------------------------------------- // Sets up unpacked local time information for use by UNPACKDT and PACKDT. // Stores results in ult (see ULT structure for contents). // If utv is nonzero, uses it (rather than 570) to supply the local time zone. // **** Defaults time information to Pacific if unavailable from system. [ if OsVersion ls 14 then SysErr(0, ecOSVersion) // Extract or default time parameters test timeParams!0 eq 0 % timeParams!1 eq 0 ifnot [ ult>>ULT.beginDST = timeParams>>LTP.beginDST ult>>ULT.endDST = timeParams>>LTP.endDST ult>>ULT.zone.sign = timeParams>>LTP.sign ult>>ULT.zone.hour = timeParams>>LTP.zoneH ult>>ULT.zone.minute = timeParams>>LTP.zoneM ] ifso [ // **** Default them if not present ult>>ULT.beginDST, ult>>ULT.endDST = 121, 305 ult>>ULT.zone = 8 lshift size ULT.zone.minute ] // **** if utv ne 0 then ult>>ULT.zone = utv>>UTV.zone // Compute composite zone -- minutes west (+) or east (-) of GMT ult>>ULT.compZone = 60*(ult>>ULT.zone.hour) + ult>>ULT.zone.minute if ult>>ULT.zone.sign ne 0 then ult>>ULT.compZone = -(ult>>ULT.compZone) ]