src/squirrel/sqstdlib/sqstdrex.c

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