pwr_c.c

2410得测试程序

typedef char	Capital_Letter;
typedef int		Boolean;
typedef char	Str_30 [31];
typedef int		Arr_1_Dim [50];
typedef int		Arr_2_Dim [50] [50];

typedef struct record 
{
	struct record *Ptr_Comp;
	Enumeration	Discr;
	union {
		struct {
			Enumeration Enum_Comp;
			int		Int_Comp;
			char		Str_Comp [31];
		} var_1;
		struct {
			Enumeration E_Comp_2;
			char		Str_2_Comp [31];
		} var_2;
		struct {
			char		Ch_1_Comp;
			char		Ch_2_Comp;
		} var_3;
	} variant;
} Rec_Type, *Rec_Pointer;

/***************************************************************************
 *
 *					"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 <string.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];

/* extern char	*malloc (); */
Enumeration Func_1 (Capital_Letter Ch_1_Par_Val,Capital_Letter Ch_2_Par_Val);

//Enumeration	Func_1 ();
	/* forward declaration necessary since Enumeration may not simply be int */

#ifndef REG
		Boolean Reg = false;
#define REG
		/* REG becomes defined as empty */
		/* i.e. no register variables	*/
#else
		Boolean Reg = true;
#endif

void dhrystone21(void)
{
	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;

	/* Initializations */

	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.					*/

	Number_Of_Runs = 10000;

	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 */
			Int_1_Loc += 1;
		} /* while */
		/* Int_1_Loc == 3, Int_2_Loc == 3, Int_3_Loc == 7 */
		Proc_8 (Arr_1_Glob, Arr_2_Glob, Int_1_Loc, Int_3_Loc);
		/* Int_Glob == 5 */
		Proc_1 (Ptr_Glob);
		for (Ch_Index = 'A'; Ch_Index <= Ch_2_Glob; ++Ch_Index)
		{/* loop body executed twice */
			if (Enum_Loc == Func_1 (Ch_Index, 'C'))	/* then, not executed */
			{
				Proc_6 (Ident_1, &Enum_Loc);
				strcpy (Str_2_Loc, "DHRYSTONE PROGRAM, 3'RD STRING");
				Int_2_Loc = Run_Index;
				Int_Glob = Run_Index;
			}
		}
		/* Int_1_Loc == 3, Int_2_Loc == 3, Int_3_Loc == 7 */
		Int_2_Loc = Int_2_Loc * Int_1_Loc;
		Int_1_Loc = Int_2_Loc / Int_3_Loc;
		Int_2_Loc = 7 * (Int_2_Loc - Int_3_Loc) - Int_1_Loc;
		/* Int_1_Loc == 1, Int_2_Loc == 13, Int_3_Loc == 7 */
		Proc_2 (&Int_1_Loc);
		/* Int_1_Loc == 5 */
	} /* loop "for Run_Index" */
}

Proc_1 (REG Rec_Pointer Ptr_Val_Par)
{
	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 */

/******************/
	/* executed once */
	/* *Int_Par_Ref == 1, becomes 4 */
Proc_2 (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;
		}
	} while (Enum_Loc != Ident_1); /* true */
} /* Proc_2 */

/******************/
	/* executed once */
	/* Ptr_Ref_Par becomes Ptr_Glob */
Proc_3 (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 ( void ) /* without parameters */
{
	Boolean Bool_Loc;

	Bool_Loc = Ch_1_Glob == 'A';
	Bool_Glob = Bool_Loc | Bool_Glob;
	Ch_2_Glob = 'B';
} /* Proc_4 */


Proc_5 ( void ) /* without parameters */
{
	Ch_1_Glob = 'A';
	Bool_Glob = false;
} /* Proc_5 */

/*
 ****************************************************************************
 *
 *					"DHRYSTONE" Benchmark Program
 *					-----------------------------
 *																			
 *	Version:	C, Version 2.1
 *																			
 *	File:		dhry_2.c (part 3 of 3)
 *
 *	Date:		May 25, 1988
 *
 *	Author:	Reinhold P. Weicker
 *
 ****************************************************************************
 */

#ifndef REG
#define REG
		/* REG becomes defined as empty */
		/* i.e. no register variables	*/
#endif

extern	int	Int_Glob;
extern	char	Ch_1_Glob;

/*********************************/
	/* executed once */
	/* Enum_Val_Par == Ident_3, Enum_Ref_Par becomes Ident_2 */
Proc_6 (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 */

/**********************************************/
	/* 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					*/
Proc_7 (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 */

/*********************************************************************/
	/* executed once		*/
	/* Int_Par_Val_1 == 3 */
	/* Int_Par_Val_2 == 7 */
Proc_8 (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 */

/*************************************************/
	/* 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'	*/
Enumeration Func_1 (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 */

/*************************************************/
	/* executed once */
	/* Str_1_Par_Ref == "DHRYSTONE PROGRAM, 1'ST STRING" */
	/* Str_2_Par_Ref == "DHRYSTONE PROGRAM, 2'ND STRING" */
Boolean Func_2 (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 */

/***************************/
	/* executed once		*/
	/* Enum_Par_Val == Ident_3 */
Boolean Func_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 */