dhry.c

Small Device C Compiler 面向Inter8051

    printf ("Str_2_Loc:           %s\n", (char *)Str_2_Loc);
    printf ("        should be:   DHRYSTONE PROGRAM, 2'ND STRING\n");
    printf ("\n");
#endif
#if 1
    printf("Number of runs: %u.  runTime: %u.\n", Number_Of_Runs, (unsigned)runTime);
    mark();
    printf("Dhrystones/s = %u\n", (unsigned)((unsigned long)Number_Of_Runs / (runTime/CLOCKS_PER_SEC)));
    printf("MIPS = d/s/1757 = (sigh, need floats...)\n");
#endif
#ifdef PRINT_T_STATES    
    _printTStates();
#endif    
#if 1
    printf("Time: %lu ticks\n", runTime);
#endif
}

void Proc_1 (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           */
  
#if !defined(SDCC_ds390)    
    structassign (*Ptr_Val_Par->Ptr_Comp, *Ptr_Glob);
#else
    /* I have no idea why this is necessary... */
    memcpyx((void xdata *)*Ptr_Val_Par->Ptr_Comp, (void xdata *)*Ptr_Glob, 
	   sizeof(Rec_Type));
#endif
    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 */


void Proc_2 (One_Fifty *Int_Par_Ref)
    /******************/
    /* executed once */
    /* *Int_Par_Ref == 1, becomes 4 */
{
    One_Fifty  Int_Loc;  
    Enumeration   Enum_Loc;

    DPRINTF(("-> Proc_2\n"));

    Int_Loc = *Int_Par_Ref + 10;
    do {
	DPRINTF(("1"));
	/* executed once */
	if (Ch_1_Glob == 'A')
	    /* then, executed */
	    {
		DPRINTF(("2"));
		Int_Loc -= 1;
		*Int_Par_Ref = Int_Loc - Int_Glob;
		Enum_Loc = Ident_1;
	    } /* if */
	DPRINTF(("3"));
    } while (Enum_Loc != Ident_1); /* true */
    DPRINTF(("Proc_2 done.\n"));
} /* Proc_2 */


void Proc_3 (Rec_Pointer *Ptr_Ref_Par)
    /******************/
    /* executed once */
    /* Ptr_Ref_Par becomes Ptr_Glob */
{
    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 */

void Proc_4 (void) /* without parameters */
    /*******/
    /* executed once */
{
    Boolean Bool_Loc;

    DPRINTF(("-> Proc_4\n"));
    Bool_Loc = Ch_1_Glob == 'A';
    Bool_Glob = Bool_Loc | Bool_Glob;
    Ch_2_Glob = 'B';
    DPRINTF(("Expect Ch_1_Glob '%c' == 'A'\n", (char)Ch_1_Glob));
    DPRINTF(("       Ch_2_Glob '%c' == 'B'\n", (char)Ch_2_Glob));
    DPRINTF(("       Bool_Loc %d == 1\n", (unsigned)Bool_Loc));
    DPRINTF(("       Bool_Glob %d == 1\n", (unsigned)Bool_Glob));
} /* Proc_4 */


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

void Proc_6 (Enumeration Enum_Val_Par, Enumeration *Enum_Ref_Par)
    /*********************************/
    /* executed once */
    /* Enum_Val_Par == Ident_3, Enum_Ref_Par becomes Ident_2 */

{
    *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:      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;

    DPRINTF(("-> Func_1\n"));
    DPRINTF(("  Inputs: Ch_1_Par_Val '%c' == { R, A, B }\n", (char)Ch_1_Par_Val));
    DPRINTF(("          Ch_2_Par_Val '%c' == { Y, C, C }\n", (char)Ch_2_Par_Val));

    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_3 (Enumeration Enum_Par_Val)
    /***************************/
    /* executed once        */
    /* Enum_Par_Val == Ident_3 */
{
    Enumeration Enum_Loc;

    Enum_Loc = Enum_Par_Val;
    if (Enum_Loc == Ident_3)
	/* then, executed */
	return (true);
    else /* not executed */
	return (false);
} /* Func_3 */

void Proc_7 (One_Fifty Int_1_Par_Val, One_Fifty Int_2_Par_Val, One_Fifty *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_Loc;

    Int_Loc = Int_1_Par_Val + 2;
    *Int_Par_Ref = Int_2_Par_Val + Int_Loc;
} /* Proc_7 */

/*void 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)*/
void Proc_8 (int *Arr_1_Par_Ref, int *Arr_2_Par_Ref,
	     int Int_1_Par_Val, int Int_2_Par_Val)
{
    REG One_Fifty Int_Index;
    REG One_Fifty Int_Loc;

    DPRINTF(("-> Proc_8\n"));
    Int_Loc = Int_1_Par_Val + 5;
    Arr_1_Par_Ref [Int_Loc] = Int_2_Par_Val;
    DPRINTF(("Int_Loc %d == 8 Int_2_Par_Val %d == 7\n", 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*50 + Int_Index] = Int_Loc;
    Arr_2_Par_Ref [Int_Loc * 50 + Int_Loc-1] += 1;
    Arr_2_Par_Ref [(Int_Loc+20 *50) + Int_Loc] = Arr_1_Par_Ref [Int_Loc];
    Int_Glob = 5;
    DPRINTF(("Arr_1_Glob[8] %d == 7\n", Arr_1_Par_Ref[8]));
}

/*********************************************************************/
/* executed once      */
/* Int_Par_Val_1 == 3 */
/* Int_Par_Val_2 == 7 */
Boolean Func_2 (char *Str_1_Par_Ref, char *Str_2_Par_Ref)
    /*************************************************/
    /* executed once */
    /* Str_1_Par_Ref == "DHRYSTONE PROGRAM, 1'ST STRING" */
    /* Str_2_Par_Ref == "DHRYSTONE PROGRAM, 2'ND STRING" */
{
    REG One_Thirty        Int_Loc;
    Capital_Letter    Ch_Loc;

    DPRINTF(("-> Func_2\n"));
    DPRINTF(("  Inputs Str_1_Par_Ref \"%s\" = \"DHRYSTONE PROGRAM, 1'ST STRING\"\n", Str_1_Par_Ref));
    DPRINTF(("         Str_2_Par_Ref \"%s\" = \"DHRYSTONE PROGRAM, 2'ND STRING\"\n", Str_2_Par_Ref));

    Int_Loc = 2;

    while (Int_Loc <= 2) {
	if (Func_1 (Str_1_Par_Ref[Int_Loc],
		    Str_2_Par_Ref[Int_Loc+1]) == Ident_1)
	    /* then, executed */
	    {
		DPRINTF(("  2.3 Then OK.\n"));
		Ch_Loc = 'A';
		Int_Loc += 1;
	    } /* if, while */
	else {
	    DPRINTF(("  2.2 Error.\n"));
	}
    }
    if (Ch_Loc >= 'W' && Ch_Loc < 'Z') {
	/* then, not executed */
	DPRINTF((" 2.4 Error\n"));
	Int_Loc = 7;
    }
    if (Ch_Loc == 'R') {
	/* then, not executed */
	DPRINTF((" 2.5 Error\n"));
	return (true);
    }
    else /* executed */
	{
	    DPRINTF(("Str_1_Par_Ref = \"%s\", Str_2_Par_Ref = \"%s\"\n",
		   Str_1_Par_Ref, Str_2_Par_Ref));
	    if (strcmp (Str_1_Par_Ref, Str_2_Par_Ref) > 0)
		/* then, not executed */
		{
		    DPRINTF((" 2.5 Error diff=%d\n", strcmp(Str_1_Par_Ref, Str_2_Par_Ref)));
		    Int_Loc += 7;
		    Int_Glob = Int_Loc;
		    return (true);
		}
	    else {
		/* executed */
		DPRINTF((" 2.6 OK\n"));
		return (false);
	    }
	} /* if Ch_Loc */
} /* Func_2 */