/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ /* ***** BEGIN LICENSE BLOCK ***** * Version: MPL 1.1/GPL 2.0/LGPL 2.1 * * The contents of this file are subject to the Mozilla Public License Version * 1.1 (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * http://www.mozilla.org/MPL/ * * Software distributed under the License is distributed on an "AS IS" basis, * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License * for the specific language governing rights and limitations under the * License. * * The Original Code is the Netscape Portable Runtime (NSPR). * * The Initial Developer of the Original Code is * Netscape Communications Corporation. * Portions created by the Initial Developer are Copyright (C) 1998-2000 * the Initial Developer. All Rights Reserved. * * Contributor(s): * * Alternatively, the contents of this file may be used under the terms of * either the GNU General Public License Version 2 or later (the "GPL"), or * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), * in which case the provisions of the GPL or the LGPL are applicable instead * of those above. If you wish to allow use of your version of this file only * under the terms of either the GPL or the LGPL, and not to allow others to * use your version of this file under the terms of the MPL, indicate your * decision by deleting the provisions above and replace them with the notice * and other provisions required by the GPL or the LGPL. If you do not delete * the provisions above, a recipient may use your version of this file under * the terms of any one of the MPL, the GPL or the LGPL. * * ***** END LICENSE BLOCK ***** */ /* * NCR 3.0 - cloned from UnixWare by ruslan */ #include "primpl.h" #include void _MD_EarlyInit(void) { } PRWord *_MD_HomeGCRegisters(PRThread *t, int isCurrent, int *np) { if (isCurrent) { (void) setjmp(CONTEXT(t)); } *np = sizeof(CONTEXT(t)) / sizeof(PRWord); return (PRWord *) CONTEXT(t); } #ifdef ALARMS_BREAK_TCP /* I don't think they do */ PRInt32 _MD_connect(PRInt32 osfd, const PRNetAddr *addr, PRInt32 addrlen, PRIntervalTime timeout) { PRInt32 rv; _MD_BLOCK_CLOCK_INTERRUPTS(); rv = _connect(osfd,addr,addrlen); _MD_UNBLOCK_CLOCK_INTERRUPTS(); } PRInt32 _MD_accept(PRInt32 osfd, PRNetAddr *addr, PRInt32 addrlen, PRIntervalTime timeout) { PRInt32 rv; _MD_BLOCK_CLOCK_INTERRUPTS(); rv = _accept(osfd,addr,addrlen); _MD_UNBLOCK_CLOCK_INTERRUPTS(); return(rv); } #endif /* * These are also implemented in pratom.c using NSPR locks. Any reason * this might be better or worse? If you like this better, define * _PR_HAVE_ATOMIC_OPS in include/md/unixware.h */ #ifdef _PR_HAVE_ATOMIC_OPS /* Atomic operations */ #include static FILE *_uw_semf; void _MD_INIT_ATOMIC(void) { /* Sigh. Sure wish SYSV semaphores weren't such a pain to use */ if ((_uw_semf = tmpfile()) == NULL) PR_ASSERT(0); return; } void _MD_ATOMIC_INCREMENT(PRInt32 *val) { flockfile(_uw_semf); (*val)++; unflockfile(_uw_semf); } void _MD_ATOMIC_ADD(PRInt32 *ptr, PRInt32 val) { flockfile(_uw_semf); (*ptr) += val; unflockfile(_uw_semf); } void _MD_ATOMIC_DECREMENT(PRInt32 *val) { flockfile(_uw_semf); (*val)--; unflockfile(_uw_semf); } void _MD_ATOMIC_SET(PRInt32 *val, PRInt32 newval) { flockfile(_uw_semf); *val = newval; unflockfile(_uw_semf); } #endif void _MD_SET_PRIORITY(_MDThread *thread, PRUintn newPri) { return; } PRStatus _MD_InitializeThread(PRThread *thread) { return PR_SUCCESS; } PRStatus _MD_WAIT(PRThread *thread, PRIntervalTime ticks) { PR_ASSERT(!(thread->flags & _PR_GLOBAL_SCOPE)); _PR_MD_SWITCH_CONTEXT(thread); return PR_SUCCESS; } PRStatus _MD_WAKEUP_WAITER(PRThread *thread) { if (thread) { PR_ASSERT(!(thread->flags & _PR_GLOBAL_SCOPE)); } return PR_SUCCESS; } /* These functions should not be called for Unixware */ void _MD_YIELD(void) { PR_NOT_REACHED("_MD_YIELD should not be called for Unixware."); } PRStatus _MD_CREATE_THREAD( PRThread *thread, void (*start) (void *), PRUintn priority, PRThreadScope scope, PRThreadState state, PRUint32 stackSize) { PR_NOT_REACHED("_MD_CREATE_THREAD should not be called for Unixware."); return PR_FAILURE; } /* This is temp. replacement for localtime_r. Normally PR_ExplodeTime should be used as to my understanding */ /* ** $$$$$ THEN WHY ARE WE DOING THIS? - AOF $$$$$ */ #define NEED_LOCALTIME_R #define NEED_GMTIME_R #define NEED_ASCTIME_R #define NEED_STRTOK_R #define NEED_CTIME_R #if defined (NEED_LOCALTIME_R) || defined (NEED_CTIME_R) || defined (NEED_ASCTIME_R) || defined (NEED_GMTIME_R) || defined (NEED_STRTOK_R) #include "prlock.h" #endif #if defined (NEED_LOCALTIME_R) static PRLock *localtime_r_monitor = NULL; struct tm *localtime_r (const time_t *clock, struct tm *result) { struct tm *tmPtr; int needLock = PR_Initialized(); /* We need to use a lock to protect * against NSPR threads only when the * NSPR thread system is activated. */ if (needLock) { if (localtime_r_monitor == NULL) { localtime_r_monitor = PR_NewLock(); } PR_Lock(localtime_r_monitor); } /* * On Windows, localtime() returns a NULL pointer if 'clock' * represents a time before midnight January 1, 1970. In * that case, we also return a NULL pointer and the struct tm * object pointed to by 'result' is not modified. */ tmPtr = localtime(clock); if (tmPtr) { *result = *tmPtr; } else { result = NULL; } if (needLock) PR_Unlock(localtime_r_monitor); return result; } #endif #if defined (NEED_GMTIME_R) static PRLock *gmtime_r_monitor = NULL; struct tm *gmtime_r (const time_t *clock, struct tm *result) { struct tm *tmPtr; int needLock = PR_Initialized(); /* We need to use a lock to protect * against NSPR threads only when the * NSPR thread system is activated. */ if (needLock) { if (gmtime_r_monitor == NULL) { gmtime_r_monitor = PR_NewLock(); } PR_Lock(gmtime_r_monitor); } tmPtr = gmtime(clock); if (tmPtr) { *result = *tmPtr; } else { result = NULL; } if (needLock) PR_Unlock(gmtime_r_monitor); return result; } #endif #if defined (NEED_CTIME_R) static PRLock *ctime_r_monitor = NULL; char *ctime_r (const time_t *clock, char *buf, int buflen) { char *cbuf; int needLock = PR_Initialized(); /* We need to use a lock to protect * against NSPR threads only when the * NSPR thread system is activated. */ if (needLock) { if (ctime_r_monitor == NULL) { ctime_r_monitor = PR_NewLock(); } PR_Lock(ctime_r_monitor); } cbuf = ctime (clock); if (cbuf) { strncpy (buf, cbuf, buflen - 1); buf[buflen - 1] = 0; } if (needLock) PR_Unlock(ctime_r_monitor); return cbuf; } #endif #if defined (NEED_ASCTIME_R) static PRLock *asctime_r_monitor = NULL; char *asctime_r (const struct tm *tm, char *buf, int buflen) { char *cbuf; int needLock = PR_Initialized(); /* We need to use a lock to protect * against NSPR threads only when the * NSPR thread system is activated. */ if (needLock) { if (asctime_r_monitor == NULL) { asctime_r_monitor = PR_NewLock(); } PR_Lock(asctime_r_monitor); } cbuf = asctime (tm); if (cbuf) { strncpy (buf, cbuf, buflen - 1); buf[buflen - 1] = 0; } if (needLock) PR_Unlock(asctime_r_monitor); return cbuf; } #endif #if defined (NEED_STRTOK_R) char * strtok_r (s, delim, last) register char *s; register const char *delim; register char **last; { register char *spanp; register int c, sc; char *tok; if (s == NULL && (s = *last) == NULL) return (NULL); /* * Skip (span) leading delimiters (s += strspn(s, delim), sort of). */ cont: c = *s++; for (spanp = (char *)delim; (sc = *spanp++) != 0;) { if (c == sc) goto cont; } if (c == 0) { /* no non-delimiter characters */ *last = NULL; return (NULL); } tok = s - 1; /* * Scan token (scan for delimiters: s += strcspn(s, delim), sort of). * Note that delim must have one NUL; we stop if we see that, too. */ for (;;) { c = *s++; spanp = (char *)delim; do { if ((sc = *spanp++) == c) { if (c == 0) s = NULL; else s[-1] = 0; *last = s; return (tok); } } while (sc != 0); } /* NOTREACHED */ } #endif