/* -*- 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
syntax highlighted by Code2HTML, v. 0.9.1