Back to index

lightning-sunbird  0.9+nobinonly
Defines | Functions
portreg.c File Reference
#include "seccomon.h"
#include "portreg.h"

Go to the source code of this file.

Defines

#define MATCH   0
#define NOMATCH   1
#define ABORTED   -1

Functions

static int _valid_subexp (const char *exp, char stop)
int PORT_RegExpValid (const char *exp)
static int _shexp_match (const char *str, const char *exp, PRBool case_insensitive)
static int _handle_union (const char *str, const char *exp, PRBool case_insensitive)
static int port_RegExpMatch (const char *str, const char *xp, PRBool case_insensitive)
int PORT_RegExpSearch (const char *str, const char *exp)
int PORT_RegExpCaseSearch (const char *str, const char *exp)

Define Documentation

#define ABORTED   -1

Definition at line 137 of file portreg.c.

#define MATCH   0

Definition at line 135 of file portreg.c.

#define NOMATCH   1

Definition at line 136 of file portreg.c.


Function Documentation

static int _handle_union ( const char *  str,
const char *  exp,
PRBool  case_insensitive 
) [static]

Definition at line 142 of file portreg.c.

{
    char *e2 = (char *) PORT_Alloc(sizeof(char)*strlen(exp));
    register int t,p2,p1 = 1;
    int cp;

    while(1) {
        for(cp=1;exp[cp] != ')';cp++)
            if(exp[cp] == '\\')
                ++cp;
        for(p2 = 0;(exp[p1] != '|') && (p1 != cp);p1++,p2++) {
            if(exp[p1] == '\\')
                e2[p2++] = exp[p1++];
            e2[p2] = exp[p1];
        }
        for (t=cp+1; ((e2[p2] = exp[t]) != 0); ++t,++p2) {}
        if(_shexp_match(str,e2, case_insensitive) == MATCH) {
            PORT_Free(e2);
            return MATCH;
        }
        if(p1 == cp) {
            PORT_Free(e2);
            return NOMATCH;
        }
        else ++p1;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int _shexp_match ( const char *  str,
const char *  exp,
PRBool  case_insensitive 
) [static]

Definition at line 172 of file portreg.c.

{
    register int x,y;
    int ret,neg;

    ret = 0;
    for(x=0,y=0;exp[y];++y,++x) {
        if((!str[x]) && (exp[y] != '(') && (exp[y] != '$') && (exp[y] != '*'))
            ret = ABORTED;
        else {
            switch(exp[y]) {
              case '$':
                if( (str[x]) )
                    ret = NOMATCH;
                else
                    --x;             /* we don't want loop to increment x */
                break;
              case '*':
                while(exp[++y] == '*'){}
                if(!exp[y])
                    return MATCH;
                while(str[x]) {
                    switch(_shexp_match(&str[x++],&exp[y], case_insensitive)) {
                    case NOMATCH:
                        continue;
                    case ABORTED:
                        ret = ABORTED;
                        break;
                    default:
                        return MATCH;
                    }
                    break;
                }
                if((exp[y] == '$') && (exp[y+1] == '\0') && (!str[x]))
                    return MATCH;
                else
                    ret = ABORTED;
                break;
              case '[':
                     neg = ((exp[++y] == '^') && (exp[y+1] != ']'));
                if (neg)
                    ++y;
                
                if ((isalnum(exp[y])) && (exp[y+1] == '-') && 
                   (isalnum(exp[y+2])) && (exp[y+3] == ']'))
                    {
                        int start = exp[y], end = exp[y+2];
                        
                        /* no safeguards here */
                        if(neg ^ ((str[x] < start) || (str[x] > end))) {
                            ret = NOMATCH;
                            break;
                        }
                        y+=3;
                    }
                else {
                    int matched;
                    
                    for (matched=0;exp[y] != ']';y++)
                        matched |= (str[x] == exp[y]);
                    if (neg ^ (!matched))
                        ret = NOMATCH;
                }
                break;
              case '(':
                return _handle_union(&str[x],&exp[y], case_insensitive);
                break;
              case '?':
                break;
              case '\\':
                ++y;
              default:
              if(case_insensitive)
                {
                    if(toupper(str[x]) != toupper(exp[y]))
                        ret = NOMATCH;
                }
              else
                {
                    if(str[x] != exp[y])
                        ret = NOMATCH;
                }
                break;
            }
        }
        if(ret)
            break;
    }
    return (ret ? ret : (str[x] ? NOMATCH : MATCH));
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int _valid_subexp ( const char *  exp,
char  stop 
) [static]

Definition at line 53 of file portreg.c.

{
    register int x,y,t;
    int nsc,np,tld;

    x=0;nsc=0;tld=0;

    while(exp[x] && (exp[x] != stop)) {
        switch(exp[x]) {
          case '~':
            if(tld) return INVALID_SXP;
            else ++tld;
          case '*':
          case '?':
          case '^':
          case '$':
            ++nsc;
            break;
          case '[':
            ++nsc;
            if((!exp[++x]) || (exp[x] == ']'))
                return INVALID_SXP;
            for(++x;exp[x] && (exp[x] != ']');++x)
                if(exp[x] == '\\')
                    if(!exp[++x])
                        return INVALID_SXP;
            if(!exp[x])
                return INVALID_SXP;
            break;
          case '(':
            ++nsc;np = 0;
            while(1) {
                if(exp[++x] == ')')
                    return INVALID_SXP;
                for(y=x;(exp[y]) && (exp[y] != '|') && (exp[y] != ')');++y)
                    if(exp[y] == '\\')
                        if(!exp[++y])
                            return INVALID_SXP;
                if(!exp[y])
                    return INVALID_SXP;
                if(exp[y] == '|')
                    ++np;
                t = _valid_subexp(&exp[x],exp[y]);
                if(t == INVALID_SXP)
                    return INVALID_SXP;
                x+=t;
                if(exp[x] == ')') {
                    if(!np)
                        return INVALID_SXP;
                    break;
                }
            }
            break;
          case ')':
          case ']':
            return INVALID_SXP;
          case '\\':
            if(!exp[++x])
                return INVALID_SXP;
          default:
            break;
        }
        ++x;
    }
    if((!stop) && (!nsc))
        return NON_SXP;
    return ((exp[x] == stop) ? x : INVALID_SXP);
}

Here is the caller graph for this function:

int PORT_RegExpCaseSearch ( const char *  str,
const char *  exp 
)

Definition at line 309 of file portreg.c.

{
    switch(PORT_RegExpValid(exp))
      {
        case INVALID_SXP:
            return -1;
        case NON_SXP:
            return (PORT_Strcasecmp(exp,str) ? 1 : 0);
        default:
            return port_RegExpMatch(str, exp, PR_TRUE);
      }
}

Here is the call graph for this function:

static int port_RegExpMatch ( const char *  str,
const char *  xp,
PRBool  case_insensitive 
) [static]

Definition at line 264 of file portreg.c.

                                                                           {
    register int x;
    char *exp = 0;

    exp = PORT_Strdup(xp);

    if(!exp)
       return 1;

    for(x=strlen(exp)-1;x;--x) {
        if((exp[x] == '~') && (exp[x-1] != '\\')) {
            exp[x] = '\0';
            if(_shexp_match(str,&exp[++x], case_insensitive) == MATCH)
                goto punt;
            break;
        }
    }
    if(_shexp_match(str,exp, case_insensitive) == MATCH) {
        PORT_Free(exp);
        return 0;
    }

  punt:
    PORT_Free(exp);
    return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int PORT_RegExpSearch ( const char *  str,
const char *  exp 
)

Definition at line 295 of file portreg.c.

{
    switch(PORT_RegExpValid(exp)) 
         {
        case INVALID_SXP:
            return -1;
        case NON_SXP:
            return (strcmp(exp,str) ? 1 : 0);
        default:
            return port_RegExpMatch(str, exp, PR_FALSE);
      }
}

Here is the call graph for this function:

int PORT_RegExpValid ( const char *  exp)

Definition at line 123 of file portreg.c.

{
    int x;

    x = _valid_subexp(exp, '\0');
    return (x < 0 ? x : VALID_SXP);
}

Here is the call graph for this function: