2066 lines
57 KiB
Plaintext
Executable File
2066 lines
57 KiB
Plaintext
Executable File
{ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿
|
||
³ ³
|
||
³ X - P a c k e t ³
|
||
³ ³
|
||
³ ³
|
||
³ X P L O A D . P A S ³
|
||
³ ³
|
||
³ Routinen f<>r die Ladung der verschiedenen Systemfiles beim Start von ³
|
||
³ TOP. Ebenfalls Initialisierung der TNCs. ³
|
||
ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ}
|
||
|
||
|
||
Procedure Emblem_Zeigen;
|
||
Var i : Byte;
|
||
Begin
|
||
i := 1;
|
||
Assign(G^.TFile,SysPfad + EmbDatei);
|
||
if ResetTxt(G^.TFile) > 0 then Abbruch_XP(6,'');
|
||
Repeat
|
||
inc(i);
|
||
Readln(G^.TFile,DZeile);
|
||
WriteTxt(1,i,StartColor,DZeile);
|
||
Until Eof(G^.TFile);
|
||
{ FiResult := CloseTxt(G^.TFile); }
|
||
close(G^.TFile);
|
||
XCP := 3;
|
||
End;
|
||
|
||
|
||
Procedure Ini_Start_Tnc;
|
||
var i,i1,
|
||
dB,N,
|
||
KA, KA2: Byte;
|
||
l : LongInt;
|
||
Chan,
|
||
Date : String[11];
|
||
Zeit : String[8];
|
||
Fstr : String[3];
|
||
Istr : String[9];
|
||
Hstr : String[80];
|
||
f : File;
|
||
|
||
Begin
|
||
Init_HardDrive;
|
||
for i := 1 to maxLink do
|
||
begin
|
||
Assign(K[i]^.DBox,Konfig.TempVerz + DBoxDatei + SFillStr(3,'0',int_str(i)));
|
||
if WishBoxLst and (K[i]^.SysArt in SysMenge) then OpenDBox(i);
|
||
end;
|
||
|
||
|
||
{ABFRAGE ob tnc deaktiv ist !!!!! initialisierung pr<70>fen!!!!}
|
||
|
||
|
||
for N := 1 to TNC_Anzahl do (* alle angeschlossenen TNCs in den Hostmode schalten *)
|
||
Begin
|
||
TNC[N]^.AfuPort := Konfig.TNC[n].AfuPort;
|
||
|
||
|
||
{$IFNDEF no_Netrom} {//db1ras}
|
||
NodesSortieren;
|
||
{$ENDIF}
|
||
|
||
{$IFNDEF no_bake} {//db1ras}
|
||
TNC[N]^.MailBakenTimer:=MailBakenZeit+N-1;
|
||
{$ENDIF}
|
||
K[0]^.TncNummer := N;
|
||
Hstr := int_str(N) + Pkt + TncI + B1 + GL;
|
||
if (TNC[N]^.RS232 = 5)
|
||
then M_aus(Attrib[28],EFillStr(65,B1,Hstr + PcxStr), 0) else
|
||
begin
|
||
if HwHs then Istr := 'NoIRQ'
|
||
else Istr := 'IRQ'+ GL + int_str(COM[TNC[N]^.RS232].IRQ_Nr);
|
||
|
||
if COM[TNC[N]^.RS232].FifoOn then i := 1
|
||
else i := 0;
|
||
|
||
M_aus(Attrib[28],EFillStr(65,B1,Hstr +
|
||
B1 + 'Ch' + GL + EFillStr(2,B1,int_str(TNC[N]^.Channels)) +
|
||
B1 + 'COM' + GL + int_str(TNC[N]^.RS232) +
|
||
B1 + 'Bd' + GL + EFillStr(6,B1,int_str(COM[TNC[N]^.RS232].Baudrate)) +
|
||
B1 + EFillStr(6,B1,Istr) +
|
||
B1 + 'Fifo' + GL + EFillStr(2,B1,int_str(i)) +
|
||
B1 + 'Po' + GL + int_str(TNC[N]^.HF_Port) +
|
||
B1 + 'Mpx' + GL + int_str(TNC[N]^.MPX) +
|
||
B1 + 'ID' + GL + TNC[N]^.Ident +
|
||
B2), 0);
|
||
end;
|
||
if not TNC[N]^.TNC_im_Host then
|
||
begin
|
||
Switch_TNC(N);
|
||
{ tnc[n]^.tnc_im_host:=true;
|
||
tncini(1);
|
||
tnc[n]^.tnc_im_host:=false; }
|
||
Switch_Hostmode(TNC[N]^.RS232,N);
|
||
DRSI_Hostmode(N,0);
|
||
end;
|
||
M_aus(Attrib[28],InfoZeile(57) + ^J, 0);
|
||
End;
|
||
|
||
M_aus(Attrib[28],^J, 0);
|
||
|
||
Hstr := '';
|
||
|
||
for N := 1 to TNC_Anzahl do with TNC[N]^ do
|
||
begin
|
||
if Falc then for i := Kvon to Kbis do
|
||
begin
|
||
Ausgabe := false;
|
||
S_PAC(i,CM,true,'@CCHAN ' + int_str(HF_Port));
|
||
end;
|
||
|
||
if TNC3 then for i := Kvon to Kbis do
|
||
begin
|
||
Ausgabe := false;
|
||
S_PAC(i,CM,true,'#PORT' + int_str(HF_Port));
|
||
end;
|
||
|
||
if PCXD then
|
||
begin
|
||
for i := Kvon to Kbis do Hstr := Hstr + int_str(HF_Port);
|
||
K[0]^.TncNummer := N;
|
||
S_PAC(0,CM,true,'@PO '+ EFillStr(40,'-',Hstr));
|
||
end;
|
||
end;
|
||
|
||
{ TNC[N]^.TXBedarf:=False;
|
||
TNC[N]^.TXGesperrt := TRUE;
|
||
|
||
S_Pac(TNC[N]^.Kvon, cM, True, 'X 0'); }
|
||
|
||
|
||
for KA := 0 to maxLink do
|
||
begin
|
||
with K[KA]^ do
|
||
begin
|
||
for N := 1 to 3 do StatusOut(KA,1,1,Attrib[9],ConstStr(B1,80),N);
|
||
if KA > 0 then
|
||
begin
|
||
StatusOut(KA,1,1,Attrib[14],SFillStr(2,B1,int_str(KA)),1);
|
||
if connected then
|
||
begin
|
||
AnyConnect := true;
|
||
StatusOut(KA,4,1,Attrib[11],EFillStr(9,B1,Call),1);
|
||
User_Name := GetName(KA,Call,dB,TRUE);
|
||
UserInStatus(KA);
|
||
end;
|
||
|
||
Ausgabe := false;
|
||
S_PAC(KA,CM,true,'C');
|
||
|
||
if pos(' NOT ',Response) = 0 then
|
||
begin
|
||
if not connected then
|
||
begin
|
||
Kanal_benutz := true;
|
||
ConText := Response;
|
||
L_ON(KA,TncConStr + B1 + Response,false,false);
|
||
AnyConnect := true;
|
||
end;
|
||
end else Begin
|
||
{Connect ist zwischenzeitlich verlohren gegangen}
|
||
connected := false;
|
||
Auto_Init(KA); {//db1ras}
|
||
End;
|
||
|
||
Check_Eig_Mail(KA,KA);
|
||
end;
|
||
if not connected then EraseBufferFile(ka);
|
||
SetzeFlags(KA);
|
||
end; (* with K[KA]^ do ... *)
|
||
end;
|
||
|
||
Date := Datum;
|
||
Zeit := Uhrzeit;
|
||
ZeitMerk := Zeit;
|
||
|
||
for N := 1 to TNC_Anzahl do
|
||
begin
|
||
K[0]^.TncNummer := N;
|
||
Ausgabe := false; S_PAC(0,CM,true,'K ' + copy(Date,4,8));
|
||
Ausgabe := false; S_PAC(0,CM,true,'K ' + Zeit);
|
||
Ausgabe := false; S_PAC(0,CM,true,'K1');
|
||
|
||
Ausgabe := false;
|
||
Pseudo := true;
|
||
TxRxTNC(FF,1,'G');
|
||
TNC[N]^.ExtHost := pos('INVALID',K[0]^.Response) = 0;
|
||
if not TNC[N]^.ExtHost then Idle := false;
|
||
end;
|
||
|
||
multiTNC := (TNC_Anzahl > 1);
|
||
|
||
{ if TncINr > 0 then TncIniDatei := TncIniDatei + int_str(TncINr);
|
||
TncIniDatei := TncIniDatei + Ext; }
|
||
TncIni(0);
|
||
|
||
Unproto := 1;
|
||
K[0]^.TncNummer := Unproto;
|
||
SetzeFlags(0);
|
||
Unproto_darstellen;
|
||
|
||
for N := 1 to TNC_Anzahl do
|
||
begin
|
||
K[0]^.TncNummer := N;
|
||
Ausgabe := false;
|
||
S_PAC(0,CM,true,'I');
|
||
Istr := K[0]^.Response;
|
||
Hstr := EFillStr(35,B1,int_str(N) + Pkt + TncI + DP + B1 +
|
||
InfoZeile(146) + B1 + GL + B1 + Istr);
|
||
if TNC[N]^.ExtHost then Hstr := Hstr + InfoZeile(52) + B1;
|
||
i := TNC[N]^.RS232;
|
||
M_aus(Attrib[28],Hstr +^J, 0);
|
||
end;
|
||
|
||
M_aus(Attrib[28],^J, 0);
|
||
i1:=0;
|
||
for KA := 1 to maxLink do
|
||
Begin
|
||
with K[KA]^ do
|
||
Begin
|
||
if tncnummer<>i1 then
|
||
begin
|
||
i1:=tncnummer;
|
||
Ka2:=KA-1;
|
||
end;
|
||
Chan := SFillStr(2,B1,int_str(KA));
|
||
if OwnCall = S_ch then
|
||
begin
|
||
OwnCall := Konfig.TNC[TNCNummer].INIA[1];
|
||
|
||
if Konfig.TNC[TNCNummer].NodeKan > 0 then
|
||
begin
|
||
if Ka-KA2 > (Konfig.TNC[TNCNummer].MaxKan)-(Konfig.TNC[TNCNummer].NodeKan) then
|
||
begin
|
||
OwnCall:=Konfig.TNC[TNCNummer].INIA[2];
|
||
Node:=True;
|
||
end;
|
||
end;
|
||
end;
|
||
|
||
Ausgabe := false;
|
||
Rufz_TNC_init(KA);
|
||
|
||
M_aus(Attrib[28],EFillStr(15,B1,LRK + Chan + RRK + DP + OwnCall), 0);
|
||
if (KA mod 5) = 0 then M_aus(Attrib[28],^J, 0);
|
||
if connected then
|
||
begin
|
||
if FirstConCh = 1 then FirstConCh := KA;
|
||
end else
|
||
if Mo.MonActive then
|
||
begin
|
||
Stat_MonitorCalls(KA);
|
||
end else
|
||
begin
|
||
StatusOut(KA,4,1,Attrib[9],EFillStr(9,B1,OwnCall),1);
|
||
StatusOut(KA,14,1,Attrib[9],ConstStr(B1,19),1);
|
||
end;
|
||
end;
|
||
end;
|
||
M_aus(Attrib[28],^J, 0);
|
||
|
||
TNC_High_Channel_Init;
|
||
|
||
if G^.Infostr > '' then
|
||
begin
|
||
_aus(Attrib[20],1,InfoZeile(97) + M1);
|
||
_aus(Attrib[20],1,G^.InfoStr + M2);
|
||
if Klingel then Beep(G^.RemPiepFreq,G^.RemPiepTime);
|
||
G^.Infostr := '';
|
||
end;
|
||
|
||
if LogChk > 0 then
|
||
begin
|
||
Assign(f,Sys1Pfad + LogDatei + LngExt);
|
||
if ResetBin(f,1) = 0 then
|
||
begin
|
||
l := FileSize(f);
|
||
FiResult := CloseBin(f);
|
||
if l > LogChk then
|
||
begin
|
||
_aus(Attrib[20],1,InfoZeile(29) + B1 +
|
||
FormByte(int_str(l)) + B1 + Bytes + M2);
|
||
if Klingel then Beep(G^.RemPiepFreq,G^.RemPiepTime);
|
||
end;
|
||
end;
|
||
end;
|
||
|
||
if LogArt > 0 then
|
||
begin
|
||
Assign(G^.TFile,Sys1Pfad + LogDatei + LngExt);
|
||
FiResult := ResetTxt(G^.TFile);
|
||
if FiResult > 0 then FiResult := RewriteTxt(G^.TFile);
|
||
FiResult := CloseTxt(G^.TFile);
|
||
end;
|
||
|
||
if Eig_Mail_Zeile > '' then
|
||
begin
|
||
InfoOut(1,0,1,InfoZeile(153) + Eig_Mail_Zeile);
|
||
If Klingel then Triller;
|
||
end;
|
||
|
||
Assign(G^.TFile,Sys1Pfad + ConDatei);
|
||
FiResult := EraseTxt(G^.TFile);
|
||
End;
|
||
|
||
Procedure TNC_High_Channel_Init;
|
||
var i,i1 : Byte;
|
||
Begin
|
||
for i := 1 to TNC_Anzahl do
|
||
begin
|
||
K[0]^.TncNummer := i;
|
||
i1 := TNC[i]^.TncChannels;
|
||
Repeat
|
||
inc(i1);
|
||
Pseudo := true;
|
||
Ausgabe := false;
|
||
TxRxTNC(i1,1,'I' + B1 + PhantasieCall);
|
||
Until (i1 = FF) or (K[0]^.Response > '');
|
||
end;
|
||
End;
|
||
|
||
Procedure Switch_Hostmode (* V24Nr,TNC_Nr : Byte *);
|
||
var N,i,zhs : Byte;
|
||
w : Word;
|
||
Host,Flag : Boolean;
|
||
ch : Char;
|
||
Hstr : String;
|
||
|
||
Begin
|
||
zhs:=0;
|
||
(* for w:=1 to 10 do writeAux(V24Nr,#1);
|
||
|
||
for i:=1 to 2 do
|
||
begin
|
||
clearV24Buffer;
|
||
WriteAux(V24Nr,ESC+'JHOST0'+ M1);
|
||
{Achtung: Steht noch ein M1 bzw. #13 vor ESC, sendet der TNC!!!}
|
||
Wait_Read(V24Nr);
|
||
Verzoegern(300);
|
||
end;
|
||
*)
|
||
(* repeat
|
||
inc(zhs); *)
|
||
|
||
Host := false;
|
||
|
||
{ ClearV24Buffer;
|
||
WriteAux(V24Nr,ESC+M1);
|
||
Wait_Read(V24Nr);}
|
||
|
||
ClearV24Buffer;
|
||
WriteAux(V24Nr,^Q^X);
|
||
{^Q^M^X statt JHOST0 geht auch anstatt ESC+M1, QX}
|
||
Wait_Read(V24Nr);
|
||
|
||
if V24Buffer[0] = 6 then
|
||
begin
|
||
WriteAux(V24Nr,^R^X);
|
||
Wait_Read(V24Nr);
|
||
end;
|
||
|
||
ClearV24Buffer;
|
||
WriteAux(V24Nr,ESC + 'E1'+ M1);
|
||
Wait_Read(V24Nr);
|
||
|
||
ClearV24Buffer;
|
||
WriteAux(V24Nr,^X);
|
||
Wait_Read(V24Nr);
|
||
|
||
ClearV24Buffer;
|
||
WriteAux(V24Nr,ESC);
|
||
Wait_Read(V24Nr);
|
||
|
||
if BufferPos>0 then inc(zhs,3);
|
||
(* if BufferPos=0 then
|
||
begin
|
||
for i:=1 to 2 do
|
||
begin
|
||
clearV24Buffer;
|
||
WriteAux(V24Nr,ESC+'JHOST0'+ M1);
|
||
{Achtung: Steht noch ein M1 bzw. #13 vor ESC, sendet der TNC!!!}
|
||
Wait_Read(V24Nr);
|
||
Verzoegern(300);
|
||
end;
|
||
end;
|
||
until zhs>2; *)
|
||
|
||
if BufferPos = 0 then
|
||
begin
|
||
if not ReSync(V24Nr) then Abbruch_XP(11,'')
|
||
else Host := true;
|
||
end else ch := Chr(V24Buffer[0]);
|
||
|
||
if not Host then
|
||
begin
|
||
i := 10;
|
||
While (ch <> '*') and (i > 0) do
|
||
begin
|
||
Wait_Read(V24Nr);
|
||
w := BufferPos;
|
||
While (w > 0) and (ch <> '*') do
|
||
begin
|
||
dec(w);
|
||
ch := Chr(V24Buffer[w]);
|
||
end;
|
||
if ch <> '*' then ClearV24Buffer;
|
||
dec(i);
|
||
end;
|
||
|
||
if ch <> '*' then Abbruch_XP(14,int_str(V24Nr));
|
||
ClearV24Buffer;
|
||
WriteAux(V24Nr,'JHOST1' + M1);
|
||
Wait_Read(V24Nr);
|
||
Verzoegern(300);
|
||
end;
|
||
|
||
ClearV24Buffer;
|
||
End;
|
||
|
||
Procedure DRSI_Hostmode (* TNC_Nr,Art : Byte *);
|
||
Var i,i1 : Byte;
|
||
Begin
|
||
if Art = 0 then
|
||
begin
|
||
TNC[TNC_Nr]^.TNC_im_Host := true;
|
||
i1 := TNC[TNC_Nr]^.DRSI;
|
||
if i1 > 0 then
|
||
for i := TNC_Nr+1 to TNC_Anzahl do
|
||
if TNC[i]^.DRSI = i1 then TNC[i]^.TNC_im_Host := true;
|
||
end;
|
||
|
||
if Art = 1 then
|
||
begin
|
||
TNC[TNC_Nr]^.TNC_im_Host := false;
|
||
i1 := TNC[TNC_Nr]^.DRSI;
|
||
if i1 > 0 then
|
||
for i := TNC_Nr+1 to TNC_Anzahl do
|
||
if i1 = TNC[i]^.DRSI then TNC[i]^.TNC_im_Host := false;
|
||
end;
|
||
End;
|
||
|
||
|
||
Procedure ConfigLesen;
|
||
var i,i1,i2,i3,
|
||
Ka,Error : Integer;
|
||
m : Word;
|
||
flag : Boolean;
|
||
ch : char;
|
||
l : LongInt;
|
||
|
||
Begin (* ConfigLesen *)
|
||
|
||
|
||
|
||
if CFGNr > 0 then CfgDatei := CfgDatei + int_str(CFGNr);
|
||
|
||
{ WriteTxt(XCP,SZ1,StartColor,CfgDatei + Ext); }
|
||
{*** 1}
|
||
gotoxy(1,20);
|
||
writeln(' Ú ÜÜÜÜÜÜ ¿');
|
||
writeln(' À ßßßßßß Ù');
|
||
XCP := XCP + SZL;
|
||
for i := 1 to MaxAnwesend do
|
||
begin
|
||
Anwesend[i] := NIL;
|
||
GetMem(Anwesend[i], SizeOf(Anwesend[i]^));
|
||
Anwesend[i]^.Call:='';
|
||
Anwesend[i]^.Da:=False;
|
||
end;
|
||
Assign(G^.Config,Sys1Pfad + CfgDatei + Ext);
|
||
{ if ResetTxt(G^.Config) > 0 then Abbruch_XP(8,'');}
|
||
|
||
{$I-} Reset(G^.Config); {$I+}
|
||
if ioresult<>0 then Abbruch_XP(8,'');
|
||
|
||
read(G^.config, Konfig);
|
||
if Konfig.BackupTime=1 then Konfig.BackupTime:=2;
|
||
TNC_Anzahl:=0;
|
||
for i:=1 to maxTNC do
|
||
begin
|
||
|
||
if (konfig.tnc[i].art=0) and (i<maxTNC) then
|
||
begin
|
||
konfig.tnc[i]:=konfig.tnc[i+1];
|
||
konfig.tnc[i+1].art:=0;
|
||
konfig.tnc[i+1].maxkan:=0;
|
||
end;
|
||
if (konfig.tnc[i].art>0) then inc(TNC_Anzahl);
|
||
{ writeln(konfig.TNC[i].art,' ', konfig.tnc[i].baud);}
|
||
end;
|
||
i:=0;
|
||
|
||
if Konfig.MaxLoginUser=0 then Konfig.MaxLoginUser:=3;
|
||
{$IFNDEF no_Netrom} {//db1ras}
|
||
if Konfig.MaxNodes=0 then BCastKillen;
|
||
{$ENDIF}
|
||
|
||
CRCNROM:=chr(Konfig.Teil1)+chr(Konfig.Teil2)+chr(Konfig.Teil3)+chr(Konfig.Teil4);
|
||
|
||
Konfig.LifeTime:=Konfig.LifeTime*60;
|
||
Config_TNC_Lesen;
|
||
|
||
for i := 0 to maxKanal do
|
||
begin
|
||
K[i] := Nil;
|
||
VorWrite[i] := Nil;
|
||
NotCh[i] := Nil;
|
||
end;
|
||
|
||
for i := 0 to maxLink do { Kanal-Record auf den Heap bringen }
|
||
begin
|
||
GetMem(K[i],SizeOf(K[i]^));
|
||
FillChar(K[i]^,SizeOf(K[i]^),0);
|
||
Var_Init(i);
|
||
end;
|
||
K_Record_on_Heap := true;
|
||
|
||
Config_RAM_Lesen;
|
||
GetMem(MH,maxMH * SizeOf(MH_Typ));
|
||
FillChar(MH^,maxMH * SizeOf(MH_Typ),0);
|
||
|
||
{ Zuordnung Terminalkan„le - TNC-Kan„le }
|
||
for i := 1 to TNC_Anzahl do with TNC[i]^ do if Channels > 0 then
|
||
begin
|
||
for i1 := Kvon to Kbis do K[i1]^.TncNummer := i;
|
||
if DRSI = 0 then
|
||
begin
|
||
for i1 := Kvon to Kbis do K[i1]^.TNCKanal := Chr(i1-Kvon+1);
|
||
ExtHost := true;
|
||
end else
|
||
begin
|
||
Ka := 0;
|
||
for i1 := 1 to TNC_Anzahl do if not TNC[i1]^.ExtHost and
|
||
(TNC[i]^.DRSI = TNC[i1]^.DRSI) and (TNC[i1]^.Channels > 0) then
|
||
begin
|
||
for i3 := TNC[i1]^.Kvon to TNC[i1]^.Kbis do
|
||
begin
|
||
inc(Ka);
|
||
K[i3]^.TNCKanal := Chr(Ka);
|
||
end;
|
||
TNC[i1]^.ExtHost := true;
|
||
end;
|
||
end;
|
||
end;
|
||
for i1 := 1 to TNC_Anzahl do TNC[i1]^.ExtHost := false;
|
||
|
||
Config_Verz_Lesen;
|
||
Config_Allg_Lesen;
|
||
Config_Sound_Lesen;
|
||
|
||
if Nutze_XMS then use_XMS := XMS_Installed;
|
||
|
||
if Nutze_EMS then
|
||
begin
|
||
use_EMS := EMS_Installiert;
|
||
Vor_im_EMS := use_EMS;
|
||
end;
|
||
|
||
{ if use_EMS then
|
||
begin
|
||
Writeln(G^.BootFile,EmsStr,'LIM-Version = ',EMS_Version shr 4,Pkt ,(EMS_Version and 15));
|
||
Writeln(G^.BootFile,EmsStr,'Free = ',LongInt(EMS_FreieSeiten * 16),' Kb');
|
||
Writeln(G^.BootFile,EmsStr,'Frame = ',Hex(EMS_Segment,4));
|
||
end; }
|
||
|
||
{ if use_XMS then
|
||
begin
|
||
if HMA = 1 then Writeln(G^.BootFile,'HMA: Exist');
|
||
DZeile := Hex(XMS_Version,3);
|
||
insert(Pkt ,DZeile,2);
|
||
Writeln(G^.BootFile,XmsStr,'Version = ',DZeile);
|
||
DZeile := Hex(XMS_Treiber,3);
|
||
insert(Pkt ,DZeile,2);
|
||
Writeln(G^.BootFile,XmsStr,'Driver = ',DZeile);
|
||
Writeln(G^.BootFile,XmsStr,'Free = ',get_XMS_Free,' Kb');
|
||
end; }
|
||
|
||
if use_XMS then
|
||
begin
|
||
if (LongInt(get_XMS_Free) * 1024) > GesamtNotCh then
|
||
begin
|
||
use_VDisk := false;
|
||
use_EMS := false;
|
||
end else use_XMS := false;
|
||
end;
|
||
|
||
if use_EMS then
|
||
if (EMS_FreieSeiten >= EMS_Pages_Ins) then
|
||
begin
|
||
use_VDisk := false;
|
||
end else use_EMS := false;
|
||
|
||
if not Vdisk_Exists then use_VDisk := false;
|
||
|
||
if use_VDisk then
|
||
begin
|
||
{Writeln(G^.BootFile,RamStr,'Free Memory = ',}
|
||
FormByte(int_str(DiskFree(ord(Vdisk[1])-64)));{,B1 + Bytes);}
|
||
if (GesamtNotCh + 2048) > DiskFree(ord(Vdisk[1])-64)
|
||
then use_VDisk := false;
|
||
end;
|
||
|
||
flag := false;
|
||
|
||
if use_XMS then
|
||
begin
|
||
{ Writeln(G^.BootFile,XmsStr,GesamtNotCh div 1024,' Kb for Backscrollbuffer'); }
|
||
XMS_Handle := get_XMS_Ram((GesamtNotCh div 1024) + 2);
|
||
l := 0;
|
||
GetMem(Page,maxNotChBuf);
|
||
FillChar(Page^,maxNotChBuf,0);
|
||
for i := 0 to maxLink do with K[i]^ do
|
||
begin
|
||
Pos_im_Scr := l;
|
||
l := l + maxNotCh + 40;
|
||
Data_to_XMS(@Page^[0],XMS_Handle,Pos_im_Scr,maxNotCh);
|
||
end;
|
||
FreeMem(Page,maxNotChBuf);
|
||
end else
|
||
if use_EMS then
|
||
begin
|
||
{ Writeln(G^.BootFile,EmsStr,LongInt(EMS_Pages_Ins * 16),' Kb for Backscrollbuffer'); }
|
||
ScrHandle := EMS_Belegen(EMS_Pages_Ins);
|
||
for i := 0 to maxLink do with K[i]^ do
|
||
begin
|
||
NotCh[i] := Ptr(EMS_Segment,0);
|
||
EMS_Seite_einblenden(i,Scr);
|
||
FillChar(NotCh[i]^,maxNotCh,0);
|
||
end;
|
||
end else
|
||
if use_VDisk then
|
||
begin
|
||
{ Writeln(G^.BootFile,RamStr,
|
||
FormByte(int_str(GesamtNotCh+2048)),B1,Bytes,B1,'for Backscrollbuffer'); }
|
||
ScrFile_erzeugen;
|
||
end else
|
||
begin
|
||
if not HeapFrei(GesamtNotCh + MindestHeap) then
|
||
begin
|
||
flag := true;
|
||
GesamtNotCh := 0;
|
||
for i := 0 to maxLink do with K[i]^ do
|
||
begin
|
||
maxNotCh := NeuBildRam + 96;
|
||
GesamtNotCh := GesamtNotCh + maxNotCh;
|
||
end;
|
||
end;
|
||
if HeapFrei(GesamtNotCh + MindestHeap) then
|
||
begin
|
||
{ if flag then Writeln(G^.BootFile,'Backscrollbuffer corrected !');}
|
||
for i := 0 to maxLink do with K[i]^ do
|
||
begin
|
||
GetMem(NotCh[i],maxNotCh);
|
||
FillChar(NotCh[i]^,maxNotCh,FF);
|
||
end;
|
||
end
|
||
else Abbruch_XP(5,'Free RAM = ' + int_str(MaxAvail - MindestHeap) +
|
||
' use = ' + int_str(GesamtNotCh) + B1 + Bytes);
|
||
end;
|
||
|
||
if Vor_im_EMS then Vor_im_EMS := ((EMS_FreieSeiten >= (maxLink + 1)));
|
||
|
||
if Vor_im_EMS then
|
||
begin
|
||
{ Writeln(G^.BootFile,EmsStr,LongInt(maxLink+1)*16,' Kb for TX-Write-Buffer');}
|
||
VorHandle := EMS_Belegen(maxLink + 1);
|
||
GesamtVorCh := 0;
|
||
for i := 0 to maxLink do with K[i]^ do
|
||
begin
|
||
VorWrite[i] := Ptr(EMS_Segment,0);
|
||
VorZeilen := 200;
|
||
GesamtVorCh := GesamtVorCh + VorZeilen * 81;
|
||
VorCmdZeilen := VorZeilen div 5;
|
||
end;
|
||
end else
|
||
|
||
begin
|
||
flag := false;
|
||
if not HeapFrei(GesamtVorCh + MindestHeap) then
|
||
begin
|
||
flag := true;
|
||
GesamtVorCh := 0;
|
||
for i := 0 to maxLink do with K[i]^ do
|
||
begin
|
||
VorZeilen := 20;
|
||
GesamtVorCh := GesamtVorCh + VorZeilen * 81;
|
||
VorCmdZeilen := VorZeilen div 5;
|
||
end;
|
||
end;
|
||
|
||
if HeapFrei(GesamtVorCh + MindestHeap) then
|
||
begin
|
||
{ if flag then Writeln(G^.BootFile,'Tx-Write-Buffer corrected !');}
|
||
for i := 0 to maxLink do with K[i]^ do GetMem(VorWrite[i],VorZeilen * 81);
|
||
end else Abbruch_XP(9,'Free RAM = ' + int_str(MaxAvail - MindestHeap) +
|
||
' use = ' + int_str(GesamtVorCh) + B1 + Bytes);
|
||
end;
|
||
|
||
for i := 0 to maxLink do with K[i]^ do
|
||
begin
|
||
if Vor_im_EMS then EMS_Seite_einblenden(i,Vor);
|
||
FillChar(VorWrite[i]^,VorZeilen * 81,0);
|
||
stC := (VorZeilen - VorCmdZeilen) + 1;
|
||
for i1 := stC to VorZeilen do VorWrite[i]^[i1] := CvCh;
|
||
end;
|
||
|
||
Config_BLIND_Lesen;
|
||
|
||
Config_PRN_Lesen;
|
||
{ FiResult := CloseTxt(G^.Config);}
|
||
close(G^.config);
|
||
|
||
Assign(BuffFile,Konfig.TempVerz + BuffDatei);
|
||
|
||
ScreenTimer := ScreenInit;
|
||
End;
|
||
|
||
|
||
Procedure Infos_Lesen;
|
||
var Hstr : String;
|
||
i,i1,
|
||
Anz,
|
||
Groesse : Word;
|
||
|
||
Begin
|
||
{ WriteTxt(XCP,SZ1,StartColor,MsgsDatei);}
|
||
{*** 2}
|
||
gotoxy(1,20);
|
||
writeln(' Ú ÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜ ¿');
|
||
writeln(' À ßßßßßßßßßßßßßßßßßß Ù');
|
||
XCP := XCP + SZL;
|
||
|
||
Msg := Nil;
|
||
MsgPos := Nil;
|
||
|
||
Anz := 0;
|
||
Groesse := 0;
|
||
Assign(G^.TFile,SysPfad + MsgsDatei);
|
||
FiResult := ResetTxt(G^.TFile);
|
||
Repeat
|
||
Readln(G^.TFile,Hstr);
|
||
Groesse := Groesse + ord(Hstr[0]);
|
||
inc(Anz,2);
|
||
Until Eof(G^.TFile);
|
||
|
||
GetMem(Msg,Groesse);
|
||
FillChar(Msg^,Groesse,0);
|
||
|
||
GetMem(MsgPos,Anz);
|
||
FillChar(MsgPos^,Anz,0);
|
||
|
||
FiResult := ResetTxt(G^.TFile);
|
||
i := 1;
|
||
i1 := 1;
|
||
Repeat
|
||
MsgPos^[i1] := i;
|
||
Readln(G^.TFile,Hstr);
|
||
move(Hstr[1],Msg^[i],ord(Hstr[0]));
|
||
i := i + ord(Hstr[0]);
|
||
inc(i1);
|
||
Until Eof(G^.TFile);
|
||
FiResult := CloseTxt(G^.TFile);
|
||
MaxMsgs:=i1-2;
|
||
LastInfoOut := Nil;
|
||
GetMem(LastInfoOut,SizeOf(LastInfoOut^));
|
||
FillChar(LastInfoOut^,SizeOf(LastInfoOut^),0);
|
||
for i := 1 to maxInfoOut do LastInfoOut^.IZ[i] := ConstStr(B1,4);
|
||
|
||
History := Nil;
|
||
GetMem(History,SizeOf(History^));
|
||
FillChar(History^,SizeOf(History^),0);
|
||
End;
|
||
|
||
|
||
Procedure Strings_Lesen;
|
||
Begin
|
||
G^.InfoDieBox := InfoZeile(175) + B1;
|
||
G^.UserDieBox := InfoZeile(176) + B1;
|
||
G^.InfoBayBox := InfoZeile(177) + B1;
|
||
G^.InfoTnc3Box := InfoZeile(178) + B3;
|
||
G^.RubrikStr := InfoZeile(179) + B1;
|
||
|
||
G^.EzFileStr := InfoZeile(180);
|
||
G^.EzMsgStr := InfoZeile(189);
|
||
|
||
G^.RunElDir := InfoZeile(268) + B1;
|
||
G^.RunElFile := InfoZeile(269) + B1;
|
||
G^.RunElTree := InfoZeile(270) + B1;
|
||
G^.BinEL := InfoZeile(271) + B1;
|
||
G^.TxtEL := InfoZeile(272) + B1;
|
||
G^.DirEL := InfoZeile(273) + B1;
|
||
|
||
WeekDayStr := InfoZeile(86);
|
||
End;
|
||
|
||
|
||
Procedure AttributFile_Lesen;
|
||
var i : Byte;
|
||
Begin
|
||
if ColNr > 0 then AttrDatei := AttrDatei + int_str(ColNr);
|
||
AttrDatei := AttrDatei + Pkt ;
|
||
{ WriteTxt(XCP,SZ1,StartColor,AttrDatei + LngExt);}
|
||
{*** 4}
|
||
gotoxy(1,20);
|
||
writeln(' Ú ÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜ ¿');
|
||
writeln(' À ßßßßßßßßßßßßßßßßßßßßßßßßßßß Ù');
|
||
XCP := XCP + SZL;
|
||
Assign(G^.TFile,Sys1Pfad + AttrDatei + LngExt);
|
||
if ResetTxt(G^.TFile) <> 0 then Abbruch_XP(8,'');
|
||
for i := 1 to maxAttr do
|
||
begin
|
||
Readln(G^.TFile,DZeile);
|
||
Attrib[i] := str_int(CutStr(DZeile));
|
||
end;
|
||
Readln(G^.TFile,DZeile);
|
||
HighCol := Byte(str_int(copy(DZeile,1,1))) = 1;
|
||
FiResult := CloseTxt(G^.TFile);
|
||
End;
|
||
|
||
Procedure ESC_Lesen;
|
||
Var i : Byte;
|
||
Begin
|
||
{ WriteTxt(XCP,SZ1,StartColor,EscDatei);}
|
||
{*** 5}
|
||
gotoxy(1,20);
|
||
writeln(' Ú ÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜ ¿');
|
||
writeln(' À ßßßßßßßßßßßßßßßßßßßßßßßßßßßßßß Ù');
|
||
XCP := XCP + SZL;
|
||
Assign(G^.TFile,SysPfad + EscDatei);
|
||
if ResetTxt(G^.TFile) <> 0 then Abbruch_XP(8,'');
|
||
i := 1;
|
||
Repeat
|
||
Readln(G^.TFile,G^.ESCP[i]);
|
||
inc(i);
|
||
Until Eof(G^.TFile);
|
||
FiResult := CloseTxt(G^.TFile);
|
||
End;
|
||
|
||
Procedure QRG_Lesen;
|
||
Var i : Byte;
|
||
Hstr : String[80];
|
||
Freq : String[10];
|
||
Begin
|
||
XCP := 3;
|
||
{ WriteTxt(XCP,SZ2,StartColor,QrgDatei);}
|
||
{*** 6}
|
||
gotoxy(1,20);
|
||
writeln(' Ú ÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜ ¿');
|
||
writeln(' À ßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßß Ù');
|
||
XCP := XCP + SZL;
|
||
|
||
Assign(G^.TFile,Sys1Pfad + QrgDatei);
|
||
if ResetTxt(G^.TFile) <> 0 then Abbruch_XP(8,'');
|
||
|
||
G^.QRG_Anz := 0;
|
||
Repeat
|
||
Readln(G^.TFile,Hstr);
|
||
KillStartBlanks(Hstr);
|
||
|
||
if copy(Hstr,1,1) <> LZ then
|
||
begin
|
||
Hstr := UpCaseStr(Hstr);
|
||
Freq := CutStr(Hstr);
|
||
Hstr := RestStr(Hstr);
|
||
|
||
While Hstr > '' do
|
||
begin
|
||
inc(G^.QRG_Anz);
|
||
G^.QRG[G^.QRG_Anz].CALL := CutStr(Hstr);
|
||
G^.QRG[G^.QRG_Anz].QRG := Freq;
|
||
Hstr := RestStr(Hstr);
|
||
end;
|
||
end;
|
||
|
||
Until (Eof(G^.TFile) or (G^.QRG_Anz >= maxQRG));
|
||
FiResult := CloseTxt(G^.TFile);
|
||
|
||
Assign(G^.LinkFile,Sys1Pfad + LinkDatei);
|
||
FiResult := ResetTxt(G^.LinkFile);
|
||
if FiResult > 0 then FiResult := RewriteTxt(G^.LinkFile);
|
||
FiResult := CloseTxt(G^.LinkFile);
|
||
|
||
End;
|
||
|
||
Procedure REM_Lesen;
|
||
Var tmi, mi,i : Byte;
|
||
Hstr : String[40];
|
||
Remotes2: Array [1..maxREM] of REM_Type;
|
||
Begin
|
||
{ WriteTxt(XCP,SZ2,StartColor,RemDatei);}
|
||
{*** 7}
|
||
gotoxy(1,20);
|
||
writeln(' Ú ÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜ ¿');
|
||
writeln(' À ßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßß Ù');
|
||
XCP := XCP + SZL;
|
||
|
||
Assign(G^.TFile,SysPfad + RemDatei);
|
||
if ResetTxt(G^.TFile) <> 0 then Abbruch_XP(8,'');
|
||
i := 1;
|
||
Repeat
|
||
Readln(G^.TFile,Hstr);
|
||
KillStartBlanks(Hstr);
|
||
KillEndBlanks(Hstr);
|
||
if hstr<>'' then
|
||
begin
|
||
with G^.Remotes[i] do
|
||
begin
|
||
BefNr := str_int(CutStr(Hstr));
|
||
Befehl := ParmStr(2,B1,Hstr);
|
||
AnzCh := str_int(ParmStr(3,B1,Hstr));
|
||
AnzPa := str_int(ParmStr(4,B1,Hstr));
|
||
Level := str_int(ParmStr(5,B1,Hstr));
|
||
LevelN:= str_int(ParmStr(6,B1,Hstr));
|
||
end;
|
||
inc(i);
|
||
end;
|
||
Until Eof(G^.TFile);
|
||
FiResult := CloseTxt(G^.TFile);
|
||
mi:=i-1;
|
||
tmi:=1;
|
||
|
||
for i:=1 to mi do
|
||
begin
|
||
if G^.Remotes[i].BefNr<>99 then
|
||
begin
|
||
Remotes2[G^.Remotes[i].BefNr]:=G^.Remotes[i];
|
||
inc(tmi);
|
||
end;
|
||
end;
|
||
|
||
for i:=1 to mi do
|
||
begin
|
||
if G^.Remotes[i].BefNr=99 then
|
||
begin
|
||
Remotes2[TMI]:=G^.Remotes[i];
|
||
inc(tmi);
|
||
end;
|
||
end;
|
||
|
||
for i:=1 to mi do
|
||
G^.Remotes[i]:=Remotes2[i];
|
||
|
||
|
||
End;
|
||
|
||
|
||
Procedure PWD_Lesen;
|
||
Var Hstr : String[80];
|
||
Flag : Boolean;
|
||
Begin
|
||
Assign(G^.TFile,Sys1Pfad + PwDatei);
|
||
if ResetTxt(G^.TFile) = 0 then
|
||
begin
|
||
{ WriteTxt(XCP,SZ2,StartColor,PwDatei);}
|
||
{*** 8}
|
||
gotoxy(1,20);
|
||
writeln(' Ú ÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜ ¿');
|
||
writeln(' À ßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßß Ù');
|
||
XCP := XCP + SZL;
|
||
Repeat
|
||
Readln(G^.TFile,Hstr);
|
||
KillStartBlanks(Hstr);
|
||
KillEndBlanks(Hstr);
|
||
Flag := PWD = Hstr;
|
||
Until Eof(G^.TFile) or Flag;
|
||
If Flag then
|
||
begin
|
||
Readln(G^.TFile,Hstr);
|
||
KillStartBlanks(Hstr);
|
||
KillEndBlanks(Hstr);
|
||
Priv_PassWord := EFillStr(80,'a',Hstr);
|
||
end;
|
||
FiResult := CloseTxt(G^.TFile);
|
||
end;
|
||
End;
|
||
|
||
|
||
Procedure HELP_Lesen;
|
||
Var i : Byte;
|
||
Hstr : String[HlpRec];
|
||
Result : Word;
|
||
Found,
|
||
EFlag : Boolean;
|
||
Begin
|
||
if not Exists(Konfig.TempVerz + THlpDatei) or HlpCompile then Help_Compile;
|
||
{ WriteTxt(XCP,SZ2,StartColor,EFillStr(80-XCP+1,B1,THlpDatei));}
|
||
{*** 9}
|
||
gotoxy(1,20);
|
||
writeln(' Ú ÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜ ¿');
|
||
writeln(' À ßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßß Ù');
|
||
XCP := XCP + SZL;
|
||
Assign(G^.BFile,Konfig.TempVerz + THlpDatei);
|
||
if ResetBin(G^.BFile,HlpRec) <> 0 then Abbruch_XP(8,'');
|
||
Found := false;
|
||
EFlag := false;
|
||
Hstr := '';
|
||
i := 0;
|
||
Repeat
|
||
if not Found or (Hstr = '') then
|
||
begin
|
||
BlockRead(G^.BFile,Hstr[1],1,Result);
|
||
Hstr[0] := Chr(HlpRec);
|
||
KillStartBlanks(Hstr);
|
||
KillEndBlanks(Hstr);
|
||
EFlag := Hstr = LZ;
|
||
if not Found then
|
||
begin
|
||
Found := Hstr = OHelpStr;
|
||
if Found then Hstr := '';
|
||
end;
|
||
end;
|
||
|
||
if Found and not EFlag then
|
||
begin
|
||
if Hstr > '' then
|
||
begin
|
||
inc(i);
|
||
G^.OHelp[i] := CutStr(Hstr);
|
||
Hstr := RestStr(Hstr);
|
||
end;
|
||
end;
|
||
Until Eof(G^.BFile) or EFlag or (i >= maxOHelp);
|
||
|
||
FiResult := CloseBin(G^.BFile);
|
||
End;
|
||
|
||
|
||
Procedure TncIni (* Art : Byte *);
|
||
Var N,bef,
|
||
von,
|
||
bis : Byte;
|
||
Hstr : String[4];
|
||
Flag : Boolean;
|
||
Begin
|
||
{ Assign(G^.TFile,Sys1Pfad + TncIniDatei);
|
||
if ResetTxt(G^.TFile) = 0 then }
|
||
|
||
if 1=1 then
|
||
begin
|
||
|
||
if 1=1 then
|
||
|
||
if 1=1 then
|
||
begin
|
||
von:=1; bis:=tnc_anzahl;
|
||
|
||
if von > 0 then for N := von to bis do
|
||
begin
|
||
dzeile:='';
|
||
for bef:= 1 to 17 do
|
||
begin
|
||
Case Bef of
|
||
1..16:
|
||
begin
|
||
if (Bef in [1,2]) and (Art=0) then
|
||
begin
|
||
if (Konfig.TNC[N].IniA[bef]<>'') and ((bef=1) or (bef=2)) then
|
||
Konfig.TNC[N].IniA[bef]:='I '+Konfig.TNC[N].IniA[Bef];
|
||
end;
|
||
|
||
if art=0 then DZeile:=Konfig.TNC[N].iniA[bef]
|
||
else DZeile:=Konfig.TNC[N].DiniA[bef];
|
||
if (Konfig.TNC[N].IniA[bef]<>'') and ((bef=1) or (bef=2)) then delete(Konfig.TNC[N].IniA[bef],1,2)
|
||
end;
|
||
17:
|
||
begin
|
||
if art=0 then DZeile:=Konfig.TNC[N].iniB
|
||
else DZeile:=Konfig.TNC[N].DiniB;
|
||
end;
|
||
end;
|
||
|
||
while copy(dzeile,1,1)=#32 do delete(Dzeile,1,1);
|
||
KillEndBlanks(Dzeile);
|
||
|
||
if (Art = 0) and (Upcasestr(copy(DZeile,1,1)) = 'I') then
|
||
begin
|
||
DZeile := CutStr(RestStr(DZeile));
|
||
TNC[N]^.HostCall := upcasestr(DZeile);
|
||
DZeile := 'I ' + DZeile;
|
||
end;
|
||
K[0]^.TncNummer := N;
|
||
if dzeile<>'' then S_PAC(0,CM,true,DZeile);
|
||
end; {for bef ...}
|
||
end;
|
||
end;
|
||
{ Until Eof(G^.TFile) or (copy(DZeile,1,1) = DP); }
|
||
{ FiResult := CloseTxt(G^.TFile); }
|
||
end;
|
||
|
||
if Art = 1 then for N := 1 to TNC_Anzahl do
|
||
begin
|
||
if TNC[N]^.TNC_im_Host then
|
||
begin
|
||
K[0]^.TncNummer := N;
|
||
S_PAC(0,CM,true,'JHOST0');
|
||
Verzoegern(300);
|
||
ClearV24Buffer;
|
||
DRSI_Hostmode(N,1);
|
||
end;
|
||
end;
|
||
End;
|
||
|
||
|
||
Procedure Abschluss_XP;
|
||
var i : Byte;
|
||
Flag : Boolean;
|
||
Begin
|
||
AnyConnect := false;
|
||
for i := 1 to maxLink do if K[i]^.connected then AnyConnect := true;
|
||
if (SSAV = 1) or ((SSAV = 2) and AnyConnect) then
|
||
begin
|
||
Puffer_schreiben;
|
||
end else FiResult := EraseBin(BuffFile);
|
||
|
||
Merker_Conn_Schreiben;
|
||
Merker_File_schreiben;
|
||
|
||
ReInstall;
|
||
|
||
for i := 0 to maxLink do with K[i]^ do
|
||
begin
|
||
if Save then SaveFile(i);
|
||
if WishBoxLst and (SysArt in SysMenge) then CloseDBox(i);
|
||
if EraseChk > 0 then
|
||
begin
|
||
if ResetBin(DBox,1) = 0 then
|
||
begin
|
||
Flag := FileSize(DBox) > EraseChk;
|
||
FiResult := CloseBin(DBox);
|
||
if Flag then FiResult := EraseBin(DBox);
|
||
end;
|
||
end;
|
||
end;
|
||
|
||
if use_VDisk then
|
||
begin
|
||
if ResetBin(ScrollFile,T) = 0 then
|
||
begin
|
||
FiResult := CloseBin(ScrollFile);
|
||
FiResult := EraseBin(ScrollFile);
|
||
end;
|
||
end;
|
||
|
||
Writeln;
|
||
Writeln('Ende ... ',Datum,B2,Uhrzeit);
|
||
SetCBreak(BreakStatus);
|
||
End;
|
||
|
||
Procedure Abbruch_XP (* Nr : Byte; Zeile : Str80 *);
|
||
Var i : Byte;
|
||
Begin
|
||
{ if TextRec(G^.Config).Mode <> fmClosed then FiResult := CloseTxt(G^.Config);}
|
||
{$I-} close(G^.config); i:=ioresult; i:=0; {$I+}
|
||
if K_Record_on_Heap then Close_SaveFiles;
|
||
ReInstall;
|
||
SetzeCursor(1,25);
|
||
Writeln(^G);
|
||
Case Nr of
|
||
1: Writeln('Fehler im File ',CfgDatei);
|
||
2: Writeln('Falsche Interrupt-Nummer f<>r COM' + Zeile + ' !');
|
||
3: Writeln('Falsche Baudrate f<>r COM ' + Zeile + ' !');
|
||
4: Writeln('ERROR, Pfad nicht gefunden -> ' + Zeile);
|
||
5: Writeln('Zuviel Scrollspeicher vergeben !',#10#13,Zeile);
|
||
6: Writeln('Fehler mit Datei ',EmbDatei + ' !');
|
||
7: Writeln('Pufferfiles f<>r Scroll konnte nicht erzeugt werden !');
|
||
8: Writeln('File nicht gefunden, Programm abgebrochen !');
|
||
9: Writeln('Zuviel Vorschreibspeicher vergeben !',#10#13,Zeile);
|
||
10: Writeln('EMS-Fehler: ',EMS_errortext[str_int(Zeile)]);
|
||
11: Writeln('Re-Synchronisation war leider nicht erfolgreich !');
|
||
12: Writeln('TFPCR/X/DRSI-Treiber nicht gefunden !');
|
||
13: Writeln('Schnittstelle f<>r COM-',Zeile,' nicht installiert !');
|
||
14: Writeln('Hostmodebetrieb des TNC an COM-',Zeile,' nicht m”glich !');
|
||
15: Writeln('Zuviele Kan„le insgesamt vergeben, ',Zeile,' !');
|
||
end;
|
||
for i := 1 to maxZ do WriteAttr(1,i,80,TextAttr,1);
|
||
PRG_Stoppen(0);
|
||
End;
|
||
|
||
Procedure ScrFile_erzeugen;
|
||
var i : Byte;
|
||
l : LongInt;
|
||
Result : Word;
|
||
begin
|
||
Assign(ScrollFile,VDisk + ScrollDatei);
|
||
if RewriteBin(ScrollFile,T) = 0 then
|
||
begin
|
||
GetMem(Page,maxNotChBuf);
|
||
FillChar(Page^,maxNotChBuf,0);
|
||
l := 0;
|
||
for i := 0 to maxLink do with K[i]^ do
|
||
begin
|
||
Pos_im_Scr := l;
|
||
l := l + maxNotCh;
|
||
BlockWrite(ScrollFile,Page^[0],maxNotCh,Result);
|
||
end;
|
||
FreeMem(Page,maxNotChBuf);
|
||
FiResult := CloseBin(ScrollFile);
|
||
end else Abbruch_XP(7,'');
|
||
end;
|
||
|
||
Function HeapFrei (* Bedarf : LongInt) : Boolean *);
|
||
Begin
|
||
HeapFrei := MaxAvail > Bedarf;
|
||
End;
|
||
|
||
{Procedure LineRead (* Fstr : Str10 *);
|
||
var Flag : Boolean;
|
||
i : Byte;
|
||
Begin
|
||
Flag := false;
|
||
i := 0;
|
||
Repeat
|
||
inc(i);
|
||
While not Flag and not Eof(G^.Config) do
|
||
begin
|
||
Readln(G^.Config,DZeile);
|
||
if copy(DZeile,1,length(Fstr)) = Fstr then
|
||
begin
|
||
Flag := true;
|
||
delete(DZeile,1,pos(GL,DZeile));
|
||
end;
|
||
end;
|
||
if not Flag then DZeile := '';
|
||
if Eof(G^.Config) and not Flag then FiResult := ResetTxt(G^.Config);
|
||
Until Flag or (i > 1);
|
||
End;
|
||
}
|
||
|
||
Function MakeString(Zahl:Integer) : String;
|
||
var mst:string;
|
||
begin
|
||
str(Zahl, MSt);
|
||
Makestring:=mst;
|
||
end;
|
||
|
||
|
||
Procedure Config_TNC_Lesen;
|
||
Const PTNC : String[5] = 'CFG:';
|
||
|
||
Var at,T,i,i1,ta,t2,
|
||
i2,i3 : Byte;
|
||
TNC_Str : String[4];
|
||
MpxNr : Byte;
|
||
HfPort : Byte;
|
||
ComNr : Byte;
|
||
TicFlag : Boolean;
|
||
m : LongInt;
|
||
Flag : Boolean;
|
||
|
||
Begin { 1 2 3 4 5 6 7 8 9 10 11}
|
||
{ CFG:TNC1=FALC,10,2M,0,3,1,3E8,10,115200,1,0 }
|
||
|
||
for T:=1 to maxTNC do
|
||
TNC[T]:=NIL;
|
||
T2:=0;
|
||
for T := 1 to maxTNC do
|
||
begin
|
||
at := Konfig.TNC[T].art; {>}
|
||
if (konfig.tnc[t].art=0) or (konfig.TNC[t].maxKan=0)
|
||
{and (konfig.TNC[t].maxKan<=MaxKanal)} then
|
||
begin
|
||
dzeile:=''
|
||
end else
|
||
begin
|
||
dzeile:='WWL';
|
||
inc(T2);
|
||
|
||
{ LineRead(PTNC + 'TNC' + int_str(T));}
|
||
|
||
if dzeile<>'' then
|
||
begin
|
||
tnc_str:=tnc_art[Konfig.TNC[T].Art];
|
||
|
||
if konfig.tnc[t].art=3 then { TFPC }
|
||
begin
|
||
Interface_Exist;
|
||
if not (DRSI_installed or TFPC_installed) then Abbruch_XP(12,'');
|
||
ComNr := 5;
|
||
MpxNr := 0;
|
||
end else
|
||
begin
|
||
ComNr := Konfig.tnc[T].com; { COM-Nummer }
|
||
if not (ComNr in [1..4]) then Abbruch_XP(1,'');
|
||
end;
|
||
|
||
if ComNr in [1..4] then
|
||
begin
|
||
dzeile:='$'+Konfig.tnc[t].adresse;
|
||
m := str_int(dzeile); { Basisadresse }
|
||
if m > 0 then COM[ComNr].Base := m;
|
||
|
||
case ComNr of
|
||
1 : ComAdr1 := COM[1].Base;
|
||
2 : ComAdr2 := COM[2].Base;
|
||
3 : ComAdr3 := COM[3].Base;
|
||
4 : ComAdr4 := COM[4].Base;
|
||
end;
|
||
|
||
m := Byte(Konfig.tnc[t].irq); { Interrupt-Nummer }
|
||
if not (m in [0..15]) then Abbruch_XP(2,int_str(ComNr) + ' : ' + int_str(m));
|
||
if m = 0 then HwHs := true;
|
||
COM[ComNr].IRQ_Nr := m;
|
||
|
||
case ComNr of
|
||
1 : EoiPic1 := COM[1].IRQ_Nr > 7;
|
||
2 : EoiPic2 := COM[2].IRQ_Nr > 7;
|
||
3 : EoiPic3 := COM[3].IRQ_Nr > 7;
|
||
4 : EoiPic4 := COM[4].IRQ_Nr > 7;
|
||
end;
|
||
|
||
m := LongInt(konfig.tnc[t].baud); { Baudrate }
|
||
if (m < 1200) or (m > 115200) then Abbruch_XP(3,int_str(ComNr) + ' : ' + int_str(m));
|
||
COM[ComNr].BaudRate := m;
|
||
|
||
{ FIFOs }
|
||
if konfig.tnc[t].fifo then COM[ComNr].FifoCfg := $01
|
||
else COM[ComNr].FifoCfg := $00;
|
||
end;
|
||
|
||
HfPort := konfig.tnc[t].port; { HF-Portnummer }
|
||
|
||
TicFlag := konfig.tnc[t].tickzeile;{ Tickerzeile }
|
||
|
||
MpxNr := konfig.tnc[t].multiplexnr; { Nummer am Multiplexer }
|
||
if (not (MpxNr in [0..4])) then Abbruch_XP(1,'');
|
||
|
||
m := konfig.tnc[t].maxkan; { Kanalanzahl }
|
||
|
||
if (m >= 0) and (maxLink <= maxKanal) then
|
||
begin { hier sollen ein paar Kan„le spendiert werden }
|
||
TNC_used[T2] := true;
|
||
{inc(TNC_Anzahl);}
|
||
GetMem(TNC[T2],SizeOf(TNC[T2]^));
|
||
FillChar(TNC[T2]^,SizeOf(TNC[T2]^),0);
|
||
|
||
with TNC[T2]^ do
|
||
begin
|
||
{PortName:=konfig.tnc[t].portnam;}
|
||
DRSI := 0;
|
||
FALC := false;
|
||
TNC3 := false;
|
||
PCXD := false;
|
||
ExtHost := false;
|
||
TNC_im_Host := false;
|
||
Kvon := 0;
|
||
Kbis := 0;
|
||
{$IFNDEF no_Bake} {//db1ras}
|
||
Bake := false;
|
||
BTimer := 20;
|
||
{$ENDIF}
|
||
CText := 1;
|
||
Info := 1;
|
||
Aktuell := 1;
|
||
QText := 1;
|
||
Fix := 1;
|
||
QRG_Akt := PseudoQRG;
|
||
|
||
if TNC_Str = TNC_Art[4] then { FALC }
|
||
begin
|
||
FALC := true;
|
||
DRSI := 1;
|
||
HF_PortStr := '@CCHAN' + B1 + int_str(HfPort);
|
||
end;
|
||
|
||
if TNC_Str = TNC_Art[2] then { TNC3 }
|
||
begin
|
||
TNC3 := true;
|
||
DRSI := 1;
|
||
HF_PortStr := '#PORT' + B1 + int_str(HfPort);
|
||
end;
|
||
|
||
if (ComNr = 5) and DRSI_installed then
|
||
begin
|
||
PCXD := true;
|
||
DRSI := 1;
|
||
HF_PortStr := 'C' + B1 + int_str(HfPort) + DP;
|
||
end;
|
||
|
||
HF_Port := HfPort;
|
||
Tic := TicFlag;
|
||
if Tic then inc(TicAnz);
|
||
TicStr := ConstStr(B1,TL);
|
||
RS232 := ComNr;
|
||
MPX := MpxNr;
|
||
Ident := LRK + EFillStr(2,B1,konfig.tnc[t].identi) + RRK;
|
||
HostCall := NoCall;
|
||
Channels := m;
|
||
TncChannels := m;
|
||
if Channels > 0 then
|
||
begin
|
||
Kvon := maxLink + 1;
|
||
Kbis := Kvon + Channels - 1;
|
||
end;
|
||
end;
|
||
maxLink := maxLink + m;
|
||
if (maxLink > maxKanal) then
|
||
Abbruch_XP(15,LRK + int_str(maxLink) + '/' + int_str(maxKanal) + RRK);
|
||
end;
|
||
end;
|
||
end;
|
||
end;
|
||
|
||
i1 := 1;
|
||
for T := 1 to TNC_Anzahl do { Zuordnung DRSI-Kennziffer }
|
||
begin
|
||
ComNr := TNC[T]^.RS232;
|
||
MpxNr := TNC[T]^.MPX;
|
||
Flag := false;
|
||
|
||
if (TNC[T]^.DRSI > 0) and not TNC[T]^.ExtHost then
|
||
begin
|
||
for i := 1 to TNC_Anzahl do if (TNC[i]^.DRSI > 0) and
|
||
not TNC[i]^.ExtHost then
|
||
begin
|
||
if (TNC[i]^.RS232 = ComNr) and (TNC[i]^.MPX = MpxNr) then
|
||
begin
|
||
TNC[i]^.DRSI := i1;
|
||
TNC[i]^.ExtHost := true;
|
||
Flag := true;
|
||
end;
|
||
end;
|
||
end;
|
||
if Flag then inc(i1);
|
||
end;
|
||
for T := 1 to TNC_Anzahl do TNC[T]^.ExtHost := false;
|
||
|
||
for T := 1 to TNC_Anzahl do { Feststellen, wieviel Kan„le der DRSI-TNC hat }
|
||
begin
|
||
i2 := TNC[T]^.DRSI;
|
||
i3 := TNC[T]^.Channels;
|
||
for i := 1 to TNC_Anzahl do if T <> i then
|
||
begin
|
||
if i2 = TNC[i]^.DRSI then i3 := i3 + TNC[i]^.Channels;
|
||
end;
|
||
TNC[T]^.TncChannels := i3;
|
||
end;
|
||
|
||
End;
|
||
|
||
Procedure Config_Verz_Lesen;
|
||
Const Verz : String[5] = 'VERZ:';
|
||
|
||
var i,i1,i2 : Integer;
|
||
Flag : Boolean;
|
||
NrStr : String[4];
|
||
DrvStr : String[2];
|
||
Begin
|
||
DrvStr := copy(SysPfad,1,2);
|
||
|
||
{ LineRead(Verz + 'SAVE');}
|
||
DZeile:=Konfig.SavVerz;
|
||
if pos(BS,DZeile) = 1 then DZeile := DrvStr + DZeile;
|
||
Konfig.SavVerz := UpCaseStr(CutStr(DZeile));
|
||
if Konfig.SavVerz[length(Konfig.SavVerz)] <> BS then Konfig.SavVerz := Konfig.SavVerz + BS;
|
||
if not PfadOk(1,Konfig.SavVerz) then Konfig.SavVerz := SysPfad;
|
||
|
||
{ LineRead(Verz + 'REM');}
|
||
Dzeile:=konfig.RemVerz;
|
||
if pos(BS,DZeile) = 1 then DZeile := DrvStr + DZeile;
|
||
G^.Drive := UpCaseStr(CutStr(DZeile));
|
||
if G^.Drive[length(G^.Drive)] <> BS then G^.Drive := G^.Drive + BS;
|
||
if not PfadOk(0,G^.Drive) then G^.Drive := SysPfad;
|
||
Ini_RemPath;
|
||
G^.Merk_Drive := G^.Drive;
|
||
|
||
{ LineRead(Verz + 'MAIL');}
|
||
Dzeile:=Konfig.MailVerz;
|
||
if pos(BS,DZeile) = 1 then DZeile := DrvStr + DZeile;
|
||
Konfig.MailVerz := UpCaseStr(CutStr(DZeile));
|
||
if Konfig.MailVerz[length(Konfig.MailVerz)] <> BS then Konfig.MailVerz := Konfig.MailVerz + BS;
|
||
if not PfadOk(1,Konfig.MailVerz) then Konfig.MailVerz := SysPfad;
|
||
|
||
{ LineRead(Verz + 'RUN');}
|
||
Dzeile:=Konfig.RunVerz;
|
||
if pos(BS,DZeile) = 1 then DZeile := DrvStr + DZeile;
|
||
Konfig.RunVerz := UpCaseStr(CutStr(DZeile));
|
||
if Konfig.RunVerz[length(Konfig.RunVerz)] <> BS then Konfig.RunVerz := Konfig.RunVerz + BS;
|
||
if not PfadOk(1,Konfig.RunVerz) then Konfig.RunVerz := SysPfad;
|
||
|
||
{LineRead(Verz + 'SPK');
|
||
Dzeile:=
|
||
if pos(BS,DZeile) = 1 then DZeile := DrvStr + DZeile;
|
||
G^.SpkPfad := UpCaseStr(CutStr(DZeile));
|
||
if G^.SpkPfad[length(G^.SpkPfad)] <> BS then G^.SpkPfad := G^.SpkPfad + BS;
|
||
if not PfadOk(1,G^.SpkPfad) then G^.SpkPfad := SysPfad;
|
||
}
|
||
{LineRead(Verz + 'BIN');}
|
||
Dzeile:=Konfig.BinVerz;
|
||
if pos(BS,DZeile) = 1 then DZeile := DrvStr + DZeile;
|
||
Konfig.BinVerz := UpCaseStr(CutStr(DZeile));
|
||
if Konfig.BinVerz[length(Konfig.BinVerz)] <> BS then Konfig.BinVerz := Konfig.BinVerz + BS;
|
||
if not PfadOk(1,Konfig.BinVerz) then Konfig.BinVerz := SysPfad;
|
||
|
||
{LineRead(Verz + '7PL');}
|
||
Dzeile:=Konfig.SplVerz;
|
||
if pos(BS,DZeile) = 1 then DZeile := DrvStr + DZeile;
|
||
Konfig.splverz := UpCaseStr(CutStr(DZeile));
|
||
if Konfig.splVerz[length(Konfig.SplVerz)] <> BS then Konfig.SplVerz := Konfig.SplVerz + BS;
|
||
if not PfadOk(1,Konfig.SplVerz) then Konfig.SplVerz := SysPfad;
|
||
|
||
{LineRead(Verz + 'TMP');}
|
||
DZeile:=Konfig.TempVerz;
|
||
if pos(BS,DZeile) = 1 then DZeile := DrvStr + DZeile;
|
||
Konfig.TempVerz := UpCaseStr(CutStr(DZeile));
|
||
if Konfig.TempVerz[length(Konfig.TempVerz)] <> BS then Konfig.TempVerz := Konfig.TempVErz + BS;
|
||
if not PfadOk(1,Konfig.TempVErz) then Konfig.TempVerz := SysPfad;
|
||
|
||
{LineRead(Verz + 'MAK');}
|
||
Dzeile:=konfig.MakVerz;
|
||
if pos(BS,DZeile) = 1 then DZeile := DrvStr + DZeile;
|
||
Konfig.MakVerz := UpCaseStr(CutStr(DZeile));
|
||
if Konfig.MakVerz[length(Konfig.MakVerz)] <> BS then Konfig.MakVerz := Konfig.MakVerz + BS;
|
||
if not PfadOk(1,Konfig.MakVerz) then Konfig.MakVerz := SysPfad;
|
||
|
||
if Konfig.spkVerz[length(Konfig.spkVerz)] <> BS then Konfig.spkVerz := Konfig.spkVerz + BS;
|
||
if not PfadOk(1,Konfig.spkVerz) then Konfig.spkVerz := SysPfad;
|
||
|
||
Flag := false;
|
||
{LineRead(Verz + 'VDRV');}
|
||
{DZeile:='';}
|
||
DZeile:=Konfig.TempVerz;
|
||
if (DZeile > '') and Vdisk_Exists then
|
||
begin
|
||
VDisk := DZeile; {UpCaseStr(copy(DZeile,1,1)) + DP + BS;}
|
||
if not PfadOk(1,VDisk) then Flag := true;
|
||
end else Flag := true;
|
||
if Flag then
|
||
begin
|
||
Vdisk_Exists := false;
|
||
VDisk := SysPfad[1] + DP + BS;
|
||
end;
|
||
|
||
{LineRead(Verz + 'CDRV');}
|
||
Dzeile:=Konfig.CDRom;
|
||
if DZeile > '' then
|
||
begin
|
||
RomDisk := DZeile + DP + BS;
|
||
if PfadOk(0,RomDisk) then Rom_Exists := true;
|
||
end;
|
||
|
||
{LineRead(Verz + 'EDI');}
|
||
{G^.Ext_Edi_Path := Konfig.EditVerz;} {UpCaseStr(CutStr(DZeile));}
|
||
|
||
{ LineRead(Verz + 'VIEW'); }
|
||
{Konfig.ViewVerz := Konfig.ViewVerz;} {UpCaseStr(CutStr(DZeile));}
|
||
End;
|
||
|
||
|
||
Procedure Config_Allg_Lesen;
|
||
Const Allg : String[5] = 'ALLG:';
|
||
var iza : byte;
|
||
|
||
var b : Byte;
|
||
w : Word;
|
||
i,i1,i2 : Integer;
|
||
Flag : Boolean;
|
||
NrStr : String[4];
|
||
h1, h2 : str4;
|
||
Begin
|
||
|
||
{LineRead(Allg + 'TIME');}
|
||
|
||
ZeitArt := EFillStr(3,B1,Konfig.ZeitBez);
|
||
ZeitDiff := Konfig.UTCDiff;;
|
||
if (ZeitDiff < -23) or (ZeitDiff > 23) then ZeitDiff := 0;
|
||
RTC := Konfig.Echtzeit;
|
||
UseUTC := Konfig.UTCBenutzen;
|
||
|
||
{ LineRead(Allg + 'POP');}
|
||
Box_Time := Konfig.PopupZeit;
|
||
|
||
{ LineRead(Allg + 'LIT'); }
|
||
LockInt := Konfig.LockIRQ;
|
||
|
||
|
||
{LineRead(Allg + 'SABF');}{sicherheitsabfragen j/n}
|
||
|
||
SiAltD := Konfig.SichAbfr;
|
||
SiAltK := SiAltD;
|
||
|
||
G^.PromptStr := Konfig.PromptS;
|
||
|
||
if (Konfig.NTimeout>0) and (konfig.NTimeout<10) then Konfig.NTimeout:=10;
|
||
if (Konfig.TTimeout>0) and (Konfig.TTimeout<10) then Konfig.TTimeOut:=10;
|
||
|
||
NTimeOut := Konfig.NTimeOut;
|
||
|
||
quietZeitG := konfig.QuietZg;
|
||
if Konfig.QuietDh then
|
||
begin
|
||
Quiet:=true;
|
||
quietZeitG:=false;
|
||
end;
|
||
for iza := 1 to 3 do
|
||
begin
|
||
if konfig.quietzt[iza].stdanf=0 then h1:='0' else h1:='';
|
||
if konfig.quietzt[iza].minanf=0 then h2:='0' else h2:='';
|
||
quietztenan[iza]:=''; quietztenaus[iza]:='';
|
||
quietZtenAn[iza]:=h1+int_str(Konfig.quietzt[iza].StdAnf)+ ':' +h2+int_str(Konfig.quietzt[iza].MinAnf);
|
||
|
||
if konfig.quietzt[iza].stdend=0 then h1:='0' else h1:='';
|
||
if konfig.quietzt[iza].minend=0 then h2:='0' else h2:='';
|
||
quietZtenaus[iza]:=h1+int_str(Konfig.quietzt[iza].StdEND)+ ':' +h2+int_str(Konfig.quietzt[iza].MinEnd);
|
||
|
||
end;
|
||
|
||
{LineRead(Allg + 'IDLE');}
|
||
idle := Konfig.IDLE;
|
||
|
||
ScreenInit:=Konfig.ScrSavZ;
|
||
|
||
{$IFNDEF no_Bake} {//db1ras}
|
||
MailBakenZeit:=Konfig.MailFrameZeit;
|
||
MailBake:=Konfig.OwnMailFr;
|
||
{$ENDIF}
|
||
End;
|
||
|
||
Procedure Config_PRN_Lesen;
|
||
Const Druck : String[5] = 'PRN:';
|
||
|
||
var i,i1,Anz : Byte;
|
||
Hstr : String[4];
|
||
Begin
|
||
{LineRead(Druck + 'PORT');}
|
||
|
||
PrtPort := Konfig.LPTNr;
|
||
if not (PrtPort in [1..4]) then PrtPort := 1;
|
||
if pos(Km,DZeile) > 0 then
|
||
LPT_Base[PrtPort] := str_int('$' + Konfig.LPTAdr);
|
||
LPT_vorhanden := LPT_Base[PrtPort] > 0;
|
||
|
||
for i := 1 to 10 do
|
||
begin
|
||
{*} lptEsc[i]:='';
|
||
{LineRead(Druck + 'PAR' + int_str(i-1));}
|
||
Dzeile:='';
|
||
if DZeile > '' then
|
||
begin
|
||
Hstr := ParmStr(1,Km,DZeile);
|
||
Anz := ParmAnz;
|
||
Hstr := '';
|
||
if Anz in [1..20] then for i1 := 1 to Anz do
|
||
begin
|
||
Hstr := Hstr + chr(str_int(ParmStr(i1,Km,DZeile)));
|
||
end;
|
||
LptEsc[i] := Hstr;
|
||
end;
|
||
end;
|
||
End;
|
||
|
||
Procedure Config_RAM_Lesen;
|
||
Const Ram : String[4] = 'RAM:';
|
||
|
||
var i : Byte;
|
||
maxCh : Word;
|
||
maxSt : Byte;
|
||
|
||
Procedure Berechnen(Kanal : Byte);
|
||
Var i1 : Integer;
|
||
Begin
|
||
with K[Kanal]^ do
|
||
begin
|
||
if maxNotCh mod 16 <> 0 then inc(PagesAnz);
|
||
PagesAnz := PagesAnz + (maxNotCh div 16);
|
||
EMS_Pages_Ins := EMS_Pages_Ins + PagesAnz;
|
||
for i1 := 0 to PagesAnz-1 do PagesNot[i1] := EMS_Pages_Ins - PagesAnz + i1;
|
||
maxNotCh := maxNotCh * 1024;
|
||
if maxNotCh < NeuBildRam then maxNotCh := NeuBildRam + 96;
|
||
GesamtNotCh := GesamtNotCh + maxNotCh;
|
||
|
||
if not (VorZeilen in [10..maxVorZeilen]) then VorZeilen := 20;
|
||
|
||
|
||
GesamtVorCh := GesamtVorCh + VorZeilen * 81;
|
||
VorCmdZeilen := VorZeilen div 5;
|
||
end;
|
||
End;
|
||
|
||
Begin
|
||
{LineRead(Ram + 'MH');}
|
||
|
||
maxMH := Konfig.MH;
|
||
if not (maxMH in [10..200]) then maxMH := 25;
|
||
|
||
{LineRead(Ram + 'ALL');}
|
||
maxCh := Konfig.BackScRam;
|
||
maxSt := Konfig.VorschZRam;
|
||
if maxCh > 63 then maxCh := 63;
|
||
for i := 0 to maxLink do with K[i]^ do
|
||
begin
|
||
maxNotCh := maxCh;
|
||
VorZeilen := maxSt;
|
||
Berechnen(i);
|
||
end;
|
||
if Konfig.BufferDat then SSAV:=1 else SSAV:=0;
|
||
End;
|
||
|
||
|
||
|
||
Procedure Config_BLIND_Lesen;
|
||
Const BLN : String[5] = 'BLND:';
|
||
|
||
var i : Byte;
|
||
Begin
|
||
HardCur := Konfig.SoftHardC;
|
||
|
||
Win_Rout := Konfig.WinRout;
|
||
|
||
Win_Time := Konfig.WinRoutTime;
|
||
|
||
Braille80 := Konfig.AchzigBrail;
|
||
|
||
for i := 1 to maxLink do K[i]^.RX_Datenpieps := Konfig.RXBeepStart;
|
||
|
||
WCTRL := Konfig.Steuerz;
|
||
|
||
BLTON := Konfig.MarkTon;
|
||
|
||
BiosOut := Konfig.AusgabeBios;
|
||
End;
|
||
|
||
Procedure Puffer_schreiben;
|
||
var i,i1 : Integer;
|
||
Result : Word;
|
||
VorZ : Word;
|
||
CmdZ : Word;
|
||
Begin
|
||
if RewriteBin(BuffFile,T) = 0 then
|
||
begin
|
||
InfoOut(show,0,0,InfoZeile(98) + B1 + BuffDatei);
|
||
GetMem(Page,maxNotChBuf);
|
||
FillChar(Page^,maxNotChBuf,0);
|
||
|
||
BlockWrite(BuffFile,maxLink,SizeOf(maxLink),Result);
|
||
BlockWrite(BuffFile,Mon_Anz,SizeOf(Mon_Anz),Result);
|
||
|
||
move(MH^,Page^,maxMH * SizeOf(MH_Typ));
|
||
BlockWrite(BuffFile,Page^,maxMhRec * SizeOf(MH_Typ),Result);
|
||
|
||
for i := 0 to maxLink do with K[i]^ do
|
||
begin
|
||
BlockWrite(BuffFile,NotPos,SizeOf(NotPos),Result);
|
||
BlockWrite(BuffFile,RxLRet,SizeOf(RxLRet),Result);
|
||
BlockWrite(BuffFile,X2,SizeOf(X2),Result);
|
||
BlockWrite(BuffFile,Mo,SizeOf(Mo),Result);
|
||
BlockWrite(BuffFile,BoxStr,SizeOf(BoxStr),Result);
|
||
BlockWrite(BuffFile,NZeile,SizeOf(NZeile),Result);
|
||
BlockWrite(BuffFile,ACMerk,SizeOf(ACMerk),Result);
|
||
BlockWrite(BuffFile,CompZeile,SizeOf(CompZeile),Result);
|
||
BlockWrite(BuffFile,SendZeile,SizeOf(SendZeile),Result);
|
||
|
||
VorZ := VorZeilen - VorCmdZeilen;
|
||
CmdZ := VorCmdZeilen;
|
||
FillChar(Page^,maxNotChBuf,0);
|
||
if Vor_im_EMS then EMS_Seite_einblenden(i,Vor);
|
||
move(VorWrite[i]^[1],Page^,VorZ * 81);
|
||
move(VorWrite[i]^[VorZ+1],Page^[maxVz*81+1],CmdZ * 81);
|
||
BlockWrite(BuffFile,Page^,maxVorZeilen * 81,Result);
|
||
|
||
if use_VDisk then
|
||
begin
|
||
FiResult := ResetBin(ScrollFile,T);
|
||
Seek(ScrollFile,Pos_im_Scr);
|
||
FillChar(Page^,maxNotChBuf,0);
|
||
BlockRead(ScrollFile,Page^[0],maxNotCh,Result);
|
||
FiResult := CloseBin(ScrollFile);
|
||
BlockWrite(BuffFile,Page^,maxNotChBuf,Result);
|
||
end else
|
||
if use_XMS then
|
||
begin
|
||
FillChar(Page^,maxNotChBuf,0);
|
||
XMS_to_Data(@Page^[0],XMS_Handle,Pos_im_Scr,maxNotCh);
|
||
BlockWrite(BuffFile,Page^,maxNotChBuf,Result);
|
||
end else
|
||
begin
|
||
if use_EMS then EMS_Seite_einblenden(i,Scr);
|
||
FillChar(Page^,maxNotChBuf,0);
|
||
move(NotCh[i]^,Page^,maxNotCh);
|
||
BlockWrite(BuffFile,Page^,maxNotChBuf,Result);
|
||
end;
|
||
end;
|
||
|
||
FreeMem(Page,maxNotChBuf);
|
||
FiResult := CloseBin(BuffFile);
|
||
Neu_Bild;
|
||
end;
|
||
End;
|
||
|
||
Procedure Config_SOUND_Lesen;
|
||
begin
|
||
{AdLibFM:=Str_int('$'+konfig.MidiADR);}
|
||
end;
|
||
|
||
|
||
|
||
Procedure Puffer_lesen;
|
||
var i,i1 : Byte;
|
||
max : Byte;
|
||
Result : Word;
|
||
VorZ : Word;
|
||
CmdZ : Word;
|
||
w : Word;
|
||
Flag : Boolean;
|
||
Begin
|
||
if ResetBin(BuffFile,T) = 0 then
|
||
begin
|
||
{ WriteTxt(XCP,SZ2,StartColor,BuffDatei); }
|
||
{*** 10}
|
||
gotoxy(1,20);
|
||
writeln(' Ú ÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜ ¿');
|
||
writeln(' À ßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßß Ù');
|
||
GetMem(Page,maxNotChBuf);
|
||
FillChar(Page^,maxNotChBuf,0);
|
||
|
||
BlockRead(BuffFile,max,SizeOf(maxLink),Result);
|
||
if max > maxLink then max := maxLink;
|
||
BlockRead(BuffFile,Mon_Anz,SizeOf(Mon_Anz),Result);
|
||
|
||
BlockRead(BuffFile,Page^,maxMhRec * SizeOf(MH_Typ),Result);
|
||
move(Page^,MH^,maxMH * SizeOf(MH_Typ));
|
||
|
||
for i := 0 to max do with K[i]^ do
|
||
begin
|
||
BlockRead(BuffFile,NotPos,SizeOf(NotPos),Result);
|
||
BlockRead(BuffFile,RxLRet,SizeOf(RxLRet),Result);
|
||
BlockRead(BuffFile,X2,SizeOf(X2),Result);
|
||
BlockRead(BuffFile,Mo,SizeOf(Mo),Result);
|
||
BlockRead(BuffFile,BoxStr,SizeOf(BoxStr),Result);
|
||
BlockRead(BuffFile,NZeile,SizeOf(NZeile),Result);
|
||
BlockRead(BuffFile,ACMerk,SizeOf(ACMerk),Result);
|
||
BlockRead(BuffFile,CompZeile,SizeOf(CompZeile),Result);
|
||
BlockRead(BuffFile,SendZeile,SizeOf(SendZeile),Result);
|
||
|
||
for i1 := 1 to 2 do with Mo do
|
||
begin
|
||
MonFirst[i1] := true;
|
||
MonFrameNr[i1] := 0;
|
||
end;
|
||
|
||
VorZ := VorZeilen - VorCmdZeilen;
|
||
CmdZ := VorCmdZeilen;
|
||
if Vor_im_EMS then EMS_Seite_einblenden(i,Vor);
|
||
FillChar(Page^,maxNotChBuf,0);
|
||
BlockRead(BuffFile,Page^,maxVorZeilen * 81,Result);
|
||
move(Page^,VorWrite[i]^[1],VorZ * 81);
|
||
move(Page^[maxVz*81+1],VorWrite[i]^[VorZ+1],CmdZ * 81);
|
||
|
||
Flag := NotPos > maxNotCh;
|
||
if Flag then NotPos := 0;
|
||
|
||
if use_VDisk then
|
||
begin
|
||
FillChar(Page^,maxNotChBuf,0);
|
||
BlockRead(BuffFile,Page^,maxNotChBuf,Result);
|
||
if Flag then FillChar(Page^,maxNotChBuf,0);
|
||
FiResult := ResetBin(ScrollFile,T);
|
||
Seek(ScrollFile,Pos_im_Scr);
|
||
BlockWrite(ScrollFile,Page^[0],maxNotCh,Result);
|
||
FiResult := CloseBin(ScrollFile);
|
||
end else
|
||
if use_XMS then
|
||
begin
|
||
FillChar(Page^,maxNotChBuf,0);
|
||
BlockRead(BuffFile,Page^,maxNotChBuf,Result);
|
||
if Flag then FillChar(Page^,maxNotChBuf,0);
|
||
Data_to_XMS(@Page^[0],XMS_Handle,Pos_im_Scr,maxNotCh);
|
||
end else
|
||
begin
|
||
if use_EMS then EMS_Seite_einblenden(i,Scr);
|
||
FillChar(Page^,maxNotChBuf,0);
|
||
BlockRead(BuffFile,Page^,maxNotChBuf,Result);
|
||
if Flag then FillChar(Page^,maxNotChBuf,0);
|
||
move(Page^,NotCh[i]^,maxNotCh);
|
||
end;
|
||
end;
|
||
FiResult := CloseBin(BuffFile);
|
||
FreeMem(Page,maxNotChBuf);
|
||
|
||
for i := 0 to maxLink do with K[i]^ do
|
||
begin
|
||
if Vor_im_EMS then EMS_Seite_einblenden(i,Vor);
|
||
for i1 := (VorZeilen - VorCmdZeilen) + 1 to VorZeilen do
|
||
begin
|
||
delete(VorWrite[i]^[i1],1,2);
|
||
VorWrite[i]^[i1] := CvCh + VorWrite[i]^[i1];
|
||
end;
|
||
end;
|
||
end;
|
||
gotoxy(1,20);
|
||
{*** 11 }
|
||
writeln(' Ú ÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜ ¿');
|
||
writeln(' À ßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßß Ù');
|
||
End;
|
||
|
||
|
||
Procedure VorCurEnd;
|
||
Var i : Byte;
|
||
CMerk : Boolean;
|
||
Begin
|
||
for i := 0 to maxLink do with K[i]^ do
|
||
begin
|
||
CMerk := Cmd;
|
||
Cmd := true;
|
||
Chr_Cmd_Show(i,_CtrlPgDn,#255);
|
||
if VorWrite[i]^[stC] <> CvCh then Chr_Cmd_Show(i,_Dn,#255);
|
||
Cmd := false;
|
||
Chr_Vor_Show(i,_CtrlPgDn,#255);
|
||
if VorWrite[i]^[stV] > '' then Chr_Vor_Show(i,_Dn,#255);
|
||
Cmd := CMerk;
|
||
end;
|
||
end;
|
||
|
||
Procedure Interface_Exist;
|
||
Type KArrayTyp = array [1..11] of Char;
|
||
|
||
Var KPointer : Pointer;
|
||
KArray : ^KArrayTyp;
|
||
KStr : String[11];
|
||
Begin
|
||
if not (TFPC_Installed or DRSI_Installed) then
|
||
begin
|
||
Kiss_Int := $3F;
|
||
Repeat
|
||
Inc(Kiss_Int);
|
||
GetIntVec(Kiss_Int,KPointer);
|
||
KArray := KPointer;
|
||
move(KArray^[1],Kstr[1],11);
|
||
Kstr[0] := #11;
|
||
|
||
if (pos(MatchTFPC,Kstr) = 4) then TFPC_installed := true
|
||
else if
|
||
(pos(MatchDRSI1,Kstr) = 1) and
|
||
(pos(MatchDRSI2,Kstr) = 6) then DRSI_installed := true;
|
||
Until TFPC_installed or DRSI_installed or (Kiss_Int >= $FF);
|
||
end;
|
||
End;
|
||
|
||
|
||
Procedure GenCrcTab;
|
||
Const CRCBIT : Array [1..8] of Word = ($9188,$48C4,$2462,$1231,
|
||
$8108,$4084,$2042,$1021);
|
||
BITTAB : Array [1..8] of Byte = (128,64,32,16,8,4,2,1);
|
||
|
||
Var i,i1 : Byte;
|
||
|
||
Begin
|
||
for i := 0 to FF do
|
||
begin
|
||
G^.CrcFeld[i] := 0;
|
||
for i1 := 1 to 8 do if (BITTAB[i1] and i) > 0 then
|
||
G^.CrcFeld[i] := G^.CrcFeld[i] xor CRCBIT[i1];
|
||
end;
|
||
END;
|
||
|
||
|
||
Procedure GenPrivPWD;
|
||
Var i : Byte;
|
||
Hstr : String[80];
|
||
f : Text;
|
||
Begin
|
||
Randomize;
|
||
Hstr := '';
|
||
Repeat
|
||
i := Random(123);
|
||
if i in [33,34,36..43,45..58,60..122] then Hstr := Hstr + Chr(i);
|
||
Until length(Hstr) >= 80;
|
||
Assign(f,Sys1Pfad + PwDatei);
|
||
if AppendTxt(f) = 0 then
|
||
begin
|
||
Writeln(f);
|
||
Writeln(f,PWD);
|
||
Writeln(f,Hstr);
|
||
FiResult := CloseTxt(f);
|
||
end;
|
||
End;
|
||
|
||
|
||
Procedure UebergabeAuswert;
|
||
Var Hstr : String[80];
|
||
Bstr : String[80];
|
||
i : Byte;
|
||
unknown : Boolean;
|
||
|
||
Function Sequenz(s : Str60) : Boolean;
|
||
begin
|
||
if pos(s,Hstr) > 0 then
|
||
begin
|
||
unknown := false;
|
||
Sequenz := true;
|
||
end else Sequenz := false;
|
||
end;
|
||
|
||
Begin
|
||
Hstr := UpCaseStr(ParamZeile^);
|
||
KillEndBlanks(Hstr);
|
||
unknown := true;
|
||
for i:=1 to MaxParm do
|
||
if ParmCmd[i]=Hstr then unknown:=false;
|
||
if Hstr='' then unknown:=false;
|
||
if Sequenz(ParmCmd[1]) then Nutze_EMS := false; (* NOEMS *)
|
||
if Sequenz(ParmCmd[2]) then Nutze_XMS := false; (* NOXMS *)
|
||
if Sequenz(ParmCmd[3]) then Vdisk_Exists := false; (* NORAM *)
|
||
if Sequenz(ParmCmd[4]) then OVRtoEMS := false; (* NEOVR *)
|
||
if Sequenz(ParmCmd[5]) then HwHs := true; (* HS *)
|
||
if Sequenz(ParmCmd[6]) then ColNr := str_int(Hstr[pos(ParmCmd[7],Hstr)+1]); (* F *)
|
||
if Sequenz(ParmCmd[7]) then CRC_PR_EXE := true; (* CRC *)
|
||
|
||
{ if Sequenz(ParmCmd[10]) then (* NET *)
|
||
begin
|
||
Sys1Pfad := copy(Hstr,pos(ParmCmd[10],Hstr),80);
|
||
delete(Sys1Pfad,1,3);
|
||
Sys1Pfad := CutStr(Sys1Pfad);
|
||
if Sys1Pfad[length(Sys1Pfad)] <> BS then Sys1Pfad := Sys1Pfad + BS;
|
||
end; }
|
||
if Sequenz(ParmCmd[8]) then (* VER *)
|
||
begin
|
||
Writeln;
|
||
Writeln(Version + B2 + lastEdit);
|
||
Halt(0);
|
||
end;
|
||
if Sequenz(ParmCmd[9]) then HlpCompile := true; (* HLP *)
|
||
if Sequenz(ParmCmd[10]) then GenPrivPWD; (* PWD *)
|
||
if Sequenz(ParmCMD[11]) then OVRtoXMS := false; (* NXOVR *)
|
||
if unknown then
|
||
begin
|
||
Writeln;
|
||
for i := 1 to maxParm do
|
||
begin
|
||
Write(B3 + EFillStr(6,B1,ParmCmd[i]));
|
||
if i mod 5 = 0 then Writeln;
|
||
end;
|
||
Writeln;
|
||
Halt(0);
|
||
end;
|
||
End;
|
||
|
||
|
||
Procedure Sicherung_Speichern; {Backup - Puffer, Con und Merker sichern, ohne Prog zu beenden}
|
||
var i:byte;
|
||
begin
|
||
if not backupbremsen then
|
||
begin
|
||
BackUpLauf:=true;
|
||
Cursor_Aus;
|
||
G^.Fstr[7] := InfoZeile(458);
|
||
G^.Fstx[11] := 3;
|
||
Fenster(7);
|
||
delay(100);
|
||
AnyConnect := false;
|
||
for i := 1 to maxLink do
|
||
begin
|
||
if K[i]^.connected then AnyConnect := true;
|
||
{ if (K[i]^.RXSave) or (K[i]^.Save) or (K[i]^.Splus and K[i]^.Splsave)}
|
||
end;
|
||
{if (SSAV = 1) or ((SSAV = 2) and AnyConnect) then
|
||
begin}
|
||
Puffer_schreiben;
|
||
{ end else FiResult := EraseBin(BuffFile);}
|
||
Merker_Conn_Schreiben;
|
||
Merker_File_schreiben;
|
||
BackUpLauf:=false;
|
||
clrFenster;
|
||
end; {if not backup_bremsen}
|
||
end;
|