?login_element?

Subversion Repositories NedoOS

Rev

Rev 1465 | Blame | Compare with Previous | Last modification | View Log | Download

  1.  
  2. #include <stdlib.h>
  3. #include <stdio.h>
  4. #include <string.h>
  5. #include <oscalls.h>
  6. #include <intrz80.h>
  7. #define COMMANDLINE 0x0080
  8.  
  9.  
  10.  
  11. /* Accuracy of timings and human fatigue controlled by next two lines */
  12. //#define LOOPS 5000            /* Use this for slow or 16 bit machines */
  13. #define LOOPS   50000           /* Use this for slow or 16 bit machines */
  14. //#define LOOPS 500000          /* Use this for faster machines */
  15.  
  16. /* Compiler dependent options */
  17. //#undef        NOENUM                  /* Define if compiler has no enum's */
  18. //#undef        NOSTRUCTASSIGN          /* Define if compiler can't assign structures */
  19.  
  20. /* define only one of the next three defines */
  21. //#define GETRUSAGE             /* Use getrusage(2) time function */
  22. //#define TIMES                 /* Use times(2) time function */
  23. #define TIME                    /* Use time(2) time function */
  24. //#define TIME_EVO_IAR                  /* Use time(2) time function */
  25.  
  26.  
  27. /* define the granularity of your times(2) function (when used) */
  28. //#define HZ    60              /* times(2) returns 1/60 second (most) */
  29. //#define HZ    100             /* times(2) returns 1/100 second (WECo) */
  30. #define HZ      50              /* times(2) returns 1/50 second (ZX-Evo) */
  31. //#define HZ    1               /* for time(2) */
  32.  
  33. /* for compatibility with goofed up version */
  34. //#define GOOF                  /* Define if you want the goofed up version */
  35.  
  36. #ifdef GOOF
  37. char    Version[] = "1.0";
  38. #else
  39. char    Version[] = "1.1";
  40. #endif
  41.  
  42. #ifdef  NOSTRUCTASSIGN
  43. #define structassign(d, s)      memcpy(&(d), &(s), sizeof(d))
  44. #else
  45. #define structassign(d, s)      d = s
  46. #endif
  47.  
  48. #ifdef  NOENUM
  49. #define Ident1  1
  50. #define Ident2  2
  51. #define Ident3  3
  52. #define Ident4  4
  53. #define Ident5  5
  54. typedef int     Enumeration;
  55. #else
  56. typedef enum    {Ident1, Ident2, Ident3, Ident4, Ident5} Enumeration;
  57. #endif
  58.  
  59. typedef int     OneToThirty;
  60. typedef int     OneToFifty;
  61. typedef char    CapitalLetter;
  62. typedef char    String30[31];
  63. typedef int     Array1Dim[51];
  64. typedef int     Array2Dim[51][51];
  65.  
  66. struct  Record
  67. {
  68.         struct Record           *PtrComp;
  69.         Enumeration             Discr;
  70.         Enumeration             EnumComp;
  71.         OneToFifty              IntComp;
  72.         String30                StringComp;
  73. };
  74.  
  75. typedef struct Record   RecordType;
  76. typedef RecordType *    RecordPtr;
  77. typedef int             boolean;
  78.  
  79. //#define       NULL            0
  80. #define TRUE            1
  81. #define FALSE           0
  82.  
  83. #ifndef REG
  84. #define REG
  85. #endif
  86.  
  87. #ifdef TIMES
  88. #include <sys/param.h>
  89. #include <sys/types.h>
  90. #include <sys/times.h>
  91. #endif
  92. #ifdef GETRUSAGE
  93. #include <sys/time.h>
  94. #include <sys/resource.h>
  95. #endif
  96. #ifdef TIME_EVO_IAR
  97. #include <string.h>
  98. #include <intrz80.h>
  99. #include <stdio.h>
  100. #include "conio.h"
  101. #endif
  102.  
  103.  
  104. /*
  105.  * Package 1
  106.  */
  107. int             IntGlob;
  108. boolean         BoolGlob;
  109. char            Char1Glob;
  110. char            Char2Glob;
  111. Array1Dim       Array1Glob;
  112. Array2Dim       Array2Glob;
  113. RecordPtr       PtrGlb;
  114. RecordPtr       PtrGlbNext;
  115. void Proc4(void );
  116. void Proc5(void );
  117. Enumeration Func1(CapitalLetter CharPar1,CapitalLetter  CharPar2);
  118. boolean Func2(String30  StrParI1,String30       StrParI2);
  119. void Proc1(REG RecordPtr        PtrParIn);
  120. void Proc2(OneToFifty   *IntParIO);
  121. void Proc3(RecordPtr    *PtrParOut);
  122. void Proc6(REG Enumeration      EnumParIn, REG Enumeration      *EnumParOut);
  123. void Proc7(OneToFifty   IntParI1, OneToFifty    IntParI2, OneToFifty    *IntParOut);
  124. void Proc8(Array1Dim    Array1Par,Array2Dim     Array2Par,OneToFifty    IntParI1,OneToFifty     IntParI2);
  125. boolean Func3(REG Enumeration   EnumParIn);
  126.  
  127. void Proc0(void )
  128. {
  129.         OneToFifty              IntLoc1;
  130.         REG OneToFifty          IntLoc2;
  131.         OneToFifty              IntLoc3;
  132.         REG char                CharLoc;
  133.         REG char                CharIndex;
  134.         Enumeration             EnumLoc;
  135.         String30                String1Loc;
  136.         String30                String2Loc;
  137.         RecordType _GlbNext;
  138.         RecordType _Glb;
  139.  
  140.         register unsigned int   i;
  141. #ifdef TIME
  142.         long                    time(void);
  143.         long                    starttime;
  144.         long                    benchtime;
  145.         long                    nulltime;
  146.  
  147.         starttime = time(/* (long *) 0*/);
  148.         for (i = 0; i < LOOPS; ++i);
  149.         nulltime = time(/* (long *) 0*/) - starttime; /* Computes o'head of loop */
  150. #endif
  151. #ifdef TIMES
  152.         time_t                  starttime;
  153.         time_t                  benchtime;
  154.         time_t                  nulltime;
  155.         struct tms              tms;
  156.  
  157.         times(&tms); starttime = tms.tms_utime;
  158.         for (i = 0; i < LOOPS; ++i);
  159.         times(&tms);
  160.         nulltime = tms.tms_utime - starttime; /* Computes overhead of looping */
  161. #endif
  162. #ifdef TIME_EVO_IAR
  163.         extern long     int_timer;
  164.         long                    starttime;
  165.         long                    benchtime;
  166.         long                    nulltime;
  167.        
  168.         MCU_Init();
  169.  
  170.         textbackground(BLUE);
  171.         clrscr();
  172.         textcolor(BLACK);
  173.         textbackground(CYAN);
  174.         enable_interrupt();
  175.         halt();
  176.         starttime = int_timer;
  177.         for (i = 0; i < LOOPS; ++i);
  178.         halt();
  179.         nulltime = int_timer - starttime; /* Computes overhead of looping */
  180. #endif
  181. #ifdef GETRUSAGE
  182.         struct rusage starttime;
  183.         struct rusage endtime;
  184.         struct timeval nulltime;
  185.  
  186.         getrusage(RUSAGE_SELF, &starttime);
  187.         for (i = 0; i < LOOPS; ++i);
  188.         getrusage(RUSAGE_SELF, &endtime);
  189.         nulltime.tv_sec  = endtime.ru_utime.tv_sec  - starttime.ru_utime.tv_sec;
  190.         nulltime.tv_usec = endtime.ru_utime.tv_usec - starttime.ru_utime.tv_usec;
  191. #endif
  192.  
  193.         PtrGlbNext = &_GlbNext;
  194.         PtrGlb = &_Glb;
  195.         PtrGlb->PtrComp = PtrGlbNext;
  196.         PtrGlb->Discr = Ident1;
  197.         PtrGlb->EnumComp = Ident3;
  198.         PtrGlb->IntComp = 40;
  199.         strcpy(PtrGlb->StringComp, "DHRYSTONE PROGRAM, SOME STRING");
  200. #ifndef GOOF
  201.         strcpy(String1Loc, "DHRYSTONE PROGRAM, 1'ST STRING");   /*GOOF*/
  202. #endif
  203.         Array2Glob[8][7] = 10;  /* Was missing in published program */
  204.  
  205. /*****************
  206. -- Start Timer --
  207. *****************/
  208. #ifdef TIME
  209.         starttime = time(/* (long *) 0*/);
  210. #endif
  211. #ifdef TIMES
  212.         times(&tms); starttime = tms.tms_utime;
  213. #endif
  214. #ifdef TIME_EVO_IAR
  215.         halt();
  216.         starttime = int_timer;
  217. #endif
  218. #ifdef GETRUSAGE
  219.         getrusage (RUSAGE_SELF, &starttime);
  220. #endif
  221.         for (i = 0; i < LOOPS; ++i)
  222.         {
  223.  
  224.                 Proc5();
  225.                 Proc4();
  226.                 IntLoc1 = 2;
  227.                 IntLoc2 = 3;
  228.                 strcpy(String2Loc, "DHRYSTONE PROGRAM, 2'ND STRING");
  229.                 EnumLoc = Ident2;
  230.                 BoolGlob = ! Func2(String1Loc, String2Loc);
  231.                 while (IntLoc1 < IntLoc2)
  232.                 {
  233.                         IntLoc3 = 5 * IntLoc1 - IntLoc2;
  234.                         Proc7(IntLoc1, IntLoc2, &IntLoc3);
  235.                         ++IntLoc1;
  236.                 }
  237.                 Proc8(Array1Glob, Array2Glob, IntLoc1, IntLoc3);
  238.                 Proc1(PtrGlb);
  239.                 for (CharIndex = 'A'; CharIndex <= Char2Glob; ++CharIndex)
  240.                         if (EnumLoc == Func1(CharIndex, 'C'))
  241.                                 Proc6(Ident1, &EnumLoc);
  242.                 IntLoc3 = IntLoc2 * IntLoc1;
  243.                 IntLoc2 = IntLoc3 / IntLoc1;
  244.                 IntLoc2 = 7 * (IntLoc3 - IntLoc2) - IntLoc1;
  245.                 Proc2(&IntLoc1);
  246.         }
  247.  
  248. /*****************
  249. -- Stop Timer --
  250. *****************/
  251.  
  252. #ifdef TIME
  253.         benchtime = time(/* (long *) 0*/) - starttime - nulltime;
  254.         printf("Dhrystone(%s) time for %ld passes = %ld\r\n",
  255.                 Version,
  256.                 (long) LOOPS, benchtime/HZ);
  257.         printf("This machine benchmarks at %ld dhrystones/second\r\n",
  258.                 ((long) LOOPS) * HZ / benchtime);
  259. #endif
  260. #ifdef TIMES
  261.         times(&tms);
  262.         benchtime = tms.tms_utime - starttime - nulltime;
  263.         printf("Dhrystone(%s) time for %ld passes = %ld\r\n",
  264.                 Version,
  265.                 (long) LOOPS, benchtime/HZ);
  266.         printf("This machine benchmarks at %ld dhrystones/second\r\n",
  267.                 ((long) LOOPS) * HZ / benchtime);
  268. #endif
  269. #ifdef TIME_EVO_IAR
  270.         halt();
  271.         benchtime = int_timer - starttime - nulltime;
  272.         printf("Dhrystone(%s) time for %ld passes = %ld\r\n",
  273.                 Version,
  274.                 (long) LOOPS, benchtime/HZ);
  275.         printf("This machine benchmarks at %ld dhrystones/second\r\n",
  276.                 ((long) LOOPS) * HZ / benchtime);
  277. #endif
  278. #ifdef GETRUSAGE
  279.         getrusage(RUSAGE_SELF, &endtime);
  280.         {
  281.             double t = (double)(endtime.ru_utime.tv_sec
  282.                                 - starttime.ru_utime.tv_sec
  283.                                 - nulltime.tv_sec)
  284.                      + (double)(endtime.ru_utime.tv_usec
  285.                                 - starttime.ru_utime.tv_usec
  286.                                 - nulltime.tv_usec) * 1e-6;
  287.             printf("Dhrystone(%s) time for %ld passes = %.1f\r\n",
  288.                    Version,
  289.                    (long)LOOPS,
  290.                    t);
  291.             printf("This machine benchmarks at %.0f dhrystones/second\r\n",
  292.                    (double)LOOPS / t);
  293.         }
  294. #endif
  295.  
  296. }
  297.  
  298. void Proc1(REG RecordPtr        PtrParIn)
  299. {
  300. #define NextRecord      (*(PtrParIn->PtrComp))
  301.  
  302.         structassign(NextRecord, *PtrGlb);
  303.         PtrParIn->IntComp = 5;
  304.         NextRecord.IntComp = PtrParIn->IntComp;
  305.         NextRecord.PtrComp = PtrParIn->PtrComp;
  306.         Proc3(&NextRecord.PtrComp);
  307.         if (NextRecord.Discr == Ident1)
  308.         {
  309.                 NextRecord.IntComp = 6;
  310.                 Proc6(PtrParIn->EnumComp, &NextRecord.EnumComp);
  311.                 NextRecord.PtrComp = PtrGlb->PtrComp;
  312.                 Proc7(NextRecord.IntComp, 10, &NextRecord.IntComp);
  313.         }
  314.         else
  315.                 structassign(*PtrParIn, NextRecord);
  316.  
  317. #undef  NextRecord
  318. }
  319.  
  320. void Proc2(OneToFifty   *IntParIO)
  321. {
  322.         REG OneToFifty          IntLoc;
  323.         REG Enumeration         EnumLoc;
  324.  
  325.         IntLoc = *IntParIO + 10;
  326.         for(;;)
  327.         {
  328.                 if (Char1Glob == 'A')
  329.                 {
  330.                         --IntLoc;
  331.                         *IntParIO = IntLoc - IntGlob;
  332.                         EnumLoc = Ident1;
  333.                 }
  334.                 if (EnumLoc == Ident1)
  335.                         break;
  336.         }
  337. }
  338.  
  339. void Proc3(RecordPtr    *PtrParOut)
  340. {
  341.         if (PtrGlb != NULL)
  342.                 *PtrParOut = PtrGlb->PtrComp;
  343.         else
  344.                 IntGlob = 100;
  345.         Proc7(10, IntGlob, &PtrGlb->IntComp);
  346. }
  347.  
  348. void Proc4(void )
  349. {
  350.         REG boolean     BoolLoc;
  351.  
  352.         BoolLoc = Char1Glob == 'A';
  353.         BoolLoc |= BoolGlob;
  354.         Char2Glob = 'B';
  355. }
  356.  
  357. void Proc5(void )
  358. {
  359.         Char1Glob = 'A';
  360.         BoolGlob = FALSE;
  361. }
  362.  
  363. void Proc6(REG Enumeration      EnumParIn, REG Enumeration      *EnumParOut)
  364. {
  365.         *EnumParOut = EnumParIn;
  366.         if (! Func3(EnumParIn) )
  367.                 *EnumParOut = Ident4;
  368.         switch (EnumParIn)
  369.         {
  370.         case Ident1:    *EnumParOut = Ident1; break;
  371.         case Ident2:    if (IntGlob > 100) *EnumParOut = Ident1;
  372.                         else *EnumParOut = Ident4;
  373.                         break;
  374.         case Ident3:    *EnumParOut = Ident2; break;
  375.         case Ident4:    break;
  376.         case Ident5:    *EnumParOut = Ident3;
  377.         }
  378. }
  379.  
  380. void Proc7(OneToFifty   IntParI1, OneToFifty    IntParI2, OneToFifty    *IntParOut)
  381. {
  382.         REG OneToFifty  IntLoc;
  383.  
  384.         IntLoc = IntParI1 + 2;
  385.         *IntParOut = IntParI2 + IntLoc;
  386. }
  387.  
  388. void Proc8(Array1Dim    Array1Par,Array2Dim     Array2Par,OneToFifty    IntParI1,OneToFifty     IntParI2)
  389. {
  390.         REG OneToFifty  IntLoc;
  391.         REG OneToFifty  IntIndex;
  392.  
  393.         IntLoc = IntParI1 + 5;
  394.         Array1Par[IntLoc] = IntParI2;
  395.         Array1Par[IntLoc+1] = Array1Par[IntLoc];
  396.         Array1Par[IntLoc+30] = IntLoc;
  397.         for (IntIndex = IntLoc; IntIndex <= (IntLoc+1); ++IntIndex)
  398.                 Array2Par[IntLoc][IntIndex] = IntLoc;
  399.         ++Array2Par[IntLoc][IntLoc-1];
  400.         Array2Par[IntLoc+20][IntLoc] = Array1Par[IntLoc];
  401.         IntGlob = 5;
  402. }
  403.  
  404. Enumeration Func1(CapitalLetter CharPar1,CapitalLetter  CharPar2)
  405. {
  406.         REG CapitalLetter       CharLoc1;
  407.         REG CapitalLetter       CharLoc2;
  408.  
  409.         CharLoc1 = CharPar1;
  410.         CharLoc2 = CharLoc1;
  411.         if (CharLoc2 != CharPar2)
  412.                 return (Ident1);
  413.         else
  414.                 return (Ident2);
  415. }
  416.  
  417. boolean Func2(String30  StrParI1,String30       StrParI2)
  418. {
  419.         REG OneToThirty         IntLoc;
  420.         REG CapitalLetter       CharLoc;
  421.  
  422.         IntLoc = 1;
  423.         while (IntLoc <= 1)
  424.                 if (Func1(StrParI1[IntLoc], StrParI2[IntLoc+1]) == Ident1)
  425.                 {
  426.                         CharLoc = 'A';
  427.                         ++IntLoc;
  428.                 }
  429.         if (CharLoc >= 'W' && CharLoc <= 'Z')
  430.                 IntLoc = 7;
  431.         if (CharLoc == 'X')
  432.                 return(TRUE);
  433.         else
  434.         {
  435.                 if (strcmp(StrParI1, StrParI2) > 0)
  436.                 {
  437.                         IntLoc += 7;
  438.                         return (TRUE);
  439.                 }
  440.                 else
  441.                         return (FALSE);
  442.         }
  443. }
  444.  
  445. boolean Func3(REG Enumeration   EnumParIn)
  446. {
  447.         REG Enumeration EnumLoc;
  448.  
  449.         EnumLoc = EnumParIn;
  450.         if (EnumLoc == Ident3) return (TRUE);
  451.         return (FALSE);
  452. }
  453.  
  454. int main(void)
  455. {
  456.        
  457.     os_initstdio(); //Alone Coder
  458.         Proc0();
  459.         return 0; //while(1); //Alone Coder
  460. }
  461. #ifdef  NOSTRUCTASSIGN
  462. memcpy(d, s, l)
  463. register char   *d;
  464. register char   *s;
  465. register int    l;
  466. {
  467.         while (l--) *d++ = *s++;
  468. }
  469. #endif
  470. /* ---------- */
  471.  
  472.