Sage-ST ä

Timelib

Documentation

Unit Documentation (Unit description)
Global Declarations (Constants, Types, Variables)
CheckDate CheckGregorianDate
CheckTime ChronoJulianToGregorianDate ClockToDate0 ClockToTime1
ClockToTime2 ClockToTime3 ClockToTime4 ClockToTime5
CurrentDate0 CurrentDateChronoJulian CurrentTime1 CurrentTime2
CurrentTime3 CurrentTime4 CurrentTime5 CurrentWeekDay
Date0ToDate1 Date0ToDate10 Date0ToDate11 Date0ToDate12
Date0ToDate2 Date0ToDate3 Date0ToDate4 Date0ToDate5
Date0ToDate6 Date0ToDate7 Date0ToDate8 Date0ToDate9
Date0ToFractional Date0ToJulian Date10ToDate0 Date11ToDate0
Date12ToDate0 Date1ToDate0 Date2ToDate0 Date3ToDate0
Date4ToDate0 Date5ToDate0 Date6ToDate0 Date7ToDate0
Date8ToDate0 Date9ToDate0 DayOfWeek DayOfYear
DaysInMonth ElapsedTime FixGregorianDate FractionalToDate0
GregorianDateToChronoJulian IsLeapYearCard IsLeapYearStr JulianToDate0
ParseGregorianDate STRCheckDate STRCheckGregorianDate STRCheckTime
STRChronoJulianToGregorianDate STRClockToDate0 STRClockToTime1 STRClockToTime2
STRClockToTime3 STRClockToTime4 STRCurrentDate0 STRCurrentTime1
STRCurrentTime2 STRCurrentTime3 STRCurrentTime4 STRDate0ToDate1
STRDate0ToDate10 STRDate0ToDate11 STRDate0ToDate12 STRDate0ToDate2
STRDate0ToDate3 STRDate0ToDate4 STRDate0ToDate5 STRDate0ToDate6
STRDate0ToDate7 STRDate0ToDate8 STRDate0ToDate9 STRDate0ToJulian
STRDate10ToDate0 STRDate11ToDate0 STRDate12ToDate0 STRDate1ToDate0
STRDate2ToDate0 STRDate3ToDate0 STRDate4ToDate0 STRDate5ToDate0
STRDate6ToDate0 STRDate7ToDate0 STRDate8ToDate0 STRDate9ToDate0
STRDayOfWeek STRDayOfYear STRDaysInMonth STRElapsedTime
STRFixGregorianDate STRFractionalToDate0 STRGregorianDateToChronoJulian STRIsLeapYearStr
STRJulianToDate0 STRParseGregorianDate STRSTRFixGregorianDate SetTimer
StartTimer






  // *HTMLGEN InsertUnitDocStart TimeLib_UnitDoc*

  //*
  //  TimeLib - Time and date related operations.
  //
  //
  //  This unit contains routines to get and set the time and date of the
  //  system.  These routines also check various time and date strings to
  //  detect erroneous values.  Time and date values can be acquired and
  //  converted in a number of formats.
  //
  //  The dates and times have various formats which include -
  //
  //    Date No.  Date Format
  //    --------  -----------
  //      0       yyyy/mm/dd
  //      1       mm/dd/yy
  //      2       mmm dd, yyyy
  //      3       dd mmm yyyy
  //      4       dd-mmm-yy
  //      5       yyddd
  //      6       yymmdd
  //      7       yy mm dd
  //      8       yyyymmdd
  //      9       ddmmmyy
  //      10      mm/yy
  //      11      dd mmm yy
  //      12      mm/dd/yyyy
  //
  //    Time No.  Time Format
  //    --------  -----------
  //      1       hh:mm:ss.sss
  //      2       hh:mm:ss
  //      3       hhmmss
  //      4       hhmm
  //
  //
  //  Copyright (C) Idaho National Laboratory (INL) All Rights Reserved
  //
  // *HTMLGEN InsertUnitDocEnd*





  //
  // This type is used in conjunction with Gregorian date types including
  // the dual date format.  This records holds the values when the string
  // is parsed out into its components.
  //

  type
    GregorianPrefixType = (NoPrefix,
                           AboutPrefix,
                           BeforePrefix,
                           AfterPrefix);

    GregorianSuffixType = (NoSuffix,
                           BCSuffix,
                           ADSuffix);

    GregorianDateRecordType = packed record
      DatePrefix      : GregorianPrefixType;
      DayValid        : boolean;
      DayValStr       : array [0 .. 19] of ansichar;
      DayValCard      : ModSys.S_Natural;
      MonthValid      : boolean;
      MonthValStr     : array [0 .. 19] of ansichar;
      MonthValCard    : ModSys.S_Natural;
      LowYearValid    : boolean;
      LowYearValStr   : array [0 .. 19] of ansichar;
      LowYearValCard  : ModSys.S_Natural;
      YearSlashValid  : boolean;
      YearSlashValStr : array [0 .. 19] of ansichar;
      HighYearValid   : boolean;
      HighYearValStr  : array [0 .. 19] of ansichar;
      HighYearValCard : ModSys.S_Natural;
      DateSuffix      : GregorianSuffixType;
      BCDate          : boolean;
      LowDateStr      : array [0 .. 19] of ansichar;
      HighDateStr     : array [0 .. 19] of ansichar;
    end;




  procedure CheckDate
             (const dateVal  : array of ansichar;
              const dateType : ModSys.S_Natural;
              var   Error    : ModSys.S_Natural); overload; stdcall;

  exports CheckDate (const dateVal  : array of ansichar;
                     const dateType : ModSys.S_Natural;
                     var   Error    : ModSys.S_Natural) name 'TimeLib_CheckDate';


  // *HTMLGEN InsertProcDocStart TimeLib_CheckDate*

  //*
  //  CheckDate - Check the validity of a date.
  //
  //
  //  This procedure checks the validity of a date in any of the
  //  thirteen formats (0 .. 12).
  //
  //  Any date that is passed in will also be checked to ensure it
  //  is not one of the calendar dates that never occurred due to
  //  adjustments in the Julian calendar and the changeover to the
  //  Gregorian calendar.  If the date is one of the following
  //  it will cause a SageErrs.InvalidDateError to be set.
  //
  //  The invalid dates would fall in the ranges:
  //
  //    October 5, 1582 - October 14, 1582
  //    September 3, 1752 - September 13, 1752
  //
  //  CALLING SEQUENCE -
  //
  //    CheckDate (dateVal, dateType, error)
  //
  //  ENTRY -
  //
  //    dateVal : array of char
  //      The value of the date.
  //
  //    dateType : ModSys.S_Natural
  //      The type of the date.
  //      0 - yyyy/mm/dd
  //      1 - mm/dd/yy
  //      2 - mmm dd, yyyy
  //      3 - dd mmm yyyy
  //      4 - dd-mmm-yy
  //      5 - yyddd
  //      6 - yymmdd
  //      7 - yy mm dd
  //      8 - yyyymmdd
  //      9 - ddmmmyy
  //      10- mm/yy
  //      11- dd mmm yy
  //      12- mm/dd/yyyy
  //
  //  EXIT -
  //
  //    error : ModSys.S_Natural
  //      Error status
  //          0  - ok
  //          21 - incorrect year
  //          22 - incorrect month
  //          23 - incorrect day
  //
  // *HTMLGEN InsertProcDocEnd*




  procedure CheckDate
             (const dateVal  : ansistring;
              const dateType : ModSys.S_Natural;
              var   Error    : ModSys.S_Natural); overload; stdcall;

  exports CheckDate (const dateVal  : ansistring;
                     const dateType : ModSys.S_Natural;
                     var   Error    : ModSys.S_Natural) name 'TimeLib_STRCheckDate';

  //*
  //  STRCheckDate - See documentation of CheckDate.
  //




  procedure CheckGregorianDate
             (const dateVal   : array of ansichar;
              var   IsDual    : boolean;
              var   CanBeDual : boolean;
              var   Error     : ModSys.S_Natural); overload; stdcall;

  exports CheckGregorianDate (const dateVal   : array of ansichar;
                              var   IsDual    : boolean;
                              var   CanBeDual : boolean;
                              var   Error     : ModSys.S_Natural) name 'TimeLib_CheckGregorianDate';


  // *HTMLGEN InsertProcDocStart TimeLib_CheckGregorianDate*

  //*
  //  CheckGregorianDate - Check the validity of a possible dual date.
  //
  //
  //  This procedure checks the validity of a possible dual date
  //  in the basic format of a type 3 string.  A dual date is one
  //  that represents the time of the changeover from the Julian to
  //  the Gregorian calendar.  An example of a dual date early in
  //  the year is 31 Mar 1702.  An example late in the year would be
  //  12 Mar 1702/1703.  Any other format passed in will fail.
  //
  //  CALLING SEQUENCE -
  //
  //    CheckGregorianDate (dateVal, IsDual, CanBeDual, Error)
  //
  //  ENTRY -
  //
  //    dateVal : array of char
  //      The value of the date to check.
  //
  //  EXIT -
  //
  //    IsDual : boolean
  //      TRUE - The date currently is in dual year format.
  //      FALSE - The date currently is in single year format.
  //
  //    CanBeDual : boolean
  //      TRUE - The date is eligible to be a dual year format.
  //      FALSE - The date should be a single year format.
  //
  //    error : ModSys.S_Natural
  //      Error status
  //          0  - ok
  //          21 - incorrect year
  //          22 - incorrect month
  //          23 - incorrect day
  //
  // *HTMLGEN InsertProcDocEnd*




  procedure CheckGregorianDate
             (const dateVal   : ansistring;
              var   IsDual    : boolean;
              var   CanBeDual : boolean;
              var   Error     : ModSys.S_Natural); overload; stdcall;

  exports CheckGregorianDate (const dateVal   : ansistring;
                              var   IsDual    : boolean;
                              var   CanBeDual : boolean;
                              var   Error     : ModSys.S_Natural) name 'TimeLib_STRCheckGregorianDate';

  //*
  //  STRCheckGregorianDate - See documentation of CheckGregorianDate.
  //




  procedure FixGregorianDate
             (const dateVal      : array of ansichar;
              var   FixedDateVal : array of ansichar;
              var   Error        : ModSys.S_Natural); overload; stdcall;

  exports FixGregorianDate (const dateVal      : array of ansichar;
                            var   FixedDateVal : array of ansichar;
                            var   Error        : ModSys.S_Natural) name 'TimeLib_FixGregorianDate';


  // *HTMLGEN InsertProcDocStart TimeLib_FixGregorianDate*

  //*
  //  FixGregorianDate - Fix date to correct single/dual format.
  //
  //
  //  This procedure fixes a date so that it is in the correct
  //  format allowed for the given date.  If the date is within
  //  the period when dual dating was used and is an allowable
  //  dual date then it will be formatted with the dual year.
  //  If it is within that period but should only be a single date
  //  it will be set to the single format.
  //
  //  A dual date is one that represents the time of the changeover
  //  from the Julian to the Gregorian calendar.  An example of a
  //  dual date early in the year is 31 Mar 1702.  An example late
  //  in the year would be 12 Mar 1702/1703.  Any other format
  //  passed in will fail.
  //
  //  CALLING SEQUENCE -
  //
  //    FixGregorianDate (dateVal, FixedDateVal, Error)
  //
  //  ENTRY -
  //
  //    dateVal : array of char
  //      The value of the date to fix.
  //
  //  EXIT -
  //
  //    FixedDateVal : array of char
  //      The date in its correct format including dual year if
  //      possible.
  //
  //    error : ModSys.S_Natural
  //      Error status
  //          0  - ok
  //          21 - incorrect year
  //          22 - incorrect month
  //          23 - incorrect day
  //
  // *HTMLGEN InsertProcDocEnd*




  procedure FixGregorianDate
             (const dateVal      : ansistring;
              var   FixedDateVal : array of ansichar;
              var   Error        : ModSys.S_Natural); overload; stdcall;

  exports FixGregorianDate (const dateVal      : ansistring;
                            var   FixedDateVal : array of ansichar;
                            var   Error        : ModSys.S_Natural) name 'TimeLib_STRFixGregorianDate';

  //*
  //  STRFixGregorianDate - See documentation of FixGregorianDate.
  //




  procedure FixGregorianDate
             (const dateVal      : ansistring;
              var   FixedDateVal : ansistring;
              var   Error        : ModSys.S_Natural); overload; stdcall;

  exports FixGregorianDate (const dateVal      : ansistring;
                            var   FixedDateVal : ansistring;
                            var   Error        : ModSys.S_Natural) name 'TimeLib_STRSTRFixGregorianDate';

  //*
  //  STRSTRFixGregorianDate - See documentation of FixGregorianDate.
  //




  procedure CheckTime
             (const timeVal  : array of ansichar;
              const timeType : ModSys.S_Natural;
              var   Error    : ModSys.S_Natural); overload; stdcall;

  exports CheckTime (const timeVal  : array of ansichar;
                     const timeType : ModSys.S_Natural;
                     var   Error    : ModSys.S_Natural) name 'TimeLib_CheckTime';


  // *HTMLGEN InsertProcDocStart TimeLib_CheckTime*

  //*
  //  CheckTime - Check the validity of a time.
  //
  //
  //  This procedure checks the validity of a time in any of the
  //  four formats (1 .. 4).
  //
  //  CALLING SEQUENCE -
  //
  //    CheckTime (timeVal, timeType, error)
  //
  //  ENTRY -
  //
  //    timeVal : array of char
  //      The value of the time.
  //
  //    timeType : ModSys.S_Natural
  //      The type of the time.
  //        1 - "hh:mm:ss.sss"
  //        2 - "hh:mm:ss"
  //        3 - "hhmmss"
  //        4 - "hhmm"
  //
  //  EXIT -
  //
  //    error : ModSys.S_Natural
  //      Error status
  //          0  - ok
  //          24 - incorrect hour
  //          25 - incorrect minute
  //          26 - incorrect second
  //
  // *HTMLGEN InsertProcDocEnd*




  procedure CheckTime
             (const timeVal  : ansistring;
              const timeType : ModSys.S_Natural;
              var   Error    : ModSys.S_Natural); overload; stdcall;

  exports CheckTime (const timeVal  : ansistring;
                     const timeType : ModSys.S_Natural;
                     var   Error    : ModSys.S_Natural) name 'TimeLib_STRCheckTime';

  //*
  //  STRCheckTime - See documentation of CheckTime.
  //




  procedure CurrentDate0
             (var   date : array of ansichar); overload; stdcall;

  exports CurrentDate0 (var   date : array of ansichar) name 'TimeLib_CurrentDate0';


  // *HTMLGEN InsertProcDocStart TimeLib_CurrentDate0*

  //*
  //  CurrentDate0 - Return current date as yyyy/mm/dd.
  //
  //  This procedure returns the current date as an array of
  //  characters in date format 0 ('yyyy/mm/dd').
  //
  //  CALLING SEQUENCE -
  //
  //    CurrentDate0 (date)
  //
  //  EXIT -
  //
  //    date : array of char
  //      The current date in the form 'yyyy/mm/dd'.
  //
  // *HTMLGEN InsertProcDocEnd*




  procedure CurrentDate0
             (var   date : ansistring); overload; stdcall;

  exports CurrentDate0 (var   date : ansistring) name 'TimeLib_STRCurrentDate0';

  //*
  //  STRCurrentDate0 - See documentation of CurrentDate0.
  //




  procedure CurrentDateChronoJulian
             (var   ChronoDate : ModSys.S_Float64); stdcall;

  exports CurrentDateChronoJulian name 'TimeLib_CurrentDateChronoJulian';


  // *HTMLGEN InsertProcDocStart TimeLib_CurrentDateChronoJulian*

  //*
  //  CurrentDateChronoJulian - Return current date as chronological julian.
  //
  //  This procedure returns the current date as a number that represents
  //  the chronological julian date.  This differs from the other routines in
  //  this library that refer to a julian date.  Those 'julian date' routines
  //  return a modified julian date starting at 1900/01/01 and cannot represent
  //  any date prior to that time.
  //
  //  This routines chronological julian date is based on a starting date of
  //  midnight on 01 Jan 4713 B.C. and is the more standard way of representing
  //  dates when working with time prior to 1900/01/01.  The number that is
  //  returned represents the number of nychthemerons since that starting point.
  //  A nychthemeron is one cycle of night and day.  This routine's nychthemeron
  //  calculations are based on midnight to midnight with the first cycle from
  //  midnight 4713/01/01 B.C. to midnight 4713/01/02 B.C. being designated as
  //  0.  The next cycle designated as 1 and so on.
  //
  //  CALLING SEQUENCE -
  //
  //    CurrentDateChronoJulian (ChronoDate)
  //
  //  EXIT -
  //
  //    ChronoDate : ModSys.S_Float64
  //      The current date represented as the number of nychthemerons since
  //      4713/01/01 B.C.
  //
  // *HTMLGEN InsertProcDocEnd*




  procedure CurrentTime1
             (var   Time1 : array of ansichar); overload; stdcall;

  exports CurrentTime1 (var   Time1 : array of ansichar) name 'TimeLib_CurrentTime1';


  // *HTMLGEN InsertProcDocStart TimeLib_CurrentTime1*

  //*
  //  CurrentTime1 - Return current time as hh:mm:ss.sss.
  //
  //
  //  This procedure returns the current time as an array of
  //  characters in the form 'hh:mm:ss.sss'.
  //
  //  CALLING SEQUENCE -
  //
  //    CurrentTime1 (Time1)
  //
  //  EXIT -
  //
  //    Time1 : array of char
  //      The current time in the form 'hh:mm:ss.sss'
  //
  // *HTMLGEN InsertProcDocEnd*




  procedure CurrentTime1
             (var   Time1 : ansistring); overload; stdcall;

  exports CurrentTime1 (var   Time1 : ansistring) name 'TimeLib_STRCurrentTime1';

  //*
  //  STRCurrentTime1 - See documentation of CurrentTime1.
  //




  procedure CurrentTime2
             (var   time2 : array of ansichar); overload; stdcall;

  exports CurrentTime2 (var   time2 : array of ansichar) name 'TimeLib_CurrentTime2';


  // *HTMLGEN InsertProcDocStart TimeLib_CurrentTime2*

  //*
  //  CurrentTime2 - Return current time as hh:mm:ss.
  //
  //
  //  This procedure returns the current time as an array of
  //  characters in the form 'hh:mm:ss'.
  //
  //  CALLING SEQUENCE -
  //
  //    CurrentTime2 (Time2)
  //
  //  EXIT -
  //
  //    Time2 : array of char
  //      The current time in the form 'hh:mm:ss'
  //
  // *HTMLGEN InsertProcDocEnd*




  procedure CurrentTime2
             (var   time2 : ansistring); overload; stdcall;

  exports CurrentTime2 (var   time2 : ansistring) name 'TimeLib_STRCurrentTime2';

  //*
  //  STRCurrentTime2 - See documentation of CurrentTime2.
  //




  procedure CurrentTime3
             (var   Time3 : array of ansichar); overload; stdcall;

  exports CurrentTime3 (var   Time3 : array of ansichar) name 'TimeLib_CurrentTime3';


  // *HTMLGEN InsertProcDocStart TimeLib_CurrentTime3*

  //*
  //  CurrentTime3 - Return current time as hhmmss.
  //
  //
  //  This procedure returns the current time as an array of
  //  characters in the form 'hhmmss'.
  //
  //  CALLING SEQUENCE -
  //
  //    CurrentTime3 (Time3)
  //
  //  EXIT -
  //
  //    Time3 : array of char
  //      The current time in the form 'hhmmss'
  //
  // *HTMLGEN InsertProcDocEnd*




  procedure CurrentTime3
             (var   Time3 : ansistring); overload; stdcall;

  exports CurrentTime3 (var   Time3 : ansistring) name 'TimeLib_STRCurrentTime3';

  //*
  //  STRCurrentTime3 - See documentation of CurrentTime3.
  //




  procedure CurrentTime4
             (var   time4 : array of ansichar); overload; stdcall;

  exports CurrentTime4 (var   time4 : array of ansichar) name 'TimeLib_CurrentTime4';


  // *HTMLGEN InsertProcDocStart TimeLib_CurrentTime4*

  //*
  //  CurrentTime4 - Return current time as hhmm.
  //
  //
  //  This procedure returns the current time as an array of
  //  characters in the form 'hhmm'.
  //
  //  CALLING SEQUENCE -
  //
  //    CurrentTime4 (Time4)
  //
  //  EXIT -
  //
  //    Time4 : array of char
  //      The current time in the form 'hhmm'
  //
  // *HTMLGEN InsertProcDocEnd*




  procedure CurrentTime4
             (var   time4 : ansistring); overload; stdcall;

  exports CurrentTime4 (var   time4 : ansistring) name 'TimeLib_STRCurrentTime4';

  //*
  //  STRCurrentTime4 - See documentation of CurrentTime4.
  //




  procedure CurrentTime5
             (var   hours    : ModSys.S_Natural;
              var   minutes  : ModSys.S_Natural;
              var   Seconds  : ModSys.S_Natural;
              var   millisec : ModSys.S_Natural); stdcall;

  exports CurrentTime5 name 'TimeLib_CurrentTime5';


  // *HTMLGEN InsertProcDocStart TimeLib_CurrentTime5*

  //*
  //  CurrentTime5 - Return current time as ModSys.S_Natural values.
  //
  //
  //  This procedure returns the current time as four ModSys.S_Natural
  //  values representing hours, minutes, seconds, and milliseconds.
  //
  //  CALLING SEQUENCE -
  //
  //    CurrentTime5 (hours, minutes, seconds, millisec)
  //
  //  EXIT -
  //
  //    hours : ModSys.S_Natural
  //      Current hour value.
  //
  //    minutes : ModSys.S_Natural
  //      Current minute value.
  //
  //    seconds : ModSys.S_Natural
  //      Current second value.
  //
  //    millisec : ModSys.S_Natural
  //      Current millisecond value.
  //
  // *HTMLGEN InsertProcDocEnd*




  procedure ClockToDate0
             (const clock : TimeDate.Time;
              var   date0 : array of ansichar); overload; stdcall;

  exports ClockToDate0 (const clock : TimeDate.Time;
                        var   date0 : array of ansichar) name 'TimeLib_ClockToDate0';


  // *HTMLGEN InsertProcDocStart TimeLib_ClockToDate0*

  //*
  //  ClockToDate0 - Return the date in format 0 (yyyy/mm/dd).
  //
  //
  //  This procedure pulls out the date from a clock object and
  //  returns the date portion in format 0 which is yyyy/mm/dd.
  //
  //  CALLING SEQUENCE -
  //
  //    ClockToDate0 (clock, date0)
  //
  //  ENTRY -
  //
  //    clock : TimeDate.Time
  //      Some date and time in the Time format.
  //
  //  EXIT -
  //
  //    date0 : array of char
  //      The date portion of the clock variable in date format 0.
  //
  // *HTMLGEN InsertProcDocEnd*




  procedure ClockToDate0
             (const clock : TimeDate.Time;
              var   date0 : ansistring); overload; stdcall;

  exports ClockToDate0 (const clock : TimeDate.Time;
                        var   date0 : ansistring) name 'TimeLib_STRClockToDate0';

  //*
  //  STRClockToDate0 - See documentation of ClockToDate0.
  //




  procedure ClockToTime1
             (const clock : TimeDate.Time;
              var   Time1 : array of ansichar); overload; stdcall;

  exports ClockToTime1 (const clock : TimeDate.Time;
                        var   Time1 : array of ansichar) name 'TimeLib_ClockToTime1';


  // *HTMLGEN InsertProcDocStart TimeLib_ClockToTime1*

  //*
  //  ClockToTime1 - Return the time in the form 'hh:mm:ss.sss'.
  //
  //
  //  This procedure converts a raw clock value into the Time1
  //  format.  Time1 is hh:mm:ss.sss.
  //
  //  CALLING SEQUENCE -
  //
  //    ClockToTime1 (clock, Time1)
  //
  //  ENTRY -
  //
  //    clock : TimeDate.Time
  //      Some date and time in the Time format.
  //
  //  EXIT -
  //
  //    Time1 : array of char
  //      The time portion of the clock variable in time format 1.
  //
  // *HTMLGEN InsertProcDocEnd*




  procedure ClockToTime1
             (const clock : TimeDate.Time;
              var   Time1 : ansistring); overload; stdcall;

  exports ClockToTime1 (const clock : TimeDate.Time;
                        var   Time1 : ansistring) name 'TimeLib_STRClockToTime1';

  //*
  //  STRClockToTime1 - See documentation of ClockToTime1.
  //




  procedure ClockToTime2
             (const clock : TimeDate.Time;
              var   time2 : array of ansichar); overload; stdcall;

  exports ClockToTime2 (const clock : TimeDate.Time;
                        var   time2 : array of ansichar) name 'TimeLib_ClockToTime2';


  // *HTMLGEN InsertProcDocStart TimeLib_ClockToTime2*

  //*
  //  ClockToTime2 - Return the time in the form 'hh:mm:ss'.
  //
  //
  //  This procedure converts a raw clock value into the Time2
  //  format.  Time2 is hh:mm:ss.
  //
  //  CALLING SEQUENCE -
  //
  //    ClockToTime2 (clock, Time2)
  //
  //  ENTRY -
  //
  //    clock : TimeDate.Time
  //      Some date and time in the Time format.
  //
  //  EXIT -
  //
  //    Time2 : array of char
  //      The time portion of the clock variable in time format 2.
  //
  // *HTMLGEN InsertProcDocEnd*




  procedure ClockToTime2
             (const clock : TimeDate.Time;
              var   time2 : ansistring); overload; stdcall;

  exports ClockToTime2 (const clock : TimeDate.Time;
                        var   time2 : ansistring) name 'TimeLib_STRClockToTime2';

  //*
  //  STRClockToTime2 - See documentation of ClockToTime2.
  //




  procedure ClockToTime3
             (const clock : TimeDate.Time;
              var   Time3 : array of ansichar); overload; stdcall;

  exports ClockToTime3 (const clock : TimeDate.Time;
                        var   Time3 : array of ansichar) name 'TimeLib_ClockToTime3';


  // *HTMLGEN InsertProcDocStart TimeLib_ClockToTime3*

  //*
  //  ClockToTime3 - Return the time in the form 'hhmmss'.
  //
  //
  //  This procedure converts a raw clock value into the Time3
  //  format.  Time3 is hhmmss.
  //
  //  CALLING SEQUENCE -
  //
  //    ClockToTime3 (clock, Time3)
  //
  //  ENTRY -
  //
  //    clock : TimeDate.Time
  //      Some date and time in the Time format.
  //
  //  EXIT -
  //
  //    Time3 : array of char
  //      The time portion of the clock variable in time format 3.
  //
  // *HTMLGEN InsertProcDocEnd*




  procedure ClockToTime3
             (const clock : TimeDate.Time;
              var   Time3 : ansistring); overload; stdcall;

  exports ClockToTime3 (const clock : TimeDate.Time;
                        var   Time3 : ansistring) name 'TimeLib_STRClockToTime3';

  //*
  //  STRClockToTime3 - See documentation of ClockToTime3.
  //




  procedure ClockToTime4
             (const clock : TimeDate.Time;
              var   time4 : array of ansichar); overload; stdcall;

  exports ClockToTime4 (const clock : TimeDate.Time;
                        var   time4 : array of ansichar) name 'TimeLib_ClockToTime4';


  // *HTMLGEN InsertProcDocStart TimeLib_ClockToTime4*

  //*
  //  ClockToTime4 - Return the time in the form 'hhmm'.
  //
  //
  //  This procedure converts a raw clock value into the Time4
  //  format.  Time1 is hhmm.
  //
  //  CALLING SEQUENCE -
  //
  //    ClockToTime4 (clock, Time4)
  //
  //  ENTRY -
  //
  //    clock : TimeDate.Time
  //      Some date and time in the Time format.
  //
  //  EXIT -
  //
  //    Time4 : array of char
  //      The time portion of the clock variable in time format 4.
  //
  // *HTMLGEN InsertProcDocEnd*




  procedure ClockToTime4
             (const clock : TimeDate.Time;
              var   time4 : ansistring); overload; stdcall;

  exports ClockToTime4 (const clock : TimeDate.Time;
                        var   time4 : ansistring) name 'TimeLib_STRClockToTime4';

  //*
  //  STRClockToTime4 - See documentation of ClockToTime4.
  //




  procedure ClockToTime5
             (const clock    : TimeDate.Time;
              var   hours    : ModSys.S_Natural;
              var   minutes  : ModSys.S_Natural;
              var   Seconds  : ModSys.S_Natural;
              var   millisec : ModSys.S_Natural); stdcall;

  exports ClockToTime5 name 'TimeLib_ClockToTime5';


  // *HTMLGEN InsertProcDocStart TimeLib_ClockToTime5*

  //*
  //  ClockToTime5 - Return the hours, minutes, seconds, and milliseconds.
  //
  //
  //  This procedure converts a raw clock value into the Time5
  //  format.  Time5 is each component of the time returned as a
  //  ModSys.S_Natural value.
  //
  //  CALLING SEQUENCE -
  //
  //    ClockToTime5 (clock, hours, minutes, Seconds,
  //                  millisec)
  //
  //  ENTRY -
  //
  //    clock : TimeDate.Time
  //      Some date and time in the Time format.
  //
  //  EXIT -
  //
  //    hours : array of char
  //      The hours portion of the clock value.
  //
  //    minutes : array of char
  //      The minutes portion of the clock value.
  //
  //    Seconds : array of char
  //      The seconds portion of the clock value.
  //
  //    millisec : array of char
  //      The millisecs portion of the clock value.
  //
  // *HTMLGEN InsertProcDocEnd*




  procedure Date0ToDate1
             (const date0 : array of ansichar;
              var   date1 : array of ansichar); overload; stdcall;

  exports Date0ToDate1 (const date0 : array of ansichar;
                        var   date1 : array of ansichar) name 'TimeLib_Date0ToDate1';


  // *HTMLGEN InsertProcDocStart TimeLib_Date0ToDate1*

  //*
  //  Date0ToDate1 - Convert from 'yyyy/mm/dd' to 'mm/dd/yy'.
  //
  //
  //  This procedure converts from date format 0 (yyyy/mm/dd) to
  //  date format 1 (mm/dd/yy).
  //
  //  CALLING SEQUENCE -
  //
  //    Date0ToDate1 (date0, date1)
  //
  //  ENTRY -
  //
  //    date0 : array of char
  //      Date in the form 'yyyy/mm/dd'
  //
  //  EXIT -
  //
  //    date1 : array of char
  //      Date in the form 'mm/dd/yy'
  //
  // *HTMLGEN InsertProcDocEnd*




  procedure Date0ToDate1
             (const date0 : ansistring;
              var   date1 : array of ansichar); overload; stdcall;

  exports Date0ToDate1 (const date0 : ansistring;
                        var   date1 : array of ansichar) name 'TimeLib_STRDate0ToDate1';

  //*
  //  STRDate0ToDate1 - See documentation of Date0ToDate1.
  //




  procedure Date0ToDate2
             (const date0 : array of ansichar;
              var   date2 : array of ansichar); overload; stdcall;

  exports Date0ToDate2 (const date0 : array of ansichar;
                        var   date2 : array of ansichar) name 'TimeLib_Date0ToDate2';


  // *HTMLGEN InsertProcDocStart TimeLib_Date0ToDate2*

  //*
  //  Date0ToDate2 - Convert from 'yyyy/mm/dd' to 'mmm dd, yyyy'.
  //
  //
  //  This procedure converts from date format 0 (yyyy/mm/dd) to
  //  date format 2 (mmm dd, yyyy).
  //
  //  CALLING SEQUENCE -
  //
  //    Date0ToDate2 (date0, date2)
  //
  //  ENTRY -
  //
  //    date0 : array of char
  //      Date in the form 'yyyy/mm/dd'
  //
  //  EXIT -
  //
  //    date2 : array of char
  //      Date in the form 'mmm dd, yyyy'
  //
  // *HTMLGEN InsertProcDocEnd*




  procedure Date0ToDate2
             (const date0 : ansistring;
              var   date2 : array of ansichar); overload; stdcall;

  exports Date0ToDate2 (const date0 : ansistring;
                        var   date2 : array of ansichar) name 'TimeLib_STRDate0ToDate2';

  //*
  //  STRDate0ToDate2 - See documentation of Date0ToDate2.
  //




  procedure Date0ToDate3
             (const date0 : array of ansichar;
              var   date3 : array of ansichar); overload; stdcall;

  exports Date0ToDate3 (const date0 : array of ansichar;
                        var   date3 : array of ansichar) name 'TimeLib_Date0ToDate3';


  // *HTMLGEN InsertProcDocStart TimeLib_Date0ToDate3*

  //*
  //  Date0ToDate3 - Convert from 'yyyy/mm/dd' to 'dd mmm yyyy' date format.
  //
  //  Convert the date of format 0 to the format 3.
  //  ex. 1989/07/14 => 14 JUL 1988
  //
  //  CALLING SEQUENCE -
  //
  //    Date0ToDate3 (date0, date3)
  //
  //  ENTRY -
  //
  //    Date0 : array of char
  //      Date of the form 'yyyy/mm/dd'.
  //
  //  EXIT -
  //
  //    Date3 : array of char
  //      Date of the form 'dd mmm yyyy'.
  //
  // *HTMLGEN InsertProcDocEnd*




  procedure Date0ToDate3
             (const date0 : ansistring;
              var   date3 : array of ansichar); overload; stdcall;

  exports Date0ToDate3 (const date0 : ansistring;
                        var   date3 : array of ansichar) name 'TimeLib_STRDate0ToDate3';

  //*
  //  STRDate0ToDate3 - See documentation of Date0ToDate3.
  //




  procedure Date0ToDate4
             (const date0 : array of ansichar;
              var   date4 : array of ansichar); overload; stdcall;

  exports Date0ToDate4 (const date0 : array of ansichar;
                        var   date4 : array of ansichar) name 'TimeLib_Date0ToDate4';


  // *HTMLGEN InsertProcDocStart TimeLib_Date0ToDate4*

  //*
  //  Date0ToDate4 - Convert from 'yyyy/mm/dd' to 'dd-mmm-yy' date format.
  //
  //  Convert the date of format 0 to the format 4.
  //  ex. 1989/07/14 => 14-JUL-88
  //
  //  CALLING SEQUENCE -
  //
  //    Date0ToDate4 (date0, date4)
  //
  //  ENTRY -
  //
  //    Date0 : array of char
  //      Date of the form 'yyyy/mm/dd'.
  //
  //  EXIT -
  //
  //    Date4 : array of char
  //      Date of the form 'dd-mmm-yy'.
  //
  // *HTMLGEN InsertProcDocEnd*




  procedure Date0ToDate4
             (const date0 : ansistring;
              var   date4 : array of ansichar); overload; stdcall;

  exports Date0ToDate4 (const date0 : ansistring;
                        var   date4 : array of ansichar) name 'TimeLib_STRDate0ToDate4';

  //*
  //  STRDate0ToDate4 - See documentation of Date0ToDate4.
  //




  procedure Date0ToDate5
             (const date0 : array of ansichar;
              var   date5 : array of ansichar); overload; stdcall;

  exports Date0ToDate5 (const date0 : array of ansichar;
                        var   date5 : array of ansichar) name 'TimeLib_Date0ToDate5';


  // *HTMLGEN InsertProcDocStart TimeLib_Date0ToDate5*

  //*
  //  Date0ToDate5 - Convert from 'yyyy/mm/dd' to 'yyddd' date format.
  //
  //  Convert the date of format 0 to the format 5 (pseudo julian date).
  //  ex. 1988/01/14 => 88014
  //
  //  CALLING SEQUENCE -
  //
  //    Date0ToDate5 (date0, date5)
  //
  //  ENTRY -
  //
  //    Date0 : array of char
  //      Date of the form 'yyyy/mm/dd'.
  //
  //  EXIT -
  //
  //    Date5 : array of char
  //      Date of the form 'yyddd'.
  //
  // *HTMLGEN InsertProcDocEnd*




  procedure Date0ToDate5
             (const date0 : ansistring;
              var   date5 : array of ansichar); overload; stdcall;

  exports Date0ToDate5 (const date0 : ansistring;
                        var   date5 : array of ansichar) name 'TimeLib_STRDate0ToDate5';

  //*
  //  STRDate0ToDate5 - See documentation of Date0ToDate5.
  //




  procedure Date0ToDate6
             (const date0 : array of ansichar;
              var   date6 : array of ansichar); overload; stdcall;

  exports Date0ToDate6 (const date0 : array of ansichar;
                        var   date6 : array of ansichar) name 'TimeLib_Date0ToDate6';


  // *HTMLGEN InsertProcDocStart TimeLib_Date0ToDate6*

  //*
  //  Date0ToDate6 - Convert from 'yyyy/mm/dd' to 'yymmdd' date format.
  //
  //
  //  Convert the date of format 0 to the format 6.
  //  ex. 1988/05/14 => 880514
  //
  //  CALLING SEQUENCE -
  //
  //    Date0ToDate6 (date0, date6)
  //
  //  ENTRY -
  //
  //    Date0 : array of char
  //      Date of the form 'yyyy/mm/dd'.
  //
  //  EXIT -
  //
  //    Date6 : array of char
  //      Date of the form 'yymmdd'.
  //
  // *HTMLGEN InsertProcDocEnd*




  procedure Date0ToDate6
             (const date0 : ansistring;
              var   date6 : array of ansichar); overload; stdcall;

  exports Date0ToDate6 (const date0 : ansistring;
                        var   date6 : array of ansichar) name 'TimeLib_STRDate0ToDate6';

  //*
  //  STRDate0ToDate6 - See documentation of Date0ToDate6.
  //




  procedure Date0ToDate7
             (const date0 : array of ansichar;
              var   date7 : array of ansichar); overload; stdcall;

  exports Date0ToDate7 (const date0 : array of ansichar;
                        var   date7 : array of ansichar) name 'TimeLib_Date0ToDate7';


  // *HTMLGEN InsertProcDocStart TimeLib_Date0ToDate7*

  //*
  //  Date0ToDate7 - Convert from 'yyyy/mm/dd' to 'yy mm dd' date format.
  //
  //
  //  Convert the date of format 0 to the format 7.
  //  ex. 1988/05/14 => 88 05 14
  //
  //  CALLING SEQUENCE -
  //
  //    Date0ToDate7 (date0, date7)
  //
  //  ENTRY -
  //
  //    Date0 : array of char
  //      Date of the form 'yyyy/mm/dd'.
  //
  //  EXIT -
  //
  //    Date7 : array of char
  //      Date of the form 'yy mm dd'.
  //
  // *HTMLGEN InsertProcDocEnd*




  procedure Date0ToDate7
             (const date0 : ansistring;
              var   date7 : array of ansichar); overload; stdcall;

  exports Date0ToDate7 (const date0 : ansistring;
                        var   date7 : array of ansichar) name 'TimeLib_STRDate0ToDate7';

  //*
  //  STRDate0ToDate7 - See documentation of Date0ToDate7.
  //




  procedure Date0ToDate8
             (const date0 : array of ansichar;
              var   date8 : array of ansichar); overload; stdcall;

  exports Date0ToDate8 (const date0 : array of ansichar;
                        var   date8 : array of ansichar) name 'TimeLib_Date0ToDate8';


  // *HTMLGEN InsertProcDocStart TimeLib_Date0ToDate8*

  //*
  //  Date0ToDate8 - Convert from 'yyyy/mm/dd' to 'yyyymmdd' date format.
  //
  //
  //  Convert the date of format 0 to the format 6.
  //  ex. 1988/05/14 => 19880514
  //
  //  CALLING SEQUENCE -
  //
  //    Date0ToDate8 (date0, date8)
  //
  //  ENTRY -
  //
  //    Date0 : array of char
  //      Date of the form 'yyyy/mm/dd'.
  //
  //  EXIT -
  //
  //    Date8 : array of char
  //      Date of the form 'yyyymmdd'.
  //
  // *HTMLGEN InsertProcDocEnd*




  procedure Date0ToDate8
             (const date0 : ansistring;
              var   date8 : array of ansichar); overload; stdcall;

  exports Date0ToDate8 (const date0 : ansistring;
                        var   date8 : array of ansichar) name 'TimeLib_STRDate0ToDate8';

  //*
  //  STRDate0ToDate8 - See documentation of Date0ToDate8.
  //




  procedure Date0ToDate9
             (const date0 : array of ansichar;
              var   date9 : array of ansichar); overload; stdcall;

  exports Date0ToDate9 (const date0 : array of ansichar;
                        var   date9 : array of ansichar) name 'TimeLib_Date0ToDate9';


  // *HTMLGEN InsertProcDocStart TimeLib_Date0ToDate9*

  //*
  //  Date0ToDate9 - Convert from 'yyyy/mm/dd' to 'ddmmmyy' date format.
  //
  //
  //  Convert the date of format 0 to the format 4.
  //  ex. 1989/07/14 => 14JUL88
  //
  //  CALLING SEQUENCE -
  //
  //    Date0ToDate4 (date0, date2)
  //
  //  ENTRY -
  //
  //    Date0 : array of char
  //      Date of the form 'yyyy/mm/dd'.
  //
  //  EXIT -
  //
  //    Date4 : array of char
  //      Date of the form 'ddmmmyy'.
  //
  // *HTMLGEN InsertProcDocEnd*




  procedure Date0ToDate9
             (const date0 : ansistring;
              var   date9 : array of ansichar); overload; stdcall;

  exports Date0ToDate9 (const date0 : ansistring;
                        var   date9 : array of ansichar) name 'TimeLib_STRDate0ToDate9';

  //*
  //  STRDate0ToDate9 - See documentation of Date0ToDate9.
  //




  procedure Date0ToDate10
             (const date0  : array of ansichar;
              var   date10 : array of ansichar); overload; stdcall;

  exports Date0ToDate10 (const date0  : array of ansichar;
                         var   date10 : array of ansichar) name 'TimeLib_Date0ToDate10';


  // *HTMLGEN InsertProcDocStart TimeLib_Date0ToDate10*

  //*
  //  Date0ToDate10 - Convert from 'yyyy/mm/dd' to 'mm/yy'.
  //
  //
  //  This procedure converts from date format 0 (yyyy/mm/dd) to
  //  date format 10 (mm/yy).
  //
  //  CALLING SEQUENCE -
  //
  //    Date0ToDate10 (date0, date10)
  //
  //  ENTRY -
  //
  //    date0 : array of char
  //      Date in the form 'yyyy/mm/dd'
  //
  //  EXIT -
  //
  //    date10 : array of char
  //      Date in the form 'mm/yy'
  //
  // *HTMLGEN InsertProcDocEnd*




  procedure Date0ToDate10
             (const date0  : ansistring;
              var   date10 : array of ansichar); overload; stdcall;

  exports Date0ToDate10 (const date0  : ansistring;
                         var   date10 : array of ansichar) name 'TimeLib_STRDate0ToDate10';

  //*
  //  STRDate0ToDate10 - See documentation of Date0ToDate10.
  //




  procedure Date0ToDate11
             (const date0  : array of ansichar;
              var   date11 : array of ansichar); overload; stdcall;

  exports Date0ToDate11 (const date0  : array of ansichar;
                         var   date11 : array of ansichar) name 'TimeLib_Date0ToDate11';


  // *HTMLGEN InsertProcDocStart TimeLib_Date0ToDate11*

  //*
  //  Date0ToDate11 - Convert from 'yyyy/mm/dd' to 'dd mmm yy'.
  //
  //
  //  This procedure converts from date format 0 (yyyy/mm/dd) to
  //  date format 11 (dd mmm yy).
  //
  //  CALLING SEQUENCE -
  //
  //    Date0ToDate11 (date0, date11)
  //
  //  ENTRY -
  //
  //    date0 : array of char
  //      Date in the form 'yyyy/mm/dd'
  //
  //  EXIT -
  //
  //    date11 : array of char
  //      Date in the form 'dd mmm yy' (e.g. '23 Dec 90')
  //
  // *HTMLGEN InsertProcDocEnd*




  procedure Date0ToDate11
             (const date0  : ansistring;
              var   date11 : array of ansichar); overload; stdcall;

  exports Date0ToDate11 (const date0  : ansistring;
                         var   date11 : array of ansichar) name 'TimeLib_STRDate0ToDate11';

  //*
  //  STRDate0ToDate11 - See documentation of Date0ToDate11.
  //




  procedure Date0ToDate12
             (const date0  : array of ansichar;
              var   date12 : array of ansichar); overload; stdcall;

  exports Date0ToDate12 (const date0  : array of ansichar;
                         var   date12 : array of ansichar) name 'TimeLib_Date0ToDate12';


  // *HTMLGEN InsertProcDocStart TimeLib_Date0ToDate12*

  //*
  //  Date0ToDate12 - Convert from 'yyyy/mm/dd' to 'mm/dd/yyyy'.
  //
  //
  //  This procedure converts from date format 0 (yyyy/mm/dd) to
  //  date format 12 (mm/dd/yyyy).
  //
  //  CALLING SEQUENCE -
  //
  //    Date0ToDate12 (date0, date12)
  //
  //  ENTRY -
  //
  //    date0 : array of char
  //      Date in the form 'yyyy/mm/dd'
  //
  //  EXIT -
  //
  //    date12 : array of char
  //      Date in the form 'mm/dd/yyyy' (e.g. '12/23/1990')
  //
  // *HTMLGEN InsertProcDocEnd*




  procedure Date0ToDate12
             (const date0  : ansistring;
              var   date12 : array of ansichar); overload; stdcall;

  exports Date0ToDate12 (const date0  : ansistring;
                         var   date12 : array of ansichar) name 'TimeLib_STRDate0ToDate12';

  //*
  //  STRDate0ToDate12 - See documentation of Date0ToDate12.
  //




  procedure Date0ToJulian
             (const date0 : array of ansichar;
              var   jDate : ModSys.S_Natural); overload; stdcall;

  exports Date0ToJulian (const date0 : array of ansichar;
                         var   jDate : ModSys.S_Natural) name 'TimeLib_Date0ToJulian';


  // *HTMLGEN InsertProcDocStart TimeLib_Date0ToJulian*

  //*
  //  Date0ToJulian - Convert from 'yyyy/mm/dd' to a ModSys.S_Natural julian date.
  //
  //
  //  Convert the date in format 0 (yyyy/mm/dd) to a ModSys.S_Natural
  //  modified julian date (number of days since Jan 1900 where
  //  1 Jan. 1900 is 1).
  //
  //  CALLING SEQUENCE -
  //
  //    Date0ToJulian (date0, jDate)
  //
  //  ENTRY -
  //
  //    date0 : array of char
  //      Date in the form 'yyyy/mm/dd'
  //
  //  EXIT -
  //
  //    jDate : ModSys.S_Natural
  //      Number of days since 1 Jan 1900.
  //
  // *HTMLGEN InsertProcDocEnd*




  procedure Date0ToJulian
             (const date0 : ansistring;
              var   jDate : ModSys.S_Natural); overload; stdcall;

  exports Date0ToJulian (const date0 : ansistring;
                         var   jDate : ModSys.S_Natural) name 'TimeLib_STRDate0ToJulian';

  //*
  //  STRDate0ToJulian - See documentation of Date0ToJulian.
  //




  procedure GregorianDateToChronoJulian
             (const GregorianDate : array of ansichar;
              var   ChronoDate    : ModSys.S_Float64); overload; stdcall;

  exports GregorianDateToChronoJulian (const GregorianDate : array of ansichar;
                                       var   ChronoDate    : ModSys.S_Float64) name 'TimeLib_GregorianDateToChronoJulian';


  // *HTMLGEN InsertProcDocStart TimeLib_GregorianDateToChronoJulian*

  //*
  //  GregorianDateToChronoJulian - Convert from Gregorian to Chrono Julian.
  //
  //  This procedure converts a Gregorian date in the general form of
  //  DD MMM YYYY/YYYY B.C. to a Chrono Julian date.  This differs from the other
  //  routines in this library that refer to a julian date.  Those 'julian date'
  //  routines return a modified julian date starting at 1900/01/01 and cannot
  //  represent any date prior to that time.
  //
  //  This routines chronological julian date is based on a starting date of
  //  midnight on 01 Jan 4713 B.C. and is the more standard way of representing
  //  dates when working with time prior to 1900/01/01.  The number that is
  //  returned represents the number of nychthemerons since that starting point.
  //  A nychthemeron is one cycle of night and day.  This routine's nychthemeron
  //  calculations are based on midnight to midnight with the first cycle from
  //  midnight 4713/01/01 B.C. to midnight 4713/01/02 B.C. being designated as
  //  0.  The next cycle designated as 1 and so on.
  //
  //  CALLING SEQUENCE -
  //
  //    GregorianDateToChronoJulian (GregorianDate, ChronoDate)
  //
  //  ENTRY -
  //
  //    GregorianDate : array of char
  //      A Gregorian calendar date in the general format of DD MMM YYYY.  Optionally
  //      it can be in the dual date format of DD MMM YYYY/YYYY and may also include
  //      a B.C. designator (i.e. DD MMM YYYY/YYYY B.C.)
  //
  //  EXIT -
  //
  //    ChronoDate : ModSys.S_Float64
  //      The date represented as a chrono julian date.
  //
  // *HTMLGEN InsertProcDocEnd*




  procedure GregorianDateToChronoJulian
             (const GregorianDate : ansistring;
              var   ChronoDate    : ModSys.S_Float64); overload; stdcall;

  exports GregorianDateToChronoJulian (const GregorianDate : ansistring;
                                       var   ChronoDate    : ModSys.S_Float64) name 'TimeLib_STRGregorianDateToChronoJulian';

  //*
  //  STRGregorianDateToChronoJulian - See documentation of GregorianDateToChronoJulian.
  //




  procedure Date0ToFractional
             (const date0          : array of ansichar;
              var   FractionalDate : array of ansichar); overload; stdcall;

  exports Date0ToFractional (const date0          : array of ansichar;
                             var   FractionalDate : array of ansichar) name 'TimeLib_Date0ToFractional';


  // *HTMLGEN InsertProcDocStart TimeLib_Date0ToFractional*

  //*
  //  Date0ToFractional - Convert from 'yyyy/mm/dd' to a fractional date.
  //
  //
  //  Convert the date in format 0 (yyyy/mm/dd) to a fractional date
  //  (yyyy.ffffff).  A fractional date is calculated by taking the
  //  offset number of days into the year (i.e. January 01 is 0,
  //  January 02 is 1, etc) and dividing by the number of days in that
  //  year.   For a normal non leap year such as 2001 the date
  //  January 01 is 2001.000000, January 02 is 2001.002740,
  //  December 31 is 2001.997260, etc).  In a leap year the divisor is
  //  slightly larger (366 instead of 365) so the decimal digits are
  //  slightly different for those same days.
  //
  //  CALLING SEQUENCE -
  //
  //    Date0ToFractional (date0, FractionalDate)
  //
  //  ENTRY -
  //
  //    date0 : array of char
  //      Date in the form 'yyyy/mm/dd'
  //
  //  EXIT -
  //
  //    FractionalDate : array of char
  //      Date in fractional format (i.e. 2001.002740)
  //
  // *HTMLGEN InsertProcDocEnd*




  procedure Date1ToDate0
             (const date1 : array of ansichar;
              var   date0 : array of ansichar); overload; stdcall;

  exports Date1ToDate0 (const date1 : array of ansichar;
                        var   date0 : array of ansichar) name 'TimeLib_Date1ToDate0';


  // *HTMLGEN InsertProcDocStart TimeLib_Date1ToDate0*

  //*
  //  Date1ToDate0 - Convert from 'mm/dd/yy' to 'yyyy/mm/dd'.
  //
  //
  //  This procedure converts from date format 1 (mm/dd/yy) to
  //  date format 0 (yyyy/mm/dd).
  //
  //  CALLING SEQUENCE -
  //
  //    Date1ToDate0 (date1, date0)
  //
  //  ENTRY -
  //
  //    date1 : array of char
  //      Date in the form 'mm/dd/yy'
  //
  //  EXIT -
  //
  //    date0 : array of char
  //      Date in the form 'yyyy/mm/dd'
  //
  // *HTMLGEN InsertProcDocEnd*




  procedure Date1ToDate0
             (const date1 : ansistring;
              var   date0 : array of ansichar); overload; stdcall;

  exports Date1ToDate0 (const date1 : ansistring;
                        var   date0 : array of ansichar) name 'TimeLib_STRDate1ToDate0';

  //*
  //  STRDate1ToDate0 - See documentation of Date1ToDate0.
  //




  procedure Date2ToDate0
             (const date2 : array of ansichar;
              var   date0 : array of ansichar); overload; stdcall;

  exports Date2ToDate0 (const date2 : array of ansichar;
                        var   date0 : array of ansichar) name 'TimeLib_Date2ToDate0';


  // *HTMLGEN InsertProcDocStart TimeLib_Date2ToDate0*

  //*
  //  Date2ToDate0 - Convert a date of format 2 to format 0.
  //
  //  Convert a date of the format 'mmm dd, yyyy' to 'yyyy/mm/dd'.
  //  ex. JUL 7, 1988 => 1989/07/14
  //
  //  CALLING SEQUENCE -
  //
  //    Date2ToDate0 (date2, date0)
  //
  //  ENTRY -
  //
  //    date2 : array of char
  //      The date in the format 'mmm dd, yyyy'
  //
  //  EXIT -
  //
  //    date0 : array of char
  //      The date in the format 'yyyy/mm/dd'
  //
  // *HTMLGEN InsertProcDocEnd*




  procedure Date2ToDate0
             (const date2 : ansistring;
              var   date0 : array of ansichar); overload; stdcall;

  exports Date2ToDate0 (const date2 : ansistring;
                        var   date0 : array of ansichar) name 'TimeLib_STRDate2ToDate0';

  //*
  //  STRDate2ToDate0 - See documentation of Date1ToDate0.
  //




  procedure Date3ToDate0
             (const date3 : array of ansichar;
              var   date0 : array of ansichar); overload; stdcall;

  exports Date3ToDate0 (const date3 : array of ansichar;
                        var   date0 : array of ansichar) name 'TimeLib_Date3ToDate0';


  // *HTMLGEN InsertProcDocStart TimeLib_Date3ToDate0*

  //*
  //  Date3ToDate0 - Convert a date of format 3 to format 0.
  //
  //  Convert a date of the format 'dd mmm yyyy' to 'yyyy/mm/dd'.
  //  ex. JUL 7, 1988 => 1989/07/14
  //
  //  CALLING SEQUENCE -
  //
  //    Date3ToDate0 (date3, date0)
  //
  //  ENTRY -
  //
  //    date3 : array of char
  //      The date in the format 'dd mmm yyyy'
  //
  //  EXIT -
  //
  //    date0 : array of char
  //      The date in the format 'yyyy/mm/dd'
  //
  // *HTMLGEN InsertProcDocEnd*




  procedure Date3ToDate0
             (const date3 : ansistring;
              var   date0 : array of ansichar); overload; stdcall;

  exports Date3ToDate0 (const date3 : ansistring;
                        var   date0 : array of ansichar) name 'TimeLib_STRDate3ToDate0';

  //*
  //  STRDate3ToDate0 - See documentation of Date3ToDate0.
  //




  procedure Date4ToDate0
             (const date4 : array of ansichar;
              var   date0 : array of ansichar); overload; stdcall;

  exports Date4ToDate0 (const date4 : array of ansichar;
                        var   date0 : array of ansichar) name 'TimeLib_Date4ToDate0';


  // *HTMLGEN InsertProcDocStart TimeLib_Date4ToDate0*

  //*
  //  Date4ToDate0 - Convert a date of format 4 to format 0.
  //
  //  Convert a date of the format 'dd-mmm-yy' to 'yyyy/mm/dd'.
  //  ex. 07-JUL-88 => 1989/07/14
  //
  //  CALLING SEQUENCE -
  //
  //    Date4ToDate0 (date4, date0)
  //
  //  ENTRY -
  //
  //    date4 : array of char
  //      The date in the format 'dd-mmm-yy'
  //
  //  EXIT -
  //
  //    date0 : array of char
  //      The date in the format 'yyyy/mm/dd'
  //
  // *HTMLGEN InsertProcDocEnd*




  procedure Date4ToDate0
             (const date4 : ansistring;
              var   date0 : array of ansichar); overload; stdcall;

  exports Date4ToDate0 (const date4 : ansistring;
                        var   date0 : array of ansichar) name 'TimeLib_STRDate4ToDate0';

  //*
  //  STRDate4ToDate0 - See documentation of Date4ToDate0.
  //




  procedure Date5ToDate0
             (const date5 : array of ansichar;
              var   date0 : array of ansichar); overload; stdcall;

  exports Date5ToDate0 (const date5 : array of ansichar;
                        var   date0 : array of ansichar) name 'TimeLib_Date5ToDate0';


  // *HTMLGEN InsertProcDocStart TimeLib_Date5ToDate0*

  //*
  //  Date5ToDate0 - Convert a date of format 5 to format 0.
  //
  //  Convert a date of the format 'yyddd' to 'yyyy/mm/dd'.
  //  ex. JUL 7, 1988 => 1989/07/14
  //
  //  CALLING SEQUENCE -
  //
  //    Date5ToDate0 (date5, date0)
  //
  //  ENTRY -
  //
  //    date5 : array of char
  //      The date in the format 'yyddd'
  //
  //  EXIT -
  //
  //    date0 : array of char
  //      The date in the format 'yyyy/mm/dd'
  //
  // *HTMLGEN InsertProcDocEnd*




  procedure Date5ToDate0
             (const date5 : ansistring;
              var   date0 : array of ansichar); overload; stdcall;

  exports Date5ToDate0 (const date5 : ansistring;
                        var   date0 : array of ansichar) name 'TimeLib_STRDate5ToDate0';

  //*
  //  STRDate5ToDate0 - See documentation of Date5ToDate0.
  //




  procedure Date6ToDate0
             (const date6 : array of ansichar;
              var   date0 : array of ansichar); overload; stdcall;

  exports Date6ToDate0 (const date6 : array of ansichar;
                        var   date0 : array of ansichar) name 'TimeLib_Date6ToDate0';


  // *HTMLGEN InsertProcDocStart TimeLib_Date6ToDate0*

  //*
  //  Date6ToDate0 - Convert a date of format 6 to format 0.
  //
  //
  //  Convert a date of the format 'yymmdd' to 'yyyy/mm/dd'.
  //  ex. 890714 => 1989/07/14
  //
  //  CALLING SEQUENCE -
  //
  //    Date6ToDate0 (date6, date0)
  //
  //  ENTRY -
  //
  //    date6 : array of char
  //      The date in the format 'yymmdd'
  //
  //  EXIT -
  //
  //    date0 : array of char
  //      The date in the format 'yyyy/mm/dd'
  //
  // *HTMLGEN InsertProcDocEnd*




  procedure Date6ToDate0
             (const date6 : ansistring;
              var   date0 : array of ansichar); overload; stdcall;

  exports Date6ToDate0 (const date6 : ansistring;
                        var   date0 : array of ansichar) name 'TimeLib_STRDate6ToDate0';

  //*
  //  STRDate6ToDate0 - See documentation of Date6ToDate0.
  //




  procedure Date7ToDate0
             (const date7 : array of ansichar;
              var   date0 : array of ansichar); overload; stdcall;

  exports Date7ToDate0 (const date7 : array of ansichar;
                        var   date0 : array of ansichar) name 'TimeLib_Date7ToDate0';


  // *HTMLGEN InsertProcDocStart TimeLib_Date7ToDate0*

  //*
  //  Date7ToDate0 - Convert a date of format 7 to format 0.
  //
  //
  //  Convert a date of the format 'yy mm dd' to 'yyyy/mm/dd'.
  //  ex. 89 07 14 => 1989/07/14
  //
  //  CALLING SEQUENCE -
  //
  //    Date7ToDate0 (date7, date0)
  //
  //  ENTRY -
  //
  //    date7 : array of char
  //      The date in the format 'yy mm dd'
  //
  //  EXIT -
  //
  //    date0 : array of char
  //      The date in the format 'yyyy/mm/dd'
  //
  // *HTMLGEN InsertProcDocEnd*




  procedure Date7ToDate0
             (const date7 : ansistring;
              var   date0 : array of ansichar); overload; stdcall;

  exports Date7ToDate0 (const date7 : ansistring;
                        var   date0 : array of ansichar) name 'TimeLib_STRDate7ToDate0';

  //*
  //  STRDate7ToDate0 - See documentation of Date7ToDate0.
  //




  procedure Date8ToDate0
             (const date8 : array of ansichar;
              var   date0 : array of ansichar); overload; stdcall;

  exports Date8ToDate0 (const date8 : array of ansichar;
                        var   date0 : array of ansichar) name 'TimeLib_Date8ToDate0';


  // *HTMLGEN InsertProcDocStart TimeLib_Date8ToDate0*

  //*
  //  Date8ToDate0 - Convert a date of format 6 to format 0.
  //
  //
  //  Convert a date of the format 'yyyymmdd' to 'yyyy/mm/dd'.
  //  ex. 19890714 => 1989/07/14
  //
  //  CALLING SEQUENCE -
  //
  //    Date8ToDate0 (date8, date0)
  //
  //  ENTRY -
  //
  //    date8 : array of char
  //      The date in the format 'yyyymmdd'
  //
  //  EXIT -
  //
  //    date0 : array of char
  //      The date in the format 'yyyy/mm/dd'
  //
  // *HTMLGEN InsertProcDocEnd*




  procedure Date8ToDate0
             (const date8 : ansistring;
              var   date0 : array of ansichar); overload; stdcall;

  exports Date8ToDate0 (const date8 : ansistring;
                        var   date0 : array of ansichar) name 'TimeLib_STRDate8ToDate0';

  //*
  //  STRDate8ToDate0 - See documentation of Date8ToDate0.
  //




  procedure Date9ToDate0
             (const date9 : array of ansichar;
              var   date0 : array of ansichar); overload; stdcall;

  exports Date9ToDate0 (const date9 : array of ansichar;
                        var   date0 : array of ansichar) name 'TimeLib_Date9ToDate0';


  // *HTMLGEN InsertProcDocStart TimeLib_Date9ToDate0*

  //*
  //  Date9ToDate0 - Convert a date of format 9 to format 0.
  //
  //
  //  Convert a date of the format 'ddmmmyy' to 'yyyy/mm/dd'.
  //  ex. 07JUL88 => 1989/07/14
  //
  //  CALLING SEQUENCE -
  //
  //    Date9ToDate0 (date9, date0)
  //
  //  ENTRY -
  //
  //    date9 : array of char
  //      The date in the format 'ddmmmyy'
  //
  //  EXIT -
  //
  //    date0 : array of char
  //      The date in the format 'yyyy/mm/dd'
  //
  // *HTMLGEN InsertProcDocEnd*




  procedure Date9ToDate0
             (const date9 : ansistring;
              var   date0 : array of ansichar); overload; stdcall;

  exports Date9ToDate0 (const date9 : ansistring;
                        var   date0 : array of ansichar) name 'TimeLib_STRDate9ToDate0';

  //*
  //  STRDate9ToDate0 - See documentation of Date9ToDate0.
  //




  procedure Date10ToDate0
             (const date10 : array of ansichar;
              var   date0  : array of ansichar); overload; stdcall;

  exports Date10ToDate0 (const date10 : array of ansichar;
                         var   date0  : array of ansichar) name 'TimeLib_Date10ToDate0';


  // *HTMLGEN InsertProcDocStart TimeLib_Date10ToDate0*

  //*
  //  Date10ToDate0 - Convert from 'mm/yy' to 'yyyy/mm/dd'.
  //
  //
  //  This procedure converts from date format 10 (mm/yy) to
  //  date format 0 (yyyy/mm/dd).  The first day of the
  //  month (01) is assumed.
  //
  //  CALLING SEQUENCE -
  //
  //    Date10ToDate0 (date10, date0)
  //
  //  ENTRY -
  //
  //    date10 : array of char
  //      Date in the form 'mm/yy'
  //
  //  EXIT -
  //
  //    date0 : array of char
  //      Date in the form 'yyyy/mm/dd'
  //
  // *HTMLGEN InsertProcDocEnd*




  procedure Date10ToDate0
             (const date10 : ansistring;
              var   date0  : array of ansichar); overload; stdcall;

  exports Date10ToDate0 (const date10 : ansistring;
                         var   date0  : array of ansichar) name 'TimeLib_STRDate10ToDate0';

  //*
  //  STRDate10ToDate0 - See documentation of Date10ToDate0.
  //




  procedure Date11ToDate0
             (const date11 : array of ansichar;
              var   date0  : array of ansichar); overload; stdcall;

  exports Date11ToDate0 (const date11 : array of ansichar;
                         var   date0  : array of ansichar) name 'TimeLib_Date11ToDate0';


  // *HTMLGEN InsertProcDocStart TimeLib_Date11ToDate0*

  //*
  //  Date11ToDate0 - Convert from 'dd mmm yy' to 'yyyy/mm/dd'.
  //
  //
  //  This procedure converts from date format 11 (dd mmm yy) to
  //  date format 0 (yyyy/mm/dd).
  //
  //  CALLING SEQUENCE -
  //
  //    Date11ToDate0 (date11, date0)
  //
  //  ENTRY -
  //
  //    date11 : array of char
  //      Date in the form 'dd mmm yy'.
  //
  //  EXIT -
  //
  //    date0 : array of char
  //      Date in the form 'yyyy/mm/dd'
  //
  // *HTMLGEN InsertProcDocEnd*




  procedure Date11ToDate0
             (const date11 : ansistring;
              var   date0  : array of ansichar); overload; stdcall;

  exports Date11ToDate0 (const date11 : ansistring;
                         var   date0  : array of ansichar) name 'TimeLib_STRDate11ToDate0';

  //*
  //  STRDate11ToDate0 - See documentation of Date11ToDate0.
  //




  procedure Date12ToDate0
             (const date12 : array of ansichar;
              var   date0  : array of ansichar); overload; stdcall;

  exports Date12ToDate0 (const date12 : array of ansichar;
                         var   date0  : array of ansichar) name 'TimeLib_Date12ToDate0';


  // *HTMLGEN InsertProcDocStart TimeLib_Date12ToDate0*

  //*
  //  Date12ToDate0 - Convert from 'mm/dd/yyyy' to 'yyyy/mm/dd'.
  //
  //
  //  This procedure converts from date format 12 (mm/dd/yyyy) to
  //  date format 0 (yyyy/mm/dd).
  //
  //  CALLING SEQUENCE -
  //
  //    Date12ToDate0 (date12, date0)
  //
  //  ENTRY -
  //
  //    date12 : array of char
  //      Date in the form 'mm/dd/yyyy'.
  //
  //  EXIT -
  //
  //    date0 : array of char
  //      Date in the form 'yyyy/mm/dd'
  //
  // *HTMLGEN InsertProcDocEnd*




  procedure Date12ToDate0
             (const date12 : ansistring;
              var   date0  : array of ansichar); overload; stdcall;

  exports Date12ToDate0 (const date12 : ansistring;
                         var   date0  : array of ansichar) name 'TimeLib_STRDate12ToDate0';

  //*
  //  STRDate12ToDate0 - See documentation of Date12ToDate0.
  //




  procedure JulianToDate0
             (const jDate : ModSys.S_Natural;
              var   date0 : array of ansichar); overload; stdcall;

  exports JulianToDate0 (const jDate : ModSys.S_Natural;
                         var   date0 : array of ansichar) name 'TimeLib_JulianToDate0';


  // *HTMLGEN InsertProcDocStart TimeLib_JulianToDate0*

  //*
  //  JulianToDate0 - Convert from julian to 'yyyy/mm/dd'.
  //
  //
  //  Convert the julian date (days since Jan 1900 where 1 Jan. 1900
  //  is day 1) to the date in format 0 (yyyy/mm/dd).
  //
  //  CALLING SEQUENCE -
  //
  //    JulianToDate0 (jDate, date0)
  //
  //  ENTRY -
  //
  //    jDate : ModSys.S_Natural
  //      Number of days since 1 Jan 1900.
  //
  //  EXIT -
  //
  //    date0 : array of char
  //      Date in the form 'yyyy/mm/dd'
  //
  // *HTMLGEN InsertProcDocEnd*




  procedure JulianToDate0
             (const jDate : ModSys.S_Natural;
              var   date0 : ansistring); overload; stdcall;

  exports JulianToDate0 (const jDate : ModSys.S_Natural;
                         var   date0 : ansistring) name 'TimeLib_STRJulianToDate0';

  //*
  //  STRJulianToDate0 - See documentation of JulianToDate0.
  //




  procedure ChronoJulianToGregorianDate
             (const ChronoDate    : ModSys.S_Float64;
              var   GregorianDate : array of ansichar); overload; stdcall;

  exports ChronoJulianToGregorianDate (const ChronoDate    : ModSys.S_Float64;
                                       var   GregorianDate : array of ansichar) name 'TimeLib_ChronoJulianToGregorianDate';


  // *HTMLGEN InsertProcDocStart TimeLib_ChronoJulianToGregorianDate*

  //*
  //  ChronoJulianToGregorianDate - Convert from Chrono Julian to Gregorian.
  //
  //  This procedure converts a Chrono Julian date to a Gregorian date in the
  //  general form of DD MMM YYYY/YYYY B.C.  This differs from the other
  //  routines in this library that refer to a julian date.  Those 'julian date'
  //  routines return a modified julian date starting at 1900/01/01 and cannot
  //  represent any date prior to that time.
  //
  //  This routines chronological julian date is based on a starting date of
  //  midnight on 01 Jan 4713 B.C. and is the more standard way of representing
  //  dates when working with time prior to 1900/01/01.  The number that is
  //  returned represents the number of nychthemerons since that starting point.
  //  A nychthemeron is one cycle of night and day.  This routine's nychthemeron
  //  calculations are based on midnight to midnight with the first cycle from
  //  midnight 4713/01/01 B.C. to midnight 4713/01/02 B.C. being designated as
  //  0.  The next cycle designated as 1 and so on.
  //
  //  CALLING SEQUENCE -
  //
  //    ChronoJulianToGregorianDate (ChronoJulian, GregorianDate)
  //
  //  ENTRY -
  //
  //    ChronoDate : ModSys.S_Float64
  //      The date to convert represented as a chrono julian date.
  //
  //  EXIT -
  //
  //    GregorianDate : array of char
  //      The chrono julian date converted to a Gregorian calendar date in the
  //      general format of DD MMM YYYY.  It can be in the dual date format of
  //      DD MMM YYYY/YYYY and may also include a B.C. designator
  //      (i.e. DD MMM YYYY/YYYY B.C.)
  //
  // *HTMLGEN InsertProcDocEnd*




  procedure ChronoJulianToGregorianDate
             (const ChronoDate    : ModSys.S_Float64;
              var   GregorianDate : ansistring); overload; stdcall;

  exports ChronoJulianToGregorianDate (const ChronoDate    : ModSys.S_Float64;
                                       var   GregorianDate : ansistring) name 'TimeLib_STRChronoJulianToGregorianDate';

  //*
  //  STRChronoJulianToGregorianDate - See documentation of ChronoJulianToGregorianDate.
  //




  procedure FractionalToDate0
             (const FractionalDate : array of ansichar;
              var   date0          : array of ansichar); overload; stdcall;

  exports FractionalToDate0 (const FractionalDate : array of ansichar;
                             var   date0          : array of ansichar) name 'TimeLib_FractionalToDate0';


  // *HTMLGEN InsertProcDocStart TimeLib_FractionalToDate0*

  //*
  //  FractionalToDate0 - Convert from fractional date to 'yyyy/mm/dd'.
  //
  //
  //  Convert the date in fractional format (yyyy.ffffff) to format 0
  //  (yyyy/mm/dd).  A fractional date is calculated by taking the
  //  offset number of days into the year (i.e. January 01 is 0,
  //  January 02 is 1, etc) and dividing by the number of days in that
  //  year.   For a normal non leap year such as 2001 the date
  //  January 01 is 2001.000000, January 02 is 2001.002740,
  //  December 31 is 2001.997260, etc).  In a leap year the divisor is
  //  slightly larger (366 instead of 365) so the decimal digits are
  //  slightly different for those same days.
  //
  //  CALLING SEQUENCE -
  //
  //    FractionalToDate0 (FractionalDate, date0)
  //
  //  ENTRY -
  //
  //    FractionalDate : array of char
  //      Date in fractional format (i.e. 2001.002740)
  //
  //  EXIT -
  //
  //    date0 : array of char
  //      Date in the form 'yyyy/mm/dd'
  //
  // *HTMLGEN InsertProcDocEnd*




  procedure FractionalToDate0
             (const FractionalDate : ansistring;
              var   date0          : array of ansichar); overload; stdcall;

  exports FractionalToDate0 (const FractionalDate : ansistring;
                             var   date0          : array of ansichar) name 'TimeLib_STRFractionalToDate0';

  //*
  //  STRFractionalToDate0 - See documentation of FractionalToDate0.
  //




  function DayOfWeek
             (const date0 : array of ansichar) : ModSys.S_Natural; overload; stdcall;

  exports DayOfWeek (const date0 : array of ansichar) name 'TimeLib_DayOfWeek';


  // *HTMLGEN InsertProcDocStart TimeLib_DayOfWeek*

  //*
  //  DayOfWeek - Return the day of week given date format 0.
  //
  //
  //  This procedure returns the day of the week for the date given
  //  using format 0 (yyyy/mm/dd).
  //
  //  CALLING SEQUENCE -
  //
  //    day := DayOfWeek (date0)
  //
  //  ENTRY -
  //
  //    date0 : array of char
  //      Date in the form 'yyyy/mm/dd'
  //
  //  EXIT -
  //
  //    day : ModSys.S_Natural
  //      The day of the week where 0=Sunday, 1=Monday, . ..
  //      6=Saturday.
  //
  // *HTMLGEN InsertProcDocEnd*




  function DayOfWeek
             (const date0 : ansistring) : ModSys.S_Natural; overload; stdcall;

  exports DayOfWeek (const date0 : ansistring) name 'TimeLib_STRDayOfWeek';

  //*
  //  STRDayOfWeek - See documentation of DayOfWeek.
  //




  function DaysInMonth
             (const date0 : array of ansichar) : ModSys.S_Natural; overload; stdcall;

  exports DaysInMonth (const date0 : array of ansichar) name 'TimeLib_DaysInMonth';


  // *HTMLGEN InsertProcDocStart TimeLib_DaysInMonth*

  //*
  //  DaysInMonth - Return the number of days in the month of the given date.
  //
  //  This routine takes a date in zero format and determines for the given
  //  month how many days that month would have.  This calculation takes into
  //  account leap years in determining the number.
  //
  //  CALLING SEQUENCE -
  //
  //    DaysInMonth (date0)
  //
  //  ENTRY -
  //
  //    date0 : array of char
  //      A date in zero format.  The routine will return the number of days in
  //      the month of that year.
  //
  //  EXIT -
  //
  //    DaysInMonth : ModSys.S_Natural
  //      The number of days that are in the indicated month.
  //
  // *HTMLGEN InsertProcDocEnd*




  function DaysInMonth
             (const date0 : ansistring) : ModSys.S_Natural; overload; stdcall;

  exports DaysInMonth (const date0 : ansistring) name 'TimeLib_STRDaysInMonth';

  //*
  //  STRDaysInMonth - See documentation of DaysInMonth.
  //




  function CurrentWeekDay
             () : ModSys.S_Natural; stdcall;

  exports CurrentWeekDay name 'TimeLib_CurrentWeekDay';


  // *HTMLGEN InsertProcDocStart TimeLib_CurrentWeekDay*

  //*
  //  CurrentWeekDay - Return the current day of week.
  //
  //
  //  This procedure returns the day of the week for the current date
  //  as held by the system clock.
  //
  //  CALLING SEQUENCE -
  //
  //    WDay := CurrentWeekDay ()
  //
  //  EXIT -
  //
  //    CurrentWeekDay : ModSys.S_Natural
  //      The day of the week where 0=Sunday, 1=Monday, . ..
  //      6=Saturday.
  //
  // *HTMLGEN InsertProcDocEnd*




  function DayOfYear
             (const date0 : array of ansichar) : ModSys.S_Natural; overload; stdcall;

  exports DayOfYear (const date0 : array of ansichar) name 'TimeLib_DayOfYear';


  // *HTMLGEN InsertProcDocStart TimeLib_DayOfYear*

  //*
  //  DayOfYear - Convert from 'yyyy/mm/dd' to a day number in year.
  //
  //
  //  Convert the date in format 0 (yyyy/mm/dd) to a ModSys.S_Natural
  //  day number within the given year where 1 Jan. will be 1.
  //
  //  CALLING SEQUENCE -
  //
  //    ic := DayOfYear (date0)
  //
  //  ENTRY -
  //
  //    date0 : array of char
  //      Date in the form 'yyyy/mm/dd'
  //
  //  EXIT -
  //
  //    ic : ModSys.S_Natural
  //      Day number in the given year.
  //
  // *HTMLGEN InsertProcDocEnd*




  function DayOfYear
             (const date0 : ansistring) : ModSys.S_Natural; overload; stdcall;

  exports DayOfYear (const date0 : ansistring) name 'TimeLib_STRDayOfYear';

  //*
  //  STRDayOfYear - See documentation of DayOfYear.
  //




  procedure ElapsedTime
             (const seqNumber : ModSys.S_Natural;
              var   Time1     : array of ansichar;
              var   Seconds   : ModSys.S_Natural;
              var   millisec  : ModSys.S_Natural); overload; stdcall;

  exports ElapsedTime (const seqNumber : ModSys.S_Natural;
                       var   Time1     : array of ansichar;
                       var   Seconds   : ModSys.S_Natural;
                       var   millisec  : ModSys.S_Natural) name 'TimeLib_ElapsedTime';


  // *HTMLGEN InsertProcDocStart TimeLib_ElapsedTime*

  //*
  //  ElapsedTime - Return elapsed time since indicated timer began.
  //
  //
  //  This procedures returns the elapsed time for indicated
  //  timed sequence.  The time is returned in the form 'hh:mm:ss.sss'.
  //
  //  CALLING SEQUENCE -
  //
  //    ElapsedTime (seqNumber, Time1)
  //
  //  ENTRY -
  //
  //    seqNumber : ModSys.S_Natural
  //      A timed sequence. (1 .. 20)
  //
  //  EXIT -
  //
  //    Time1 : array of char
  //      The elapsed time in the form 'hh:mm:ss.sss'.
  //
  //    seconds : ModSys.S_Natural
  //      The number of seconds in elapsed time.
  //
  //    millisec : ModSys.S_Natural
  //      The millisec portion of the elapsed time.
  //
  // *HTMLGEN InsertProcDocEnd*




  procedure ElapsedTime
             (const seqNumber : ModSys.S_Natural;
              var   Time1     : ansistring;
              var   Seconds   : ModSys.S_Natural;
              var   millisec  : ModSys.S_Natural); overload; stdcall;

  exports ElapsedTime (const seqNumber : ModSys.S_Natural;
                       var   Time1     : ansistring;
                       var   Seconds   : ModSys.S_Natural;
                       var   millisec  : ModSys.S_Natural) name 'TimeLib_STRElapsedTime';

  //*
  //  STRElapsedTime - See documentation of ElapsedTime.
  //




  procedure StartTimer
             (const seqNumber : ModSys.S_Natural); stdcall;

  exports StartTimer name 'TimeLib_StartTimer';


  // *HTMLGEN InsertProcDocStart TimeLib_StartTimer*

  //*
  //  StartTimer - Start the timer for indicated sequence.
  //
  //
  //  This procedures sets the timer for the selected sequence.
  //  A sequence number of from 1 to 10 may be selected and
  //  simultaneously timed with other timers.
  //
  //  CALLING SEQUENCE -
  //
  //    StartTimer (seqNumber)
  //
  //  ENTRY -
  //
  //    seqNumber : ModSys.S_Natural
  //      A timed sequence. (1 .. 20).
  //
  // *HTMLGEN InsertProcDocEnd*




  procedure SetTimer
             (const seqNumber : ModSys.S_Natural;
              const newTime   : TimeDate.Time); stdcall;

  exports SetTimer name 'TimeLib_SetTimer';


  // *HTMLGEN InsertProcDocStart TimeLib_SetTimer*

  //*
  //  SetTimer - Set the timer for indicated sequence.
  //
  //
  //  This procedures sets the timer for the selected sequence.
  //  if some time other than the current time is required.
  //  A sequence number of from 1 to 20 may be selected and
  //  simultaneously timed with other timers.
  //
  //  CALLING SEQUENCE -
  //
  //    SetTimer (seqNumber, newTime)
  //
  //  ENTRY -
  //
  //    seqNumber : ModSys.S_Natural
  //      A timed sequence. (1 .. 20).
  //
  //    newTime : Time
  //      The new time to set the timer to.
  //
  // *HTMLGEN InsertProcDocEnd*




  function IsLeapYearStr
             (const YearStr : array of ansichar) : boolean; overload; stdcall;

  exports IsLeapYearStr (const YearStr : array of ansichar) name 'TimeLib_IsLeapYearStr';


  // *HTMLGEN InsertProcDocStart TimeLib_IsLeapYearStr*

  //*
  //  IsLeapYearStr - Is the year in this string a leap year?.
  //
  //
  //  This procedure checks the year passed in string form and returns
  //  a boolean value showing if the year would be a leap year.  Leap year
  //  is calculated by the logic that if the year is evenly divisible by 400
  //  it is a leap year.  If the year is divisible by 4 but not divisible by
  //  100 it is a leap year.  This routine only calculates for the Gregorian
  //  calendar as adopted by the US in late 1752 so any year prior to 1753
  //  passed to this routine will simply return False.
  //
  //  CALLING SEQUENCE -
  //
  //    IsLeapYearStr (YearStr)
  //
  //  ENTRY -
  //
  //    YearStr : array of char
  //      A year represented in string form.
  //
  //  EXIT -
  //
  //    True - This year would be a leap year.
  //      False - This year is not a leap year.
  //
  // *HTMLGEN InsertProcDocEnd*




  function IsLeapYearStr
             (const YearStr : ansistring) : boolean; overload; stdcall;

  exports IsLeapYearStr (const YearStr : ansistring) name 'TimeLib_STRIsLeapYearStr';

  //*
  //  STRIsLeapYearStr - See documentation of IsLeapYearStr.
  //




  function IsLeapYearCard
             (const YearCard : ModSys.S_Natural) : boolean; stdcall;

  exports IsLeapYearCard name 'TimeLib_IsLeapYearCard';


  // *HTMLGEN InsertProcDocStart TimeLib_IsLeapYearCard*

  //*
  //  IsLeapYearCard - Is the year in this ModSys.S_Natural a leap year?.
  //
  //
  //  This procedure checks the year passed in ModSys.S_Natural form and returns
  //  a boolean value showing if the year would be a leap year.  Leap year
  //  is calculated by the logic that if the year is evenly divisible by 400
  //  it is a leap year.  If the year is divisible by 4 but not divisible by
  //  100 it is a leap year.  This routine only calculates for the Gregorian
  //  calendar as adopted by the US in late 1752 so any year prior to 1753
  //  passed to this routine will simply return False.
  //
  //  CALLING SEQUENCE -
  //
  //    IsLeapYearCard (YearCard)
  //
  //  ENTRY -
  //
  //    YearCard : ModSys.S_Natural
  //      A year represented in ModSys.S_Natural form.
  //
  //  EXIT -
  //
  //    True - This year would be a leap year.
  //      False - This year is not a leap year.
  //
  // *HTMLGEN InsertProcDocEnd*




  procedure ParseGregorianDate
             (const dateVal      : array of ansichar;
              var   GregorianRec : GregorianDateRecordType;
              var   Error        : ModSys.S_Natural); overload; stdcall;

  exports ParseGregorianDate (const dateVal      : array of ansichar;
                              var   GregorianRec : GregorianDateRecordType;
                              var   Error        : ModSys.S_Natural) name 'TimeLib_ParseGregorianDate';


  // *HTMLGEN InsertProcDocStart TimeLib_ParseGregorianDate*

  //*
  //  ParseGregorianDate - Parse a Gregorian date into its components.
  //
  //
  //  This procedure parsed a Gregorian date into its components.  The expected
  //  format is like 12 Oct 2006.  It will also handle the dual dates used at
  //  the time of the calendar change from Julian to Gregorian such as
  //  23 Feb 1724/1725.  The date string is parsed into a record structure that
  //  allows for easier handling and testing of the values.
  //
  //  CALLING SEQUENCE -
  //
  //    ParseGregorianDate (DateVal, GregorianRec, Error)
  //
  //  ENTRY -
  //
  //    DateVal : array of char
  //      A gregorian date in string format.
  //
  //  EXIT -
  //
  //    GregorianRec : GregorianDateRecordType
  //      A record structure containing the component pieces of the date.
  //
  //    Error : ModSys.S_Natural
  //      Zero if correct date format encountered.  If set see date related
  //      errors in SageErrs.
  //
  // *HTMLGEN InsertProcDocEnd*




  procedure ParseGregorianDate
             (const dateVal      : ansistring;
              var   GregorianRec : GregorianDateRecordType;
              var   Error        : ModSys.S_Natural); overload; stdcall;

  exports ParseGregorianDate (const dateVal      : ansistring;
                              var   GregorianRec : GregorianDateRecordType;
                              var   Error        : ModSys.S_Natural) name 'TimeLib_STRParseGregorianDate';

  //*
  //  STRParseGregorianDate - See documentation of ParseGregorianDate.
  //




Send mail to   warren.merrill@inl.gov with questions or comments about this web site.
Copyright © 1989-2008 Battelle Energy Alliance