/* * Displays a message on the LCD */ void dispMessage(char* line1, char* line2) { int i = 0; // Clear the LCD. sendInst(L_clear); // Display first row (display addresses 0x00 - 0x14) for(i = 0; i < LCD_WIDTH; ++i) { if(line1[i] == '\0') break; dispChar(line1[i]); } // Display second row (display addresses 0x40 - 0x54) move(0x40); for(i = 0; i < LCD_WIDTH; ++i) { if(line2[i] == '\0') break; dispChar(line2[i]); } // Move cursor back to first position move(0x00); }
// // Initialize LCD_A // void initLCD_A(void) { uint8_t i; // Clear LCD memory clrLCD(); // Configure COM0-COM3 and R03-R33 pins P5SEL |= (BIT4 | BIT3 | BIT2); P5DIR |= (BIT4 | BIT3 | BIT2); // Configure LCD_A LCDACTL = LCDFREQ_128 | LCDMX1 | LCDMX0 | LCDSON | LCDON; LCDAPCTL0 = LCDS4 | LCDS8 | LCDS12 | LCDS16 | LCDS20 | LCDS24; LCDAPCTL1 = 0; LCDAVCTL0 = LCDCPEN; LCDAVCTL1 = VLCD_2_60; for( i = 0 ; i < 7 ; i++) { dispChar( i , 0 ); } clrLCD(); }
void dispList( int hash, CHARACTER *target ) { struct character *current_addr; current_addr = target; do { dispChar(hash, current_addr); current_addr = current_addr->next_addr; } while ( current_addr != NULL ); }
/* データの探索 */ int search(void) { int i, h; struct character *current_addr,*head,*target; int point; printf("NO="); point = get_num(); h = hash(point); head = HashTable[h]; if ( HashTable[h] != NULL && HashTable[h] != DELETED ) { if ( head->no == point ) { printf("探索キー%dに対応するデータは%sです.\n", point, head->name); dispChar( h, head ); printf("********************************************\n\n"); disp(); return 0; } else { current_addr = head->next_addr; while ( current_addr != NULL ) { if ( current_addr->no == point ) { printf("探索キー%dに対応するデータは%sです.\n", point, head->name); dispChar( h, head ); printf("\n********************************************\n\n"); disp(); return 0; } } } } printf("NOT FOUND.\n"); return ERROR; }
void Fontdraw::dispText(int xpos, int ypos, const char *s, ...) { char gBuffer[1024]; memset(gBuffer, ' ', sizeof(gBuffer)); va_list msg; va_start(msg, s); vsprintf(gBuffer, s, msg); va_end(msg); int xoff = 0, yoff = 0; int x = xpos; int y = ypos; int carrage = 0; int index; NormalFont.fsize = fontSize; NormalFont.ftextid = txid_FONT; NormalFont.OrthoProjX = GraphicAPI->screen_width; //640; NormalFont.OrthoProjY = GraphicAPI->screen_height; //480; carrage = getCharHits((char*)s, '\n'); for(index=0 ; gBuffer[index] ; index++, x += (int)(NormalFont.fsize/HACKFONT)) { switch(gBuffer[index]) { case 0: break; case '\n': y -= NormalFont.fsize; x = xpos - (int)(NormalFont.fsize/HACKFONT); continue; default : dispChar(NormalFont, gBuffer[index], x+xoff, y+yoff); break; } } }
int main () /*****/ /* main program, corresponds to procedures */ /* Main and Proc_0 in the Ada version */ { /* CHANGE: We no longer use the code itself for timing. double dtime(); */ /* CHANGE: We need a strcpy function in MuddCLib. Since we don't pull string literal data out of object files, we have to put them on the stack. */ /* "DHRYSTONE PROGRAM, SOME STRING" */ char some_string[32] = {'D', 'H', 'R', 'Y', 'S', 'T', 'O', 'N', 'E', ' ', 'P', 'R', 'O', 'G', 'R', 'A', 'M', ',', ' ', 'S', 'O', 'M', 'E', ' ', 'S', 'T', 'R', 'I', 'N', 'G', '\0'}; /* "DHRYSTONE PROGRAM, 1'ST STRING" */ char first_string[32] = {'D', 'H', 'R', 'Y', 'S', 'T', 'O', 'N', 'E', ' ', 'P', 'R', 'O', 'G', 'R', 'A', 'M', ',', ' ', '1', '\'', 'S', 'T', ' ', 'S', 'T', 'R', 'I', 'N', 'G', '\0'}; /* Before we count down, we need to define the strings that will be used in the tests. "DHRYSTONE PROGRAM, 2'ND STRING" */ char second_string[32] = {'D', 'H', 'R', 'Y', 'S', 'T', 'O', 'N', 'E', ' ', 'P', 'R', 'O', 'G', 'R', 'A', 'M', ',', ' ', '2', '\'', 'N', 'D', ' ', 'S', 'T', 'R', 'I', 'N', 'G', '\0'}; /* "DHRYSTONE PROGRAM, 3'RD STRING" */ char third_string[32] = {'D', 'H', 'R', 'Y', 'S', 'T', 'O', 'N', 'E', ' ', 'P', 'R', 'O', 'G', 'R', 'A', 'M', ',', ' ', '3', '\'', 'R', 'D', ' ', 'S', 'T', 'R', 'I', 'N', 'G', '\0'}; /* Now some strings for LCD printing: */ char str_empty[1] = {'\0'}; char str_title[16] = {'D', 'h', 'r', 'y', 's', 't', 'o', 'n', 'e', ' ', 'v', '2', '.', '1', '\0'}; char str_starting[18] = {'S', 't', 'a', 'r', 't', 'i', 'n', 'g', ' ', 'i', 'n', ' ', '4', '.', '.', '.', '\0'}; char str_running[9] = {'R', 'u', 'n', 'n', 'i', 'n', 'g', '\0'}; char str_done[7] = {'D', 'o', 'n', 'e', '!', '\0'}; char str_success[9] = {'S', 'u', 'c', 'c', 'e', 's', 's', '\0'}; char str_failure[9] = {'F', 'a', 'i', 'l', 'u', 'r', 'e', '\0'}; 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 = NUMBER_OF_RUNS; // Number of runs is 10,000 int i; int testsSucceeded; /* We'll hard-code 100,000 runs in for now and see how that does. */ /* Initializations */ /* CHANGE: We're never using sde!! #if !#system(sde) FILE *Ap; if ((Ap = fopen("dhry.res","a+")) == NULL) { printf("Can not open dhry.res\n\n"); exit(1); } #endif */ /* CHANGE: We don't have a malloc function. Next_Ptr_Glob = (Rec_Pointer) malloc (sizeof (Rec_Type)); Ptr_Glob = (Rec_Pointer) malloc (sizeof (Rec_Type)); */ Next_Ptr_Glob = &Next_Rec_Glob; Ptr_Glob = &Rec_Glob; Ptr_Glob->Ptr_Comp = Next_Ptr_Glob; Ptr_Glob->Discr = Ident_1; Ptr_Glob->variant.Enum_Comp = Ident_3; Ptr_Glob->variant.Int_Comp = 40; strcpy (Ptr_Glob->variant.Str_Comp, some_string); strcpy (Str_1_Loc, first_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. */ /* CHANGE: No printing necessary! printf ("\n"); printf ("Dhrystone Benchmark, Version 2.1 (Language: C)\n"); printf ("\n");*/ /* if (Reg) { printf ("Program compiled with 'register' attribute\n"); printf ("\n"); } else { printf ("Program compiled without 'register' attribute\n"); printf ("\n"); } */ /* CHANGE: We'll never run this on sde and we set the number of runs at the beginning of main, so we don't need to read it! #if #system(sde) // Call a non-inlineable function to prevent loop unrolling // from knowing the number of loops. Number_Of_Runs = number_of_runs (); #else printf ("Please give the number of runs through the benchmark: "); { int n; scanf ("%d", &n); Number_Of_Runs = n; } printf ("\n"); #endif */ /* CHANGE: Instead of printing that execution starts here, we'll flash some LEDs. printf ("Execution starts, %d runs through Dhrystone\n",Number_Of_Runs); */ /* Initialize the LCD. */ initLCD(); sendInst( L_disp ); /* The LEDs count down one at a time, then flash to indicate the beginning of tests. */ setLED(0x8); dispMessage(str_title, str_starting); delay1000clock(200); setLED(0x4); move(0x4C); dispChar( '3' ); delay1000clock(200); setLED(0x2); move(0x4C); dispChar( '2' ); delay1000clock(200); setLED(0x1); move(0x4C); dispChar( '1' ); delay1000clock(200); setLED(0xF); move(0x4C); dispChar( '0' ); delay1000clock(50); dispMessage(str_running, str_empty); setLED(0x0); /***************/ /* Start timer */ /***************/ /* CHANGE: No more internal timing. 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, second_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, third_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" */ /**************/ /* Stop timer */ /**************/ setLED(0xF); /* Flash the LEDs to indicate the end of the tests. */ for(i = 0; i < 3; ++i) { setLED(0xF); delay1000clock(100); setLED(0x0); delay1000clock(100); } /* Check all of the results, and display pass or fail on the LEDs. */ /* Assume tests succeeded and challenge. */ testsSucceeded = (Int_Glob == 5) && (Bool_Glob == 1) && (Ch_1_Glob == 'A') && (Ch_2_Glob == 'B') && (Arr_1_Glob[8] == 7) && (Arr_2_Glob[8][7] == Number_Of_Runs + 10) && ((int)Ptr_Glob->Ptr_Comp == (int)Next_Ptr_Glob->Ptr_Comp) && (Ptr_Glob->Discr == 0) && (Ptr_Glob->variant.Enum_Comp == 2) && (Ptr_Glob->variant.Int_Comp == 17) && !strcmp(Ptr_Glob->variant.Str_Comp, some_string) && // strcmp returns 0 if they're the same! (Next_Ptr_Glob->Discr == 0) && (Next_Ptr_Glob->variant.Enum_Comp == 1) && (Next_Ptr_Glob->variant.Int_Comp == 18) && !strcmp(Next_Ptr_Glob->variant.Str_Comp, some_string) && (Int_1_Loc == 5) && (Int_2_Loc == 13) && (Int_3_Loc == 7) && (Enum_Loc == 1) && !strcmp(Str_1_Loc, first_string) && !strcmp(Str_2_Loc, second_string); if(testsSucceeded) { dispMessage(str_done, str_success); /* LEDs show fireworks */ while(1) { setLED(0x2); delay1000clock(100); setLED(0x5); delay1000clock(100); setLED(0x8); delay1000clock(100); setLED(0x0); delay1000clock(500); setLED(0x4); delay1000clock(100); setLED(0xA); delay1000clock(100); setLED(0x1); delay1000clock(100); setLED(0x0); delay1000clock(700); } } else { dispMessage(str_done, str_failure); /* LEDs flash quickly */ while(1) { setLED(0xF); delay1000clock(50); setLED(0x0); delay1000clock(50); } } /* CHANGE: We don't print any of the data, but we'll validate it and flash the LEDs accordingly. End_Time = dtime(); printf ("Execution ends\n"); printf ("\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.Enum_Comp); printf (" should be: %d\n", 2); printf (" Int_Comp: %d\n", Ptr_Glob->variant.Int_Comp); printf (" should be: %d\n", 17); printf (" Str_Comp: %s\n", Ptr_Glob->variant.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.Enum_Comp); printf (" should be: %d\n", 1); printf (" Int_Comp: %d\n", Next_Ptr_Glob->variant.Int_Comp); printf (" should be: %d\n", 18); printf (" Str_Comp: %s\n", Next_Ptr_Glob->variant.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) { printf ("Measured time too small to obtain meaningful results\n"); printf ("Please increase number of runs\n"); printf ("\n"); } 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; */ /* CHANGE: All of these data will be recorded by a human datataker and a stopwatch. #ifdef ROPT printf ("Register option selected? YES\n"); #else printf ("Register option selected? NO\n"); // XXX bug in dhrystone - writes beyond end of Reg_Define XXX // strcpy(Reg_Define, "Register option not selected."); #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"); #if !#system(sde) fprintf(Ap,"\n"); fprintf(Ap,"Dhrystone Benchmark, Version 2.1 (Language: C)\n"); #ifdef ROPT fprintf(Ap,"%s\n",Reg_Define); #else fprintf (Ap,"Register option not selected.\n"); #endif 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); #endif } */ return (0); } /* End of main() */