#include <stdio.h>
#include <string.h>
#include <exec/exec.h>
#include <proto/dos.h>
#include <proto/exec.h>

void main(int,char **);
short __regargs purge(char *,char *);
void __regargs scandir(char *,char *);

short recur;

void main(int argc,char **argv)
{
   static char path[256],node[256],*filep;
   long len;
   if (!argc)
      return;
   if (argc==2 && argv[1][0]=='?')
   {
      FPuts(Output(),"USAGE : purge [-r] <file>\n");
      return;
   }
   if (argc==3 && argv[1][0]=='-' && argv[1][1]=='r')
      recur=1;
   if (filep=FilePart(argv[argc-1]))    /* Pfad und Pattern trennen */
   {
      len=filep-argv[argc-1];
      strncpy(path,argv[argc-1],len);
      strcpy(node,filep);
      scandir(path,node);
   }
}

void __regargs scandir(char *path,char *pattern)
{
   static char buffer[516],left[256],right[256];
   char *buffer1,*p;
   struct FileInfoBlock *fib;
   BPTR lock;
   short success=1,patt,purged=0;
   
   /* Zwischenspeicher allokieren */
   
   if (!(buffer1=(char *)AllocVec(256,MEMF_CLEAR|MEMF_PUBLIC)))
   {
      FPuts(Output(),"Nicht genug Speicher\n");
      return;
   }
   if (!(fib=(struct FileInfoBlock*)AllocVec(sizeof(struct FileInfoBlock),MEMF_CLEAR|MEMF_PUBLIC)))
   {
      FPuts(Output(),"Nicht genug Speicher\n");
      FreeVec(buffer1);
      return;
   }
   patt=ParsePattern(pattern,buffer,512);
   if (lock=Lock(path,ACCESS_READ))
   {
      if (Examine(lock,fib))
      {
         while (success)   /* Verzeichnis auf Matches prüfen */    
         {
            success=ExNext(lock,fib);
            
            /* Pattern vorhanden ==> Dateinamen vergleichen */
            
            if (patt && fib->fib_DirEntryType<=0 && MatchPattern(buffer,fib->fib_FileName))
            {
               if (p=stpchr(fib->fib_FileName,'.'))
               {
                  /* Wenn Punkt im Dateinamen, dann Namenstamm abtrennen
                     und versuchen diese Gruppe zu löschen */
                  memset(left,0,sizeof(left));
                  strncpy(left,fib->fib_FileName,p-(fib->fib_FileName));
                  strcpy(right,p+4);
                  strcat(left,right);
                  if (purge(path,left))
                  {
                     UnLock(lock);  
                     /* Dateien gelöscht, Dir. muß neu "gelockt" werden */
                     if (lock=Lock(path,ACCESS_READ))
                     {
                        Examine(lock,fib);
                        success=ExNext(lock,fib); /* ExNext für Volume */
                     }
                  }
               }
            }
            /* Namen ohne Pattern angegeben und noch kein purge auf dieses
               Verzeichnis */
            else if (fib->fib_DirEntryType<=0 && !patt && !purged)
            {
               if (purge(path,pattern))
               {
                  purged=1;
                  UnLock(lock);  /* Dateien gelöscht ==> neuer Lock */
                  if (lock=Lock(path,ACCESS_READ))
                  {
                     Examine(lock,fib);   /* ExNext für Volume */
                     success=ExNext(lock,fib);
                  }
               }
            }
            /* Unterverzeichnis und "-r"-Flag angegeben */
            if (fib->fib_DirEntryType>0 && recur)
            {
               strcpy(buffer1,path);             /* Pfad retten */
               strcat(path,fib->fib_FileName);   /* neuer Pfad  */
               strcat(path,"/");                 /* Slash dazu  */
               UnLock(lock);                     /* altes Lock freigeben */
               scandir(path,pattern);            /* und Rekursion */
               strcpy(path,buffer1);             /* alten Pfad zurück */
               if (!(lock=Lock(path,ACCESS_READ))) /* und "relock" */
                  return;
            }
         }
      }
      UnLock(lock);
   }
   FreeVec(buffer1);  /* Speicher freigeben */
   FreeVec(fib);
}

short __regargs purge(char *path,char *name)
{
   BPTR fh;
   short x,max,purged=0;
   static char substring[256],string[256],help[256],*p;
   strcpy(string,path);
   strcat(string,name);
   strcpy(help,string);
   strcat(help,".vers");
   if (p=stpchr(string,'.'))
   {
      strcpy(substring,p);
      if (fh=Open(help,MODE_OLDFILE))  /* Versionsdatei öffnen */
      {
         FRead(fh,&max,sizeof(max),1); /* höchste Versionsnummer */
         if (max>1)
         {
            for (x=max-1;x>0;x--)
            {
               purged=1;
               sprintf(p,".%03d",x);    /* Dateinamen mit Versionsnr. erstellen */
               strcat(string,substring);
               string[strlen(string)]=0;
               DeleteFile(string);      /* Version "x" der Datei löschen */
               strcpy(help,string);
               strcat(help," - purged\n");
               FPuts(Output(),help);
            }
            sprintf(p,".%03d",max);
            strcat(string,substring);
            strcpy(help,string);
            *p='.';
            *(p+1)='0';
            *(p+2)='0';
            *(p+3)='1';
            Rename(help,string); /* und höchste Version umbenennen */
            max=1;               /* Versionsdatei neu schreiben ("1") */
            Seek(fh,0,OFFSET_BEGINNING);
            FWrite(fh,&max,sizeof(max),1);
         }
         Close(fh);
      }
   }
   return(purged);
}