workbench/c/Sort.c

   1 /*
   2     Copyright © 1995-2014, 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 const TEXT version[] = "$VER: Sort 41.2 (3.4.2014)";
  76
  77 struct sorted_data
  78 {
  79   struct sorted_data * next;
  80   UBYTE              * data;
  81   ULONG                len; // length of line including '\n'.
  82 };
  83
  84 struct Locale * locale;
  85
  86 int compare(struct sorted_data * sd1,
  87             struct sorted_data * sd2,
  88             ULONG col,
  89             BOOL case_on)
  90 {
  91   ULONG len = MIN(sd1->len, sd2->len);
  92
  93   /* FIXME:  It seems like StrnCmp of locale does not work. */
  94 #if 1
  95   LONG retval = 0;
  96
  97   if (case_on)
  98   {
  99     int i = col;
 100
 101     while (i < len)
 102     {
 103       BOOL a,b;
 104       a = IsUpper(locale,(ULONG)*(sd1->data+col+i));
 105       b = IsUpper(locale,(ULONG)*(sd2->data+col+i));
 106
 107       if (a == b)
 108       {
 109         if (0 != (retval = StrnCmp(locale,
 110                            sd1->data+col,
 111                            sd2->data+col,
 112                            1,
 113                            SC_COLLATE2)))
 114           break;
 115       }
 116       else
 117       {
 118        retval = b - a;
 119        break;
 120       }
 121
 122       i++;
 123     }
 124   }
 125   else
 126   {
 127
 128     retval=StrnCmp(locale,
 129                    sd1->data+col,
 130                    sd2->data+col,
 131                    len,
 132                    SC_COLLATE2);
 133
 134     if (0 == retval)
 135     {
 136       if (sd1->len < sd2->len)
 137         retval = -100;
 138       else
 139         retval = +100;
 140     }
 141   }
 142
 143   return retval;
 144
 145 #else
 146   int i = col;
 147   char * str1 = sd1->data;
 148   char * str2 = sd2->data;
 149
 150   while (i < len)
 151   {
 152     if (str1[i] != str2[i])
 153       return (int)(str1[i] - str2[i]);
 154
 155     i++;
 156   }
 157
 158   return (int)sd1->len - (int)sd2->len;
 159 #endif
 160 }
 161
 162
 163 struct sorted_data * sort(UBYTE * data,
 164                           ULONG   data_len,
 165                           STRPTR  colstart,
 166                           BOOL    case_on,
 167                           BOOL    is_numeric)
 168 {
 169   ULONG pos = 0;
 170   ULONG col = 0;
 171   struct sorted_data * first = NULL;
 172   struct sorted_data * cur   = NULL;
 173   struct sorted_data * tooshort = NULL;
 174   struct sorted_data * tooshort_last = NULL;
 175
 176   if (colstart)
 177   {
 178     while (*colstart >= '0' && *colstart <= '9')
 179       col = col * 10 + *colstart++ - '0';
 180     if (col > 0)
 181       col-=1;
 182   }
 183
 184   while (pos < data_len)
 185   {
 186     ULONG begin = pos;
 187     ULONG len;
 188
 189     while (pos < data_len && data[pos] != 0x0a)
 190       pos++;
 191
 192     if (data[pos] == 0x0a || pos == data_len)
 193       len = pos++ - begin;
 194     else
 195       len = ++pos - begin;
 196
 197     cur = AllocMem(sizeof(struct sorted_data), MEMF_ANY|MEMF_CLEAR);
 198
 199     if (cur)
 200     {
 201       cur->data = data + begin;
 202       cur->len  = len;
 203
 204       if (len > col)
 205       {
 206         /*
 207         ** Insert it into the list of sorted lines
 208         */
 209         if (NULL != first)
 210         {
 211           /*
 212           ** To be first in the list?
 213           */
 214           if (compare(cur, first, col, case_on) < 0)
 215           {
 216             cur->next = first;
 217             first     = cur;
 218           }
 219           else
 220           {
 221             struct sorted_data * _cur = first;
 222
 223             while (1)
 224             {
 225               /*
 226               ** Insert it after the current one and before the
 227               ** next one?
 228               */
 229               if (NULL == _cur->next)
 230               {
 231                 _cur->next = cur;
 232                 break;
 233               }
 234               if (compare(cur, _cur->next, col, case_on) < 0)
 235               {
 236                 cur -> next = _cur->next;
 237                 _cur-> next = cur;
 238                 break;
 239               }
 240
 241               _cur = _cur->next;
 242             }
 243           }
 244         } /* if (NULL != first) */
 245         else
 246           first = cur;
 247       }
 248       else
 249       {
 250         /* this line is too short to sort it in */
 251         if (NULL == tooshort)
 252         {
 253           tooshort = cur;
 254           tooshort_last = cur;
 255         }
 256         else
 257         {
 258           tooshort_last->next = cur;
 259           tooshort_last = cur;
 260         }
 261       }
 262     } /* if (cur) */
 263
 264   }
 265
 266   if (NULL != tooshort)
 267   {
 268     tooshort_last->next = first;
 269     first = tooshort;
 270   }
 271
 272   return first;
 273 }
 274
 275
 276 LONG write_data(struct sorted_data * start, BPTR file_out)
 277 {
 278   BOOL write = TRUE;
 279   LONG error = 0;
 280   LONG count;
 281
 282   while (start)
 283   {
 284     struct sorted_data * next = start->next;
 285
 286     if (write)
 287     {
 288       count = Write(file_out, start->data, start->len);
 289       if (count != -1 && start->data[start->len-1] != 0x0a)
 290         count = Write(file_out, "\n", 1);
 291       if (count == -1)
 292       {
 293         error = IoErr();
 294         write = FALSE;
 295       }
 296     }
 297
 298     FreeMem(start, sizeof(struct sorted_data));
 299     start = next;
 300   }
 301
 302   return error;
 303 }
 304
 305 int __nocommandline;
 306
 307 int main (void)
 308 {
 309   IPTR args[ARG_NUM] = { (IPTR) NULL, (IPTR) NULL, (IPTR) NULL, FALSE, FALSE};
 310   struct RDArgs *rda;
 311   LONG result = RETURN_OK;
 312   LONG error = 0;
 313
 314   locale = OpenLocale(NULL);
 315   if (!locale)
 316   {
 317     PutStr("Could not open locale!\n");
 318     return RETURN_FAIL;
 319   }
 320
 321   rda = ReadArgs(TEMPLATE, args, NULL);
 322   if (rda)
 323   {
 324     BPTR lock_in;
 325     lock_in = Lock((STRPTR)args[ARG_FROM], ACCESS_READ);
 326
 327     if (lock_in)
 328     {
 329        BPTR file_out = Open((STRPTR)args[ARG_TO], MODE_NEWFILE);
 330        if (file_out == BNULL)
 331          error = IoErr();
 332        struct FileInfoBlock *fib = AllocDosObject(DOS_FIB, NULL);
 333        if (fib == NULL)
 334          error = IoErr();
 335
 336        if (error == 0)
 337        {
 338           UBYTE * data = NULL;
 339           BOOL success = Examine(lock_in, fib);
 340
 341           /*
 342           ** Read the input file into memory
 343           */
 344           if (fib->fib_Size && success)
 345             data = AllocVec(fib->fib_Size, MEMF_ANY);
 346
 347           if (data)
 348           {
 349             BPTR in;
 350             if ((in = OpenFromLock(lock_in))) {
 351                 ULONG read = Read(in, data, fib->fib_Size);
 352
 353                 if (-1 != read)
 354                 {
 355                   struct sorted_data * sd;
 356                   sd = sort(data,
 357                             fib->fib_Size,
 358                             (STRPTR)args[ARG_COLSTART],
 359                             (BOOL)args[ARG_CASE],
 360                             (BOOL)args[ARG_NUMERIC]);
 361
 362                   error = write_data(sd, file_out);
 363                 }
 364                 Close(in);
 365                 lock_in = BNULL;
 366             }
 367             FreeVec(data);
 368           }
 369           else
 370             error = IoErr();
 371
 372           Close(file_out);
 373        }
 374        FreeDosObject(DOS_FIB, fib);
 375        if (lock_in)
 376            UnLock(lock_in);
 377     }
 378     else
 379       error = IoErr();
 380     FreeArgs(rda);
 381   }
 382   else
 383     error = IoErr();
 384
 385   if (error)
 386   {
 387     PrintFault(error, "Sort");
 388     result = RETURN_FAIL;
 389   }
 390
 391   return result;
 392 }