summaryrefslogtreecommitdiff
Side-by-side diff
Diffstat (more/less context) (ignore whitespace changes)
-rw-r--r--noncore/apps/opie-reader/chm_lib.c5
-rw-r--r--noncore/settings/sysinfo/contrib/dhry.c4
2 files changed, 5 insertions, 4 deletions
diff --git a/noncore/apps/opie-reader/chm_lib.c b/noncore/apps/opie-reader/chm_lib.c
index ecf8278..7acd1d2 100644
--- a/noncore/apps/opie-reader/chm_lib.c
+++ b/noncore/apps/opie-reader/chm_lib.c
@@ -1539,199 +1539,200 @@ int chm_enumerate(struct chmFile *h,
/* check for NORMAL vs. SPECIAL */
if (ui.path[1] == '#' || ui.path[1] == '$')
flag = CHM_ENUMERATE_SPECIAL;
else
flag = CHM_ENUMERATE_NORMAL;
}
else
flag = CHM_ENUMERATE_META;
if (! (what & flag))
continue;
/* call the enumerator */
{
int status = (*e)(h, &ui, context);
switch (status)
{
case CHM_ENUMERATOR_FAILURE: return 0;
case CHM_ENUMERATOR_CONTINUE: break;
case CHM_ENUMERATOR_SUCCESS: return 1;
default: break;
}
}
}
/* advance to next page */
curPage = header.block_next;
}
return 1;
}
int chm_enumerate_dir(struct chmFile *h,
const char *prefix,
int what,
CHM_ENUMERATOR e,
void *context)
{
/*
* XXX: do this efficiently (i.e. using the tree index)
*/
Int32 curPage;
/* buffer to hold whatever page we're looking at */
#ifdef WIN32
UChar *page_buf = alloca((unsigned int)h->block_len);
#else
UChar page_buf[h->block_len];
#endif
struct chmPmglHeader header;
UChar *end;
UChar *cur;
unsigned long lenRemain;
/* set to 1 once we've started */
int it_has_begun=0;
/* the current ui */
struct chmUnitInfo ui;
int flag;
/* the length of the prefix */
char prefixRectified[CHM_MAX_PATHLEN+1];
int prefixLen;
- char lastPath[CHM_MAX_PATHLEN];
+ char lastPath[CHM_MAX_PATHLEN+1];
int lastPathLen;
/* starting page */
curPage = h->index_head;
/* initialize pathname state */
strncpy(prefixRectified, prefix, CHM_MAX_PATHLEN);
prefixLen = strlen(prefixRectified);
if (prefixLen != 0)
{
if (prefixRectified[prefixLen-1] != '/')
{
prefixRectified[prefixLen] = '/';
prefixRectified[prefixLen+1] = '\0';
++prefixLen;
}
}
lastPath[0] = '\0';
lastPathLen = -1;
/* until we have either returned or given up */
while (curPage != -1)
{
/* try to fetch the index page */
if (_chm_fetch_bytes(h,
page_buf,
(UInt64)h->dir_offset + (UInt64)curPage*h->block_len,
h->block_len) != h->block_len)
return 0;
/* figure out start and end for this page */
cur = page_buf;
lenRemain = _CHM_PMGL_LEN;
if (! _unmarshal_pmgl_header(&cur, &lenRemain, &header))
return 0;
end = page_buf + h->block_len - (header.free_space);
/* loop over this page */
while (cur < end)
{
if (! _chm_parse_PMGL_entry(&cur, &ui))
return 0;
/* check if we should start */
if (! it_has_begun)
{
if (ui.length == 0 && strncmp(ui.path, prefixRectified, prefixLen) == 0)
it_has_begun = 1;
else
continue;
if (ui.path[prefixLen] == '\0')
continue;
}
/* check if we should stop */
else
{
if (strncmp(ui.path, prefixRectified, prefixLen) != 0)
return 1;
}
/* check if we should include this path */
if (lastPathLen != -1)
{
if (strncmp(ui.path, lastPath, lastPathLen) == 0)
continue;
}
- strcpy(lastPath, ui.path);
+ strncpy(lastPath, ui.path, CHM_MAX_PATHLEN);
+ lastPath[CHM_MAX_PATHLEN] = '\0';
lastPathLen = strlen(lastPath);
/* check for DIRS */
if (ui.length == 0 && !(what & CHM_ENUMERATE_DIRS))
continue;
/* check for FILES */
if (ui.length != 0 && !(what & CHM_ENUMERATE_FILES))
continue;
/* check for NORMAL vs. META */
if (ui.path[0] == '/')
{
/* check for NORMAL vs. SPECIAL */
if (ui.path[1] == '#' || ui.path[1] == '$')
flag = CHM_ENUMERATE_SPECIAL;
else
flag = CHM_ENUMERATE_NORMAL;
}
else
flag = CHM_ENUMERATE_META;
if (! (what & flag))
continue;
/* call the enumerator */
{
int status = (*e)(h, &ui, context);
switch (status)
{
case CHM_ENUMERATOR_FAILURE: return 0;
case CHM_ENUMERATOR_CONTINUE: break;
case CHM_ENUMERATOR_SUCCESS: return 1;
default: break;
}
}
}
/* advance to next page */
curPage = header.block_next;
}
return 1;
}
/* resolve a particular object from the archive */
int chm_resolve_location(struct chmFile *h,
unsigned long pos,
struct chmUnitInfo *ui)
{
/*
* XXX: implement caching scheme for dir pages
*/
Int32 curPage;
/* buffer to hold whatever page we're looking at */
#ifdef WIN32
UChar *page_buf = alloca(h->block_len);
#else
UChar page_buf[h->block_len];
#endif
/* starting page */
diff --git a/noncore/settings/sysinfo/contrib/dhry.c b/noncore/settings/sysinfo/contrib/dhry.c
index 20b627c..07fd1c0 100644
--- a/noncore/settings/sysinfo/contrib/dhry.c
+++ b/noncore/settings/sysinfo/contrib/dhry.c
@@ -434,129 +434,129 @@ double dtime()
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.";
+char Reg_Define[32] = "Register option selected.";
//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 */
@@ -922,89 +922,89 @@ double dhry_main( int n )
printf ("Final values of the variables used in the benchmark:\n");
printf ("\n");
printf ("Int_Glob: %d\n", Int_Glob);
printf (" should be: %d\n", 5);
printf ("Bool_Glob: %d\n", Bool_Glob);
printf (" should be: %d\n", 1);
printf ("Ch_1_Glob: %c\n", Ch_1_Glob);
printf (" should be: %c\n", 'A');
printf ("Ch_2_Glob: %c\n", Ch_2_Glob);
printf (" should be: %c\n", 'B');
printf ("Arr_1_Glob[8]: %d\n", Arr_1_Glob[8]);
printf (" should be: %d\n", 7);
printf ("Arr_2_Glob[8][7]: %d\n", Arr_2_Glob[8][7]);
printf (" should be: Number_Of_Runs + 10\n");
printf ("Ptr_Glob->\n");
printf (" Ptr_Comp: %d\n", (int) Ptr_Glob->Ptr_Comp);
printf (" should be: (implementation-dependent)\n");
printf (" Discr: %d\n", Ptr_Glob->Discr);
printf (" should be: %d\n", 0);
printf (" Enum_Comp: %d\n", Ptr_Glob->variant.var_1.Enum_Comp);
printf (" should be: %d\n", 2);
printf (" Int_Comp: %d\n", Ptr_Glob->variant.var_1.Int_Comp);
printf (" should be: %d\n", 17);
printf (" Str_Comp: %s\n", Ptr_Glob->variant.var_1.Str_Comp);
printf (" should be: DHRYSTONE PROGRAM, SOME STRING\n");
printf ("Next_Ptr_Glob->\n");
printf (" Ptr_Comp: %d\n", (int) Next_Ptr_Glob->Ptr_Comp);
printf (" should be: (implementation-dependent), same as above\n");
printf (" Discr: %d\n", Next_Ptr_Glob->Discr);
printf (" should be: %d\n", 0);
printf (" Enum_Comp: %d\n", Next_Ptr_Glob->variant.var_1.Enum_Comp);
printf (" should be: %d\n", 1);
printf (" Int_Comp: %d\n", Next_Ptr_Glob->variant.var_1.Int_Comp);
printf (" should be: %d\n", 18);
printf (" Str_Comp: %s\n", Next_Ptr_Glob->variant.var_1.Str_Comp);
printf (" should be: DHRYSTONE PROGRAM, SOME STRING\n");
printf ("Int_1_Loc: %d\n", Int_1_Loc);
printf (" should be: %d\n", 5);
printf ("Int_2_Loc: %d\n", Int_2_Loc);
printf (" should be: %d\n", 13);
printf ("Int_3_Loc: %d\n", Int_3_Loc);
printf (" should be: %d\n", 7);
printf ("Enum_Loc: %d\n", Enum_Loc);
printf (" should be: %d\n", 1);
printf ("Str_1_Loc: %s\n", Str_1_Loc);
printf (" should be: DHRYSTONE PROGRAM, 1'ST STRING\n");
printf ("Str_2_Loc: %s\n", Str_2_Loc);
printf (" should be: DHRYSTONE PROGRAM, 2'ND STRING\n");
printf ("\n");
*/
User_Time = End_Time - Begin_Time;
if (User_Time < Too_Small_Time) return -1;
else
{
Microseconds = User_Time * Mic_secs_Per_Second
/ (double) Number_Of_Runs;
Dhrystones_Per_Second = (double) Number_Of_Runs / User_Time;
Vax_Mips = Dhrystones_Per_Second / 1757.0;
#ifdef ROPT
//printf ("Register option selected? YES\n");
#else
//printf ("Register option selected? NO\n");
- strcpy(Reg_Define, "Register option not selected.");
+ strncpy(Reg_Define, "Register option not selected.", 30);
#endif
printf ("Microseconds for one run through Dhrystone: ");
printf ("%7.1lf \n", Microseconds);
printf ("Dhrystones per Second: ");
printf ("%10.1lf \n", Dhrystones_Per_Second);
printf ("VAX MIPS rating = %10.3lf \n",Vax_Mips);
printf ("\n");
return Dhrystones_Per_Second;
/*
fprintf(Ap,"\n");
fprintf(Ap,"Dhrystone Benchmark, Version 2.1 (Language: C)\n");
fprintf(Ap,"%s\n",Reg_Define);
fprintf(Ap,"Microseconds for one loop: %7.1lf\n",Microseconds);
fprintf(Ap,"Dhrystones per second: %10.1lf\n",Dhrystones_Per_Second);
fprintf(Ap,"VAX MIPS rating: %10.3lf\n",Vax_Mips);
fclose(Ap);
*/
}
}