workbench/c/Sort.c

   1 /*
   2     Copyright © 1995-2001, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Sorts the contents of a file
   6     Lang: English
   7 */
   8 /*****************************************************************************
   9
  10     NAME
  11
  12         Sort
  13
  14     SYNOPSIS
  15
  16         FROM/A,TO/A,COLSTART/K,CASE/S,NUMERIC/S
  17
  18     LOCATION
  19
  20         C:
  21
  22     FUNCTION
  23
  24         Sorts the contents of a text file
  25
  26     INPUTS
  27
  28         FROM      -- file to read from
  29         TO        -- file to output to
  30         COLSTART  -- column at which the comparison begins
  31         CASE      -- sort is case sensitive. Uppercase items are output first
  32         NUMERIC   -- lines are interpreted as numbers
  33
  34     RESULT
  35
  36     EXAMPLE
  37
  38     BUGS
  39
  40     SEE ALSO
  41
  42     INTERNALS
  43
  44     HISTORY
  45
  46 ******************************************************************************/
  47
  48 #include <clib/macros.h>
  49 #include <exec/memory.h>
  50 #include <exec/types.h>
  51 #include <dos/dos.h>
  52 #include <dos/exall.h>
  53 #include <proto/dos.h>
  54 #include <proto/exec.h>
  55 #include <proto/utility.h>
  56 #include <proto/locale.h>
  57 #include <libraries/locale.h>
  58 #include <utility/tagitem.h>
  59
  60 #define DEBUG 0
  61 #include <aros/debug.h>
  62
  63 #include <string.h>
  64
  65 #define TEMPLATE "FROM/A,TO/A,COLSTART/K,CASE/S,NUMERIC/S"
  66
  67 #define ARG_FROM        0
  68 #define ARG_TO          1
  69 #define ARG_COLSTART    2
  70 #define ARG_CASE        3
  71 #define ARG_NUMERIC     4
  72
  73 #define ARG_NUM         5
  74
  75 struct sorted_data
  76 {
  77   struct sorted_data * next;
  78   UBYTE              * data;
  79   ULONG                len; // length of line including '\n'.
  80 };
  81
  82 struct Locale * locale;
  83
  84 int compare(struct sorted_data * sd1,
  85             struct sorted_data * sd2,
  86             ULONG col,
  87             BOOL case_on)
  88 {
  89   ULONG len = MIN(sd1->len, sd2->len);
  90
  91   /* FIXME:  It seems like StrnCmp of locale does not work. */
  92 #if 1
  93   LONG retval = 0;
  94
  95   if (TRUE == case_on)
  96   {
  97     int i = col;
  98
  99     while (i < len)
 100     {
 101       BOOL a,b;
 102       a = IsUpper(locale,(ULONG)*(sd1->data+col+i));
 103       b = IsUpper(locale,(ULONG)*(sd2->data+col+i));
 104
 105       if (a == b)
 106       {
 107         if (0 != (retval = StrnCmp(locale,
 108                            sd1->data+col,
 109                            sd2->data+col,
 110                            1,
 111                            SC_COLLATE2)));
 112           break;
 113       }
 114       else
 115       {
 116        retval = b - a;
 117        break;
 118       }
 119
 120       i++;
 121     }
 122   }
 123   else
 124   {
 125
 126     retval=StrnCmp(locale,
 127                    sd1->data+col,
 128                    sd2->data+col,
 129                    len,
 130                    SC_COLLATE2);
 131
 132     if (0 == retval)
 133     {
 134       if (sd1->len < sd2->len)
 135         retval = -100;
 136       else
 137         retval = +100;
 138     }
 139   }
 140
 141   return retval;
 142
 143 #else
 144   int i = col;
 145   char * str1 = sd1->data;
 146   char * str2 = sd2->data;
 147
 148   while (i < len)
 149   {
 150     if (str1[i] != str2[i])
 151       return (int)(str1[i] - str2[i]);
 152
 153     i++;
 154   }
 155
 156   return (int)sd1->len - (int)sd2->len;
 157 #endif
 158 }
 159
 160
 161 struct sorted_data * sort(UBYTE * data,
 162                           ULONG   data_len,
 163                           STRPTR  colstart,
 164                           BOOL    case_on,
 165                           BOOL    is_numeric)
 166 {
 167   ULONG pos = 0;
 168   ULONG col = 0;
 169   struct sorted_data * first = NULL;
 170   struct sorted_data * cur   = NULL;
 171   struct sorted_data * tooshort = NULL;
 172   struct sorted_data * tooshort_last = NULL;
 173
 174   if (colstart)
 175   {
 176     while (*colstart >= '0' && *colstart <= '9')
 177       col = col * 10 + *colstart++ - '0';
 178     if (col > 0)
 179       col-=1;
 180   }
 181
 182   while (pos < data_len)
 183   {
 184     ULONG begin = pos;
 185     ULONG len;
 186
 187     while (pos < data_len && data[pos] != 0x0a)
 188       pos++;
 189
 190     if (data[pos] == 0x0a || pos == data_len)
 191       len = pos++ - begin;
 192     else
 193       len = ++pos - begin;
 194
 195     cur = AllocMem(sizeof(struct sorted_data), MEMF_ANY|MEMF_CLEAR);
 196
 197     if (cur)
 198     {
 199       cur->data = data + begin;
 200       cur->len  = len;
 201
 202       if (len > col)
 203       {
 204         /*
 205         ** Insert it into the list of sorted lines
 206         */
 207         if (NULL != first)
 208         {
 209           /*
 210           ** To be first in the list?
 211           */
 212           if (compare(cur, first, col, case_on) < 0)
 213           {
 214             cur->next = first;
 215             first     = cur;
 216           }
 217           else
 218           {
 219             struct sorted_data * _cur = first;
 220
 221             while (1)
 222             {
 223               /*
 224               ** Insert it after the current one and before the
 225               ** next one?
 226               */
 227               if (NULL == _cur->next)
 228               {
 229                 _cur->next = cur;
 230                 break;
 231               }
 232               if (compare(cur, _cur->next, col, case_on) < 0)
 233               {
 234                 cur -> next = _cur->next;
 235                 _cur-> next = cur;
 236                 break;
 237               }
 238
 239               _cur = _cur->next;
 240             }
 241           }
 242         } /* if (NULL != first) */
 243         else
 244           first = cur;
 245       }
 246       else
 247       {
 248         /* this line is too short to sort it in */
 249         if (NULL == tooshort)
 250         {
 251           tooshort = cur;
 252           tooshort_last = cur;
 253         }
 254         else
 255         {
 256           tooshort_last->next = cur;
 257           tooshort_last = cur;
 258         }
 259       }
 260     } /* if (cur) */
 261
 262   }
 263
 264   if (NULL != tooshort)
 265   {
 266     tooshort_last->next = first;
 267     first = tooshort;
 268   }
 269
 270   return first;
 271 }
 272
 273
 274 ULONG write_data(struct sorted_data * start, BPTR file_out)
 275 {
 276   BOOL write = TRUE;
 277   ULONG error = 0;
 278
 279   while (start)
 280   {
 281     struct sorted_data * next = start->next;
 282
 283     if (TRUE == write)
 284     {
 285       error = Write(file_out, start->data, start->len);
 286       if (-1 != error && start->data[start->len-1] != 0x0a)
 287         error = Write(file_out, "\n", 1);
 288     }
 289
 290     if (-1 == error)
 291       write = FALSE;
 292
 293     FreeMem(start, sizeof(struct sorted_data));
 294     start = next;
 295   }
 296
 297   if (FALSE == write)
 298     return error;
 299
 300   return 0;
 301 }
 302
 303 int __nocommandline;
 304
 305 int main (void)
 306 {
 307   IPTR args[ARG_NUM] = { (IPTR) NULL, (IPTR) NULL, (IPTR) NULL, FALSE, FALSE};
 308   struct RDArgs *rda;
 309   ULONG error = 0;
 310
 311   locale = OpenLocale(NULL);
 312   if (!locale)
 313   {
 314     PutStr("Could not open locale!\n");
 315     return -1;
 316   }
 317
 318   rda = ReadArgs(TEMPLATE, args, NULL);
 319   if (rda)
 320   {
 321     BPTR lock_in;
 322     lock_in = Lock((STRPTR)args[ARG_FROM], ACCESS_READ);
 323
 324     if (lock_in)
 325     {
 326        BPTR file_out = Open((STRPTR)args[ARG_TO], MODE_NEWFILE);
 327        struct FileInfoBlock *fib = AllocDosObject(DOS_FIB, NULL);
 328
 329        if (BNULL != file_out && fib)
 330        {
 331           UBYTE * data = NULL;
 332           BOOL success = Examine(lock_in, fib);
 333
 334           /*
 335           ** Read  the input file into memory
 336           */
 337           if (fib->fib_Size && success)
 338             data = AllocVec(fib->fib_Size, MEMF_ANY);
 339
 340           if (data)
 341           {
 342             BPTR in;
 343             if ((in = OpenFromLock(lock_in))) {
 344                 ULONG read = Read(in, data, fib->fib_Size);
 345
 346                 if (-1 != read)
 347                 {
 348                   struct sorted_data * sd;
 349                   sd = sort(data,
 350                             fib->fib_Size,
 351                             (STRPTR)args[ARG_COLSTART],
 352                             (BOOL)args[ARG_CASE],
 353                             (BOOL)args[ARG_NUMERIC]);
 354
 355                   error = write_data(sd, file_out);
 356                 }
 357                 Close(in);
 358                 lock_in = BNULL;
 359             }
 360             FreeVec(data);
 361           }/*  if (data) */
 362
 363           Close(file_out);
 364        } /* if (file_out) */
 365        FreeDosObject(DOS_FIB, fib);
 366        if (lock_in)
 367            UnLock(lock_in);
 368     } /* if (lock_in) */
 369     FreeArgs(rda);
 370   }
 371   else
 372     error=RETURN_FAIL;
 373
 374   if (error)
 375     PrintFault(IoErr(), "Sort");
 376
 377   return error;
 378 }