---

G:/NewGrep/NewGrep.cpp

Go to the documentation of this file.

static char Module[] = "$Header: /TDS Product Cycle/0 Development/Software/MiscTools/NewGrep/NewGrep.cpp 2     00-10-31 14:48 Vwagner $";
// NewGrep.cpp : Defines the entry point for the console application.
//
/************************************************************************/
/*                                                                      */
/*                          G R E P                                     */
/*                                                                      */
/************************************************************************/
/*                                                                      */
/*                                                                      */
/* Usage:                                                               */
/*    grep [>output] [options] pattern file1 [file2...filen]            */
/*                                                                      */
/* options:                                                             */
/*    -a   print adjoining lines.                                       */
/*    -c   print only a count of matching lines.                        */
/*    -f   don't print file names.                                      */
/*    -lxxxx  only search the first xxxx lines of a file.               */
/*    -n   print line number of matching lines.                         */
/*    -q   quit searching the current after the first match.            */
/*    -tnn tree walk from the given node (nn = depth, 99 if no nn).     */
/*    -v   print non matching lines only.                               */
/*                                                                      */
/* pattern:                                                             */
/*   ?  = matches any single character except newline                   */
/*   #  = zero or more occurrances of following character               */
/*   %  = Matches the null string                                       */
/*   'a = any alphabetic character                                      */
/*   'd = any digit                                                     */
/*   'n = any alphanumeric                                              */
/*   's = any white space character                                     */
/*   '  = escape (match following metacharacter literally, \'$ = $)     */
/*   `  = or (a`b) = a or b                                             */
/*                                                                      */
/************************************************************************/

#include "stdafx.h"
#include "pattern.hpp"
#include <io.h>
using namespace std;

void log_on(char *name, char *version, char *dates)
  {
    clog << name <<  " - Version " << version
         << "\nCopyright (C) 1986,7, 1991,3,6-9 Victor A. Wagner, Jr. and Kenneth T. Spoor All Rights Reserved\n" 
         << "Copyright (C) " << dates <<" Victor A. Wagner Jr. All Rights Reserved\n";
  }
typedef struct
{
  long    handle;
  struct  _finddata_t data;
} FileData;

int find_files (string OriginalPattern,
                        void ( *dest_process ) ( char *FoundFileName,
                                                 char *path,
                                                 FileData *FileInfo ),
                        int how_deep )
  {
    return 20;
  }

bool Read_a_Line(istream_iterator<char>& Stream, istream_iterator<char>& End_of_Stream, string& towhere)
  {
    towhere.clear();
    char ch;
    while (('\n' != (ch = *Stream++)) && (Stream != End_of_Stream))
      towhere += ch;
    return (Stream != End_of_Stream) || !towhere.empty();
  }

void grep (string patt, istream& input, string log_message)
  {
    Pattern magic(patt);                        //!< holds the pattern
    string Line;
    unsigned long Line_Number = 0;

    input.unsetf(ios::skipws);
    istream_iterator<char> End_of_Stream;
    istream_iterator<char> Stream(input);
    while(Read_a_Line(Stream, End_of_Stream, Line))
      {
        ++Line_Number;
        if (magic(Line))
          cout << Line_Number << '\t' << Line << endl;
      }
  }

void pre_grep(char* name, char* path, FileData* FileInfo)
  {
  }

const int MaxLines = 64;

int aflag = 0;                          /* adjoining lines                 */
int cflag = 0;                          /* print count only option flag    */
int dflag = 0;                          /* debug flag                      */
int fflag = 1;                          /* no file names option flag       */
int kflag = 0;                          /* quiet mode, minimum output      */
int lflag = 0;                          /* line number limit option flag   */
int nflag = 0;                          /* line number option flag         */
int qflag = 0;                          /* quit on first match option flag */
int tflag = 0;                          /* tree walk depth option flag     */
int vflag = 0;                          /* print non-matching option flag  */
int zflag = 0;                          /* inhibit the logging on message  */
int files;                              /* number of input files           */

int TotalFileMatches = 0;

int LeadingLines  = 0;
int TrailingLines = 0;
int LastMatchLine = 0;
int MarkLineCount = 0;

string pattern;

void help(void)
  {
    cout << "\nUsage:\n";
    cout << "    grep [options] pattern file1 [file2...filen] [>output]\n";
    cout << "\n";
    cout << "options:\n";
    cout << "    -a[+x-y] +x = # of trailing lines, -y = # of leading lines \n"
            "             largest combined lines is " << MaxLines << '\n';
    cout << "    -c       print only a count of matching lines.\n";
    cout << "    -f       don't print file names.\n";
    cout << "    -lxxxx   only search the first xxxx lines of a file.\n";
    cout << "    -n       print line number of matching lines.\n";
    cout << "    -q       quit searching the current file after the first match.\n";
    cout << "    -tnn     tree walk from the given node (nn = depth, 99 if no nn).\n";
    cout << "    -v       print non matching lines only.\n";
    cout << "\n";
    cout << "pattern:\n";
    cout << "    ^      = matches beginning of line\n";
    cout << "    ?      = matches any single character except newline\n";
    cout << "    #      = zero or more occurrances of follow character\n";
    cout << "    %%     = matches the null string\n";
    cout << "    \'a     = any alphabetic character\n";
    cout << "    \'d     = any digit\n";
    cout << "    \'n     = any alphanumeric\n";
    cout << "    \'s     = any white space character\n";
    cout << "    \'      = escape (match following metacharacter literally, \'? = ?)\n";
    cout << "    ` or | = or, (a`b) = a or b, (mother|father) = mother or father\n";
    cout << "\n";
    cout << "   note   : Using the \"|\" requires the pattern to be in quotes.\n";
    cout << "   example: grep \"(mother|father)\" #?.txt\n";
  }

string StarConvert (char *input)
{
  string output;
  char PreviousCharacter = '\0';

  if (input)
    {
      while (*input)
        {
          if ((*input == '*') && (PreviousCharacter != '\''))
            {
              output += "#?";
            }
          else
            {
              output += *input;
            }

          PreviousCharacter = *input++;
        }
    }

  return (output);
}


/**************************************************************************/
/*                                                                        */
/*                                                                        */
/*      GetIntegerParameter (char **ParameterString)                      */
/*                                                                        */
/*        char **ParameterString // input string                          */
/*                                                                        */
/*   This function returns the integer value of a numeric (sub)string     */
/*   and updates the pointer to the first non nummeric character.         */
/*                                                                        */
/**************************************************************************/

int GetIntegerParameter (char **ParameterString)
  {
    int  IntegerValue = 0;

    while (isdigit (**ParameterString))
      {
        IntegerValue = (IntegerValue * 10) + (**ParameterString - '0');
        (*ParameterString)++;
      }

    return (IntegerValue);
  }

/**************************************************************************/
/*                                                                        */
/*                                                                        */
/*      GetStringParameter (char **ParameterString)                       */
/*                                                                        */
/*        char **ParameterString // input string                          */
/*                                                                        */
/*   This function returns the integer value of a numeric (sub)string     */
/*   and updates the pointer to the first non nummeric character.         */
/*                                                                        */
/**************************************************************************/

char *GetStringParameter (char **ParameterString, char *StringParameter)
  {
    while (isdigit (**ParameterString))
      {
        *StringParameter++ = **ParameterString;
        (*ParameterString)++;
      }

    return (StringParameter);
  }

/**************************************************************************/
/*                                                                        */
/*                                                                        */
/*                                                                        */
/*                                                                        */
/**************************************************************************/

char *AdjoiningLinesOptionProcessing (char *opt)
{
  bool more     = true;

  opt++;
  aflag         = GetIntegerParameter (&opt);
  LeadingLines  = aflag;
  TrailingLines = aflag;

  while (more)
    {
      if (*opt == '-')
        {
          ++opt;
          LeadingLines = GetIntegerParameter (&opt);
        }
      else if (*opt == '+')
        {
          ++opt;
          TrailingLines = GetIntegerParameter (&opt);
        }
      else
        {
          more = false;
        }
    }

  if (dflag)
    {
      cout << "adjoining lines = " << aflag;
      cout << "\nleading lines   = " << LeadingLines;
      cout << "\ntrailing lines  = " << TrailingLines << '\n';
    }

  if (aflag == 0)
    {
      aflag = 1;
    }

  if ((LeadingLines == 0) && (TrailingLines == 0))
    {
      LeadingLines = TrailingLines = 1;
    }

  if (aflag > (MaxLines >> 1))
    {
      aflag         = (MaxLines >> 1) - 1;
      LeadingLines  = aflag;
      TrailingLines = aflag;
    }

  if ((LeadingLines + TrailingLines + 1) >= MaxLines)
    {
      LeadingLines  = (MaxLines - 1) * LeadingLines / (LeadingLines + TrailingLines) ;
      TrailingLines = (MaxLines - 1) - LeadingLines;
    }

  return (--opt);
}

int main(int argc, char* argv[])
{
  static char myrev[] = "$Revision: 2 $";
  char  *opt;
  int   i;
  int   j;
  int   status;
  int   got_pattern = 0;

  string prefix, suffix;

  myrev [strlen (myrev) - 1] = '\0';   // take out the trailing $ and ' '
#define CopyrightDates "2000;"
  if (argc < 2)
    {
      log_on ("Grep", &myrev [11], CopyrightDates);
      help();
      return 2;
    }
  files = argc - 1;

  for (i = 1; i < argc; ++i)
  {
    opt = argv[i];

    if (*opt == '-')
    {
      ++opt;

      while (*opt != '\0')
        {
        switch (tolower(*opt))
          {
          case 'a':   // adjoining lines
            opt = AdjoiningLinesOptionProcessing (opt);
            break;
          case 'c':   // match count
            ++cflag;
            break;
          case 'd':   // debug
            ++dflag;
            break;
          case 'f':   // no file name
            fflag = 0;
            break;
          case 'k':   // quiet mode
            ++kflag;
            break;
          case 'l':   // lines per file to search
            while (isdigit (*(++opt)))
            {
              lflag = (lflag * 10) + (*opt - '0');
            }

            if (dflag)
            {
              cout << "line count = " << lflag << '\n';
            }

            opt--;
            break;
          case 'n':   // line numbers
            ++nflag;
            break;
          case 'q':   // quit on match
            ++qflag;
            break;
          case 't':   // tree walk
            while (isdigit (*(++opt)))
            {
              tflag = (tflag * 10) + (*opt - '0');
            }

            if (tflag == 0)
            {
              tflag = 99;
            }

            opt--;
            break;
          case 'v':   // print non-matching lines
            ++vflag;
            break;
          case 'z':     // inhibit logon
            ++zflag;
            break;
          default:
            log_on ("Grep", &myrev [11], CopyrightDates);
            cout << "Unknown Switch\n" << *opt;
            return 3;
          }  /* end of switch */
        opt++;
        }  /* end of while (*opt != '\0')  */
      argv[i] = 0;
      files--;
    }  /* end of if (*opt == '-')  */

    else
      if (got_pattern == 0)
        {
        pattern = StarConvert(argv[i]);
        j = pattern.size();
        suffix = "#?";

        if (pattern[0] == '^')
        {
          pattern.erase(0,1);
        }
        else
          {
          if ((pattern[0] == '#') && (pattern[1] == '?'))
            {
            if (j == 2)
              suffix.erase();
            }
          else prefix = "#?";
          }

        j = pattern.size();
        if ((j > 2) && (pattern[j-3] != '\''))
          if (pattern[j-2] == '#')
            if(pattern[j-1] == '?')
              suffix.erase();
        if((j > 2) && (pattern[j-1] == '^'))
        {
          pattern.erase(j-1);
          suffix.erase();
        }

        pattern = prefix + pattern + suffix;

        try
          {
          Pattern test_for_error(pattern);
          }
        catch (runtime_error& x)
          {
            log_on ("Grep", &myrev [11], CopyrightDates);
            cerr << "error in compiling pattern \"" << x.what() << "\"\nattempting to compile: " << pattern << '\n';
            return 4;
          }

        got_pattern++;
        argv[i] = 0;
        files--;
        }
  }  /* end of for (i = 1; i < argc; i++)  */

  if (!zflag)
  {
      log_on ("Grep", &myrev [11], CopyrightDates);
  }

  if (dflag)
  {
    cout << "\nSearch pattern = " << pattern;
  }

  if (!got_pattern)
    {
      log_on ("Grep", &myrev [11], CopyrightDates);
      cerr << "no pattern given\n";
      return 5;
    }

  if (files == 0)
    {
      if (Pattern("#?test#?")("This is a test, isn't it?"))
        cout << "Yes, and successful at that!\n";
      grep(pattern, cin, "<Standard In>");
      clog << "\n";
    }
  else
    {
      for (i = 1; i < argc; i++)
        {
          if (argv[i])
            {
              string FilePattern = StarConvert(argv [i]);

              if (dflag)
              {
                cout << "File pattern   = " << FilePattern << '\n';
              }

              status = find_files (FilePattern, pre_grep, tflag);
              printf ("\n");
            }
        }
    }

  return (TotalFileMatches == 0);
}

---