1 /* see copyright notice in squirrel.h */
6 #include "sqstdstring.h"
9 #define scisprint iswprint
11 #define scisprint isprint
17 static const SQChar *g_nnames[] =
19 _SC("NONE"),_SC("OP_GREEDY"), _SC("OP_OR"),
20 _SC("OP_EXPR"),_SC("OP_NOCAPEXPR"),_SC("OP_DOT"), _SC("OP_CLASS"),
21 _SC("OP_CCLASS"),_SC("OP_NCLASS"),_SC("OP_RANGE"),_SC("OP_CHAR"),
22 _SC("OP_EOL"),_SC("OP_BOL"),_SC("OP_WB")
27 #define OP_GREEDY (MAX_CHAR+1) // * + ? {n}
28 #define OP_OR (MAX_CHAR+2)
29 #define OP_EXPR (MAX_CHAR+3) //parentesis ()
30 #define OP_NOCAPEXPR (MAX_CHAR+4) //parentesis (?:)
31 #define OP_DOT (MAX_CHAR+5)
32 #define OP_CLASS (MAX_CHAR+6)
33 #define OP_CCLASS (MAX_CHAR+7)
34 #define OP_NCLASS (MAX_CHAR+8) //negates class the [^
35 #define OP_RANGE (MAX_CHAR+9)
36 #define OP_CHAR (MAX_CHAR+10)
37 #define OP_EOL (MAX_CHAR+11)
38 #define OP_BOL (MAX_CHAR+12)
39 #define OP_WB (MAX_CHAR+13)
41 #define SQREX_SYMBOL_ANY_CHAR ('.')
42 #define SQREX_SYMBOL_GREEDY_ONE_OR_MORE ('+')
43 #define SQREX_SYMBOL_GREEDY_ZERO_OR_MORE ('*')
44 #define SQREX_SYMBOL_GREEDY_ZERO_OR_ONE ('?')
45 #define SQREX_SYMBOL_BRANCH ('|')
46 #define SQREX_SYMBOL_END_OF_STRING ('$')
47 #define SQREX_SYMBOL_BEGINNING_OF_STRING ('^')
48 #define SQREX_SYMBOL_ESCAPE_CHAR ('\\')
51 typedef int SQRexNodeType;
53 typedef struct tagSQRexNode{
67 SQInteger _nallocated;
71 SQInteger _currsubexp;
73 const SQChar **_error;
76 static SQInteger sqstd_rex_list(SQRex *exp);
78 static SQInteger sqstd_rex_newnode(SQRex *exp, SQRexNodeType type)
82 n.next = n.right = n.left = -1;
84 n.right = exp->_nsubexpr++;
85 if(exp->_nallocated < (exp->_nsize + 1)) {
86 SQInteger oldsize = exp->_nallocated;
87 exp->_nallocated *= 2;
88 exp->_nodes = (SQRexNode *)sq_realloc(exp->_nodes, oldsize * sizeof(SQRexNode) ,exp->_nallocated * sizeof(SQRexNode));
90 exp->_nodes[exp->_nsize++] = n;
91 SQInteger newid = exp->_nsize - 1;
92 return (SQInteger)newid;
95 static void sqstd_rex_error(SQRex *exp,const SQChar *error)
97 if(exp->_error) *exp->_error = error;
98 longjmp(*((jmp_buf*)exp->_jmpbuf),-1);
101 static void sqstd_rex_expect(SQRex *exp, SQInteger n){
103 sqstd_rex_error(exp, _SC("expected paren"));
107 static SQChar sqstd_rex_escapechar(SQRex *exp)
109 if(*exp->_p == SQREX_SYMBOL_ESCAPE_CHAR){
112 case 'v': exp->_p++; return '\v';
113 case 'n': exp->_p++; return '\n';
114 case 't': exp->_p++; return '\t';
115 case 'r': exp->_p++; return '\r';
116 case 'f': exp->_p++; return '\f';
117 default: return (*exp->_p++);
119 } else if(!scisprint(*exp->_p)) sqstd_rex_error(exp,_SC("letter expected"));
123 static SQInteger sqstd_rex_charclass(SQRex *exp,SQInteger classid)
125 SQInteger n = sqstd_rex_newnode(exp,OP_CCLASS);
126 exp->_nodes[n].left = classid;
130 static SQInteger sqstd_rex_charnode(SQRex *exp,SQBool isclass)
133 if(*exp->_p == SQREX_SYMBOL_ESCAPE_CHAR) {
136 case 'n': exp->_p++; return sqstd_rex_newnode(exp,'\n');
137 case 't': exp->_p++; return sqstd_rex_newnode(exp,'\t');
138 case 'r': exp->_p++; return sqstd_rex_newnode(exp,'\r');
139 case 'f': exp->_p++; return sqstd_rex_newnode(exp,'\f');
140 case 'v': exp->_p++; return sqstd_rex_newnode(exp,'\v');
141 case 'a': case 'A': case 'w': case 'W': case 's': case 'S':
142 case 'd': case 'D': case 'x': case 'X': case 'c': case 'C':
143 case 'p': case 'P': case 'l': case 'u':
145 t = *exp->_p; exp->_p++;
146 return sqstd_rex_charclass(exp,t);
151 SQInteger node = sqstd_rex_newnode(exp,OP_WB);
152 exp->_nodes[node].left = *exp->_p;
157 t = *exp->_p; exp->_p++;
158 return sqstd_rex_newnode(exp,t);
161 else if(!scisprint(*exp->_p)) {
163 sqstd_rex_error(exp,_SC("letter expected"));
165 t = *exp->_p; exp->_p++;
166 return sqstd_rex_newnode(exp,t);
168 static SQInteger sqstd_rex_class(SQRex *exp)
171 SQInteger first = -1,chain;
172 if(*exp->_p == SQREX_SYMBOL_BEGINNING_OF_STRING){
173 ret = sqstd_rex_newnode(exp,OP_NCLASS);
175 }else ret = sqstd_rex_newnode(exp,OP_CLASS);
177 if(*exp->_p == ']') sqstd_rex_error(exp,_SC("empty class"));
179 while(*exp->_p != ']' && exp->_p != exp->_eol) {
180 if(*exp->_p == '-' && first != -1){
182 if(*exp->_p++ == ']') sqstd_rex_error(exp,_SC("unfinished range"));
183 r = sqstd_rex_newnode(exp,OP_RANGE);
184 if(first>*exp->_p) sqstd_rex_error(exp,_SC("invalid range"));
185 if(exp->_nodes[first].type == OP_CCLASS) sqstd_rex_error(exp,_SC("cannot use character classes in ranges"));
186 exp->_nodes[r].left = exp->_nodes[first].type;
187 SQInteger t = sqstd_rex_escapechar(exp);
188 exp->_nodes[r].right = t;
189 exp->_nodes[chain].next = r;
196 exp->_nodes[chain].next = c;
198 first = sqstd_rex_charnode(exp,SQTrue);
201 first = sqstd_rex_charnode(exp,SQTrue);
207 exp->_nodes[chain].next = c;
212 exp->_nodes[ret].left = exp->_nodes[ret].next;
213 exp->_nodes[ret].next = -1;
217 static SQInteger sqstd_rex_parsenumber(SQRex *exp)
219 SQInteger ret = *exp->_p-'0';
220 SQInteger positions = 10;
222 while(isdigit(*exp->_p)) {
223 ret = ret*10+(*exp->_p++-'0');
224 if(positions==1000000000) sqstd_rex_error(exp,_SC("overflow in numeric constant"));
230 static SQInteger sqstd_rex_element(SQRex *exp)
242 sqstd_rex_expect(exp,':');
243 expr = sqstd_rex_newnode(exp,OP_NOCAPEXPR);
246 expr = sqstd_rex_newnode(exp,OP_EXPR);
247 SQInteger newn = sqstd_rex_list(exp);
248 exp->_nodes[expr].left = newn;
250 sqstd_rex_expect(exp,')');
255 ret = sqstd_rex_class(exp);
256 sqstd_rex_expect(exp,']');
258 case SQREX_SYMBOL_END_OF_STRING: exp->_p++; ret = sqstd_rex_newnode(exp,OP_EOL);break;
259 case SQREX_SYMBOL_ANY_CHAR: exp->_p++; ret = sqstd_rex_newnode(exp,OP_DOT);break;
261 ret = sqstd_rex_charnode(exp,SQFalse);
267 SQBool isgreedy = SQFalse;
268 unsigned short p0 = 0, p1 = 0;
270 case SQREX_SYMBOL_GREEDY_ZERO_OR_MORE: p0 = 0; p1 = 0xFFFF; exp->_p++; isgreedy = SQTrue; break;
271 case SQREX_SYMBOL_GREEDY_ONE_OR_MORE: p0 = 1; p1 = 0xFFFF; exp->_p++; isgreedy = SQTrue; break;
272 case SQREX_SYMBOL_GREEDY_ZERO_OR_ONE: p0 = 0; p1 = 1; exp->_p++; isgreedy = SQTrue; break;
275 if(!isdigit(*exp->_p)) sqstd_rex_error(exp,_SC("number expected"));
276 p0 = (unsigned short)sqstd_rex_parsenumber(exp);
277 /*******************************/
285 if(isdigit(*exp->_p)){
286 p1 = (unsigned short)sqstd_rex_parsenumber(exp);
288 sqstd_rex_expect(exp,'}');
291 sqstd_rex_error(exp,_SC(", or } expected"));
293 /*******************************/
299 SQInteger nnode = sqstd_rex_newnode(exp,OP_GREEDY);
301 exp->_nodes[nnode].left = ret;
302 exp->_nodes[nnode].right = ((p0)<<16)|p1;
306 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')) {
307 SQInteger nnode = sqstd_rex_element(exp);
308 exp->_nodes[ret].next = nnode;
314 static SQInteger sqstd_rex_list(SQRex *exp)
317 if(*exp->_p == SQREX_SYMBOL_BEGINNING_OF_STRING) {
319 ret = sqstd_rex_newnode(exp,OP_BOL);
321 e = sqstd_rex_element(exp);
323 exp->_nodes[ret].next = e;
327 if(*exp->_p == SQREX_SYMBOL_BRANCH) {
328 SQInteger temp,tright;
330 temp = sqstd_rex_newnode(exp,OP_OR);
331 exp->_nodes[temp].left = ret;
332 tright = sqstd_rex_list(exp);
333 exp->_nodes[temp].right = tright;
339 static SQBool sqstd_rex_matchcclass(SQInteger cclass,SQChar c)
342 case 'a': return isalpha(c)?SQTrue:SQFalse;
343 case 'A': return !isalpha(c)?SQTrue:SQFalse;
344 case 'w': return (isalnum(c) || c == '_')?SQTrue:SQFalse;
345 case 'W': return (!isalnum(c) && c != '_')?SQTrue:SQFalse;
346 case 's': return isspace(c)?SQTrue:SQFalse;
347 case 'S': return !isspace(c)?SQTrue:SQFalse;
348 case 'd': return isdigit(c)?SQTrue:SQFalse;
349 case 'D': return !isdigit(c)?SQTrue:SQFalse;
350 case 'x': return isxdigit(c)?SQTrue:SQFalse;
351 case 'X': return !isxdigit(c)?SQTrue:SQFalse;
352 case 'c': return iscntrl(c)?SQTrue:SQFalse;
353 case 'C': return !iscntrl(c)?SQTrue:SQFalse;
354 case 'p': return ispunct(c)?SQTrue:SQFalse;
355 case 'P': return !ispunct(c)?SQTrue:SQFalse;
356 case 'l': return islower(c)?SQTrue:SQFalse;
357 case 'u': return isupper(c)?SQTrue:SQFalse;
359 return SQFalse; /*cannot happen*/
362 static SQBool sqstd_rex_matchclass(SQRex* exp,SQRexNode *node,SQChar c)
367 if(c >= node->left && c <= node->right) return SQTrue;
370 if(sqstd_rex_matchcclass(node->left,c)) return SQTrue;
373 if(c == node->type)return SQTrue;
375 } while((node->next != -1) && (node = &exp->_nodes[node->next]));
379 static const SQChar *sqstd_rex_matchnode(SQRex* exp,SQRexNode *node,const SQChar *str,SQRexNode *next)
382 SQRexNodeType type = node->type;
385 //SQRexNode *greedystop = (node->next != -1) ? &exp->_nodes[node->next] : NULL;
386 SQRexNode *greedystop = NULL;
387 SQInteger p0 = (node->right >> 16)&0x0000FFFF, p1 = node->right&0x0000FFFF, nmaches = 0;
388 const SQChar *s=str, *good = str;
390 if(node->next != -1) {
391 greedystop = &exp->_nodes[node->next];
397 while((nmaches == 0xFFFF || nmaches < p1)) {
400 if(!(s = sqstd_rex_matchnode(exp,&exp->_nodes[node->left],s,greedystop)))
405 //checks that 0 matches satisfy the expression(if so skips)
406 //if not would always stop(for instance if is a '?')
407 if(greedystop->type != OP_GREEDY ||
408 (greedystop->type == OP_GREEDY && ((greedystop->right >> 16)&0x0000FFFF) != 0))
410 SQRexNode *gnext = NULL;
411 if(greedystop->next != -1) {
412 gnext = &exp->_nodes[greedystop->next];
413 }else if(next && next->next != -1){
414 gnext = &exp->_nodes[next->next];
416 stop = sqstd_rex_matchnode(exp,greedystop,s,gnext);
418 //if satisfied stop it
419 if(p0 == p1 && p0 == nmaches) break;
420 else if(nmaches >= p0 && p1 == 0xFFFF) break;
421 else if(nmaches >= p0 && nmaches <= p1) break;
429 if(p0 == p1 && p0 == nmaches) return good;
430 else if(nmaches >= p0 && p1 == 0xFFFF) return good;
431 else if(nmaches >= p0 && nmaches <= p1) return good;
435 const SQChar *asd = str;
436 SQRexNode *temp=&exp->_nodes[node->left];
437 while( (asd = sqstd_rex_matchnode(exp,temp,asd,NULL)) ) {
439 temp = &exp->_nodes[temp->next];
444 temp = &exp->_nodes[node->right];
445 while( (asd = sqstd_rex_matchnode(exp,temp,asd,NULL)) ) {
447 temp = &exp->_nodes[temp->next];
456 SQRexNode *n = &exp->_nodes[node->left];
457 const SQChar *cur = str;
458 SQInteger capture = -1;
459 if(node->type != OP_NOCAPEXPR && node->right == exp->_currsubexp) {
460 capture = exp->_currsubexp;
461 exp->_matches[capture].begin = cur;
466 SQRexNode *subnext = NULL;
468 subnext = &exp->_nodes[n->next];
472 if(!(cur = sqstd_rex_matchnode(exp,n,cur,subnext))) {
474 exp->_matches[capture].begin = 0;
475 exp->_matches[capture].len = 0;
479 } while((n->next != -1) && (n = &exp->_nodes[n->next]));
482 exp->_matches[capture].len = cur - exp->_matches[capture].begin;
486 if(str == exp->_bol && !isspace(*str)
487 || (str == exp->_eol && !isspace(*(str-1)))
488 || (!isspace(*str) && isspace(*(str+1)))
489 || (isspace(*str) && !isspace(*(str+1))) ) {
490 return (node->left == 'b')?str:NULL;
492 return (node->left == 'b')?NULL:str;
494 if(str == exp->_bol) return str;
497 if(str == exp->_eol) return str;
505 if(sqstd_rex_matchclass(exp,&exp->_nodes[node->left],*str)?(type == OP_CLASS?SQTrue:SQFalse):(type == OP_NCLASS?SQTrue:SQFalse)) {
511 if(sqstd_rex_matchcclass(node->left,*str)) {
517 if(*str != node->type) return NULL;
525 SQRex *sqstd_rex_compile(const SQChar *pattern,const SQChar **error)
527 SQRex *exp = (SQRex *)sq_malloc(sizeof(SQRex));
528 exp->_eol = exp->_bol = NULL;
530 exp->_nallocated = (SQInteger)scstrlen(pattern) * sizeof(SQChar);
531 exp->_nodes = (SQRexNode *)sq_malloc(exp->_nallocated * sizeof(SQRexNode));
535 exp->_first = sqstd_rex_newnode(exp,OP_EXPR);
537 exp->_jmpbuf = sq_malloc(sizeof(jmp_buf));
538 if(setjmp(*((jmp_buf*)exp->_jmpbuf)) == 0) {
539 SQInteger res = sqstd_rex_list(exp);
540 exp->_nodes[exp->_first].left = res;
542 sqstd_rex_error(exp,_SC("unexpected character"));
550 for(i = 0;i < nsize; i++) {
551 if(exp->_nodes[i].type>MAX_CHAR)
552 scprintf(_SC("[%02d] %10s "),i,g_nnames[exp->_nodes[i].type-MAX_CHAR]);
554 scprintf(_SC("[%02d] %10c "),i,exp->_nodes[i].type);
555 scprintf(_SC("left %02d right %02d next %02d\n"),exp->_nodes[i].left,exp->_nodes[i].right,exp->_nodes[i].next);
560 exp->_matches = (SQRexMatch *) sq_malloc(exp->_nsubexpr * sizeof(SQRexMatch));
561 memset(exp->_matches,0,exp->_nsubexpr * sizeof(SQRexMatch));
570 void sqstd_rex_free(SQRex *exp)
573 if(exp->_nodes) sq_free(exp->_nodes,exp->_nallocated * sizeof(SQRexNode));
574 if(exp->_jmpbuf) sq_free(exp->_jmpbuf,sizeof(jmp_buf));
575 if(exp->_matches) sq_free(exp->_matches,exp->_nsubexpr * sizeof(SQRexMatch));
576 sq_free(exp,sizeof(SQRex));
580 SQBool sqstd_rex_match(SQRex* exp,const SQChar* text)
582 const SQChar* res = NULL;
584 exp->_eol = text + scstrlen(text);
585 exp->_currsubexp = 0;
586 res = sqstd_rex_matchnode(exp,exp->_nodes,text,NULL);
587 if(res == NULL || res != exp->_eol)
592 SQBool sqstd_rex_searchrange(SQRex* exp,const SQChar* text_begin,const SQChar* text_end,const SQChar** out_begin, const SQChar** out_end)
594 const SQChar *cur = NULL;
595 SQInteger node = exp->_first;
596 if(text_begin >= text_end) return SQFalse;
597 exp->_bol = text_begin;
598 exp->_eol = text_end;
602 exp->_currsubexp = 0;
603 cur = sqstd_rex_matchnode(exp,&exp->_nodes[node],cur,NULL);
606 node = exp->_nodes[node].next;
609 } while(cur == NULL && text_begin != text_end);
616 if(out_begin) *out_begin = text_begin;
617 if(out_end) *out_end = cur;
621 SQBool sqstd_rex_search(SQRex* exp,const SQChar* text, const SQChar** out_begin, const SQChar** out_end)
623 return sqstd_rex_searchrange(exp,text,text + scstrlen(text),out_begin,out_end);
626 SQInteger sqstd_rex_getsubexpcount(SQRex* exp)
628 return exp->_nsubexpr;
631 SQBool sqstd_rex_getsubexp(SQRex* exp, SQInteger n, SQRexMatch *subexp)
633 if( n<0 || n >= exp->_nsubexpr) return SQFalse;
634 *subexp = exp->_matches[n];