{ -------------------------------------------------------------------------
         Programbet‚t az " ltal nos file" l‚trehoz sa ‚s kezel‚s‚hez
  -------------------------------------------------------------------------
        Import:
             Crt
        Alap:
             - File-le¡r¢ file
             - F“ file
        File-le¡r¢ file:
             - szekvenci lis (Text),
             - szerkezete (soronk‚nt):
                   = a rendszer verzi¢sz ma, (l. AktVerzio konstanst)
                   = a f“ file neve,
                   = a f“ file elemsz ma,
                   = a f“ file elem‚nek mez“sz ma,
                   = a f“ file eleme 1. mez“j‚nek t¡pusa,
                   = a f“ file eleme 1. mez“j‚nek neve,
                   = a f“ file eleme 1. mez“j‚nek hossza,
                   = a f“ file eleme 2. mez“j‚nek t¡pusa,
                   = a f“ file eleme 2. mez“j‚nek neve,
                   = a f“ file eleme 2. mez“j‚nek hossza,
                   = ...
             - v laszthat¢ t¡pusok = Eg‚sz, Val¢s, Karakter, Logikai,
                                     StringS(=Sz”veg[30]),
                                     D tum(=‚v.h¢.nap), Id“(=¢ra:perc:mperc)
        F“ file:
             hagyom nyos file (amilyen lenne).
}

{
        Standard-r‚sz:
}

UNIT altf2mod;
Interface
  Uses {Newdelay,} CRt;
  Const
      AktVerzio= '1.2';   {Aktu lis rendszerverzi¢}
      MaxMDb = 9;         {Maxim lis mez“sz m}
      MaxSHossz = 30;     {Maxim lis sz”veghossz}
      MaxPufHossz = 1000; {Maxim lis pufferm‚ret}
  Type
      StringS = String[MaxSHossz];
      DatumT  = Record ev{1900-t¢l},ho,nap: Byte End;
      IdoT    = Record ora,perc,mperc: Byte End;
      FoFile  = File of Byte {Elem helyett};
      MegnyitasMod = (Letrehoz,Hasznal);
      Tipus  = (Egesz,Valos,Karakter,Szoveg,Logikai,Datum,Ido,ROSSZ);
      Puffer = Array [1..MaxPufHossz] of Byte;
      Elem   = Puffer;  {egy eleme a f“ file-nak}
      FileLeiroRekord = object
        Verzio: String[6];
        foNev : String[12];
        foHossz: LongInt;
        mezoDb: 0..MaxMDb;
        mezo  : Array [1..MaxMDb] of Record
                                        tip: Tipus;
                                        nev: String[MaxSHossz];
                                        hossz: Word
                                      End;
        fPuf  : Puffer;
        flf   : Text;
        fo    : FoFile;
        elemMeret: Word;
        hiba:boolean;
        hibakod:integer;

        Procedure Interaktiv;
        Procedure FileNyitas(mire:MegnyitasMod);
        Procedure FileZaras(mirol: MegnyitasMod);
        Function  FileVege: Boolean;
        Function  FileHossz: LongInt;
        Procedure MezoKeres(mNev: String; Var relInd: Integer);
        Procedure EgeszMezobe(mNev: String; egesz: Integer);
        Procedure EgeszMezobol(mNev: String; Var egesz: Integer);
        Procedure ValosMezobe(mNev: String; valos: Real);
        Procedure ValosMezobol(mNev: String; Var valos: Real);
        Procedure SzovegMezobe(mNev: StringS; szoveg: StringS);
        Procedure SzovegMezobol(mNev: StringS; Var szoveg: StringS);
        Procedure LogikaiMezobe(mNev: String; log: Boolean);
        Procedure LogikaiMezobol(mNev: String; Var log: Boolean);
        Procedure DatumMezobe(mNev: String; datum: DatumT);
        Procedure DatumMezobol(mNev: String; Var datum: DatumT);
        Procedure IdoMezobe(mNev: String; ido: IdoT);
        Procedure IdoMezobol(mNev: String; Var ido: IdoT);
        Procedure WriteElem;
        Procedure ReadElem;
        Procedure WriteIElem(iE: Integer);
        Procedure ReadIElem( iE: Integer);
        Procedure Elembol(Var elem: Puffer);
        Procedure Elembe(elem: Puffer);

       End;

  Const
      LogS  : Array [Boolean] of String[5]=('Hamis','Igaz');
      TipusS: Array [Tipus] of String[9]=('Eg‚sz','Val¢s','Karakter','Sz”veg',
                                          'Logikai','D tum','Id“','ROSSZ');
      TipusH: Array [Tipus] of Byte     =(SizeOf(Integer),SizeOf(Real),
                                          SizeOf(Char)+1{mivel 1 jel� string},
                                          SizeOf(StringS),SizeOf(Boolean),
                                          SizeOf(DatumT),SizeOf(IdoT),0);
{ Egy p‚lda FlRek-re:
      FlRek : FileLeiroRekord=(
         foNev:'f';
         mezoDb:4;
         mezo:((tip:Szoveg;nev:'N‚v';hossz:SizeOf(StringS)),
               (tip:Datum;nev:'Sz�l.id“';hossz:SizeOf(Datum)),
               (tip:Logikai;nev:'Ffi';hossz:SizeOf(Boolean)),
               (tip:Valos;nev:'S£ly';hossz:SizeOf(Real)),
               [ Nem l‚tez“ mez“k: ]
               (),(),())
         [nem kapnak kezd“‚rt‚ket:
          fPuf:
          flf :
          fo  :
          elemMeret:];
}

implementation
  Function MezoTipus(s: String): Tipus;
    Var  i: Tipus;
  Begin
  End; {MezoTipus}


  Procedure HibaMegallas(kod: Integer; uzenet: String);
    Var c: Char;
  Begin
    HighVideo;
    Writeln('Meg ll s fat lis hiba miatt:');
    Writeln('<',uzenet,'>',' Hibak¢d:',kod);
    NormVideo;
    c:=ReadKey;
  End; {HibaMegallas}

  Procedure FileLeiroRekord.Interaktiv;
  begin
  end;

  Procedure FileLeiroRekord.FileNyitas(mire:MegnyitasMod);
    Var i  : Byte;
        sor: String;
  Begin
    assign(flf,fonev+'.flf');
    assign(fo,fonev+'.db');
    case mire of
      hasznal : begin reset(flf); reset(fo); end;
      letrehoz : begin rewrite(flf); rewrite(fo); end;
    end;
  End; {FileNyitas}

  Procedure FileLeiroRekord.FileZaras(mirol: MegnyitasMod);
    Var i: Byte;
        fohosszb: array[0..sizeof(longint)] of byte absolute fohossz;
  Begin
    {az £j hossz kivitele az flf-file-ba:}
    case mirol of
      letrehoz: begin
                 seek(fo,3);
                 {for i:=1 to +1 to}
               end;
     hasznal: begin end;
     end;
  End; {FileZaras}

  Function FileLeiroRekord.FileVege: Boolean;
    Var i: Byte;
  Begin

  End; {FileVege}

  Function FileLeiroRekord.FileHossz: LongInt;
    Var i: Byte;
  Begin
  End; {FileHossz}
  {
        Elem-m–veletek:
  }
  Procedure FileLeiroRekord.WriteElem;
    Var i: Integer;
  Begin
  End; {WriteElem}

  Procedure FileLeiroRekord.ReadElem;
    Var i: Integer;
  Begin

  End; {ReadElem}

  Procedure FileLeiroRekord.WriteIElem(iE: Integer);
    Var i: Integer;
  Begin
  End; {WriteIElem}

  Procedure FileLeiroRekord.ReadIElem(iE: Integer);
    Var i: Integer;
  Begin
  End; {ReadIElem}
  {
        Mez“-m–veletek:
  }

  Procedure FileLeiroRekord.MezoKeres(mNev: String; Var relInd: Integer);
    Var i: Integer;
  Begin

  End; {MezoKeres}

  Procedure FileLeiroRekord.EgeszMezobe(mNev: String; egesz: Integer);
    Var i,relInd: Integer;
        seged   : Array [0..1] of Byte Absolute egesz;
  Begin
    MezoKeres(mNev,relInd);
    If not hiba then
     For i:=0 to SizeOf(seged)-1 do
       Puffer[i+relInd]:=seged[i];
  End; {EgeszMezobe}

  Procedure FileLeiroRekord.EgeszMezobol(mNev: String; Var egesz: Integer);
    Var i,relInd: Integer;
        seged   : Array [0..1] of Byte Absolute egesz;
  Begin
    MezoKeres(mNev,relInd);
    If not hiba then
     For i:=0 to SizeOf(seged)-1 do
       {seged[i]:=Puffer[i+relInd];}
  End; {EgeszMezobol}

  Procedure FileLeiroRekord.ValosMezobe(mNev: String; valos: Real);
    Var i,relInd: Integer;
        seged   : Array [0..5] of Byte Absolute valos;
  Begin
    MezoKeres(mNev,relInd);
    If not hiba then
     For i:=0 to SizeOf(seged)-1 do
       {Puffer[i+relInd]:=seged[i];}
  End; {ValosMezobe}

  Procedure FileLeiroRekord.ValosMezobol(mNev: String; Var valos: Real);
    Var i,relInd: Integer;
        seged   : Array [0..5] of Byte Absolute valos;
  Begin
    MezoKeres(mNev,relInd);
    If not hiba then
     For i:=0 to SizeOf(seged)-1 do
       {seged[i]:=Puffer[i+relInd];}
  End; {ValosMezobol}

  Procedure FileLeiroRekord.SzovegMezobe(mNev: StringS; szoveg: StringS);
    Var i,relInd: Integer;
        seged   : Array [0..SizeOf(StringS)-1] of Byte Absolute datum;
  Begin
    MezoKeres(mNev,relInd);
    If not hiba then
     For i:=0 to SizeOf(seged)-1 do
       seged[i]:=Puffer[i+relInd];
  End; {SzovegMezobe}

  Procedure FileLeiroRekord.SzovegMezobol(mNev: StringS; Var szoveg: StringS);
    Var i,relInd: Integer;
        seged   : Array [0..SizeOf(StringS)-1] of Byte Absolute datum;
  Begin
    MezoKeres(mNev,relInd);
    If not hiba then
     For i:=0 to SizeOf(seged)-1 do
       Puffer[i+relInd]:=seged[i];
  End; {SzovegMezobol}

  Procedure FileLeiroRekord.KarakterMezobe(mNev: StringS; karakter: Char);
    Var relInd: Integer;
        seged   : Byte Absolute karakter;
  Begin
    MezoKeres(mNev,relInd);
    If not hiba then Puffer[relInd]:=seged;
  End; {KarakterMezobe}

  Procedure FileLeiroRekord.KarakterMezobol(mNev: StringS; Var karakter: Char);
    Var relInd: Integer;
        seged   : Byte Absolute karakter;
  Begin
    MezoKeres(mNev,relInd);
    If not hiba then seged:=Puffer[relInd];
  End; {KarakterMezobol}

  Procedure FileLeiroRekord.LogikaiMezobe(mNev: String; log: Boolean);
    Var relInd: Integer;
  Begin
    MezoKeres(mNev,relInd);
    If not hiba then Puffer[relInd]:=Ord(log);
  End; {LogikaiMezobe}

  Procedure FileLeiroRekord.LogikaiMezobol(mNev: String; Var log: Boolean);
    Var relInd: Integer;
  Begin
    MezoKeres(mNev,relInd);
    If not hiba then log:=not(Puffer[relInd]=0);
  End; {LogikaiMezobol}

  Procedure FileLeiroRekord.DatumMezobe(mNev: String; datum: DatumT);
    Var i,relInd: Integer;
        seged   : Array [0..SizeOf(DatumT)-1] of Byte Absolute datum;
  Begin
    MezoKeres(mNev,relInd);
    If not hiba then
     For i:=0 to SizeOf(seged)-1 do
       Puffer[i+relInd]:=seged[i];
  End; {DatumMezobe}

  Procedure FileLeiroRekord.DatumMezobol(mNev: String; Var datum: DatumT);
    Var i,relInd: Integer;
        seged   : Array [0..SizeOf(DatumT)-1] of Byte Absolute datum;
  Begin
    MezoKeres(mNev,relInd);
    If not hiba then
     For i:=0 to SizeOf(seged)-1 do
       seged[i]:=Puffer[i+relInd];
  End; {DatumMezobol}

  Procedure FileLeiroRekord.IdoMezobe(mNev: String; ido: IdoT);
    Var i,relInd: Integer;
        seged   : Array [0..SizeOf(IdoT)-1] of Byte Absolute ido;
  Begin
    MezoKeres(mNev,relInd);
    If not hiba then
     For i:=0 to SizeOf(seged)-1 do
       Puffer[i+relInd]:=seged[i];
  End; {IdoMezobe}

  Procedure FileLeiroRekord.IdoMezobol(mNev: String; Var ido: IdoT);
    Var i,relInd: Integer;
        seged   : Array [0..SizeOf(IdoT)-1] of Byte Absolute ido;
  Begin
    MezoKeres(mNev,relInd);
    If not hiba then
     For i:=0 to SizeOf(seged)-1 do
       seged[i]:=Puffer[i+relInd];
  End; {IdoMezobol}

  Procedure FileLeiroRekord.Elembol(Var elem: Puffer);
  Begin
  End; {Elembol}

  Procedure FileLeiroRekord.Elembe(elem: Puffer);
  Begin
  End; {Elembe}


end.