mirror of https://github.com/lianthony/NT4.0
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
115 lines
3.3 KiB
115 lines
3.3 KiB
/* waitfor.c, /appletalk/source, Garth Conboy, 10/04/88 */
|
|
/* Copyright (c) 1988 by Pacer Software Inc., La Jolla, CA */
|
|
|
|
/* GC - Initial coding.
|
|
GC - (08/18/90): New error logging mechanism.
|
|
GC - (09/17/90): Corrected "timeb.h" installation path for Unix.
|
|
GC - (03/29/92): "stopFlag" is now volatile, so we can sample it
|
|
in the wait loop without worrying about optimizing
|
|
compilers.
|
|
GC - (03/29/92): Added some verbiage in the CPU-bound loop in
|
|
WaitFor about sharing processing with other operations.
|
|
|
|
*** Make the PVCS source control system happy:
|
|
$Header$
|
|
$Log$
|
|
***
|
|
|
|
Our timer handling only allows granularity of full seconds, if we need
|
|
to pasue for some number for 1/100s of a second, this routine will do
|
|
the deed. The routine is compute bound, so should be used very sparingly.
|
|
|
|
We are passed the address of a "Boolean", if that address becomes "True"
|
|
before the wait period has expired, we return prematurely. The function
|
|
will return the value of this flag on return -- "False" if we waited the
|
|
full time, "True" if the flag became set and we returned early.
|
|
|
|
*/
|
|
|
|
#define IncludeWaitForErrors 1
|
|
|
|
#include "atalk.h"
|
|
|
|
#if Iam a UnixBox
|
|
#if __CI /* For test builds on the Prime... */
|
|
#include <timeb.h>
|
|
#else
|
|
#include <time.h>
|
|
#include <sys/timeb.h>
|
|
#endif
|
|
#elif Iam a WindowsNT
|
|
/* No includes */
|
|
#else
|
|
#include <timeb.h>
|
|
#endif
|
|
|
|
|
|
#if (IamNot a WindowsNT)
|
|
static void FixTimebStructure(struct timeb far *time);
|
|
#endif
|
|
|
|
Boolean WaitFor(int hundreths,
|
|
volatile Boolean far *stopFlag)
|
|
{
|
|
#if (Iam a WindowsNT)
|
|
return((Boolean)NTWaitFor(hundreths, (BOOLEAN *)stopFlag));
|
|
#else
|
|
|
|
struct timeb currentTime, stopTime;
|
|
int milliSeconds;
|
|
|
|
/* Build a "timeb" that is our stop time... */
|
|
|
|
ftime(&stopTime);
|
|
stopTime.time += (long)(hundreths / 100);
|
|
stopTime.millitm += (short)((hundreths % 100) * 10);
|
|
FixTimebStructure(&stopTime);
|
|
|
|
/* As time goes by... */
|
|
|
|
for(; not *stopFlag; )
|
|
{
|
|
ftime(¤tTime);
|
|
FixTimebStructure(¤tTime);
|
|
if (currentTime.time > stopTime.time)
|
|
break;
|
|
else if (currentTime.time is stopTime.time and
|
|
currentTime.millitm >= stopTime.millitm)
|
|
break;
|
|
|
|
#if 0
|
|
/* This loop is a hard CPU-bound wait. In non-multi-treaded
|
|
environments this may be a bad thing: are other operations
|
|
withing a multi-protocol router stopped also? One solution
|
|
to this problem is to give some processing time to other
|
|
operations while in this loop. Thus the following call. */
|
|
|
|
DoOtherProcessing();
|
|
#endif
|
|
}
|
|
|
|
return(*stopFlag);
|
|
|
|
#endif
|
|
|
|
} /* WaitFor */
|
|
|
|
#if (IamNot a WindowsNT)
|
|
|
|
static void FixTimebStructure(struct timeb far *time)
|
|
{
|
|
int milliSeconds;
|
|
|
|
/* Some hosts will return "millitm" greater than 1000... in this case move
|
|
any excess into "time", so "millitm" will be less than a second. */
|
|
|
|
milliSeconds = time->millitm;
|
|
if (milliSeconds >= 1000)
|
|
{
|
|
time->time += (long)(milliSeconds / 1000);
|
|
time->millitm = (short)(milliSeconds % 1000);
|
|
}
|
|
|
|
} /* FixTimebStructure */
|
|
|
|
#endif
|