1 /* see copyright notice in squirrel.h */
\r
2 #include <squirrel.h>
\r
6 #include "sqstdstring.h"
\r
11 static const SQChar *g_nnames[] =
\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
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
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
45 typedef int SQRexNodeType;
\r
47 typedef struct tagSQRexNode{
\r
64 SQRexMatch *_matches;
\r
67 const SQChar **_error;
\r
70 static int sqstd_rex_list(SQRex *exp);
\r
72 static int sqstd_rex_newnode(SQRex *exp, SQRexNodeType type)
\r
76 n.next = n.right = n.left = -1;
\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
84 exp->_nodes[exp->_nsize++] = n;
\r
85 return (int)exp->_nsize - 1;
\r
88 static void sqstd_rex_error(SQRex *exp,const SQChar *error)
\r
90 if(exp->_error) *exp->_error = error;
\r
91 longjmp(*((jmp_buf*)exp->_jmpbuf),-1);
\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
100 static SQBool sqstd_rex_ischar(SQChar 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
112 static SQChar sqstd_rex_escapechar(SQRex *exp)
\r
114 if(*exp->_p == SQREX_SYMBOL_ESCAPE_CHAR){
\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
124 } else if(!sqstd_rex_ischar(*exp->_p)) sqstd_rex_error(exp,_SC("letter expected"));
\r
125 return (*exp->_p++);
\r
128 static int sqstd_rex_charclass(SQRex *exp,int classid)
\r
130 int n = sqstd_rex_newnode(exp,OP_CCLASS);
\r
131 exp->_nodes[n].left = classid;
\r
135 static int sqstd_rex_charnode(SQRex *exp,SQBool isclass)
\r
137 if(*exp->_p == SQREX_SYMBOL_ESCAPE_CHAR) {
\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
149 SQChar t = *exp->_p;
\r
151 return sqstd_rex_charclass(exp,t);
\r
156 int node = sqstd_rex_newnode(exp,OP_WB);
\r
157 exp->_nodes[node].left = *exp->_p;
\r
161 default: return sqstd_rex_newnode(exp,(*exp->_p++));
\r
164 else if(!sqstd_rex_ischar(*exp->_p)) {
\r
166 sqstd_rex_error(exp,_SC("letter expected"));
\r
168 return sqstd_rex_newnode(exp,*exp->_p++);
\r
170 static int sqstd_rex_class(SQRex *exp)
\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
177 }else ret = sqstd_rex_newnode(exp,OP_CLASS);
\r
179 if(*exp->_p == ']' || *exp->_p == '-'){
\r
184 while(*exp->_p != ']' && exp->_p != exp->_eol) {
\r
185 if(*exp->_p == '-' && first != -1){
\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
200 exp->_nodes[chain].next = c;
\r
202 first = sqstd_rex_charnode(exp,SQTrue);
\r
205 first = sqstd_rex_charnode(exp,SQTrue);
\r
211 exp->_nodes[chain].next = c;
\r
216 exp->_nodes[ret].left = exp->_nodes[ret].next;
\r
217 exp->_nodes[ret].next = -1;
\r
221 static int sqstd_rex_parsenumber(SQRex *exp)
\r
223 int ret = *exp->_p-'0';
\r
224 int positions = 10;
\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
234 static int sqstd_rex_element(SQRex *exp)
\r
244 if(*exp->_p =='?') {
\r
246 sqstd_rex_expect(exp,':');
\r
247 expr = sqstd_rex_newnode(exp,OP_NOCAPEXPR);
\r
250 expr = sqstd_rex_newnode(exp,OP_EXPR);
\r
251 exp->_nodes[expr].left = sqstd_rex_list(exp);
\r
253 sqstd_rex_expect(exp,')');
\r
258 ret = sqstd_rex_class(exp);
\r
259 sqstd_rex_expect(exp,']');
\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
264 ret = sqstd_rex_charnode(exp,SQFalse);
\r
270 unsigned short p0 = 0, p1 = 0;
\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
277 if(!isdigit(*exp->_p)) sqstd_rex_error(exp,_SC("number expected"));
\r
278 p0 = sqstd_rex_parsenumber(exp);
\r
281 p1 = p0; exp->_p++;
\r
286 if(isdigit(*exp->_p)){
\r
287 p1 = sqstd_rex_parsenumber(exp);
\r
289 sqstd_rex_expect(exp,'}');
\r
292 sqstd_rex_error(exp,_SC(", or } expected"));
\r
296 int nnode = sqstd_rex_newnode(exp,OP_GREEDY);
\r
298 exp->_nodes[nnode].left = ret;
\r
299 exp->_nodes[nnode].right = ((p0)<<16)|p1;
\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
309 static int sqstd_rex_list(SQRex *exp)
\r
312 if(*exp->_p == SQREX_SYMBOL_BEGINNING_OF_STRING) {
\r
314 ret = sqstd_rex_newnode(exp,OP_BOL);
\r
316 e = sqstd_rex_element(exp);
\r
318 exp->_nodes[ret].next = e;
\r
322 if(*exp->_p == SQREX_SYMBOL_BRANCH) {
\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
333 static SQBool sqstd_rex_matchcclass(int cclass,SQChar c)
\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
353 return SQFalse; /*cannot happen*/
\r
356 static SQBool sqstd_rex_matchclass(SQRex* exp,SQRexNode *node,SQChar c)
\r
359 switch(node->type) {
\r
361 if(c >= node->left && c <= node->right) return SQTrue;
\r
364 if(sqstd_rex_matchcclass(node->left,c)) return SQTrue;
\r
367 if(c == node->type)return SQTrue;
\r
369 } while((node->next != -1) && (node = &exp->_nodes[node->next]));
\r
373 static const SQChar *sqstd_rex_matchnode(SQRex* exp,SQRexNode *node,const SQChar *str)
\r
375 SQRexNodeType type = node->type;
\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
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
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
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
413 case OP_NOCAPEXPR:{
\r
414 SQRexNode *n = &exp->_nodes[node->left];
\r
415 const SQChar *cur = str;
\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
424 if(!(cur = sqstd_rex_matchnode(exp,n,cur))) {
\r
426 exp->_matches[capture].begin = 0;
\r
427 exp->_matches[capture].len = 0;
\r
431 } while((n->next != -1) && (n = &exp->_nodes[n->next]));
\r
434 exp->_matches[capture].len = cur - exp->_matches[capture].begin;
\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
444 return (node->left == 'b')?NULL:str;
\r
446 if(str == exp->_bol) return str;
\r
449 if(str == exp->_eol) return str;
\r
456 if(sqstd_rex_matchclass(exp,&exp->_nodes[node->left],*str)?(type == OP_CLASS?SQTrue:SQFalse):(type == OP_NCLASS?SQTrue:SQFalse)) {
\r
462 if(sqstd_rex_matchcclass(node->left,*str)) {
\r
467 default: /* char */
\r
468 if(*str != node->type) return NULL;
\r
476 SQRex *sqstd_rex_compile(const SQChar *pattern,const SQChar **error)
\r
478 SQRex *exp = (SQRex *)sq_malloc(sizeof(SQRex));
\r
480 exp->_nallocated = (int)scstrlen(pattern) * sizeof(SQChar);
\r
481 exp->_nodes = (SQRexNode *)sq_malloc(exp->_nallocated * sizeof(SQRexNode));
\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
491 sqstd_rex_error(exp,_SC("unexpected character"));
\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
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
506 scprintf(_SC("\n"));
\r
509 exp->_matches = (SQRexMatch *) sq_malloc(exp->_nsubexpr * sizeof(SQRexMatch));
\r
510 memset(exp->_matches,0,exp->_nsubexpr * sizeof(SQRexMatch));
\r
513 sqstd_rex_free(exp);
\r
519 void sqstd_rex_free(SQRex *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
529 SQBool sqstd_rex_match(SQRex* exp,const SQChar* text)
\r
531 const SQChar* res = NULL;
\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
541 SQBool sqstd_rex_searchrange(SQRex* exp,const SQChar* text_begin,const SQChar* text_end,const SQChar** out_begin, const SQChar** out_end)
\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
550 while(node != -1) {
\r
551 exp->_currsubexp = 0;
\r
552 cur = sqstd_rex_matchnode(exp,&exp->_nodes[node],cur);
\r
555 node = exp->_nodes[node].next;
\r
558 } while(cur == NULL && text_begin != text_end);
\r
565 if(out_begin) *out_begin = text_begin;
\r
566 if(out_end) *out_end = cur;
\r
570 SQBool sqstd_rex_search(SQRex* exp,const SQChar* text, const SQChar** out_begin, const SQChar** out_end)
\r
572 return sqstd_rex_searchrange(exp,text,text + scstrlen(text),out_begin,out_end);
\r
575 int sqstd_rex_getsubexpcount(SQRex* exp)
\r
577 return exp->_nsubexpr;
\r
580 SQBool sqstd_rex_getsubexp(SQRex* exp, int n, SQRexMatch *subexp)
\r
582 if( n<0 || n >= exp->_nsubexpr) return SQFalse;
\r
583 *subexp = exp->_matches[n];
\r