workbench/c/Search.c

   1 /*
   2     Copyright © 1995-2008, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 /*****************************************************************************
   7
   8     NAME
   9
  10     Search
  11
  12     SYNOPSIS
  13
  14     Search [FROM] {(name | pattern} [SEARCH] (string | pattern) [ALL]
  15            [NONUM] [QUIET] [QUICK] [FILE] [PATTERN] [LINES=Number]
  16
  17     LOCATION
  18
  19     C:
  20
  21     FUNCTION
  22
  23     Search looks through the files contained in the FROM directory for
  24     a specified string (SEARCH); in case the ALL switch is specified,
  25     the subdirectories of the FROM directory are also searched. The name
  26     of all files containing the SEARCH string is displayed together with
  27     the numbers of the lines where the string occurred.
  28         If CTRL-C is pressed, the search will be abandoned. CTRL-D will
  29     abandon searching the current file.
  30
  31     INPUTS
  32
  33     NONUM    --  no line numbers are printed
  34     QUIET    --  don't display the name of the file being searched
  35     QUICK    --  more compact output
  36     FILE     --  look for a file with a specific name rather than a string
  37                  in a file
  38     PATTERN  --  use pattern matching when searching
  39     CASE     --  use case sensitive pattern matching when searching
  40     LINES    --  extra lines after a line match which should be shown
  41
  42     RESULT
  43
  44     If the object is found, the condition flag is set to 0. Otherwise it's
  45     set to WARN.
  46
  47     NOTES
  48
  49     EXAMPLE
  50
  51     BUGS
  52
  53     SEE ALSO
  54
  55     INTERNALS
  56
  57     HISTORY
  58
  59     Author: Neil Cafferkey
  60     Placed in the public domain by Neil Cafferkey.
  61     Changes by: Johan 'S.Duvan' Alfredsson
  62
  63 ******************************************************************************/
  64
  65 #include <proto/exec.h>
  66 #include <proto/dos.h>
  67 #include <proto/locale.h>
  68 #include <exec/memory.h>
  69 #include <dos/dos.h>
  70 #include <libraries/locale.h>
  71
  72 #include <string.h>
  73
  74 // *****  Layout and version parameters  ***********
  75
  76 #define LOCALE_VERSION   38
  77 #define PATH_BUF_SIZE    512
  78 #define SPACES_SIZE      (160 + 1)
  79 #define MARGIN           3
  80 #define INDENT           5
  81 #define DIR_MARGIN       2
  82
  83
  84 // *****  Command line arguments *******************
  85
  86 enum
  87 {
  88     ARG_FROM,
  89     ARG_SEARCH,
  90     ARG_ALL,
  91     ARG_NONUM,
  92     ARG_QUIET,
  93     ARG_QUICK,
  94     ARG_FILE,
  95     ARG_PATTERN,
  96     ARG_CASE,
  97     ARG_LINES,
  98     ARG_COUNT
  99 };
 100
 101 int LocaleBase_version = LOCALE_VERSION;
 102
 103 // *****  Prototypes for internal functions  *******
 104
 105 VOID  PrintFullName(TEXT *buffer, UWORD cut_off, struct AnchorPath *anchor);
 106 UWORD GetDirName(struct AnchorPath *anchor, TEXT *buffer);
 107 BOOL  FindString(struct AnchorPath *anchor, IPTR *args, TEXT *pattern,
 108                  struct Locale *locale, UBYTE *pi);
 109 BOOL  MatchStringNoCase(TEXT *string, TEXT *text, TEXT *text_end, UBYTE *pi,
 110                         struct Locale *locale);
 111 BOOL MatchString(TEXT *string, TEXT *text, TEXT *text_end, UBYTE *pi,
 112                  struct Locale *locale);
 113
 114
 115 // *****  String information (version, messages) ***
 116
 117 const TEXT template[] =
 118      "FROM/M,SEARCH/A,ALL/S,NONUM/S,QUIET/S,QUICK/S,FILE/S,PATTERN/S,CASE/S,LINES/N";
 119 const TEXT version_string[] = "$VER: Search 42.4 (6.4.2008)";
 120 const TEXT locale_name[]    = "locale.library";
 121
 122 const TEXT control_codes[]  = { 0x9b, 'K', 13 };
 123 const TEXT wild_card[]      = { '#', '?'};
 124 const TEXT new_line[]       = "\n";
 125 const TEXT abandon_msg[]    = "** File abandoned\n";
 126
 127 const STRPTR default_from[] = {"", 0};
 128
 129 int __nocommandline;
 130
 131 int main(void)
 132 {
 133     IPTR              args[ARG_COUNT] = {0};
 134     struct RDArgs     *read_args;
 135     struct AnchorPath *anchor;
 136     LONG               error;
 137     LONG               return_code = RETURN_WARN;
 138     TEXT              *text, *spaces, *pattern = NULL, *path_buffer,
 139                       *user_pattern = NULL, *p, ch, **from;
 140     BOOL               found, success = TRUE, new_dir, print_names;
 141     UWORD              indent = 0, pat_buf_length = 0, cut_off = 0, pat_length = 0;
 142     UBYTE              k, q;
 143     struct Locale     *locale;
 144
 145     /* Allocate buffers */
 146
 147     spaces      = AllocMem(SPACES_SIZE, MEMF_CLEAR);
 148     anchor      = AllocMem(sizeof(struct AnchorPath), MEMF_CLEAR);
 149     path_buffer = AllocMem(PATH_BUF_SIZE,MEMF_ANY);
 150
 151     if(anchor && spaces && path_buffer)
 152     {
 153         locale = OpenLocale(NULL);
 154
 155         for(text = spaces + SPACES_SIZE - 1; text > spaces; *(--text) = ' ');
 156
 157         /* Parse arguments */
 158
 159         read_args = ReadArgs((STRPTR)template, args, NULL);
 160
 161         if(locale && read_args)
 162         {
 163             if ( ! args[ARG_FROM] )
 164             {
 165                 /* /M ignores the default value, so we must set it after
 166                    ReadArgs() */
 167                 args[ARG_FROM] = (IPTR)default_from;
 168             }
 169
 170             /* Prepare the pattern to be matched */
 171
 172             pat_length = strlen((TEXT *)args[ARG_SEARCH]);
 173             pat_buf_length = pat_length * 2 + 3;
 174             user_pattern = AllocMem(pat_length + 5, MEMF_CLEAR);
 175             pattern = AllocMem(pat_buf_length, MEMF_ANY);
 176
 177             if(user_pattern && pattern)
 178             {
 179                 if(args[ARG_PATTERN] || args[ARG_FILE])
 180                 {
 181                     if(args[ARG_FILE])
 182                         text = user_pattern;
 183                     else
 184                     {
 185                         text = user_pattern + 2;
 186                         CopyMem(wild_card, user_pattern, 2);
 187                         CopyMem(wild_card, text + pat_length, 2);
 188                     }
 189
 190                     CopyMem((TEXT *)args[ARG_SEARCH], text, pat_length);
 191                     if (args[ARG_CASE])
 192                     {
 193                         if (ParsePattern(user_pattern, pattern, pat_buf_length) < 0)
 194                         {
 195                                 success = FALSE;
 196                         }
 197                     }
 198                     else
 199                     {
 200                         if(ParsePatternNoCase(user_pattern, pattern,
 201                             pat_buf_length) < 0)
 202                             success = FALSE;
 203                     }
 204                 }
 205                 else
 206                 {
 207                     /* Copy the search string and convert it to uppercase */
 208
 209                     text = pattern;
 210
 211                     for(p = (TEXT *)args[ARG_SEARCH]; (ch = *p) != '\0'; p++)
 212                         *(text++) = ConvToUpper(locale, ch);
 213
 214                     *text = '\0';
 215
 216                     /* Construct prefix table for Knuth-Morris-Pratt
 217                        algorithm */
 218
 219                     *user_pattern = 0;
 220                     k = 0;
 221
 222                     for(q = 1; q < pat_length; q++)
 223                     {
 224                         while(k && (pattern[k] != pattern[q]))
 225                             k = user_pattern[k - 1];
 226
 227                         if(pattern[k] == pattern[q])
 228                             k++;
 229
 230                         user_pattern[q] = k;
 231                     }
 232                 }
 233             }
 234             else
 235                 success = FALSE;
 236
 237             /* Get the next starting point */
 238
 239             for(from = (TEXT **)args[ARG_FROM]; from && *from && success;
 240                 from++)
 241             {
 242
 243                 /* Initialise file search */
 244
 245                 anchor->ap_BreakBits = SIGBREAKF_CTRL_C;
 246                 anchor->ap_FoundBreak = 0;
 247                 anchor->ap_Flags = 0;
 248                 error = MatchFirst(*from, anchor);
 249
 250                 /* Work out if more than one file is being searched */
 251
 252                 print_names = ((TEXT **)args[ARG_FROM])[1]
 253                     || (anchor->ap_Flags & APF_ITSWILD);
 254
 255                 /* Enter sub-dir if the pattern was an explicitly named dir */
 256
 257                 if(!(anchor->ap_Flags & APF_ITSWILD)
 258                    && (anchor->ap_Info.fib_DirEntryType > 0))
 259                     anchor->ap_Flags |= APF_DODIR;
 260
 261                 /* Set flag to get name of starting directory */
 262
 263                 new_dir = TRUE;
 264
 265                 /* Traverse the directory */
 266
 267                 while(!error && success)
 268                 {
 269                     found = FALSE;
 270
 271                     if(anchor->ap_Info.fib_DirEntryType > 0)
 272                     {
 273                         /* Enter sub-dir if the ALL switch was supplied and
 274                            we're not on the way out of it */
 275
 276                         if(!(anchor->ap_Flags & APF_DIDDIR))
 277                         {
 278                             if(!(args[ARG_FILE] || args[ARG_QUIET] ||
 279                                  args[ARG_QUICK]))
 280                             {
 281                                 WriteChars(spaces, MARGIN + INDENT * indent +
 282                                            DIR_MARGIN);
 283                                 text = (TEXT *)&(anchor->ap_Info.fib_FileName);
 284                                 VPrintf("%s (dir)\n", (IPTR *)&text);
 285                             }
 286
 287                             if(args[ARG_ALL] || (anchor->ap_Flags & APF_DODIR))
 288                             {
 289                                 anchor->ap_Flags |= APF_DODIR;
 290                                 indent++;
 291                                 print_names = TRUE;
 292                             }
 293                         }
 294                         else
 295                         {
 296                             indent--;
 297                         }
 298
 299                         new_dir = TRUE;
 300                         anchor->ap_Flags &= ~APF_DIDDIR;
 301                     }
 302                     else
 303                     {
 304                         /* Deal with a file */
 305
 306                         if(anchor->ap_Flags & APF_DirChanged)
 307                             new_dir = TRUE;
 308
 309                         if(new_dir)
 310                         {
 311                             if(!(cut_off = GetDirName(anchor, path_buffer)))
 312                                 success = FALSE;
 313
 314                             new_dir = FALSE;
 315                         }
 316
 317                         if(args[ARG_FILE])
 318                         {
 319                             found = MatchPatternNoCase(pattern,
 320                                 (TEXT *)&(anchor->ap_Info.fib_FileName));
 321                         }
 322                         else
 323                         {
 324                             if(args[ARG_QUICK])
 325                             {
 326                                 PrintFullName(path_buffer, cut_off, anchor);
 327                                 WriteChars((STRPTR)control_codes, 3);
 328                             }
 329                             else if(!args[ARG_QUIET] && print_names)
 330                             {
 331                                 WriteChars(spaces, MARGIN + INDENT*indent);
 332                                 text = (TEXT *)&(anchor->ap_Info.fib_FileName);
 333                                 VPrintf("%s..\n", (IPTR *)&text);
 334                             }
 335
 336                             found = FindString(anchor, args, pattern, locale,
 337                                                user_pattern);
 338                         }
 339
 340                         if(found)
 341                         {
 342                             if((args[ARG_FILE] || args[ARG_QUIET]) &&
 343                                !args[ARG_QUICK])
 344                             {
 345                                 PrintFullName(path_buffer, cut_off, anchor);
 346                                 PutStr(new_line);
 347                             }
 348
 349                             return_code = RETURN_OK;
 350                         }
 351                     }
 352
 353                     error = MatchNext(anchor);
 354
 355                     if(error && (error != ERROR_NO_MORE_ENTRIES))
 356                     {
 357                         success = FALSE;
 358                         SetIoErr(error);
 359                     }
 360                 }
 361             }
 362
 363             /* Clear line for next shell prompt */
 364
 365             if(args[ARG_QUICK] && !args[ARG_FILE])
 366                 WriteChars((STRPTR)control_codes, 2);
 367
 368             MatchEnd(anchor);
 369
 370             if(success)
 371                 SetIoErr(0);
 372         }
 373
 374         FreeArgs(read_args);
 375
 376         CloseLocale(locale);
 377     }
 378     else
 379     {
 380         SetIoErr(ERROR_NO_FREE_STORE);
 381     }
 382
 383     /* Free memory */
 384
 385     if(anchor)
 386         FreeMem(anchor, sizeof(struct AnchorPath));
 387     if(spaces)
 388         FreeMem(spaces, SPACES_SIZE);
 389     if(path_buffer)
 390         FreeMem(path_buffer, PATH_BUF_SIZE);
 391     if(user_pattern)
 392         FreeMem(user_pattern, pat_length + 5);
 393     if(pattern)
 394         FreeMem(pattern, pat_buf_length);
 395
 396     /* Check and reset signals */
 397
 398     if(SetSignal(0, -1) & SIGBREAKF_CTRL_C)
 399         SetIoErr(ERROR_BREAK);
 400
 401     /* Exit */
 402
 403     if((error = IoErr()) != 0)
 404     {
 405         PrintFault(error, NULL);
 406         return RETURN_FAIL;
 407     }
 408
 409     return return_code;
 410 }
 411
 412
 413
 414 VOID PrintFullName(TEXT *buffer, UWORD cut_off, struct AnchorPath *anchor)
 415 {
 416     buffer[cut_off] = '\0';
 417
 418     if(AddPart(buffer, (TEXT *)&(anchor->ap_Info.fib_FileName), PATH_BUF_SIZE))
 419     {
 420         PutStr(buffer);
 421     }
 422
 423     return;
 424 }
 425
 426
 427 UWORD GetDirName(struct AnchorPath *anchor, TEXT *buffer)
 428 {
 429     if(NameFromLock(anchor->ap_Current->an_Lock, buffer, PATH_BUF_SIZE))
 430         return strlen(buffer);
 431
 432     return 0;
 433 }
 434
 435
 436 BOOL FindString(struct AnchorPath *anchor, IPTR *args, TEXT *pattern,
 437                 struct Locale *locale, UBYTE *pi)
 438 {
 439     BOOL   found = FALSE, end_early = FALSE, line_matches, at_end;
 440     BPTR   old_lock, file;
 441     TEXT  *p, *q, *r, *line, *buffer = NULL, ch;
 442     ULONG  max_line_length = 0, line_length, offset = 0, file_size, buf_size,
 443            line_start = 0, line_count = 1, sigs, lines_to_show = 0;
 444     LONG   read_length = 1;
 445
 446     /* Move into the file's directory */
 447
 448     old_lock = CurrentDir(anchor->ap_Current->an_Lock);
 449
 450     /* Open the file for reading */
 451
 452     if((file = Open(anchor->ap_Info.fib_FileName, MODE_OLDFILE)) != BNULL)
 453     {
 454         /* Get a buffer for the file */
 455
 456         file_size = anchor->ap_Info.fib_Size;
 457         buf_size  = file_size + 1;
 458
 459         while(!buffer && buf_size)
 460         {
 461             if(!(buffer = AllocMem(buf_size, MEMF_ANY)))
 462                 buf_size >>= 1;
 463         }
 464
 465         /* Check size of buffer */
 466
 467         if((buf_size <= file_size) && buffer)
 468         {
 469             /* Get length of longest line */
 470
 471             while(read_length > 0)
 472             {
 473                 read_length = Read(file, buffer, buf_size - 1);
 474                 q = buffer + read_length;
 475
 476                 if(!read_length)
 477                     q++;
 478
 479                 for(p = buffer; p < q; p++)
 480                 {
 481                     if((*p=='\n')||!read_length)
 482                     {
 483                         line_length = offset + (p - buffer) - line_start;
 484
 485                         if(line_length > max_line_length)
 486                             max_line_length = line_length;
 487
 488                         line_start = offset + (p - buffer) + 1;
 489                     }
 490                 }
 491
 492                 offset += read_length;
 493             }
 494
 495             /* Ensure buffer is big enough for longest line */
 496
 497             if(buf_size <= max_line_length)
 498             {
 499                 FreeMem(buffer, buf_size);
 500                 buf_size = max_line_length + 1;
 501                 buffer = AllocMem(buf_size, MEMF_ANY);
 502             }
 503         }
 504
 505         /* Test every line against the pattern */
 506
 507         if(buffer && pattern)
 508         {
 509
 510             read_length = Seek(file, 0, OFFSET_BEGINNING) + 1;
 511
 512             while(((read_length = Read(file, buffer, buf_size - 1)) > 0) &&
 513                   !end_early)
 514             {
 515                 q = buffer + read_length;
 516                 at_end = Seek(file, 0, OFFSET_CURRENT) == file_size;
 517
 518                 if(at_end)
 519                     *(q++) = '\0';
 520
 521                 line = buffer;
 522
 523                 for(p = buffer; (p < q) && !end_early; p++)
 524                 {
 525                     ch = *p;
 526
 527                     if((ch == '\n') || (ch == '\0'))
 528                     {
 529                         *p = '\0';
 530
 531                         if (args[ARG_CASE])
 532                         {
 533                             if (args[ARG_PATTERN])
 534                                 line_matches = MatchPattern(pattern, line);
 535                             else
 536                                 line_matches = MatchString(pattern, line, p, pi, locale);
 537                         }
 538                         else
 539                         {
 540                             if(args[ARG_PATTERN])
 541                                 line_matches = MatchPatternNoCase(pattern, line);
 542                             else
 543                                 line_matches = MatchStringNoCase(pattern, line, p, pi, locale);
 544                         }
 545                         if(line_matches)
 546                         {
 547                             if(!found && args[ARG_QUICK])
 548                                 PutStr(new_line);
 549
 550                             found = TRUE;
 551
 552                             if(args[ARG_QUIET])
 553                             {
 554                                 end_early = TRUE;
 555                             }
 556                             else
 557                             {
 558                                 if(!args[ARG_NONUM])
 559                                     VPrintf("%6lu ", (IPTR *)&line_count);
 560
 561                                 /* Replace invisible characters with dots */
 562
 563                                 for(r = line; r < p; r++)
 564                                 {
 565                                     if(!IsPrint(locale, *r))
 566                                         *r = '.';
 567                                 }
 568
 569                                 VPrintf("%s\n", (IPTR *)&line);
 570                                 if (args[ARG_LINES])
 571                                 {
 572                                     lines_to_show =
 573                                         *((ULONG *) args[ARG_LINES]);
 574                                 }
 575                             }
 576                         }
 577                         else
 578                         {
 579                             if (lines_to_show != 0)
 580                             {
 581                                 Printf("%6lu: ", line_count);
 582
 583                                 /* Replace invisible characters with dots */
 584
 585                                 for (r = line; r < p; r++)
 586                                 {
 587                                     if (!IsPrint(locale, *r))
 588                                         *r = '.';
 589                                 }
 590                                 PutStr(line);
 591                                 PutStr("\n");
 592                                 lines_to_show--;
 593                             }
 594                         }
 595                         line = p + 1;
 596
 597                         if(ch == '\n')
 598                             line_count++;
 599
 600                         sigs = SetSignal(0, SIGBREAKF_CTRL_D);
 601
 602                         if(sigs & (SIGBREAKF_CTRL_C | SIGBREAKF_CTRL_D))
 603                         {
 604                             end_early = TRUE;
 605
 606                             if(sigs & SIGBREAKF_CTRL_D)
 607                             {
 608                                 PutStr(abandon_msg);
 609                             }
 610                         }
 611                     }
 612                 }
 613
 614                 /* Start reading again at start of most recent line */
 615
 616                 if(!at_end)
 617                     Seek(file, line - q, OFFSET_CURRENT);
 618             }
 619         }
 620
 621         if(buffer)
 622             FreeMem(buffer, buf_size);
 623
 624         Close(file);
 625     }
 626
 627     CurrentDir(old_lock);
 628
 629     return found;
 630 }
 631
 632
 633 BOOL MatchStringNoCase(TEXT *string, TEXT *text, TEXT *text_end, UBYTE *pi,
 634                        struct Locale *locale)
 635 {
 636     TEXT *s, ch;
 637
 638     s = string;
 639
 640     while(text < text_end)
 641     {
 642         ch = ConvToUpper(locale, *(text++));
 643
 644         while((s != string) && (*s != ch))
 645             s = string + pi[s - string - 1];
 646
 647         if(ch == *s)
 648             s++;
 649
 650         if(!*s)
 651             return TRUE;
 652     }
 653
 654     return FALSE;
 655 }
 656
 657 BOOL MatchString(TEXT *string, TEXT *text, TEXT *text_end, UBYTE *pi,
 658                  struct Locale *locale)
 659 {
 660         TEXT *s, ch;
 661
 662         s = string;
 663
 664         while (text < text_end)
 665         {
 666                 ch = *(text++);
 667
 668                 while ((s != string) && (*s != ch))
 669                         s = string + pi[s - string - 1];
 670
 671                 if (ch == *s)
 672                         s++;
 673
 674                 if (!*s)
 675                         return TRUE;
 676         }
 677
 678         return FALSE;
 679 }
 680
 681