src/squirrel/sqstdlib/sqstdrex.c

   1 /* see copyright notice in squirrel.h */
   2 #include <squirrel.h>
   3 #include <string.h>
   4 #include <ctype.h>
   5 #include <setjmp.h>
   6 #include "sqstdstring.h"
   7
   8 #ifdef _DEBUG
   9 #include <stdio.h>
  10
  11 static const SQChar *g_nnames[] =
  12 {
  13         _SC("NONE"),_SC("OP_GREEDY"),   _SC("OP_OR"),
  14         _SC("OP_EXPR"),_SC("OP_NOCAPEXPR"),_SC("OP_DOT"),       _SC("OP_CLASS"),
  15         _SC("OP_CCLASS"),_SC("OP_NCLASS"),_SC("OP_RANGE"),_SC("OP_CHAR"),
  16         _SC("OP_EOL"),_SC("OP_BOL"),_SC("OP_WB")
  17 };
  18
  19 #endif
  20
  21 #define OP_GREEDY               MAX_CHAR+1 // * + ? {n}
  22 #define OP_OR                   MAX_CHAR+2
  23 #define OP_EXPR                 MAX_CHAR+3 //parentesis ()
  24 #define OP_NOCAPEXPR    MAX_CHAR+4 //parentesis (?:)
  25 #define OP_DOT                  MAX_CHAR+5
  26 #define OP_CLASS                MAX_CHAR+6
  27 #define OP_CCLASS               MAX_CHAR+7
  28 #define OP_NCLASS               MAX_CHAR+8 //negates class the [^
  29 #define OP_RANGE                MAX_CHAR+9
  30 #define OP_CHAR                 MAX_CHAR+10
  31 #define OP_EOL                  MAX_CHAR+11
  32 #define OP_BOL                  MAX_CHAR+12
  33 #define OP_WB                   MAX_CHAR+13
  34
  35 #define SQREX_SYMBOL_ANY_CHAR '.'
  36 #define SQREX_SYMBOL_GREEDY_ONE_OR_MORE '+'
  37 #define SQREX_SYMBOL_GREEDY_ZERO_OR_MORE '*'
  38 #define SQREX_SYMBOL_GREEDY_ZERO_OR_ONE '?'
  39 #define SQREX_SYMBOL_BRANCH '|'
  40 #define SQREX_SYMBOL_END_OF_STRING '$'
  41 #define SQREX_SYMBOL_BEGINNING_OF_STRING '^'
  42 #define SQREX_SYMBOL_ESCAPE_CHAR '\\'
  43
  44
  45 typedef int SQRexNodeType;
  46
  47 typedef struct tagSQRexNode{
  48         SQRexNodeType type;
  49         long left;
  50         long right;
  51         int next;
  52 }SQRexNode;
  53
  54 struct SQRex{
  55         const SQChar *_eol;
  56         const SQChar *_bol;
  57         const SQChar *_p;
  58         int _first;
  59         int _op;
  60         SQRexNode *_nodes;
  61         int _nallocated;
  62         int _nsize;
  63         int _nsubexpr;
  64         SQRexMatch *_matches;
  65         int _currsubexp;
  66         void *_jmpbuf;
  67         const SQChar **_error;
  68 };
  69
  70 static int sqstd_rex_list(SQRex *exp);
  71
  72 static int sqstd_rex_newnode(SQRex *exp, SQRexNodeType type)
  73 {
  74         SQRexNode n;
  75         n.type = type;
  76         n.next = n.right = n.left = -1;
  77         if(type == OP_EXPR)
  78                 n.right = exp->_nsubexpr++;
  79         if(exp->_nallocated < (exp->_nsize + 1)) {
  80                 int oldsize = exp->_nallocated;
  81                 exp->_nallocated *= 2;
  82                 exp->_nodes = (SQRexNode *)sq_realloc(exp->_nodes, oldsize * sizeof(SQRexNode) ,exp->_nallocated * sizeof(SQRexNode));
  83         }
  84         exp->_nodes[exp->_nsize++] = n;
  85         return (int)exp->_nsize - 1;
  86 }
  87
  88 static void sqstd_rex_error(SQRex *exp,const SQChar *error)
  89 {
  90         if(exp->_error) *exp->_error = error;
  91         longjmp(*((jmp_buf*)exp->_jmpbuf),-1);
  92 }
  93
  94 static void sqstd_rex_expect(SQRex *exp, int n){
  95         if((*exp->_p) != n)
  96                 sqstd_rex_error(exp, _SC("expected paren"));
  97         exp->_p++;
  98 }
  99
 100 static SQBool sqstd_rex_ischar(SQChar c)
 101 {
 102         switch(c) {
 103         case SQREX_SYMBOL_BRANCH:case SQREX_SYMBOL_GREEDY_ZERO_OR_MORE:
 104         case SQREX_SYMBOL_GREEDY_ZERO_OR_ONE:case SQREX_SYMBOL_GREEDY_ONE_OR_MORE:
 105         case SQREX_SYMBOL_BEGINNING_OF_STRING:case SQREX_SYMBOL_END_OF_STRING:
 106         case SQREX_SYMBOL_ANY_CHAR:case SQREX_SYMBOL_ESCAPE_CHAR:case '(':case ')':case '[':case '{': case '}':
 107                 return SQFalse;
 108     }
 109         return SQTrue;
 110 }
 111
 112 static SQChar sqstd_rex_escapechar(SQRex *exp)
 113 {
 114         if(*exp->_p == SQREX_SYMBOL_ESCAPE_CHAR){
 115                 exp->_p++;
 116                 switch(*exp->_p) {
 117                 case 'v': exp->_p++; return '\v';
 118                 case 'n': exp->_p++; return '\n';
 119                 case 't': exp->_p++; return '\t';
 120                 case 'r': exp->_p++; return '\r';
 121                 case 'f': exp->_p++; return '\f';
 122                 default: return (*exp->_p++);
 123                 }
 124         } else if(!sqstd_rex_ischar(*exp->_p)) sqstd_rex_error(exp,_SC("letter expected"));
 125         return (*exp->_p++);
 126 }
 127
 128 static int sqstd_rex_charclass(SQRex *exp,int classid)
 129 {
 130         int n = sqstd_rex_newnode(exp,OP_CCLASS);
 131         exp->_nodes[n].left = classid;
 132         return n;
 133 }
 134
 135 static int sqstd_rex_charnode(SQRex *exp,SQBool isclass)
 136 {
 137         if(*exp->_p == SQREX_SYMBOL_ESCAPE_CHAR) {
 138                 exp->_p++;
 139                 switch(*exp->_p) {
 140                         case 'n': exp->_p++; return sqstd_rex_newnode(exp,'\n');
 141                         case 't': exp->_p++; return sqstd_rex_newnode(exp,'\t');
 142                         case 'r': exp->_p++; return sqstd_rex_newnode(exp,'\r');
 143                         case 'f': exp->_p++; return sqstd_rex_newnode(exp,'\f');
 144                         case 'v': exp->_p++; return sqstd_rex_newnode(exp,'\v');
 145                         case 'a': case 'A': case 'w': case 'W': case 's': case 'S':
 146                         case 'd': case 'D': case 'x': case 'X': case 'c': case 'C':
 147                         case 'p': case 'P': case 'l': case 'u':
 148                                 {
 149                                 SQChar t = *exp->_p;
 150                                 exp->_p++;
 151                                 return sqstd_rex_charclass(exp,t);
 152                                 }
 153                         case 'b':
 154                         case 'B':
 155                                 if(!isclass) {
 156                                         int node = sqstd_rex_newnode(exp,OP_WB);
 157                                         exp->_nodes[node].left = *exp->_p;
 158                                         exp->_p++;
 159                                         return node;
 160                                 } //else default
 161                         default: return sqstd_rex_newnode(exp,(*exp->_p++));
 162                 }
 163         }
 164         else if(!sqstd_rex_ischar(*exp->_p)) {
 165
 166                 sqstd_rex_error(exp,_SC("letter expected"));
 167         }
 168         return sqstd_rex_newnode(exp,*exp->_p++);
 169 }
 170 static int sqstd_rex_class(SQRex *exp)
 171 {
 172         int ret = -1;
 173         int first = -1,chain;
 174         if(*exp->_p == SQREX_SYMBOL_BEGINNING_OF_STRING){
 175                 ret = sqstd_rex_newnode(exp,OP_NCLASS);
 176                 exp->_p++;
 177         }else ret = sqstd_rex_newnode(exp,OP_CLASS);
 178
 179         if(*exp->_p == ']' || *exp->_p == '-'){
 180                 first = *exp->_p;
 181                 exp->_p++;
 182         }
 183         chain = ret;
 184         while(*exp->_p != ']' && exp->_p != exp->_eol) {
 185                 if(*exp->_p == '-' && first != -1){
 186                         int r;
 187                         if(*exp->_p++ == ']') sqstd_rex_error(exp,_SC("unfinished range"));
 188                         r = sqstd_rex_newnode(exp,OP_RANGE);
 189                         if(first>*exp->_p) sqstd_rex_error(exp,_SC("invalid range"));
 190                         if(exp->_nodes[first].type == OP_CCLASS) sqstd_rex_error(exp,_SC("cannot use character classes in ranges"));
 191                         exp->_nodes[r].left = exp->_nodes[first].type;
 192                         exp->_nodes[r].right = sqstd_rex_escapechar(exp);
 193             exp->_nodes[chain].next = r;
 194                         chain = r;
 195                         first = -1;
 196                 }
 197                 else{
 198                         if(first!=-1){
 199                                 int c = first;
 200                                 exp->_nodes[chain].next = c;
 201                                 chain = c;
 202                                 first = sqstd_rex_charnode(exp,SQTrue);
 203                         }
 204                         else{
 205                                 first = sqstd_rex_charnode(exp,SQTrue);
 206                         }
 207                 }
 208         }
 209         if(first!=-1){
 210                 int c = first;
 211                 exp->_nodes[chain].next = c;
 212                 chain = c;
 213                 first = -1;
 214         }
 215         /* hack? */
 216         exp->_nodes[ret].left = exp->_nodes[ret].next;
 217         exp->_nodes[ret].next = -1;
 218         return ret;
 219 }
 220
 221 static int sqstd_rex_parsenumber(SQRex *exp)
 222 {
 223         int ret = *exp->_p-'0';
 224         int positions = 10;
 225         exp->_p++;
 226         while(isdigit(*exp->_p)) {
 227                 ret = ret*10+(*exp->_p++-'0');
 228                 if(positions==1000000000) sqstd_rex_error(exp,_SC("overflow in numeric constant"));
 229                 positions *= 10;
 230         };
 231         return ret;
 232 }
 233
 234 static int sqstd_rex_element(SQRex *exp)
 235 {
 236         int ret;
 237         switch(*exp->_p)
 238         {
 239         case '(': {
 240                 int expr;
 241                 exp->_p++;
 242
 243
 244                 if(*exp->_p =='?') {
 245                         exp->_p++;
 246                         sqstd_rex_expect(exp,':');
 247                         expr = sqstd_rex_newnode(exp,OP_NOCAPEXPR);
 248                 }
 249                 else
 250                         expr = sqstd_rex_newnode(exp,OP_EXPR);
 251                 exp->_nodes[expr].left = sqstd_rex_list(exp);
 252                 ret = expr;
 253                 sqstd_rex_expect(exp,')');
 254         }
 255                 break;
 256         case '[':
 257                 exp->_p++;
 258                 ret = sqstd_rex_class(exp);
 259                 sqstd_rex_expect(exp,']');
 260                 break;
 261         case SQREX_SYMBOL_END_OF_STRING: exp->_p++; ret = sqstd_rex_newnode(exp,OP_EOL);break;
 262         case SQREX_SYMBOL_ANY_CHAR: exp->_p++; ret = sqstd_rex_newnode(exp,OP_DOT);break;
 263         default:
 264                 ret = sqstd_rex_charnode(exp,SQFalse);
 265                 break;
 266         }
 267         /* scope block */
 268         {
 269                 int op;
 270                 unsigned short p0 = 0, p1 = 0;
 271                 switch(*exp->_p){
 272                 case SQREX_SYMBOL_GREEDY_ZERO_OR_MORE: p0 = 0; p1 = 0xFFFF; exp->_p++; goto __end;
 273                 case SQREX_SYMBOL_GREEDY_ONE_OR_MORE: p0 = 1; p1 = 0xFFFF; exp->_p++; goto __end;
 274                 case SQREX_SYMBOL_GREEDY_ZERO_OR_ONE: p0 = 0; p1 = 1; exp->_p++; goto __end;
 275                 case '{':{
 276                         exp->_p++;
 277                         if(!isdigit(*exp->_p)) sqstd_rex_error(exp,_SC("number expected"));
 278                         p0 = sqstd_rex_parsenumber(exp);
 279                         switch(*exp->_p) {
 280                         case '}':
 281                                 p1 = p0; exp->_p++;
 282                                 goto __end;
 283                         case ',':
 284                                 exp->_p++;
 285                                 p1 = 0xFFFF;
 286                                 if(isdigit(*exp->_p)){
 287                                         p1 = sqstd_rex_parsenumber(exp);
 288                                 }
 289                                 sqstd_rex_expect(exp,'}');
 290                                 goto __end;
 291                         default:
 292                                 sqstd_rex_error(exp,_SC(", or } expected"));
 293                         }
 294                 }
 295                 __end: {
 296                                 int nnode = sqstd_rex_newnode(exp,OP_GREEDY);
 297                                 op = OP_GREEDY;
 298                                 exp->_nodes[nnode].left = ret;
 299                                 exp->_nodes[nnode].right = ((p0)<<16)|p1;
 300                                 ret = nnode;
 301                         }
 302                 }
 303         }
 304         if(*exp->_p != SQREX_SYMBOL_BRANCH && *exp->_p != ')' && *exp->_p != SQREX_SYMBOL_GREEDY_ZERO_OR_MORE && *exp->_p != SQREX_SYMBOL_GREEDY_ONE_OR_MORE && *exp->_p != '\0')
 305                 exp->_nodes[ret].next = sqstd_rex_element(exp);
 306         return ret;
 307 }
 308
 309 static int sqstd_rex_list(SQRex *exp)
 310 {
 311         int ret=-1,e;
 312         if(*exp->_p == SQREX_SYMBOL_BEGINNING_OF_STRING) {
 313                 exp->_p++;
 314                 ret = sqstd_rex_newnode(exp,OP_BOL);
 315         }
 316         e = sqstd_rex_element(exp);
 317         if(ret != -1) {
 318                 exp->_nodes[ret].next = e;
 319         }
 320         else ret = e;
 321
 322         if(*exp->_p == SQREX_SYMBOL_BRANCH) {
 323                 int temp;
 324                 exp->_p++;
 325                 temp = sqstd_rex_newnode(exp,OP_OR);
 326                 exp->_nodes[temp].left = ret;
 327                 exp->_nodes[temp].right = sqstd_rex_list(exp);
 328                 ret = temp;
 329         }
 330         return ret;
 331 }
 332
 333 static SQBool sqstd_rex_matchcclass(int cclass,SQChar c)
 334 {
 335         switch(cclass) {
 336         case 'a': return isalpha(c)?SQTrue:SQFalse;
 337         case 'A': return !isalpha(c)?SQTrue:SQFalse;
 338         case 'w': return (isalnum(c) || c == '_')?SQTrue:SQFalse;
 339         case 'W': return (!isalnum(c) && c != '_')?SQTrue:SQFalse;
 340         case 's': return isspace(c)?SQTrue:SQFalse;
 341         case 'S': return !isspace(c)?SQTrue:SQFalse;
 342         case 'd': return isdigit(c)?SQTrue:SQFalse;
 343         case 'D': return !isdigit(c)?SQTrue:SQFalse;
 344         case 'x': return isxdigit(c)?SQTrue:SQFalse;
 345         case 'X': return !isxdigit(c)?SQTrue:SQFalse;
 346         case 'c': return iscntrl(c)?SQTrue:SQFalse;
 347         case 'C': return !iscntrl(c)?SQTrue:SQFalse;
 348         case 'p': return ispunct(c)?SQTrue:SQFalse;
 349         case 'P': return !ispunct(c)?SQTrue:SQFalse;
 350         case 'l': return islower(c)?SQTrue:SQFalse;
 351         case 'u': return isupper(c)?SQTrue:SQFalse;
 352         }
 353         return SQFalse; /*cannot happen*/
 354 }
 355
 356 static SQBool sqstd_rex_matchclass(SQRex* exp,SQRexNode *node,SQChar c)
 357 {
 358         do {
 359                 switch(node->type) {
 360                         case OP_RANGE:
 361                                 if(c >= node->left && c <= node->right) return SQTrue;
 362                                 break;
 363                         case OP_CCLASS:
 364                                 if(sqstd_rex_matchcclass(node->left,c)) return SQTrue;
 365                                 break;
 366                         default:
 367                                 if(c == node->type)return SQTrue;
 368                 }
 369         } while((node->next != -1) && (node = &exp->_nodes[node->next]));
 370         return SQFalse;
 371 }
 372
 373 static const SQChar *sqstd_rex_matchnode(SQRex* exp,SQRexNode *node,const SQChar *str)
 374 {
 375         SQRexNodeType type = node->type;
 376         switch(type) {
 377         case OP_GREEDY: {
 378                 int p0 = (node->right >> 16)&0x0000FFFF, p1 = node->right&0x0000FFFF, nmaches = 0;
 379                 const SQChar *s=str, *good = str;
 380                 while((nmaches == 0xFFFF || nmaches < p1)
 381                         && (s = sqstd_rex_matchnode(exp,&exp->_nodes[node->left],s))) {
 382                         good=s;
 383                         nmaches++;
 384                         if(s >= exp->_eol)
 385                                 break;
 386                 }
 387                 if(p0 == p1 && p0 == nmaches) return good;
 388                 else if(nmaches >= p0 && p1 == 0xFFFF) return good;
 389                 else if(nmaches >= p0 && nmaches <= p1) return good;
 390                 return NULL;
 391         }
 392         case OP_OR: {
 393                         const SQChar *asd = str;
 394                         SQRexNode *temp=&exp->_nodes[node->left];
 395                         while(asd = sqstd_rex_matchnode(exp,temp,asd)) {
 396                                 if(temp->next != -1)
 397                                         temp = &exp->_nodes[temp->next];
 398                                 else
 399                                         return asd;
 400                         }
 401                         asd = str;
 402                         temp = &exp->_nodes[node->right];
 403                         while(asd = sqstd_rex_matchnode(exp,temp,asd)) {
 404                                 if(temp->next != -1)
 405                                         temp = &exp->_nodes[temp->next];
 406                                 else
 407                                         return asd;
 408                         }
 409                         return NULL;
 410                         break;
 411         }
 412         case OP_EXPR:
 413         case OP_NOCAPEXPR:{
 414                         SQRexNode *n = &exp->_nodes[node->left];
 415                         const SQChar *cur = str;
 416                         int capture = -1;
 417                         if(node->type != OP_NOCAPEXPR && node->right == exp->_currsubexp) {
 418                                 capture = exp->_currsubexp;
 419                                 exp->_matches[capture].begin = cur;
 420                                 exp->_currsubexp++;
 421                         }
 422
 423                         do {
 424                                 if(!(cur = sqstd_rex_matchnode(exp,n,cur))) {
 425                                         if(capture != -1){
 426                                                 exp->_matches[capture].begin = 0;
 427                                                 exp->_matches[capture].len = 0;
 428                                         }
 429                                         return NULL;
 430                                 }
 431                         } while((n->next != -1) && (n = &exp->_nodes[n->next]));
 432
 433                         if(capture != -1)
 434                                 exp->_matches[capture].len = cur - exp->_matches[capture].begin;
 435                         return cur;
 436         }
 437         case OP_WB:
 438                 if(str == exp->_bol && !isspace(*str)
 439                  || (str == exp->_eol && !isspace(*(str-1)))
 440                  || (!isspace(*str) && isspace(*(str+1)))
 441                  || (isspace(*str) && !isspace(*(str+1))) ) {
 442                         return (node->left == 'b')?str:NULL;
 443                 }
 444                 return (node->left == 'b')?NULL:str;
 445         case OP_BOL:
 446                 if(str == exp->_bol) return str;
 447                 return NULL;
 448         case OP_EOL:
 449                 if(str == exp->_eol) return str;
 450                 return NULL;
 451         case OP_DOT:
 452                 *str++;
 453                 return str;
 454         case OP_NCLASS:
 455         case OP_CLASS:
 456                 if(sqstd_rex_matchclass(exp,&exp->_nodes[node->left],*str)?(type == OP_CLASS?SQTrue:SQFalse):(type == OP_NCLASS?SQTrue:SQFalse)) {
 457                         *str++;
 458                         return str;
 459                 }
 460                 return NULL;
 461         case OP_CCLASS:
 462                 if(sqstd_rex_matchcclass(node->left,*str)) {
 463                         *str++;
 464                         return str;
 465                 }
 466                 return NULL;
 467         default: /* char */
 468                 if(*str != node->type) return NULL;
 469                 *str++;
 470                 return str;
 471         }
 472         return NULL;
 473 }
 474
 475 /* public api */
 476 SQRex *sqstd_rex_compile(const SQChar *pattern,const SQChar **error)
 477 {
 478         SQRex *exp = (SQRex *)sq_malloc(sizeof(SQRex));
 479         exp->_p = pattern;
 480         exp->_nallocated = (int)scstrlen(pattern) * sizeof(SQChar);
 481         exp->_nodes = (SQRexNode *)sq_malloc(exp->_nallocated * sizeof(SQRexNode));
 482         exp->_nsize = 0;
 483         exp->_matches = 0;
 484         exp->_nsubexpr = 0;
 485         exp->_first = sqstd_rex_newnode(exp,OP_EXPR);
 486         exp->_error = error;
 487         exp->_jmpbuf = sq_malloc(sizeof(jmp_buf));
 488         if(setjmp(*((jmp_buf*)exp->_jmpbuf)) == 0) {
 489                 exp->_nodes[exp->_first].left=sqstd_rex_list(exp);
 490                 if(*exp->_p!='\0')
 491                         sqstd_rex_error(exp,_SC("unexpected character"));
 492 #ifdef _DEBUG
 493                 {
 494                         int nsize,i;
 495                         SQRexNode *t;
 496                         nsize = exp->_nsize;
 497                         t = &exp->_nodes[0];
 498                         scprintf(_SC("\n"));
 499                         for(i = 0;i < nsize; i++) {
 500                                 if(exp->_nodes[i].type>MAX_CHAR)
 501                                         scprintf(_SC("[%02d] %10s "),i,g_nnames[exp->_nodes[i].type-MAX_CHAR]);
 502                                 else
 503                                         scprintf(_SC("[%02d] %10c "),i,exp->_nodes[i].type);
 504                                 scprintf(_SC("left %02d right %02d next %02d\n"),exp->_nodes[i].left,exp->_nodes[i].right,exp->_nodes[i].next);
 505                         }
 506                         scprintf(_SC("\n"));
 507                 }
 508 #endif
 509                 exp->_matches = (SQRexMatch *) sq_malloc(exp->_nsubexpr * sizeof(SQRexMatch));
 510                 memset(exp->_matches,0,exp->_nsubexpr * sizeof(SQRexMatch));
 511         }
 512         else{
 513                 sqstd_rex_free(exp);
 514                 return NULL;
 515         }
 516         return exp;
 517 }
 518
 519 void sqstd_rex_free(SQRex *exp)
 520 {
 521         if(exp) {
 522                 if(exp->_nodes) sq_free(exp->_nodes,exp->_nallocated * sizeof(SQRexNode));
 523                 if(exp->_jmpbuf) sq_free(exp->_jmpbuf,sizeof(jmp_buf));
 524                 if(exp->_matches) sq_free(exp->_matches,exp->_nsubexpr * sizeof(SQRexMatch));
 525                 sq_free(exp,sizeof(SQRex));
 526         }
 527 }
 528
 529 SQBool sqstd_rex_match(SQRex* exp,const SQChar* text)
 530 {
 531         const SQChar* res = NULL;
 532         exp->_bol = text;
 533         exp->_eol = text + scstrlen(text);
 534         exp->_currsubexp = 0;
 535         res = sqstd_rex_matchnode(exp,exp->_nodes,text);
 536         if(res == NULL || res != exp->_eol)
 537                 return SQFalse;
 538         return SQTrue;
 539 }
 540
 541 SQBool sqstd_rex_searchrange(SQRex* exp,const SQChar* text_begin,const SQChar* text_end,const SQChar** out_begin, const SQChar** out_end)
 542 {
 543         const SQChar *cur = NULL;
 544         int node = exp->_first;
 545         if(text_begin >= text_end) return SQFalse;
 546         exp->_bol = text_begin;
 547         exp->_eol = text_end;
 548         do {
 549                 cur = text_begin;
 550                 while(node != -1) {
 551                         exp->_currsubexp = 0;
 552                         cur = sqstd_rex_matchnode(exp,&exp->_nodes[node],cur);
 553                         if(!cur)
 554                                 break;
 555                         node = exp->_nodes[node].next;
 556                 }
 557                 *text_begin++;
 558         } while(cur == NULL && text_begin != text_end);
 559
 560         if(cur == NULL)
 561                 return SQFalse;
 562
 563         --text_begin;
 564
 565         if(out_begin) *out_begin = text_begin;
 566         if(out_end) *out_end = cur;
 567         return SQTrue;
 568 }
 569
 570 SQBool sqstd_rex_search(SQRex* exp,const SQChar* text, const SQChar** out_begin, const SQChar** out_end)
 571 {
 572         return sqstd_rex_searchrange(exp,text,text + scstrlen(text),out_begin,out_end);
 573 }
 574
 575 int sqstd_rex_getsubexpcount(SQRex* exp)
 576 {
 577         return exp->_nsubexpr;
 578 }
 579
 580 SQBool sqstd_rex_getsubexp(SQRex* exp, int n, SQRexMatch *subexp)
 581 {
 582         if( n<0 || n >= exp->_nsubexpr) return SQFalse;
 583         *subexp = exp->_matches[n];
 584         return SQTrue;
 585 }
 586