path: root/dateibeziehungen.pas

unit dateiBeziehungen;

{$mode objfpc}{$H+}

interface

uses
  classes, sysUtils, tools, regExpr;

type
  tZeilenTyp = (ztSuche,ztZiel,ztQuelle,ztBefehl);

  pTAbhaengigkeit = ^tAbhaengigkeit;
  tAbhaengigkeit = class;

  tAbhaengigkeiten = class(tFPList)
  private
    function rItem(idx: longint): tAbhaengigkeit; inline;
    procedure wItem(idx: longint; neu: tAbhaengigkeit); inline;
  public
    property items[idx: longint]: tAbhaengigkeit
      read rItem
      write wItem; default;
    procedure kopiereVon(original: tAbhaengigkeiten);
    procedure mrProper;
    function add(neu: tAbhaengigkeit): longint;
    function last: tAbhaengigkeit;
    procedure sort;
  end;

  tAbhaengigkeit = class(tObject)
  private
    _erben,_eltern:    tAbhaengigkeiten;
    _quellens,_zieles: array of tDateienMitDaten;
    function rQuellen(idx: longint): tDateienMitDaten;
    function rZiele(idx: longint): tDateienMitDaten;
  public
    quellenREs:     array of tRegExpr; // regexes der Quellen
    qrePack:        array of boolean;  // sind mehrere matches obiger regexes zu einem Paket zu bündeln?
    zieleFkt,
    befehle:        tStringlist;
    property quellen[idx: longint]: tDateienMitDaten
      read rQuellen;
    property ziele[idx: longint]: tDateienMitDaten
      read rZiele;
    function matchCount: longint;
    constructor create; overload;
//    constructor create(original: tAbhaengigkeit); overload;
    destructor destroy; override;
    function hatQuelleVonAlsZiel(abh: tAbhaengigkeit): boolean;
    function hatErbenMitQuelle(name: string): boolean;
    function erbeMitGleichenZielen(zl: tDateienMitDaten): tAbhaengigkeit;
    procedure neuerErbe(erb: tAbhaengigkeit);
    procedure entferneErben(i: longint); overload;
    procedure entferneErben(erb: tAbhaengigkeit); overload;
    procedure entferneElterReferenz(elt: tAbhaengigkeit);
    function findeQuellen(dats: tDateienMitDaten): boolean;
  end;

  tMach = class
  private
    _machDatei,_pruefsummenDatei: string;
    _oriAbh,_mglAbh,_ztAbh:       tAbhaengigkeiten;
    _dats:                        tDateienMitDaten;
    _ign:                         array of tRegExpr;
    procedure wMachDatei(md: string);
    procedure wPruefsummenDatei(pd: string);
    function liesMachDatei: boolean;
    function liesPruefsummenfile: boolean;
    function sammleDateien(wo: string; rekursiv: boolean): longint;
    procedure zieleHinzufuegen(var ziele: tDateienMitDaten; ziel,quelle: string);
    procedure findeMehrZiele(var ziele: tDateienMitDaten; zieleFkt: tStringList; quelle: string);
  public
    property machDatei: string
      read _machDatei
      write wMachDatei;
    property pruefsummenDatei: string
      read _pruefsummenDatei
      write wPruefsummenDatei;
    constructor create;
    destructor destroy; override;
    procedure erzeugeRegeln;
    procedure findeWasZuTunIst;
    procedure tueWasZuTunIst(allesNeu, unsicher: boolean; ausgabeDatei: string);
    function anzOriAbh: longint; inline;
    function anzMglAbh: longint; inline;
    function anzZtAbh: longint; inline;
    function anzDats: longint; inline;
  end;

function quellersetzung(var worin: string; quelle, inputfile: string): boolean;

implementation

uses
  lowlevelunit, mystringlistunit, systemunit;

// tAbhaengigkeiten ************************************************************

function tAbhaengigkeiten.rItem(idx: longint): tAbhaengigkeit;
begin
  result:=tAbhaengigkeit(get(idx));
end;

procedure tAbhaengigkeiten.wItem(idx: longint; neu: tAbhaengigkeit);
begin
  put(idx,neu);
end;

procedure tAbhaengigkeiten.kopiereVon(original: tAbhaengigkeiten);
var
  i: longint;
begin
  clear;
  for i:=0 to original.count-1 do
    add(original[i]);
end;

procedure tAbhaengigkeiten.mrProper;
var
  i: longint;
begin
  for i:=0 to count-1 do
    items[i].free;
  clear;
end;

function tAbhaengigkeiten.add(neu: tAbhaengigkeit): longint;
var
  i: longint;
begin
  for i:=0 to count-1 do
    if items[i]=neu then
      fehler('Fehler: Ich soll etwas zur Liste hinzufügen, was schon drin ist!');
  result:=inherited add(neu);
end;

function tAbhaengigkeiten.last: tAbhaengigkeit;
begin
  result:=tAbhaengigkeit(inherited last);
end;

procedure tAbhaengigkeiten.sort;
var
  i,j,k,pLen:  longint;
  perm:        array of longint;
  tmp:         tAbhaengigkeit;
  bedingungen: array of tPoint;
  nehmbare:    array of byte; // 0 = ja, 1 = nein, 2 = nie wieder (schon genommen)
  fortschritt: boolean;
begin
  // Permutation initialisieren
  setlength(perm,count);
  for i:=0 to length(perm)-1 do
    perm[i]:=count; // sollte ohnehin überschrieben werden, aber "count" sorgt unten für einen Fehler!

  setlength(bedingungen,0); // aka "y hängt (direkt) von x ab"
  for i:=0 to count-1 do
    for j:=0 to count-1 do
      if (i<>j) and (items[i].hatQuelleVonAlsZiel(items[j])) then begin
        setlength(bedingungen,length(bedingungen)+1);
        bedingungen[length(bedingungen)-1].x:=i;
        bedingungen[length(bedingungen)-1].y:=j;
      end;

  setlength(nehmbare,count);
  for i:=0 to length(nehmbare)-1 do
    nehmbare[i]:=0;

  pLen:=0;
  while pLen<count do begin
    fortschritt:=false;
    for i:=0 to length(nehmbare)-1 do
      if nehmbare[i]=1 then                // noch nicht genommenes zurücksetzen
        nehmbare[i]:=0;
    for i:=0 to length(bedingungen)-1 do
      if nehmbare[bedingungen[i].x]<2 then // wenn die Quelle noch nicht dran war,
        nehmbare[bedingungen[i].y]:=1;     // darf das Ziel auch nicht genommen werden
    for i:=0 to length(nehmbare)-1 do
      if nehmbare[i]=0 then begin          // nehmbar?
        nehmbare[i]:=2;                    // als "genommen" markieren
        perm[pLen]:=i;
        inc(pLen);
        fortschritt:=true;
      end;
    if not fortschritt then
      fehler('Ich kann keine Regel mehr finden, deren Quellen nicht mehr erzeugt werden müssen - gibt es vllt. eine zyklische Abhängigkeit?');
  end;

  // berechnete Permutation anwenden
  for i:=0 to length(perm)-1 do
    if perm[i]>=0 then begin
      tmp:=items[i];
      j:=i;
      while perm[j]<>i do begin
        k:=perm[j];
        perm[j]:=-1;
        items[j]:=items[k];
        j:=k;
      end;
      items[j]:=tmp;
      perm[j]:=-1;
    end;
end;

// tAbhaengigkeit **************************************************************

constructor tAbhaengigkeit.create;
begin
  inherited create;
  setlength(quellenREs,0);
  setlength(qrePack,0);
  zieleFkt:=tStringlist.create;
  befehle:=tStringlist.create;
  _erben:=tAbhaengigkeiten.create;
  _eltern:=tAbhaengigkeiten.create;
  setlength(_quellens,0);
  setlength(_zieles,0);
end;
(*
constructor tAbhaengigkeit.create(original: tAbhaengigkeit);
var
  i: longint;
begin
  inherited create;
  setlength(quellenREs,0);
  setlength(qrePack,0);
  zieleFkt:=tStringlist.create;
  zieleFkt.text:=original.zieleFkt.text;
  setlength(_quellens,0);
  setlength(_zieles,0);
  befehle:=tStringlist.create;
  befehle.text:=original.befehle.text;
  _erben:=tAbhaengigkeiten.create;
  _eltern:=tAbhaengigkeiten.create;
  original.neuerErbe(self);
end;
*)
destructor tAbhaengigkeit.destroy;
var
  i: longint;
begin
  for i:=0 to length(quellenREs)-1 do
    quellenREs[i].free;
  setlength(quellenREs,0);
  setlength(qrePack,0);
  for i:=0 to length(_quellens)-1 do
    setlength(_quellens[i],0);
  setLength(_quellens,0);
  for i:=0 to length(_zieles)-1 do
    setlength(_zieles[i],0);
  setLength(_zieles,0);
  zieleFkt.free;
  befehle.free;
  while _erben.count>0 do
    entferneErben(0);
  while _eltern.count>0 do
    _eltern[0].entferneErben(self);
  _erben.free;
  _eltern.free;
  for i:=0 to length(_quellens)-1 do
    setlength(_quellens[i],0);
  setlength(_quellens,0);
  inherited destroy;
end;

function tAbhaengigkeit.rQuellen(idx: longint): tDateienMitDaten;
begin
  result:=_quellens[idx];
end;

function tAbhaengigkeit.rZiele(idx: longint): tDateienMitDaten;
begin
  result:=_zieles[idx];
end;

function tAbhaengigkeit.matchCount: longint;
begin
  if length(_quellens)<>length(_zieles) then
    fehler('unterschiedlich viele Sätze an Quellen ('+inttostr(length(_quellens))+') und Zielen ('+inttostr(length(_zieles))+').');
  result:=length(_quellens);
end;

function tAbhaengigkeit.hatQuelleVonAlsZiel(abh: tAbhaengigkeit): boolean;
var
  i,j: longint;
begin
  result:=true;
  if (matchCount>1) or (abh.matchCount>1) then
    fehler('hatQuelleVonAlsZiel geht nur für Abhängigkeiten mit einem Satz Quellen und Zielen.');
  if (matchCount=1) and (abh.matchCount=1) then
    for i:=0 to length(ziele[0])-1 do
      for j:=0 to length(abh.quellen[0])-1 do
        if abh.quellen[0][j].name = ziele[0][i].name then
          exit;
  result:=false;
end;

function tAbhaengigkeit.hatErbenMitQuelle(name: string): boolean;
var
  i,j: longint;
begin
  result:=true;
  for i:=0 to _erben.count-1 do
    with _erben[i] do begin
      if matchCount=0 then
        continue;
      if matchCount>1 then
        fehler('hatErbenMitQuelle geht nur für Abhängigkeiten mit Erben mit je einem Satz Quellen.');
      for j:=0 to length(quellen[0])-1 do
        if quellen[0][j].name=name then
          exit;
    end;
  result:=false;
end;

function tAbhaengigkeit.erbeMitGleichenZielen(zl: tDateienMitDaten): tAbhaengigkeit;
var
  i: longint;
begin
  result:=nil;
  for i:=0 to _erben.count-1 do begin
    if _erben[i].matchCount=0 then
      continue;
    if _erben[i].matchCount>1 then
      fehler('erbeMitGleichenZielen geht nur für Abhängigkeiten mit Erben mit je einem Satz Ziele.');
    if gleicheDateinamen(_erben[i].ziele[0],zl) then begin
      result:=_erben[i];
      exit;
    end;
  end;
end;

procedure tAbhaengigkeit.neuerErbe(erb: tAbhaengigkeit);
begin
  _erben.add(erb);
  erb._eltern.add(self);
end;

procedure tAbhaengigkeit.entferneErben(i: longint);
begin
  _erben[i].entferneElterReferenz(self);
  _erben.delete(i);
end;

procedure tAbhaengigkeit.entferneErben(erb: tAbhaengigkeit);
var
  i: longint;
begin
  for i:=0 to _erben.count-1 do
    if _erben[i]=erb then begin
      entferneErben(i);
      exit;
    end;
  fehler('Fehler: Kann Erben nicht finden zum Entfernen!');
end;

procedure tAbhaengigkeit.entferneElterReferenz(elt: tAbhaengigkeit);
var
  i: longint;
begin
  for i:=0 to _eltern.count-1 do
    if _eltern[i]=elt then begin
      _eltern.delete(i);
      exit;
    end;
  fehler('Fehler: Kann Elter nicht finden zum Entfernen der Referenz!');
end;

function tAbhaengigkeit.findeQuellen(dats: tDateienMitDaten): boolean;
var
  i,j,k:   longint;
  treffer: array of tDateienMitDaten;
  idx:     array of longint;
  tmpQs:   tDateienMitDaten;
  s:       string;
begin
  for i:=0 to length(_quellens)-1 do
    setlength(_quellens[i],0);
  setlength(_quellens,0);

  if length(quellenREs)=0 then exit;

  setlength(treffer,length(quellenREs));
  for i:=0 to length(treffer)-1 do
    for j:=0 to length(dats)-1 do
      if quellenREs[i].exec(dats[j].name) then begin
        setlength(treffer[i],length(treffer[i])+1);
        treffer[i,length(treffer[i])-1]:=dats[j];
      end;

  for i:=0 to length(treffer)-1 do
    if length(treffer[i])=0 then
      exit;

  setlength(idx,length(treffer));
  idx[0]:=-1;
  for i:=1 to length(idx)-1 do
    idx[i]:=length(treffer[i])-1;

  j:=0;
  for i:=0 to length(idx)-1 do
    if qrePack[i] then
      j:=j+length(treffer[i])
    else
      inc(j);
  setlength(tmpQs,j);

  // feste Bestandteile von tmpQs initialisieren
  j:=length(treffer);
  for i:=0 to length(idx)-1 do
    if qrePack[i] then begin
      tmpQs[i]:=treffer[i][0];
      for k:=1 to length(treffer[i])-1 do begin
        tmpQs[j]:=treffer[i][k];
        inc(j);
      end;
    end;

  repeat
    i:=length(idx)-1;
    while (i>=0) and qrePack[i] do
      dec(i);
    if i<0 then break;
    repeat
      inc(idx[i]);
      if idx[i]>=length(treffer[i]) then begin
        idx[i]:=0;
        repeat
          dec(i);
        until (i<0) or not qrePack[i];
        continue;
      end;
      break;
    until i<0;
    if i<0 then break;

    // idx und qrePack codieren, welche "treffer" die aktuellen Quellen sind.
    for i:=0 to length(idx)-1 do
      if not qrePack[i] then
        tmpQs[i]:=treffer[i][idx[i]];

    for i:=0 to zieleFkt.count-1 do begin
      s:=zieleFkt[i];
      if quellersetzung(s,tmpQs,machDatei) then begin

      end;
    end;
  until false;
  setlength(tmpQs,0);
end;

// tMach ***********************************************************************

constructor tMach.create;
begin
  inherited create;
  _oriAbh:=tAbhaengigkeiten.create;
  _mglAbh:=tAbhaengigkeiten.create;
  _ztAbh:=tAbhaengigkeiten.create;
  setlength(_dats,0);
end;

destructor tMach.destroy;
var
  i: longint;
begin
  _oriAbh.mrProper;
  _oriAbh.free;
  _mglAbh.mrProper;
  _mglAbh.free;
  _ztAbh.mrProper;
  _ztAbh.free;
  for i:=0 to length(_dats)-1 do
    _dats[i].free;
  setlength(_dats,0);
  for i:=0 to length(_ign)-1 do
    _ign[i].free;
  setlength(_ign,0);
  inherited destroy;
end;

procedure tMach.wMachDatei(md: string);
begin
  if md='' then begin
    md:=pwd+'/';
    while (md<>'/') and not fileexists(md+'Machdatei') do begin
      delete(md,length(md),1);
      md:=extractfilepath(md);
    end;
    md:=md+'Machdatei';
  end;
  _machDatei:=md;
  if not fileexists(_machDatei) then
    fehler('Datei '''+_machDatei+''' existiert nicht!');
  if not liesMachDatei then
    fehler('Datei '''+_machDatei+''' ist fehlerhaft!');
end;

procedure tMach.wPruefsummenDatei(pd: string);
begin
  if pd='' then
    pd:=extractfilepath(machDatei)+'.summen';
  _pruefsummenDatei:=pd;
  if not liesPruefsummenfile then
    fehler('Datei '''+_pruefsummenDatei+''' ist fehlerhaft!');
end;

function tMach.liesMachDatei: boolean;
var
  f:             tMyStringList;
  s:             string;
  na:            tAbhaengigkeit;
  rek:           boolean;
  posi:          longint;
  wasWar,wasIst: tZeilenTyp;

procedure aufraeumen;
begin
  f.free;
  na.free;
end;

begin
  result:=false;

  na:=tAbhaengigkeit.create;
  wasWar:=ztSuche;
  f:=tMyStringList.create;
  f.loadFromFile(machDatei);
  f.add('%%DATEIENDE%%');
  if not f.unfoldMacros then begin
    f.free;
    exit;
  end;
  s:='';
  while f.readln(s) do begin
    if rightStr(s,1)=';' then
      // ein Befehl(steil)
      wasIst:=ztBefehl
    else if rightStr(s,1)=':' then
      // ein Ziel
      wasIst:=ztZiel
    else if (leftStr(s,1)='^') and (rightStr(s,1)='$') then
      // eine Quelle
      wasIst:=ztQuelle
    else
      // eine zu überwachende Datei
      wasIst:=ztSuche;

    if wasIst in [ztZiel,ztBefehl] then
      delete(s,length(s),1);

    if (wasWar=ztBefehl) and (wasIst<>ztBefehl) then begin
      _oriAbh.add(na);
      na:=tAbhaengigkeit.create;
    end;

    if s='%%DATEIENDE%%' then break;

    case wasIst of
      ztSuche: begin
        if not quellersetzung(s,'',machDatei) then begin
          gibAus('Fehler: Quellersetzung in '''+s+''' fehlgeschlagen!',3);
          aufraeumen;
          exit;
        end;
        if startetMit('!',s) then begin
          setlength(_ign,length(_ign)+1);
          _ign[length(_ign)-1]:=tRegExpr.create;
          _ign[length(_ign)-1].expression:=s;
        end
        else begin
          rek:=startetMit('-r',s);
          while s<>'' do
            if sammleDateien(erstesArgument(s),rek)=0 then begin
              f.stepBack;
              f.readln(s);
              gibAus('Fehler: Ich habe etwas zu überwachendes nicht gefudnen ('''+s+''').',3);
              aufraeumen;
              exit;
            end;
        end;
      end;
      ztBefehl: begin
        while unescapedpos(';',s)>0 do begin
          posi:=unescapedpos(';',s);
          s:=trim(leftStr(s,posi-1))+' && '+trim(rightStr(s,length(s)-posi));
        end;
        while pos(';;',s)>0 do
          delete(s,pos(';;',s),1);
        na.befehle.add(s);
      end;
      ztZiel:
        while s<>'' do
          na.zieleFkt.add(erstesArgument(s));
      ztQuelle: begin
        if not quellersetzung(s,'',machDatei) then begin
          gibAus('Fehler: Quellersetzung in '''+s+''' fehlgeschlagen!',3);
          aufraeumen;
          exit;
        end;
        setlength(na.quellenREs,length(na.quellenREs)+1);
        na.quellenREs[length(na.quellenREs)-1]:=tRegExpr.create;
        na.quellenREs[length(na.quellenREs)-1].expression:=s;
      end;
    end{of case};
    wasWar:=wasIst;
  end;

  if s<>'%%DATEIENDE%%' then
    gibAus('Interner Fehler! Die letzte Regel wird vsl. nicht beachtet!',3);

  aufraeumen;
  result:=true;
end;

function tMach.liesPruefsummenfile: boolean;
var
  f:            textfile;
  i,j:          longint;
  gutschlecht:  tStringlistBArray;
  gefunden,gut: boolean;
begin
  result:=false;
  if pruefsummenDatei='' then begin
    gibAus('Fehler: Leerer Name als Summendatei angegeben!',3);
    exit;
  end;

  if not fileexists(pruefsummenDatei) then begin
    assignfile(f,pruefsummenDatei);
    rewrite(f);
    closefile(f);
  end;
  if not fileexists(pruefsummenDatei) then begin
    gibAus('Fehler: Ich bin nicht in der Lage, die bisher nicht existierende Datei '''+pruefsummenDatei+''' anzulegen!',3);
    exit;
  end;

  gutschlecht:=testeSummen(pruefsummenDatei);

  for gut:=false to true do
    for i:=0 to gutschlecht[gut].count-1 do begin
      gefunden:=false;
      for j:=0 to length(_dats)-1 do
        if _dats[j].name=gutschlecht[gut][i] then begin
          if gut then
            _dats[j].aktuell:=aAktuell
          else
            _dats[j].aktuell:=aVeraltet;
          gefunden:=true;
          break;
        end;
      if not gefunden then begin
        if not gut then begin // dateien mit ungültiger Prüfsumme können auch nicht vorhanden sein,
          setlength(_dats,length(_dats)+1); // dann werden sie einfach eingefügt
          _dats[length(_dats)-1]:=tDateiMitDatum.create;
          _dats[length(_dats)-1].name:=gutschlecht[gut][i];
          _dats[length(_dats)-1].aktuell:=aNichtVorhanden;
          continue;
        end;
        gibAus('Fehler: In der Summendatei gibt es eine Datei mit gültiger Prüfsumme, die ich nicht finden kann: '''+gutschlecht[gut][i]+'''!',3);
        for gefunden:=false to true do
          gutschlecht[gefunden].free;
        exit;
      end;
    end;

  for gefunden:=false to true do
    gutschlecht[gefunden].free;
  result:=true;
end;

function tMach.sammleDateien(wo: string; rekursiv: boolean): longint;
var
  sr:        tSearchRec;
  err,i:     longint;
  weglassen: boolean;
begin
  result:=0;
  err:=FindFirst(wo,fareadOnly or faHidden or faSysFile or (byte(rekursiv)*faDirectory),sr);
  while err=0 do begin
    weglassen:=false;
    for i:=0 to length(_ign)-1 do
      weglassen:=weglassen or _ign[i].exec(extractfilepath(wo)+sr.name);
    if not weglassen then begin
      if sr.attr and faDirectory <> 0 then begin
        if rekursiv and
          (sr.name<>'.') and
          (sr.name<>'..') then
            result:=result+sammleDateien(extractfilepath(wo)+sr.name+'/*',rekursiv);
      end
      else begin
        inc(result);
        setlength(_dats,length(_dats)+1);
        _dats[length(_dats)-1]:=tDateiMitDatum.create;
        _dats[length(_dats)-1].name:=extractfilepath(wo)+sr.name;
        _dats[length(_dats)-1].aktuell:=aVeraltet;
      end;
    end;
    err:=FindNext(sr);
  end;
  findClose(sr);
end;

procedure tMach.zieleHinzufuegen(var ziele: tDateienMitDaten; ziel,quelle: string);
var
  i,ebene,ende: longint;
  s,t,u:        string;
  wasda:        boolean;
begin
  if pos('{',ziel)=0 then begin
    if not quellersetzung(ziel,quelle,machDatei) then exit;
    ziel:=unescape(ziel);
    i:=0;
    wasda:=false;
    while i<length(_dats) do begin
      if bashMatch(ziel,_dats[i].name) then begin
        wasda:=true;
        setlength(ziele,length(ziele)+1);
        ziele[length(ziele)-1]:=_dats[i];
      end;
      inc(i);
    end;
    if not wasda then begin
      setlength(_dats,length(_dats)+1);
      _dats[i]:=tDateiMitDatum.create;
      if pos('*',ziel)=0 then _dats[i].name:=ziel
      else _dats[i].name:='.uralt.'; // unpassende *-Muster erzeugen formal keine echte Datei
      _dats[i].aktuell:=aNichtVorhanden;
      setlength(ziele,length(ziele)+1);
      ziele[length(ziele)-1]:=_dats[i];
    end;
  end
  else begin
    ende:=pos('{',ziel);
    ebene:=1;
    while (ebene>0) or (ziel[ende]<>'}') do begin
      inc(ende);
      case ziel[ende] of
        '{': inc(ebene);
        '}': dec(ebene);
      end{of case};
    end;
    s:=copy(ziel,1,pos('{',ziel)-1);
    t:=copy(ziel,pos('{',ziel)+1,ende-pos('{',ziel)-1);
    u:=copy(ziel,ende+1,length(ziel));
    if unescapedpos('..',t)>0 then begin
      for i:=strtoint(copy(t,1,unescapedpos('..',t)-1)) to strtoint(copy(t,unescapedpos('..',t)+2,length(t))) do
        zieleHinzufuegen(ziele,s+inttostr(i)+u,quelle);
    end
    else begin
      t:=t+',';
      while unescapedpos(',',t)>0 do begin
        zieleHinzufuegen(ziele,s+copy(t,1,unescapedpos(',',t)-1)+u,quelle);
        delete(t,1,unescapedpos(',',t));
      end;
    end;
  end;
end;

procedure tMach.findeMehrZiele(var ziele: tDateienMitDaten; zieleFkt: tStringList; quelle: string);
var
  i: longint;
begin
  for i:=0 to zieleFkt.count-1 do
    zieleHinzufuegen(ziele,zieleFkt[i],quelle);
end;

procedure tMach.erzeugeRegeln;
var
  i,j,k,l:  longint;
  neues:    boolean;
  s:        string;
  tmpZiele: tDateienMitDaten;
  erb:      tAbhaengigkeit;
begin
  repeat
    neues:=false;

    for i:=0 to _oriAbh.count-1 do begin
      _oriAbh[i].findeQuellen(_dats);

      for j:=0 to _oriAbh[i].matchCount-1 do
        if _oriAbh[i].quellenRE.exec(_dats[j].name) then begin
          // Falls diese Quelle schon in eine Regel einfließt, brauchen
          // wir nichts mehr zu machen, da es für jede Quelle höchstens
          // eine Regel gibt.
          if _oriAbh[i].hatErbenMitQuelle(_dats[j].name) then continue;

          // Andernfalls müssen wir schauen, ob es zu dem Ziel / den Zielen
          // der Quelle schon eine Regel gibt.
          setlength(tmpZiele,0);
          findeMehrZiele(tmpZiele,_oriAbh[i].zieleFkt,_dats[j].name);

          if length(tmpZiele)=0 then begin
            gibAus('Fehler: Keine Ziele für Abhängigkeit!',3);
            gibAus('Quelle:',3);
            gibAus(''''+_dats[j].name+'''',3);
            gibAus('Ziele:',3);
            for k:=0 to _oriAbh[i].zieleFkt.count-1 do
              gibAus(' '''+_oriAbh[i].zieleFkt[k]+'''',3);
            fehler('... ich beende.');
          end;

          erb:=_oriAbh[i].erbeMitGleichenZielen(tmpZiele);
          if assigned(erb) then begin
            // es gibt schon eine Regel für die Ziele der Quelle,
            // dann wird dieser Regel nur die Quelle hinzugefügt
            setlength(erb.quellen,length(erb.quellen)+1);
            erb.quellen[length(erb.quellen)-1]:=_dats[j];
            // und womöglich die befehle generiert
            for l:=0 to _oriAbh[i].befehle.count-1 do begin
              s:=_oriAbh[i].befehle[l];
              if quellersetzung(s,_dats[j].name,machDatei) then begin
                if l=0 then erb.befehle.clear;
                erb.befehle.add(s);
              end;
            end;
            neues:=true;
            continue;
          end;

          // Ziel(e) ist/sind neu
          _mglAbh.add(tAbhaengigkeit.create);
          _oriAbh[i].neuerErbe(_mglAbh.last);
          setlength(_mglAbh.last.quellen,1);
          _mglAbh.last.quellen[0]:=_dats[j];
          _mglAbh.last.zieleFkt:=tStringlist.create;
          _mglAbh.last.zieleFkt.text:=_oriAbh[i].zieleFkt.text;
          setlength(_mglAbh.last.ziele,length(tmpZiele));
          for k:=0 to length(tmpZiele)-1 do
            _mglAbh.last.ziele[k]:=tmpZiele[k];
          _mglAbh.last.befehle.clear;
          for k:=0 to _oriAbh[i].befehle.count-1 do begin
            s:=_oriAbh[i].befehle[k];
            if quellersetzung(s,_dats[j].name,machDatei) then
              _mglAbh.last.befehle.add(s);
          end;
        end;

  until not neues;
end;

procedure tMach.findeWasZuTunIst;
var
  i,j,k:   longint;
  ziA,quA: tAktualitaet;
  neues:   boolean;
begin
  // schauen, welche Regeln angewandt werden müssen
  repeat
    neues:=false;
    for i:=_mglAbh.count-1 downto 0 do begin
      for j:=0 to length(_mglAbh[i].quellen)-1 do
        findeMehrZiele(_mglAbh[i].ziele,_mglAbh[i].zieleFkt,_mglAbh[i].quellen[j].name);
      if length(_mglAbh[i].ziele)=0 then begin // immer noch keine ziele
        gibAus('Warnung: Keine Ziele für diese Abhängigkeit!',3);
        gibAus('quellen:',3);
        for k:=0 to length(_mglAbh[i].quellen)-1 do
          gibAus(' '''+_mglAbh[i].quellen[k].name+'''',3);
        gibAus('zieleFkt:',3);
        for k:=0 to _mglAbh[i].zieleFkt.count-1 do
          gibAus(' '''+_mglAbh[i].zieleFkt[k]+'''',3);
        gibAus(' - wird ignoriert.',3);
        _mglAbh[i].free;
        _mglAbh.delete(i);
        continue;
      end;

      quA:=aAktuell;                                    // bis auf weiteres gehen wir davon aus, dass die Quellen aktuell sind
      for j:=0 to length(_mglAbh[i].quellen)-1 do
        if _mglAbh[i].quellen[j].aktuell<>aAktuell then // nicht aktuelle Quellen
          quA:=aWirdErneuert;                           // werden sicherlich erneuert werden
      ziA:=aAktuell;                                    // bis auf weiteres gehen wir davon aus, dass die Ziele aktuell sind
      for j:=0 to length(_mglAbh[i].ziele)-1 do
        ziA:=min(ziA,_mglAbh[i].ziele[j].aktuell);

      if ziA<quA then begin
        neues:=true;
        _ztAbh.add(tAbhaengigkeit.create(_mglAbh[i]));
        for j:=0 to length(_mglAbh[i].ziele)-1 do
          _mglAbh[i].ziele[j].aktuell:=aWirdErneuert;
        _mglAbh[i].free;
        _mglAbh.delete(i);
      end;
    end;
  until not neues;

  // anzuwendende Regeln sortieren
  _ztAbh.sort;
end;

procedure tMach.tueWasZuTunIst(allesNeu, unsicher: boolean; ausgabeDatei: string);
var
  i,j:                       longint;
  ausg:                      textfile;
  befehle,geaenderteDateien,
    sumDateien:              tStringlist;
  gefunden:                  boolean;
  lokTest:                   tRegExpr;
  befehl:                    string;
begin
  befehle:=tStringlist.create;
  geaenderteDateien:=tStringlist.create;
  sumDateien:=dateienMitGueltigerSumme(pruefsummenDatei);
  for i:=0 to length(_dats)-1 do begin
    gefunden:=(_dats[i].name=pruefsummenDatei) or (_dats[i].name=ausgabeDatei);
    for j:=0 to sumDateien.count-1 do
      if sumDateien[j]=_dats[i].name then begin
        gefunden:=true;
        sumDateien.delete(j);
        break;
      end;
    if not gefunden then
      geaenderteDateien.add(_dats[i].name);
  end;
  sumDateien.free;
  if allesNeu then
    for i:=0 to _mglAbh.count-1 do begin
      for j:=0 to length(_mglAbh[i].ziele)-1 do
        geaenderteDateien.add(_mglAbh[i].ziele[j].name);
      for j:=0 to length(_mglAbh[i].quellen)-1 do
        geaenderteDateien.add(_mglAbh[i].quellen[j].name);
    end;
  for i:=0 to _ztAbh.count-1 do begin
    for j:=0 to length(_ztAbh[i].ziele)-1 do
      geaenderteDateien.add(_ztAbh[i].ziele[j].name);
    for j:=0 to length(_ztAbh[i].quellen)-1 do
      geaenderteDateien.add(_ztAbh[i].quellen[j].name);
  end;
  for i:=0 to _ztAbh.count-1 do
    for j:=0 to _ztAbh[i].befehle.count-1 do
      befehle.add(_ztAbh[i].befehle[j]);
  if not unsicher then begin
    lokTest:=tRegExpr.create;
    if extractfilepath(ausgabeDatei)=extractfilepath(pruefsummenDatei) then
      lokTest.expression:='^'+extractfilepath(ausgabeDatei)+'/'
    else
      lokTest.expression:='^('+extractfilepath(ausgabeDatei)+'|'+extractfilepath(pruefsummenDatei)+')/';
    for i:=0 to befehle.count-1 do
      testeObBefehlLokal(befehle[i],extractfiledir(ausgabeDatei),lokTest);
    lokTest.free;
  end;
  for i:=geaenderteDateien.count-1 downto 0 do begin
    if geaenderteDateien[i]='.uralt.' then begin
      geaenderteDateien.delete(i);
      continue;
    end;
    for j:=0 to i-1 do
      if geaenderteDateien[i]=geaenderteDateien[j] then begin
        geaenderteDateien.delete(i);
        break;
      end;
  end;
  if geaenderteDateien.count>0 then begin
    befehle.add('echo -n "Sha512summen erneuern ..."');
    befehl:='sed "';
    for i:=0 to geaenderteDateien.count-1 do
      befehl:=befehl+'/\s'+escape(geaenderteDateien[i],'./','\')+'\$/d; ';
    befehl:=befehl+'" -i "'+pruefsummenDatei+'"';
    befehle.add(befehl);
    for i:=0 to geaenderteDateien.count-1 do
      befehle.add('sha512sum "'+geaenderteDateien[i]+'" >> '+pruefsummenDatei);
    befehle.add('echo " fertig"');
  end;

  if _ztAbh.count=0 then
    befehle.add('echo "Es gibt hier nichts zu tun!"');
  if ausgabeDatei='' then begin
    gibAus('befehle:',3);
    for i:=0 to befehle.count-1 do
      writeln(befehle[i]);
  end
  else begin
    assignFile(ausg,ausgabeDatei);
    rewrite(ausg);
    for i:=0 to befehle.count-1 do
      writeln(ausg,'('+befehle[i]+') || (read -p "Ein Fehler ist aufgetreten! ... "; exit 1)');
    closeFile(ausg);
  end;
  befehle.free;
  geaenderteDateien.free;
end;

function tMach.anzOriAbh: longint;
begin
  result:=_oriAbh.count;
end;

function tMach.anzMglAbh: longint;
begin
  result:=_mglAbh.count;
end;

function tMach.anzZtAbh: longint;
begin
  result:=_ztAbh.count;
end;

function tMach.anzDats: longint;
begin
  result:=length(_dats);
end;

// allgemeine Funktionen *******************************************************

function quellersetzung(var worin: string; quelle, inputfile: string): boolean;
var
  s,anfang,mitte: string;
  i,li,re:        longint;
begin
  result:=true;
  if quelle<>'' then begin
    while pos('%in',worin)>0 do
      worin:=copy(worin,1,pos('%in',worin)-1)+quelle+copy(worin,pos('%in',worin)+3,length(worin));
    s:=extractfilename(quelle);
    while pos('%ifile',worin)>0 do
      worin:=copy(worin,1,pos('%ifile',worin)-1)+s+copy(worin,pos('%ifile',worin)+6,length(worin));
    if pos('.',s)>0 then begin
      while s[length(s)]<>'.' do delete(s,length(s),1);
      delete(s,length(s),1);
    end;
    while pos('%basename',worin)>0 do
      worin:=copy(worin,1,pos('%basename',worin)-1)+s+copy(worin,pos('%basename',worin)+9,length(worin));
    while pos('%dirname(',worin)>0 do begin
      anfang:=erstesArgument(worin,'%dirname(');
      mitte:=erstesArgument(worin,')');
      s:=extractfilepath(quelle);
      if rightStr(s,1)='/' then
        delete(s,length(s),1);
      i:=anzCs('/',s)+1;
      li:=strtoint(erstesArgument(mitte,','));
      if li<0 then li:=li+i;
      if mitte='' then
        re:=0
      else
        re:=strtoint(mitte);
      if re<=0 then re:=re+i;
      while li>0 do begin
        dec(li);
        dec(re);
        erstesArgument(s,'/');
      end;
      mitte:='';
      while re>0 do begin
        dec(re);
        mitte:=mitte+'/'+erstesArgument(s,'/');
      end;
      delete(mitte,1,1);
      worin:=anfang+mitte+worin;
    end;
    s:=extractfilepath(quelle);
    if rightStr(s,1)='/' then
      delete(s,length(s),1);
    while pos('%dirname',worin)>0 do
      worin:=copy(worin,1,pos('%dirname',worin)-1)+s+copy(worin,pos('%dirname',worin)+8,length(worin));
  end;
  s:=extractfilepath(inputfile);
  if rightStr(s,1)='/' then
    delete(s,length(s),1);
  while pos('%DIRNAME',worin)>0 do
    worin:=copy(worin,1,pos('%DIRNAME',worin)-1)+s+copy(worin,pos('%DIRNAME',worin)+8,length(worin));
  while pos('%num''',worin)>0 do begin
    anfang:=erstesArgument(worin,'%num''');
    mitte:=erstesArgument(worin,'''');
    for i:=length(mitte) downto 1 do
      if mitte[i] in ['0'..'9'] then
        break
      else
        delete(mitte,i,1);
    for i:=length(mitte) downto 1 do
      if not (mitte[i] in ['0'..'9']) then begin
        delete(mitte,1,i);
        break;
      end;
    worin:=anfang+mitte+worin;
  end;
  if quelle<>'' then begin
    result:=false;
    while pos('%nurmit''',worin)>0 do begin
      anfang:=erstesArgument(worin,'%nurmit''');
      mitte:=erstesArgument(worin,'''');
      if pos(mitte,quelle)=0 then
        exit;
      worin:=anfang+worin;
    end;
    while pos('%nurohne''',worin)>0 do begin
      anfang:=erstesArgument(worin,'%nurohne''');
      mitte:=erstesArgument(worin,'''');
      if pos(mitte,quelle)>0 then
        exit;
      worin:=anfang+worin;
    end;
    result:=true;
  end;
end;

end.