home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 1 / FFMCD01.bin / bbs / cliutil / dirs.lha / Dirs / Deutsch / dirs.c < prev    next >
C/C++ Source or Header  |  1993-08-23  |  16KB  |  659 lines
  1. // dirs geschrieben von Harald Pehl
  2. // Letze Änderung am 23.August.1993, 18:30:24
  3. // Version 1.00
  4. // compiliert mit MaxonC++
  5.  
  6.  
  7. // Includes
  8. #include <pragma/exec_lib.h>
  9. #include <pragma/dos_lib.h>
  10. #include <dos/dosextens.h>
  11. #include <dos/datetime.h>
  12. #include <exec/memory.h>
  13. #include <dos/dos.h>
  14. #include <stream.h>
  15. #include <stdlib.h>
  16. #include <string.h>
  17. #include <ctype.h>
  18. #include <stdio.h>
  19.  
  20.  
  21. // Funktionen
  22. void close_all (const char *, const int);
  23. char *itoa (int);
  24. void strrfil (char *, char *, const char, int);
  25. void strlfil (char *, char *, const char, int);
  26. BOOL readdir (char *);
  27. void usage ();
  28.  
  29.  
  30.  
  31. // Optionen für ReadArgs
  32. char *template = "ARGS/M,C=CLI/S,S=SINCE/K,U=UPTO/K,AS=ALPHASORT/S,"\
  33.                  "-AS=-ALPHASORT/S,SS=SIZESORT/S,-SS=-SIZESORT/S,"\
  34.                  "DS=DATESORT/S,-DS=-DATESORT/S,Q=QUICK/S,DO=DIRSONLY/S,"\
  35.                  "FO=FILESONLY/S,FF=FILESFIRST/S,SH=SHOWHIDDEN/S,NH=NOHEAD/S,"\
  36.                  "NI=NOINFO/S,NS=NOSIZE/S,NP=NOPROTECT/S,ND=NODATE/S,"\
  37.                  "NC=NOCOMMENT/S,V=VAR/K,HEADFORM/K,?=HELP/S";
  38.  
  39. struct Def
  40. {
  41.    char **argv;
  42.    long cli;
  43.    char *since;
  44.    char *upto;
  45.    long alphasort;
  46.    long alphasortdown;
  47.    long sizesort;
  48.    long sizesortdown;
  49.    long datesort;
  50.    long datesortdown;
  51.    long quick;
  52.    long dirsonly;
  53.    long filesonly;
  54.    long filesfirst;
  55.    long showhidden;
  56.    long nohead;
  57.    long noinfo;
  58.    long nosize;
  59.    long noprotect;
  60.    long nodate;
  61.    long nocomment;
  62.    char *var;
  63.    char *headform;
  64.    long help;
  65. } args = {NULL,  FALSE, FALSE, FALSE, NULL,  NULL,  FALSE, FALSE,
  66.           FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE,
  67.           FALSE, FALSE, FALSE, FALSE, FALSE, NULL,  "  <»--«>  ", FALSE};
  68.  
  69.  
  70.  
  71. struct RDArgs *rda = NULL;
  72. struct FileInfoBlock *fib = NULL;
  73. BOOL sincedate = TRUE, uptodate = TRUE;
  74. struct DateTime *dat = NULL, *since = NULL, *upto = NULL;
  75. char strdate[LEN_DATSTRING], strtime[LEN_DATSTRING], *pat = NULL;
  76.  
  77.  
  78. // Klasse, in der ein File bzw. Directory festgehalten wird
  79. class Entry
  80. {
  81.    Entry *prev, *next;
  82.    BOOL dir;
  83.    long size, days, mins;
  84.    char name[108], outstr[116];
  85.    
  86.    Entry ();
  87.    int compare (const Entry *) const;
  88.    friend class Lst;
  89. };
  90.  
  91.  
  92. Entry::Entry ()
  93. {
  94.    char *s = outstr;
  95.    
  96.    prev = next = NULL;
  97.    dir  = fib->fib_DirEntryType > 0 ? TRUE : FALSE;
  98.    size = fib->fib_Size;
  99.    days = fib->fib_Date.ds_Days;
  100.    mins = fib->fib_Date.ds_Minute;
  101.    strcpy (name, fib->fib_FileName);
  102.    memset (s, 0, 116);
  103.    if (args.quick)      // Jetzt outstr je nach Parameter mit Daten auffüllen
  104.    {
  105.       strcpy (outstr, name);
  106.       return;
  107.    }
  108.    strlfil (s, name, ' ', 25);
  109.    s += 24;
  110.    if (!args.nosize)
  111.    {
  112.       if (dir)
  113.       {
  114.          strncpy (s, "  (dir)   ", 11);
  115.          s += 10;
  116.       }
  117.       else
  118.       {
  119.          strrfil (s, itoa (size), ' ', 7);
  120.          strcat (s, "    "); 
  121.          s += 10;
  122.       }
  123.    }
  124.    if (!args.noprotect)
  125.    {
  126.       int i, j;
  127.       char p[] = "hsparwed";
  128.       
  129.       for (i = 128, j = 0 ; i >= 16 ; i >>= 1, j++, s++)
  130.          if (fib->fib_Protection & i)
  131.             *s = p[j];
  132.          else
  133.             *s = '-';
  134.       for (i = 8, j = 4 ; i >= 1 ; i >>= 1, j++, s++)
  135.          if (fib->fib_Protection & i)
  136.             *s = '-';
  137.          else
  138.             *s = p[j];
  139.       strcat (s, "    ");
  140.       s += 3;
  141.    }
  142.    if (!args.nodate)
  143.    {
  144.       dat->dat_Stamp = fib->fib_Date;
  145.       if (DateToStr (dat))
  146.       {
  147.          strlfil (s, dat->dat_StrDate, ' ', 11);
  148.          s += 10;
  149.          strlfil (s, dat->dat_StrTime, ' ', 12);
  150.          s += 11;
  151.       }
  152.    }
  153.    if (!args.nocomment)
  154.    {
  155.       if (*fib->fib_Comment != '\0')
  156.       {
  157.          strcat (s, "\n    ");
  158.          s += 4;
  159.          strncat (s, fib->fib_Comment, 40);
  160.       }
  161.    }
  162. }
  163.  
  164.  
  165. int Entry::compare (const Entry *that) const
  166. {
  167.    if (args.alphasort || args.alphasortdown)
  168.       return stricmp (name, that->name);
  169.    else if (args.sizesort || args.sizesortdown)
  170.       return size - that->size;
  171.    else if (args.datesort || args.datesortdown)
  172.       return (days - that->days) ? (days - that->days) : (mins - that->mins);
  173.       // Wenn die Differenz der zwei Daten 0 ist, dann wird die Differenz
  174.       // der zwei Zeitangaben zurückgegeben
  175.    else return -1;
  176. }
  177.  
  178.  
  179. // Klasse, die die Einträge enthält
  180. class Lst
  181. {
  182.    Entry *first, *last;
  183.    
  184.    public:
  185.    int count, bytes;
  186.    
  187.    Lst ();
  188.    ~Lst ();
  189.    void insert ();
  190.    void ausgabe () const;
  191.    BOOL empty () const;
  192. };
  193.  
  194.  
  195. Lst::Lst ()
  196. {
  197.    count = bytes = 0;
  198.    first = last = NULL;
  199. }
  200.  
  201.  
  202. Lst::~Lst ()
  203. {
  204.    Entry *e = first;
  205.    
  206.    while (e)
  207.    {
  208.       Entry *hilf = e;
  209.       e = e->next;
  210.       delete hilf;
  211.    }
  212. }
  213.  
  214.  
  215. void Lst::insert ()
  216. {
  217.    BOOL sort = FALSE;
  218.    Entry *pos = first, *neu = NULL;
  219.    
  220.    if (pat)             // Ist ein Pattern definiert?
  221.       if (MatchPatternNoCase (pat, fib->fib_FileName) == NULL)
  222.          return;
  223.    if (args.since)      // Gibt es eine since-Vorgabe
  224.    {
  225.       if (sincedate)
  226.       {
  227.          if (fib->fib_Date.ds_Days < since->dat_Stamp.ds_Days)
  228.             return;
  229.       }
  230.       else
  231.       {
  232.          if (fib->fib_Date.ds_Minute < since->dat_Stamp.ds_Minute)
  233.             return;
  234.       }
  235.    }
  236.    if (args.upto)       // Gibt es eine upto-Vorgabe
  237.    {
  238.       if (uptodate)
  239.       {
  240.          if (fib->fib_Date.ds_Days > upto->dat_Stamp.ds_Days)
  241.             return;
  242.       }
  243.       else
  244.       {
  245.          if (fib->fib_Date.ds_Minute > upto->dat_Stamp.ds_Minute)
  246.             return;
  247.       }
  248.    }
  249.    if (fib->fib_DirEntryType < 0)   // Ist der Eintrag ein File
  250.    {                                // und sind nur Dirs
  251.       if (args.dirsonly)            // zugelassen...
  252.          return;
  253.       if (args.noinfo && strstr (fib->fib_FileName, ".info"))
  254.          return;
  255.    }
  256.    else
  257.    {
  258.       if (args.filesonly)           // ...oder umgekehrt?
  259.          return;
  260.    }
  261.    if (!args.showhidden)            // Ist das 'h'-Bit gesetzt
  262.       if (fib->fib_Protection & FIBF_HIDDEN)
  263.          return;
  264.    neu = new Entry ();
  265.    if (neu == NULL)
  266.    {
  267.       cout << "\nKein Speicherplatz mehr!!\n\n";
  268.       return;
  269.    }
  270.    
  271.    // Sortieren falls nötig
  272.    if (args.alphasort || args.sizesort || args.datesort)
  273.    {
  274.       while (pos && neu->compare (pos) > 0)
  275.          pos = pos->next;
  276.       sort = TRUE;
  277.    }
  278.    else if (args.alphasortdown || args.sizesortdown || args.datesortdown)
  279.    {
  280.       while (pos && neu->compare (pos) < 0)
  281.          pos = pos->next;
  282.       sort = TRUE;
  283.    }
  284.    if (sort)
  285.    {
  286.       // und endlich einfügen
  287.       if (pos == NULL)
  288.       {
  289.          Entry *alt = last;
  290.  
  291.          if (alt != NULL)
  292.          {
  293.             alt->next = neu;
  294.             neu->prev = alt;
  295.             last = neu;
  296.          }
  297.          else
  298.          {
  299.             first = neu;
  300.             last = neu;
  301.          }
  302.       }
  303.       else
  304.       {
  305.          if (pos->prev == NULL)
  306.          {
  307.             pos->prev = neu;
  308.             neu->next = pos;
  309.             first = neu;
  310.          }
  311.          else
  312.          {
  313.             Entry *vor = pos->prev;
  314.             
  315.             vor->next = neu;
  316.             neu->prev = vor;
  317.             neu->next = pos;
  318.             pos->prev = neu;
  319.          }
  320.       }
  321.    }
  322.    else
  323.    {
  324.       Entry *alt = last;
  325.    
  326.       if (alt)
  327.       {
  328.          alt->next = neu;
  329.          neu->prev = alt;
  330.          last = neu;
  331.       }
  332.       else
  333.       {
  334.          first = neu;
  335.          last = neu;
  336.       }
  337.    }
  338.    count++;
  339.    if (!neu->dir)
  340.       bytes += neu->size;
  341.    return;
  342. }
  343.  
  344.  
  345. void Lst::ausgabe () const
  346. {
  347.    for (Entry *e = first ; e ; e = e->next)
  348.       cout << "   " << e->outstr << "\n";
  349. }
  350.  
  351.  
  352. BOOL Lst::empty () const
  353. {
  354.    return first || last ? FALSE : TRUE;
  355. }
  356.  
  357.  
  358.  
  359. void close_all (const char *why, const int how)
  360. {
  361.    if (why)    cout << why << "\n\n";
  362.    if (pat)    delete [] pat;
  363.    if (fib)    FreeDosObject (DOS_FIB, (APTR)fib);
  364.    if (upto)   FreeVec ((APTR)upto);
  365.    if (since)  FreeVec ((APTR)since);
  366.    if (dat)    FreeVec ((APTR)dat);
  367.    if (rda)    FreeArgs (rda);
  368.    exit (how);
  369. }
  370.  
  371.  
  372. char *itoa (int zahl)
  373. {
  374.    static char res[10];
  375.    char c, *dest = res;
  376.    int maxpot = 1000000, flag = 0;
  377.    
  378.    while (maxpot >= 1)
  379.    {
  380.       c = zahl / maxpot + '0';
  381.       if ((c != '0') || (maxpot == 1) || flag)
  382.       {
  383.          flag = 1;
  384.          *dest++ = c;
  385.       }
  386.       zahl %= maxpo