1 /*
2 +----------------------------------------------------------------------+
3 | PHP Version 5 |
4 +----------------------------------------------------------------------+
5 | Copyright (c) 1997-2014 The PHP Group |
6 +----------------------------------------------------------------------+
7 | This source file is subject to version 3.01 of the PHP license, |
8 | that is bundled with this package in the file LICENSE, and is |
9 | available through the world-wide-web at the following url: |
10 | http://www.php.net/license/3_01.txt |
11 | If you did not receive a copy of the PHP license and are unable to |
12 | obtain it through the world-wide-web, please send a note to |
13 | license@php.net so we can mail you a copy immediately. |
14 +----------------------------------------------------------------------+
15 | Authors: Rasmus Lerdorf <rasmus@php.net> |
16 | Jim Winstead <jimw@php.net> |
17 | Jaakko Hyv�tti <jaakko@hyvatti.iki.fi> |
18 +----------------------------------------------------------------------+
19 */
20 /* $Id$ */
21
22 #include <stdio.h>
23 #include <ctype.h>
24 #include "php.h"
25 #include "ext/standard/php_string.h"
26 #include "php_ereg.h"
27 #include "ext/standard/info.h"
28
29 /* {{{ arginfo */
30 ZEND_BEGIN_ARG_INFO_EX(arginfo_ereg, 0, 0, 2)
31 ZEND_ARG_INFO(0, pattern)
32 ZEND_ARG_INFO(0, string)
33 ZEND_ARG_INFO(1, registers) /* ARRAY_INFO(1, registers, 1) */
34 ZEND_END_ARG_INFO()
35
36 ZEND_BEGIN_ARG_INFO(arginfo_ereg_replace, 0)
37 ZEND_ARG_INFO(0, pattern)
38 ZEND_ARG_INFO(0, replacement)
39 ZEND_ARG_INFO(0, string)
40 ZEND_END_ARG_INFO()
41
42 ZEND_BEGIN_ARG_INFO_EX(arginfo_split, 0, 0, 2)
43 ZEND_ARG_INFO(0, pattern)
44 ZEND_ARG_INFO(0, string)
45 ZEND_ARG_INFO(0, limit)
46 ZEND_END_ARG_INFO()
47
48 ZEND_BEGIN_ARG_INFO(arginfo_sql_regcase, 0)
49 ZEND_ARG_INFO(0, string)
50 ZEND_END_ARG_INFO()
51 /* }}} */
52
53 /* {{{ Function table */
54 const zend_function_entry ereg_functions[] = {
55 PHP_DEP_FE(ereg, arginfo_ereg)
56 PHP_DEP_FE(ereg_replace, arginfo_ereg_replace)
57 PHP_DEP_FE(eregi, arginfo_ereg)
58 PHP_DEP_FE(eregi_replace, arginfo_ereg_replace)
59 PHP_DEP_FE(split, arginfo_split)
60 PHP_DEP_FE(spliti, arginfo_split)
61 PHP_DEP_FE(sql_regcase, arginfo_sql_regcase)
62 PHP_FE_END
63 };
64 /* }}} */
65
66 /* {{{ reg_cache */
67 typedef struct {
68 regex_t preg;
69 int cflags;
70 unsigned long lastuse;
71 } reg_cache;
72 static int reg_magic = 0;
73 #define EREG_CACHE_SIZE 4096
74 /* }}} */
75
76 ZEND_DECLARE_MODULE_GLOBALS(ereg)
77 static PHP_GINIT_FUNCTION(ereg);
78 static PHP_GSHUTDOWN_FUNCTION(ereg);
79
80 /* {{{ Module entry */
81 zend_module_entry ereg_module_entry = {
82 STANDARD_MODULE_HEADER,
83 "ereg",
84 ereg_functions,
85 NULL,
86 NULL,
87 NULL,
88 NULL,
89 PHP_MINFO(ereg),
90 NO_VERSION_YET,
91 PHP_MODULE_GLOBALS(ereg),
92 PHP_GINIT(ereg),
93 PHP_GSHUTDOWN(ereg),
94 NULL,
95 STANDARD_MODULE_PROPERTIES_EX
96 };
97 /* }}} */
98
99 /* {{{ COMPILE_DL_EREG */
100 #ifdef COMPILE_DL_EREG
ZEND_GET_MODULE(ereg)101 ZEND_GET_MODULE(ereg)
102 #endif
103 /* }}} */
104
105 /* {{{ ereg_lru_cmp */
106 static int ereg_lru_cmp(const void *a, const void *b TSRMLS_DC)
107 {
108 Bucket *f = *((Bucket **) a);
109 Bucket *s = *((Bucket **) b);
110
111 if (((reg_cache *)f->pData)->lastuse <
112 ((reg_cache *)s->pData)->lastuse) {
113 return -1;
114 } else if (((reg_cache *)f->pData)->lastuse ==
115 ((reg_cache *)s->pData)->lastuse) {
116 return 0;
117 } else {
118 return 1;
119 }
120 }
121 /* }}} */
122
123 /* {{{ static ereg_clean_cache */
ereg_clean_cache(void * data,void * arg TSRMLS_DC)124 static int ereg_clean_cache(void *data, void *arg TSRMLS_DC)
125 {
126 int *num_clean = (int *)arg;
127
128 if (*num_clean > 0) {
129 (*num_clean)--;
130 return ZEND_HASH_APPLY_REMOVE;
131 } else {
132 return ZEND_HASH_APPLY_STOP;
133 }
134 }
135 /* }}} */
136
137 /* {{{ _php_regcomp
138 */
_php_regcomp(regex_t * preg,const char * pattern,int cflags TSRMLS_DC)139 static int _php_regcomp(regex_t *preg, const char *pattern, int cflags TSRMLS_DC)
140 {
141 int r = 0;
142 int patlen = strlen(pattern);
143 reg_cache *rc = NULL;
144
145 if (zend_hash_num_elements(&EREG(ht_rc)) >= EREG_CACHE_SIZE) {
146 /* easier than dealing with overflow as it happens */
147 if (EREG(lru_counter) >= (1 << 31) || zend_hash_sort(&EREG(ht_rc), zend_qsort, ereg_lru_cmp, 0 TSRMLS_CC) == FAILURE) {
148 zend_hash_clean(&EREG(ht_rc));
149 EREG(lru_counter) = 0;
150 } else {
151 int num_clean = EREG_CACHE_SIZE / 4;
152 zend_hash_apply_with_argument(&EREG(ht_rc), ereg_clean_cache, &num_clean TSRMLS_CC);
153 }
154 }
155
156 if(zend_hash_find(&EREG(ht_rc), (char *) pattern, patlen+1, (void **) &rc) == SUCCESS
157 && rc->cflags == cflags) {
158 #ifdef HAVE_REGEX_T_RE_MAGIC
159 /*
160 * We use a saved magic number to see whether cache is corrupted, and if it
161 * is, we flush it and compile the pattern from scratch.
162 */
163 if (rc->preg.re_magic != reg_magic) {
164 zend_hash_clean(&EREG(ht_rc));
165 EREG(lru_counter) = 0;
166 } else {
167 memcpy(preg, &rc->preg, sizeof(*preg));
168 return r;
169 }
170 }
171
172 r = regcomp(preg, pattern, cflags);
173 if(!r) {
174 reg_cache rcp;
175
176 rcp.cflags = cflags;
177 rcp.lastuse = ++(EREG(lru_counter));
178 memcpy(&rcp.preg, preg, sizeof(*preg));
179 /*
180 * Since we don't have access to the actual MAGIC1 definition in the private
181 * header file, we save the magic value immediately after compilation. Hopefully,
182 * it's good.
183 */
184 if (!reg_magic) reg_magic = preg->re_magic;
185 zend_hash_update(&EREG(ht_rc), (char *) pattern, patlen+1,
186 (void *) &rcp, sizeof(rcp), NULL);
187 }
188 #else
189 memcpy(preg, &rc->preg, sizeof(*preg));
190 } else {
191 r = regcomp(preg, pattern, cflags);
192 if(!r) {
193 reg_cache rcp;
194
195 rcp.cflags = cflags;
196 rcp.lastuse = ++(EREG(lru_counter));
197 memcpy(&rcp.preg, preg, sizeof(*preg));
198 zend_hash_update(&EREG(ht_rc), (char *) pattern, patlen+1,
199 (void *) &rcp, sizeof(rcp), NULL);
200 }
201 }
202 #endif
203 return r;
204 }
205 /* }}} */
206
_free_ereg_cache(reg_cache * rc)207 static void _free_ereg_cache(reg_cache *rc)
208 {
209 regfree(&rc->preg);
210 }
211
212 #undef regfree
213 #define regfree(a);
214 #undef regcomp
215 #define regcomp(a, b, c) _php_regcomp(a, b, c TSRMLS_CC)
216
217 /* {{{ PHP_GINIT_FUNCTION
218 */
PHP_GINIT_FUNCTION(ereg)219 static PHP_GINIT_FUNCTION(ereg)
220 {
221 zend_hash_init(&ereg_globals->ht_rc, 0, NULL, (void (*)(void *)) _free_ereg_cache, 1);
222 ereg_globals->lru_counter = 0;
223 }
224 /* }}} */
225
226 /* {{{ PHP_GSHUTDOWN_FUNCTION
227 */
PHP_GSHUTDOWN_FUNCTION(ereg)228 static PHP_GSHUTDOWN_FUNCTION(ereg)
229 {
230 zend_hash_destroy(&ereg_globals->ht_rc);
231 }
232 /* }}} */
233
PHP_MINFO_FUNCTION(ereg)234 PHP_MINFO_FUNCTION(ereg)
235 {
236 php_info_print_table_start();
237 #if HSREGEX
238 php_info_print_table_row(2, "Regex Library", "Bundled library enabled");
239 #else
240 php_info_print_table_row(2, "Regex Library", "System library enabled");
241 #endif
242 php_info_print_table_end();
243 }
244
245
246 /* {{{ php_ereg_eprint
247 * php_ereg_eprint - convert error number to name
248 */
php_ereg_eprint(int err,regex_t * re TSRMLS_DC)249 static void php_ereg_eprint(int err, regex_t *re TSRMLS_DC) {
250 char *buf = NULL, *message = NULL;
251 size_t len;
252 size_t buf_len;
253
254 #ifdef REG_ITOA
255 /* get the length of the message */
256 buf_len = regerror(REG_ITOA | err, re, NULL, 0);
257 if (buf_len) {
258 buf = (char *)safe_emalloc(buf_len, sizeof(char), 0);
259 if (!buf) return; /* fail silently */
260 /* finally, get the error message */
261 regerror(REG_ITOA | err, re, buf, buf_len);
262 }
263 #else
264 buf_len = 0;
265 #endif
266 len = regerror(err, re, NULL, 0);
267 if (len) {
268 message = (char *)safe_emalloc((buf_len + len + 2), sizeof(char), 0);
269 if (!message) {
270 return; /* fail silently */
271 }
272 if (buf_len) {
273 snprintf(message, buf_len, "%s: ", buf);
274 buf_len += 1; /* so pointer math below works */
275 }
276 /* drop the message into place */
277 regerror(err, re, message + buf_len, len);
278
279 php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", message);
280 }
281
282 STR_FREE(buf);
283 STR_FREE(message);
284 }
285 /* }}} */
286
287 /* {{{ php_ereg
288 */
php_ereg(INTERNAL_FUNCTION_PARAMETERS,int icase)289 static void php_ereg(INTERNAL_FUNCTION_PARAMETERS, int icase)
290 {
291 zval **regex, /* Regular expression */
292 **array = NULL; /* Optional register array */
293 char *findin; /* String to apply expression to */
294 int findin_len;
295 regex_t re;
296 regmatch_t *subs;
297 int err, match_len, string_len;
298 uint i;
299 int copts = 0;
300 off_t start, end;
301 char *buf = NULL;
302 char *string = NULL;
303 int argc = ZEND_NUM_ARGS();
304
305 if (zend_parse_parameters(argc TSRMLS_CC, "Zs|Z", ®ex, &findin, &findin_len, &array) == FAILURE) {
306 return;
307 }
308
309 if (icase) {
310 copts |= REG_ICASE;
311 }
312
313 if (argc == 2) {
314 copts |= REG_NOSUB;
315 }
316
317 /* compile the regular expression from the supplied regex */
318 if (Z_TYPE_PP(regex) == IS_STRING) {
319 err = regcomp(&re, Z_STRVAL_PP(regex), REG_EXTENDED | copts);
320 } else {
321 /* we convert numbers to integers and treat them as a string */
322 if (Z_TYPE_PP(regex) == IS_DOUBLE) {
323 convert_to_long_ex(regex); /* get rid of decimal places */
324 }
325 convert_to_string_ex(regex);
326 /* don't bother doing an extended regex with just a number */
327 err = regcomp(&re, Z_STRVAL_PP(regex), copts);
328 }
329
330 if (err) {
331 php_ereg_eprint(err, &re TSRMLS_CC);
332 RETURN_FALSE;
333 }
334
335 /* make a copy of the string we're looking in */
336 string = estrndup(findin, findin_len);
337
338 /* allocate storage for (sub-)expression-matches */
339 subs = (regmatch_t *)ecalloc(sizeof(regmatch_t),re.re_nsub+1);
340
341 /* actually execute the regular expression */
342 err = regexec(&re, string, re.re_nsub+1, subs, 0);
343 if (err && err != REG_NOMATCH) {
344 php_ereg_eprint(err, &re TSRMLS_CC);
345 regfree(&re);
346 efree(subs);
347 RETURN_FALSE;
348 }
349 match_len = 1;
350
351 if (array && err != REG_NOMATCH) {
352 match_len = (int) (subs[0].rm_eo - subs[0].rm_so);
353 string_len = findin_len + 1;
354
355 buf = emalloc(string_len);
356
357 zval_dtor(*array); /* start with clean array */
358 array_init(*array);
359
360 for (i = 0; i <= re.re_nsub; i++) {
361 start = subs[i].rm_so;
362 end = subs[i].rm_eo;
363 if (start != -1 && end > 0 && start < string_len && end < string_len && start < end) {
364 add_index_stringl(*array, i, string+start, end-start, 1);
365 } else {
366 add_index_bool(*array, i, 0);
367 }
368 }
369 efree(buf);
370 }
371
372 efree(subs);
373 efree(string);
374 if (err == REG_NOMATCH) {
375 RETVAL_FALSE;
376 } else {
377 if (match_len == 0)
378 match_len = 1;
379 RETVAL_LONG(match_len);
380 }
381 regfree(&re);
382 }
383 /* }}} */
384
385 /* {{{ proto int ereg(string pattern, string string [, array registers])
386 Regular expression match */
PHP_FUNCTION(ereg)387 PHP_FUNCTION(ereg)
388 {
389 php_ereg(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
390 }
391 /* }}} */
392
393 /* {{{ proto int eregi(string pattern, string string [, array registers])
394 Case-insensitive regular expression match */
PHP_FUNCTION(eregi)395 PHP_FUNCTION(eregi)
396 {
397 php_ereg(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1);
398 }
399 /* }}} */
400
401 /* {{{ php_ereg_replace
402 * this is the meat and potatoes of regex replacement! */
php_ereg_replace(const char * pattern,const char * replace,const char * string,int icase,int extended TSRMLS_DC)403 PHP_EREG_API char *php_ereg_replace(const char *pattern, const char *replace, const char *string, int icase, int extended TSRMLS_DC)
404 {
405 regex_t re;
406 regmatch_t *subs;
407
408 char *buf, /* buf is where we build the replaced string */
409 *nbuf, /* nbuf is used when we grow the buffer */
410 *walkbuf; /* used to walk buf when replacing backrefs */
411 const char *walk; /* used to walk replacement string for backrefs */
412 int buf_len;
413 int pos, tmp, string_len, new_l;
414 int err, copts = 0;
415
416 string_len = strlen(string);
417
418 if (icase) {
419 copts = REG_ICASE;
420 }
421 if (extended) {
422 copts |= REG_EXTENDED;
423 }
424
425 err = regcomp(&re, pattern, copts);
426 if (err) {
427 php_ereg_eprint(err, &re TSRMLS_CC);
428 return ((char *) -1);
429 }
430
431
432 /* allocate storage for (sub-)expression-matches */
433 subs = (regmatch_t *)ecalloc(sizeof(regmatch_t),re.re_nsub+1);
434
435 /* start with a buffer that is twice the size of the stringo
436 we're doing replacements in */
437 buf_len = 2 * string_len + 1;
438 buf = safe_emalloc(buf_len, sizeof(char), 0);
439
440 err = pos = 0;
441 buf[0] = '\0';
442 while (!err) {
443 err = regexec(&re, &string[pos], re.re_nsub+1, subs, (pos ? REG_NOTBOL : 0));
444
445 if (err && err != REG_NOMATCH) {
446 php_ereg_eprint(err, &re TSRMLS_CC);
447 efree(subs);
448 efree(buf);
449 regfree(&re);
450 return ((char *) -1);
451 }
452
453 if (!err) {
454 /* backref replacement is done in two passes:
455 1) find out how long the string will be, and allocate buf
456 2) copy the part before match, replacement and backrefs to buf
457
458 Jaakko Hyv�tti <Jaakko.Hyvatti@iki.fi>
459 */
460
461 new_l = strlen(buf) + subs[0].rm_so; /* part before the match */
462 walk = replace;
463 while (*walk) {
464 if ('\\' == *walk && isdigit((unsigned char)walk[1]) && ((unsigned char)walk[1]) - '0' <= (int)re.re_nsub) {
465 if (subs[walk[1] - '0'].rm_so > -1 && subs[walk[1] - '0'].rm_eo > -1) {
466 new_l += subs[walk[1] - '0'].rm_eo - subs[walk[1] - '0'].rm_so;
467 }
468 walk += 2;
469 } else {
470 new_l++;
471 walk++;
472 }
473 }
474 if (new_l + 1 > buf_len) {
475 buf_len = 1 + buf_len + 2 * new_l;
476 nbuf = emalloc(buf_len);
477 strncpy(nbuf, buf, buf_len - 1);
478 nbuf[buf_len - 1] = '\0';
479 efree(buf);
480 buf = nbuf;
481 }
482 tmp = strlen(buf);
483 /* copy the part of the string before the match */
484 strncat(buf, &string[pos], subs[0].rm_so);
485
486 /* copy replacement and backrefs */
487 walkbuf = &buf[tmp + subs[0].rm_so];
488 walk = replace;
489 while (*walk) {
490 if ('\\' == *walk && isdigit((unsigned char)walk[1]) && (unsigned char)walk[1] - '0' <= (int)re.re_nsub) {
491 if (subs[walk[1] - '0'].rm_so > -1 && subs[walk[1] - '0'].rm_eo > -1
492 /* this next case shouldn't happen. it does. */
493 && subs[walk[1] - '0'].rm_so <= subs[walk[1] - '0'].rm_eo) {
494
495 tmp = subs[walk[1] - '0'].rm_eo - subs[walk[1] - '0'].rm_so;
496 memcpy (walkbuf, &string[pos + subs[walk[1] - '0'].rm_so], tmp);
497 walkbuf += tmp;
498 }
499 walk += 2;
500 } else {
501 *walkbuf++ = *walk++;
502 }
503 }
504 *walkbuf = '\0';
505
506 /* and get ready to keep looking for replacements */
507 if (subs[0].rm_so == subs[0].rm_eo) {
508 if (subs[0].rm_so + pos >= string_len) {
509 break;
510 }
511 new_l = strlen (buf) + 1;
512 if (new_l + 1 > buf_len) {
513 buf_len = 1 + buf_len + 2 * new_l;
514 nbuf = safe_emalloc(buf_len, sizeof(char), 0);
515 strncpy(nbuf, buf, buf_len-1);
516 efree(buf);
517 buf = nbuf;
518 }
519 pos += subs[0].rm_eo + 1;
520 buf [new_l-1] = string [pos-1];
521 buf [new_l] = '\0';
522 } else {
523 pos += subs[0].rm_eo;
524 }
525 } else { /* REG_NOMATCH */
526 new_l = strlen(buf) + strlen(&string[pos]);
527 if (new_l + 1 > buf_len) {
528 buf_len = new_l + 1; /* now we know exactly how long it is */
529 nbuf = safe_emalloc(buf_len, sizeof(char), 0);
530 strncpy(nbuf, buf, buf_len-1);
531 efree(buf);
532 buf = nbuf;
533 }
534 /* stick that last bit of string on our output */
535 strlcat(buf, &string[pos], buf_len);
536 }
537 }
538
539 /* don't want to leak memory .. */
540 efree(subs);
541 regfree(&re);
542
543 /* whew. */
544 return (buf);
545 }
546 /* }}} */
547
548 /* {{{ php_do_ereg_replace
549 */
php_do_ereg_replace(INTERNAL_FUNCTION_PARAMETERS,int icase)550 static void php_do_ereg_replace(INTERNAL_FUNCTION_PARAMETERS, int icase)
551 {
552 zval **arg_pattern,
553 **arg_replace;
554 char *pattern, *arg_string;
555 char *string;
556 char *replace;
557 char *ret;
558 int arg_string_len;
559
560 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ZZs", &arg_pattern, &arg_replace, &arg_string, &arg_string_len) == FAILURE) {
561 return;
562 }
563
564 if (Z_TYPE_PP(arg_pattern) == IS_STRING) {
565 if (Z_STRVAL_PP(arg_pattern) && Z_STRLEN_PP(arg_pattern)) {
566 pattern = estrndup(Z_STRVAL_PP(arg_pattern), Z_STRLEN_PP(arg_pattern));
567 } else {
568 pattern = STR_EMPTY_ALLOC();
569 }
570 } else {
571 convert_to_long_ex(arg_pattern);
572 pattern = emalloc(2);
573 pattern[0] = (char) Z_LVAL_PP(arg_pattern);
574 pattern[1] = '\0';
575 }
576
577 if (Z_TYPE_PP(arg_replace) == IS_STRING) {
578 if (Z_STRVAL_PP(arg_replace) && Z_STRLEN_PP(arg_replace)) {
579 replace = estrndup(Z_STRVAL_PP(arg_replace), Z_STRLEN_PP(arg_replace));
580 } else {
581 replace = STR_EMPTY_ALLOC();
582 }
583 } else {
584 convert_to_long_ex(arg_replace);
585 replace = emalloc(2);
586 replace[0] = (char) Z_LVAL_PP(arg_replace);
587 replace[1] = '\0';
588 }
589
590 if (arg_string && arg_string_len) {
591 string = estrndup(arg_string, arg_string_len);
592 } else {
593 string = STR_EMPTY_ALLOC();
594 }
595
596 /* do the actual work */
597 ret = php_ereg_replace(pattern, replace, string, icase, 1 TSRMLS_CC);
598 if (ret == (char *) -1) {
599 RETVAL_FALSE;
600 } else {
601 RETVAL_STRING(ret, 1);
602 STR_FREE(ret);
603 }
604
605 STR_FREE(string);
606 STR_FREE(replace);
607 STR_FREE(pattern);
608 }
609 /* }}} */
610
611 /* {{{ proto string ereg_replace(string pattern, string replacement, string string)
612 Replace regular expression */
PHP_FUNCTION(ereg_replace)613 PHP_FUNCTION(ereg_replace)
614 {
615 php_do_ereg_replace(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
616 }
617 /* }}} */
618
619 /* {{{ proto string eregi_replace(string pattern, string replacement, string string)
620 Case insensitive replace regular expression */
PHP_FUNCTION(eregi_replace)621 PHP_FUNCTION(eregi_replace)
622 {
623 php_do_ereg_replace(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1);
624 }
625 /* }}} */
626
627 /* {{{ php_split
628 */
php_split(INTERNAL_FUNCTION_PARAMETERS,int icase)629 static void php_split(INTERNAL_FUNCTION_PARAMETERS, int icase)
630 {
631 long count = -1;
632 regex_t re;
633 regmatch_t subs[1];
634 char *spliton, *str, *strp, *endp;
635 int spliton_len, str_len;
636 int err, size, copts = 0;
637
638 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|l", &spliton, &spliton_len, &str, &str_len, &count) == FAILURE) {
639 return;
640 }
641
642 if (icase) {
643 copts = REG_ICASE;
644 }
645
646 strp = str;
647 endp = strp + str_len;
648
649 err = regcomp(&re, spliton, REG_EXTENDED | copts);
650 if (err) {
651 php_ereg_eprint(err, &re TSRMLS_CC);
652 RETURN_FALSE;
653 }
654
655 array_init(return_value);
656
657 /* churn through str, generating array entries as we go */
658 while ((count == -1 || count > 1) && !(err = regexec(&re, strp, 1, subs, 0))) {
659 if (subs[0].rm_so == 0 && subs[0].rm_eo) {
660 /* match is at start of string, return empty string */
661 add_next_index_stringl(return_value, "", 0, 1);
662 /* skip ahead the length of the regex match */
663 strp += subs[0].rm_eo;
664 } else if (subs[0].rm_so == 0 && subs[0].rm_eo == 0) {
665 /* No more matches */
666 regfree(&re);
667
668 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid Regular Expression");
669
670 zend_hash_destroy(Z_ARRVAL_P(return_value));
671 efree(Z_ARRVAL_P(return_value));
672 RETURN_FALSE;
673 } else {
674 /* On a real match */
675
676 /* make a copy of the substring */
677 size = subs[0].rm_so;
678
679 /* add it to the array */
680 add_next_index_stringl(return_value, strp, size, 1);
681
682 /* point at our new starting point */
683 strp = strp + subs[0].rm_eo;
684 }
685
686 /* if we're only looking for a certain number of points,
687 stop looking once we hit it */
688 if (count != -1) {
689 count--;
690 }
691 }
692
693 /* see if we encountered an error */
694 if (err && err != REG_NOMATCH) {
695 php_ereg_eprint(err, &re TSRMLS_CC);
696 regfree(&re);
697 zend_hash_destroy(Z_ARRVAL_P(return_value));
698 efree(Z_ARRVAL_P(return_value));
699 RETURN_FALSE;
700 }
701
702 /* otherwise we just have one last element to add to the array */
703 size = endp - strp;
704
705 add_next_index_stringl(return_value, strp, size, 1);
706
707 regfree(&re);
708 }
709 /* }}} */
710
711 /* {{{ proto array split(string pattern, string string [, int limit])
712 Split string into array by regular expression */
PHP_FUNCTION(split)713 PHP_FUNCTION(split)
714 {
715 php_split(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
716 }
717 /* }}} */
718
719 /* {{{ proto array spliti(string pattern, string string [, int limit])
720 Split string into array by regular expression case-insensitive */
721
PHP_FUNCTION(spliti)722 PHP_FUNCTION(spliti)
723 {
724 php_split(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1);
725 }
726
727 /* }}} */
728
729 /* {{{ proto string sql_regcase(string string)
730 Make regular expression for case insensitive match */
PHP_FUNCTION(sql_regcase)731 PHP_EREG_API PHP_FUNCTION(sql_regcase)
732 {
733 char *string, *tmp;
734 int string_len;
735 unsigned char c;
736 register int i, j;
737
738 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &string, &string_len) == FAILURE) {
739 return;
740 }
741
742 tmp = safe_emalloc(string_len, 4, 1);
743
744 for (i = j = 0; i < string_len; i++) {
745 c = (unsigned char) string[i];
746 if (isalpha(c)) {
747 tmp[j++] = '[';
748 tmp[j++] = toupper(c);
749 tmp[j++] = tolower(c);
750 tmp[j++] = ']';
751 } else {
752 tmp[j++] = c;
753 }
754 }
755 tmp[j] = 0;
756
757 RETVAL_STRINGL(tmp, j, 1);
758 efree(tmp);
759 }
760 /* }}} */
761
762 /*
763 * Local variables:
764 * tab-width: 4
765 * c-basic-offset: 4
766 * End:
767 * vim600: noet sw=4 ts=4 fdm=marker
768 * vim<600: noet sw=4 ts=4
769 */
770
