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
@@ -116,769 +116,769 @@ double dtime()
 
 #ifndef HZ
 #define HZ 60
 #endif
 
 struct tms tms;
 
 double dtime()
 {
  double q;
 
  times(&tms);
 
  q = (double)(tms.tms_utime) / (double)HZ;
 
  return q;
 }
 #endif
 
 /*********************************************************/
 /*  VMS dtime() for VMS systems.                         */
 /*  Provided by: RAMO@uvphys.phys.UVic.CA                */
 /*  Some people have run into problems with this timer.  */
 /*********************************************************/
 #ifdef VMS
 #include time
 
 #ifndef HZ
 #define HZ 100
 #endif
 
 struct tbuffer_t
       {
        int proc_user_time;
        int proc_system_time;
        int child_user_time;
        int child_system_time;
       };
 
 struct tbuffer_t tms;
 
 double dtime()
 {
  double q;
 
  times(&tms);
 
  q = (double)(tms.proc_user_time) / (double)HZ;
 
  return q;
 }
 #endif
 
 /******************************/
 /*  BORLAND C dtime() for DOS */
 /******************************/
 #ifdef BORLAND_C
 #include <ctype.h>
 #include <dos.h>
 #include <time.h>
 
 #define HZ 100
 struct time tnow;
 
 double dtime()
 {
  double q;
 
  gettime(&tnow);
 
  q = 60.0 * (double)(tnow.ti_min);
  q = q + (double)(tnow.ti_sec);
  q = q + (double)(tnow.ti_hund)/(double)HZ;
 
  return q;
 }
 #endif
 
 /**************************************/
 /*  Microsoft C (MSC) dtime() for DOS */
 /**************************************/
 #ifdef MSC
 #include <time.h>
 #include <ctype.h>
 
 #define HZ CLOCKS_PER_SEC
 clock_t tnow;
 
 double dtime()
 {
  double q;
 
  tnow = clock();
 
  q = (double)tnow / (double)HZ;
 
  return q;
 }
 #endif
 
 /*************************************/
 /*  Macintosh (MAC) Think C dtime()  */
 /*************************************/
 #ifdef MAC
 #include <time.h>
 
 #define HZ 60
 
 double dtime()
 {
  double q;
 
  q = (double)clock() / (double)HZ;
 
  return q;
 }
 #endif
 
 /************************************************************/
 /*  iPSC/860 (IPSC) dtime() for i860.                       */
 /*  Provided by: Dan Yergeau, yergeau@gloworm.Stanford.EDU  */
 /************************************************************/
 #ifdef IPSC
 extern double dclock();
 
 double dtime()
 {
  double q;
 
  q = dclock();
 
  return q;
 }
 #endif
 
 /**************************************************/
 /*  FORTRAN dtime() for Cray type systems.        */
 /*  This is the preferred timer for Cray systems. */
 /**************************************************/
 #ifdef FORTRAN_SEC
 
 fortran double second();
 
 double dtime()
 {
  double q;
 
  second(&q);
 
  return q;
 }
 #endif
 
 /***********************************************************/
 /*  UNICOS C dtime() for Cray UNICOS systems.  Don't use   */
 /*  unless absolutely necessary as returned time includes  */
 /*  'user+system' time.  Provided by: R. Mike Dority,      */
 /*  dority@craysea.cray.com                                */
 /***********************************************************/
 #ifdef CTimer
 #include <time.h>
 
 double dtime()
 {
  double    q;
  clock_t   clock(void);
 
  q = (double)clock() / (double)CLOCKS_PER_SEC;
 
  return q;
 }
 #endif
 
 /********************************************/
 /* Another UNIX timer using gettimeofday(). */
 /* However, getrusage() is preferred.       */
 /********************************************/
 #ifdef GTODay
 #include <sys/time.h>
 
 struct timeval tnow;
 
 double dtime()
 {
  double q;
 
  gettimeofday(&tnow,NULL);
  q = (double)tnow.tv_sec + (double)tnow.tv_usec * 1.0e-6;
 
  return q;
 }
 #endif
 
 /*****************************************************/
 /*  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 */
 
 
 Proc_8 (Arr_1_Par_Ref, Arr_2_Par_Ref, Int_1_Par_Val, Int_2_Par_Val)
 /*********************************************************************/
     /* executed once      */
     /* Int_Par_Val_1 == 3 */
     /* Int_Par_Val_2 == 7 */
 Arr_1_Dim       Arr_1_Par_Ref;
 Arr_2_Dim       Arr_2_Par_Ref;
 int             Int_1_Par_Val;
 int             Int_2_Par_Val;
 {
   REG One_Fifty Int_Index;
   REG One_Fifty Int_Loc;
 
   Int_Loc = Int_1_Par_Val + 5;
   Arr_1_Par_Ref [Int_Loc] = Int_2_Par_Val;
   Arr_1_Par_Ref [Int_Loc+1] = Arr_1_Par_Ref [Int_Loc];
   Arr_1_Par_Ref [Int_Loc+30] = Int_Loc;
   for (Int_Index = Int_Loc; Int_Index <= Int_Loc+1; ++Int_Index)
     Arr_2_Par_Ref [Int_Loc] [Int_Index] = Int_Loc;
   Arr_2_Par_Ref [Int_Loc] [Int_Loc-1] += 1;
   Arr_2_Par_Ref [Int_Loc+20] [Int_Loc] = Arr_1_Par_Ref [Int_Loc];
   Int_Glob = 5;
 } /* Proc_8 */
 
 
 Enumeration Func_1 (Ch_1_Par_Val, Ch_2_Par_Val)
 /*************************************************/
     /* executed three times                                         */
     /* first call:      Ch_1_Par_Val == 'H', Ch_2_Par_Val == 'R'    */
     /* second call:     Ch_1_Par_Val == 'A', Ch_2_Par_Val == 'C'    */
     /* third call:      Ch_1_Par_Val == 'B', Ch_2_Par_Val == 'C'    */
 
 Capital_Letter   Ch_1_Par_Val;
 Capital_Letter   Ch_2_Par_Val;
 {
   Capital_Letter        Ch_1_Loc;
   Capital_Letter        Ch_2_Loc;
 
   Ch_1_Loc = Ch_1_Par_Val;
   Ch_2_Loc = Ch_1_Loc;
   if (Ch_2_Loc != Ch_2_Par_Val)
     /* then, executed */
     return (Ident_1);
   else  /* not executed */
   {
     Ch_1_Glob = Ch_1_Loc;
     return (Ident_2);
    }
 } /* Func_1 */
 
 
 Boolean Func_2 (Str_1_Par_Ref, Str_2_Par_Ref)
 /*************************************************/
     /* executed once */
     /* Str_1_Par_Ref == "DHRYSTONE PROGRAM, 1'ST STRING" */
     /* Str_2_Par_Ref == "DHRYSTONE PROGRAM, 2'ND STRING" */
 
 Str_30  Str_1_Par_Ref;
 Str_30  Str_2_Par_Ref;
 {
   REG One_Thirty        Int_Loc;
       Capital_Letter    Ch_Loc;
 
   Int_Loc = 2;
   while (Int_Loc <= 2) /* loop body executed once */
     if (Func_1 (Str_1_Par_Ref[Int_Loc],
                 Str_2_Par_Ref[Int_Loc+1]) == Ident_1)
       /* then, executed */
     {
       Ch_Loc = 'A';
       Int_Loc += 1;
     } /* if, while */
   if (Ch_Loc >= 'W' && Ch_Loc < 'Z')
     /* then, not executed */
     Int_Loc = 7;
   if (Ch_Loc == 'R')
     /* then, not executed */
     return (true);
   else /* executed */
   {
     if (strcmp (Str_1_Par_Ref, Str_2_Par_Ref) > 0)
       /* then, not executed */
     {
       Int_Loc += 7;
       Int_Glob = Int_Loc;
       return (true);
     }
     else /* executed */
       return (false);
   } /* if Ch_Loc */
 } /* Func_2 */
 
 
 Boolean Func_3 (Enum_Par_Val)
 /***************************/
     /* executed once        */
     /* Enum_Par_Val == Ident_3 */
 Enumeration Enum_Par_Val;
 {
   Enumeration Enum_Loc;
 
   Enum_Loc = Enum_Par_Val;
   if (Enum_Loc == Ident_3)
     /* then, executed */
     return (true);
   else /* not executed */
     return (false);
 } /* Func_3 */
 
 /*********************************************************************************/
 
 double dhry_main( int n )
 /*****/
 
   /* main program, corresponds to procedures        */
   /* Main and Proc_0 in the Ada version             */
 {
         One_Fifty       Int_1_Loc;
   REG   One_Fifty       Int_2_Loc;
         One_Fifty       Int_3_Loc;
   REG   char            Ch_Index;
         Enumeration     Enum_Loc;
         Str_30          Str_1_Loc;
         Str_30          Str_2_Loc;
   REG   int             Run_Index;
   REG   int             Number_Of_Runs;
 
         FILE            *Ap;
 
   /* Initializations */
 
 /*  if ((Ap = fopen("dhry.res","a+")) == NULL)
     {
        printf("Can not open dhry.res\n\n");
        exit(1);
     }
 */
   Next_Ptr_Glob = (Rec_Pointer) malloc (sizeof (Rec_Type));
   Ptr_Glob = (Rec_Pointer) malloc (sizeof (Rec_Type));
 
   Ptr_Glob->Ptr_Comp                    = Next_Ptr_Glob;
   Ptr_Glob->Discr                       = Ident_1;
   Ptr_Glob->variant.var_1.Enum_Comp     = Ident_3;
   Ptr_Glob->variant.var_1.Int_Comp      = 40;
   strcpy (Ptr_Glob->variant.var_1.Str_Comp,
           "DHRYSTONE PROGRAM, SOME STRING");
   strcpy (Str_1_Loc, "DHRYSTONE PROGRAM, 1'ST STRING");
 
   Arr_2_Glob [8][7] = 10;
         /* Was missing in published program. Without this statement,    */
         /* Arr_2_Glob [8][7] would have an undefined value.             */
         /* Warning: With 16-Bit processors and Number_Of_Runs > 32000,  */
         /* overflow may occur for this array element.                   */
 
 /*
   if (Reg)
   {
     printf ("Program compiled with 'register' attribute\n");
     printf ("\n");
   }
   else
   {
     printf ("Program compiled without 'register' attribute\n");
     printf ("\n");
   }
 */
   Number_Of_Runs = n;
 
   /***************/
   /* Start timer */
   /***************/
 
   Begin_Time = dtime();
 
   for (Run_Index = 1; Run_Index <= Number_Of_Runs; ++Run_Index)
   {
 
     Proc_5();
     Proc_4();
       /* Ch_1_Glob == 'A', Ch_2_Glob == 'B', Bool_Glob == true */
     Int_1_Loc = 2;
     Int_2_Loc = 3;
     strcpy (Str_2_Loc, "DHRYSTONE PROGRAM, 2'ND STRING");
     Enum_Loc = Ident_2;
     Bool_Glob = ! Func_2 (Str_1_Loc, Str_2_Loc);
       /* Bool_Glob == 1 */
     while (Int_1_Loc < Int_2_Loc)  /* loop body executed once */
     {
       Int_3_Loc = 5 * Int_1_Loc - Int_2_Loc;
         /* Int_3_Loc == 7 */
       Proc_7 (Int_1_Loc, Int_2_Loc, &Int_3_Loc);
         /* Int_3_Loc == 7 */