ossimRegExp Class Reference

#include <ossimRegExp.h>

Public Member Functions
	ossimRegExp ()
	ossimRegExp (const char *)
	ossimRegExp (const ossimRegExp &)
	~ossimRegExp ()
void	compile (const char *)
bool	find (const char *)
ossim_uint32	start () const
ossim_uint32	end () const
bool	operator== (const ossimRegExp &) const
bool	operator!= (const ossimRegExp &) const
bool	deep_equal (const ossimRegExp &) const
bool	is_valid () const
void	set_invalid ()
ossim_uint32	start (ossim_uint32 n) const
ossim_uint32	end (ossim_uint32 n) const
std::string	match (ossim_uint32 n) const

Private Member Functions
char *	reg (int, int *)
char *	regbranch (int *)
char *	regpiece (int *)
char *	regatom (int *)
char *	regnode (char)
const char *	regnext (const char *)
char *	regnext (char *)
void	regc (unsigned char)
void	reginsert (char, char *)
void	regtail (char *, const char *)
void	regoptail (char *, const char *)
int	regtry (const char *, const char **, const char **, const char *)
int	regmatch (const char *)
int	regrepeat (const char *)

Private Attributes
const char *	startp [NSUBEXP]
const char *	endp [NSUBEXP]
char	regstart
char	reganch
const char *	regmust
ossim_uint32	regmlen
char *	program
ossim_uint32	progsize
const char *	searchstring
const char *	regparse
int	regnpar
char	regdummy
char *	regcode
long	regsize
const char *	reginput
const char *	regbol
const char **	regstartp
const char **	regendp

Detailed Description

Definition at line 75 of file ossimRegExp.h.

Constructor & Destructor Documentation

ossimRegExp() [1/3]

ossimRegExp::ossimRegExp ( )

inline

Definition at line 144 of file ossimRegExp.h.

                                :
  regstart(0),     // Internal use only
  reganch(0),      // Internal use only
  regmust(0),      // Internal use only
  regmlen(0),     // Internal use only
  program(0),   
  progsize(0),
  searchstring(0),

 // work variables
  regparse(0),
  regnpar(0),  // () count.
  regdummy(0),
  regcode(0),  // Code-emit pointer; &regdummy = don't.
  regsize(0),  // Code size.
  reginput(0),  // String-input pointer.
  regbol(0),  // Beginning of input, for ^ check.
  regstartp(0), // Pointer to startp array.
  regendp(0) // Ditto for endp.
{ 
}

ossimRegExp() [2/3]

ossimRegExp::ossimRegExp ( const char *  s )

inline

Definition at line 171 of file ossimRegExp.h.

References compile(), and program.

                                              :
  regstart(0),     // Internal use only
  reganch(0),      // Internal use only
  regmust(0),      // Internal use only
  regmlen(0),     // Internal use only
  program(0),   
  progsize(0),
  searchstring(0),

 // work variables
  regparse(0),
  regnpar(0),  // () count.
  regdummy(0),
  regcode(0),  // Code-emit pointer; &regdummy = don't.
  regsize(0),  // Code size.
  reginput(0),  // String-input pointer.
  regbol(0),  // Beginning of input, for ^ check.
  regstartp(0), // Pointer to startp array.
  regendp(0) // Ditto for endp.
{  
  this->program = NULL;
  compile(s);
}

ossimRegExp() [3/3]

ossimRegExp::ossimRegExp

(

const ossimRegExp &

rxp

)

Definition at line 124 of file ossimRegExp.cpp.

References endp, if(), program, progsize, reganch, regmlen, regmust, regstart, and startp.

                                                :
  regstart(0),     // Internal use only
  reganch(0),      // Internal use only
  regmust(0),      // Internal use only
  regmlen(0),     // Internal use only
  program(0),   
  progsize(0),
  searchstring(0),

 // work variables
  regparse(0),
  regnpar(0),  // () count.
  regdummy(0),
  regcode(0),  // Code-emit pointer; &regdummy = don't.
  regsize(0),  // Code size.
  reginput(0),  // String-input pointer.
  regbol(0),  // Beginning of input, for ^ check.
  regstartp(0), // Pointer to startp array.
  regendp(0) // Ditto for endp.
{
   if(rxp.program)
   {
      int ind = 0; 
      this->progsize = rxp.progsize;        // Copy regular expression size
      this->program = new char[this->progsize]; // Allocate storage
      for(ind=this->progsize; ind-- != 0;)      // Copy regular expresion
         this->program[ind] = rxp.program[ind];
      this->startp[0] = rxp.startp[0];      // Copy pointers into last
      this->endp[0] = rxp.endp[0];          // Successful "find" operation
      this->regmust = rxp.regmust;          // Copy field
      if (rxp.regmust != NULL) {
         char* dum = rxp.program;
         ind = 0;
         while (dum != rxp.regmust) {
            ++dum;
            ++ind;
         }
         this->regmust = this->program + ind;
      }
      this->regstart = rxp.regstart;        // Copy starting index
      this->reganch = rxp.reganch;          // Copy remaining private data
      this->regmlen = rxp.regmlen;          // Copy remaining private data
   }
}

~ossimRegExp()

ossimRegExp::~ossimRegExp ( )

inline

Definition at line 197 of file ossimRegExp.h.

References program.

                                  {
//#ifndef WIN32
   if(program)
   {
      delete [] this->program;
      this->program = 0;
   }
//#endif
}

Member Function Documentation

compile()

void ossimRegExp::compile

(

const char *

exp

)

Definition at line 405 of file ossimRegExp.cpp.

References BOL, END, endp, EXACTLY, MAGIC, OP, OPERAND, program, progsize, reg(), reganch, regc(), regcode, regdummy, regmlen, regmust, regnext(), regnpar, regparse, regsize, regstart, searchstring, SPSTART, and startp.

Referenced by ossimKeywordlist::add(), ossimKeywordlist::addPrefixToKeysThatMatch(), ossimTraceManager::addTrace(), ossimString::afterRegExp(), ossimString::beforeRegExp(), ossimKeywordlist::extractKeysThatMatch(), ossimDirectoryTree::findAllFilesThatMatch(), ossimDirectory::findAllFilesThatMatch(), ossimKeywordlist::findAllKeysThatMatch(), ossimString::fromRegExp(), ossimKeywordlist::getNumberOfKeysThatMatch(), ossimKeywordlist::getSubstringKeyList(), ossimString::match(), ossimRegExp(), ossimKeywordlist::removeKeysThatMatch(), ossimString::replaceAllThatMatch(), ossimString::replaceStrThatMatch(), ossimSrtmFilename::setFilename(), ossimTraceManager::setTraceFlags(), and ossimKeywordlist::stripPrefixFromAll().

                                          {
    const char* scan;
    const char* longest;
    unsigned long len;
             int         flags;

    if (exp == NULL) {
      //RAISE Error, SYM(ossimRegExp), SYM(No_Expr),
      printf ("ossimRegExp::compile(): No expression supplied.\n");
      return;
    }

    // First pass: determine size, legality.
    regparse = exp;
    regnpar = 1;
    regsize = 0L;
    regcode = &regdummy;
    regc(MAGIC);
    if(!reg(0, &flags))
      {
    printf ("ossimRegExp::compile(): Error in compile.\n");
    return;
      }
    this->startp[0] = this->endp[0] = this->searchstring = NULL;

    // Small enough for pointer-storage convention? 
    if (regsize >= 32767L) {    // Probably could be 65535L. 
      //RAISE Error, SYM(ossimRegExp), SYM(Expr_Too_Big),
      printf ("ossimRegExp::compile(): Expression too big.\n");
      return;
    }

    // Allocate space. 
//#ifndef WIN32
    if (this->program != NULL) delete [] this->program;  
//#endif
    this->program = new char[regsize];
    this->progsize = (int) regsize;

    if (this->program == NULL) {
      //RAISE Error, SYM(ossimRegExp), SYM(Out_Of_Memory),
      printf ("ossimRegExp::compile(): Out of memory.\n"); 
      return;
    }

    // Second pass: emit code.
    regparse = exp;
    regnpar = 1;
    regcode = this->program;
    regc(MAGIC);
    reg(0, &flags);

    // Dig out information for optimizations.
    this->regstart = '\0';      // Worst-case defaults.
    this->reganch = 0;
    this->regmust = NULL;
    this->regmlen = 0;
    scan = this->program + 1;   // First BRANCH.
    if (OP(regnext(scan)) == END) { // Only one top-level choice.
    scan = OPERAND(scan);

    // Starting-point info.
    if (OP(scan) == EXACTLY)
        this->regstart = *OPERAND(scan);
    else if (OP(scan) == BOL)
        this->reganch++;

     //
     // If there's something expensive in the r.e., find the longest
     // literal string that must appear and make it the regmust.  Resolve
     // ties in favor of later strings, since the regstart check works
     // with the beginning of the r.e. and avoiding duplication
     // strengthens checking.  Not a strong reason, but sufficient in the
     // absence of others. 
     //
    if (flags & SPSTART) {
        longest = NULL;
        len = 0;
        for (; scan != NULL; scan = regnext(scan))
        if (OP(scan) == EXACTLY && strlen(OPERAND(scan)) >= len) {
            longest = OPERAND(scan);
            len = (unsigned long)strlen(OPERAND(scan));
        }
        this->regmust = longest;
        this->regmlen = len;
    }
    }
}

deep_equal()

bool ossimRegExp::deep_equal

(

const ossimRegExp &

rxp

)

const

Definition at line 189 of file ossimRegExp.cpp.

References endp, program, progsize, and startp.

                                                          {
  ossim_uint32 ind = this->progsize;        // Get regular expression size
  if (ind != rxp.progsize)          // If different size regexp
    return false;               // Return failure
  while(ind-- != 0)             // Else while still characters
    if(this->program[ind] != rxp.program[ind])  // If regexp are different    
      return false;             // Return failure             
  return (this->startp[0] == rxp.startp[0] &&   // Else if same start/end ptrs,
      this->endp[0] == rxp.endp[0]);    // Return true
}   

end() [1/2]

ossim_uint32 ossimRegExp::end ( ) const

inline

Definition at line 217 of file ossimRegExp.h.

References endp, and searchstring.

Referenced by ossimString::afterRegExp(), ossimFilename::drive(), ossimKeywordlist::getSubstringKeyList(), ossimString::match(), regtry(), ossimString::replaceAllThatMatch(), ossimString::replaceStrThatMatch(), ossimSrtmFilename::setFilename(), and ossimKeywordlist::stripPrefixFromAll().

                                            {
  return(this->endp[0] - searchstring);
}

end() [2/2]

ossim_uint32 ossimRegExp::end ( ossim_uint32  n ) const

inline

Definition at line 253 of file ossimRegExp.h.

References endp, n, and searchstring.

{
  return this->endp[n] - searchstring;
}

find()

bool ossimRegExp::find

(

const char *

string

)

Definition at line 948 of file ossimRegExp.cpp.

References endp, MAGIC, program, reganch, regbol, regmlen, regmust, regstart, regtry(), searchstring, startp, and UCHARAT.

Referenced by ossimKeywordlist::add(), ossimKeywordlist::addPrefixToKeysThatMatch(), ossimTraceManager::addTrace(), ossimString::afterRegExp(), ossimString::beforeRegExp(), ossimFilename::drive(), ossimString::expandEnvironmentVariable(), ossimKeywordlist::extractKeysThatMatch(), ossimDirectoryTree::findAllFilesThatMatch(), ossimDirectory::findAllFilesThatMatch(), ossimKeywordlist::findAllKeysThatMatch(), ossimString::fromRegExp(), ossimKeywordlist::getNumberOfKeysThatMatch(), ossimKeywordlist::getSubstringKeyList(), ossimFilename::isRelative(), ossimString::match(), ossimDtedInfo::open(), ossimKeywordlist::removeKeysThatMatch(), ossimString::replaceAllThatMatch(), ossimString::replaceStrThatMatch(), ossimSrtmFilename::setFilename(), ossimTraceManager::setTraceFlags(), ossimKeywordlist::stripPrefixFromAll(), and ossimKeywordlist::writeToStream().

                                          {
    const char* s = 0;

    if(!string) return false;
    this->searchstring = string;

     // Check validity of program.
    if (!this->program || UCHARAT(this->program) != MAGIC) {
        //RAISE Error, SYM(ossimRegExp), SYM(Internal_Error),
        printf ("ossimRegExp::find(): Compiled regular expression corrupted.\n");
        return 0;
    }
    
    // If there is a "must appear" string, look for it.
    if (this->regmust != NULL) {
    s = string;
    while ((s = strchr(s, this->regmust[0])) != NULL) {
        if (strncmp(s, this->regmust, this->regmlen) == 0)
        break;      // Found it.
        s++;
    }
    if (s == NULL)      // Not present.
        return (0);
    }
     
    // Mark beginning of line for ^ .
    regbol = string;

    // Simplest case:  anchored match need be tried only once.
    if (this->reganch)
    return (regtry(string, this->startp, this->endp, this->program));
    
    // Messy cases:  unanchored match.
    s = string;
    if (this->regstart != '\0')
    // We know what char it must start with.
    while ((s = strchr(s, this->regstart)) != NULL) {
        if (regtry(s, this->startp, this->endp, this->program))
        return (1);
        s++;
      
    }
    else
    // We don't -- general case.
    do {
        if (regtry(s, this->startp, this->endp, this->program))
        return (1);
    } while (*s++ != '\0');
    
    // Failure.
    return (0);
}

is_valid()

bool ossimRegExp::is_valid ( ) const

inline

Definition at line 232 of file ossimRegExp.h.

References program.

Referenced by ossimString::replaceAllThatMatch(), and ossimString::replaceStrThatMatch().

                                         {
  return (this->program != NULL);
}

match()

std::string ossimRegExp::match ( ossim_uint32  n ) const

inline

Definition at line 259 of file ossimRegExp.h.

References endp, and startp.

{
    return std::string(this->startp[n], this->endp[n] - this->startp[n]);
}

operator!=()

bool ossimRegExp::operator!= ( const ossimRegExp &  r ) const

inline

Definition at line 224 of file ossimRegExp.h.

                                                               {
  return(!(*this == r));
}

operator==()

bool ossimRegExp::operator==

(

const ossimRegExp &

rxp

)

const

Definition at line 173 of file ossimRegExp.cpp.

References program, and progsize.

                                                          {
  if (this != &rxp) {               // Same address?
    ossim_uint32 ind = this->progsize;      // Get regular expression size
    if (ind != rxp.progsize)            // If different size regexp
      return false;             // Return failure
    while(ind-- != 0)               // Else while still characters
      if(this->program[ind] != rxp.program[ind]) // If regexp are different    
    return false;                // Return failure             
  }
  return true;                  // Else same, return success  
}

reg()

char * ossimRegExp::reg ( int  paren, int *  flagp  )

private

Definition at line 504 of file ossimRegExp.cpp.

References CLOSE, END, HASWIDTH, NSUBEXP, OPEN, regbranch(), regnext(), regnode(), regnpar, regoptail(), regparse, regtail(), and SPSTART.

Referenced by compile(), and regatom().

                                             {
    char* ret;
    char* br;
    char* ender;
    int   parno =0;
             int   flags;

    *flagp = HASWIDTH;      // Tentatively.

    // Make an OPEN node, if parenthesized.
    if (paren) {
    if (regnpar >= NSUBEXP) {
      //RAISE Error, SYM(ossimRegExp), SYM(Too_Many_Parens),
      printf ("ossimRegExp::compile(): Too many parentheses.\n");
      return 0;
        }
    parno = regnpar;
    regnpar++;
    ret = regnode(OPEN + parno);
    }
    else
    ret = NULL;

    // Pick up the branches, linking them together.
    br = regbranch(&flags);
    if (br == NULL)
    return (NULL);
    if (ret != NULL)
    regtail(ret, br);   // OPEN -> first.
    else
    ret = br;
    if (!(flags & HASWIDTH))
    *flagp &= ~HASWIDTH;
    *flagp |= flags & SPSTART;
    while (*regparse == '|') {
    regparse++;
    br = regbranch(&flags);
    if (br == NULL)
        return (NULL);
    regtail(ret, br);   // BRANCH -> BRANCH.
    if (!(flags & HASWIDTH))
        *flagp &= ~HASWIDTH;
    *flagp |= flags & SPSTART;
      }

    // Make a closing node, and hook it on the end.
    ender = regnode((paren) ? CLOSE + parno : END);
    regtail(ret, ender);

    // Hook the tails of the branches to the closing node.
    for (br = ret; br != NULL; br = regnext(br))
    regoptail(br, ender);

    // Check for proper termination.
    if (paren && *regparse++ != ')') {
        //RAISE Error, SYM(ossimRegExp), SYM(Unmatched_Parens),
        printf ("ossimRegExp::compile(): Unmatched parentheses.\n");
    return 0;
    }
    else if (!paren && *regparse != '\0') {
        if (*regparse == ')') {
            //RAISE Error, SYM(ossimRegExp), SYM(Unmatched_Parens),
            printf ("ossimRegExp::compile(): Unmatched parentheses.\n");
        return 0;
    }
    else {
        //RAISE Error, SYM(ossimRegExp), SYM(Internal_Error),
        printf ("ossimRegExp::compile(): Internal error.\n");
        return 0;
        }
    // NOTREACHED
    }
    return (ret);
}

regatom()

char * ossimRegExp::regatom ( int *  flagp )

private

Definition at line 691 of file ossimRegExp.cpp.

References ANY, ANYBUT, ANYOF, BOL, EOL, EXACTLY, HASWIDTH, ISMULT, META, reg(), regc(), regnode(), regparse, SIMPLE, SPSTART, UCHARAT, and WORST.

Referenced by regpiece().

                                      {
    char* ret;
             int   flags;

    *flagp = WORST;     // Tentatively.

    switch (*regparse++) {
    case '^':
        ret = regnode(BOL);
        break;
    case '$':
        ret = regnode(EOL);
        break;
    case '.':
        ret = regnode(ANY);
        *flagp |= HASWIDTH | SIMPLE;
        break;
    case '[':{
        int    rxpclass;
        int    rxpclassend;

        if (*regparse == '^') { // Complement of range.
            ret = regnode(ANYBUT);
            regparse++;
        }
        else
            ret = regnode(ANYOF);
        if (*regparse == ']' || *regparse == '-')
            regc(*regparse++);
        while (*regparse != '\0' && *regparse != ']') {
            if (*regparse == '-') {
            regparse++;
            if (*regparse == ']' || *regparse == '\0')
                regc('-');
            else {
                rxpclass = UCHARAT(regparse - 2) + 1;
                rxpclassend = UCHARAT(regparse);
                if (rxpclass > rxpclassend + 1) {
                   //RAISE Error, SYM(ossimRegExp), SYM(Invalid_Range),
                   printf ("ossimRegExp::compile(): Invalid range in [].\n");
                   return 0;
                            }
                for (; rxpclass <= rxpclassend; rxpclass++)
                regc(rxpclass);
                regparse++;
            }
            }
            else
            regc(*regparse++);
        }
        regc('\0');
        if (*regparse != ']') {
                    //RAISE Error, SYM(ossimRegExp), SYM(Unmatched_Bracket),
                    printf ("ossimRegExp::compile(): Unmatched [].\n");
            return 0;
            }
        regparse++;
        *flagp |= HASWIDTH | SIMPLE;
        }
        break;
    case '(':
        ret = reg(1, &flags);
        if (ret == NULL)
        return (NULL);
        *flagp |= flags & (HASWIDTH | SPSTART);
        break;
    case '\0':
    case '|':
    case ')':
        //RAISE Error, SYM(ossimRegExp), SYM(Internal_Error),
            printf ("ossimRegExp::compile(): Internal error.\n"); // Never here
        return 0;
    case '?':
    case '+':
    case '*':
        //RAISE Error, SYM(ossimRegExp), SYM(No_Operand),
            printf ("ossimRegExp::compile(): ?+* follows nothing.\n");
        return 0;
    case '\\':
        if (*regparse == '\0') {
            //RAISE Error, SYM(ossimRegExp), SYM(Trailing_Backslash),
                printf ("ossimRegExp::compile(): Trailing backslash.\n");
        return 0;
            }
        ret = regnode(EXACTLY);
        regc(*regparse++);
        regc('\0');
        *flagp |= HASWIDTH | SIMPLE;
        break;
    default:{
        int    len;
        char   ender;

        regparse--;
        len = (int)strcspn(regparse, META);
        if (len <= 0) {
            //RAISE Error, SYM(ossimRegExp), SYM(Internal_Error),
                    printf ("ossimRegExp::compile(): Internal error.\n");
            return 0;
                }
        ender = *(regparse + len);
        if (len > 1 && ISMULT(ender))
            len--;  // Back off clear of ?+* operand.
        *flagp |= HASWIDTH;
        if (len == 1)
            *flagp |= SIMPLE;
        ret = regnode(EXACTLY);
        while (len > 0) {
            regc(*regparse++);
            len--;
        }
        regc('\0');
        }
        break;
    }
    return (ret);
}

regbranch()

char * ossimRegExp::regbranch ( int *  flagp )

private

Definition at line 585 of file ossimRegExp.cpp.

References BRANCH, HASWIDTH, NOTHING, regnode(), regparse, regpiece(), regtail(), SPSTART, and WORST.

Referenced by reg().

                                        {
    char* ret;
    char* chain;
    char* latest;
    int                  flags;

    *flagp = WORST;     // Tentatively.

    ret = regnode(BRANCH);
    chain = NULL;
    while (*regparse != '\0' && *regparse != '|' && *regparse != ')') {
    latest = regpiece(&flags);
    if (latest == NULL)
        return (NULL);
    *flagp |= flags & HASWIDTH;
    if (chain == NULL)  // First piece.
        *flagp |= flags & SPSTART;
    else
        regtail(chain, latest);
    chain = latest;
    }
    if (chain == NULL)      // Loop ran zero times.
    regnode(NOTHING);

    return (ret);
}

regc()

void ossimRegExp::regc ( unsigned char  b )

private

Definition at line 837 of file ossimRegExp.cpp.

References regcode, regdummy, and regsize.

Referenced by compile(), and regatom().

                                       {
    if (regcode != &regdummy)
    *regcode++ = b;
    else
    regsize++;
}

reginsert()

void ossimRegExp::reginsert ( char  op, char *  opnd  )

private

Definition at line 850 of file ossimRegExp.cpp.

References regcode, regdummy, and regsize.

Referenced by regpiece().

                                                {
    char* src;
    char* dst;
    char* place;

    if (regcode == &regdummy) {
    regsize += 3;
    return;
    }

    src = regcode;
    regcode += 3;
    dst = regcode;
    while (src > opnd)
    *--dst = *--src;

    place = opnd;       // Op node, where operand used to be.
    *place++ = op;
    *place++ = '\0';
    *place++ = '\0';
}

regmatch()

int ossimRegExp::regmatch ( const char *  prog )

private

Definition at line 1043 of file ossimRegExp.cpp.

References ANY, ANYBUT, ANYOF, BACK, BOL, BRANCH, CLOSE, END, EOL, EXACTLY, NOTHING, OP, OPEN, OPERAND, PLUS, regbol, regendp, reginput, regnext(), regrepeat(), regstartp, and STAR.

Referenced by regtry().

                                           {
    const char* scan;   // Current node.
             const char* next;  // Next node.

    scan = prog;

    while (scan != NULL) {

    next = regnext(scan);

    switch (OP(scan)) {
        case BOL:
        if (reginput != regbol)
            return (0);
        break;
        case EOL:
        if (*reginput != '\0')
            return (0);
        break;
        case ANY:
        if (*reginput == '\0')
            return (0);
        reginput++;
        break;
        case EXACTLY:{
            int         len;
            const char* opnd;

            opnd = OPERAND(scan);
            // Inline the first character, for speed.
            if (*opnd != *reginput)
            return (0);
            len = (int)strlen(opnd);
            if (len > 1 && strncmp(opnd, reginput, len) != 0)
            return (0);
            reginput += len;
        }
        break;
        case ANYOF:
        if (*reginput == '\0' || strchr(OPERAND(scan), *reginput) == NULL)
            return (0);
        reginput++;
        break;
        case ANYBUT:
        if (*reginput == '\0' || strchr(OPERAND(scan), *reginput) != NULL)
            return (0);
        reginput++;
        break;
        case NOTHING:
        break;
        case BACK:
        break;
        case OPEN + 1:
        case OPEN + 2:
        case OPEN + 3:
        case OPEN + 4:
        case OPEN + 5:
        case OPEN + 6:
        case OPEN + 7:
        case OPEN + 8:
        case OPEN + 9:{
                  int    no;
            const char* save;

            no = OP(scan) - OPEN;
            save = reginput;

            if (regmatch(next)) {

            //
            // Don't set startp if some later invocation of the
            // same parentheses already has. 
            //
            if (regstartp[no] == NULL)
                regstartp[no] = save;
            return (1);
            }
            else
            return (0);
        }
//      break;
        case CLOSE + 1:
        case CLOSE + 2:
        case CLOSE + 3:
        case CLOSE + 4:
        case CLOSE + 5:
        case CLOSE + 6:
        case CLOSE + 7:
        case CLOSE + 8:
        case CLOSE + 9:{
                  int    no;
            const char* save;

            no = OP(scan) - CLOSE;
            save = reginput;

            if (regmatch(next)) {

            //
            // Don't set endp if some later invocation of the
            // same parentheses already has. 
            //
            if (regendp[no] == NULL)
                regendp[no] = save;
            return (1);
            }
            else
            return (0);
        }
//      break;
        case BRANCH:{
          
          const char* save;

            if (OP(next) != BRANCH) // No choice.
            next = OPERAND(scan);   // Avoid recursion.
            else {
            do {
                save = reginput;
                if (regmatch(OPERAND(scan)))
                return (1);
                reginput = save;
                scan = regnext(scan);
            } while (scan != NULL && OP(scan) == BRANCH);
            return (0);
            // NOTREACHED
            }
        }
        break;
        case STAR:
        case PLUS:{
          char   nextch;
            int        no;
            const char* save;
            int        min_no;

            //
            // Lookahead to avoid useless match attempts when we know
            // what character comes next. 
            //
            nextch = '\0';
            if (OP(next) == EXACTLY)
            nextch = *OPERAND(next);
            min_no = (OP(scan) == STAR) ? 0 : 1;
            save = reginput;
            no = regrepeat(OPERAND(scan));
            while (no >= min_no) {
            // If it could work, try it.
            if (nextch == '\0' || *reginput == nextch)
                if (regmatch(next))
                return (1);
            // Couldn't or didn't -- back up.
            no--;
            reginput = save + no;
            }
            return (0);
        }
//      break;
        case END:
        return (1); // Success!

        default:
            //RAISE Error, SYM(ossimRegExp), SYM(Internal_Error),
                printf ("ossimRegExp::find(): Internal error -- memory corrupted.\n");
        return 0;
    }
    scan = next;
    }

    // 
    //  We get here only if there's trouble -- normally "case END" is the
    //  terminating point. 
    // 
    //RAISE Error, SYM(ossimRegExp), SYM(Internal_Error),
    printf ("ossimRegExp::find(): Internal error -- corrupted pointers.\n");
    return (0);
}

regnext() [1/2]

const char * ossimRegExp::regnext ( const char *  p )

private

Definition at line 1268 of file ossimRegExp.cpp.

References BACK, NEXT, OP, and regdummy.

Referenced by compile(), reg(), regmatch(), and regtail().

                                               {
    int offset;

    if (p == &regdummy)
    return (NULL);

    offset = NEXT(p);
    if (offset == 0)
    return (NULL);

    if (OP(p) == BACK)
    return (p - offset);
    else
    return (p + offset);
}

regnext() [2/2]

char * ossimRegExp::regnext ( char *  p )

private

Definition at line 1285 of file ossimRegExp.cpp.

References BACK, NEXT, OP, and regdummy.

                                   {
    int offset;

    if (p == &regdummy)
    return (NULL);

    offset = NEXT(p);
    if (offset == 0)
    return (NULL);

    if (OP(p) == BACK)
    return (p - offset);
    else
    return (p + offset);
}

regnode()

char * ossimRegExp::regnode ( char  op )

private

Definition at line 814 of file ossimRegExp.cpp.

References regcode, regdummy, and regsize.

Referenced by reg(), regatom(), regbranch(), and regpiece().

                                   {
    char* ret;
    char* ptr;

    ret = regcode;
    if (ret == &regdummy) {
    regsize += 3;
    return (ret);
    }

    ptr = ret;
    *ptr++ = op;
    *ptr++ = '\0';      // Null "next" pointer.
    *ptr++ = '\0';
    regcode = ptr;

    return (ret);
}

regoptail()

void ossimRegExp::regoptail ( char *  p, const char *  val  )

private

Definition at line 905 of file ossimRegExp.cpp.

References BRANCH, OP, OPERAND, regdummy, and regtail().

Referenced by reg(), and regpiece().

                                                     {
    // "Operandless" and "op != BRANCH" are synonymous in practice.
    if (p == NULL || p == &regdummy || OP(p) != BRANCH)
    return;
    regtail(OPERAND(p), val);
}

regpiece()

char * ossimRegExp::regpiece ( int *  flagp )

private

Definition at line 622 of file ossimRegExp.cpp.

References BACK, BRANCH, HASWIDTH, ISMULT, NOTHING, PLUS, regatom(), reginsert(), regnode(), regoptail(), regparse, regtail(), SIMPLE, SPSTART, STAR, and WORST.

Referenced by regbranch().

                                       {
    char* ret;
    char  op;
    char* next;
    int            flags;

    ret = regatom(&flags);
    if (ret == NULL)
    return (NULL);

    op = *regparse;
    if (!ISMULT(op)) {
    *flagp = flags;
    return (ret);
    }

    if (!(flags & HASWIDTH) && op != '?') {
        //RAISE Error, SYM(ossimRegExp), SYM(Empty_Operand),
        printf ("ossimRegExp::compile() : *+ operand could be empty.\n");
    return 0;
    }
    *flagp = (op != '+') ? (WORST | SPSTART) : (WORST | HASWIDTH);

    if (op == '*' && (flags & SIMPLE))
    reginsert(STAR, ret);
    else if (op == '*') {
    // Emit x* as (x&|), where & means "self".
    reginsert(BRANCH, ret); // Either x
    regoptail(ret, regnode(BACK));  // and loop
    regoptail(ret, ret);    // back
    regtail(ret, regnode(BRANCH));  // or
    regtail(ret, regnode(NOTHING)); // null.
    }
    else if (op == '+' && (flags & SIMPLE))
    reginsert(PLUS, ret);
    else if (op == '+') {
    // Emit x+ as x(&|), where & means "self".
    next = regnode(BRANCH); // Either
    regtail(ret, next);
    regtail(regnode(BACK), ret);    // loop back
    regtail(next, regnode(BRANCH)); // or
    regtail(ret, regnode(NOTHING)); // null.
    }
    else if (op == '?') {
    // Emit x? as (x|)
    reginsert(BRANCH, ret); // Either x
    regtail(ret, regnode(BRANCH));  // or
    next = regnode(NOTHING);// null.
    regtail(ret, next);
    regoptail(ret, next);
    }
    regparse++;
    if (ISMULT(*regparse)) {
        //RAISE Error, SYM(ossimRegExp), SYM(Nested_Operand),
        printf ("ossimRegExp::compile(): Nested *?+.\n");
    return 0;
    }
    return (ret);
}

regrepeat()

int ossimRegExp::regrepeat ( const char *  p )

private

Definition at line 1225 of file ossimRegExp.cpp.

References ANY, ANYBUT, ANYOF, EXACTLY, OP, OPERAND, and reginput.

Referenced by regmatch().

                                         {
          int   count = 0;
    const char* scan;
    const char* opnd;

    scan = reginput;
    opnd = OPERAND(p);
    switch (OP(p)) {
    case ANY:
        count = (int)strlen(scan);
        scan += count;
        break;
    case EXACTLY:
        while (*opnd == *scan) {
        count++;
        scan++;
        }
        break;
    case ANYOF:
        while (*scan != '\0' && strchr(opnd, *scan) != NULL) {
        count++;
        scan++;
        }
        break;
    case ANYBUT:
        while (*scan != '\0' && strchr(opnd, *scan) == NULL) {
        count++;
        scan++;
        }
        break;
    default:        // Oh dear.  Called inappropriately.
        //RAISE Error, SYM(ossimRegExp), SYM(Internal_Error),
        printf ("ossimRegExp::find(): Internal error.\n");
        return 0;
    }
    reginput = scan;
    return (count);
}

regtail()

void ossimRegExp::regtail ( char *  p, const char *  val  )

private

Definition at line 876 of file ossimRegExp.cpp.

References BACK, OP, regdummy, and regnext().

Referenced by reg(), regbranch(), regoptail(), and regpiece().

                                                   {
    char* scan;
    char* temp;
    int   offset;

    if (p == &regdummy)
    return;

    // Find last node.
    scan = p;
    for (;;) {
    temp = regnext(scan);
    if (temp == NULL)
        break;
    scan = temp;
    }

    if (OP(scan) == BACK)
    offset = (const char*)scan - val;
    else
    offset = val - scan;
    *(scan + 1) = (offset >> 8) & 0377;
    *(scan + 2) = offset & 0377;
}

regtry()

int ossimRegExp::regtry ( const char *  string, const char **  start, const char **  end, const char *  prog  )

private

Definition at line 1006 of file ossimRegExp.cpp.

References end(), NSUBEXP, regendp, reginput, regmatch(), regstartp, and start().

Referenced by find().

                                               {
          int    i;
    const char* *sp1;
    const char* *ep;

    reginput = string;
    regstartp = start;
    regendp = end;

    sp1 = start;
    ep = end;
    for (i = NSUBEXP; i > 0; i--) {
    *sp1++ = NULL;
    *ep++ = NULL;
    }
    if (regmatch(prog + 1)) {
    start[0] = string;
    end[0] = reginput;
    return (1);
    }
    else
    return (0);
}

set_invalid()

void ossimRegExp::set_invalid ( )

inline

Definition at line 239 of file ossimRegExp.h.

References program.

                                      {
//#ifndef WIN32
  delete [] this->program;
//#endif
  this->program = NULL;
}

start() [1/2]

ossim_uint32 ossimRegExp::start ( ) const

inline

Definition at line 209 of file ossimRegExp.h.

References searchstring, and startp.

Referenced by ossimString::beforeRegExp(), ossimFilename::drive(), ossimString::expandEnvironmentVariable(), ossimString::fromRegExp(), ossimKeywordlist::getSubstringKeyList(), ossimString::match(), regtry(), ossimString::replaceAllThatMatch(), ossimString::replaceStrThatMatch(), ossimSrtmFilename::setFilename(), and ossimKeywordlist::stripPrefixFromAll().

                                              {
  return(this->startp[0] - searchstring);
}

start() [2/2]

ossim_uint32 ossimRegExp::start ( ossim_uint32  n ) const

inline

Definition at line 247 of file ossimRegExp.h.

References n, searchstring, and startp.

{
  return this->startp[n] - searchstring;
}

Member Data Documentation

endp

const char* ossimRegExp::endp[NSUBEXP]

private

Definition at line 101 of file ossimRegExp.h.

Referenced by compile(), deep_equal(), end(), find(), match(), and ossimRegExp().

program

char* ossimRegExp::program

private

Definition at line 106 of file ossimRegExp.h.

Referenced by compile(), deep_equal(), find(), is_valid(), operator==(), ossimRegExp(), set_invalid(), and ~ossimRegExp().

progsize

ossim_uint32 ossimRegExp::progsize

private

Definition at line 107 of file ossimRegExp.h.

Referenced by compile(), deep_equal(), operator==(), and ossimRegExp().

reganch

char ossimRegExp::reganch

private

Definition at line 103 of file ossimRegExp.h.

Referenced by compile(), find(), and ossimRegExp().

regbol

const char* ossimRegExp::regbol

private

Definition at line 117 of file ossimRegExp.h.

Referenced by find(), and regmatch().

regcode

char* ossimRegExp::regcode

mutableprivate

Definition at line 114 of file ossimRegExp.h.

Referenced by compile(), regc(), reginsert(), and regnode().

regdummy

char ossimRegExp::regdummy

mutableprivate

Definition at line 113 of file ossimRegExp.h.

Referenced by compile(), regc(), reginsert(), regnext(), regnode(), regoptail(), and regtail().

regendp

const char* * ossimRegExp::regendp

private

Definition at line 119 of file ossimRegExp.h.

Referenced by regmatch(), and regtry().

reginput

const char* ossimRegExp::reginput

private

Definition at line 116 of file ossimRegExp.h.

Referenced by regmatch(), regrepeat(), and regtry().

regmlen

ossim_uint32 ossimRegExp::regmlen

private

Definition at line 105 of file ossimRegExp.h.

Referenced by compile(), find(), and ossimRegExp().

regmust

const char* ossimRegExp::regmust

private

Definition at line 104 of file ossimRegExp.h.

Referenced by compile(), find(), and ossimRegExp().

regnpar

int ossimRegExp::regnpar

mutableprivate

Definition at line 112 of file ossimRegExp.h.

Referenced by compile(), and reg().

regparse

const char* ossimRegExp::regparse

mutableprivate

Definition at line 111 of file ossimRegExp.h.

Referenced by compile(), reg(), regatom(), regbranch(), and regpiece().

regsize

long ossimRegExp::regsize

mutableprivate

Definition at line 115 of file ossimRegExp.h.

Referenced by compile(), regc(), reginsert(), and regnode().

regstart

char ossimRegExp::regstart

private

Definition at line 102 of file ossimRegExp.h.

Referenced by compile(), find(), and ossimRegExp().

regstartp

const char* * ossimRegExp::regstartp

private

Definition at line 118 of file ossimRegExp.h.

Referenced by regmatch(), and regtry().

searchstring

const char* ossimRegExp::searchstring

private

Definition at line 108 of file ossimRegExp.h.

Referenced by compile(), end(), find(), and start().

startp

const char* ossimRegExp::startp[NSUBEXP]

private

Definition at line 100 of file ossimRegExp.h.

Referenced by compile(), deep_equal(), find(), match(), ossimRegExp(), and start().

---

The documentation for this class was generated from the following files:

• ossimRegExp.h
• ossimRegExp.cpp