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                                 Printf("%s (dir)\n", &anchor->ap_Info.fib_FileName[0]);
 284                             }
 285
 286                             if(args[ARG_ALL] || (anchor->ap_Flags & APF_DODIR))
 287                             {
 288                                 anchor->ap_Flags |= APF_DODIR;
 289                                 indent++;
 290                                 print_names = TRUE;
 291                             }
 292                         }
 293                         else
 294                         {
 295                             indent--;
 296                         }
 297
 298                         new_dir = TRUE;
 299                         anchor->ap_Flags &= ~APF_DIDDIR;
 300                     }
 301                     else
 302                     {
 303                         /* Deal with a file */
 304
 305                         if(anchor->ap_Flags & APF_DirChanged)
 306                             new_dir = TRUE;
 307
 308                         if(new_dir)
 309                         {
 310                             if(!(cut_off = GetDirName(anchor, path_buffer)))
 311                                 success = FALSE;
 312
 313                             new_dir = FALSE;
 314                         }
 315
 316                         if(args[ARG_FILE])
 317                         {
 318                             found = MatchPatternNoCase(pattern,
 319                                 (TEXT *)&(anchor->ap_Info.fib_FileName));
 320                         }
 321                         else
 322                         {
 323                             if(args[ARG_QUICK])
 324                             {
 325                                 PrintFullName(path_buffer, cut_off, anchor);
 326                                 WriteChars((STRPTR)control_codes, 3);
 327                             }
 328                             else if(!args[ARG_QUIET] && print_names)
 329                             {
 330                                 WriteChars(spaces, MARGIN + INDENT*indent);
 331                                 Printf("%s..\n", &anchor->ap_Info.fib_FileName[0]);
 332                             }
 333
 334                             found = FindString(anchor, args, pattern, locale,
 335                                                user_pattern);
 336                         }
 337
 338                         if(found)
 339                         {
 340                             if((args[ARG_FILE] || args[ARG_QUIET]) &&
 341                                !args[ARG_QUICK])
 342                             {
 343                                 PrintFullName(path_buffer, cut_off, anchor);
 344                                 PutStr(new_line);
 345                             }
 346
 347                             return_code = RETURN_OK;
 348                         }
 349                     }
 350
 351                     error = MatchNext(anchor);
 352
 353                     if(error && (error != ERROR_NO_MORE_ENTRIES))
 354                     {
 355                         success = FALSE;
 356                         SetIoErr(error);
 357                     }
 358                 }
 359             }
 360
 361             /* Clear line for next shell prompt */
 362
 363             if(args[ARG_QUICK] && !args[ARG_FILE])
 364                 WriteChars((STRPTR)control_codes, 2);
 365
 366             MatchEnd(anchor);
 367
 368             if(success)
 369                 SetIoErr(0);
 370         }
 371
 372         FreeArgs(read_args);
 373
 374         CloseLocale(locale);
 375     }
 376     else
 377     {
 378         SetIoErr(ERROR_NO_FREE_STORE);
 379     }
 380
 381     /* Free memory */
 382
 383     if(anchor)
 384         FreeMem(anchor, sizeof(struct AnchorPath));
 385     if(spaces)
 386         FreeMem(spaces, SPACES_SIZE);
 387     if(path_buffer)
 388         FreeMem(path_buffer, PATH_BUF_SIZE);
 389     if(user_pattern)
 390         FreeMem(user_pattern, pat_length + 5);
 391     if(pattern)
 392         FreeMem(pattern, pat_buf_length);
 393
 394     /* Check and reset signals */
 395
 396     if(SetSignal(0, -1) & SIGBREAKF_CTRL_C)
 397         SetIoErr(ERROR_BREAK);
 398
 399     /* Exit */
 400
 401     if((error = IoErr()) != 0)
 402     {
 403         PrintFault(error, NULL);
 404         return RETURN_FAIL;
 405     }
 406
 407     return return_code;
 408 }
 409
 410
 411
 412 VOID PrintFullName(TEXT *buffer, UWORD cut_off, struct AnchorPath *anchor)
 413 {
 414     buffer[cut_off] = '\0';
 415
 416     if(AddPart(buffer, (TEXT *)&(anchor->ap_Info.fib_FileName), PATH_BUF_SIZE))
 417     {
 418         PutStr(buffer);
 419     }
 420
 421     return;
 422 }
 423
 424
 425 UWORD GetDirName(struct AnchorPath *anchor, TEXT *buffer)
 426 {
 427     if(NameFromLock(anchor->ap_Current->an_Lock, buffer, PATH_BUF_SIZE))
 428         return strlen(buffer);
 429
 430     return 0;
 431 }
 432
 433
 434 BOOL FindString(struct AnchorPath *anchor, IPTR *args, TEXT *pattern,
 435                 struct Locale *locale, UBYTE *pi)
 436 {
 437     BOOL   found = FALSE, end_early = FALSE, line_matches, at_end;
 438     BPTR   old_lock, file;
 439     TEXT  *p, *q, *r, *line, *buffer = NULL, ch;
 440     ULONG  max_line_length = 0, line_length, offset = 0, file_size, buf_size,
 441            line_start = 0, line_count = 1, sigs, lines_to_show = 0;
 442     LONG   read_length = 1;
 443
 444     /* Move into the file's directory */
 445
 446     old_lock = CurrentDir(anchor->ap_Current->an_Lock);
 447
 448     /* Open the file for reading */
 449
 450     if((file = Open(anchor->ap_Info.fib_FileName, MODE_OLDFILE)) != BNULL)
 451     {
 452         /* Get a buffer for the file */
 453
 454         file_size = anchor->ap_Info.fib_Size;
 455         buf_size  = file_size + 1;
 456
 457         while(!buffer && buf_size)
 458         {
 459             if(!(buffer = AllocMem(buf_size, MEMF_ANY)))
 460                 buf_size >>= 1;
 461         }
 462
 463         /* Check size of buffer */
 464
 465         if((buf_size <= file_size) && buffer)
 466         {
 467             /* Get length of longest line */
 468
 469             while(read_length > 0)
 470             {
 471                 read_length = Read(file, buffer, buf_size - 1);
 472                 q = buffer + read_length;
 473
 474                 if(!read_length)
 475                     q++;
 476
 477                 for(p = buffer; p < q; p++)
 478                 {
 479                     if((*p=='\n')||!read_length)
 480                     {
 481                         line_length = offset + (p - buffer) - line_start;
 482
 483                         if(line_length > max_line_length)
 484                             max_line_length = line_length;
 485
 486                         line_start = offset + (p - buffer) + 1;
 487                     }
 488                 }
 489
 490                 offset += read_length;
 491             }
 492
 493             /* Ensure buffer is big enough for longest line */
 494
 495             if(buf_size <= max_line_length)
 496             {
 497                 FreeMem(buffer, buf_size);
 498                 buf_size = max_line_length + 1;
 499                 buffer = AllocMem(buf_size, MEMF_ANY);
 500             }
 501         }
 502
 503         /* Test every line against the pattern */
 504
 505         if(buffer && pattern)
 506         {
 507
 508             read_length = Seek(file, 0, OFFSET_BEGINNING) + 1;
 509
 510             while(((read_length = Read(file, buffer, buf_size - 1)) > 0) &&
 511                   !end_early)
 512             {
 513                 q = buffer + read_length;
 514                 at_end = Seek(file, 0, OFFSET_CURRENT) == file_size;
 515
 516                 if(at_end)
 517                     *(q++) = '\0';
 518
 519                 line = buffer;
 520
 521                 for(p = buffer; (p < q) && !end_early; p++)
 522                 {
 523                     ch = *p;
 524
 525                     if((ch == '\n') || (ch == '\0'))
 526                     {
 527                         *p = '\0';
 528
 529                         if (args[ARG_CASE])
 530                         {
 531                             if (args[ARG_PATTERN])
 532                                 line_matches = MatchPattern(pattern, line);
 533                             else
 534                                 line_matches = MatchString(pattern, line, p, pi, locale);
 535                         }
 536                         else
 537                         {
 538                             if(args[ARG_PATTERN])
 539                                 line_matches = MatchPatternNoCase(pattern, line);
 540                             else
 541                                 line_matches = MatchStringNoCase(pattern, line, p, pi, locale);
 542                         }
 543                         if(line_matches)
 544                         {
 545                             if(!found && args[ARG_QUICK])
 546                                 PutStr(new_line);
 547
 548                             found = TRUE;
 549
 550                             if(args[ARG_QUIET])
 551                             {
 552                                 end_early = TRUE;
 553                             }
 554                             else
 555                             {
 556                                 if(!args[ARG_NONUM])
 557                                     Printf("%6lu ", line_count);
 558
 559                                 /* Replace invisible characters with dots */
 560
 561                                 for(r = line; r < p; r++)
 562                                 {
 563                                     if(!IsPrint(locale, *r))
 564                                         *r = '.';
 565                                 }
 566
 567                                 Printf("%s\n", line);
 568                                 if (args[ARG_LINES])
 569                                 {
 570                                     lines_to_show =
 571                                         *((ULONG *) args[ARG_LINES]);
 572                                 }
 573                             }
 574                         }
 575                         else
 576                         {
 577                             if (lines_to_show != 0)
 578                             {
 579                                 Printf("%6lu: ", line_count);
 580
 581                                 /* Replace invisible characters with dots */
 582
 583                                 for (r = line; r < p; r++)
 584                                 {
 585                                     if (!IsPrint(locale, *r))
 586                                         *r = '.';
 587                                 }
 588                                 PutStr(line);
 589                                 PutStr("\n");
 590                                 lines_to_show--;
 591                             }
 592                         }
 593                         line = p + 1;
 594
 595                         if(ch == '\n')
 596                             line_count++;
 597
 598                         sigs = SetSignal(0, SIGBREAKF_CTRL_D);
 599
 600                         if(sigs & (SIGBREAKF_CTRL_C | SIGBREAKF_CTRL_D))
 601                         {
 602                             end_early = TRUE;
 603
 604                             if(sigs & SIGBREAKF_CTRL_D)
 605                             {
 606                                 PutStr(abandon_msg);
 607                             }
 608                         }
 609                     }
 610                 }
 611
 612                 /* Start reading again at start of most recent line */
 613
 614                 if(!at_end)
 615                     Seek(file, line - q, OFFSET_CURRENT);
 616             }
 617         }
 618
 619         if(buffer)
 620             FreeMem(buffer, buf_size);
 621
 622         Close(file);
 623     }
 624
 625     CurrentDir(old_lock);
 626
 627     return found;
 628 }
 629
 630
 631 BOOL MatchStringNoCase(TEXT *string, TEXT *text, TEXT *text_end, UBYTE *pi,
 632                        struct Locale *locale)
 633 {
 634     TEXT *s, ch;
 635
 636     s = string;
 637
 638     while(text < text_end)
 639     {
 640         ch = ConvToUpper(locale, *(text++));
 641
 642         while((s != string) && (*s != ch))
 643             s = string + pi[s - string - 1];
 644
 645         if(ch == *s)
 646             s++;
 647
 648         if(!*s)
 649             return TRUE;
 650     }
 651
 652     return FALSE;
 653 }
 654
 655 BOOL MatchString(TEXT *string, TEXT *text, TEXT *text_end, UBYTE *pi,
 656                  struct Locale *locale)
 657 {
 658         TEXT *s, ch;
 659
 660         s = string;
 661
 662         while (text < text_end)
 663         {
 664                 ch = *(text++);
 665
 666                 while ((s != string) && (*s != ch))
 667                         s = string + pi[s - string - 1];
 668
 669                 if (ch == *s)
 670                         s++;
 671
 672                 if (!*s)
 673                         return TRUE;
 674         }
 675
 676         return FALSE;
 677 }
 678
 679