diff options
Diffstat (limited to 'src/libs/xpcom18a4/nsprpub/pr/src/md/unix/ncr.c')
-rw-r--r-- | src/libs/xpcom18a4/nsprpub/pr/src/md/unix/ncr.c | 395 |
1 files changed, 395 insertions, 0 deletions
diff --git a/src/libs/xpcom18a4/nsprpub/pr/src/md/unix/ncr.c b/src/libs/xpcom18a4/nsprpub/pr/src/md/unix/ncr.c new file mode 100644 index 00000000..909b09e6 --- /dev/null +++ b/src/libs/xpcom18a4/nsprpub/pr/src/md/unix/ncr.c @@ -0,0 +1,395 @@ +/* -*- 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 <setjmp.h> + +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 <stdio.h> +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 |