Erstellen von Unix-Termine

Erstellen von Unix-Termine

Erstellen von Unix-Termine : Mehreren tausend Tipps, um Ihr Leben einfacher machen.

Diese Einheit ermöglicht den Zugriff auf UNIX bis heute ähnliche Funktionen und Prozeduren

Autor: BRIAN STARK

(***************************************************************************)
(* UNIX Datum Version 1.01 *)
(* Diese Einheit ermöglicht den Zugriff auf UNIX bis heute ähnliche Funktionen und Prozeduren *)
(* Ein UNIX-Datum ist die Anzahl der Sekunden seit 1. Januar 1970. Diese Einheit *)
(* frei verwendet werden können. Wenn Sie den Quellcode ändern, bitte nicht *)
(* Ihr Zubehör zu verteilen. *)
(* (C) 1991-1993 von Brian Stark. *)
(* Dies ist eine Programmierung Release von Digital Illusions *)
(* FidoNet 1:289 / 27.2 + Columbia, MO - USA *)
(* Revisionshistorie *)
(* ----------------------------------------------------------------------- *)
(* 13.06.1993 1.02 | Kleinere Codebereinigung *)
(* 23.05.1993 1.01 | Ein paar mehr Routinen für die Verwendung mit ViSiON BBS hinzugefügt *)
(* ?? -?? -1991 1.00 | Erstes release *)
(* ----------------------------------------------------------------------- *)
(***************************************************************************)

SCHNITTSTELLE

Verwendet
DOS;

Funktion GetTimeZone: ShortInt;
{Gibt den Wert aus der Enviroment-Variablen 'TZ'. Wenn keine gefunden wird, ist UTC
angenommen, und ein Wert von 0 (null) wird zurückgegeben}
Funktion IsLeapYear(Source: Word): Boolean;
{Bestimmt, ob das Jahr ein Schaltjahr oder nicht ist}
Funktion Norm2Unix (Y, M, D, H, Min, S: Word): LongInt;
{Konvertieren Sie ein normales Datum in ihren UNIX-Datum. Wenn Umgebung Variable 'TZ' ist
definiert, dann die Eingabeparameter angenommen sind, sich in ** LOKALZEIT **}
Prozedur Unix2Norm (Datum: LongInt; Var Y, M, D, H, Min, S: Word);
{Konvertieren Sie ein UNIX-Datum in Gegenstück normalen Datum. Wenn die Umwelt
Variable 'TZ' definiert ist, dann die Ausgabe in ** LOKALZEIT **}

Funktion TodayInUnix: LongInt;
{Ruft heute und ruft Norm2Unix}
{
Folgendes gibt eine Zeichenfolge zurück und die TechnoJock-TotSTR-Einheit erfordert.
Funktion Unix2Str(N: LongInt): String;
}
Const
DaysPerMonth:
Array [1..12] von ShortInt = (031,028,031,030,031,030,031,031,030,031,030,031);
DaysPerYear:
[1..12] Array von Integer = (031,059,090,120,151,181,212,243,273,304,334,365);
DaysPerLeapYear:
[1..12] Array von Integer = (031,060,091,121,152,182,213,244,274,305,335,366);
SecsPerYear: LongInt = 31536000;
SecsPerLeapYear: LongInt = 31622400;
SecsPerDay: LongInt = 86400;
SecsPerHour: Integer = 3600;
SecsPerMinute: ShortInt = 60;

UMSETZUNG

Funktion GetTimeZone: ShortInt;
Var
Umwelt: String;
Index: Integer;
BEGIN
GetTimeZone: = 0; {Übernehmen UTC}
Umwelt: = GetEnv('TZ'); {Grab TZ Zeichenfolge}
Für Index: = 1 bis Length(Environment)-Do
Umwelt [Index]: = Upcase(Environment[Index]);
(*
Hinweis: Ich habe noch eine komplette Liste der ISO-Tabelle der Zeitzone
Abkürzungen. Im folgenden ist die Opus-Cbcs ein Auszug aus
Dokumentationsdateien.
*)
Wenn Umwelt = 'EST05' dann GetTimeZone: =-05; {ÖSTLICHEN USA}
Wenn Umwelt = 'EST05EDT' dann GetTimeZone: =-06;
Wenn Umwelt = 'CST06' dann GetTimeZone: =-06; {USA CENTRAL}
Wenn Umwelt = 'CST06CDT' dann GetTimeZone: =-07;
Wenn Umwelt = 'MST07' dann GetTimeZone: =-07; {USA BERG}
Wenn Umwelt = 'MST07MDT' dann GetTimeZone: =-08;
Wenn Umwelt = 'PST08' dann GetTimeZone: =-08;
Wenn Umwelt = 'PST08PDT' dann GetTimeZone: =-09;
Wenn Umwelt = 'YST09' dann GetTimeZone: =-09;
Wenn Umwelt = 'AST10' dann GetTimeZone: =-10;
Wenn Umwelt = 'BST11' dann GetTimeZone: =-11;
Wenn Umwelt = 'CET-1' dann GetTimeZone: = 01;
Wenn Umwelt = 'CET-01' dann GetTimeZone: = 01;
Wenn Umwelt = 'EST-10' dann GetTimeZone: = 10;
Wenn Umwelt = 'WST-8' dann GetTimeZone: = 08; {Perth, West Australien}
Wenn Umwelt = 'WST-08', dann GetTimeZone: = 08;
Ende;

Funktion IsLeapYear(Source: Word): Boolean;
BEGIN
(*
Hinweis: Das ist falsch!
*)
Wenn (Quelle: Mod 4 = 0) dann
IsLeapYear: = True
Sonst
IsLeapYear: = False;
Ende;

Funktion Norm2Unix (Y, M, D, H, Min, S: Word): LongInt;
Var
UnixDate: LongInt;
Index: Word;
BEGIN
UnixDate: = 0; {Initialisieren}
Inc(UnixDate,S); {Weitere Sekunden}
Inc (UnixDate,(SecsPerMinute * Min)); {Minuten hinzufügen}
Inc (UnixDate,(SecsPerHour * H)); {Stunden hinzufügen}
(*************************************************************************)
(* Wenn UTC = 0, und die lokale Zeit ist-06 Stunden UTC, dann *)
(* UTC: = UTC - (-06 * SecsPerHour) *)
(* Nicht vergessen, dass eine negative # abzüglich einer negativen # ergibt sich einen positiven Wert *)
(*************************************************************************)
UnixDate: = UnixDate - (GetTimeZone * SecsPerHour); {UTC-Offset}

Wenn D > 1 dann {eines Tages schon vergangen?}
Inc (UnixDate, (SecsPerDay * (D-1)));

Wenn IsLeapYear(Y) dann
DaysPerMonth [02]: = 29
Sonst
DaysPerMonth [02]: = 28; {Für Februar 29th überprüfen}

Index: = 1;
Wenn M > 1 dann für Index: = 1 To (M-1) Do {ist bereits ein Monat vergangen?}
Inc (UnixDate, (DaysPerMonth [Index] * SecsPerDay));

Während Y > 1970
BEGIN
Wenn IsLeapYear((Y-1)) dann
Inc(UnixDate,SecsPerLeapYear)
Sonst
Inc(UnixDate,SecsPerYear);
Dec(Y,1);
Ende;

Norm2Unix: = UnixDate;
Ende;

Prozedur Unix2Norm (Datum: LongInt; Var Y, M, D, H, Min, S: Word);
{}
Var
LocalDate: LongInt;
Getan: Boolean;
X: ShortInt;
TotDays: Integer;
BEGIN
Y: = 1970;
M: = 1;
D: = 1;
H: = 0;
Min: = 0;
S: = 0;
LocalDate: = Datum + (GetTimeZone * SecsPerHour); {Lokale Uhrzeit Datum}
(*************************************************************************)
(* Fegen die Jahre... *)
(*************************************************************************)
Fertig: = False;
Weile getan nicht
BEGIN
Wenn LocalDate > = SecsPerYear Then
BEGIN
Inc(Y,1);
Dec(LocalDate,SecsPerYear);
Ende
Sonst
Fertig: = True;

Wenn (IsLeapYear(Y+1)) und (LocalDate > = SecsPerLeapYear) und
(Nicht fertig) Dann
BEGIN
Inc(Y,1);
Dec(LocalDate,SecsPerLeapYear);
Ende;
Ende;
(*************************************************************************)
M: = 1;
D: = 1;
Fertig: = False;
TotDays: = LocalDate Div SecsPerDay;
Wenn IsLeapYear(Y) dann
BEGIN
DaysPerMonth [02]: = 29;
X: = 1;
Wiederholen Sie die
Wenn (TotDays < = DaysPerLeapYear[x]) Then
BEGIN
M: = X;
Fertig: = True;
Dec (LocalDate,(TotDays * SecsPerDay));
D: = DaysPerMonth[M]-(DaysPerLeapYear[M]-TotDays) + 1;
Ende
Sonst
Fertig: = False;
Inc(X);
Bis (erledigt) oder (X > 12);
Ende
Sonst
BEGIN
DaysPerMonth [02]: = 28;
X: = 1;
Wiederholen Sie die
Wenn (TotDays < = DaysPerYear[x]) Then
BEGIN
M: = X;
Fertig: = True;
Dec (LocalDate,(TotDays * SecsPerDay));
D: = DaysPerMonth[M]-(DaysPerYear[M]-TotDays) + 1;
Ende
Sonst
Fertig: = False;
Inc(X);
Bis Done = True oder (X > 12);
Ende;
H: = LocalDate Div SecsPerHour;
Dec (LocalDate,(H * SecsPerHour));
Min: = LocalDate Div SecsPerMinute;
Dec (LocalDate,(Min * SecsPerMinute));
S: = LocalDate;
Ende;

Funktion TodayInUnix: LongInt;
Var
Jahr, Monat, Tag, DayOfWeek: Word;
Stunde, Minute, Sekunde, Sec100: Word;
BEGIN
GetDate (Jahr, Monat, Tag, DayOfWeek);
GetTime (Stunde, Minute, Sekunde, Sec100);
TodayInUnix: = Norm2Unix(Year,Month,Day,Hour,Minute,Second);
Ende;

Funktion Unix2Str(N: LongInt): String;
Var
Jahr, Monat, Tag, DayOfWeek: Word;
Stunde, Minute, Sekunde, Sec100: Word;
T: String;
BEGIN
Unix2Norm (N, Jahr, Monat, Tag, Stunde, Minute, Second);
T: = PadRight(IntToStr(Month),2,'0')+'-'+PadRight(IntToStr(Day),2,'0') +'-' +
PadRight(IntToStr(Year),2,'0') + ''+ PadRight(IntToStr(Hour),2,'0') +':' +
PadRight(IntToStr(Minute),2,'0')+':'+PadRight(IntToStr(Second),2,'0');
Wenn Stunden > 12 dann
T: = T + 'PM'
Sonst
T: = T + 'AM';
Unix2Str: = T;
Ende;

ENDE.