RegularExpression.hxx.in 13.4 KB
Newer Older
1 2
/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
   file Copyright.txt or https://cmake.org/licensing#kwsys for details.  */
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
// Original Copyright notice:
// Copyright (C) 1991 Texas Instruments Incorporated.
//
// Permission is granted to any individual or institution to use, copy, modify,
// and distribute this software, provided that this complete copyright and
// permission notice is maintained, intact, in all copies and supporting
// documentation.
//
// Texas Instruments Incorporated provides this software "as is" without
// express or implied warranty.
//
// Created: MNF 06/13/89  Initial Design and Implementation
// Updated: LGO 08/09/89  Inherit from Generic
// Updated: MBN 09/07/89  Added conditional exception handling
// Updated: MBN 12/15/89  Sprinkled "const" qualifiers all over the place!
// Updated: DLS 03/22/91  New lite version
//

#ifndef @KWSYS_NAMESPACE@_RegularExpression_hxx
#define @KWSYS_NAMESPACE@_RegularExpression_hxx

Brad King's avatar
Brad King committed
24
#include <@KWSYS_NAMESPACE@/Configure.h>
25
#include <@KWSYS_NAMESPACE@/Configure.hxx>
26

Brad King's avatar
Brad King committed
27
#include <string>
28

29 30 31 32 33 34
/* Disable useless Borland warnings.  KWSys tries not to force things
   on its includers, but there is no choice here.  */
#if defined(__BORLANDC__)
# pragma warn -8027 /* function not inlined.  */
#endif

35 36 37
namespace @KWSYS_NAMESPACE@
{

38
/** \class RegularExpression
39 40 41 42 43
 * \brief Implements pattern matching with regular expressions.
 *
 * This is the header file for the regular expression class.  An object of
 * this class contains a regular expression, in a special "compiled" format.
 * This compiled format consists of several slots all kept as the objects
44
 * private data.  The RegularExpression class provides a convenient way to
45 46 47 48 49 50 51 52 53 54 55
 * represent regular expressions.  It makes it easy to search for the same
 * regular expression in many different strings without having to compile a
 * string to regular expression format more than necessary.
 *
 * This class implements pattern matching via regular expressions.
 * A regular expression allows a programmer to specify  complex
 * patterns  that  can  be searched for and matched against the
 * character string of a string object. In its simplest form, a
 * regular  expression  is  a  sequence  of  characters used to
 * search for exact character matches. However, many times  the
 * exact  sequence to be found is not known, or only a match at
56
 * the beginning or end of a string is desired. The RegularExpression regu-
57 58 59 60 61 62 63 64 65 66 67
 * lar  expression  class implements regular expression pattern
 * matching as is found and implemented in many  UNIX  commands
 * and utilities.
 *
 * Example: The perl code
 * 
 *    $filename =~ m"([a-z]+)\.cc";
 *    print $1;
 *    
 * Is written as follows in C++
 *
68
 *    RegularExpression re("([a-z]+)\\.cc");
69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105
 *    re.find(filename);
 *    cerr << re.match(1);
 *
 *
 * The regular expression class provides a convenient mechanism
 * for  specifying  and  manipulating  regular expressions. The
 * regular expression object allows specification of such  pat-
 * terns  by using the following regular expression metacharac-
 * ters:
 *
 *  ^        Matches at beginning of a line
 *
 *  $        Matches at end of a line
 *
 * .         Matches any single character
 *
 * [ ]       Matches any character(s) inside the brackets
 *
 * [^ ]      Matches any character(s) not inside the brackets
 *
 *  -        Matches any character in range on either side of a dash
 *
 *  *        Matches preceding pattern zero or more times
 *
 *  +        Matches preceding pattern one or more times
 *
 *  ?        Matches preceding pattern zero or once only
 *
 * ()        Saves a matched expression and uses it in a  later match
 *
 * Note that more than one of these metacharacters can be  used
 * in  a  single  regular expression in order to create complex
 * search patterns. For example, the pattern [^ab1-9]  says  to
 * match  any  character  sequence that does not begin with the
 * characters "ab"  followed  by  numbers  in  the  series  one
 * through nine.
 *
106 107
 * There are three constructors for RegularExpression.  One just creates an
 * empty RegularExpression object.  Another creates a RegularExpression
108
 * object and initializes it with a regular expression that is given in the
109
 * form of a char*.  The third takes a reference to a RegularExpression
110
 * object as an argument and creates an object initialized with the
111
 * information from the given RegularExpression object.
112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174
 *
 * The  find  member function  finds   the  first  occurence   of  the regualr
 * expression of that object in the string given to find as an argument.  Find
 * returns a boolean, and  if true,  mutates  the private  data appropriately.
 * Find sets pointers to the beginning and end of  the thing last  found, they
 * are pointers into the actual string  that was searched.   The start and end
 * member functions return indicies  into the searched string that  correspond
 * to the beginning   and  end pointers  respectively.   The    compile member
 * function takes a char* and puts the  compiled version of the char* argument
 * into the object's private data fields.  The == and  != operators only check
 * the  to see  if   the compiled  regular  expression   is the same, and  the
 * deep_equal functions also checks  to see if the  start and end pointers are
 * the same.  The is_valid  function returns false if  program is set to NULL,
 * (i.e. there is no valid compiled exression).  The set_invalid function sets
 * the  program to NULL  (Warning: this deletes the compiled  expression). The
 * following examples may help clarify regular expression usage:
 *
 *   *  The regular expression  "^hello" matches  a "hello"  only at  the
 *      beginning of a  line.  It would match "hello  there" but not "hi,
 *      hello there".
 *
 *   *  The regular expression "long$" matches a  "long"  only at the end
 *      of a line. It would match "so long\0", but not "long ago".
 *
 *   *  The regular expression "t..t..g"  will match anything that  has a
 *      "t" then any two characters, another "t", any  two characters and
 *      then a "g".   It will match  "testing", or "test again" but would
 *      not match "toasting"
 *
 *   *  The regular  expression "[1-9ab]" matches any  number one through
 *      nine, and the characters  "a" and  "b".  It would match "hello 1"
 *      or "begin", but would not match "no-match".
 *
 *   *  The  regular expression "[^1-9ab]"  matches any character that is
 *      not a number one  through nine, or  an "a" or "b".   It would NOT
 *      match "hello 1" or "begin", but would match "no-match".
 *
 *   *  The regular expression "br* " matches  something that begins with
 *      a "b", is followed by zero or more "r"s, and ends in a space.  It
 *      would match "brrrrr ", and "b ", but would not match "brrh ".
 *
 *   *  The regular expression "br+ " matches something  that begins with
 *      a "b", is followed by one or more "r"s, and ends in  a space.  It
 *      would match "brrrrr ",  and  "br ", but would not  match "b  " or
 *      "brrh ".
 *
 *   *  The regular expression "br? " matches  something that begins with
 *      a "b", is followed by zero or one "r"s, and ends in  a space.  It
 *      would  match  "br ", and "b  ", but would not match  "brrrr "  or
 *      "brrh ".
 *
 *   *  The regular expression "(..p)b" matches  something ending with pb
 *      and beginning with whatever the two characters before the first p
 *      encounterd in the line were.  It would find  "repb" in "rep drepa
 *      qrepb".  The regular expression "(..p)a"  would find "repa qrepb"
 *      in "rep drepa qrepb"
 *
 *   *  The regular expression "d(..p)" matches something ending  with p,
 *      beginning with d, and having  two characters  in between that are
 *      the same as the two characters before  the first p  encounterd in
 *      the line.  It would match "drepa qrepb" in "rep drepa qrepb".
 *
 */
Brad King's avatar
Brad King committed
175
class @KWSYS_NAMESPACE@_EXPORT RegularExpression 
176 177 178 179 180 181 182 183 184 185 186
{
public:
  /**
   * Instantiate RegularExpression with program=NULL.
   */
  inline RegularExpression ();        

  /**
   * Instantiate RegularExpression with compiled char*.
   */
  inline RegularExpression (char const*);
187

188 189 190 191 192
  /**
   * Instantiate RegularExpression as a copy of another regular expression.
   */
  RegularExpression (RegularExpression const&);

193 194 195
  /**
   * Instantiate RegularExpression with compiled string.
   */
Brad King's avatar
Brad King committed
196
  inline RegularExpression (std::string const&);
197

198 199 200 201 202 203 204 205 206 207 208
  /**
   * Destructor.
   */
  inline ~RegularExpression();

  /**
   * Compile a regular expression into internal code
   * for later pattern matching.
   */
  bool compile (char const*);

209 210 211 212
  /**
   * Compile a regular expression into internal code
   * for later pattern matching.
   */
Brad King's avatar
Brad King committed
213
  inline bool compile (std::string const&);
214

215 216 217 218 219 220 221 222 223 224
  /**
   * Matches the regular expression to the given string.
   * Returns true if found, and sets start and end indexes accordingly.
   */
  bool find (char const*);

  /**
   * Matches the regular expression to the given std string.
   * Returns true if found, and sets start and end indexes accordingly.
   */
Brad King's avatar
Brad King committed
225
  inline bool find (std::string const&);
226 227 228 229

  /**
   * Index to start of first find.
   */
Brad King's avatar
Brad King committed
230
  inline std::string::size_type start() const;
231 232 233 234

  /**
   * Index to end of first find.
   */
Brad King's avatar
Brad King committed
235
  inline std::string::size_type end() const;
236

237 238 239 240 241
  /**
   * Copy the given regular expression.
   */
  RegularExpression& operator= (const RegularExpression& rxp);

242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273
  /**
   * Returns true if two regular expressions have the same
   * compiled program for pattern matching.
   */
  bool operator== (RegularExpression const&) const;

  /**
   * Returns true if two regular expressions have different
   * compiled program for pattern matching.
   */
  inline bool operator!= (RegularExpression const&) const;

  /**
   * Returns true if have the same compiled regular expressions
   * and the same start and end pointers.
   */
  bool deep_equal (RegularExpression const&) const;
  
  /**
   * True if the compiled regexp is valid.
   */
  inline bool is_valid() const;

  /**
   * Marks the regular expression as invalid.
   */
  inline void set_invalid();            

  /**
   * Destructor.
   */
  // awf added
Brad King's avatar
Brad King committed
274 275 276
  std::string::size_type start(int n) const;
  std::string::size_type end(int n) const;
  std::string match(int n) const;
277
  
Brad King's avatar
Brad King committed
278
  enum { NSUBEXP = 10 };
279
private: 
Brad King's avatar
Brad King committed
280 281
  const char* startp[NSUBEXP];
  const char* endp[NSUBEXP];
282 283 284
  char  regstart;                       // Internal use only
  char  reganch;                        // Internal use only
  const char* regmust;                  // Internal use only
Brad King's avatar
Brad King committed
285
  std::string::size_type regmlen;                // Internal use only
286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311
  char* program;   
  int   progsize;
  const char* searchstring;
};

/**
 * Create an empty regular expression.
 */
inline RegularExpression::RegularExpression () 
{ 
  this->program = 0;
}

/**
 * Creates a regular expression from string s, and
 * compiles s.
 */
inline RegularExpression::RegularExpression (const char* s) 
{  
  this->program = 0;
  if ( s )
    {
    this->compile(s);
    }
}

312 313 314 315
/**
 * Creates a regular expression from string s, and
 * compiles s.
 */
Brad King's avatar
Brad King committed
316
inline RegularExpression::RegularExpression (const std::string& s)
317 318 319 320 321
{
  this->program = 0;
  this->compile(s);
}

322 323 324 325 326
/**
 * Destroys and frees space allocated for the regular expression.
 */
inline RegularExpression::~RegularExpression () 
{
327
//#ifndef _WIN32
328 329 330 331
  delete [] this->program;
//#endif
}

332 333 334 335
/**
 * Compile a regular expression into internal code
 * for later pattern matching.
 */
Brad King's avatar
Brad King committed
336
inline bool RegularExpression::compile (std::string const& s)
337 338 339 340 341 342 343 344
{
  return this->compile(s.c_str());
}

/**
 * Matches the regular expression to the given std string.
 * Returns true if found, and sets start and end indexes accordingly.
 */
Brad King's avatar
Brad King committed
345
inline bool RegularExpression::find (std::string const& s)
346 347 348 349
{
  return this->find(s.c_str());
}

350 351 352
/**
 * Set the start position for the regular expression.
 */
Brad King's avatar
Brad King committed
353
inline std::string::size_type RegularExpression::start () const
354
{
Brad King's avatar
Brad King committed
355
  return static_cast<std::string::size_type>(
Francois Bertel's avatar
Francois Bertel committed
356
    this->startp[0] - searchstring);
357 358 359 360 361 362
}


/**
 * Returns the start/end index of the last item found.
 */
Brad King's avatar
Brad King committed
363
inline std::string::size_type RegularExpression::end () const
364
{
Brad King's avatar
Brad King committed
365
  return static_cast<std::string::size_type>(
Francois Bertel's avatar
Francois Bertel committed
366
    this->endp[0] - searchstring);
367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389
}

/**
 * Returns true if two regular expressions have different
 * compiled program for pattern matching.
 */
inline bool RegularExpression::operator!= (const RegularExpression& r) const 
{
  return(!(*this == r));
}

/**
 * Returns true if a valid regular expression is compiled
 * and ready for pattern matching.
 */
inline bool RegularExpression::is_valid () const 
{
  return (this->program != 0);
}


inline void RegularExpression::set_invalid () 
{
390
//#ifndef _WIN32
391 392 393 394 395 396 397 398
  delete [] this->program;
//#endif
  this->program = 0;
}

/**
 * Return start index of nth submatch. start(0) is the start of the full match.
 */
Brad King's avatar
Brad King committed
399
inline std::string::size_type RegularExpression::start(int n) const
400
{
Brad King's avatar
Brad King committed
401
  return static_cast<std::string::size_type>(
Francois Bertel's avatar
Francois Bertel committed
402
    this->startp[n] - searchstring);
403 404 405 406 407 408
}


/**
 * Return end index of nth submatch. end(0) is the end of the full match.
 */
Brad King's avatar
Brad King committed
409
inline std::string::size_type RegularExpression::end(int n) const
410
{
Brad King's avatar
Brad King committed
411
  return static_cast<std::string::size_type>(
Francois Bertel's avatar
Francois Bertel committed
412
    this->endp[n] - searchstring);
413 414 415 416 417
}

/**
 * Return nth submatch as a string.
 */
Brad King's avatar
Brad King committed
418
inline std::string RegularExpression::match(int n) const
419
{
Alexander Neundorf's avatar
 
Alexander Neundorf committed
420 421
  if (this->startp[n]==0)
    {
Brad King's avatar
Brad King committed
422
    return std::string("");
Alexander Neundorf's avatar
 
Alexander Neundorf committed
423 424 425
    }
  else
    {
Brad King's avatar
Brad King committed
426 427
    return std::string(this->startp[n],
                             static_cast<std::string::size_type>(
Francois Bertel's avatar
Francois Bertel committed
428
                               this->endp[n] - this->startp[n]));
Alexander Neundorf's avatar
 
Alexander Neundorf committed
429
    }
430 431 432 433 434
}

} // namespace @KWSYS_NAMESPACE@

#endif