1 files changed, 1 insertions, 1 deletions

diff --git a/noncore/settings/sysinfo/contrib/dhry.c b/noncore/settings/sysinfo/contrib/dhry.c
index d1dadbd..20b627c 100644
--- a/noncore/settings/sysinfo/contrib/dhry.c
+++ b/noncore/settings/sysinfo/contrib/dhry.c
@@ -308,385 +308,385 @@ double dtime()
 
 /*****************************************************/
 /*  Fujitsu UXP/M timer.                             */
 /*  Provided by: Mathew Lim, ANUSF, M.Lim@anu.edu.au */
 /*****************************************************/
 #ifdef UXPM
 #include <sys/types.h>
 #include <sys/timesu.h>
 struct tmsu rusage;
 
 double dtime()
 {
  double q;
 
  timesu(&rusage);
 
  q = (double)(rusage.tms_utime) * 1.0e-06;
 
  return q;
 }
 #endif
 
 /**********************************************/
 /*    Macintosh (MAC_TMgr) Think C dtime()    */
 /*   requires Think C Language Extensions or  */
 /*    #include <MacHeaders> in the prefix     */
 /*  provided by Francis H Schiffer 3rd (fhs)  */
 /*         skipschiffer@genie.geis.com        */
 /**********************************************/
 #ifdef MAC_TMgr
 #include <Timer.h>
 #include <stdlib.h>
 
 static TMTask   mgrTimer;
 static Boolean  mgrInited = false;
 static double   mgrClock;
 
 #define RMV_TIMER RmvTime( (QElemPtr)&mgrTimer )
 #define MAX_TIME  1800000000L
 /* MAX_TIME limits time between calls to */
 /* dtime( ) to no more than 30 minutes   */
 /* this limitation could be removed by   */
 /* creating a completion routine to sum  */
 /* 30 minute segments (fhs 1994 feb 9)   */
 
 static void Remove_timer( )
 {
  RMV_TIMER;
  mgrInited = false;
 }
 
 double  dtime( )
 {
  if( mgrInited ) {
    RMV_TIMER;
    mgrClock += (MAX_TIME + mgrTimer.tmCount)*1.0e-6;
  } else {
    if( _atexit( &Remove_timer ) == 0 ) mgrInited = true;
    mgrClock = 0.0;
  }
 
  if ( mgrInited )
    {
     mgrTimer.tmAddr = NULL;
     mgrTimer.tmCount = 0;
     mgrTimer.tmWakeUp = 0;
     mgrTimer.tmReserved = 0;
     InsTime( (QElemPtr)&mgrTimer );
     PrimeTime( (QElemPtr)&mgrTimer, -MAX_TIME );
    }
  return( mgrClock );
 }
 #endif
 
 /***********************************************************/
 /*  Parsytec GCel timer.                                   */
 /*  Provided by: Georg Wambach, gw@informatik.uni-koeln.de */
 /***********************************************************/
 #ifdef PARIX
 #include <sys/time.h>
 
 double dtime()
 {
  double q;
 
  q = (double) (TimeNowHigh()) / (double) CLK_TCK_HIGH;
 
  return q;
 }
 #endif
 
 /************************************************/
 /*  Sun Solaris POSIX dtime() routine           */
 /*  Provided by: Case Larsen, CTLarsen.lbl.gov  */
 /************************************************/
 #ifdef POSIX
 #include <sys/time.h>
 #include <sys/resource.h>
 #include <sys/rusage.h>
 
 #ifdef __hpux
 #include <sys/syscall.h>
 #endif
 
 struct rusage rusage;
 
 double dtime()
 {
  double q;
 
  getrusage(RUSAGE_SELF,&rusage);
 
  q = (double)(rusage.ru_utime.tv_sec);
  q = q + (double)(rusage.ru_utime.tv_nsec) * 1.0e-09;
 
  return q;
 }
 #endif
 
 
 /****************************************************/
 /*  Windows NT (32 bit) dtime() routine             */
 /*  Provided by: Piers Haken, piersh@microsoft.com  */
 /****************************************************/
 #ifdef WIN32
 #include <windows.h>
 
 double dtime(void)
 {
  double q;
 
  q = (double)GetTickCount() * 1.0e-03;
 
  return q;
 }
 #endif
 
 /*****************************************************/
 /* Time according to POSIX.1  -  <J.Pelan@qub.ac.uk> */
 /* Ref: "POSIX Programmer's Guide"  O'Reilly & Assoc.*/
 /*****************************************************/
 #ifdef POSIX1
 #define _POSIX_SOURCE 1
 #include <unistd.h>
 #include <limits.h>
 #include <sys/times.h>
 
 struct tms tms;
 
 double dtime()
 {
  double q;
  times(&tms);
  q = (double)tms.tms_utime / (double)CLK_TCK;
  return q;
 }
 #endif
 /*
  *************************************************************************
  *
  *                   "DHRYSTONE" Benchmark Program
  *                   -----------------------------
  *
  *  Version:    C, Version 2.1
  *
  *  File:       dhry_1.c (part 2 of 3)
  *
  *  Date:       May 25, 1988
  *
  *  Author:     Reinhold P. Weicker
  *
  *************************************************************************
  */
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include "dhry.h"
 
 /* Global Variables: */
 
 Rec_Pointer     Ptr_Glob,
                 Next_Ptr_Glob;
 int             Int_Glob;
 Boolean         Bool_Glob;
 char            Ch_1_Glob,
                 Ch_2_Glob;
 int             Arr_1_Glob [50];
 int             Arr_2_Glob [50] [50];
 
 char Reg_Define[] = "Register option selected.";
 
-extern char     *malloc ();
+//extern char     *malloc ();
 Enumeration     Func_1 ();
   /*
   forward declaration necessary since Enumeration may not simply be int
   */
 
 #ifndef ROPT
 #define REG
         /* REG becomes defined as empty */
         /* i.e. no register variables   */
 #else
 #define REG register
 #endif
 
 
 /* variables for time measurement: */
 
 #define Too_Small_Time 2
                 /* Measurements should last at least 2 seconds */
 
 double          Begin_Time,
                 End_Time,
                 User_Time;
 
 double          Microseconds,
                 Dhrystones_Per_Second,
                 Vax_Mips;
 
 /* end of variables for time measurement */
 
 /**********************************************************************************************/
 
 
 Proc_1 (Ptr_Val_Par)
 /******************/
 
 REG Rec_Pointer Ptr_Val_Par;
     /* executed once */
 {
   REG Rec_Pointer Next_Record = Ptr_Val_Par->Ptr_Comp;
                                         /* == Ptr_Glob_Next */
   /* Local variable, initialized with Ptr_Val_Par->Ptr_Comp,    */
   /* corresponds to "rename" in Ada, "with" in Pascal           */
 
   structassign (*Ptr_Val_Par->Ptr_Comp, *Ptr_Glob);
   Ptr_Val_Par->variant.var_1.Int_Comp = 5;
   Next_Record->variant.var_1.Int_Comp
         = Ptr_Val_Par->variant.var_1.Int_Comp;
   Next_Record->Ptr_Comp = Ptr_Val_Par->Ptr_Comp;
   Proc_3 (&Next_Record->Ptr_Comp);
     /* Ptr_Val_Par->Ptr_Comp->Ptr_Comp
                         == Ptr_Glob->Ptr_Comp */
   if (Next_Record->Discr == Ident_1)
     /* then, executed */
   {
     Next_Record->variant.var_1.Int_Comp = 6;
     Proc_6 (Ptr_Val_Par->variant.var_1.Enum_Comp,
            &Next_Record->variant.var_1.Enum_Comp);
     Next_Record->Ptr_Comp = Ptr_Glob->Ptr_Comp;
     Proc_7 (Next_Record->variant.var_1.Int_Comp, 10,
            &Next_Record->variant.var_1.Int_Comp);
   }
   else /* not executed */
     structassign (*Ptr_Val_Par, *Ptr_Val_Par->Ptr_Comp);
 } /* Proc_1 */
 
 
 Proc_2 (Int_Par_Ref)
 /******************/
     /* executed once */
     /* *Int_Par_Ref == 1, becomes 4 */
 
 One_Fifty   *Int_Par_Ref;
 {
   One_Fifty  Int_Loc;
   Enumeration   Enum_Loc;
 
   Int_Loc = *Int_Par_Ref + 10;
   do /* executed once */
     if (Ch_1_Glob == 'A')
       /* then, executed */
     {
       Int_Loc -= 1;
       *Int_Par_Ref = Int_Loc - Int_Glob;
       Enum_Loc = Ident_1;
     } /* if */
   while (Enum_Loc != Ident_1); /* true */
 } /* Proc_2 */
 
 
 Proc_3 (Ptr_Ref_Par)
 /******************/
     /* executed once */
     /* Ptr_Ref_Par becomes Ptr_Glob */
 
 Rec_Pointer *Ptr_Ref_Par;
 
 {
   if (Ptr_Glob != Null)
     /* then, executed */
     *Ptr_Ref_Par = Ptr_Glob->Ptr_Comp;
   Proc_7 (10, Int_Glob, &Ptr_Glob->variant.var_1.Int_Comp);
 } /* Proc_3 */
 
 
 Proc_4 () /* without parameters */
 /*******/
     /* executed once */
 {
   Boolean Bool_Loc;
 
   Bool_Loc = Ch_1_Glob == 'A';
   Bool_Glob = Bool_Loc | Bool_Glob;
   Ch_2_Glob = 'B';
 } /* Proc_4 */
 
 
 Proc_5 () /* without parameters */
 /*******/
     /* executed once */
 {
   Ch_1_Glob = 'A';
   Bool_Glob = false;
 } /* Proc_5 */
 
 
         /* Procedure for the assignment of structures,          */
         /* if the C compiler doesn't support this feature       */
 #ifdef  NOSTRUCTASSIGN
 memcpy (d, s, l)
 register char   *d;
 register char   *s;
 register int    l;
 {
         while (l--) *d++ = *s++;
 }
 #endif
 
 
 Proc_6 (Enum_Val_Par, Enum_Ref_Par)
 /*********************************/
     /* executed once */
     /* Enum_Val_Par == Ident_3, Enum_Ref_Par becomes Ident_2 */
 
 Enumeration  Enum_Val_Par;
 Enumeration *Enum_Ref_Par;
 {
   *Enum_Ref_Par = Enum_Val_Par;
   if (! Func_3 (Enum_Val_Par))
     /* then, not executed */
     *Enum_Ref_Par = Ident_4;
   switch (Enum_Val_Par)
   {
     case Ident_1:
       *Enum_Ref_Par = Ident_1;
       break;
     case Ident_2:
       if (Int_Glob > 100)
         /* then */
       *Enum_Ref_Par = Ident_1;
       else *Enum_Ref_Par = Ident_4;
       break;
     case Ident_3: /* executed */
       *Enum_Ref_Par = Ident_2;
       break;
     case Ident_4: break;
     case Ident_5:
       *Enum_Ref_Par = Ident_3;
       break;
   } /* switch */
 } /* Proc_6 */
 
 
 Proc_7 (Int_1_Par_Val, Int_2_Par_Val, Int_Par_Ref)
 /**********************************************/
     /* executed three times                                      */
     /* first call:      Int_1_Par_Val == 2, Int_2_Par_Val == 3,  */
     /*                  Int_Par_Ref becomes 7                    */
     /* second call:     Int_1_Par_Val == 10, Int_2_Par_Val == 5, */
     /*                  Int_Par_Ref becomes 17                   */
     /* third call:      Int_1_Par_Val == 6, Int_2_Par_Val == 10, */
     /*                  Int_Par_Ref becomes 18                   */
 One_Fifty       Int_1_Par_Val;
 One_Fifty       Int_2_Par_Val;
 One_Fifty      *Int_Par_Ref;
 {
   One_Fifty Int_Loc;
 
   Int_Loc = Int_1_Par_Val + 2;
   *Int_Par_Ref = Int_2_Par_Val + Int_Loc;
 } /* Proc_7 */