reworked regex directory structure to match boost requirements.

[SVN r9752]

example/jgrep/bc55.mak

@@ -0,0 +1,50 @@
+
+# very basic makefile for jgrep.exe
+#
+# Borland C++ tools
+#
+# BCROOT defines the root directory of your bc builder install
+#
+!ifndef BCROOT
+BCROOT=$(MAKEDIR)\..
+!endif
+
+BCC32   = $(BCROOT)\bin\Bcc32.exe
+LIBPATH=..\..\build\bcb5
+
+IDE_LinkFLAGS32 =  -L$(BCROOT)\LIB
+LINKOPTS= -ap -Tpe -x
+COMPOPTS= -O2 -tWM- -DSTRICT; -I$(BCROOT)\include;../../../../; -D_NO_VCL
+
+
+
+jgrep.exe : jgrep.obj main.obj
+  $(BCC32) $(COMPOPTS) -e$@  -L$(LIBPATH) main.obj jgrep.obj
+
+jgrep.obj :  jgrep.cpp
+  $(BCC32) -c @&&|
+ $(COMPOPTS) -o$@ jgrep.cpp
+|
+
+main.obj :  main.cpp
+  $(BCC32) -c @&&|
+ $(COMPOPTS) -o$@ main.cpp
+|
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

example/jgrep/bcb4.mak

@@ -0,0 +1,50 @@
+
+# very basic makefile for jgrep.exe
+#
+# Borland C++ tools
+#
+# BCROOT defines the root directory of your bc builder install
+#
+!ifndef BCROOT
+BCROOT=$(MAKEDIR)\..
+!endif
+
+BCC32   = $(BCROOT)\bin\Bcc32.exe
+LIBPATH="..\..\build\bcb4"
+
+IDE_LinkFLAGS32 =  -L$(BCROOT)\LIB
+LINKOPTS= -ap -Tpe -x
+COMPOPTS= -O2 -tWM- -DSTRICT; -I$(BCROOT)\include;../../../../; -D_NO_VCL
+
+
+
+jgrep.exe : jgrep.obj main.obj
+  $(BCC32) @&&|
+$(COMPOPTS) -e$@  -L$(LIBPATH) main.obj jgrep.obj
+|
+
+jgrep.obj :  jgrep.cpp
+  $(BCC32) -c @&&|
+ $(COMPOPTS) -o$@ jgrep.cpp
+|
+
+main.obj :  main.cpp
+  $(BCC32) -c @&&|
+ $(COMPOPTS) -o$@ main.cpp
+|
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

example/jgrep/bcb5.mak

@@ -0,0 +1,49 @@
+
+# very basic makefile for jgrep.exe
+#
+# Borland C++ tools
+#
+# BCROOT defines the root directory of your bc builder install
+#
+!ifndef BCROOT
+BCROOT=$(MAKEDIR)\..
+!endif
+
+BCC32   = $(BCROOT)\bin\Bcc32.exe
+LIBPATH=../../build/bcb5
+
+IDE_LinkFLAGS32 =  -L$(BCROOT)\LIB
+LINKOPTS= -ap -Tpe -x
+COMPOPTS= -O2 -tWM- -DSTRICT; -I$(BCROOT)\include;../../../../; -D_NO_VCL
+
+
+
+jgrep.exe : jgrep.obj main.obj
+  $(BCC32) $(COMPOPTS) -e$@  -L..\..\build\bcb5 main.obj jgrep.obj
+
+jgrep.obj :  jgrep.cpp
+  $(BCC32) -c @&&|
+ $(COMPOPTS) -o$@ jgrep.cpp
+|
+
+main.obj :  main.cpp
+  $(BCC32) -c @&&|
+ $(COMPOPTS) -o$@ main.cpp
+|
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

example/jgrep/gcc.mak

@@ -0,0 +1,32 @@
+
+# very basic makefile for jgrep
+#
+# GNU compiler g++
+#
+CXX= $(INCLUDES) -O2 -I../../../../ -I./ $(CXXFLAGS) $(LDFLAGS)
+
+jgrep : jgrep.cpp main.cpp
+	g++ -ojgrep $(CXX) jgrep.cpp main.cpp -L../../build/gcc -lboost_regex $(LIBS)
+
+debug : jgrep.cpp main.cpp
+	g++ -ojgrep -I../../../../ -I./ -g jgrep.cpp main.cpp -L../../build/gcc -lboost_regex_debug $(LIBS)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

example/jgrep/jgrep.cpp

@@ -0,0 +1,126 @@
+/*
+ *
+ * Copyright (c) 1998-2000
+ * Dr John Maddock
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Dr John Maddock makes no representations
+ * about the suitability of this software for any purpose.  
+ * It is provided "as is" without express or implied warranty.
+ *
+ */
+ 
+ /*
+  *   FILE     jgrep.cpp
+  *   VERSION  3.04
+  */
+
+#include <stdio.h>
+#include <boost/regex.hpp>
+#ifdef JM_OLD_IOSTREAM
+#include <iostream.h>
+#else
+#include <iostream>
+using std::cout;
+using std::cin;
+using std::cerr;
+using std::endl;
+#endif
+#pragma hrdstop
+
+#include <boost/re_detail/fileiter.hpp>
+
+#include "jgrep.h"
+
+
+//
+// class ogrep_predicate
+// outputs the results of regex_grep to screen:
+template <class iterator, class Allocator >
+class ogrep_predicate
+{
+   unsigned int& lines;
+   const char* filename;
+   unsigned int last_line;
+   iterator end_of_storage;
+public:
+   ogrep_predicate(unsigned int& i, const char* p, iterator e) : lines(i), filename(p), last_line(-1), end_of_storage(e) {}
+   ogrep_predicate(const ogrep_predicate& o) : lines(o.lines), filename(o.filename), last_line(o.last_line), end_of_storage(o.end_of_storage) {}
+   bool operator () (const boost::match_results<iterator, Allocator>& i);
+};
+
+// ideally we'd ignor the allocator type and use a template member function
+// to deel with the allocator type passed to regex_grep, unfortunately most
+// compilers don't support this feature yet, so we'll have to be sure that
+// the allocator passed to instances of this class match that used in our
+// regular expression classes.
+
+template <class iterator, class Allocator>
+bool ogrep_predicate<iterator, Allocator>::operator()(const boost::match_results<iterator, Allocator>& i)
+{
+   if(last_line == (unsigned int)-1)
+      cout << "File " << filename << ":" << endl;
+   if(last_line != i.line())
+   {
+      ++lines;
+      last_line = i.line();
+      if(count_only == 0)
+      {
+         if(show_lines)
+            cout << i.line() << "\t";
+         iterator ptr = i.line_start();
+         while((ptr != end_of_storage) && (*ptr != '\n'))++ptr;
+         iterator pos = i.line_start();
+         while(pos != ptr)
+         {
+            cout.put(*pos);
+            ++pos;
+         }
+         cout << endl;
+      }
+   }
+   return true;
+}
+
+
+void process_grep(const char* file)
+{
+   using namespace boost;
+   mapfile f(file);
+   unsigned int count = 0;
+   ogrep_predicate<mapfile::iterator, allocator_type> oi(count, file, f.end());
+   if(files_only)
+   {
+      bool ok;
+      boost::match_results<mapfile::iterator, allocator_type> m;
+         ok = regex_search(f.begin(), f.end(), m, e, match_not_dot_newline | match_not_dot_null);
+      if(ok)
+         cout << "File " << file << endl;
+   }
+   else
+   {
+      regex_grep(oi, f.begin(), f.end(), e, match_not_dot_newline | match_not_dot_null);
+      if(count)
+      {
+         if(verbose || count_only)
+         {
+            cout << count << " lines match" << endl;
+            return;
+         }
+      }
+      else if(verbose)
+      {
+         cout << "File " << file << "(" << f.size() << "bytes):" << endl << "0 lines match" << endl;
+      }
+   }
+}
+
+
+
+
+
+
+

example/jgrep/jgrep.h

@@ -0,0 +1,53 @@
+/*
+ *
+ * Copyright (c) 1998-2000
+ * Dr John Maddock
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Dr John Maddock makes no representations
+ * about the suitability of this software for any purpose.  
+ * It is provided "as is" without express or implied warranty.
+ *
+ */
+ 
+ /*
+  *   FILE     jgrep.h
+  *   VERSION  3.04
+  */
+
+#ifndef _JGREP_H
+#define _JGREP_H
+
+#include <boost/regex.hpp>
+
+// case sensitive reg_expression determines our allocator type:
+typedef boost::reg_expression<char> re_type;
+typedef re_type::allocator_type allocator_type;
+
+// now declare static (global) data, including an allocator
+// instance which we'll pass to all instances that require an allocator.
+
+extern allocator_type a;
+
+extern re_type e;
+
+// flags for output:
+
+extern bool use_case;
+extern bool show_lines;
+extern bool count_only;
+extern bool files_only;
+extern bool recurse;
+extern bool regularexs;
+extern bool words_only;
+extern bool verbose;
+
+void process_grep(const char* file);
+
+#endif
+
+
+

example/jgrep/main.cpp

@@ -0,0 +1,284 @@
+/*
+ *
+ * Copyright (c) 1998-2000
+ * Dr John Maddock
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Dr John Maddock makes no representations
+ * about the suitability of this software for any purpose.  
+ * It is provided "as is" without express or implied warranty.
+ *
+ */
+ 
+ /*
+  *   FILE     main.cpp
+  *   VERSION  3.04
+  */
+
+
+#include <stdio.h>
+#include <boost/regex.hpp>
+#ifdef JM_OLD_IOSTREAM
+#include <iostream.h>
+#else
+#include <iostream>
+using std::cout;
+using std::cin;
+using std::cerr;
+using std::endl;
+#endif
+#pragma hrdstop
+
+#include <boost/re_detail/fileiter.hpp>
+#include "jgrep.h"
+
+#ifndef JM_ALGO_INCLUDED
+// HP and SGI STL's use <algo.h> instead
+// this will have been pulled in by <jm_cfg.h>
+// for std::distance
+#include <algorithm>
+#endif
+
+allocator_type a;
+
+re_type e(a);
+//rei_type ei(a);
+
+// flags for output:
+
+bool use_case = true;
+bool show_lines = false;
+bool count_only = false;
+bool files_only = false;
+bool recurse = false;
+bool regularexs = true;
+bool words_only = false;
+bool verbose = false;
+
+
+void usage()
+{
+   cout <<
+"jgrep version 0.95\n"
+"usage: jgrep [-options] expression file [files...]\n"
+"\n"
+"options can be one of the following:\n"
+"\n"
+"-c   prints a count of the number of matching lines only\n"
+"-d   recurses through subdirectories for matching files\n"
+"-i   causes case to be ignored when matching\n"
+"-l   lists the files which contain a match only\n"
+"-n   displays the line numbers of matches\n"
+"-r-  causes the expression to be interpreted as a literal string and not\n"
+"     as a regular expression\n"
+"-w   searches for matches that are whole words only\n"
+"-z   verbose mode\n"
+"\n"
+"expression: a regular expression, or a literal string if -r- is specified\n"
+"\n"
+"files:  one or more files to search, the names can contain the wildcard\n"
+"        characters ? and *\n" << endl;
+
+}
+
+void parse_switch(const char* flag)
+{
+   ++flag;
+   while(*flag)
+   {
+      switch(*flag)
+      {
+         case '-':
+            switch(*(flag-1))
+            {
+               case 'c':
+                  count_only = false;
+                  break;
+               case 'd':
+                  recurse = false;
+                  break;
+               case 'i':
+                  use_case = false;
+                  break;
+               case 'l':
+                  files_only = false;
+                  break;
+               case 'n':
+                  show_lines = false;
+                  break;
+               case 'r':
+                  regularexs = false;
+                  break;
+               case 'w':
+                  words_only = false;
+                  break;
+               case 'z':
+                  verbose = false;
+                  break;
+               default:
+                  cout << "Undefined option -";
+                  cout.put(*flag);
+                  cout << endl;
+            }
+            // turn off prev character:
+            break;
+         case 'c':
+            count_only = true;
+            break;
+         case 'd':
+            recurse = true;
+            break;
+         case 'i':
+            use_case = false;
+            break;
+         case 'l':
+            files_only = true;
+            break;
+         case 'n':
+            show_lines = true;
+            break;
+         case 'r':
+            regularexs = true;
+            break;
+         case 'w':
+            words_only = true;
+            break;
+         case 'z':
+            verbose = true;
+            break;
+         case '?':
+            usage();
+            exit(0);
+         case '+':
+            break;
+         default:
+            cout << "Undefined option -";
+            cout.put(*flag);
+            cout << endl;
+      }
+      ++flag;
+   }
+}
+
+void HandleFile(const char* wild)
+{
+   using namespace boost;
+   jm_trace("Handling file " << wild);
+   file_iterator end;
+   file_iterator start(wild);
+
+   if(recurse)
+   {
+      // go through sub directories:
+      char buf[MAX_PATH];
+      std::strcpy(buf, start.root());
+      int rootlen = strlen(buf);
+      if(*buf == 0)
+      {
+         std::strcpy(buf, ".");
+         std::strcat(buf, directory_iterator::separator());
+         std::strcat(buf, "*");
+      }
+      else
+      {
+         std::strcat(buf, directory_iterator::separator());
+         std::strcat(buf, "*");
+      }
+      jm_trace("Enumerating directories: " << buf);
+      directory_iterator dstart(buf);
+      directory_iterator dend;
+
+      // now get the file mask bit of "wild":
+      const char* ptr = wild + rootlen;
+      if(*ptr) ++ptr;
+      jm_trace("File mask part is: " << ptr);
+
+      while(dstart != dend)
+      {
+         std::sprintf(buf, "%s%s%s", dstart.path(), directory_iterator::separator(), ptr);
+         HandleFile(buf);
+         ++dstart;
+      }
+   }
+   std::for_each(start, end, process_grep);
+}
+
+int done = 0;
+
+void HandleArg(const char* arg)
+{
+   using namespace boost;
+   jm_trace("Handling argument: " << arg);
+   if(*arg == '-')
+   {
+      parse_switch(arg);
+      return;
+   }
+   if(done == 0)
+   {
+      // parse regular expression
+      if(regularexs)
+      {
+         if(words_only == 0)
+         {
+            e.set_expression(arg, use_case ? regbase::normal : regbase::normal | regbase::icase);
+            //ei.set_expression(arg);
+         }
+         else
+         {
+            char* buf = new char[std::strlen(arg) + 8];
+            std::sprintf(buf, "\\<%s\\>", arg);
+            e.set_expression(buf, use_case ? regbase::normal : regbase::normal | regbase::icase);
+            //ei.set_expression(buf);
+            delete[] buf;
+         }
+      }
+      else
+      {
+         // we need to convert text to literal:
+         int len2 = std::strlen(arg);
+         int len = len2 * 5 + 6;
+         char buf[8];
+         char* buf2 = new char[len];
+         *buf2 = 0;
+         if(words_only)
+            std::strcpy(buf2, "\\<");
+         for(int j = 0; j < len2; ++j)
+         {
+            std::sprintf(buf, "\\0%o", int(arg[j]));
+            std::strcat(buf2, buf);
+         }
+         if(words_only)
+            std::strcat(buf2, "\\>");
+         e.set_expression(buf2, use_case ? regbase::normal : regbase::normal | regbase::icase);
+         //ei.set_expression(buf2);
+         delete[] buf2;
+      }
+      done = 1;
+      return;
+   }
+   // if we get to here we have one or more file names to process:
+   ++done;
+   HandleFile(arg);
+}
+
+int main(int argc, char * argv[])
+{
+   for(int i = 1; i < argc; ++i)
+      HandleArg(argv[i]);
+   if(done < 2)
+      usage();
+   return 0;
+}
+
+
+
+
+
+
+
+
+

example/jgrep/makefile.in

@@ -0,0 +1,42 @@
+
+# very basic makefile for jgrep
+#
+
+CXX=@CXX@
+CXXFLAGS=@CXXFLAGS@
+LIBS=@LIBS@
+EXE=@ac_exe_ext@
+OBJ=@ac_obj_ext@
+
+LIBDEP=../../build/libboost_regex.a ../../../../boost/re_detail/regex_options.hpp ../../../../boost/re_detail/regex_config.hpp
+
+jgrep$(EXE) : jgrep$(OBJ) main$(OBJ)
+	$(CXX) -o jgrep$(EXE) jgrep$(OBJ) main$(OBJ) -L../../build -lboost_regex $(LIBS)
+
+jgrep$(OBJ) : jgrep.cpp jgrep.h $(LIBDEP)
+	$(CXX) -c $(CXXFLAGS) -I../../../../ -I./ jgrep.cpp
+
+main$(OBJ) : main.cpp jgrep.h $(LIBDEP)
+	$(CXX) -c $(CXXFLAGS) -I../../../../ -I./ main.cpp
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

example/jgrep/vc6-stlport.mak

@@ -0,0 +1,18 @@
+
+#
+# very simple makefile for Visual C++ 6 + STLPort 4
+#
+
+jgrep.exe: main.cpp jgrep.cpp jgrep.h
+	cl -GX -GR /Oityb1 /GF /Gy -MT -I..\..\..\..\ jgrep.cpp main.cpp /link /LIBPATH:..\..\build\vc6-stlport user32.lib
+
+
+
+
+
+
+
+
+
+
+

example/jgrep/vc6.mak

@@ -0,0 +1,17 @@
+
+#
+# very simple makefile for Visual C++ 6
+#
+
+jgrep.exe: main.cpp jgrep.cpp jgrep.h
+	cl -GX -GR /Oityb1 /GF /Gy -I..\..\..\..\ jgrep.cpp main.cpp /link /LIBPATH:..\..\build\vc6 user32.lib
+
+
+
+
+
+
+
+
+
+