PRInt32
_PR_MD_GETFILEINFO(const char *fn, PRFileInfo *info)
{
struct stat sb;
PRInt32 rv;
PRInt64 s, s2us;
if ( (rv = _PR_MD_STAT(fn, &sb)) == 0 ) {
if (info) {
if (S_IFREG & sb.st_mode)
info->type = PR_FILE_FILE ;
else if (S_IFDIR & sb.st_mode)
info->type = PR_FILE_DIRECTORY;
else
info->type = PR_FILE_OTHER;
info->size = sb.st_size;
LL_I2L(s2us, PR_USEC_PER_SEC);
LL_I2L(s, sb.st_mtime);
LL_MUL(s, s, s2us);
info->modifyTime = s;
LL_I2L(s, sb.st_ctime);
LL_MUL(s, s, s2us);
info->creationTime = s;
}
}
return rv;
}
static SECCertTimeValidity _NSSCPY_CheckCrlTimes(CERTCrl *crl, PRTime t)
{
PRTime notBefore, notAfter, llPendingSlop, tmp1;
SECStatus rv;
PRInt32 pSlop = CERT_GetSlopTime();
rv = _NSSCPY_GetCrlTimes(crl, ¬Before, ¬After);
if (rv) {
return(secCertTimeExpired);
}
LL_I2L(llPendingSlop, pSlop);
/* convert to micro seconds */
LL_I2L(tmp1, PR_USEC_PER_SEC);
LL_MUL(llPendingSlop, llPendingSlop, tmp1);
LL_SUB(notBefore, notBefore, llPendingSlop);
if ( LL_CMP( t, <, notBefore ) ) {
return(secCertTimeNotValidYet);
}
/* If next update is omitted and the test for notBefore passes, then
* we assume that the crl is up to date.
*/
if ( LL_IS_ZERO(notAfter) ) {
return(secCertTimeValid);
}
if ( LL_CMP( t, >, notAfter) ) {
return(secCertTimeExpired);
}
return(secCertTimeValid);
}
PRMJ_ToExtendedTime(PRInt32 time)
{
PRInt64 exttime;
PRInt64 g1970GMTMicroSeconds;
PRInt64 low;
time_t diff;
PRInt64 tmp;
PRInt64 tmp1;
diff = PRMJ_LocalGMTDifference();
LL_UI2L(tmp, PRMJ_USEC_PER_SEC);
LL_I2L(tmp1,diff);
LL_MUL(tmp,tmp,tmp1);
LL_UI2L(g1970GMTMicroSeconds,G1970GMTMICROHI);
LL_UI2L(low,G1970GMTMICROLOW);
#ifndef HAVE_LONG_LONG
LL_SHL(g1970GMTMicroSeconds,g1970GMTMicroSeconds,16);
LL_SHL(g1970GMTMicroSeconds,g1970GMTMicroSeconds,16);
#else
LL_SHL(g1970GMTMicroSeconds,g1970GMTMicroSeconds,32);
#endif
LL_ADD(g1970GMTMicroSeconds,g1970GMTMicroSeconds,low);
LL_I2L(exttime,time);
LL_ADD(exttime,exttime,g1970GMTMicroSeconds);
LL_SUB(exttime,exttime,tmp);
return exttime;
}
static PRTime SecondsToPRTime(uint32_t t_sec)
{
PRTime t_usec, usec_per_sec;
LL_I2L(t_usec, t_sec);
LL_I2L(usec_per_sec, PR_USEC_PER_SEC);
t_usec *= usec_per_sec;
return t_usec;
}
static PRTime SecondsToPRTime(PRUint32 t_sec)
{
PRTime t_usec, usec_per_sec;
LL_I2L(t_usec, t_sec);
LL_I2L(usec_per_sec, PR_USEC_PER_SEC);
LL_MUL(t_usec, t_usec, usec_per_sec);
return t_usec;
}
static PRInt64 PR_CALLBACK SocketAvailable64(PRFileDesc *fd)
{
PRInt64 rv;
#ifdef _PR_HAVE_PEEK_BUFFER
if (fd->secret->peekBytes != 0) {
LL_I2L(rv, fd->secret->peekBytes);
return rv;
}
#endif
LL_I2L(rv, _PR_MD_SOCKETAVAILABLE(fd));
return rv;
}
static PRIntn PR_CALLBACK RealMain(PRIntn argc, char **argv)
{
Overlay_i si;
Overlay_u ui;
PLOptStatus os;
PRBool bsi = PR_FALSE, bui = PR_FALSE;
PLOptState *opt = PL_CreateOptState(argc, argv, "hi:u:");
err = PR_GetSpecialFD(PR_StandardError);
while (PL_OPT_EOL != (os = PL_GetNextOpt(opt)))
{
if (PL_OPT_BAD == os) continue;
switch (opt->option)
{
case 'i': /* signed integer */
si.i = (PRInt32)atoi(opt->value);
bsi = PR_TRUE;
break;
case 'u': /* unsigned */
ui.i = (PRUint32)atoi(opt->value);
bui = PR_TRUE;
break;
case 'h': /* user wants some guidance */
default:
Help(); /* so give him an earful */
return 2; /* but not a lot else */
}
}
PL_DestroyOptState(opt);
#if defined(HAVE_LONG_LONG)
PR_fprintf(err, "We have long long\n");
#else
PR_fprintf(err, "We don't have long long\n");
#endif
if (bsi)
{
PR_fprintf(err, "Converting %ld: ", si.i);
LL_I2L(si.l, si.i);
PR_fprintf(err, "%lld\n", si.l);
}
if (bui)
{
PR_fprintf(err, "Converting %lu: ", ui.i);
LL_I2L(ui.l, ui.i);
PR_fprintf(err, "%llu\n", ui.l);
}
return 0;
} /* main */
PR_Now(void)
{
PRInt64 s, ms, ms2us, s2us;
struct timeb b;
ftime(&b);
LL_I2L(ms2us, PR_USEC_PER_MSEC);
LL_I2L(s2us, PR_USEC_PER_SEC);
LL_I2L(s, b.time);
LL_I2L(ms, b.millitm);
LL_MUL(ms, ms, ms2us);
LL_MUL(s, s, s2us);
LL_ADD(s, s, ms);
return s;
}
static void TestIntervals(void)
{
PRStatus rv;
PRUint32 delta;
PRInt32 seconds;
PRUint64 elapsed, thousand;
PRTime timein, timeout;
PRLock *ml = PR_NewLock();
PRCondVar *cv = PR_NewCondVar(ml);
for (seconds = 0; seconds < 10; ++seconds)
{
PRIntervalTime ticks = PR_SecondsToInterval(seconds);
PR_Lock(ml);
timein = PR_Now();
rv = PR_WaitCondVar(cv, ticks);
timeout = PR_Now();
PR_Unlock(ml);
LL_SUB(elapsed, timeout, timein);
LL_I2L(thousand, 1000);
LL_DIV(elapsed, elapsed, thousand);
LL_L2UI(delta, elapsed);
if (debug_mode) PR_fprintf(output,
"TestIntervals: %swaiting %ld seconds took %ld msecs\n",
((rv == PR_SUCCESS) ? "" : "FAILED "), seconds, delta);
}
PR_DestroyCondVar(cv);
PR_DestroyLock(ml);
if (debug_mode) PR_fprintf(output, "\n");
} /* TestIntervals */
/* PRBool getProperty (in nsIXPConnectWrappedNative wrapper, in JSContextPtr cx, in JSObjectPtr obj, in JSVal id, in JSValPtr vp); */
NS_IMETHODIMP
calDateTime::GetProperty(nsIXPConnectWrappedNative *wrapper, JSContext * cx,
JSObject * obj_, jsval id, jsval * vp, PRBool *_retval)
{
NS_ENSURE_ARG_POINTER(vp);
NS_ENSURE_ARG_POINTER(_retval);
if (JSVAL_IS_STRING(id)) {
nsDependentString const jsid(
reinterpret_cast<PRUnichar const*>(
JS_GetStringChars(JSVAL_TO_STRING(id))),
JS_GetStringLength(JSVAL_TO_STRING(id)));
if (jsid.EqualsLiteral("jsDate")) {
PRTime tmp, thousand;
jsdouble msec;
LL_I2L(thousand, 1000);
LL_DIV(tmp, mNativeTime, thousand);
LL_L2D(msec, tmp);
JSObject *obj;
PRBool b;
if (NS_SUCCEEDED(mTimezone->GetIsFloating(&b)) && b)
obj = js_NewDateObject(cx, mYear, mMonth, mDay, mHour, mMinute, mSecond);
else
obj = js_NewDateObjectMsec(cx, msec);
*vp = OBJECT_TO_JSVAL(obj);
*_retval = PR_TRUE;
return NS_SUCCESS_I_DID_SOMETHING;
}
}
*_retval = PR_TRUE;
return NS_OK;
}
PRTime
rdf_ParseDate(const nsACString &aTime)
{
PRTime t;
PR_ParseTimeString(PromiseFlatCString(aTime).get(), PR_TRUE, &t);
PRInt32 usec = 0;
nsACString::const_iterator begin, digit, end;
aTime.BeginReading(begin);
aTime.EndReading(end);
// Walk backwards until we find a `+', run out of string, or a
// non-numeric character.
digit = end;
while (--digit != begin && *digit != '+') {
if (*digit < '0' || *digit > '9')
break;
}
if (digit != begin && *digit == '+') {
// There's a usec field specified (or, at least, something
// that looks close enough. Parse it, and add it to the time.
while (++digit != end) {
usec *= 10;
usec += *digit - '0';
}
PRTime temp;
LL_I2L(temp, usec);
LL_ADD(t, t, temp);
}
return t;
}
//----------------------------------------------------------------------------------------
PRInt64 nsFileSpec::GetDiskSpaceAvailable() const
//----------------------------------------------------------------------------------------
{
PRInt64 bytes; /* XXX dougt needs to fix this */
LL_I2L(bytes , LONG_MAX); // initialize to all the space in the world?
#if defined(HAVE_SYS_STATFS_H) || defined(HAVE_SYS_STATVFS_H)
char curdir [MAXPATHLEN];
if (mPath.IsEmpty())
{
(void) getcwd(curdir, MAXPATHLEN);
if (!curdir)
return bytes; /* hope for the best as we did in cheddar */
}
else
sprintf(curdir, "%.200s", (const char*)mPath);
struct STATFS fs_buf;
#if defined(__QNX__) && !defined(HAVE_STATVFS) /* Maybe this should be handled differently? */
if (STATFS(curdir, &fs_buf, 0, 0) < 0)
#else
if (STATFS(curdir, &fs_buf) < 0)
#endif
return bytes; /* hope for the best as we did in cheddar */
#ifdef DEBUG_DISK_SPACE
printf("DiskSpaceAvailable: %d bytes\n",
fs_buf.f_bsize * (fs_buf.f_bavail - 1));
#endif
PRInt64 bsize,bavail;
LL_I2L( bsize, fs_buf.f_bsize );
LL_I2L( bavail, fs_buf.f_bavail - 1 );
LL_MUL( bytes, bsize, bavail );
return bytes;
#else
/*
** This platform doesn't have statfs or statvfs, so we don't have much
** choice but to "hope for the best as we did in cheddar".
*/
return bytes;
#endif /* HAVE_SYS_STATFS_H or HAVE_SYS_STATVFS_H */
} // nsFileSpec::GetDiskSpace()
PRInt64 _PR_InvalidInt64(void)
{
PRInt64 rv;
LL_I2L(rv, -1);
PR_NOT_REACHED("I/O method is invalid");
PR_SetError(PR_INVALID_METHOD_ERROR, 0);
return rv;
} /* _PR_InvalidInt */
int main() {
PRInt16 i16;
PRIntn n;
PRInt32 i32;
PRInt64 i64;
char buf[BUF_SIZE];
char answer[BUF_SIZE];
int i, rv = 0;
i16 = -1;
n = -1;
i32 = -1;
LL_I2L(i64, i32);
PR_snprintf(buf, BUF_SIZE, "%hx %x %lx %llx", i16, n, i32, i64);
strcpy(answer, "ffff ");
for (i = PR_BYTES_PER_INT * 2; i; i--) {
strcat(answer, "f");
}
strcat(answer, " ffffffff ffffffffffffffff");
if (!strcmp(buf, answer)) {
printf("PR_snprintf test 1 passed\n");
} else {
printf("PR_snprintf test 1 failed\n");
printf("Converted string is %s\n", buf);
printf("Should be %s\n", answer);
rv = 1;
}
i16 = -32;
n = 30;
i32 = 64;
LL_I2L(i64, 333);
PR_snprintf(buf, BUF_SIZE, "%d %hd %lld %ld", n, i16, i64, i32);
if (!strcmp(buf, "30 -32 333 64")) {
printf("PR_snprintf test 2 passed\n");
} else {
printf("PR_snprintf test 2 failed\n");
printf("Converted string is %s\n", buf);
printf("Should be 30 -32 333 64\n");
rv = 1;
}
return rv;
}
/*
* Determine if the token is logged in. We have to actually query the token,
* because it's state can change without intervention from us.
*/
PRBool
PK11_IsLoggedIn(PK11SlotInfo *slot,void *wincx)
{
CK_SESSION_INFO sessionInfo;
int askpw = slot->askpw;
int timeout = slot->timeout;
CK_RV crv;
PRIntervalTime curTime;
static PRIntervalTime login_delay_time = 0;
if (login_delay_time == 0) {
login_delay_time = PR_SecondsToInterval(1);
}
/* If we don't have our own password default values, use the system
* ones */
if ((slot->defaultFlags & PK11_OWN_PW_DEFAULTS) == 0) {
PK11SlotInfo *def_slot = PK11_GetInternalKeySlot();
if (def_slot) {
askpw = def_slot->askpw;
timeout = def_slot->timeout;
PK11_FreeSlot(def_slot);
}
}
if ((wincx != NULL) && (PK11_Global.isLoggedIn != NULL) &&
(*PK11_Global.isLoggedIn)(slot, wincx) == PR_FALSE) { return PR_FALSE; }
/* forget the password if we've been inactive too long */
if (askpw == 1) {
int64 currtime = PR_Now();
int64 result;
int64 mult;
LL_I2L(result, timeout);
LL_I2L(mult, 60*1000*1000);
LL_MUL(result,result,mult);
LL_ADD(result, result, slot->authTime);
if (LL_CMP(result, <, currtime) ) {
PK11_EnterSlotMonitor(slot);
PK11_GETTAB(slot)->C_Logout(slot->session);
slot->lastLoginCheck = 0;
PK11_ExitSlotMonitor(slot);
} else {
static void
testParseTimeString(PRTime t)
{
PRExplodedTime et;
PRTime t2;
char timeString[128];
char buf[128];
PRInt32 totalOffset;
PRInt32 hourOffset, minOffset;
const char *sign;
PRInt64 usec_per_sec;
/* Truncate the microsecond part of PRTime */
LL_I2L(usec_per_sec, PR_USEC_PER_SEC);
LL_DIV(t, t, usec_per_sec);
LL_MUL(t, t, usec_per_sec);
PR_ExplodeTime(t, PR_LocalTimeParameters, &et);
/* Print day of the week, month, day, hour, minute, and second */
PR_snprintf(timeString, 128, "%s %s %ld %02ld:%02ld:%02ld ",
dayOfWeek[et.tm_wday], month[et.tm_month], et.tm_mday,
et.tm_hour, et.tm_min, et.tm_sec);
/* Print time zone */
totalOffset = et.tm_params.tp_gmt_offset + et.tm_params.tp_dst_offset;
if (totalOffset == 0) {
strcat(timeString, "GMT "); /* I wanted to use "UTC" here, but
* PR_ParseTimeString doesn't
* understand "UTC". */
} else {
sign = "+";
if (totalOffset < 0) {
totalOffset = -totalOffset;
sign = "-";
}
hourOffset = totalOffset / 3600;
minOffset = (totalOffset % 3600) / 60;
PR_snprintf(buf, 128, "%s%02ld%02ld ", sign, hourOffset, minOffset);
strcat(timeString, buf);
}
/* Print year */
PR_snprintf(buf, 128, "%hd", et.tm_year);
strcat(timeString, buf);
if (PR_ParseTimeString(timeString, PR_FALSE, &t2) == PR_FAILURE) {
fprintf(stderr, "PR_ParseTimeString() failed\n");
exit(1);
}
if (LL_NE(t, t2)) {
fprintf(stderr, "PR_ParseTimeString() incorrect\n");
PR_snprintf(buf, 128, "t is %lld, t2 is %lld, time string is %s\n",
t, t2, timeString);
fprintf(stderr, "%s\n", buf);
exit(1);
}
}
static PRUint32
NowInMinutes()
{
PRTime now = PR_Now(), minutes, factor;
LL_I2L(factor, 60 * PR_USEC_PER_SEC);
LL_DIV(minutes, now, factor);
PRUint32 result;
LL_L2UI(result, minutes);
return result;
}
static inline PRUint32
PRTimeToSeconds(PRTime t_usec)
{
PRTime usec_per_sec;
PRUint32 t_sec;
LL_I2L(usec_per_sec, PR_USEC_PER_SEC);
LL_DIV(t_usec, t_usec, usec_per_sec);
LL_L2I(t_sec, t_usec);
return t_sec;
}
nsresult
nsSafariProfileMigrator::CopyHistoryBatched(bool aReplace)
{
nsCOMPtr<nsIProperties> fileLocator(do_GetService(NS_DIRECTORY_SERVICE_CONTRACTID));
nsCOMPtr<nsILocalFile> safariHistoryFile;
fileLocator->Get(NS_MAC_USER_LIB_DIR, NS_GET_IID(nsILocalFile),
getter_AddRefs(safariHistoryFile));
safariHistoryFile->Append(NS_LITERAL_STRING("Safari"));
safariHistoryFile->Append(SAFARI_HISTORY_FILE_NAME);
CFDictionaryRef safariHistory =
static_cast<CFDictionaryRef>(CopyPListFromFile(safariHistoryFile));
if (!safariHistory)
return NS_OK;
if (!::CFDictionaryContainsKey(safariHistory, CFSTR("WebHistoryDates"))) {
::CFRelease(safariHistory);
return NS_OK;
}
nsCOMPtr<nsIBrowserHistory> history(do_GetService(NS_GLOBALHISTORY2_CONTRACTID));
CFArrayRef children = (CFArrayRef)
::CFDictionaryGetValue(safariHistory, CFSTR("WebHistoryDates"));
if (children) {
CFIndex count = ::CFArrayGetCount(children);
for (PRInt32 i = 0; i < count; ++i) {
CFDictionaryRef entry = (CFDictionaryRef)::CFArrayGetValueAtIndex(children, i);
CFStringRef lastVisitedDate = (CFStringRef)
::CFDictionaryGetValue(entry, CFSTR("lastVisitedDate"));
nsAutoString url, title;
if (GetDictionaryStringValue(entry, CFSTR(""), url) &&
GetDictionaryStringValue(entry, CFSTR("title"), title) &&
lastVisitedDate) {
double lvd = ::CFStringGetDoubleValue(lastVisitedDate) + SAFARI_DATE_OFFSET;
PRTime lastVisitTime;
PRInt64 temp, million;
LL_D2L(temp, lvd);
LL_I2L(million, PR_USEC_PER_SEC);
LL_MUL(lastVisitTime, temp, million);
nsCOMPtr<nsIURI> uri;
NS_NewURI(getter_AddRefs(uri), url);
if (uri)
history->AddPageWithDetails(uri, title.get(), lastVisitTime);
}
}
}
::CFRelease(safariHistory);
return NS_OK;
}
PRInt32
_PR_MD_GETOPENFILEINFO(const PRFileDesc *fd, PRFileInfo *info)
{
/* For once, the VAC compiler/library did a nice thing.
* The file handle used by the C runtime is the same one
* returned by the OS when you call DosOpen(). This means
* that you can take an OS HFILE and use it with C file
* functions. The only caveat is that you have to call
* _setmode() first to initialize some junk. This is
* immensely useful because I did not have a clue how to
* implement this function otherwise. The windows folks
* took the source from the Microsoft C library source, but
* IBM wasn't kind enough to ship the source with VAC.
* On second thought, the needed function could probably
* be gotten from the OS/2 GNU library source, but the
* point is now moot.
*/
struct stat hinfo;
PRInt64 s, s2us;
_setmode(fd->secret->md.osfd, O_BINARY);
if(fstat((int)fd->secret->md.osfd, &hinfo) != NO_ERROR) {
_PR_MD_MAP_FSTAT_ERROR(errno);
return -1;
}
if (hinfo.st_mode & S_IFDIR)
info->type = PR_FILE_DIRECTORY;
else
info->type = PR_FILE_FILE;
info->size = hinfo.st_size;
LL_I2L(s2us, PR_USEC_PER_SEC);
LL_I2L(s, hinfo.st_mtime);
LL_MUL(s, s, s2us);
info->modifyTime = s;
LL_I2L(s, hinfo.st_ctime);
LL_MUL(s, s, s2us);
info->creationTime = s;
return 0;
}
static void TestNowOverhead(void)
{
PRTime timeout, timein;
PRInt32 overhead, loops = 1000000;
PRInt64 elapsed, per_call, ten23rd, ten26th;
LL_I2L(ten23rd, 1000);
LL_I2L(ten26th, 1000000);
timein = PR_Now();
while (--loops > 0)
timeout = PR_Now();
LL_SUB(elapsed, timeout, timein);
LL_MUL(elapsed, elapsed, ten23rd);
LL_DIV(per_call, elapsed, ten26th);
LL_L2I(overhead, per_call);
PR_fprintf(
output, "Overhead of 'PR_Now()' is %u nsecs\n\n", overhead);
} /* TestNowOverhead */
PRTime
PRTimeFromSeconds(uint32_t seconds)
{
int64_t microSecondsPerSecond, intermediateResult;
PRTime prTime;
LL_I2L(microSecondsPerSecond, PR_USEC_PER_SEC);
LL_UI2L(intermediateResult, seconds);
prTime = intermediateResult * microSecondsPerSecond;
return prTime;
}
uint32_t
SecondsFromPRTime(PRTime prTime)
{
int64_t microSecondsPerSecond, intermediateResult;
uint32_t seconds;
LL_I2L(microSecondsPerSecond, PR_USEC_PER_SEC);
intermediateResult = prTime / microSecondsPerSecond;
LL_L2UI(seconds, intermediateResult);
return seconds;
}
static int _amigaos_convert_stat_to_fileinfo64(const struct stat *sb, PRFileInfo64 *info)
{
if (_IFREG & sb->st_mode)
info->type = PR_FILE_FILE;
else if (_IFDIR & sb->st_mode)
info->type = PR_FILE_DIRECTORY;
else
info->type = PR_FILE_OTHER;
LL_I2L(info->size, sb->st_size);
info->creationTime = (PRTime)sb->st_ctime * 1000;
info->modifyTime = (PRTime)sb->st_mtime * 1000;
return 0;
}
static void timePRTime32(void)
{
PRInt32 index = count;
PRInt32 rv32;
PRTime q;
PRTime rv;
LL_I2L(q, 1000000);
for (;index--;) {
rv = PR_Now();
LL_DIV(rv, rv, q);
LL_L2I(rv32, rv);
}
}
static PRInt64 PR_CALLBACK FileAvailable64(PRFileDesc *fd)
{
PRInt64 result, cur, end;
PRInt64 minus_one;
LL_I2L(minus_one, -1);
cur = _PR_MD_LSEEK64(fd, LL_ZERO, PR_SEEK_CUR);
if (LL_GE_ZERO(cur))
end = _PR_MD_LSEEK64(fd, LL_ZERO, PR_SEEK_END);
if (!LL_GE_ZERO(cur) || !LL_GE_ZERO(end)) return minus_one;
LL_SUB(result, end, cur);
(void)_PR_MD_LSEEK64(fd, cur, PR_SEEK_SET);
return result;
}
/* returns an unsigned int containing the number of seconds in PR_Now() */
PRUint32
ssl_Time(void)
{
PRUint32 myTime;
#if (defined(XP_UNIX) || defined(XP_WIN) || defined(_WINDOWS) || defined(XP_BEOS)) && !defined(_WIN32_WCE)
myTime = time(NULL); /* accurate until the year 2038. */
#else
/* portable, but possibly slower */
PRTime now;
PRInt64 ll;
now = PR_Now();
LL_I2L(ll, 1000000L);
LL_DIV(now, now, ll);
LL_L2UI(myTime, now);
#endif
return myTime;
}
PRUint32 nsMailDatabase::GetMailboxModDate()
{
PRUint32 retModTime = 0;
PRInt64 lastModTime;
if (m_folderFile)
{
nsresult rv = m_folderFile->GetLastModifiedTime(&lastModTime);
if (NS_SUCCEEDED(rv))
{
PRTime temp64;
PRInt64 thousand;
LL_I2L(thousand, PR_MSEC_PER_SEC);
LL_DIV(temp64, lastModTime, thousand);
LL_L2UI(retModTime, temp64);
}
}
return retModTime;
}
/*
** Convert a 64-bit integer into its printable form
*/
static int cvt_ll(SprintfState *ss, PRInt64 num, int width, int prec, int radix,
int type, int flags, const char *hexp)
{
char cvtbuf[100];
char *cvt;
int digits;
PRInt64 rad;
/* according to the man page this needs to happen */
if ((prec == 0) && (LL_IS_ZERO(num))) {
return 0;
}
/*
** Converting decimal is a little tricky. In the unsigned case we
** need to stop when we hit 10 digits. In the signed case, we can
** stop when the number is zero.
*/
LL_I2L(rad, radix);
cvt = cvtbuf + sizeof(cvtbuf);
digits = 0;
while (!LL_IS_ZERO(num)) {
PRInt32 digit;
PRInt64 quot, rem;
LL_UDIVMOD(", &rem, num, rad);
LL_L2I(digit, rem);
*--cvt = hexp[digit & 0xf];
digits++;
num = quot;
}
if (digits == 0) {
*--cvt = '0';
digits++;
}
/*
** Now that we have the number converted without its sign, deal with
** the sign and zero padding.
*/
return fill_n(ss, cvt, digits, width, prec, type, flags);
}
PRMJ_DSTOffset(PRInt64 time)
{
PRInt64 us2s;
#ifdef XP_MAC
MachineLocation machineLocation;
PRInt64 dlsOffset;
/* Get the information about the local machine, including
* its GMT offset and its daylight savings time info.
* Convert each into wides that we can add to
* startupTimeMicroSeconds.
*/
MyReadLocation(&machineLocation);
/* Is Daylight Savings On? If so, we need to add an hour to the offset. */
if (machineLocation.u.dlsDelta != 0) {
LL_UI2L(us2s, PRMJ_USEC_PER_SEC); /* seconds in a microseconds */
LL_UI2L(dlsOffset, PRMJ_HOUR_SECONDS); /* seconds in one hour */
LL_MUL(dlsOffset, dlsOffset, us2s);
}
else
LL_I2L(dlsOffset, 0);
return(dlsOffset);
#else
time_t local;
PRInt32 diff;
PRInt64 maxtimet;
struct tm tm;
#if defined( XP_PC ) || defined( FREEBSD )
struct tm *ptm;
#endif
PRMJTime prtm;
LL_UI2L(us2s, PRMJ_USEC_PER_SEC);
LL_DIV(time, time, us2s);
/* get the maximum of time_t value */
LL_UI2L(maxtimet,PRMJ_MAX_UNIX_TIMET);
if(LL_CMP(time,>,maxtimet)){
LL_UI2L(time,PRMJ_MAX_UNIX_TIMET);
} else if(!LL_GE_ZERO(time)){
