home *** CD-ROM | disk | FTP | other *** search
/ Programmer 7500 / MAX_PROGRAMMERS.iso / INFO / MODEM / MUFUS32R.ZIP / MUFTIMER.PAS < prev    next >
Encoding:
Pascal/Delphi Source File  |  1991-09-06  |  20.4 KB  |  446 lines
  1. (*$R-,V-*)
  2. UNIT MufTimer;
  3.  
  4. INTERFACE
  5.  
  6. USES
  7.    Dos, MufGlobs;
  8.  
  9.    PROCEDURE Adjust_Hour( VAR Hour : INTEGER;
  10.                           VAR AmPm : ShortStr );
  11.    FUNCTION TimeOfDay : LONGINT;
  12.    FUNCTION TimeDiff( Timer1, Timer2: LONGINT ) : LONGINT;
  13.    FUNCTION TimeString( Timer_Value  : LONGINT;
  14.                         Timer_Format : Time_Format_Type ) : ShortStr;
  15.    FUNCTION DateString : ShortStr;
  16.    FUNCTION DialDateString: ShortStr;
  17.  
  18.    FUNCTION TimeOfDayH : LONGINT;
  19.    FUNCTION TimeDiffH( Timer1, Timer2: LONGINT ) : LONGINT;
  20.    FUNCTION TimeStringH( Timer_Value  : LONGINT;
  21.                          Timer_Format : Time_Format_Type ) : ShortStr;
  22.  
  23. IMPLEMENTATION
  24.  
  25. (*--------------------------------------------------------------------------*)
  26. (*        Adjust_Hour --- Convert 24 hour time to 12 hour am/pm             *)
  27. (*--------------------------------------------------------------------------*)
  28.  
  29. PROCEDURE Adjust_Hour( VAR Hour : INTEGER;
  30.                        VAR AmPm : ShortStr );
  31.  
  32. (*----------------------------------------------------------------------*)
  33. (*                                                                      *)
  34. (*    Procedure: Adjust_Hour                                            *)
  35. (*                                                                      *)
  36. (*    Purpose:   Converts 24 hour time to 12 hour am/pm time            *)
  37. (*                                                                      *)
  38. (*    Calling sequence:                                                 *)
  39. (*                                                                      *)
  40. (*       Adjust_Hour( VAR Hour : INTEGER; AmPm : ShortStr );            *)
  41. (*                                                                      *)
  42. (*          Hour --- Input = Hours in 24 hour form;                     *)
  43. (*                   Output = Hours in 12 hour form.                    *)
  44. (*          AmPm --- Output 'am' or 'pm' indicator                      *)
  45. (*                                                                      *)
  46. (*----------------------------------------------------------------------*)
  47.  
  48. BEGIN (* Adjust_Hour *)
  49.  
  50.    IF ( Hour < 12 ) THEN
  51.       BEGIN
  52.          AmPm := 'am';
  53.          IF ( Hour = 0 ) THEN
  54.             Hour := 12;
  55.       END
  56.    ELSE
  57.       BEGIN
  58.          AmPm := 'pm';
  59.          IF ( Hour <> 12 ) THEN
  60.             Hour := Hour - 12;
  61.       END;
  62.  
  63. END   (* Adjust_Hour *);
  64.  
  65. (*--------------------------------------------------------------------------*)
  66. (*                TimeOfDay  --- Get time of day                            *)
  67. (*--------------------------------------------------------------------------*)
  68.  
  69. FUNCTION TimeOfDay : LONGINT;
  70.  
  71. (*--------------------------------------------------------------------------*)
  72. (*                                                                          *)
  73. (*     Function:  TimeOfDay                                                 *)
  74. (*                                                                          *)
  75. (*     Purpose:   Gets time of day from internal clock                      *)
  76. (*                                                                          *)
  77. (*     Calling sequence:                                                    *)
  78. (*                                                                          *)
  79. (*        Tod := TimeOfDay : LONGINT;                                       *)
  80. (*                                                                          *)
  81. (*           Tod --- Long integer number which is timer value expressed in  *)
  82. (*                   seconds as:                                            *)
  83. (*                   ( 3600 x hour + 60 x minutes + seconds )               *)
  84. (*                                                                          *)
  85. (*     Calls:  GetTime                                                      *)
  86. (*                                                                          *)
  87. (*--------------------------------------------------------------------------*)
  88.  
  89. VAR
  90.    Hours   : WORD;
  91.    Minutes : WORD;
  92.    Seconds : WORD;
  93.    SecHun  : WORD;
  94.  
  95.    TimeVal : LONGINT;
  96.  
  97. BEGIN (* TimeOfDay *)
  98.  
  99.    GetTime( Hours, Minutes, Seconds, SecHun );
  100.  
  101.    TimeVal    := Hours;
  102.    TimeOfDay  := TimeVal * 3600 + Minutes * 60 + Seconds;
  103.  
  104. END   (* TimeOfDay *);
  105.  
  106. (*--------------------------------------------------------------------------*)
  107. (*        TimeDiff  --- Get difference in time between two timer values     *)
  108. (*--------------------------------------------------------------------------*)
  109.  
  110. FUNCTION TimeDiff( Timer1, Timer2: LONGINT ) : LONGINT;
  111.  
  112. (*--------------------------------------------------------------------------*)
  113. (*                                                                          *)
  114. (*     Function:  TimeDiff                                                  *)
  115. (*                                                                          *)
  116. (*     Purpose:   Get difference in time between two timer values in        *)
  117. (*                seconds.                                                  *)
  118. (*                                                                          *)
  119. (*     Calling sequence:                                                    *)
  120. (*                                                                          *)
  121. (*        TDiff := TimeDiff( Timer1, Timer2: LONGINT ) : LONGINT;           *)
  122. (*                                                                          *)
  123. (*           Timer1  --- first timer value (earlier)                        *)
  124. (*           Timer2  --- second timer value (later)                         *)
  125. (*                                                                          *)
  126. (*           TDiff   --- difference between timer values                    *)
  127. (*                                                                          *)
  128. (*     Calls:  None                                                         *)
  129. (*                                                                          *)
  130. (*     Remarks:                                                             *)
  131. (*                                                                          *)
  132. (*        This routine will handle time wrap around midnight.  However, it  *)
  133. (*        only handles timer values <= 24 hours in duration.                *)
  134. (*                                                                          *)
  135. (*--------------------------------------------------------------------------*)
  136.  
  137. CONST
  138.    Secs_Per_Day = 86400    (* Seconds in one day *);
  139.  
  140. VAR
  141.    TDiff : LONGINT;
  142.  
  143. BEGIN (* TimeDiff *)
  144.  
  145.    TDiff := Timer2 - Timer1;
  146.  
  147.    IF ( TDiff < 0 ) THEN 
  148.       TDiff := TDiff + Secs_Per_Day;
  149.  
  150.    TimeDiff := TDiff;
  151.  
  152. END   (* TimeDiff *);
  153.  
  154. (*--------------------------------------------------------------------------*)
  155. (*          TimeString  --- convert timer value to string                   *)
  156. (*--------------------------------------------------------------------------*)
  157.  
  158. FUNCTION TimeString( Timer_Value  : LONGINT;
  159.                      Timer_Format : Time_Format_Type ) : ShortStr;
  160.  
  161. (*--------------------------------------------------------------------------*)
  162. (*                                                                          *)
  163. (*     Function:  TimeString                                                *)
  164. (*                                                                          *)
  165. (*     Purpose:   Convert elapsed timer value to HH:MM:SS string            *)
  166. (*                                                                          *)
  167. (*     Calling sequence:                                                    *)
  168. (*                                                                          *)
  169. (*        Tstring := TimeString( Timer_Value  : LONGINT;                    *)
  170. (*                               Timer_Format : Time_Format_Type ) :        *)
  171. (*                               AnyStr;                                    *)
  172. (*                                                                          *)
  173. (*           Timer_Value ---  Number which is timer value expressed as      *)
  174. (*                            seconds from 12 am.                           *)
  175. (*           Timer_Format --- Format type for time                          *)
  176. (*           Tstring      --- Resultant 'HH:MM:SS' form of time             *)
  177. (*                                                                          *)
  178. (*     Calls:  None                                                         *)
  179. (*                                                                          *)
  180. (*--------------------------------------------------------------------------*)
  181.  
  182. VAR
  183.    Hours   : INTEGER;
  184.    SaveHrs : LONGINT;
  185.    Minutes : INTEGER;
  186.    Seconds : INTEGER;
  187.    Save_H  : LONGINT;
  188.    SH      : STRING[2];
  189.    SM      : STRING[2];
  190.    SS      : STRING[2];
  191.    AmPm    : STRING[3];
  192.  
  193. BEGIN (* TimeString *)
  194.  
  195.    Hours   := Timer_Value DIV 3600;
  196.    SaveHrs := Hours;
  197.    AmPm    := '';
  198.  
  199.    IF ( Timer_Format = AMPM_Time ) THEN
  200.       BEGIN
  201.          Adjust_Hour( Hours , AmPm );
  202.          AmPm := ' ' + AmPm;
  203.       END;
  204.  
  205.    Save_H  := Timer_Value - SaveHrs * 3600;
  206.    Minutes := Save_H DIV 60;
  207.    Seconds := Save_H - Minutes * 60;
  208.  
  209.    STR( Hours:2,   SH );
  210.    STR( Minutes:2, SM );
  211.    STR( Seconds:2, SS );
  212.  
  213.    IF ( Timer_Format <> AMPM_Time ) THEN
  214.       IF SH[1] = ' ' THEN SH[1] := '0';
  215.    IF SM[1] = ' ' THEN SM[1] := '0';
  216.    IF SS[1] = ' ' THEN SS[1] := '0';
  217.  
  218.    TimeString := SH + ':' + SM + ':' + SS + AmPm;
  219.  
  220. END   (* TimeString *);
  221.  
  222. (*--------------------------------------------------------------------------*)
  223. (*             DateString  --- Return current date in string form           *)
  224. (*--------------------------------------------------------------------------*)
  225.  
  226. FUNCTION DateString : ShortStr;
  227.  
  228. (*--------------------------------------------------------------------------*)
  229. (*                                                                          *)
  230. (*     Function:  DateString                                                *)
  231. (*                                                                          *)
  232. (*     Purpose:   Returns current date in string form                       *)
  233. (*                                                                          *)
  234. (*     Calling sequence:                                                    *)
  235. (*                                                                          *)
  236. (*        Dstring := DateString: AnyStr;                                    *)
  237. (*                                                                          *)
  238. (*           Dstring     --- Resultant string form of date                  *)
  239. (*                                                                          *)
  240. (*     Calls:  GetDate                                                      *)
  241. (*                                                                          *)
  242. (*--------------------------------------------------------------------------*)
  243.  
  244. VAR
  245.    SMonth:         STRING[2];
  246.    SDay:           STRING[2];
  247.    SYear:          STRING[4];
  248.    Month:          WORD;
  249.    Day:            WORD;
  250.    Year:           WORD;
  251.    DayOfWeek:      WORD;
  252.  
  253. BEGIN (* DateString *)
  254.                                    (* Date function *)
  255.  
  256.    GetDate( Year, Month, Day, DayOfWeek );
  257.  
  258.                                    (* Convert date to string *)
  259.    STR( Year  , SYear  );
  260.    STR( Day   , SDay   );
  261.    STR( Month , SMonth );
  262.  
  263.    CASE Date_Format OF
  264.       YMD_Style: DateString := SYear  + '/' + SMonth + '/' + SDay;
  265.       DMY_Style: DateString := SDay   + '/' + SMonth + '/' + SYear;
  266.       ELSE
  267.          DateString := SMonth + '/' + SDay + '/' + SYear;
  268.    END (* CASE *);
  269.  
  270. END   (* DateString *);
  271.  
  272. (*--------------------------------------------------------------------------*)
  273. (*              DialDateString  --- Return current date                     *)
  274. (*--------------------------------------------------------------------------*)
  275.  
  276. FUNCTION DialDateString : ShortStr;
  277.  
  278. (*--------------------------------------------------------------------------*)
  279. (*                                                                          *)
  280. (*     Function:  DialDateString                                            *)
  281. (*                                                                          *)
  282. (*     Purpose:   Returns current date in string form                       *)
  283. (*                                                                          *)
  284. (*     Calling sequence:                                                    *)
  285. (*                                                                          *)
  286. (*        Dstring := DialDateString: AnyStr;                                *)
  287. (*                                                                          *)
  288. (*           Dstring     --- Resultant string form of date                  *)
  289. (*                                                                          *)
  290. (*     Calls:  GetDate                                                      *)
  291. (*                                                                          *)
  292. (*--------------------------------------------------------------------------*)
  293.  
  294. VAR
  295.    SMonth:         STRING[2];
  296.    SDay:           STRING[2];
  297.    SYear:          STRING[4];
  298.    Month:          WORD;
  299.    Day:            WORD;
  300.    Year:           WORD;
  301.    DayOfWeek:      WORD;
  302.  
  303. BEGIN (* DialDateString *)
  304.                                    (* Date function *)
  305.  
  306.    GetDate( Year, Month, Day, DayOfWeek );
  307.  
  308.                                    (* Convert date to string *)
  309.    STR( Year  : 4  , SYear  );
  310.    STR( Day   : 2  , SDay   );
  311.    STR( Month : 2  , SMonth );
  312.  
  313.    IF ( SDay[1]   = ' ' ) THEN SDay[1]   := '0';
  314.    IF ( SMonth[1] = ' ' ) THEN SMonth[1] := '0';
  315.  
  316.    DialDateString := SYear[3] + SYear[4] + '/' + SMonth + '/' + SDay;
  317.  
  318. END   (* DialDateString *);
  319.  
  320. (*--------------------------------------------------------------------------*)
  321. (*      TimeOfDayH  --- Get time of day in 1/100 seconds from midnight      *)
  322. (*--------------------------------------------------------------------------*)
  323.  
  324. FUNCTION TimeOfDayH : LONGINT;
  325.  
  326. (*--------------------------------------------------------------------------*)
  327. (*                                                                          *)
  328. (*     Function:  TimeOfDayH                                                *)
  329. (*                                                                          *)
  330. (*     Purpose:   Gets time of day from internal clock in 1/100 seconds     *)
  331. (*                                                                          *)
  332. (*     Calling sequence:                                                    *)
  333. (*                                                                          *)
  334. (*        Tod := TimeOfDayH : LONGINT;                                      *)
  335. (*                                                                          *)
  336. (*           Tod --- Real number which is timer value expressed in          *)
  337. (*                   hundredths of seconds as:                              *)
  338. (*                   ( 360000 x hour + 6000 x minutes + 100 x seconds +     *)
  339. (*                     hundredths of seconds ).                             *)
  340. (*                                                                          *)
  341. (*     Calls:  GetTime                                                      *)
  342. (*                                                                          *)
  343. (*--------------------------------------------------------------------------*)
  344.  
  345. VAR
  346.    Hours   : WORD;
  347.    Minutes : WORD;
  348.    Seconds : WORD;
  349.    SecHun  : WORD;
  350.  
  351.    TimerVal: LONGINT;
  352.  
  353. BEGIN (* TimeOfDayH *)
  354.  
  355.    GetTime( Hours, Minutes, Seconds, SecHun );
  356.  
  357.    TimerVal    := Hours;
  358.    TimeOfDayH  := TimerVal * 360000 + Minutes * 6000 + Seconds * 100 + SecHun;
  359.  
  360. END   (* TimeOfDayH *);
  361.  
  362. (*--------------------------------------------------------------------------*)
  363. (*       TimeDiffH  --- Get difference in time between two timer values     *)
  364. (*--------------------------------------------------------------------------*)
  365.  
  366. FUNCTION TimeDiffH( Timer1, Timer2: LONGINT ) : LONGINT;
  367.  
  368. (*--------------------------------------------------------------------------*)
  369. (*                                                                          *)
  370. (*     Function:  TimeDiffH                                                 *)
  371. (*                                                                          *)
  372. (*     Purpose:   Get difference in time between two timer values           *)
  373. (*                in hundredths of seconds.                                 *)
  374. (*                                                                          *)
  375. (*     Calling sequence:                                                    *)
  376. (*                                                                          *)
  377. (*        Tdiff := TimeDiffH( Timer1, Timer2: LONGINT ) : REAL;             *)
  378. (*                                                                          *)
  379. (*           Timer1  --- first timer value (earlier)                        *)
  380. (*           Timer2  --- second timer value (later)                         *)
  381. (*                                                                          *)
  382. (*           Tdiff   --- difference between timer values                    *)
  383. (*                                                                          *)
  384. (*     Calls:  None                                                         *)
  385. (*                                                                          *)
  386. (*     Remarks:                                                             *)
  387. (*                                                                          *)
  388. (*        This routine will handle time wrap around midnight.  However, it  *)
  389. (*        only handles timer values <= 24 hours in duration.                *)
  390. (*                                                                          *)
  391. (*--------------------------------------------------------------------------*)
  392.  
  393. CONST
  394.    Hundredths_Secs_Per_Day = 8640000    (* 1/100 Seconds in one day *);
  395.  
  396. VAR
  397.    TDiff : LONGINT;
  398.  
  399. BEGIN (* TimeDiffH *)
  400.  
  401.    TDiff := Timer2 - Timer1;
  402.  
  403.    IF Tdiff < 0 THEN Tdiff := Tdiff + Hundredths_Secs_Per_Day;
  404.  
  405.    TimeDiffH := Tdiff;
  406.  
  407. END   (* TimeDiffH *);
  408.  
  409. (*--------------------------------------------------------------------------*)
  410. (*      TimeStringH  --- convert timer value in 1/100 secs to string        *)
  411. (*--------------------------------------------------------------------------*)
  412.  
  413. FUNCTION TimeStringH( Timer_Value  : LONGINT;
  414.                       Timer_Format : Time_Format_Type ) : ShortStr;
  415.  
  416. (*--------------------------------------------------------------------------*)
  417. (*                                                                          *)
  418. (*     Function:  TimeStringH                                               *)
  419. (*                                                                          *)
  420. (*     Purpose:   Convert elapsed timer value to HH:MM:SS string            *)
  421. (*                                                                          *)
  422. (*     Calling sequence:                                                    *)
  423. (*                                                                          *)
  424. (*        Tstring := TimeStringH( Timer_Value  : LONGINT;                   *)
  425. (*                                Timer_Format : Time_Format_Type ) :       *)
  426. (*                                AnyStr;                                   *)
  427. (*                                                                          *)
  428. (*           Timer_Value ---  Real number which is timer value expressed as *)
  429. (*                            1/100th seconds from 12 am.                   *)
  430. (*           Timer_Format --- Format type for time                          *)
  431. (*           Tstring      --- Resultant 'HH:MM:SS' form of time             *)
  432. (*                                                                          *)
  433. (*     Calls:  None                                                         *)
  434. (*                                                                          *)
  435. (*--------------------------------------------------------------------------*)
  436.  
  437. BEGIN (* TimeStringH *)
  438.  
  439.    TimeStringH := TimeString( Timer_Value DIV 100 , Timer_Format );
  440.  
  441. END   (* TimeStringH *);
  442.  
  443.  
  444. END (* PibTimer *).
  445.  
  446.