1999-04-17 00:37:12 +00:00
/*
+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +
2004-01-08 08:18:22 +00:00
| PHP Version 5 |
1999-04-17 00:37:12 +00:00
+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +
2007-12-31 07:17:19 +00:00
| Copyright ( c ) 1997 - 2008 The PHP Group |
1999-04-17 00:37:12 +00:00
+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +
2006-01-01 12:51:34 +00:00
| This source file is subject to version 3.01 of the PHP license , |
1999-07-16 13:13:16 +00:00
| that is bundled with this package in the file LICENSE , and is |
2003-06-10 20:04:29 +00:00
| available through the world - wide - web at the following url : |
2006-01-01 12:51:34 +00:00
| http : //www.php.net/license/3_01.txt |
1999-07-16 13:13:16 +00:00
| If you did not receive a copy of the PHP license and are unable to |
| obtain it through the world - wide - web , please send a note to |
| license @ php . net so we can mail you a copy immediately . |
1999-04-17 00:37:12 +00:00
+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +
2000-05-23 20:16:14 +00:00
| Authors : Rasmus Lerdorf < rasmus @ php . net > |
2003-03-18 12:06:09 +00:00
| Stig S <EFBFBD> ther Bakken < ssb @ php . net > |
1999-07-16 13:13:16 +00:00
| Zeev Suraski < zeev @ zend . com > |
1999-04-17 00:37:12 +00:00
+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +
*/
/* $Id$ */
1999-04-23 20:06:01 +00:00
1999-12-18 04:01:20 +00:00
/* Synced with php 3.0 revision 1.193 1999-06-16 [ssb] */
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
1999-04-17 00:37:12 +00:00
# include <stdio.h>
# include "php.h"
2002-09-26 19:18:35 +00:00
# include "php_rand.h"
1999-12-04 19:19:57 +00:00
# include "php_string.h"
2000-01-28 17:24:53 +00:00
# include "php_variables.h"
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
# ifdef HAVE_LOCALE_H
# include <locale.h>
1999-04-17 00:37:12 +00:00
# endif
2001-07-04 10:10:30 +00:00
# ifdef HAVE_LANGINFO_H
# include <langinfo.h>
# endif
2002-08-21 13:14:57 +00:00
# ifdef HAVE_MONETARY_H
# include <monetary.h>
# endif
2003-05-27 00:42:39 +00:00
# ifdef HAVE_LIBINTL
# include <libintl.h> /* For LC_MESSAGES */
# endif
2003-02-07 21:36:18 +00:00
2000-06-06 18:58:15 +00:00
# include "scanf.h"
# include "zend_API.h"
1999-06-15 21:51:00 +00:00
# include "zend_execute.h"
# include "php_globals.h"
1999-12-28 18:47:59 +00:00
# include "basic_functions.h"
2000-10-12 01:26:26 +00:00
# include "php_smart_str.h"
2001-01-14 16:36:30 +00:00
# ifdef ZTS
# include "TSRM.h"
# endif
1999-04-17 00:37:12 +00:00
2000-09-11 13:52:22 +00:00
# define STR_PAD_LEFT 0
# define STR_PAD_RIGHT 1
# define STR_PAD_BOTH 2
2002-01-22 03:35:23 +00:00
# define PHP_PATHINFO_DIRNAME 1
# define PHP_PATHINFO_BASENAME 2
# define PHP_PATHINFO_EXTENSION 4
2006-07-16 10:37:24 +00:00
# define PHP_PATHINFO_FILENAME 8
# define PHP_PATHINFO_ALL (PHP_PATHINFO_DIRNAME | PHP_PATHINFO_BASENAME | PHP_PATHINFO_EXTENSION | PHP_PATHINFO_FILENAME)
2000-07-08 20:38:23 +00:00
2002-09-25 19:06:29 +00:00
# define STR_STRSPN 0
# define STR_STRCSPN 1
2001-06-06 13:06:12 +00:00
/* {{{ register_string_constants
*/
2000-07-08 20:38:23 +00:00
void register_string_constants ( INIT_FUNC_ARGS )
{
2000-09-10 05:59:16 +00:00
REGISTER_LONG_CONSTANT ( " STR_PAD_LEFT " , STR_PAD_LEFT , CONST_CS | CONST_PERSISTENT ) ;
REGISTER_LONG_CONSTANT ( " STR_PAD_RIGHT " , STR_PAD_RIGHT , CONST_CS | CONST_PERSISTENT ) ;
REGISTER_LONG_CONSTANT ( " STR_PAD_BOTH " , STR_PAD_BOTH , CONST_CS | CONST_PERSISTENT ) ;
REGISTER_LONG_CONSTANT ( " PATHINFO_DIRNAME " , PHP_PATHINFO_DIRNAME , CONST_CS | CONST_PERSISTENT ) ;
2000-09-11 13:52:22 +00:00
REGISTER_LONG_CONSTANT ( " PATHINFO_BASENAME " , PHP_PATHINFO_BASENAME , CONST_CS | CONST_PERSISTENT ) ;
2000-09-10 05:59:16 +00:00
REGISTER_LONG_CONSTANT ( " PATHINFO_EXTENSION " , PHP_PATHINFO_EXTENSION , CONST_CS | CONST_PERSISTENT ) ;
2006-07-16 10:37:24 +00:00
REGISTER_LONG_CONSTANT ( " PATHINFO_FILENAME " , PHP_PATHINFO_FILENAME , CONST_CS | CONST_PERSISTENT ) ;
2000-12-10 15:55:34 +00:00
2001-01-14 16:36:30 +00:00
# ifdef HAVE_LOCALECONV
/* If last members of struct lconv equal CHAR_MAX, no grouping is done */
/* This is bad, but since we are going to be hardcoding in the POSIX stuff anyway... */
# ifndef HAVE_LIMITS_H
# define CHAR_MAX 127
# endif
REGISTER_LONG_CONSTANT ( " CHAR_MAX " , CHAR_MAX , CONST_CS | CONST_PERSISTENT ) ;
# endif
2000-12-10 15:55:34 +00:00
# ifdef HAVE_LOCALE_H
REGISTER_LONG_CONSTANT ( " LC_CTYPE " , LC_CTYPE , CONST_CS | CONST_PERSISTENT ) ;
REGISTER_LONG_CONSTANT ( " LC_NUMERIC " , LC_NUMERIC , CONST_CS | CONST_PERSISTENT ) ;
REGISTER_LONG_CONSTANT ( " LC_TIME " , LC_TIME , CONST_CS | CONST_PERSISTENT ) ;
REGISTER_LONG_CONSTANT ( " LC_COLLATE " , LC_COLLATE , CONST_CS | CONST_PERSISTENT ) ;
REGISTER_LONG_CONSTANT ( " LC_MONETARY " , LC_MONETARY , CONST_CS | CONST_PERSISTENT ) ;
REGISTER_LONG_CONSTANT ( " LC_ALL " , LC_ALL , CONST_CS | CONST_PERSISTENT ) ;
2000-12-14 15:58:14 +00:00
# ifdef LC_MESSAGES
2000-12-11 16:27:48 +00:00
REGISTER_LONG_CONSTANT ( " LC_MESSAGES " , LC_MESSAGES , CONST_CS | CONST_PERSISTENT ) ;
# endif
2000-12-10 15:55:34 +00:00
# endif
2000-07-08 20:38:23 +00:00
}
2001-06-06 13:06:12 +00:00
/* }}} */
2000-07-08 20:38:23 +00:00
1999-12-05 14:16:37 +00:00
int php_tag_find ( char * tag , int len , char * set ) ;
1999-11-28 00:31:02 +00:00
/* this is read-only, so it's ok */
1999-05-16 11:12:23 +00:00
static char hexconvtab [ ] = " 0123456789abcdef " ;
2001-01-14 16:36:30 +00:00
/* localeconv mutex */
# ifdef ZTS
static MUTEX_T locale_mutex = NULL ;
# endif
2001-06-06 13:06:12 +00:00
/* {{{ php_bin2hex
*/
1999-05-16 11:32:51 +00:00
static char * php_bin2hex ( const unsigned char * old , const size_t oldlen , size_t * newlen )
1999-05-16 11:12:23 +00:00
{
2001-09-04 06:18:11 +00:00
register unsigned char * result = NULL ;
1999-08-12 10:53:29 +00:00
size_t i , j ;
1999-05-16 11:12:23 +00:00
2003-08-11 23:16:54 +00:00
result = ( char * ) safe_emalloc ( oldlen * 2 , sizeof ( char ) , 1 ) ;
1999-05-16 11:12:23 +00:00
2002-10-02 17:56:04 +00:00
for ( i = j = 0 ; i < oldlen ; i + + ) {
2000-03-26 17:06:19 +00:00
result [ j + + ] = hexconvtab [ old [ i ] > > 4 ] ;
result [ j + + ] = hexconvtab [ old [ i ] & 15 ] ;
1999-05-16 11:12:23 +00:00
}
2001-02-22 10:36:40 +00:00
result [ j ] = ' \0 ' ;
1999-05-16 11:12:23 +00:00
2001-09-04 06:18:11 +00:00
if ( newlen )
* newlen = oldlen * 2 * sizeof ( char ) ;
1999-05-16 11:12:23 +00:00
2000-03-26 17:06:19 +00:00
return result ;
1999-05-16 11:12:23 +00:00
}
2001-06-06 13:06:12 +00:00
/* }}} */
1999-05-16 11:12:23 +00:00
2001-01-14 16:36:30 +00:00
# ifdef HAVE_LOCALECONV
2001-06-05 13:12:10 +00:00
/* {{{ localeconv_r
* glibc ' s localeconv is not reentrant , so lets make it so . . . sorta */
2004-11-03 23:36:51 +00:00
PHPAPI struct lconv * localeconv_r ( struct lconv * out )
2001-01-14 16:36:30 +00:00
{
struct lconv * res ;
# ifdef ZTS
tsrm_mutex_lock ( locale_mutex ) ;
# endif
/* localeconv doesn't return an error condition */
res = localeconv ( ) ;
* out = * res ;
# ifdef ZTS
tsrm_mutex_unlock ( locale_mutex ) ;
# endif
return out ;
}
2001-06-05 13:12:10 +00:00
/* }}} */
2001-01-14 16:36:30 +00:00
# ifdef ZTS
2001-06-05 13:12:10 +00:00
/* {{{ PHP_MINIT_FUNCTION
*/
2001-01-14 16:36:30 +00:00
PHP_MINIT_FUNCTION ( localeconv )
{
locale_mutex = tsrm_mutex_alloc ( ) ;
return SUCCESS ;
}
2001-06-05 13:12:10 +00:00
/* }}} */
2001-01-14 16:36:30 +00:00
2001-06-05 13:12:10 +00:00
/* {{{ PHP_MSHUTDOWN_FUNCTION
*/
2001-01-14 16:36:30 +00:00
PHP_MSHUTDOWN_FUNCTION ( localeconv )
{
tsrm_mutex_free ( locale_mutex ) ;
locale_mutex = NULL ;
return SUCCESS ;
}
2001-06-05 13:12:10 +00:00
/* }}} */
2001-01-14 16:36:30 +00:00
# endif
# endif
2000-02-24 10:11:42 +00:00
/* {{{ proto string bin2hex(string data)
Converts the binary representation of data to hex */
1999-05-16 11:12:23 +00:00
PHP_FUNCTION ( bin2hex )
{
2008-06-22 19:22:41 +00:00
char * result , * data ;
2008-07-03 14:00:20 +00:00
size_t newlen ;
int datalen ;
1999-05-16 11:12:23 +00:00
2008-06-22 19:22:41 +00:00
if ( zend_parse_parameters ( ZEND_NUM_ARGS ( ) TSRMLS_CC , " s " , & data , & datalen ) = = FAILURE ) {
return ;
1999-05-16 11:12:23 +00:00
}
2008-06-22 19:22:41 +00:00
result = php_bin2hex ( data , datalen , & newlen ) ;
1999-05-16 11:12:23 +00:00
2001-09-04 06:18:11 +00:00
if ( ! result ) {
1999-05-16 11:12:23 +00:00
RETURN_FALSE ;
}
2000-03-26 17:06:19 +00:00
RETURN_STRINGL ( result , newlen , 0 ) ;
1999-05-16 11:12:23 +00:00
}
2000-02-24 10:11:42 +00:00
/* }}} */
1999-04-17 00:37:12 +00:00
2007-06-05 13:35:26 +00:00
static void php_spn_common_handler ( INTERNAL_FUNCTION_PARAMETERS , int behavior ) /* { { { */
1999-04-17 00:37:12 +00:00
{
2002-09-25 19:06:29 +00:00
char * s11 , * s22 ;
2003-03-06 23:07:28 +00:00
int len1 , len2 ;
long start , len ;
1999-04-17 00:37:12 +00:00
2002-09-25 19:06:29 +00:00
start = 0 ;
len = 0 ;
if ( zend_parse_parameters ( ZEND_NUM_ARGS ( ) TSRMLS_CC , " ss|ll " , & s11 , & len1 ,
& s22 , & len2 , & start , & len ) = = FAILURE ) {
return ;
}
if ( ZEND_NUM_ARGS ( ) < 4 ) {
len = len1 ;
}
/* look at substr() function for more information */
if ( start < 0 ) {
start + = len1 ;
if ( start < 0 ) {
start = 0 ;
}
} else if ( start > len1 ) {
RETURN_FALSE ;
}
if ( len < 0 ) {
len + = ( len1 - start ) ;
if ( len < 0 ) {
len = 0 ;
}
}
2007-06-06 17:59:07 +00:00
if ( len > len1 - start ) {
2002-09-25 19:06:29 +00:00
len = len1 - start ;
1999-04-17 00:37:12 +00:00
}
2001-09-04 06:18:11 +00:00
2007-06-06 17:59:07 +00:00
if ( len = = 0 ) {
RETURN_LONG ( 0 ) ;
}
2002-09-25 19:06:29 +00:00
if ( behavior = = STR_STRSPN ) {
RETURN_LONG ( php_strspn ( s11 + start /*str1_start*/ ,
s22 /*str2_start*/ ,
s11 + start + len /*str1_end*/ ,
s22 + len2 /*str2_end*/ ) ) ;
} else if ( behavior = = STR_STRCSPN ) {
RETURN_LONG ( php_strcspn ( s11 + start /*str1_start*/ ,
s22 /*str2_start*/ ,
s11 + start + len /*str1_end*/ ,
s22 + len2 /*str2_end*/ ) ) ;
}
}
2007-06-05 13:35:26 +00:00
/* }}} */
2002-09-25 19:06:29 +00:00
/* {{{ proto int strspn(string str, string mask [, start [, len]])
Finds length of initial segment consisting entirely of characters found in mask . If start or / and length is provided works like strspn ( substr ( $ s , $ start , $ len ) , $ good_chars ) */
PHP_FUNCTION ( strspn )
{
php_spn_common_handler ( INTERNAL_FUNCTION_PARAM_PASSTHRU , STR_STRSPN ) ;
1999-04-17 00:37:12 +00:00
}
/* }}} */
2002-09-25 19:06:29 +00:00
/* {{{ proto int strcspn(string str, string mask [, start [, len]])
Finds length of initial segment consisting entirely of characters not found in mask . If start or / and length is provide works like strcspn ( substr ( $ s , $ start , $ len ) , $ bad_chars ) */
1999-06-15 21:51:00 +00:00
PHP_FUNCTION ( strcspn )
1999-04-17 00:37:12 +00:00
{
2002-09-25 19:06:29 +00:00
php_spn_common_handler ( INTERNAL_FUNCTION_PARAM_PASSTHRU , STR_STRCSPN ) ;
1999-04-17 00:37:12 +00:00
}
/* }}} */
2001-07-05 10:49:58 +00:00
/* {{{ PHP_MINIT_FUNCTION(nl_langinfo) */
2001-07-04 10:10:30 +00:00
# if HAVE_NL_LANGINFO
PHP_MINIT_FUNCTION ( nl_langinfo )
{
# define REGISTER_NL_LANGINFO_CONSTANT(x) REGISTER_LONG_CONSTANT(#x, x, CONST_CS | CONST_PERSISTENT)
2001-08-10 18:02:59 +00:00
# ifdef ABDAY_1
2001-07-04 10:10:30 +00:00
REGISTER_NL_LANGINFO_CONSTANT ( ABDAY_1 ) ;
REGISTER_NL_LANGINFO_CONSTANT ( ABDAY_2 ) ;
REGISTER_NL_LANGINFO_CONSTANT ( ABDAY_3 ) ;
REGISTER_NL_LANGINFO_CONSTANT ( ABDAY_4 ) ;
REGISTER_NL_LANGINFO_CONSTANT ( ABDAY_5 ) ;
REGISTER_NL_LANGINFO_CONSTANT ( ABDAY_6 ) ;
REGISTER_NL_LANGINFO_CONSTANT ( ABDAY_7 ) ;
2001-08-10 18:02:59 +00:00
# endif
# ifdef DAY_1
2001-07-04 10:10:30 +00:00
REGISTER_NL_LANGINFO_CONSTANT ( DAY_1 ) ;
REGISTER_NL_LANGINFO_CONSTANT ( DAY_2 ) ;
REGISTER_NL_LANGINFO_CONSTANT ( DAY_3 ) ;
REGISTER_NL_LANGINFO_CONSTANT ( DAY_4 ) ;
REGISTER_NL_LANGINFO_CONSTANT ( DAY_5 ) ;
REGISTER_NL_LANGINFO_CONSTANT ( DAY_6 ) ;
REGISTER_NL_LANGINFO_CONSTANT ( DAY_7 ) ;
2001-08-10 18:02:59 +00:00
# endif
# ifdef ABMON_1
2001-07-04 10:10:30 +00:00
REGISTER_NL_LANGINFO_CONSTANT ( ABMON_1 ) ;
REGISTER_NL_LANGINFO_CONSTANT ( ABMON_2 ) ;
REGISTER_NL_LANGINFO_CONSTANT ( ABMON_3 ) ;
REGISTER_NL_LANGINFO_CONSTANT ( ABMON_4 ) ;
REGISTER_NL_LANGINFO_CONSTANT ( ABMON_5 ) ;
REGISTER_NL_LANGINFO_CONSTANT ( ABMON_6 ) ;
REGISTER_NL_LANGINFO_CONSTANT ( ABMON_7 ) ;
REGISTER_NL_LANGINFO_CONSTANT ( ABMON_8 ) ;
REGISTER_NL_LANGINFO_CONSTANT ( ABMON_9 ) ;
REGISTER_NL_LANGINFO_CONSTANT ( ABMON_10 ) ;
REGISTER_NL_LANGINFO_CONSTANT ( ABMON_11 ) ;
REGISTER_NL_LANGINFO_CONSTANT ( ABMON_12 ) ;
2001-08-10 18:02:59 +00:00
# endif
# ifdef MON_1
2001-07-04 10:10:30 +00:00
REGISTER_NL_LANGINFO_CONSTANT ( MON_1 ) ;
REGISTER_NL_LANGINFO_CONSTANT ( MON_2 ) ;
REGISTER_NL_LANGINFO_CONSTANT ( MON_3 ) ;
REGISTER_NL_LANGINFO_CONSTANT ( MON_4 ) ;
REGISTER_NL_LANGINFO_CONSTANT ( MON_5 ) ;
REGISTER_NL_LANGINFO_CONSTANT ( MON_6 ) ;
REGISTER_NL_LANGINFO_CONSTANT ( MON_7 ) ;
REGISTER_NL_LANGINFO_CONSTANT ( MON_8 ) ;
REGISTER_NL_LANGINFO_CONSTANT ( MON_9 ) ;
REGISTER_NL_LANGINFO_CONSTANT ( MON_10 ) ;
REGISTER_NL_LANGINFO_CONSTANT ( MON_11 ) ;
REGISTER_NL_LANGINFO_CONSTANT ( MON_12 ) ;
2001-08-10 18:02:59 +00:00
# endif
# ifdef AM_STR
2001-07-04 10:10:30 +00:00
REGISTER_NL_LANGINFO_CONSTANT ( AM_STR ) ;
2001-08-10 18:02:59 +00:00
# endif
# ifdef PM_STR
2001-07-04 10:10:30 +00:00
REGISTER_NL_LANGINFO_CONSTANT ( PM_STR ) ;
2001-08-10 18:02:59 +00:00
# endif
# ifdef D_T_FMT
2001-07-04 10:10:30 +00:00
REGISTER_NL_LANGINFO_CONSTANT ( D_T_FMT ) ;
2001-08-10 18:02:59 +00:00
# endif
# ifdef D_FMT
2001-07-04 10:10:30 +00:00
REGISTER_NL_LANGINFO_CONSTANT ( D_FMT ) ;
2001-08-10 18:02:59 +00:00
# endif
# ifdef T_FMT
2001-07-04 10:10:30 +00:00
REGISTER_NL_LANGINFO_CONSTANT ( T_FMT ) ;
2001-08-10 18:02:59 +00:00
# endif
# ifdef T_FMT_AMPM
2001-07-04 10:10:30 +00:00
REGISTER_NL_LANGINFO_CONSTANT ( T_FMT_AMPM ) ;
2001-08-10 18:02:59 +00:00
# endif
# ifdef ERA
2001-07-04 10:10:30 +00:00
REGISTER_NL_LANGINFO_CONSTANT ( ERA ) ;
2001-08-10 18:02:59 +00:00
# endif
2001-07-05 10:49:58 +00:00
# ifdef ERA_YEAR
2001-07-04 10:10:30 +00:00
REGISTER_NL_LANGINFO_CONSTANT ( ERA_YEAR ) ;
2001-07-05 10:49:58 +00:00
# endif
2001-08-10 18:02:59 +00:00
# ifdef ERA_D_T_FMT
2001-07-04 10:10:30 +00:00
REGISTER_NL_LANGINFO_CONSTANT ( ERA_D_T_FMT ) ;
2001-08-10 18:02:59 +00:00
# endif
# ifdef ERA_D_FMT
2001-07-04 10:10:30 +00:00
REGISTER_NL_LANGINFO_CONSTANT ( ERA_D_FMT ) ;
2001-08-10 18:02:59 +00:00
# endif
# ifdef ERA_T_FMT
2001-07-04 10:10:30 +00:00
REGISTER_NL_LANGINFO_CONSTANT ( ERA_T_FMT ) ;
2001-08-10 18:02:59 +00:00
# endif
# ifdef ALT_DIGITS
2001-07-04 10:10:30 +00:00
REGISTER_NL_LANGINFO_CONSTANT ( ALT_DIGITS ) ;
2001-08-10 18:02:59 +00:00
# endif
2001-07-05 10:49:58 +00:00
# ifdef INT_CURR_SYMBOL
2001-07-04 10:10:30 +00:00
REGISTER_NL_LANGINFO_CONSTANT ( INT_CURR_SYMBOL ) ;
2001-07-05 10:49:58 +00:00
# endif
2001-07-04 10:10:30 +00:00
# ifdef CURRENCY_SYMBOL
REGISTER_NL_LANGINFO_CONSTANT ( CURRENCY_SYMBOL ) ;
# endif
# ifdef CRNCYSTR
REGISTER_NL_LANGINFO_CONSTANT ( CRNCYSTR ) ;
# endif
2001-07-05 10:49:58 +00:00
# ifdef MON_DECIMAL_POINT
2001-07-04 10:10:30 +00:00
REGISTER_NL_LANGINFO_CONSTANT ( MON_DECIMAL_POINT ) ;
2001-07-05 10:49:58 +00:00
# endif
# ifdef MON_THOUSANDS_SEP
2001-07-04 10:10:30 +00:00
REGISTER_NL_LANGINFO_CONSTANT ( MON_THOUSANDS_SEP ) ;
2001-07-05 10:49:58 +00:00
# endif
# ifdef MON_GROUPING
2001-07-04 10:10:30 +00:00
REGISTER_NL_LANGINFO_CONSTANT ( MON_GROUPING ) ;
2001-07-05 10:49:58 +00:00
# endif
# ifdef POSITIVE_SIGN
2001-07-04 10:10:30 +00:00
REGISTER_NL_LANGINFO_CONSTANT ( POSITIVE_SIGN ) ;
2001-07-05 10:49:58 +00:00
# endif
# ifdef NEGATIVE_SIGN
2001-07-04 10:10:30 +00:00
REGISTER_NL_LANGINFO_CONSTANT ( NEGATIVE_SIGN ) ;
2001-07-05 10:49:58 +00:00
# endif
# ifdef INT_FRAC_DIGITS
2001-07-04 10:10:30 +00:00
REGISTER_NL_LANGINFO_CONSTANT ( INT_FRAC_DIGITS ) ;
2001-07-05 10:49:58 +00:00
# endif
# ifdef FRAC_DIGITS
2001-07-04 10:10:30 +00:00
REGISTER_NL_LANGINFO_CONSTANT ( FRAC_DIGITS ) ;
2001-07-05 10:49:58 +00:00
# endif
# ifdef P_CS_PRECEDES
2001-07-04 10:10:30 +00:00
REGISTER_NL_LANGINFO_CONSTANT ( P_CS_PRECEDES ) ;
2001-07-05 10:49:58 +00:00
# endif
# ifdef P_SEP_BY_SPACE
2001-07-04 10:10:30 +00:00
REGISTER_NL_LANGINFO_CONSTANT ( P_SEP_BY_SPACE ) ;
2001-07-05 10:49:58 +00:00
# endif
# ifdef N_CS_PRECEDES
2001-07-04 10:10:30 +00:00
REGISTER_NL_LANGINFO_CONSTANT ( N_CS_PRECEDES ) ;
2001-07-05 10:49:58 +00:00
# endif
# ifdef N_SEP_BY_SPACE
2001-07-04 10:10:30 +00:00
REGISTER_NL_LANGINFO_CONSTANT ( N_SEP_BY_SPACE ) ;
2001-07-05 10:49:58 +00:00
# endif
# ifdef P_SIGN_POSN
2001-07-04 10:10:30 +00:00
REGISTER_NL_LANGINFO_CONSTANT ( P_SIGN_POSN ) ;
2001-07-05 10:49:58 +00:00
# endif
# ifdef N_SIGN_POSN
2001-07-04 10:10:30 +00:00
REGISTER_NL_LANGINFO_CONSTANT ( N_SIGN_POSN ) ;
2001-07-05 10:49:58 +00:00
# endif
2001-07-04 10:10:30 +00:00
# ifdef DECIMAL_POINT
REGISTER_NL_LANGINFO_CONSTANT ( DECIMAL_POINT ) ;
2008-05-09 12:59:16 +00:00
# elif defined(RADIXCHAR)
2001-07-04 10:10:30 +00:00
REGISTER_NL_LANGINFO_CONSTANT ( RADIXCHAR ) ;
# endif
# ifdef THOUSANDS_SEP
REGISTER_NL_LANGINFO_CONSTANT ( THOUSANDS_SEP ) ;
2008-05-09 12:59:16 +00:00
# elif defined(THOUSEP)
2001-07-04 10:10:30 +00:00
REGISTER_NL_LANGINFO_CONSTANT ( THOUSEP ) ;
# endif
2001-07-05 10:53:15 +00:00
# ifdef GROUPING
2001-07-04 10:10:30 +00:00
REGISTER_NL_LANGINFO_CONSTANT ( GROUPING ) ;
2001-07-05 10:53:15 +00:00
# endif
# ifdef YESEXPR
2001-07-04 10:10:30 +00:00
REGISTER_NL_LANGINFO_CONSTANT ( YESEXPR ) ;
2001-07-05 10:53:15 +00:00
# endif
# ifdef NOEXPR
2001-07-04 10:10:30 +00:00
REGISTER_NL_LANGINFO_CONSTANT ( NOEXPR ) ;
2001-07-05 10:53:15 +00:00
# endif
# ifdef YESSTR
2001-07-04 10:10:30 +00:00
REGISTER_NL_LANGINFO_CONSTANT ( YESSTR ) ;
2001-07-05 10:53:15 +00:00
# endif
# ifdef NOSTR
2001-07-04 10:10:30 +00:00
REGISTER_NL_LANGINFO_CONSTANT ( NOSTR ) ;
2001-07-05 10:53:15 +00:00
# endif
2001-07-04 10:10:30 +00:00
# ifdef CODESET
REGISTER_NL_LANGINFO_CONSTANT ( CODESET ) ;
# endif
# undef REGISTER_NL_LANGINFO_CONSTANT
return SUCCESS ;
}
2001-07-05 10:49:58 +00:00
/* }}} */
2001-12-06 19:02:27 +00:00
/* {{{ proto string nl_langinfo(int item)
Query language and locale information */
2001-07-04 10:10:30 +00:00
PHP_FUNCTION ( nl_langinfo )
{
2007-12-13 22:29:48 +00:00
long item ;
2001-09-04 06:18:11 +00:00
char * value ;
2001-07-04 10:10:30 +00:00
2007-12-13 22:29:48 +00:00
if ( zend_parse_parameters ( ZEND_NUM_ARGS ( ) TSRMLS_CC , " l " , & item ) = = FAILURE ) {
return ;
}
switch ( item ) { /* {{{ */
# ifdef ABDAY_1
case ABDAY_1 :
case ABDAY_2 :
case ABDAY_3 :
case ABDAY_4 :
case ABDAY_5 :
case ABDAY_6 :
case ABDAY_7 :
# endif
# ifdef DAY_1
case DAY_1 :
case DAY_2 :
case DAY_3 :
case DAY_4 :
case DAY_5 :
case DAY_6 :
case DAY_7 :
# endif
# ifdef ABMON_1
case ABMON_1 :
case ABMON_2 :
case ABMON_3 :
case ABMON_4 :
case ABMON_5 :
case ABMON_6 :
case ABMON_7 :
case ABMON_8 :
case ABMON_9 :
case ABMON_10 :
case ABMON_11 :
case ABMON_12 :
# endif
# ifdef MON_1
case MON_1 :
case MON_2 :
case MON_3 :
case MON_4 :
case MON_5 :
case MON_6 :
case MON_7 :
case MON_8 :
case MON_9 :
case MON_10 :
case MON_11 :
case MON_12 :
# endif
# ifdef AM_STR
case AM_STR :
# endif
# ifdef PM_STR
case PM_STR :
# endif
# ifdef D_T_FMT
case D_T_FMT :
# endif
# ifdef D_FMT
case D_FMT :
# endif
# ifdef T_FMT
case T_FMT :
# endif
# ifdef T_FMT_AMPM
case T_FMT_AMPM :
# endif
# ifdef ERA
case ERA :
# endif
# ifdef ERA_YEAR
case ERA_YEAR :
# endif
# ifdef ERA_D_T_FMT
case ERA_D_T_FMT :
# endif
# ifdef ERA_D_FMT
case ERA_D_FMT :
# endif
# ifdef ERA_T_FMT
case ERA_T_FMT :
# endif
# ifdef ALT_DIGITS
case ALT_DIGITS :
# endif
# ifdef INT_CURR_SYMBOL
case INT_CURR_SYMBOL :
# endif
# ifdef CURRENCY_SYMBOL
case CURRENCY_SYMBOL :
# endif
# ifdef CRNCYSTR
case CRNCYSTR :
# endif
# ifdef MON_DECIMAL_POINT
case MON_DECIMAL_POINT :
# endif
# ifdef MON_THOUSANDS_SEP
case MON_THOUSANDS_SEP :
# endif
# ifdef MON_GROUPING
case MON_GROUPING :
# endif
# ifdef POSITIVE_SIGN
case POSITIVE_SIGN :
# endif
# ifdef NEGATIVE_SIGN
case NEGATIVE_SIGN :
# endif
# ifdef INT_FRAC_DIGITS
case INT_FRAC_DIGITS :
# endif
# ifdef FRAC_DIGITS
case FRAC_DIGITS :
# endif
# ifdef P_CS_PRECEDES
case P_CS_PRECEDES :
# endif
# ifdef P_SEP_BY_SPACE
case P_SEP_BY_SPACE :
# endif
# ifdef N_CS_PRECEDES
case N_CS_PRECEDES :
# endif
# ifdef N_SEP_BY_SPACE
case N_SEP_BY_SPACE :
# endif
# ifdef P_SIGN_POSN
case P_SIGN_POSN :
# endif
# ifdef N_SIGN_POSN
case N_SIGN_POSN :
# endif
# ifdef DECIMAL_POINT
case DECIMAL_POINT :
# endif
# ifdef RADIXCHAR
case RADIXCHAR :
# endif
# ifdef THOUSANDS_SEP
case THOUSANDS_SEP :
# endif
# ifdef THOUSEP
case THOUSEP :
# endif
# ifdef GROUPING
case GROUPING :
# endif
# ifdef YESEXPR
case YESEXPR :
# endif
# ifdef NOEXPR
case NOEXPR :
# endif
# ifdef YESSTR
case YESSTR :
# endif
# ifdef NOSTR
case NOSTR :
# endif
# ifdef CODESET
case CODESET :
# endif
break ;
default :
php_error_docref ( NULL TSRMLS_CC , E_WARNING , " Item '%ld' is not valid " , item ) ;
RETURN_FALSE ;
2001-07-04 10:10:30 +00:00
}
2007-12-13 22:29:48 +00:00
/* }}} */
2001-09-04 06:18:11 +00:00
2007-12-13 22:29:48 +00:00
value = nl_langinfo ( item ) ;
2002-10-02 18:13:56 +00:00
if ( value = = NULL ) {
2001-07-04 10:10:30 +00:00
RETURN_FALSE ;
2002-10-02 18:13:56 +00:00
} else {
2001-07-04 10:10:30 +00:00
RETURN_STRING ( value , 1 ) ;
}
}
# endif
2002-05-16 14:41:15 +00:00
/* }}} */
2001-07-04 10:10:30 +00:00
2001-01-17 01:10:50 +00:00
# ifdef HAVE_STRCOLL
/* {{{ proto int strcoll(string str1, string str2)
2001-09-04 10:44:28 +00:00
Compares two strings using the current locale */
2001-01-17 01:10:50 +00:00
PHP_FUNCTION ( strcoll )
{
2008-06-22 19:22:41 +00:00
char * s1 , * s2 ;
int s1len , s2len ;
if ( zend_parse_parameters ( ZEND_NUM_ARGS ( ) TSRMLS_CC , " ss " , & s1 , & s1len , & s2 , & s2len ) = = FAILURE ) {
return ;
2001-01-17 01:10:50 +00:00
}
2008-06-22 19:22:41 +00:00
RETURN_LONG ( strcoll ( ( const char * ) s1 ,
( const char * ) s2 ) ) ;
2001-01-17 01:10:50 +00:00
}
2001-06-05 13:12:10 +00:00
/* }}} */
2001-01-17 01:10:50 +00:00
# endif
2001-08-03 23:09:05 +00:00
/* {{{ php_charmask
* Fills a 256 - byte bytemask with input . You can specify a range like ' a . . z ' ,
* it needs to be incrementing .
2006-01-05 20:49:37 +00:00
* Returns : FAILURE / SUCCESS whether the input was correct ( i . e . no range errors )
2001-08-03 23:09:05 +00:00
*/
2002-07-13 04:13:43 +00:00
static inline int php_charmask ( unsigned char * input , int len , char * mask TSRMLS_DC )
2001-08-03 23:09:05 +00:00
{
unsigned char * end ;
unsigned char c ;
2001-08-05 19:38:49 +00:00
int result = SUCCESS ;
2001-08-03 23:09:05 +00:00
memset ( mask , 0 , 256 ) ;
2002-10-02 17:56:04 +00:00
for ( end = input + len ; input < end ; input + + ) {
2001-08-03 23:09:05 +00:00
c = * input ;
2002-10-02 17:56:04 +00:00
if ( ( input + 3 < end ) & & input [ 1 ] = = ' . ' & & input [ 2 ] = = ' . '
2001-08-05 19:38:49 +00:00
& & input [ 3 ] > = c ) {
memset ( mask + c , 1 , input [ 3 ] - c + 1 ) ;
2001-08-03 23:09:05 +00:00
input + = 3 ;
2002-10-02 17:56:04 +00:00
} else if ( ( input + 1 < end ) & & input [ 0 ] = = ' . ' & & input [ 1 ] = = ' . ' ) {
2001-08-05 19:38:49 +00:00
/* Error, try to be as helpful as possible:
( a range ending / starting with ' . ' won ' t be captured here ) */
2002-10-02 17:56:04 +00:00
if ( end - len > = input ) { /* there was no 'left' char */
2007-09-30 05:40:23 +00:00
php_error_docref ( NULL TSRMLS_CC , E_WARNING , " Invalid '..'-range, no character to the left of '..' " ) ;
2001-08-05 19:38:49 +00:00
result = FAILURE ;
continue ;
}
2002-10-02 17:56:04 +00:00
if ( input + 2 > = end ) { /* there is no 'right' char */
2007-09-30 05:40:23 +00:00
php_error_docref ( NULL TSRMLS_CC , E_WARNING , " Invalid '..'-range, no character to the right of '..' " ) ;
2001-08-05 19:38:49 +00:00
result = FAILURE ;
continue ;
}
if ( input [ - 1 ] > input [ 2 ] ) { /* wrong order */
2007-09-30 05:40:23 +00:00
php_error_docref ( NULL TSRMLS_CC , E_WARNING , " Invalid '..'-range, '..'-range needs to be incrementing " ) ;
2001-08-05 19:38:49 +00:00
result = FAILURE ;
continue ;
}
/* FIXME: better error (a..b..c is the only left possibility?) */
2007-09-30 05:40:23 +00:00
php_error_docref ( NULL TSRMLS_CC , E_WARNING , " Invalid '..'-range " ) ;
2001-08-05 19:38:49 +00:00
result = FAILURE ;
continue ;
} else {
2001-08-03 23:09:05 +00:00
mask [ c ] = 1 ;
2001-08-05 19:38:49 +00:00
}
2001-08-03 23:09:05 +00:00
}
2001-08-05 19:38:49 +00:00
return result ;
2001-08-03 23:09:05 +00:00
}
/* }}} */
2002-07-13 04:13:43 +00:00
/* {{{ php_trim()
* mode 1 : trim left
* mode 2 : trim right
* mode 3 : trim left and right
* what indicates which chars are to be trimmed . NULL - > default ( ' \ t \ n \ r \ v \ 0 ' )
2001-06-05 13:12:10 +00:00
*/
2002-07-13 04:13:43 +00:00
PHPAPI char * php_trim ( char * c , int len , char * what , int what_len , zval * return_value , int mode TSRMLS_DC )
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
{
register int i ;
int trimmed = 0 ;
2001-08-03 23:09:05 +00:00
char mask [ 256 ] ;
if ( what ) {
2002-07-13 04:13:43 +00:00
php_charmask ( what , what_len , mask TSRMLS_CC ) ;
2001-08-03 23:09:05 +00:00
} else {
2001-08-05 20:25:40 +00:00
php_charmask ( " \n \r \t \v \0 " , 6 , mask TSRMLS_CC ) ;
2001-08-03 23:09:05 +00:00
}
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
if ( mode & 1 ) {
for ( i = 0 ; i < len ; i + + ) {
2001-08-03 23:09:05 +00:00
if ( mask [ ( unsigned char ) c [ i ] ] ) {
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
trimmed + + ;
} else {
break ;
}
}
len - = trimmed ;
c + = trimmed ;
}
if ( mode & 2 ) {
for ( i = len - 1 ; i > = 0 ; i - - ) {
2001-08-03 23:09:05 +00:00
if ( mask [ ( unsigned char ) c [ i ] ] ) {
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
len - - ;
} else {
break ;
}
}
}
2002-07-13 04:13:43 +00:00
if ( return_value ) {
RETVAL_STRINGL ( c , len , 1 ) ;
} else {
return estrndup ( c , len ) ;
}
return " " ;
}
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
/* }}} */
2002-07-13 04:13:43 +00:00
/* {{{ php_do_trim
* Base for trim ( ) , rtrim ( ) and ltrim ( ) functions .
*/
static void php_do_trim ( INTERNAL_FUNCTION_PARAMETERS , int mode )
1999-04-17 00:37:12 +00:00
{
2008-06-22 19:22:41 +00:00
char * str ;
char * what = NULL ;
int str_len , what_len = 0 ;
if ( zend_parse_parameters ( ZEND_NUM_ARGS ( ) TSRMLS_CC , " s|s " , & str , & str_len , & what , & what_len ) = = FAILURE ) {
return ;
2001-09-04 06:18:11 +00:00
}
2008-06-22 19:22:41 +00:00
php_trim ( str , str_len , what , what_len , return_value , mode TSRMLS_CC ) ;
1999-04-17 00:37:12 +00:00
}
/* }}} */
2001-09-04 10:44:28 +00:00
/* {{{ proto string trim(string str [, string character_mask])
Strips whitespace from the beginning and end of a string */
1999-06-15 21:51:00 +00:00
PHP_FUNCTION ( trim )
1999-04-17 00:37:12 +00:00
{
2002-07-13 04:13:43 +00:00
php_do_trim ( INTERNAL_FUNCTION_PARAM_PASSTHRU , 3 ) ;
}
/* }}} */
1999-04-17 00:37:12 +00:00
2002-07-13 04:13:43 +00:00
/* {{{ proto string rtrim(string str [, string character_mask])
Removes trailing whitespace */
PHP_FUNCTION ( rtrim )
{
php_do_trim ( INTERNAL_FUNCTION_PARAM_PASSTHRU , 2 ) ;
1999-04-17 00:37:12 +00:00
}
/* }}} */
2001-09-04 10:44:28 +00:00
/* {{{ proto string ltrim(string str [, string character_mask])
Strips whitespace from the beginning of a string */
1999-06-15 21:51:00 +00:00
PHP_FUNCTION ( ltrim )
1999-04-17 00:37:12 +00:00
{
2002-07-13 04:13:43 +00:00
php_do_trim ( INTERNAL_FUNCTION_PARAM_PASSTHRU , 1 ) ;
1999-04-17 00:37:12 +00:00
}
/* }}} */
2003-03-09 00:05:48 +00:00
/* {{{ proto string wordwrap(string str [, int width [, string break [, boolean cut]]])
2001-09-04 10:44:28 +00:00
Wraps buffer to selected number of characters using string break char */
2000-07-22 01:12:24 +00:00
PHP_FUNCTION ( wordwrap )
{
2002-01-05 20:46:43 +00:00
const char * text , * breakchar = " \n " ;
char * newtext ;
2006-08-10 14:40:13 +00:00
int textlen , breakcharlen = 1 , newtextlen , chk ;
size_t alloced ;
2002-01-05 20:46:43 +00:00
long current = 0 , laststart = 0 , lastspace = 0 ;
long linelength = 75 ;
2002-01-04 19:48:08 +00:00
zend_bool docut = 0 ;
2000-07-22 01:12:24 +00:00
2002-01-04 19:48:08 +00:00
if ( zend_parse_parameters ( ZEND_NUM_ARGS ( ) TSRMLS_CC , " s|lsb " , & text , & textlen , & linelength , & breakchar , & breakcharlen , & docut ) = = FAILURE ) {
return ;
2000-07-22 01:12:24 +00:00
}
2004-07-06 22:16:42 +00:00
if ( textlen = = 0 ) {
RETURN_EMPTY_STRING ( ) ;
}
2000-07-22 01:12:24 +00:00
2007-07-22 15:55:16 +00:00
if ( breakcharlen = = 0 ) {
php_error_docref ( NULL TSRMLS_CC , E_WARNING , " Break string cannot be empty " ) ;
RETURN_FALSE ;
}
2002-01-04 19:48:08 +00:00
if ( linelength = = 0 & & docut ) {
2007-09-07 18:23:58 +00:00
php_error_docref ( NULL TSRMLS_CC , E_WARNING , " Can't force cut when width is zero " ) ;
2002-01-04 19:48:08 +00:00
RETURN_FALSE ;
2000-09-11 20:06:24 +00:00
}
2000-07-22 01:12:24 +00:00
/* Special case for a single-character break as it needs no
additional storage space */
2002-01-04 19:48:08 +00:00
if ( breakcharlen = = 1 & & ! docut ) {
newtext = estrndup ( text , textlen ) ;
2001-09-04 06:18:11 +00:00
2002-01-05 20:46:43 +00:00
laststart = lastspace = 0 ;
for ( current = 0 ; current < textlen ; current + + ) {
if ( text [ current ] = = breakchar [ 0 ] ) {
laststart = lastspace = current ;
2002-10-10 18:41:24 +00:00
} else if ( text [ current ] = = ' ' ) {
2002-01-05 20:46:43 +00:00
if ( current - laststart > = linelength ) {
newtext [ current ] = breakchar [ 0 ] ;
2004-05-13 17:44:23 +00:00
laststart = current + 1 ;
2000-07-22 01:12:24 +00:00
}
2002-01-05 20:46:43 +00:00
lastspace = current ;
2002-10-10 18:41:24 +00:00
} else if ( current - laststart > = linelength & & laststart ! = lastspace ) {
2002-01-05 20:46:43 +00:00
newtext [ lastspace ] = breakchar [ 0 ] ;
2006-07-28 12:23:18 +00:00
laststart = lastspace + 1 ;
2000-07-22 01:12:24 +00:00
}
}
2001-09-04 06:18:11 +00:00
2002-01-04 19:48:08 +00:00
RETURN_STRINGL ( newtext , textlen , 0 ) ;
2002-10-10 18:41:24 +00:00
} else {
2002-01-05 20:46:43 +00:00
/* Multiple character line break or forced cut */
if ( linelength > 0 ) {
2002-12-12 13:38:19 +00:00
chk = ( int ) ( textlen / linelength + 1 ) ;
2006-03-13 14:37:10 +00:00
newtext = safe_emalloc ( chk , breakcharlen , textlen + 1 ) ;
2002-12-12 13:38:19 +00:00
alloced = textlen + chk * breakcharlen + 1 ;
2002-10-10 18:41:24 +00:00
} else {
2002-12-12 13:38:19 +00:00
chk = textlen ;
alloced = textlen * ( breakcharlen + 1 ) + 1 ;
2006-03-13 14:37:10 +00:00
newtext = safe_emalloc ( textlen , ( breakcharlen + 1 ) , 1 ) ;
2002-01-05 20:46:43 +00:00
}
2002-12-12 13:38:19 +00:00
2002-01-05 20:46:43 +00:00
/* now keep track of the actual new text length */
newtextlen = 0 ;
laststart = lastspace = 0 ;
for ( current = 0 ; current < textlen ; current + + ) {
2002-12-12 13:38:19 +00:00
if ( chk < = 0 ) {
alloced + = ( int ) ( ( ( textlen - current + 1 ) / linelength + 1 ) * breakcharlen ) + 1 ;
newtext = erealloc ( newtext , alloced ) ;
chk = ( int ) ( ( textlen - current ) / linelength ) + 1 ;
}
2002-01-05 20:46:43 +00:00
/* when we hit an existing break, copy to new buffer, and
* fix up laststart and lastspace */
if ( text [ current ] = = breakchar [ 0 ]
& & current + breakcharlen < textlen
& & ! strncmp ( text + current , breakchar , breakcharlen ) ) {
memcpy ( newtext + newtextlen , text + laststart , current - laststart + breakcharlen ) ;
newtextlen + = current - laststart + breakcharlen ;
current + = breakcharlen - 1 ;
laststart = lastspace = current + 1 ;
2002-12-12 13:38:19 +00:00
chk - - ;
2000-07-22 01:12:24 +00:00
}
2002-01-05 20:46:43 +00:00
/* if it is a space, check if it is at the line boundary,
* copy and insert a break , or just keep track of it */
else if ( text [ current ] = = ' ' ) {
if ( current - laststart > = linelength ) {
memcpy ( newtext + newtextlen , text + laststart , current - laststart ) ;
newtextlen + = current - laststart ;
memcpy ( newtext + newtextlen , breakchar , breakcharlen ) ;
newtextlen + = breakcharlen ;
laststart = current + 1 ;
2002-12-12 13:38:19 +00:00
chk - - ;
2000-07-22 01:12:24 +00:00
}
2002-01-05 20:46:43 +00:00
lastspace = current ;
2000-07-22 01:12:24 +00:00
}
2002-01-05 20:46:43 +00:00
/* if we are cutting, and we've accumulated enough
2002-01-05 23:49:58 +00:00
* characters , and we haven ' t see a space for this line ,
* copy and insert a break . */
else if ( current - laststart > = linelength
& & docut & & laststart > = lastspace ) {
2002-01-05 20:46:43 +00:00
memcpy ( newtext + newtextlen , text + laststart , current - laststart ) ;
newtextlen + = current - laststart ;
memcpy ( newtext + newtextlen , breakchar , breakcharlen ) ;
newtextlen + = breakcharlen ;
laststart = lastspace = current ;
2002-12-12 13:38:19 +00:00
chk - - ;
2002-01-05 20:46:43 +00:00
}
/* if the current word puts us over the linelength, copy
* back up until the last space , insert a break , and move
* up the laststart */
else if ( current - laststart > = linelength
& & laststart < lastspace ) {
memcpy ( newtext + newtextlen , text + laststart , lastspace - laststart ) ;
newtextlen + = lastspace - laststart ;
memcpy ( newtext + newtextlen , breakchar , breakcharlen ) ;
newtextlen + = breakcharlen ;
laststart = lastspace = lastspace + 1 ;
2002-12-12 13:38:19 +00:00
chk - - ;
2000-07-22 01:12:24 +00:00
}
}
2002-01-05 20:46:43 +00:00
/* copy over any stragglers */
if ( laststart ! = current ) {
memcpy ( newtext + newtextlen , text + laststart , current - laststart ) ;
newtextlen + = current - laststart ;
2000-07-22 01:12:24 +00:00
}
2002-01-05 20:46:43 +00:00
newtext [ newtextlen ] = ' \0 ' ;
2002-09-05 14:00:28 +00:00
/* free unused memory */
newtext = erealloc ( newtext , newtextlen + 1 ) ;
2002-01-05 20:46:43 +00:00
RETURN_STRINGL ( newtext , newtextlen , 0 ) ;
2000-07-22 01:12:24 +00:00
}
}
/* }}} */
2001-06-05 13:12:10 +00:00
/* {{{ php_explode
*/
2000-05-23 05:04:28 +00:00
PHPAPI void php_explode ( zval * delim , zval * str , zval * return_value , int limit )
1999-04-17 00:37:12 +00:00
{
1999-12-06 18:29:22 +00:00
char * p1 , * p2 , * endp ;
1999-04-17 00:37:12 +00:00
2001-09-04 06:18:11 +00:00
endp = Z_STRVAL_P ( str ) + Z_STRLEN_P ( str ) ;
1999-12-06 18:29:22 +00:00
2001-09-04 06:18:11 +00:00
p1 = Z_STRVAL_P ( str ) ;
p2 = php_memnstr ( Z_STRVAL_P ( str ) , Z_STRVAL_P ( delim ) , Z_STRLEN_P ( delim ) , endp ) ;
1999-12-06 18:29:22 +00:00
1999-04-17 00:37:12 +00:00
if ( p2 = = NULL ) {
2001-09-04 06:18:11 +00:00
add_next_index_stringl ( return_value , p1 , Z_STRLEN_P ( str ) , 1 ) ;
1999-12-07 08:14:00 +00:00
} else {
do {
2001-09-04 06:18:11 +00:00
add_next_index_stringl ( return_value , p1 , p2 - p1 , 1 ) ;
p1 = p2 + Z_STRLEN_P ( delim ) ;
} while ( ( p2 = php_memnstr ( p1 , Z_STRVAL_P ( delim ) , Z_STRLEN_P ( delim ) , endp ) ) ! = NULL & &
2000-05-23 12:38:12 +00:00
( limit = = - 1 | | - - limit > 1 ) ) ;
1999-12-07 08:14:00 +00:00
2000-05-23 12:38:12 +00:00
if ( p1 < = endp )
add_next_index_stringl ( return_value , p1 , endp - p1 , 1 ) ;
1999-04-17 00:37:12 +00:00
}
}
2001-06-05 13:12:10 +00:00
/* }}} */
1999-04-17 00:37:12 +00:00
2004-07-18 11:34:28 +00:00
/* {{{ php_explode_negative_limit
*/
PHPAPI void php_explode_negative_limit ( zval * delim , zval * str , zval * return_value , int limit )
{
# define EXPLODE_ALLOC_STEP 50
char * p1 , * p2 , * endp ;
int allocated = EXPLODE_ALLOC_STEP , found = 0 , i = 0 , to_return = 0 ;
char * * positions = safe_emalloc ( allocated , sizeof ( char * ) , 0 ) ;
endp = Z_STRVAL_P ( str ) + Z_STRLEN_P ( str ) ;
p1 = Z_STRVAL_P ( str ) ;
p2 = php_memnstr ( Z_STRVAL_P ( str ) , Z_STRVAL_P ( delim ) , Z_STRLEN_P ( delim ) , endp ) ;
if ( p2 = = NULL ) {
/*
do nothing since limit < = - 1 , thus if only one chunk - 1 + ( limit ) < = 0
by doing nothing we return empty array
*/
} else {
positions [ found + + ] = p1 ;
do {
if ( found > = allocated ) {
allocated = found + EXPLODE_ALLOC_STEP ; /* make sure we have enough memory */
positions = erealloc ( positions , allocated * sizeof ( char * ) ) ;
}
positions [ found + + ] = p1 = p2 + Z_STRLEN_P ( delim ) ;
} while ( ( p2 = php_memnstr ( p1 , Z_STRVAL_P ( delim ) , Z_STRLEN_P ( delim ) , endp ) ) ! = NULL ) ;
to_return = limit + found ;
/* limit is at least -1 therefore no need of bounds checking : i will be always less than found */
for ( i = 0 ; i < to_return ; i + + ) { /* this checks also for to_return > 0 */
add_next_index_stringl ( return_value , positions [ i ] ,
( positions [ i + 1 ] - Z_STRLEN_P ( delim ) ) - positions [ i ] ,
1
) ;
}
}
efree ( positions ) ;
# undef EXPLODE_ALLOC_STEP
}
/* }}} */
2000-05-23 05:04:28 +00:00
/* {{{ proto array explode(string separator, string str [, int limit])
2004-07-18 11:34:28 +00:00
Splits a string on string separator and return array of components . If limit is positive only limit number of components is returned . If limit is negative all components except the last abs ( limit ) are returned . */
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
PHP_FUNCTION ( explode )
1999-04-17 00:37:12 +00:00
{
2008-07-01 11:27:05 +00:00
zval * * str , * * delim ;
2008-06-30 10:10:44 +00:00
long limit = - 1 ;
2001-09-04 06:18:11 +00:00
int argc = ZEND_NUM_ARGS ( ) ;
2008-06-22 19:22:41 +00:00
if ( zend_parse_parameters ( ZEND_NUM_ARGS ( ) TSRMLS_CC , " ZZ|l " , & delim , & str , & limit ) = = FAILURE ) {
return ;
2000-05-20 05:07:53 +00:00
}
2008-06-22 19:22:41 +00:00
1999-09-25 11:55:42 +00:00
convert_to_string_ex ( str ) ;
convert_to_string_ex ( delim ) ;
1999-04-17 00:37:12 +00:00
2001-09-04 06:18:11 +00:00
if ( ! Z_STRLEN_PP ( delim ) ) {
2007-09-30 05:40:23 +00:00
php_error_docref ( NULL TSRMLS_CC , E_WARNING , " Empty delimiter " ) ;
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
RETURN_FALSE ;
}
1999-12-06 18:29:22 +00:00
2002-12-05 22:28:02 +00:00
array_init ( return_value ) ;
1999-12-06 18:29:22 +00:00
2004-07-18 11:34:28 +00:00
if ( ! Z_STRLEN_PP ( str ) ) {
add_next_index_stringl ( return_value , " " , sizeof ( " " ) - 1 , 1 ) ;
return ;
}
2001-09-04 06:18:11 +00:00
if ( limit = = 0 | | limit = = 1 ) {
add_index_stringl ( return_value , 0 , Z_STRVAL_PP ( str ) , Z_STRLEN_PP ( str ) , 1 ) ;
2004-07-18 11:34:28 +00:00
} else if ( limit < 0 & & argc = = 3 ) {
php_explode_negative_limit ( * delim , * str , return_value , limit ) ;
2000-05-23 05:04:28 +00:00
} else {
php_explode ( * delim , * str , return_value , limit ) ;
}
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
}
/* }}} */
/* {{{ proto string join(array src, string glue)
An alias for implode */
/* }}} */
2001-06-05 13:12:10 +00:00
/* {{{ php_implode
*/
2006-08-28 23:33:37 +00:00
PHPAPI void php_implode ( zval * delim , zval * arr , zval * return_value TSRMLS_DC )
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
{
2002-10-04 20:44:19 +00:00
zval * * tmp ;
HashPosition pos ;
smart_str implstr = { 0 } ;
int numelems , i = 0 ;
2006-08-22 19:55:56 +00:00
zval tmp_val ;
int str_len ;
2002-10-04 20:44:19 +00:00
numelems = zend_hash_num_elements ( Z_ARRVAL_P ( arr ) ) ;
1999-04-17 00:37:12 +00:00
2003-02-08 15:26:17 +00:00
if ( numelems = = 0 ) {
2002-10-06 11:28:11 +00:00
RETURN_EMPTY_STRING ( ) ;
}
2001-09-04 06:18:11 +00:00
zend_hash_internal_pointer_reset_ex ( Z_ARRVAL_P ( arr ) , & pos ) ;
2003-02-08 15:26:17 +00:00
while ( zend_hash_get_current_data_ex ( Z_ARRVAL_P ( arr ) , ( void * * ) & tmp , & pos ) = = SUCCESS ) {
2006-08-27 19:06:09 +00:00
switch ( ( * tmp ) - > type ) {
case IS_STRING :
smart_str_appendl ( & implstr , Z_STRVAL_PP ( tmp ) , Z_STRLEN_PP ( tmp ) ) ;
break ;
case IS_LONG : {
char stmp [ MAX_LENGTH_OF_LONG + 1 ] ;
2007-02-27 03:28:17 +00:00
str_len = slprintf ( stmp , sizeof ( stmp ) , " %ld " , Z_LVAL_PP ( tmp ) ) ;
2006-08-27 19:06:09 +00:00
smart_str_appendl ( & implstr , stmp , str_len ) ;
}
break ;
case IS_BOOL :
if ( Z_LVAL_PP ( tmp ) = = 1 ) {
smart_str_appendl ( & implstr , " 1 " , sizeof ( " 1 " ) - 1 ) ;
}
break ;
case IS_NULL :
break ;
case IS_DOUBLE : {
2006-08-29 19:50:04 +00:00
char * stmp ;
str_len = spprintf ( & stmp , 0 , " %.*G " , ( int ) EG ( precision ) , Z_DVAL_PP ( tmp ) ) ;
2006-08-27 19:06:09 +00:00
smart_str_appendl ( & implstr , stmp , str_len ) ;
2006-08-29 19:50:04 +00:00
efree ( stmp ) ;
2006-08-27 19:06:09 +00:00
}
break ;
case IS_OBJECT : {
2006-06-11 21:55:49 +00:00
int copy ;
zval expr ;
zend_make_printable_zval ( * tmp , & expr , & copy ) ;
smart_str_appendl ( & implstr , Z_STRVAL ( expr ) , Z_STRLEN ( expr ) ) ;
if ( copy ) {
zval_dtor ( & expr ) ;
}
2006-08-27 19:06:09 +00:00
}
break ;
default :
2006-08-22 19:55:56 +00:00
tmp_val = * * tmp ;
zval_copy_ctor ( & tmp_val ) ;
convert_to_string ( & tmp_val ) ;
2006-08-27 19:06:09 +00:00
smart_str_appendl ( & implstr , Z_STRVAL ( tmp_val ) , Z_STRLEN ( tmp_val ) ) ;
zval_dtor ( & tmp_val ) ;
break ;
2006-08-22 19:55:56 +00:00
}
2002-10-04 20:44:19 +00:00
if ( + + i ! = numelems ) {
smart_str_appendl ( & implstr , Z_STRVAL_P ( delim ) , Z_STRLEN_P ( delim ) ) ;
1999-04-17 00:37:12 +00:00
}
2001-09-04 06:18:11 +00:00
zend_hash_move_forward_ex ( Z_ARRVAL_P ( arr ) , & pos ) ;
1999-04-17 00:37:12 +00:00
}
2002-10-04 20:44:19 +00:00
smart_str_0 ( & implstr ) ;
2006-11-06 17:21:05 +00:00
if ( implstr . len ) {
RETURN_STRINGL ( implstr . c , implstr . len , 0 ) ;
} else {
smart_str_free ( & implstr ) ;
RETURN_EMPTY_STRING ( ) ;
}
1999-04-17 00:37:12 +00:00
}
2001-06-05 13:12:10 +00:00
/* }}} */
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
2002-10-04 16:53:14 +00:00
/* {{{ proto string implode([string glue,] array pieces)
2001-09-04 10:44:28 +00:00
Joins array elements placing glue string between items and return one string */
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
PHP_FUNCTION ( implode )
{
2002-10-04 16:53:14 +00:00
zval * * arg1 = NULL , * * arg2 = NULL , * delim , * arr ;
2006-06-11 21:55:49 +00:00
HashPosition pos ;
2002-10-04 16:53:14 +00:00
2008-06-22 19:22:41 +00:00
if ( zend_parse_parameters ( ZEND_NUM_ARGS ( ) TSRMLS_CC , " Z|Z " , & arg1 , & arg2 ) = = FAILURE ) {
return ;
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
}
2008-06-22 19:22:41 +00:00
if ( arg2 = = NULL ) {
2002-10-04 16:53:14 +00:00
if ( Z_TYPE_PP ( arg1 ) ! = IS_ARRAY ) {
2007-10-01 12:05:41 +00:00
php_error_docref ( NULL TSRMLS_CC , E_WARNING , " Argument must be an array " ) ;
2002-10-04 16:53:14 +00:00
return ;
}
2002-10-06 18:39:03 +00:00
MAKE_STD_ZVAL ( delim ) ;
# define _IMPL_EMPTY ""
ZVAL_STRINGL ( delim , _IMPL_EMPTY , sizeof ( _IMPL_EMPTY ) - 1 , 0 ) ;
1999-10-15 14:45:54 +00:00
SEPARATE_ZVAL ( arg1 ) ;
1999-09-25 11:55:42 +00:00
arr = * arg1 ;
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
} else {
2002-10-04 16:53:14 +00:00
if ( Z_TYPE_PP ( arg1 ) = = IS_ARRAY ) {
arr = * arg1 ;
convert_to_string_ex ( arg2 ) ;
delim = * arg2 ;
} else if ( Z_TYPE_PP ( arg2 ) = = IS_ARRAY ) {
arr = * arg2 ;
convert_to_string_ex ( arg1 ) ;
delim = * arg1 ;
} else {
2007-10-01 12:05:41 +00:00
php_error_docref ( NULL TSRMLS_CC , E_WARNING , " Invalid arguments passed " ) ;
2002-10-04 16:53:14 +00:00
return ;
}
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
}
2001-09-04 06:18:11 +00:00
2006-06-11 21:55:49 +00:00
pos = Z_ARRVAL_P ( arr ) - > pInternalPointer ;
2006-08-28 23:33:37 +00:00
php_implode ( delim , arr , return_value TSRMLS_CC ) ;
2002-11-05 13:52:11 +00:00
2006-06-11 21:55:49 +00:00
Z_ARRVAL_P ( arr ) - > pInternalPointer = pos ;
2008-06-22 19:22:41 +00:00
if ( arg2 = = NULL ) {
2002-11-05 13:52:11 +00:00
FREE_ZVAL ( delim ) ;
}
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
}
1999-04-17 00:37:12 +00:00
/* }}} */
2001-08-03 23:09:05 +00:00
# define STRTOK_TABLE(p) BG(strtok_table)[(unsigned char) *p]
2002-09-11 14:51:09 +00:00
/* {{{ proto string strtok([string str,] string token)
1999-04-17 00:37:12 +00:00
Tokenize a string */
1999-06-15 21:51:00 +00:00
PHP_FUNCTION ( strtok )
2008-08-16 21:32:41 +00:00
{
char * str , * tok = NULL ;
int str_len , tok_len = 0 ;
zval * zv ;
2001-08-03 23:09:05 +00:00
char * token ;
char * token_end ;
char * p ;
char * pe ;
2001-11-02 19:19:24 +00:00
int skipped = 0 ;
1999-04-17 00:37:12 +00:00
2008-08-16 21:32:41 +00:00
if ( zend_parse_parameters ( ZEND_NUM_ARGS ( ) TSRMLS_CC , " s|s " , & str , & str_len , & tok , & tok_len ) = = FAILURE ) {
return ;
2003-02-08 15:26:17 +00:00
}
2008-08-16 21:32:41 +00:00
if ( ZEND_NUM_ARGS ( ) = = 1 ) {
tok = str ;
tok_len = str_len ;
} else {
if ( BG ( strtok_zval ) ) {
zval_ptr_dtor ( & BG ( strtok_zval ) ) ;
}
MAKE_STD_ZVAL ( zv ) ;
ZVAL_STRINGL ( zv , str , str_len , 1 ) ;
BG ( strtok_zval ) = zv ;
BG ( strtok_last ) = BG ( strtok_string ) = Z_STRVAL_P ( zv ) ;
BG ( strtok_len ) = str_len ;
2001-08-03 08:49:19 +00:00
}
2001-08-03 23:09:05 +00:00
p = BG ( strtok_last ) ; /* Where we start to search */
pe = BG ( strtok_string ) + BG ( strtok_len ) ;
2001-08-03 08:49:19 +00:00
2003-02-08 15:26:17 +00:00
if ( ! p | | p > = pe ) {
2001-08-03 23:09:05 +00:00
RETURN_FALSE ;
2003-02-08 15:26:17 +00:00
}
2001-08-03 23:09:05 +00:00
2008-08-16 21:32:41 +00:00
token = tok ;
token_end = token + tok_len ;
2001-08-03 23:09:05 +00:00
2003-02-08 15:26:17 +00:00
while ( token < token_end ) {
2001-08-03 23:09:05 +00:00
STRTOK_TABLE ( token + + ) = 1 ;
2003-02-08 15:26:17 +00:00
}
2001-08-03 23:09:05 +00:00
/* Skip leading delimiters */
2002-10-10 18:41:24 +00:00
while ( STRTOK_TABLE ( p ) ) {
2001-08-03 23:09:05 +00:00
if ( + + p > = pe ) {
/* no other chars left */
BG ( strtok_last ) = NULL ;
RETVAL_FALSE ;
goto restore ;
2001-08-03 22:42:02 +00:00
}
2001-11-02 19:19:24 +00:00
skipped + + ;
}
2001-08-03 23:09:05 +00:00
/* We know at this place that *p is no delimiter, so skip it */
2003-02-08 15:26:17 +00:00
while ( + + p < pe ) {
if ( STRTOK_TABLE ( p ) ) {
2001-11-02 19:31:57 +00:00
goto return_token ;
2003-02-08 15:26:17 +00:00
}
}
2001-08-03 23:09:05 +00:00
if ( p - BG ( strtok_last ) ) {
return_token :
2001-11-02 19:31:57 +00:00
RETVAL_STRINGL ( BG ( strtok_last ) + skipped , ( p - BG ( strtok_last ) ) - skipped , 1 ) ;
2001-08-03 23:09:05 +00:00
BG ( strtok_last ) = p + 1 ;
1999-04-17 00:37:12 +00:00
} else {
RETVAL_FALSE ;
2001-08-03 23:09:05 +00:00
BG ( strtok_last ) = NULL ;
1999-04-17 00:37:12 +00:00
}
2001-08-03 23:09:05 +00:00
2003-02-08 15:26:17 +00:00
/* Restore table -- usually faster then memset'ing the table on every invocation */
2001-08-03 23:09:05 +00:00
restore :
2008-08-16 21:32:41 +00:00
token = tok ;
2001-08-03 23:09:05 +00:00
2003-02-08 15:26:17 +00:00
while ( token < token_end ) {
2001-08-03 23:09:05 +00:00
STRTOK_TABLE ( token + + ) = 0 ;
2003-02-08 15:26:17 +00:00
}
1999-04-17 00:37:12 +00:00
}
/* }}} */
2001-06-05 13:12:10 +00:00
/* {{{ php_strtoupper
*/
1999-12-09 23:45:30 +00:00
PHPAPI char * php_strtoupper ( char * s , size_t len )
1999-04-17 00:37:12 +00:00
{
2002-10-25 20:09:53 +00:00
unsigned char * c , * e ;
2002-08-25 19:08:07 +00:00
1999-04-17 00:37:12 +00:00
c = s ;
2002-08-25 19:08:07 +00:00
e = c + len ;
2002-10-02 17:56:04 +00:00
while ( c < e ) {
2002-08-25 19:08:07 +00:00
* c = toupper ( * c ) ;
c + + ;
1999-04-17 00:37:12 +00:00
}
2001-09-04 06:18:11 +00:00
return s ;
1999-04-17 00:37:12 +00:00
}
2001-06-05 13:12:10 +00:00
/* }}} */
1999-04-17 00:37:12 +00:00
/* {{{ proto string strtoupper(string str)
2001-09-04 10:44:28 +00:00
Makes a string uppercase */
1999-06-15 21:51:00 +00:00
PHP_FUNCTION ( strtoupper )
1999-04-17 00:37:12 +00:00
{
2008-06-22 19:22:41 +00:00
char * arg ;
int arglen ;
1999-04-17 00:37:12 +00:00
2008-06-22 19:22:41 +00:00
if ( zend_parse_parameters ( ZEND_NUM_ARGS ( ) TSRMLS_CC , " s " , & arg , & arglen ) = = FAILURE ) {
return ;
1999-04-17 00:37:12 +00:00
}
2008-06-24 06:07:08 +00:00
arg = estrndup ( arg , arglen ) ;
php_strtoupper ( arg , arglen ) ;
RETURN_STRINGL ( arg , arglen , 0 ) ;
1999-04-17 00:37:12 +00:00
}
/* }}} */
2001-06-05 13:12:10 +00:00
/* {{{ php_strtolower
*/
1999-12-09 23:45:30 +00:00
PHPAPI char * php_strtolower ( char * s , size_t len )
1999-04-17 00:37:12 +00:00
{
2002-10-25 20:09:53 +00:00
unsigned char * c , * e ;
2002-08-25 19:08:07 +00:00
1999-04-17 00:37:12 +00:00
c = s ;
2002-08-25 19:08:07 +00:00
e = c + len ;
2002-10-02 17:56:04 +00:00
while ( c < e ) {
2002-08-25 19:08:07 +00:00
* c = tolower ( * c ) ;
c + + ;
1999-04-17 00:37:12 +00:00
}
2001-09-04 06:18:11 +00:00
return s ;
1999-04-17 00:37:12 +00:00
}
2001-06-05 13:12:10 +00:00
/* }}} */
1999-04-17 00:37:12 +00:00
/* {{{ proto string strtolower(string str)
2001-09-04 10:44:28 +00:00
Makes a string lowercase */
1999-06-15 21:51:00 +00:00
PHP_FUNCTION ( strtolower )
1999-04-17 00:37:12 +00:00
{
2008-06-22 19:22:41 +00:00
char * str ;
int arglen ;
1999-04-17 00:37:12 +00:00
2008-06-22 19:22:41 +00:00
if ( zend_parse_parameters ( ZEND_NUM_ARGS ( ) TSRMLS_CC , " s " , & str , & arglen ) = = FAILURE ) {
return ;
1999-04-17 00:37:12 +00:00
}
2008-06-24 06:07:08 +00:00
str = estrndup ( str , arglen ) ;
2008-06-22 19:22:41 +00:00
php_strtolower ( str , arglen ) ;
2008-06-24 06:07:08 +00:00
RETURN_STRINGL ( str , arglen , 0 ) ;
1999-04-17 00:37:12 +00:00
}
/* }}} */
2001-06-05 13:12:10 +00:00
/* {{{ php_basename
*/
2003-12-10 21:23:35 +00:00
PHPAPI void php_basename ( char * s , size_t len , char * suffix , size_t sufflen , char * * p_ret , size_t * p_len TSRMLS_DC )
1999-04-17 00:37:12 +00:00
{
2003-12-10 07:15:28 +00:00
char * ret = NULL , * c , * comp , * cend ;
size_t inc_len , cnt ;
int state ;
c = comp = cend = s ;
cnt = len ;
state = 0 ;
while ( cnt > 0 ) {
inc_len = ( * c = = ' \0 ' ? 1 : php_mblen ( c , cnt ) ) ;
switch ( inc_len ) {
case - 2 :
case - 1 :
inc_len = 1 ;
php_mblen ( NULL , 0 ) ;
break ;
case 0 :
goto quit_loop ;
case 1 :
2005-03-01 14:59:37 +00:00
# if defined(PHP_WIN32) || defined(NETWARE)
2003-12-10 07:15:28 +00:00
if ( * c = = ' / ' | | * c = = ' \\ ' ) {
# else
if ( * c = = ' / ' ) {
1999-04-17 00:37:12 +00:00
# endif
2003-12-10 07:15:28 +00:00
if ( state = = 1 ) {
state = 0 ;
cend = c ;
}
} else {
if ( state = = 0 ) {
comp = c ;
state = 1 ;
}
}
2006-07-17 20:36:47 +00:00
break ;
2003-12-10 07:15:28 +00:00
default :
2006-07-17 20:36:47 +00:00
if ( state = = 0 ) {
comp = c ;
state = 1 ;
}
2003-12-10 07:15:28 +00:00
break ;
}
c + = inc_len ;
cnt - = inc_len ;
2003-02-08 15:26:17 +00:00
}
2003-12-10 07:15:28 +00:00
quit_loop :
if ( state = = 1 ) {
cend = c ;
2003-02-08 15:26:17 +00:00
}
2006-02-26 10:57:00 +00:00
if ( suffix ! = NULL & & sufflen < ( uint ) ( cend - comp ) & &
2003-12-10 07:15:28 +00:00
memcmp ( cend - sufflen , suffix , sufflen ) = = 0 ) {
cend - = sufflen ;
2003-02-08 15:26:17 +00:00
}
2003-05-05 13:46:14 +00:00
2003-12-10 07:15:28 +00:00
len = cend - comp ;
2003-05-05 13:46:14 +00:00
2003-12-10 07:15:28 +00:00
if ( p_ret ) {
2006-12-20 23:30:30 +00:00
ret = emalloc ( len + 1 ) ;
memcpy ( ret , comp , len ) ;
ret [ len ] = ' \0 ' ;
2003-12-10 07:15:28 +00:00
* p_ret = ret ;
}
if ( p_len ) {
* p_len = len ;
}
2000-05-23 20:16:14 +00:00
}
2001-06-05 13:12:10 +00:00
/* }}} */
2000-05-23 20:16:14 +00:00
2001-06-23 00:51:03 +00:00
/* {{{ proto string basename(string path [, string suffix])
2001-09-04 10:44:28 +00:00
Returns the filename component of the path */
2000-05-23 20:16:14 +00:00
PHP_FUNCTION ( basename )
{
2003-05-05 13:46:14 +00:00
char * string , * suffix = NULL , * ret ;
2003-12-10 07:15:28 +00:00
int string_len , suffix_len = 0 ;
size_t ret_len ;
2000-05-23 20:16:14 +00:00
2001-12-01 15:45:55 +00:00
if ( zend_parse_parameters ( ZEND_NUM_ARGS ( ) TSRMLS_CC , " s|s " , & string , & string_len , & suffix , & suffix_len ) = = FAILURE ) {
return ;
2000-05-23 20:16:14 +00:00
}
2001-06-23 00:51:03 +00:00
2003-12-10 21:23:35 +00:00
php_basename ( string , string_len , suffix , suffix_len , & ret , & ret_len TSRMLS_CC ) ;
2003-12-10 07:15:28 +00:00
RETURN_STRINGL ( ret , ( int ) ret_len , 0 ) ;
1999-04-17 00:37:12 +00:00
}
/* }}} */
2001-06-05 13:12:10 +00:00
/* {{{ php_dirname
2002-05-16 16:04:45 +00:00
Returns directory name component of path */
2003-04-12 21:53:46 +00:00
PHPAPI size_t php_dirname ( char * path , size_t len )
2000-10-03 14:43:04 +00:00
{
2008-02-12 00:21:15 +00:00
return zend_dirname ( path , len ) ;
1999-04-17 00:37:12 +00:00
}
2001-06-05 13:12:10 +00:00
/* }}} */
1999-04-17 00:37:12 +00:00
/* {{{ proto string dirname(string path)
2001-09-04 10:44:28 +00:00
Returns the directory name component of the path */
1999-06-15 21:51:00 +00:00
PHP_FUNCTION ( dirname )
1999-04-17 00:37:12 +00:00
{
2008-06-22 19:22:41 +00:00
char * str ;
1999-04-17 00:37:12 +00:00
char * ret ;
2008-06-22 19:22:41 +00:00
int str_len ;
2003-04-12 21:53:46 +00:00
size_t ret_len ;
2008-06-22 19:22:41 +00:00
if ( zend_parse_parameters ( ZEND_NUM_ARGS ( ) TSRMLS_CC , " s " , & str , & str_len ) = = FAILURE ) {
return ;
1999-04-17 00:37:12 +00:00
}
2008-06-22 19:22:41 +00:00
ret = estrndup ( str , str_len ) ;
ret_len = php_dirname ( ret , str_len ) ;
2001-09-04 06:18:11 +00:00
2003-04-12 21:53:46 +00:00
RETURN_STRINGL ( ret , ret_len , 0 ) ;
1999-04-17 00:37:12 +00:00
}
/* }}} */
2006-06-26 18:48:56 +00:00
/* {{{ proto array pathinfo(string path[, int options])
2001-09-04 10:44:28 +00:00
Returns information about a certain string */
2000-09-10 05:59:16 +00:00
PHP_FUNCTION ( pathinfo )
{
2002-01-22 03:35:23 +00:00
zval * tmp ;
2002-10-24 19:15:40 +00:00
char * path , * ret = NULL ;
2006-07-17 06:45:08 +00:00
int path_len , have_basename ;
2003-12-10 07:15:28 +00:00
size_t ret_len ;
2003-03-06 23:07:28 +00:00
long opt = PHP_PATHINFO_ALL ;
2002-01-22 03:35:23 +00:00
if ( zend_parse_parameters ( ZEND_NUM_ARGS ( ) TSRMLS_CC , " s|l " , & path , & path_len , & opt ) = = FAILURE ) {
return ;
2000-09-10 05:59:16 +00:00
}
2001-09-04 06:18:11 +00:00
2006-07-17 06:45:08 +00:00
have_basename = ( ( opt & PHP_PATHINFO_BASENAME ) = = PHP_PATHINFO_BASENAME ) ;
2000-09-10 05:59:16 +00:00
MAKE_STD_ZVAL ( tmp ) ;
array_init ( tmp ) ;
2002-01-22 03:35:23 +00:00
if ( ( opt & PHP_PATHINFO_DIRNAME ) = = PHP_PATHINFO_DIRNAME ) {
ret = estrndup ( path , path_len ) ;
php_dirname ( ret , path_len ) ;
2003-02-08 15:26:17 +00:00
if ( * ret ) {
2000-09-11 13:52:22 +00:00
add_assoc_string ( tmp , " dirname " , ret , 1 ) ;
2003-02-08 15:26:17 +00:00
}
2000-09-10 05:59:16 +00:00
efree ( ret ) ;
2006-07-17 06:45:08 +00:00
ret = NULL ;
2000-09-10 05:59:16 +00:00
}
2006-07-17 06:45:08 +00:00
if ( have_basename ) {
2003-12-10 21:23:35 +00:00
php_basename ( path , path_len , NULL , 0 , & ret , & ret_len TSRMLS_CC ) ;
2003-05-05 13:46:14 +00:00
add_assoc_stringl ( tmp , " basename " , ret , ret_len , 0 ) ;
2006-07-17 06:45:08 +00:00
}
2000-09-11 13:52:22 +00:00
2002-01-22 03:35:23 +00:00
if ( ( opt & PHP_PATHINFO_EXTENSION ) = = PHP_PATHINFO_EXTENSION ) {
2000-09-10 05:59:16 +00:00
char * p ;
int idx ;
2002-01-22 03:35:23 +00:00
if ( ! have_basename ) {
2003-12-10 21:23:35 +00:00
php_basename ( path , path_len , NULL , 0 , & ret , & ret_len TSRMLS_CC ) ;
2002-01-22 03:35:23 +00:00
}
2006-08-08 10:22:25 +00:00
p = zend_memrchr ( ret , ' . ' , ret_len ) ;
2000-09-10 05:59:16 +00:00
2001-04-13 18:22:13 +00:00
if ( p ) {
2002-01-22 03:35:23 +00:00
idx = p - ret ;
add_assoc_stringl ( tmp , " extension " , ret + idx + 1 , ret_len - idx - 1 , 1 ) ;
}
2000-09-10 05:59:16 +00:00
}
2006-07-16 10:37:24 +00:00
if ( ( opt & PHP_PATHINFO_FILENAME ) = = PHP_PATHINFO_FILENAME ) {
char * p ;
int idx ;
/* Have we alrady looked up the basename? */
2006-07-17 06:45:08 +00:00
if ( ! have_basename & & ! ret ) {
2006-07-16 10:37:24 +00:00
php_basename ( path , path_len , NULL , 0 , & ret , & ret_len TSRMLS_CC ) ;
}
2006-08-08 10:22:25 +00:00
p = zend_memrchr ( ret , ' . ' , ret_len ) ;
2006-07-16 10:37:24 +00:00
idx = p ? ( p - ret ) : ret_len ;
add_assoc_stringl ( tmp , " filename " , ret , idx , 1 ) ;
2006-07-17 06:45:08 +00:00
}
2006-07-16 10:37:24 +00:00
2006-07-17 06:45:08 +00:00
if ( ! have_basename & & ret ) {
efree ( ret ) ;
2006-07-16 10:37:24 +00:00
}
2001-09-04 06:18:11 +00:00
2002-01-22 03:35:23 +00:00
if ( opt = = PHP_PATHINFO_ALL ) {
2005-03-10 23:52:43 +00:00
RETURN_ZVAL ( tmp , 0 , 1 ) ;
2002-01-22 03:35:23 +00:00
} else {
zval * * element ;
if ( zend_hash_get_current_data ( Z_ARRVAL_P ( tmp ) , ( void * * ) & element ) = = SUCCESS ) {
2005-03-10 23:42:15 +00:00
RETVAL_ZVAL ( * element , 1 , 0 ) ;
2002-01-22 03:35:23 +00:00
} else {
ZVAL_EMPTY_STRING ( return_value ) ;
}
2000-09-10 05:59:16 +00:00
}
2005-03-10 23:42:15 +00:00
zval_ptr_dtor ( & tmp ) ;
2000-09-10 05:59:16 +00:00
}
/* }}} */
1999-04-17 00:37:12 +00:00
2001-06-05 13:12:10 +00:00
/* {{{ php_stristr
2002-09-11 14:40:52 +00:00
case insensitve strstr */
PHPAPI char * php_stristr ( unsigned char * s , unsigned char * t , size_t s_len , size_t t_len )
1999-04-17 00:37:12 +00:00
{
1999-12-11 19:50:01 +00:00
php_strtolower ( s , s_len ) ;
php_strtolower ( t , t_len ) ;
return php_memnstr ( s , t , t_len , s + s_len ) ;
1999-04-17 00:37:12 +00:00
}
2001-06-05 13:12:10 +00:00
/* }}} */
1999-04-17 00:37:12 +00:00
2001-06-05 13:12:10 +00:00
/* {{{ php_strspn
*/
1999-12-13 23:40:36 +00:00
PHPAPI size_t php_strspn ( char * s1 , char * s2 , char * s1_end , char * s2_end )
{
register const char * p = s1 , * spanp ;
register char c = * p ;
cont :
2003-02-08 15:26:17 +00:00
for ( spanp = s2 ; p ! = s1_end & & spanp ! = s2_end ; ) {
1999-12-13 23:40:36 +00:00
if ( * spanp + + = = c ) {
c = * ( + + p ) ;
goto cont ;
}
2003-02-08 15:26:17 +00:00
}
1999-12-13 23:40:36 +00:00
return ( p - s1 ) ;
}
2001-06-05 13:12:10 +00:00
/* }}} */
1999-12-13 23:40:36 +00:00
2001-06-05 13:12:10 +00:00
/* {{{ php_strcspn
*/
1999-12-13 23:40:36 +00:00
PHPAPI size_t php_strcspn ( char * s1 , char * s2 , char * s1_end , char * s2_end )
{
register const char * p , * spanp ;
register char c = * s1 ;
for ( p = s1 ; ; ) {
spanp = s2 ;
do {
2003-02-08 15:26:17 +00:00
if ( * spanp = = c | | p = = s1_end ) {
2001-09-04 06:18:11 +00:00
return p - s1 ;
2003-02-08 15:26:17 +00:00
}
2006-10-04 11:14:32 +00:00
} while ( spanp + + < ( s2_end - 1 ) ) ;
2001-09-04 06:18:11 +00:00
c = * + + p ;
1999-12-13 23:40:36 +00:00
}
/* NOTREACHED */
}
2001-06-05 13:12:10 +00:00
/* }}} */
1999-12-13 23:40:36 +00:00
2008-02-01 12:28:44 +00:00
/* {{{ proto string stristr(string haystack, string needle[, bool part])
2001-09-04 10:44:28 +00:00
Finds first occurrence of a string within another , case insensitive */
1999-06-15 21:51:00 +00:00
PHP_FUNCTION ( stristr )
1999-04-17 00:37:12 +00:00
{
1999-12-11 19:50:01 +00:00
zval * * haystack , * * needle ;
1999-04-17 00:37:12 +00:00
char * found = NULL ;
2000-03-30 14:34:46 +00:00
int found_offset ;
char * haystack_orig ;
1999-12-11 19:50:01 +00:00
char needle_char [ 2 ] ;
2008-02-01 12:28:44 +00:00
zend_bool part = 0 ;
1999-04-17 00:37:12 +00:00
2008-02-01 12:28:44 +00:00
if ( zend_parse_parameters ( ZEND_NUM_ARGS ( ) TSRMLS_CC , " ZZ|b " , & haystack , & needle , & part ) = = FAILURE ) {
return ;
1999-04-17 00:37:12 +00:00
}
2001-09-06 08:54:54 +00:00
2008-02-03 14:30:25 +00:00
SEPARATE_ZVAL ( haystack ) ;
convert_to_string ( * haystack ) ;
1999-04-17 00:37:12 +00:00
2001-09-04 06:18:11 +00:00
haystack_orig = estrndup ( Z_STRVAL_PP ( haystack ) , Z_STRLEN_PP ( haystack ) ) ;
if ( Z_TYPE_PP ( needle ) = = IS_STRING ) {
if ( ! Z_STRLEN_PP ( needle ) ) {
2007-09-30 05:40:23 +00:00
php_error_docref ( NULL TSRMLS_CC , E_WARNING , " Empty delimiter " ) ;
2002-12-26 20:52:42 +00:00
efree ( haystack_orig ) ;
1999-12-11 19:50:01 +00:00
RETURN_FALSE ;
}
2000-03-22 08:14:00 +00:00
2008-02-03 14:30:25 +00:00
found = php_stristr ( Z_STRVAL_PP ( haystack ) , Z_STRVAL_PP ( needle ) , Z_STRLEN_PP ( haystack ) , Z_STRLEN_PP ( needle ) ) ;
2002-09-11 14:40:52 +00:00
} else {
2008-02-03 14:30:25 +00:00
SEPARATE_ZVAL ( needle ) ;
convert_to_long ( * needle ) ;
2001-09-04 06:18:11 +00:00
needle_char [ 0 ] = ( char ) Z_LVAL_PP ( needle ) ;
needle_char [ 1 ] = 0 ;
2000-03-22 08:14:00 +00:00
2008-02-03 14:30:25 +00:00
found = php_stristr ( Z_STRVAL_PP ( haystack ) , needle_char , Z_STRLEN_PP ( haystack ) , 1 ) ;
1999-04-17 00:37:12 +00:00
}
2002-09-11 14:40:52 +00:00
1999-04-17 00:37:12 +00:00
if ( found ) {
2001-09-04 06:18:11 +00:00
found_offset = found - Z_STRVAL_PP ( haystack ) ;
2008-02-01 12:28:44 +00:00
if ( part ) {
RETVAL_STRINGL ( haystack_orig , found_offset , 1 ) ;
} else {
RETVAL_STRINGL ( haystack_orig + found_offset , Z_STRLEN_PP ( haystack ) - found_offset , 1 ) ;
}
1999-04-17 00:37:12 +00:00
} else {
2001-09-27 00:21:21 +00:00
RETVAL_FALSE ;
1999-04-17 00:37:12 +00:00
}
2001-09-04 06:18:11 +00:00
2000-03-30 14:34:46 +00:00
efree ( haystack_orig ) ;
1999-04-17 00:37:12 +00:00
}
/* }}} */
2008-02-01 12:28:44 +00:00
/* {{{ proto string strstr(string haystack, string needle[, bool part])
2001-09-04 10:44:28 +00:00
Finds first occurrence of a string within another */
1999-06-15 21:51:00 +00:00
PHP_FUNCTION ( strstr )
1999-04-17 00:37:12 +00:00
{
1999-12-11 19:50:01 +00:00
zval * * haystack , * * needle ;
1999-04-17 00:37:12 +00:00
char * found = NULL ;
1999-12-11 19:50:01 +00:00
char needle_char [ 2 ] ;
2002-10-02 18:41:55 +00:00
long found_offset ;
2008-02-01 12:28:44 +00:00
zend_bool part = 0 ;
1999-04-17 00:37:12 +00:00
2008-02-01 12:28:44 +00:00
if ( zend_parse_parameters ( ZEND_NUM_ARGS ( ) TSRMLS_CC , " ZZ|b " , & haystack , & needle , & part ) = = FAILURE ) {
return ;
1999-04-17 00:37:12 +00:00
}
2003-02-08 15:26:17 +00:00
2008-02-03 14:30:25 +00:00
SEPARATE_ZVAL ( haystack ) ;
convert_to_string ( * haystack ) ;
1999-04-17 00:37:12 +00:00
2001-09-04 06:18:11 +00:00
if ( Z_TYPE_PP ( needle ) = = IS_STRING ) {
if ( ! Z_STRLEN_PP ( needle ) ) {
2007-09-30 05:40:23 +00:00
php_error_docref ( NULL TSRMLS_CC , E_WARNING , " Empty delimiter " ) ;
1999-04-17 00:37:12 +00:00
RETURN_FALSE ;
}
2001-09-04 06:18:11 +00:00
2008-02-03 14:30:25 +00:00
found = php_memnstr ( Z_STRVAL_PP ( haystack ) , Z_STRVAL_PP ( needle ) , Z_STRLEN_PP ( needle ) , Z_STRVAL_PP ( haystack ) + Z_STRLEN_PP ( haystack ) ) ;
2002-09-11 14:40:52 +00:00
} else {
2008-02-03 14:30:25 +00:00
SEPARATE_ZVAL ( needle ) ;
convert_to_long ( * needle ) ;
2001-09-04 06:18:11 +00:00
needle_char [ 0 ] = ( char ) Z_LVAL_PP ( needle ) ;
needle_char [ 1 ] = 0 ;
1999-04-17 00:37:12 +00:00
2008-02-03 14:30:25 +00:00
found = php_memnstr ( Z_STRVAL_PP ( haystack ) , needle_char , 1 , Z_STRVAL_PP ( haystack ) + Z_STRLEN_PP ( haystack ) ) ;
2001-09-04 06:18:11 +00:00
}
1999-04-17 00:37:12 +00:00
if ( found ) {
2002-10-02 18:41:55 +00:00
found_offset = found - Z_STRVAL_PP ( haystack ) ;
2008-02-01 12:28:44 +00:00
if ( part ) {
RETURN_STRINGL ( Z_STRVAL_PP ( haystack ) , found_offset , 1 ) ;
} else {
RETURN_STRINGL ( found , Z_STRLEN_PP ( haystack ) - found_offset , 1 ) ;
}
1999-04-17 00:37:12 +00:00
}
2008-02-03 14:30:25 +00:00
RETURN_FALSE ;
1999-04-17 00:37:12 +00:00
}
/* }}} */
1999-08-09 20:52:58 +00:00
/* {{{ proto string strchr(string haystack, string needle)
An alias for strstr */
/* }}} */
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
/* {{{ proto int strpos(string haystack, string needle [, int offset])
2001-09-04 10:44:28 +00:00
Finds position of first occurrence of a string within another */
1999-06-15 21:51:00 +00:00
PHP_FUNCTION ( strpos )
1999-04-17 00:37:12 +00:00
{
2008-06-22 19:22:41 +00:00
zval * * needle ;
char * haystack ;
1999-04-17 00:37:12 +00:00
char * found = NULL ;
2001-09-04 06:18:11 +00:00
char needle_char [ 2 ] ;
2008-06-30 10:39:34 +00:00
long offset = 0 ;
2008-06-22 19:22:41 +00:00
int haystack_len ;
if ( zend_parse_parameters ( ZEND_NUM_ARGS ( ) TSRMLS_CC , " sZ|l " , & haystack , & haystack_len , & needle , & offset ) = = FAILURE ) {
return ;
1999-04-17 00:37:12 +00:00
}
2008-06-22 19:22:41 +00:00
if ( offset < 0 | | offset > haystack_len ) {
2007-09-30 05:40:23 +00:00
php_error_docref ( NULL TSRMLS_CC , E_WARNING , " Offset not contained in string " ) ;
2001-09-04 06:18:11 +00:00
RETURN_FALSE ;
}
1999-12-06 17:37:59 +00:00
2001-09-04 06:18:11 +00:00
if ( Z_TYPE_PP ( needle ) = = IS_STRING ) {
if ( ! Z_STRLEN_PP ( needle ) ) {
2007-09-30 05:40:23 +00:00
php_error_docref ( NULL TSRMLS_CC , E_WARNING , " Empty delimiter " ) ;
1999-04-17 00:37:12 +00:00
RETURN_FALSE ;
}
1999-12-06 17:37:59 +00:00
2008-06-22 19:22:41 +00:00
found = php_memnstr ( haystack + offset ,
2002-09-11 14:40:52 +00:00
Z_STRVAL_PP ( needle ) ,
Z_STRLEN_PP ( needle ) ,
2008-06-22 19:22:41 +00:00
haystack + haystack_len ) ;
2002-09-11 14:40:52 +00:00
} else {
1999-09-25 11:55:42 +00:00
convert_to_long_ex ( needle ) ;
2001-09-04 06:18:11 +00:00
needle_char [ 0 ] = ( char ) Z_LVAL_PP ( needle ) ;
needle_char [ 1 ] = 0 ;
1999-12-06 17:37:59 +00:00
2008-06-22 19:22:41 +00:00
found = php_memnstr ( haystack + offset ,
2003-02-08 15:26:17 +00:00
needle_char ,
1 ,
2008-06-22 19:22:41 +00:00
haystack + haystack_len ) ;
1999-04-17 00:37:12 +00:00
}
if ( found ) {
2008-06-22 19:22:41 +00:00
RETURN_LONG ( found - haystack ) ;
1999-04-17 00:37:12 +00:00
} else {
2001-09-04 06:18:11 +00:00
RETURN_FALSE ;
1999-04-17 00:37:12 +00:00
}
}
/* }}} */
2003-01-11 17:52:38 +00:00
/* {{{ proto int stripos(string haystack, string needle [, int offset])
Finds position of first occurrence of a string within another , case insensitive */
PHP_FUNCTION ( stripos )
{
char * found = NULL ;
char * haystack ;
int haystack_len ;
long offset = 0 ;
char * needle_dup = NULL , * haystack_dup ;
char needle_char [ 2 ] ;
zval * needle ;
if ( zend_parse_parameters ( ZEND_NUM_ARGS ( ) TSRMLS_CC , " sz|l " , & haystack , & haystack_len , & needle , & offset ) = = FAILURE ) {
return ;
}
2003-02-08 15:26:17 +00:00
2003-01-11 17:52:38 +00:00
if ( offset < 0 | | offset > haystack_len ) {
2007-09-30 05:40:23 +00:00
php_error_docref ( NULL TSRMLS_CC , E_WARNING , " Offset not contained in string " ) ;
2003-01-11 17:52:38 +00:00
RETURN_FALSE ;
}
2006-07-12 12:33:48 +00:00
if ( haystack_len = = 0 ) {
RETURN_FALSE ;
}
2003-01-11 17:52:38 +00:00
haystack_dup = estrndup ( haystack , haystack_len ) ;
php_strtolower ( haystack_dup , haystack_len ) ;
if ( Z_TYPE_P ( needle ) = = IS_STRING ) {
2006-07-12 12:33:48 +00:00
if ( Z_STRLEN_P ( needle ) = = 0 | | Z_STRLEN_P ( needle ) > haystack_len ) {
efree ( haystack_dup ) ;
RETURN_FALSE ;
}
2003-01-11 17:52:38 +00:00
needle_dup = estrndup ( Z_STRVAL_P ( needle ) , Z_STRLEN_P ( needle ) ) ;
php_strtolower ( needle_dup , Z_STRLEN_P ( needle ) ) ;
found = php_memnstr ( haystack_dup + offset , needle_dup , Z_STRLEN_P ( needle ) , haystack_dup + haystack_len ) ;
} else {
switch ( Z_TYPE_P ( needle ) ) {
case IS_LONG :
case IS_BOOL :
needle_char [ 0 ] = tolower ( ( char ) Z_LVAL_P ( needle ) ) ;
break ;
case IS_DOUBLE :
needle_char [ 0 ] = tolower ( ( char ) Z_DVAL_P ( needle ) ) ;
break ;
default :
2007-09-30 05:40:23 +00:00
php_error_docref ( NULL TSRMLS_CC , E_WARNING , " needle is not a string or an integer " ) ;
2003-01-11 17:52:38 +00:00
efree ( haystack_dup ) ;
RETURN_FALSE ;
break ;
}
needle_char [ 1 ] = ' \0 ' ;
2003-02-08 15:26:17 +00:00
found = php_memnstr ( haystack_dup + offset ,
needle_char ,
sizeof ( needle_char ) - 1 ,
haystack_dup + haystack_len ) ;
2003-01-11 17:52:38 +00:00
}
efree ( haystack_dup ) ;
if ( needle_dup ) {
efree ( needle_dup ) ;
}
if ( found ) {
RETURN_LONG ( found - haystack_dup ) ;
} else {
RETURN_FALSE ;
}
}
/* }}} */
/* {{{ proto int strrpos(string haystack, string needle [, int offset])
2003-04-12 07:36:22 +00:00
Finds position of last occurrence of a string within another string */
1999-06-15 21:51:00 +00:00
PHP_FUNCTION ( strrpos )
1999-04-17 00:37:12 +00:00
{
2006-08-31 14:21:21 +00:00
zval * * zneedle ;
2003-04-12 07:36:22 +00:00
char * needle , * haystack ;
2004-06-15 22:38:18 +00:00
int needle_len , haystack_len ;
long offset = 0 ;
2003-12-03 01:11:36 +00:00
char * p , * e , ord_needle [ 2 ] ;
2003-01-11 17:52:38 +00:00
2006-08-31 14:21:21 +00:00
if ( zend_parse_parameters ( ZEND_NUM_ARGS ( ) TSRMLS_CC , " sZ|l " , & haystack , & haystack_len , & zneedle , & offset ) = = FAILURE ) {
2003-04-12 07:36:22 +00:00
RETURN_FALSE ;
2003-01-11 17:52:38 +00:00
}
2006-08-31 14:21:21 +00:00
if ( Z_TYPE_PP ( zneedle ) = = IS_STRING ) {
needle = Z_STRVAL_PP ( zneedle ) ;
needle_len = Z_STRLEN_PP ( zneedle ) ;
2003-12-03 01:11:36 +00:00
} else {
2006-08-31 14:21:21 +00:00
convert_to_long_ex ( zneedle ) ;
ord_needle [ 0 ] = ( char ) ( Z_LVAL_PP ( zneedle ) & 0xFF ) ;
2003-12-03 01:11:36 +00:00
ord_needle [ 1 ] = ' \0 ' ;
needle = ord_needle ;
needle_len = 1 ;
}
2003-04-12 20:04:06 +00:00
if ( ( haystack_len = = 0 ) | | ( needle_len = = 0 ) ) {
RETURN_FALSE ;
}
2003-04-12 07:36:22 +00:00
if ( offset > = 0 ) {
2006-10-02 19:42:42 +00:00
if ( offset > haystack_len ) {
2006-10-02 20:07:14 +00:00
php_error_docref ( NULL TSRMLS_CC , E_NOTICE , " Offset is greater than the length of haystack string " ) ;
2006-10-02 19:42:42 +00:00
RETURN_FALSE ;
}
2003-04-12 07:36:22 +00:00
p = haystack + offset ;
e = haystack + haystack_len - needle_len ;
2003-01-11 17:52:38 +00:00
} else {
2008-07-22 01:10:58 +00:00
if ( - offset > haystack_len | | offset < - INT_MAX ) {
2006-10-02 20:07:14 +00:00
php_error_docref ( NULL TSRMLS_CC , E_NOTICE , " Offset is greater than the length of haystack string " ) ;
2006-10-02 19:42:42 +00:00
RETURN_FALSE ;
}
p = haystack ;
if ( needle_len > - offset ) {
2003-04-12 07:36:22 +00:00
e = haystack + haystack_len - needle_len ;
} else {
e = haystack + haystack_len + offset ;
}
2003-01-11 17:52:38 +00:00
}
2003-12-03 01:31:56 +00:00
if ( needle_len = = 1 ) {
/* Single character search can shortcut memcmps */
while ( e > = p ) {
if ( * e = = * needle ) {
RETURN_LONG ( e - p + ( offset > 0 ? offset : 0 ) ) ;
}
e - - ;
}
RETURN_FALSE ;
}
2003-04-12 07:36:22 +00:00
while ( e > = p ) {
if ( memcmp ( e , needle , needle_len ) = = 0 ) {
2003-12-03 01:31:56 +00:00
RETURN_LONG ( e - p + ( offset > 0 ? offset : 0 ) ) ;
2003-04-12 07:36:22 +00:00
}
e - - ;
2003-01-11 17:52:38 +00:00
}
2003-04-12 07:36:22 +00:00
RETURN_FALSE ;
2003-01-11 17:52:38 +00:00
}
/* }}} */
/* {{{ proto int strripos(string haystack, string needle [, int offset])
2003-04-12 07:36:22 +00:00
Finds position of last occurrence of a string within another string */
2003-01-11 17:52:38 +00:00
PHP_FUNCTION ( strripos )
{
2006-08-31 14:21:21 +00:00
zval * * zneedle ;
2003-04-12 07:36:22 +00:00
char * needle , * haystack ;
2004-02-25 20:16:27 +00:00
int needle_len , haystack_len ;
long offset = 0 ;
2003-12-03 01:11:36 +00:00
char * p , * e , ord_needle [ 2 ] ;
2003-04-12 07:36:22 +00:00
char * needle_dup , * haystack_dup ;
1999-04-17 00:37:12 +00:00
2006-08-31 14:21:21 +00:00
if ( zend_parse_parameters ( ZEND_NUM_ARGS ( ) TSRMLS_CC , " sZ|l " , & haystack , & haystack_len , & zneedle , & offset ) = = FAILURE ) {
2003-04-12 07:36:22 +00:00
RETURN_FALSE ;
2003-01-11 17:52:38 +00:00
}
2006-08-31 14:21:21 +00:00
if ( Z_TYPE_PP ( zneedle ) = = IS_STRING ) {
needle = Z_STRVAL_PP ( zneedle ) ;
needle_len = Z_STRLEN_PP ( zneedle ) ;
2003-12-03 01:11:36 +00:00
} else {
2006-08-31 14:21:21 +00:00
convert_to_long_ex ( zneedle ) ;
ord_needle [ 0 ] = ( char ) ( Z_LVAL_PP ( zneedle ) & 0xFF ) ;
2003-12-03 01:11:36 +00:00
ord_needle [ 1 ] = ' \0 ' ;
needle = ord_needle ;
needle_len = 1 ;
}
2003-04-12 20:04:06 +00:00
if ( ( haystack_len = = 0 ) | | ( needle_len = = 0 ) ) {
RETURN_FALSE ;
}
2003-12-03 01:31:56 +00:00
if ( needle_len = = 1 ) {
/* Single character search can shortcut memcmps
Can also avoid tolower emallocs */
if ( offset > = 0 ) {
2006-10-02 19:58:15 +00:00
if ( offset > haystack_len ) {
2006-10-02 20:07:14 +00:00
php_error_docref ( NULL TSRMLS_CC , E_NOTICE , " Offset is greater than the length of haystack string " ) ;
2006-10-02 19:58:15 +00:00
RETURN_FALSE ;
}
2003-12-03 01:31:56 +00:00
p = haystack + offset ;
e = haystack + haystack_len - 1 ;
} else {
p = haystack ;
2007-06-06 21:53:54 +00:00
if ( - offset > haystack_len | | offset < - INT_MAX ) {
2006-10-02 20:07:14 +00:00
php_error_docref ( NULL TSRMLS_CC , E_NOTICE , " Offset is greater than the length of haystack string " ) ;
2006-10-02 19:58:15 +00:00
RETURN_FALSE ;
2004-05-06 16:11:50 +00:00
}
2007-06-06 21:53:54 +00:00
e = haystack + haystack_len + offset ;
2003-12-03 01:31:56 +00:00
}
/* Borrow that ord_needle buffer to avoid repeatedly tolower()ing needle */
* ord_needle = tolower ( * needle ) ;
while ( e > = p ) {
if ( tolower ( * e ) = = * ord_needle ) {
RETURN_LONG ( e - p + ( offset > 0 ? offset : 0 ) ) ;
}
e - - ;
}
RETURN_FALSE ;
}
2003-04-12 07:36:22 +00:00
needle_dup = estrndup ( needle , needle_len ) ;
php_strtolower ( needle_dup , needle_len ) ;
haystack_dup = estrndup ( haystack , haystack_len ) ;
php_strtolower ( haystack_dup , haystack_len ) ;
2003-01-11 17:52:38 +00:00
2003-04-12 07:36:22 +00:00
if ( offset > = 0 ) {
2006-10-02 19:58:15 +00:00
if ( offset > haystack_len ) {
2007-02-01 13:45:25 +00:00
efree ( needle_dup ) ;
efree ( haystack_dup ) ;
2006-10-02 20:07:14 +00:00
php_error_docref ( NULL TSRMLS_CC , E_NOTICE , " Offset is greater than the length of haystack string " ) ;
2006-10-02 19:58:15 +00:00
RETURN_FALSE ;
}
2003-04-12 07:36:22 +00:00
p = haystack_dup + offset ;
e = haystack_dup + haystack_len - needle_len ;
2002-10-10 18:41:24 +00:00
} else {
2007-06-06 21:53:54 +00:00
if ( - offset > haystack_len | | offset < - INT_MAX ) {
2007-02-01 13:45:25 +00:00
efree ( needle_dup ) ;
efree ( haystack_dup ) ;
2006-10-02 20:07:14 +00:00
php_error_docref ( NULL TSRMLS_CC , E_NOTICE , " Offset is greater than the length of haystack string " ) ;
2006-10-02 19:58:15 +00:00
RETURN_FALSE ;
}
p = haystack_dup ;
if ( needle_len > - offset ) {
2003-04-12 07:36:22 +00:00
e = haystack_dup + haystack_len - needle_len ;
} else {
e = haystack_dup + haystack_len + offset ;
}
1999-04-17 00:37:12 +00:00
}
2003-04-12 07:36:22 +00:00
while ( e > = p ) {
if ( memcmp ( e , needle_dup , needle_len ) = = 0 ) {
efree ( haystack_dup ) ;
efree ( needle_dup ) ;
2003-12-03 01:31:56 +00:00
RETURN_LONG ( e - p + ( offset > 0 ? offset : 0 ) ) ;
2003-04-12 07:36:22 +00:00
}
e - - ;
}
2003-01-11 17:52:38 +00:00
efree ( haystack_dup ) ;
2003-04-12 07:36:22 +00:00
efree ( needle_dup ) ;
RETURN_FALSE ;
1999-04-17 00:37:12 +00:00
}
/* }}} */
/* {{{ proto string strrchr(string haystack, string needle)
2001-09-04 10:44:28 +00:00
Finds the last occurrence of a character in a string within another */
1999-06-15 21:51:00 +00:00
PHP_FUNCTION ( strrchr )
1999-04-17 00:37:12 +00:00
{
2008-06-22 19:22:41 +00:00
zval * * needle ;
char * haystack ;
1999-04-17 00:37:12 +00:00
char * found = NULL ;
2002-10-02 18:58:09 +00:00
long found_offset ;
2008-06-22 19:22:41 +00:00
int haystack_len ;
1999-04-17 00:37:12 +00:00
2008-06-22 19:22:41 +00:00
if ( zend_parse_parameters ( ZEND_NUM_ARGS ( ) TSRMLS_CC , " sZ " , & haystack , & haystack_len , & needle ) = = FAILURE ) {
return ;
1999-04-17 00:37:12 +00:00
}
2001-09-04 06:18:11 +00:00
if ( Z_TYPE_PP ( needle ) = = IS_STRING ) {
2008-06-22 19:22:41 +00:00
found = zend_memrchr ( haystack , * Z_STRVAL_PP ( needle ) , haystack_len ) ;
2002-10-10 18:41:24 +00:00
} else {
1999-09-25 11:55:42 +00:00
convert_to_long_ex ( needle ) ;
2008-06-22 19:22:41 +00:00
found = zend_memrchr ( haystack , ( char ) Z_LVAL_PP ( needle ) , haystack_len ) ;
1999-04-17 00:37:12 +00:00
}
if ( found ) {
2008-06-22 19:22:41 +00:00
found_offset = found - haystack ;
RETURN_STRINGL ( found , haystack_len - found_offset , 1 ) ;
1999-04-17 00:37:12 +00:00
} else {
2001-09-04 06:18:11 +00:00
RETURN_FALSE ;
1999-04-17 00:37:12 +00:00
}
}
/* }}} */
2001-06-05 13:12:10 +00:00
/* {{{ php_chunk_split
*/
2003-02-08 15:26:17 +00:00
static char * php_chunk_split ( char * src , int srclen , char * end , int endlen , int chunklen , int * destlen )
1999-04-17 00:37:12 +00:00
{
char * dest ;
char * p , * q ;
int chunks ; /* complete chunks! */
int restlen ;
2007-06-06 17:59:07 +00:00
int out_len ;
1999-04-17 00:37:12 +00:00
chunks = srclen / chunklen ;
restlen = srclen - chunks * chunklen ; /* srclen % chunklen */
2007-06-06 17:59:07 +00:00
if ( chunks > INT_MAX - 1 ) {
return NULL ;
}
2007-06-03 18:47:10 +00:00
out_len = chunks + 1 ;
2007-06-06 18:15:41 +00:00
if ( endlen ! = 0 & & out_len > INT_MAX / endlen ) {
2007-06-06 17:59:07 +00:00
return NULL ;
}
2007-06-03 18:47:10 +00:00
out_len * = endlen ;
2007-06-06 17:59:07 +00:00
if ( out_len > INT_MAX - srclen - 1 ) {
2007-05-30 00:33:13 +00:00
return NULL ;
}
2007-06-06 17:59:07 +00:00
out_len + = srclen + 1 ;
2007-05-30 00:33:13 +00:00
2007-06-03 18:47:10 +00:00
dest = safe_emalloc ( ( int ) out_len , sizeof ( char ) , 0 ) ;
1999-04-17 00:37:12 +00:00
2002-10-02 17:56:04 +00:00
for ( p = src , q = dest ; p < ( src + srclen - chunklen + 1 ) ; ) {
1999-04-17 00:37:12 +00:00
memcpy ( q , p , chunklen ) ;
q + = chunklen ;
memcpy ( q , end , endlen ) ;
q + = endlen ;
p + = chunklen ;
}
2002-10-02 17:56:04 +00:00
if ( restlen ) {
1999-04-17 00:37:12 +00:00
memcpy ( q , p , restlen ) ;
q + = restlen ;
memcpy ( q , end , endlen ) ;
q + = endlen ;
}
* q = ' \0 ' ;
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
if ( destlen ) {
* destlen = q - dest ;
}
1999-04-17 00:37:12 +00:00
return ( dest ) ;
}
2001-06-05 13:12:10 +00:00
/* }}} */
1999-04-17 00:37:12 +00:00
/* {{{ proto string chunk_split(string str [, int chunklen [, string ending]])
2001-09-04 10:44:28 +00:00
Returns split line */
1999-06-15 21:51:00 +00:00
PHP_FUNCTION ( chunk_split )
1999-04-17 00:37:12 +00:00
{
2008-06-22 19:22:41 +00:00
zval * * p_chunklen , * * p_ending ;
char * str ;
1999-04-17 00:37:12 +00:00
char * result ;
char * end = " \r \n " ;
int endlen = 2 ;
2007-12-24 18:09:50 +00:00
long chunklen = 76 ;
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
int result_len ;
2001-09-04 06:18:11 +00:00
int argc = ZEND_NUM_ARGS ( ) ;
2008-06-22 19:22:41 +00:00
int str_len ;
if ( zend_parse_parameters ( ZEND_NUM_ARGS ( ) TSRMLS_CC , " s|ZZ " , & str , & str_len , & p_chunklen , & p_ending ) = = FAILURE ) {
2007-12-24 18:09:50 +00:00
return ;
1999-04-17 00:37:12 +00:00
}
2003-02-08 15:26:17 +00:00
2001-09-04 06:18:11 +00:00
if ( argc > 1 ) {
2001-09-27 06:55:23 +00:00
convert_to_long_ex ( p_chunklen ) ;
2001-09-04 06:18:11 +00:00
chunklen = Z_LVAL_PP ( p_chunklen ) ;
1999-04-17 00:37:12 +00:00
}
2001-09-04 06:18:11 +00:00
if ( argc > 2 ) {
convert_to_string_ex ( p_ending ) ;
end = Z_STRVAL_PP ( p_ending ) ;
endlen = Z_STRLEN_PP ( p_ending ) ;
}
if ( chunklen < = 0 ) {
2007-09-30 05:40:23 +00:00
php_error_docref ( NULL TSRMLS_CC , E_WARNING , " Chunk length should be greater than zero " ) ;
1999-04-17 00:37:12 +00:00
RETURN_FALSE ;
}
2000-08-17 08:47:42 +00:00
2008-06-22 19:22:41 +00:00
if ( chunklen > str_len ) {
2005-04-03 18:08:40 +00:00
/* to maintain BC, we must return original string + ending */
2008-06-22 19:22:41 +00:00
result_len = endlen + str_len ;
2005-04-03 18:08:40 +00:00
result = emalloc ( result_len + 1 ) ;
2008-06-22 19:22:41 +00:00
memcpy ( result , str , str_len ) ;
memcpy ( result + str_len , end , endlen ) ;
2005-04-03 18:08:40 +00:00
result [ result_len ] = ' \0 ' ;
RETURN_STRINGL ( result , result_len , 0 ) ;
2005-01-18 15:47:57 +00:00
}
2008-06-22 19:22:41 +00:00
if ( ! str_len ) {
2000-08-17 08:47:42 +00:00
RETURN_EMPTY_STRING ( ) ;
}
2008-06-22 19:22:41 +00:00
result = php_chunk_split ( str , str_len , end , endlen , chunklen , & result_len ) ;
2003-02-08 15:26:17 +00:00
2001-09-04 06:18:11 +00:00
if ( result ) {
RETURN_STRINGL ( result , result_len , 0 ) ;
1999-04-17 00:37:12 +00:00
} else {
RETURN_FALSE ;
}
}
/* }}} */
/* {{{ proto string substr(string str, int start [, int length])
2001-09-04 10:44:28 +00:00
Returns part of a string */
1999-06-15 21:51:00 +00:00
PHP_FUNCTION ( substr )
1999-04-17 00:37:12 +00:00
{
2008-06-25 12:16:17 +00:00
char * str ;
2008-06-30 10:39:34 +00:00
long l , f ;
2008-06-25 12:16:17 +00:00
int str_len ;
2001-09-04 06:18:11 +00:00
int argc = ZEND_NUM_ARGS ( ) ;
2008-06-25 12:16:17 +00:00
if ( zend_parse_parameters ( ZEND_NUM_ARGS ( ) TSRMLS_CC , " sl|l " , & str , & str_len , & f , & l ) = = FAILURE ) {
return ;
1999-04-17 00:37:12 +00:00
}
2003-02-08 15:26:17 +00:00
2001-09-04 06:18:11 +00:00
if ( argc > 2 ) {
2008-06-25 12:16:17 +00:00
if ( ( l < 0 & & - l > str_len ) ) {
2007-03-09 01:58:34 +00:00
RETURN_FALSE ;
2008-06-25 12:16:17 +00:00
} else if ( l > str_len ) {
l = str_len ;
2007-03-09 01:58:34 +00:00
}
2002-10-03 18:15:18 +00:00
} else {
2008-06-25 12:16:17 +00:00
l = str_len ;
2001-09-04 06:18:11 +00:00
}
2008-06-25 12:16:17 +00:00
if ( f > str_len ) {
2007-03-09 01:58:34 +00:00
RETURN_FALSE ;
2008-06-25 12:16:17 +00:00
} else if ( f < 0 & & - f > str_len ) {
2008-02-13 17:02:16 +00:00
f = 0 ;
2007-03-09 01:58:34 +00:00
}
1999-04-17 00:37:12 +00:00
2008-06-25 12:16:17 +00:00
if ( l < 0 & & ( l + str_len - f ) < 0 ) {
2007-03-12 23:42:26 +00:00
RETURN_FALSE ;
}
1999-04-17 00:37:12 +00:00
/* if "from" position is negative, count start position from the end
* of the string
*/
if ( f < 0 ) {
2008-06-25 12:16:17 +00:00
f = str_len + f ;
1999-04-17 00:37:12 +00:00
if ( f < 0 ) {
f = 0 ;
}
}
/* if "length" position is negative, set it to the length
* needed to stop that many chars from the end of the string
*/
if ( l < 0 ) {
2008-06-25 12:16:17 +00:00
l = ( str_len - f ) + l ;
1999-04-17 00:37:12 +00:00
if ( l < 0 ) {
l = 0 ;
}
}
2008-06-25 12:16:17 +00:00
if ( f > = str_len ) {
1999-04-17 00:37:12 +00:00
RETURN_FALSE ;
}
2008-06-25 12:16:17 +00:00
if ( ( f + l ) > str_len ) {
l = str_len - f ;
1999-04-17 00:37:12 +00:00
}
1999-06-15 21:51:00 +00:00
2008-06-25 12:16:17 +00:00
RETURN_STRINGL ( str + f , l , 1 ) ;
1999-04-17 00:37:12 +00:00
}
/* }}} */
2003-05-02 10:02:40 +00:00
/* {{{ proto mixed substr_replace(mixed str, mixed repl, mixed start [, mixed length])
2001-09-04 10:44:28 +00:00
Replaces part of a string with another string */
1999-11-16 22:44:13 +00:00
PHP_FUNCTION ( substr_replace )
{
2002-09-11 14:40:52 +00:00
zval * * str ;
zval * * from ;
2003-05-02 10:02:40 +00:00
zval * * len = NULL ;
2002-09-11 14:40:52 +00:00
zval * * repl ;
char * result ;
int result_len ;
2003-08-27 00:43:54 +00:00
int l = 0 ;
2002-09-11 14:40:52 +00:00
int f ;
int argc = ZEND_NUM_ARGS ( ) ;
2003-05-02 10:02:40 +00:00
HashPosition pos_str , pos_from , pos_repl , pos_len ;
zval * * tmp_str = NULL , * * tmp_from = NULL , * * tmp_repl = NULL , * * tmp_len = NULL ;
2008-06-25 12:16:17 +00:00
if ( zend_parse_parameters ( ZEND_NUM_ARGS ( ) TSRMLS_CC , " ZZZ|Z " , & str , & repl , & from , & len ) = = FAILURE ) {
return ;
1999-11-16 22:44:13 +00:00
}
2001-09-04 06:18:11 +00:00
2003-05-02 10:02:40 +00:00
if ( Z_TYPE_PP ( str ) ! = IS_ARRAY ) {
convert_to_string_ex ( str ) ;
}
if ( Z_TYPE_PP ( repl ) ! = IS_ARRAY ) {
convert_to_string_ex ( repl ) ;
}
if ( Z_TYPE_PP ( from ) ! = IS_ARRAY ) {
convert_to_long_ex ( from ) ;
}
2001-09-04 06:18:11 +00:00
if ( argc > 3 ) {
2007-08-05 14:47:42 +00:00
SEPARATE_ZVAL ( len ) ;
2003-05-02 10:02:40 +00:00
if ( Z_TYPE_PP ( len ) ! = IS_ARRAY ) {
convert_to_long_ex ( len ) ;
l = Z_LVAL_PP ( len ) ;
}
2002-10-10 18:41:24 +00:00
} else {
2003-05-02 10:02:40 +00:00
if ( Z_TYPE_PP ( str ) ! = IS_ARRAY ) {
l = Z_STRLEN_PP ( str ) ;
}
1999-11-16 22:44:13 +00:00
}
2003-05-02 10:02:40 +00:00
if ( Z_TYPE_PP ( str ) = = IS_STRING ) {
if (
2007-10-01 13:38:14 +00:00
( argc = = 3 & & Z_TYPE_PP ( from ) = = IS_ARRAY ) | |
2003-05-02 10:02:40 +00:00
( argc = = 4 & & Z_TYPE_PP ( from ) ! = Z_TYPE_PP ( len ) )
) {
php_error_docref ( NULL TSRMLS_CC , E_WARNING , " 'from' and 'len' should be of same type - numerical or array " ) ;
RETURN_STRINGL ( Z_STRVAL_PP ( str ) , Z_STRLEN_PP ( str ) , 1 ) ;
}
if ( argc = = 4 & & Z_TYPE_PP ( from ) = = IS_ARRAY ) {
if ( zend_hash_num_elements ( Z_ARRVAL_PP ( from ) ) ! = zend_hash_num_elements ( Z_ARRVAL_PP ( len ) ) ) {
php_error_docref ( NULL TSRMLS_CC , E_WARNING , " 'from' and 'len' should have the same number of elements " ) ;
RETURN_STRINGL ( Z_STRVAL_PP ( str ) , Z_STRLEN_PP ( str ) , 1 ) ;
}
1999-11-16 22:44:13 +00:00
}
2002-10-10 18:41:24 +00:00
}
2003-05-02 10:02:40 +00:00
if ( Z_TYPE_PP ( str ) ! = IS_ARRAY ) {
if ( Z_TYPE_PP ( from ) ! = IS_ARRAY ) {
int repl_len = 0 ;
1999-11-16 22:44:13 +00:00
2003-05-02 10:02:40 +00:00
f = Z_LVAL_PP ( from ) ;
/* if "from" position is negative, count start position from the end
* of the string
*/
if ( f < 0 ) {
f = Z_STRLEN_PP ( str ) + f ;
if ( f < 0 ) {
f = 0 ;
}
} else if ( f > Z_STRLEN_PP ( str ) ) {
f = Z_STRLEN_PP ( str ) ;
}
/* if "length" position is negative, set it to the length
* needed to stop that many chars from the end of the string
*/
if ( l < 0 ) {
l = ( Z_STRLEN_PP ( str ) - f ) + l ;
if ( l < 0 ) {
l = 0 ;
}
}
2007-03-09 01:58:34 +00:00
if ( f > Z_STRLEN_PP ( str ) | | ( f < 0 & & - f > Z_STRLEN_PP ( str ) ) ) {
RETURN_FALSE ;
} else if ( l > Z_STRLEN_PP ( str ) | | ( l < 0 & & - l > Z_STRLEN_PP ( str ) ) ) {
2007-07-30 14:22:06 +00:00
l = Z_STRLEN_PP ( str ) ;
2007-03-09 01:58:34 +00:00
}
2006-02-26 10:57:00 +00:00
if ( ( f + l ) > Z_STRLEN_PP ( str ) ) {
2003-05-02 10:02:40 +00:00
l = Z_STRLEN_PP ( str ) - f ;
}
if ( Z_TYPE_PP ( repl ) = = IS_ARRAY ) {
zend_hash_internal_pointer_reset_ex ( Z_ARRVAL_PP ( repl ) , & pos_repl ) ;
if ( SUCCESS = = zend_hash_get_current_data_ex ( Z_ARRVAL_PP ( repl ) , ( void * * ) & tmp_repl , & pos_repl ) ) {
convert_to_string_ex ( tmp_repl ) ;
repl_len = Z_STRLEN_PP ( tmp_repl ) ;
}
} else {
repl_len = Z_STRLEN_PP ( repl ) ;
2003-12-01 23:17:22 +00:00
}
result_len = Z_STRLEN_PP ( str ) - l + repl_len ;
result = emalloc ( result_len + 1 ) ;
2003-05-02 10:02:40 +00:00
2003-12-01 23:17:22 +00:00
memcpy ( result , Z_STRVAL_PP ( str ) , f ) ;
if ( repl_len ) {
memcpy ( ( result + f ) , ( Z_TYPE_PP ( repl ) = = IS_ARRAY ? Z_STRVAL_PP ( tmp_repl ) : Z_STRVAL_PP ( repl ) ) , repl_len ) ;
2003-05-02 10:02:40 +00:00
}
2003-12-01 23:17:22 +00:00
memcpy ( ( result + f + repl_len ) , Z_STRVAL_PP ( str ) + f + l , Z_STRLEN_PP ( str ) - f - l ) ;
result [ result_len ] = ' \0 ' ;
2003-05-02 10:02:40 +00:00
RETURN_STRINGL ( result , result_len , 0 ) ;
} else {
2007-09-30 05:40:23 +00:00
php_error_docref ( NULL TSRMLS_CC , E_WARNING , " Functionality of 'from' and 'len' as arrays is not implemented " ) ;
2003-05-02 10:02:40 +00:00
RETURN_STRINGL ( Z_STRVAL_PP ( str ) , Z_STRLEN_PP ( str ) , 1 ) ;
1999-11-16 22:44:13 +00:00
}
2003-05-02 10:02:40 +00:00
} else { /* str is array of strings */
array_init ( return_value ) ;
1999-11-16 22:44:13 +00:00
2003-05-02 10:02:40 +00:00
if ( Z_TYPE_PP ( from ) = = IS_ARRAY ) {
zend_hash_internal_pointer_reset_ex ( Z_ARRVAL_PP ( from ) , & pos_from ) ;
}
1999-11-16 22:44:13 +00:00
2003-05-02 10:02:40 +00:00
if ( argc > 3 & & Z_TYPE_PP ( len ) = = IS_ARRAY ) {
zend_hash_internal_pointer_reset_ex ( Z_ARRVAL_PP ( len ) , & pos_len ) ;
}
2003-12-01 23:17:22 +00:00
2003-05-02 10:02:40 +00:00
if ( Z_TYPE_PP ( repl ) = = IS_ARRAY ) {
zend_hash_internal_pointer_reset_ex ( Z_ARRVAL_PP ( repl ) , & pos_repl ) ;
}
2003-12-01 23:17:22 +00:00
2003-05-02 10:02:40 +00:00
zend_hash_internal_pointer_reset_ex ( Z_ARRVAL_PP ( str ) , & pos_str ) ;
while ( zend_hash_get_current_data_ex ( Z_ARRVAL_PP ( str ) , ( void * * ) & tmp_str , & pos_str ) = = SUCCESS ) {
convert_to_string_ex ( tmp_str ) ;
2003-12-01 23:17:22 +00:00
2003-05-02 10:02:40 +00:00
if ( Z_TYPE_PP ( from ) = = IS_ARRAY ) {
if ( SUCCESS = = zend_hash_get_current_data_ex ( Z_ARRVAL_PP ( from ) , ( void * * ) & tmp_from , & pos_from ) ) {
convert_to_long_ex ( tmp_from ) ;
2003-12-01 23:17:22 +00:00
2003-05-02 10:02:40 +00:00
f = Z_LVAL_PP ( tmp_from ) ;
if ( f < 0 ) {
f = Z_STRLEN_PP ( tmp_str ) + f ;
if ( f < 0 ) {
f = 0 ;
}
} else if ( f > Z_STRLEN_PP ( tmp_str ) ) {
f = Z_STRLEN_PP ( tmp_str ) ;
}
zend_hash_move_forward_ex ( Z_ARRVAL_PP ( from ) , & pos_from ) ;
} else {
f = 0 ;
2003-12-01 23:17:22 +00:00
}
2003-05-02 10:02:40 +00:00
} else {
f = Z_LVAL_PP ( from ) ;
if ( f < 0 ) {
f = Z_STRLEN_PP ( tmp_str ) + f ;
if ( f < 0 ) {
f = 0 ;
}
} else if ( f > Z_STRLEN_PP ( tmp_str ) ) {
f = Z_STRLEN_PP ( tmp_str ) ;
2003-12-01 23:17:22 +00:00
}
2003-05-02 10:02:40 +00:00
}
if ( argc > 3 & & Z_TYPE_PP ( len ) = = IS_ARRAY ) {
if ( SUCCESS = = zend_hash_get_current_data_ex ( Z_ARRVAL_PP ( len ) , ( void * * ) & tmp_len , & pos_len ) ) {
convert_to_long_ex ( tmp_len ) ;
2003-12-01 23:17:22 +00:00
2003-05-02 10:02:40 +00:00
l = Z_LVAL_PP ( tmp_len ) ;
zend_hash_move_forward_ex ( Z_ARRVAL_PP ( len ) , & pos_len ) ;
} else {
l = Z_STRLEN_PP ( tmp_str ) ;
}
} else if ( argc > 3 ) {
l = Z_LVAL_PP ( len ) ;
} else {
l = Z_STRLEN_PP ( tmp_str ) ;
}
2003-12-01 23:17:22 +00:00
2003-05-02 10:02:40 +00:00
if ( l < 0 ) {
l = ( Z_STRLEN_PP ( tmp_str ) - f ) + l ;
if ( l < 0 ) {
l = 0 ;
}
2003-12-01 23:17:22 +00:00
}
2003-05-02 10:02:40 +00:00
2006-02-26 10:57:00 +00:00
if ( ( f + l ) > Z_STRLEN_PP ( tmp_str ) ) {
2003-05-02 10:02:40 +00:00
l = Z_STRLEN_PP ( tmp_str ) - f ;
}
2003-12-01 23:17:22 +00:00
2003-05-02 10:02:40 +00:00
result_len = Z_STRLEN_PP ( tmp_str ) - l ;
2003-12-01 23:17:22 +00:00
2003-05-02 10:02:40 +00:00
if ( Z_TYPE_PP ( repl ) = = IS_ARRAY ) {
if ( SUCCESS = = zend_hash_get_current_data_ex ( Z_ARRVAL_PP ( repl ) , ( void * * ) & tmp_repl , & pos_repl ) ) {
convert_to_string_ex ( tmp_repl ) ;
result_len + = Z_STRLEN_PP ( tmp_repl ) ;
zend_hash_move_forward_ex ( Z_ARRVAL_PP ( repl ) , & pos_repl ) ;
2003-12-01 23:17:22 +00:00
result = emalloc ( result_len + 1 ) ;
2003-05-02 10:02:40 +00:00
memcpy ( result , Z_STRVAL_PP ( tmp_str ) , f ) ;
2003-12-01 23:17:22 +00:00
memcpy ( ( result + f ) , Z_STRVAL_PP ( tmp_repl ) , Z_STRLEN_PP ( tmp_repl ) ) ;
memcpy ( ( result + f + Z_STRLEN_PP ( tmp_repl ) ) , Z_STRVAL_PP ( tmp_str ) + f + l , Z_STRLEN_PP ( tmp_str ) - f - l ) ;
2003-05-02 10:02:40 +00:00
} else {
2003-12-01 23:17:22 +00:00
result = emalloc ( result_len + 1 ) ;
2003-05-02 10:02:40 +00:00
memcpy ( result , Z_STRVAL_PP ( tmp_str ) , f ) ;
2003-12-01 23:17:22 +00:00
memcpy ( ( result + f ) , Z_STRVAL_PP ( tmp_str ) + f + l , Z_STRLEN_PP ( tmp_str ) - f - l ) ;
2003-05-02 10:02:40 +00:00
}
} else {
result_len + = Z_STRLEN_PP ( repl ) ;
2003-12-01 23:17:22 +00:00
result = emalloc ( result_len + 1 ) ;
1999-11-16 22:44:13 +00:00
2003-05-02 10:02:40 +00:00
memcpy ( result , Z_STRVAL_PP ( tmp_str ) , f ) ;
2003-12-01 23:17:22 +00:00
memcpy ( ( result + f ) , Z_STRVAL_PP ( repl ) , Z_STRLEN_PP ( repl ) ) ;
memcpy ( ( result + f + Z_STRLEN_PP ( repl ) ) , Z_STRVAL_PP ( tmp_str ) + f + l , Z_STRLEN_PP ( tmp_str ) - f - l ) ;
2003-05-02 10:02:40 +00:00
}
2003-12-01 23:17:22 +00:00
result [ result_len ] = ' \0 ' ;
2003-05-02 10:02:40 +00:00
add_next_index_stringl ( return_value , result , result_len , 0 ) ;
2003-12-01 23:17:22 +00:00
2003-05-02 10:02:40 +00:00
zend_hash_move_forward_ex ( Z_ARRVAL_PP ( str ) , & pos_str ) ;
} /*while*/
} /* if */
1999-11-16 22:44:13 +00:00
}
/* }}} */
1999-04-17 00:37:12 +00:00
/* {{{ proto string quotemeta(string str)
2001-09-04 10:44:28 +00:00
Quotes meta characters */
1999-06-15 21:51:00 +00:00
PHP_FUNCTION ( quotemeta )
1999-04-17 00:37:12 +00:00
{
char * str , * old ;
1999-12-20 20:43:47 +00:00
char * old_end ;
1999-04-17 00:37:12 +00:00
char * p , * q ;
char c ;
2008-06-25 12:16:17 +00:00
int old_len ;
1999-04-17 00:37:12 +00:00
2008-06-25 12:16:17 +00:00
if ( zend_parse_parameters ( ZEND_NUM_ARGS ( ) TSRMLS_CC , " s " , & old , & old_len ) = = FAILURE ) {
return ;
}
old_end = old + old_len ;
1999-12-20 20:43:47 +00:00
if ( old = = old_end ) {
1999-04-17 00:37:12 +00:00
RETURN_FALSE ;
}
2008-06-25 12:16:17 +00:00
str = safe_emalloc ( 2 , old_len , 1 ) ;
1999-04-17 00:37:12 +00:00
2002-10-02 17:56:04 +00:00
for ( p = old , q = str ; p ! = old_end ; p + + ) {
1999-12-20 20:43:47 +00:00
c = * p ;
2002-10-02 17:56:04 +00:00
switch ( c ) {
1999-04-17 00:37:12 +00:00
case ' . ' :
case ' \\ ' :
case ' + ' :
case ' * ' :
case ' ? ' :
case ' [ ' :
case ' ^ ' :
case ' ] ' :
case ' $ ' :
case ' ( ' :
case ' ) ' :
* q + + = ' \\ ' ;
/* break is missing _intentionally_ */
default :
* q + + = c ;
}
}
* q = 0 ;
2001-09-04 06:18:11 +00:00
RETURN_STRINGL ( erealloc ( str , q - str + 1 ) , q - str , 0 ) ;
1999-04-17 00:37:12 +00:00
}
/* }}} */
/* {{{ proto int ord(string character)
2001-09-04 10:44:28 +00:00
Returns ASCII value of character */
1999-06-15 21:51:00 +00:00
PHP_FUNCTION ( ord )
1999-04-17 00:37:12 +00:00
{
2008-06-25 12:16:17 +00:00
char * str ;
int str_len ;
1999-04-17 00:37:12 +00:00
2008-06-25 12:16:17 +00:00
if ( zend_parse_parameters ( ZEND_NUM_ARGS ( ) TSRMLS_CC , " s " , & str , & str_len ) = = FAILURE ) {
return ;
1999-04-17 00:37:12 +00:00
}
2008-06-25 12:16:17 +00:00
RETURN_LONG ( ( unsigned char ) str [ 0 ] ) ;
1999-04-17 00:37:12 +00:00
}
/* }}} */
/* {{{ proto string chr(int ascii)
2001-09-04 10:44:28 +00:00
Converts ASCII code to a character */
1999-06-15 21:51:00 +00:00
PHP_FUNCTION ( chr )
1999-04-17 00:37:12 +00:00
{
2008-01-22 01:34:24 +00:00
long c ;
1999-04-17 00:37:12 +00:00
char temp [ 2 ] ;
2008-01-22 01:34:24 +00:00
2008-01-25 01:31:10 +00:00
if ( ZEND_NUM_ARGS ( ) ! = 1 ) {
WRONG_PARAM_COUNT ;
1999-04-17 00:37:12 +00:00
}
2008-01-25 01:31:10 +00:00
if ( zend_parse_parameters_ex ( ZEND_PARSE_PARAMS_QUIET , ZEND_NUM_ARGS ( ) TSRMLS_CC , " l " , & c ) = = FAILURE ) {
c = 0 ;
}
2008-01-22 01:34:24 +00:00
temp [ 0 ] = ( char ) c ;
temp [ 1 ] = ' \0 ' ;
2001-09-04 06:18:11 +00:00
2008-01-22 01:34:24 +00:00
RETURN_STRINGL ( temp , 1 , 1 ) ;
1999-04-17 00:37:12 +00:00
}
/* }}} */
2008-01-16 03:11:26 +00:00
/* {{{ php_ucfirst
Uppercase the first character of the word in a native string */
static void php_ucfirst ( char * str )
{
register char * r ;
r = str ;
* r = toupper ( ( unsigned char ) * r ) ;
}
/* }}} */
1999-08-09 20:52:58 +00:00
/* {{{ proto string ucfirst(string str)
2001-09-04 10:44:28 +00:00
Makes a string ' s first character uppercase */
1999-06-15 21:51:00 +00:00
PHP_FUNCTION ( ucfirst )
1999-04-17 00:37:12 +00:00
{
2008-01-16 03:11:26 +00:00
char * str ;
int str_len ;
1999-04-17 00:37:12 +00:00
2008-01-16 03:11:26 +00:00
if ( zend_parse_parameters ( ZEND_NUM_ARGS ( ) TSRMLS_CC , " s " , & str , & str_len ) = = FAILURE ) {
return ;
1999-04-17 00:37:12 +00:00
}
2008-01-16 03:11:26 +00:00
if ( ! str_len ) {
2002-06-17 11:37:49 +00:00
RETURN_EMPTY_STRING ( ) ;
1999-04-17 00:37:12 +00:00
}
1999-11-14 17:20:56 +00:00
2008-01-16 03:11:26 +00:00
ZVAL_STRINGL ( return_value , str , str_len , 1 ) ;
php_ucfirst ( Z_STRVAL_P ( return_value ) ) ;
1999-04-17 00:37:12 +00:00
}
/* }}} */
2008-01-19 19:27:22 +00:00
/* {{{
Lowercase the first character of the word in a native string */
static void php_lcfirst ( char * str )
{
register char * r ;
r = str ;
* r = tolower ( ( unsigned char ) * r ) ;
}
/* }}} */
/* {{{ proto string ucfirst(string str)
Make a string ' s first character lowercase */
PHP_FUNCTION ( lcfirst )
{
char * str ;
int str_len ;
if ( zend_parse_parameters ( ZEND_NUM_ARGS ( ) TSRMLS_CC , " s " , & str , & str_len ) = = FAILURE ) {
return ;
}
if ( ! str_len ) {
RETURN_EMPTY_STRING ( ) ;
}
ZVAL_STRINGL ( return_value , str , str_len , 1 ) ;
php_lcfirst ( Z_STRVAL_P ( return_value ) ) ;
}
/* }}} */
1999-04-17 00:37:12 +00:00
/* {{{ proto string ucwords(string str)
Uppercase the first character of every word in a string */
1999-06-15 21:51:00 +00:00
PHP_FUNCTION ( ucwords )
1999-04-17 00:37:12 +00:00
{
2008-06-25 12:16:17 +00:00
char * str ;
2000-06-01 14:18:45 +00:00
register char * r , * r_end ;
2008-06-25 12:16:17 +00:00
int str_len ;
1999-04-17 00:37:12 +00:00
2008-06-25 12:16:17 +00:00
if ( zend_parse_parameters ( ZEND_NUM_ARGS ( ) TSRMLS_CC , " s " , & str , & str_len ) = = FAILURE ) {
return ;
1999-04-17 00:37:12 +00:00
}
2008-06-25 12:16:17 +00:00
if ( ! str_len ) {
2002-06-17 11:37:49 +00:00
RETURN_EMPTY_STRING ( ) ;
1999-04-17 00:37:12 +00:00
}
2000-06-01 10:07:44 +00:00
2008-06-25 12:16:17 +00:00
ZVAL_STRINGL ( return_value , str , str_len , 1 ) ;
2001-09-04 06:18:11 +00:00
r = Z_STRVAL_P ( return_value ) ;
* r = toupper ( ( unsigned char ) * r ) ;
for ( r_end = r + Z_STRLEN_P ( return_value ) - 1 ; r < r_end ; ) {
2003-02-18 18:11:34 +00:00
if ( isspace ( ( int ) * ( unsigned char * ) r + + ) ) {
2001-09-04 06:18:11 +00:00
* r = toupper ( ( unsigned char ) * r ) ;
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
}
1999-04-17 00:37:12 +00:00
}
}
/* }}} */
2001-06-05 13:12:10 +00:00
/* {{{ php_strtr
*/
2003-02-08 15:26:17 +00:00
PHPAPI char * php_strtr ( char * str , int len , char * str_from , char * str_to , int trlen )
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
{
int i ;
unsigned char xlat [ 256 ] ;
if ( ( trlen < 1 ) | | ( len < 1 ) ) {
2000-02-08 22:21:43 +00:00
return str ;
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
}
for ( i = 0 ; i < 256 ; xlat [ i ] = i , i + + ) ;
for ( i = 0 ; i < trlen ; i + + ) {
xlat [ ( unsigned char ) str_from [ i ] ] = str_to [ i ] ;
}
for ( i = 0 ; i < len ; i + + ) {
2000-02-08 22:21:43 +00:00
str [ i ] = xlat [ ( unsigned char ) str [ i ] ] ;
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
}
2000-02-08 22:21:43 +00:00
return str ;
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
}
2001-06-05 13:12:10 +00:00
/* }}} */
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
2001-06-05 13:12:10 +00:00
/* {{{ php_strtr_array
*/
2001-08-11 17:03:37 +00:00
static void php_strtr_array ( zval * return_value , char * str , int slen , HashTable * hash )
1999-11-20 15:53:18 +00:00
{
2001-09-04 06:18:11 +00:00
zval * * entry ;
char * string_key ;
uint string_key_len ;
1999-11-20 15:53:18 +00:00
zval * * trans ;
2001-09-04 06:18:11 +00:00
zval ctmp ;
1999-11-20 15:53:18 +00:00
ulong num_key ;
int minlen = 128 * 1024 ;
2000-10-12 01:26:26 +00:00
int maxlen = 0 , pos , len , found ;
char * key ;
2000-06-18 10:37:01 +00:00
HashPosition hpos ;
2000-10-12 01:26:26 +00:00
smart_str result = { 0 } ;
2004-03-18 09:48:37 +00:00
HashTable tmp_hash ;
1999-11-20 15:53:18 +00:00
2006-10-03 17:41:47 +00:00
zend_hash_init ( & tmp_hash , zend_hash_num_elements ( hash ) , NULL , NULL , 0 ) ;
2000-06-18 10:37:01 +00:00
zend_hash_internal_pointer_reset_ex ( hash , & hpos ) ;
while ( zend_hash_get_current_data_ex ( hash , ( void * * ) & entry , & hpos ) = = SUCCESS ) {
2001-09-04 06:18:11 +00:00
switch ( zend_hash_get_current_key_ex ( hash , & string_key , & string_key_len , & num_key , 0 , & hpos ) ) {
2003-02-08 15:26:17 +00:00
case HASH_KEY_IS_STRING :
len = string_key_len - 1 ;
2003-09-20 16:10:49 +00:00
if ( len < 1 ) {
2004-03-18 09:48:37 +00:00
zend_hash_destroy ( & tmp_hash ) ;
2003-09-20 16:10:49 +00:00
RETURN_FALSE ;
}
2004-03-18 09:48:37 +00:00
zend_hash_add ( & tmp_hash , string_key , string_key_len , entry , sizeof ( zval * ) , NULL ) ;
2003-02-08 15:26:17 +00:00
if ( len > maxlen ) {
maxlen = len ;
}
if ( len < minlen ) {
minlen = len ;
}
break ;
1999-11-20 15:53:18 +00:00
2003-02-08 15:26:17 +00:00
case HASH_KEY_IS_LONG :
Z_TYPE ( ctmp ) = IS_LONG ;
Z_LVAL ( ctmp ) = num_key ;
1999-11-20 15:53:18 +00:00
2003-02-08 15:26:17 +00:00
convert_to_string ( & ctmp ) ;
len = Z_STRLEN ( ctmp ) ;
2004-03-18 09:48:37 +00:00
zend_hash_add ( & tmp_hash , Z_STRVAL ( ctmp ) , len + 1 , entry , sizeof ( zval * ) , NULL ) ;
2003-02-08 15:26:17 +00:00
zval_dtor ( & ctmp ) ;
1999-11-20 15:53:18 +00:00
2003-02-08 15:26:17 +00:00
if ( len > maxlen ) {
maxlen = len ;
}
if ( len < minlen ) {
minlen = len ;
}
break ;
1999-11-20 15:53:18 +00:00
}
2000-06-18 10:37:01 +00:00
zend_hash_move_forward_ex ( hash , & hpos ) ;
1999-11-20 15:53:18 +00:00
}
2000-10-12 01:26:26 +00:00
1999-11-20 15:53:18 +00:00
key = emalloc ( maxlen + 1 ) ;
2000-10-12 01:26:26 +00:00
pos = 0 ;
1999-11-20 15:53:18 +00:00
while ( pos < slen ) {
if ( ( pos + maxlen ) > slen ) {
maxlen = slen - pos ;
}
2001-09-04 06:18:11 +00:00
1999-11-20 15:53:18 +00:00
found = 0 ;
2001-08-11 17:03:37 +00:00
memcpy ( key , str + pos , maxlen ) ;
1999-11-20 15:53:18 +00:00
for ( len = maxlen ; len > = minlen ; len - - ) {
2001-09-04 06:18:11 +00:00
key [ len ] = 0 ;
1999-11-20 15:53:18 +00:00
2004-03-18 09:48:37 +00:00
if ( zend_hash_find ( & tmp_hash , key , len + 1 , ( void * * ) & trans ) = = SUCCESS ) {
1999-11-20 15:53:18 +00:00
char * tval ;
int tlen ;
zval tmp ;
2001-09-04 06:18:11 +00:00
if ( Z_TYPE_PP ( trans ) ! = IS_STRING ) {
1999-11-20 15:53:18 +00:00
tmp = * * trans ;
zval_copy_ctor ( & tmp ) ;
convert_to_string ( & tmp ) ;
2001-09-04 06:18:11 +00:00
tval = Z_STRVAL ( tmp ) ;
tlen = Z_STRLEN ( tmp ) ;
1999-11-20 15:53:18 +00:00
} else {
2001-09-04 06:18:11 +00:00
tval = Z_STRVAL_PP ( trans ) ;
tlen = Z_STRLEN_PP ( trans ) ;
1999-11-20 15:53:18 +00:00
}
2000-10-12 01:26:26 +00:00
smart_str_appendl ( & result , tval , tlen ) ;
1999-11-20 15:53:18 +00:00
pos + = len ;
found = 1 ;
2001-09-04 06:18:11 +00:00
if ( Z_TYPE_PP ( trans ) ! = IS_STRING ) {
1999-11-20 15:53:18 +00:00
zval_dtor ( & tmp ) ;
}
break ;
}
}
if ( ! found ) {
2000-10-12 01:26:26 +00:00
smart_str_appendc ( & result , str [ pos + + ] ) ;
1999-11-20 15:53:18 +00:00
}
}
efree ( key ) ;
2004-03-18 09:48:37 +00:00
zend_hash_destroy ( & tmp_hash ) ;
2000-10-12 01:26:26 +00:00
smart_str_0 ( & result ) ;
2001-08-11 17:03:37 +00:00
RETVAL_STRINGL ( result . c , result . len , 0 ) ;
1999-11-20 15:53:18 +00:00
}
2001-06-05 13:12:10 +00:00
/* }}} */
1999-11-20 15:53:18 +00:00
2006-06-26 18:48:56 +00:00
/* {{{ proto string strtr(string str, string from[, string to])
2001-09-04 10:44:28 +00:00
Translates characters in str using given translation tables */
1999-06-15 21:51:00 +00:00
PHP_FUNCTION ( strtr )
2003-02-08 15:26:17 +00:00
{
2008-06-25 12:16:17 +00:00
zval * * from ;
char * str , * to ;
int str_len , to_len ;
2000-06-05 19:47:54 +00:00
int ac = ZEND_NUM_ARGS ( ) ;
2008-06-25 12:16:17 +00:00
if ( zend_parse_parameters ( ZEND_NUM_ARGS ( ) TSRMLS_CC , " sZ|s " , & str , & str_len , & from , & to , & to_len ) = = FAILURE ) {
return ;
1999-04-17 00:37:12 +00:00
}
1999-11-20 15:53:18 +00:00
2001-09-25 21:58:48 +00:00
if ( ac = = 2 & & Z_TYPE_PP ( from ) ! = IS_ARRAY ) {
2007-09-30 05:40:23 +00:00
php_error_docref ( NULL TSRMLS_CC , E_WARNING , " The second argument is not an array " ) ;
1999-11-20 15:53:18 +00:00
RETURN_FALSE ;
}
2000-12-13 10:22:36 +00:00
/* shortcut for empty string */
2008-06-25 12:16:17 +00:00
if ( str_len = = 0 ) {
2000-12-13 10:22:36 +00:00
RETURN_EMPTY_STRING ( ) ;
}
1999-11-20 15:53:18 +00:00
if ( ac = = 2 ) {
2008-06-25 12:16:17 +00:00
php_strtr_array ( return_value , str , str_len , HASH_OF ( * from ) ) ;
1999-11-20 15:53:18 +00:00
} else {
convert_to_string_ex ( from ) ;
2008-06-25 12:16:17 +00:00
ZVAL_STRINGL ( return_value , str , str_len , 1 ) ;
1999-11-20 15:53:18 +00:00
2001-09-04 06:18:11 +00:00
php_strtr ( Z_STRVAL_P ( return_value ) ,
Z_STRLEN_P ( return_value ) ,
Z_STRVAL_PP ( from ) ,
2008-06-25 12:16:17 +00:00
to ,
2003-02-08 15:26:17 +00:00
MIN ( Z_STRLEN_PP ( from ) ,
2008-06-25 12:16:17 +00:00
to_len ) ) ;
1999-11-20 15:53:18 +00:00
}
1999-04-17 00:37:12 +00:00
}
/* }}} */
/* {{{ proto string strrev(string str)
Reverse a string */
1999-06-15 21:51:00 +00:00
PHP_FUNCTION ( strrev )
1999-04-17 00:37:12 +00:00
{
2008-06-25 12:16:17 +00:00
char * str ;
char * e , * n , * p ;
int str_len ;
1999-04-17 00:37:12 +00:00
2008-06-25 12:16:17 +00:00
if ( zend_parse_parameters ( ZEND_NUM_ARGS ( ) TSRMLS_CC , " s " , & str , & str_len ) = = FAILURE ) {
return ;
1999-04-17 00:37:12 +00:00
}
2008-06-25 12:16:17 +00:00
n = emalloc ( str_len + 1 ) ;
2002-10-09 13:37:02 +00:00
p = n ;
2008-06-25 12:16:17 +00:00
e = str + str_len ;
1999-04-17 00:37:12 +00:00
2008-06-25 12:16:17 +00:00
while ( - - e > = str ) {
2002-10-09 13:37:02 +00:00
* p + + = * e ;
1999-04-17 00:37:12 +00:00
}
2002-10-09 13:37:02 +00:00
* p = ' \0 ' ;
2008-06-25 12:16:17 +00:00
RETVAL_STRINGL ( n , str_len , 0 ) ;
1999-04-17 00:37:12 +00:00
}
/* }}} */
2001-06-05 13:12:10 +00:00
/* {{{ php_similar_str
*/
2003-02-08 15:26:17 +00:00
static void php_similar_str ( const char * txt1 , int len1 , const char * txt2 , int len2 , int * pos1 , int * pos2 , int * max )
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
{
char * p , * q ;
char * end1 = ( char * ) txt1 + len1 ;
char * end2 = ( char * ) txt2 + len2 ;
int l ;
* max = 0 ;
for ( p = ( char * ) txt1 ; p < end1 ; p + + ) {
for ( q = ( char * ) txt2 ; q < end2 ; q + + ) {
2002-10-10 18:41:24 +00:00
for ( l = 0 ; ( p + l < end1 ) & & ( q + l < end2 ) & & ( p [ l ] = = q [ l ] ) ; l + + ) ;
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
if ( l > * max ) {
* max = l ;
* pos1 = p - txt1 ;
* pos2 = q - txt2 ;
}
}
}
}
2001-06-05 13:12:10 +00:00
/* }}} */
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
2001-06-05 13:12:10 +00:00
/* {{{ php_similar_char
*/
2002-09-11 14:40:52 +00:00
static int php_similar_char ( const char * txt1 , int len1 , const char * txt2 , int len2 )
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
{
int sum ;
int pos1 , pos2 , max ;
1999-10-16 16:35:20 +00:00
php_similar_str ( txt1 , len1 , txt2 , len2 , & pos1 , & pos2 , & max ) ;
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
if ( ( sum = max ) ) {
2003-02-08 15:26:17 +00:00
if ( pos1 & & pos2 ) {
sum + = php_similar_char ( txt1 , pos1 ,
txt2 , pos2 ) ;
}
if ( ( pos1 + max < len1 ) & & ( pos2 + max < len2 ) ) {
1999-10-16 16:35:20 +00:00
sum + = php_similar_char ( txt1 + pos1 + max , len1 - pos1 - max ,
txt2 + pos2 + max , len2 - pos2 - max ) ;
2003-02-08 15:26:17 +00:00
}
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
}
2001-09-04 06:18:11 +00:00
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
return sum ;
}
2001-06-05 13:12:10 +00:00
/* }}} */
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
2001-09-21 21:59:27 +00:00
/* {{{ proto int similar_text(string str1, string str2 [, float percent])
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
Calculates the similarity between two strings */
PHP_FUNCTION ( similar_text )
{
2008-06-25 12:16:17 +00:00
char * t1 , * t2 ;
zval * * percent ;
2000-06-05 19:47:54 +00:00
int ac = ZEND_NUM_ARGS ( ) ;
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
int sim ;
2008-06-25 12:16:17 +00:00
int t1_len , t2_len ;
if ( zend_parse_parameters ( ZEND_NUM_ARGS ( ) TSRMLS_CC , " ss|Z " , & t1 , & t1_len , & t2 , & t2_len , & percent ) = = FAILURE ) {
return ;
}
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
if ( ac > 2 ) {
1999-09-25 11:55:42 +00:00
convert_to_double_ex ( percent ) ;
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
}
2008-06-25 12:16:17 +00:00
if ( t1_len + t2_len = = 0 ) {
2002-09-11 14:40:52 +00:00
if ( ac > 2 ) {
2001-09-04 06:18:11 +00:00
Z_DVAL_PP ( percent ) = 0 ;
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
}
2001-09-04 06:18:11 +00:00
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
RETURN_LONG ( 0 ) ;
}
2008-06-25 12:16:17 +00:00
sim = php_similar_char ( t1 , t1_len , t2 , t2_len ) ;
2002-09-11 14:40:52 +00:00
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
if ( ac > 2 ) {
2008-06-25 12:16:17 +00:00
Z_DVAL_PP ( percent ) = sim * 200.0 / ( t1_len + t2_len ) ;
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
}
2001-09-04 06:18:11 +00:00
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
RETURN_LONG ( sim ) ;
}
/* }}} */
1999-04-17 00:37:12 +00:00
2001-06-05 13:12:10 +00:00
/* {{{ php_stripslashes
*
* be careful , this edits the string in - place */
2001-08-06 03:50:52 +00:00
PHPAPI void php_stripslashes ( char * str , int * len TSRMLS_DC )
1999-04-17 00:37:12 +00:00
{
char * s , * t ;
int l ;
if ( len ! = NULL ) {
l = * len ;
} else {
2000-02-08 22:21:43 +00:00
l = strlen ( str ) ;
1999-04-17 00:37:12 +00:00
}
2000-02-08 22:21:43 +00:00
s = str ;
t = str ;
2002-03-27 20:20:57 +00:00
if ( PG ( magic_quotes_sybase ) ) {
2002-05-16 14:41:15 +00:00
while ( l > 0 ) {
2002-10-02 17:56:04 +00:00
if ( * t = = ' \' ' ) {
if ( ( l > 0 ) & & ( t [ 1 ] = = ' \' ' ) ) {
2002-03-27 20:20:57 +00:00
t + + ;
2003-02-08 15:26:17 +00:00
if ( len ! = NULL ) {
2002-03-27 20:20:57 +00:00
( * len ) - - ;
2003-02-08 15:26:17 +00:00
}
2002-03-27 20:20:57 +00:00
l - - ;
}
2002-06-18 11:51:06 +00:00
* s + + = * t + + ;
2003-04-01 12:46:01 +00:00
} else if ( * t = = ' \\ ' & & t [ 1 ] = = ' 0 ' & & l > 0 ) {
* s + + = ' \0 ' ;
t + = 2 ;
2003-03-31 18:56:41 +00:00
if ( len ! = NULL ) {
( * len ) - - ;
}
l - - ;
2002-06-18 11:51:06 +00:00
} else {
* s + + = * t + + ;
}
2002-03-27 20:20:57 +00:00
l - - ;
}
* s = ' \0 ' ;
return ;
}
1999-04-17 00:37:12 +00:00
while ( l > 0 ) {
2002-06-18 11:51:06 +00:00
if ( * t = = ' \\ ' ) {
1999-04-17 00:37:12 +00:00
t + + ; /* skip the slash */
2003-02-08 15:26:17 +00:00
if ( len ! = NULL ) {
1999-04-17 00:37:12 +00:00
( * len ) - - ;
2003-02-08 15:26:17 +00:00
}
1999-04-17 00:37:12 +00:00
l - - ;
if ( l > 0 ) {
2002-10-02 17:56:04 +00:00
if ( * t = = ' 0 ' ) {
1999-04-17 00:37:12 +00:00
* s + + = ' \0 ' ;
t + + ;
} else {
* s + + = * t + + ; /* preserve the next character */
}
l - - ;
}
} else {
2003-03-31 12:08:31 +00:00
* s + + = * t + + ;
1999-04-17 00:37:12 +00:00
l - - ;
}
}
if ( s ! = t ) {
* s = ' \0 ' ;
}
}
2001-06-05 13:12:10 +00:00
/* }}} */
1999-04-17 00:37:12 +00:00
1999-09-05 20:55:13 +00:00
/* {{{ proto string addcslashes(string str, string charlist)
2001-09-04 10:44:28 +00:00
Escapes all chars mentioned in charlist with backslash . It creates octal representations if asked to backslash characters with 8 th bit set or with ASCII < 32 ( except ' \n ' , ' \r ' , ' \t ' etc . . . ) */
1999-09-05 20:55:13 +00:00
PHP_FUNCTION ( addcslashes )
{
2008-06-25 12:16:17 +00:00
char * str , * what ;
int str_len , what_len ;
1999-09-05 20:55:13 +00:00
2008-06-25 12:16:17 +00:00
if ( zend_parse_parameters ( ZEND_NUM_ARGS ( ) TSRMLS_CC , " ss " , & str , & str_len , & what , & what_len ) = = FAILURE ) {
return ;
1999-09-05 20:55:13 +00:00
}
2000-09-17 09:15:48 +00:00
2008-06-25 12:16:17 +00:00
if ( str_len = = 0 ) {
2000-09-17 09:15:48 +00:00
RETURN_EMPTY_STRING ( ) ;
}
2008-06-25 12:16:17 +00:00
if ( what_len = = 0 ) {
RETURN_STRINGL ( str , str_len , 1 ) ;
2000-09-17 09:15:48 +00:00
}
2008-06-25 12:16:17 +00:00
Z_STRVAL_P ( return_value ) = php_addcslashes ( str , str_len , & Z_STRLEN_P ( return_value ) , 0 , what , what_len TSRMLS_CC ) ;
2007-03-26 10:25:41 +00:00
RETURN_STRINGL ( Z_STRVAL_P ( return_value ) , Z_STRLEN_P ( return_value ) , 0 ) ;
1999-09-05 20:55:13 +00:00
}
/* }}} */
1999-04-17 00:37:12 +00:00
/* {{{ proto string addslashes(string str)
2001-09-04 10:44:28 +00:00
Escapes single quote , double quotes and backslash characters in a string with backslashes */
1999-06-15 21:51:00 +00:00
PHP_FUNCTION ( addslashes )
1999-04-17 00:37:12 +00:00
{
2008-06-25 12:16:17 +00:00
char * str ;
int str_len ;
if ( zend_parse_parameters ( ZEND_NUM_ARGS ( ) TSRMLS_CC , " s " , & str , & str_len ) = = FAILURE ) {
return ;
1999-04-17 00:37:12 +00:00
}
2000-09-17 09:15:48 +00:00
2008-06-25 12:16:17 +00:00
if ( str_len = = 0 ) {
2000-09-17 09:15:48 +00:00
RETURN_EMPTY_STRING ( ) ;
}
2008-06-25 12:16:17 +00:00
RETURN_STRING ( php_addslashes ( str ,
str_len ,
2001-09-04 06:18:11 +00:00
& Z_STRLEN_P ( return_value ) , 0
2002-09-11 14:40:52 +00:00
TSRMLS_CC ) , 0 ) ;
1999-04-17 00:37:12 +00:00
}
/* }}} */
1999-09-05 20:55:13 +00:00
/* {{{ proto string stripcslashes(string str)
2001-09-04 10:44:28 +00:00
Strips backslashes from a string . Uses C - style conventions */
1999-09-05 20:55:13 +00:00
PHP_FUNCTION ( stripcslashes )
{
2008-06-25 12:16:17 +00:00
char * str ;
int str_len ;
1999-09-05 20:55:13 +00:00
2008-06-25 12:16:17 +00:00
if ( zend_parse_parameters ( ZEND_NUM_ARGS ( ) TSRMLS_CC , " s " , & str , & str_len ) = = FAILURE ) {
return ;
1999-09-05 20:55:13 +00:00
}
2008-06-25 12:16:17 +00:00
ZVAL_STRINGL ( return_value , str , str_len , 1 ) ;
2001-09-04 06:18:11 +00:00
php_stripcslashes ( Z_STRVAL_P ( return_value ) , & Z_STRLEN_P ( return_value ) ) ;
1999-09-05 20:55:13 +00:00
}
/* }}} */
1999-04-17 00:37:12 +00:00
/* {{{ proto string stripslashes(string str)
2001-09-04 10:44:28 +00:00
Strips backslashes from a string */
1999-06-15 21:51:00 +00:00
PHP_FUNCTION ( stripslashes )
1999-04-17 00:37:12 +00:00
{
2008-06-25 12:16:17 +00:00
char * str ;
int str_len ;
1999-04-17 00:37:12 +00:00
2008-06-25 12:16:17 +00:00
if ( zend_parse_parameters ( ZEND_NUM_ARGS ( ) TSRMLS_CC , " s " , & str , & str_len ) = = FAILURE ) {
return ;
1999-04-17 00:37:12 +00:00
}
2008-06-25 12:16:17 +00:00
ZVAL_STRINGL ( return_value , str , str_len , 1 ) ;
2001-08-06 03:50:52 +00:00
php_stripslashes ( Z_STRVAL_P ( return_value ) , & Z_STRLEN_P ( return_value ) TSRMLS_CC ) ;
1999-04-17 00:37:12 +00:00
}
/* }}} */
# ifndef HAVE_STRERROR
2001-06-05 13:12:10 +00:00
/* {{{ php_strerror
*/
2000-02-10 19:41:21 +00:00
char * php_strerror ( int errnum )
1999-04-17 00:37:12 +00:00
{
extern int sys_nerr ;
extern char * sys_errlist [ ] ;
2001-07-28 11:36:37 +00:00
TSRMLS_FETCH ( ) ;
1999-04-17 00:37:12 +00:00
2003-02-08 15:26:17 +00:00
if ( ( unsigned int ) errnum < sys_nerr ) {
return ( sys_errlist [ errnum ] ) ;
}
2007-02-24 02:17:47 +00:00
( void ) snprintf ( BG ( str_ebuf ) , sizeof ( php_basic_globals . str_ebuf ) , " Unknown error: %d " , errnum ) ;
1999-11-28 00:31:02 +00:00
return ( BG ( str_ebuf ) ) ;
1999-04-17 00:37:12 +00:00
}
2001-06-05 13:12:10 +00:00
/* }}} */
1999-04-17 00:37:12 +00:00
# endif
2001-06-05 13:12:10 +00:00
/* {{{ php_stripcslashes
*/
1999-09-05 20:55:13 +00:00
PHPAPI void php_stripcslashes ( char * str , int * len )
{
2001-08-11 17:03:37 +00:00
char * source , * target , * end ;
1999-09-05 20:55:13 +00:00
int nlen = * len , i ;
char numtmp [ 4 ] ;
2002-10-02 17:56:04 +00:00
for ( source = str , end = str + nlen , target = str ; source < end ; source + + ) {
if ( * source = = ' \\ ' & & source + 1 < end ) {
1999-09-05 20:55:13 +00:00
source + + ;
switch ( * source ) {
2003-02-08 15:26:17 +00:00
case ' n ' : * target + + = ' \n ' ; nlen - - ; break ;
case ' r ' : * target + + = ' \r ' ; nlen - - ; break ;
case ' a ' : * target + + = ' \a ' ; nlen - - ; break ;
case ' t ' : * target + + = ' \t ' ; nlen - - ; break ;
case ' v ' : * target + + = ' \v ' ; nlen - - ; break ;
case ' b ' : * target + + = ' \b ' ; nlen - - ; break ;
case ' f ' : * target + + = ' \f ' ; nlen - - ; break ;
1999-09-05 20:55:13 +00:00
case ' \\ ' : * target + + = ' \\ ' ; nlen - - ; break ;
2003-02-08 15:26:17 +00:00
case ' x ' :
if ( source + 1 < end & & isxdigit ( ( int ) ( * ( source + 1 ) ) ) ) {
1999-09-05 20:55:13 +00:00
numtmp [ 0 ] = * + + source ;
2002-10-02 17:56:04 +00:00
if ( source + 1 < end & & isxdigit ( ( int ) ( * ( source + 1 ) ) ) ) {
1999-09-05 20:55:13 +00:00
numtmp [ 1 ] = * + + source ;
numtmp [ 2 ] = ' \0 ' ;
nlen - = 3 ;
} else {
numtmp [ 1 ] = ' \0 ' ;
nlen - = 2 ;
}
1999-09-07 20:29:31 +00:00
* target + + = ( char ) strtol ( numtmp , NULL , 16 ) ;
1999-09-05 20:55:13 +00:00
break ;
}
/* break is left intentionally */
2003-02-08 15:26:17 +00:00
default :
i = 0 ;
2002-10-02 17:56:04 +00:00
while ( source < end & & * source > = ' 0 ' & & * source < = ' 7 ' & & i < 3 ) {
1999-09-05 20:55:13 +00:00
numtmp [ i + + ] = * source + + ;
}
if ( i ) {
numtmp [ i ] = ' \0 ' ;
1999-09-07 20:29:31 +00:00
* target + + = ( char ) strtol ( numtmp , NULL , 8 ) ;
1999-09-05 20:55:13 +00:00
nlen - = i ;
source - - ;
} else {
* target + + = * source ;
2000-06-09 13:58:10 +00:00
nlen - - ;
1999-09-05 20:55:13 +00:00
}
}
} else {
* target + + = * source ;
}
}
2000-07-17 10:22:30 +00:00
2002-10-02 17:56:04 +00:00
if ( nlen ! = 0 ) {
2000-07-17 10:22:30 +00:00
* target = ' \0 ' ;
}
1999-09-05 20:55:13 +00:00
* len = nlen ;
}
2001-06-05 13:12:10 +00:00
/* }}} */
1999-09-05 20:55:13 +00:00
2001-06-05 13:12:10 +00:00
/* {{{ php_addcslashes
*/
2001-08-06 03:50:52 +00:00
PHPAPI char * php_addcslashes ( char * str , int length , int * new_length , int should_free , char * what , int wlength TSRMLS_DC )
1999-09-05 00:55:48 +00:00
{
char flags [ 256 ] ;
2003-08-11 23:16:54 +00:00
char * new_str = safe_emalloc ( 4 , ( length ? length : ( length = strlen ( str ) ) ) , 1 ) ;
2001-08-11 17:03:37 +00:00
char * source , * target ;
1999-09-05 00:55:48 +00:00
char * end ;
char c ;
1999-09-05 20:55:13 +00:00
int newlen ;
1999-09-05 00:55:48 +00:00
if ( ! wlength ) {
wlength = strlen ( what ) ;
}
2001-08-05 23:08:19 +00:00
php_charmask ( what , wlength , flags TSRMLS_CC ) ;
1999-09-05 00:55:48 +00:00
2007-05-24 20:53:05 +00:00
for ( source = str , end = source + length , target = new_str ; source < end ; source + + ) {
2007-05-24 21:29:27 +00:00
c = * source ;
1999-09-05 20:55:13 +00:00
if ( flags [ ( unsigned char ) c ] ) {
2003-02-08 15:26:17 +00:00
if ( ( unsigned char ) c < 32 | | ( unsigned char ) c > 126 ) {
1999-09-05 00:55:48 +00:00
* target + + = ' \\ ' ;
switch ( c ) {
case ' \n ' : * target + + = ' n ' ; break ;
case ' \t ' : * target + + = ' t ' ; break ;
case ' \r ' : * target + + = ' r ' ; break ;
1999-09-05 20:55:13 +00:00
case ' \a ' : * target + + = ' a ' ; break ;
case ' \v ' : * target + + = ' v ' ; break ;
case ' \b ' : * target + + = ' b ' ; break ;
case ' \f ' : * target + + = ' f ' ; break ;
2003-02-08 15:26:17 +00:00
default : target + = sprintf ( target , " %03o " , ( unsigned char ) c ) ;
1999-09-05 00:55:48 +00:00
}
1999-09-05 20:55:13 +00:00
continue ;
}
* target + + = ' \\ ' ;
}
* target + + = c ;
1999-09-05 00:55:48 +00:00
}
* target = 0 ;
2003-02-08 15:26:17 +00:00
newlen = target - new_str ;
if ( target - new_str < length * 4 ) {
new_str = erealloc ( new_str , newlen + 1 ) ;
1999-09-05 20:55:13 +00:00
}
1999-09-05 00:55:48 +00:00
if ( new_length ) {
1999-09-05 20:55:13 +00:00
* new_length = newlen ;
1999-09-05 00:55:48 +00:00
}
if ( should_free ) {
STR_FREE ( str ) ;
}
return new_str ;
}
2001-06-05 13:12:10 +00:00
/* }}} */
1999-04-17 00:37:12 +00:00
2001-06-05 13:12:10 +00:00
/* {{{ php_addslashes
*/
2001-08-06 03:50:52 +00:00
PHPAPI char * php_addslashes ( char * str , int length , int * new_length , int should_free TSRMLS_DC )
2005-05-31 12:54:56 +00:00
{
return php_addslashes_ex ( str , length , new_length , should_free , 0 TSRMLS_CC ) ;
}
/* }}} */
/* {{{ php_addslashes_ex
*/
PHPAPI char * php_addslashes_ex ( char * str , int length , int * new_length , int should_free , int ignore_sybase TSRMLS_DC )
1999-04-17 00:37:12 +00:00
{
/* maximum string length, worst case situation */
2000-02-02 21:53:27 +00:00
char * new_str ;
2001-08-11 17:03:37 +00:00
char * source , * target ;
1999-04-17 00:37:12 +00:00
char * end ;
2002-10-22 18:27:56 +00:00
int local_new_length ;
if ( ! new_length ) {
new_length = & local_new_length ;
}
2000-02-02 21:53:27 +00:00
if ( ! str ) {
* new_length = 0 ;
return str ;
}
2003-08-11 23:16:54 +00:00
new_str = ( char * ) safe_emalloc ( 2 , ( length ? length : ( length = strlen ( str ) ) ) , 1 ) ;
2002-10-09 13:37:02 +00:00
source = str ;
end = source + length ;
target = new_str ;
2005-05-31 12:54:56 +00:00
if ( ! ignore_sybase & & PG ( magic_quotes_sybase ) ) {
2002-10-09 13:50:06 +00:00
while ( source < end ) {
2002-10-09 13:37:02 +00:00
switch ( * source ) {
2002-03-12 07:05:40 +00:00
case ' \0 ' :
* target + + = ' \\ ' ;
* target + + = ' 0 ' ;
break ;
case ' \' ' :
1999-04-17 00:37:12 +00:00
* target + + = ' \' ' ;
* target + + = ' \' ' ;
break ;
2002-03-12 07:05:40 +00:00
default :
2002-10-09 13:37:02 +00:00
* target + + = * source ;
break ;
2002-03-12 07:05:40 +00:00
}
2002-10-09 13:37:02 +00:00
source + + ;
2002-03-12 07:05:40 +00:00
}
2002-10-09 13:50:06 +00:00
} else {
while ( source < end ) {
switch ( * source ) {
2002-03-12 07:05:40 +00:00
case ' \0 ' :
* target + + = ' \\ ' ;
* target + + = ' 0 ' ;
break ;
case ' \' ' :
case ' \" ' :
case ' \\ ' :
* target + + = ' \\ ' ;
/* break is missing *intentionally* */
default :
2002-10-09 13:37:02 +00:00
* target + + = * source ;
break ;
2002-03-12 07:05:40 +00:00
}
2002-10-09 13:37:02 +00:00
source + + ;
1999-04-17 00:37:12 +00:00
}
}
2002-10-09 13:37:02 +00:00
1999-04-17 00:37:12 +00:00
* target = 0 ;
2002-10-22 18:27:56 +00:00
* new_length = target - new_str ;
1999-04-17 00:37:12 +00:00
if ( should_free ) {
STR_FREE ( str ) ;
}
2003-02-08 15:26:17 +00:00
new_str = ( char * ) erealloc ( new_str , * new_length + 1 ) ;
1999-04-17 00:37:12 +00:00
return new_str ;
}
2001-06-05 13:12:10 +00:00
/* }}} */
1999-04-17 00:37:12 +00:00
# define _HEB_BLOCK_TYPE_ENG 1
# define _HEB_BLOCK_TYPE_HEB 2
2003-02-08 15:26:17 +00:00
# define isheb(c) (((((unsigned char) c) >= 224) && (((unsigned char) c) <= 250)) ? 1 : 0)
# define _isblank(c) (((((unsigned char) c) == ' ' || ((unsigned char) c) == '\t')) ? 1 : 0)
# define _isnewline(c) (((((unsigned char) c) == '\n' || ((unsigned char) c) == '\r')) ? 1 : 0)
1999-04-17 00:37:12 +00:00
2003-07-25 01:03:39 +00:00
/* {{{ php_char_to_str_ex
2001-06-05 13:12:10 +00:00
*/
2003-07-25 01:03:39 +00:00
PHPAPI int php_char_to_str_ex ( char * str , uint len , char from , char * to , int to_len , zval * result , int case_sensitivity , int * replace_count )
1999-04-17 00:37:12 +00:00
{
2001-09-09 12:55:48 +00:00
int char_count = 0 ;
int replaced = 0 ;
char * source , * target , * tmp , * source_end = str + len , * tmp_end = NULL ;
2006-06-10 15:29:06 +00:00
if ( case_sensitivity ) {
char * p = str , * e = p + len ;
while ( ( p = memchr ( p , from , ( e - p ) ) ) ) {
1999-04-17 00:37:12 +00:00
char_count + + ;
2006-06-10 15:29:06 +00:00
p + + ;
}
} else {
for ( source = str ; source < source_end ; source + + ) {
if ( tolower ( * source ) = = tolower ( from ) ) {
char_count + + ;
}
1999-04-17 00:37:12 +00:00
}
}
2004-10-07 23:10:35 +00:00
if ( char_count = = 0 & & case_sensitivity ) {
2001-09-04 06:18:11 +00:00
ZVAL_STRINGL ( result , str , len , 1 ) ;
2001-09-09 12:55:48 +00:00
return 0 ;
1999-04-17 00:37:12 +00:00
}
2001-09-04 06:18:11 +00:00
Z_STRLEN_P ( result ) = len + ( char_count * ( to_len - 1 ) ) ;
2007-02-10 00:50:38 +00:00
Z_STRVAL_P ( result ) = target = safe_emalloc ( char_count , to_len , len + 1 ) ;
2001-09-04 06:18:11 +00:00
Z_TYPE_P ( result ) = IS_STRING ;
2006-06-10 15:29:06 +00:00
if ( case_sensitivity ) {
char * p = str , * e = p + len , * s = str ;
while ( ( p = memchr ( p , from , ( e - p ) ) ) ) {
memcpy ( target , s , ( p - s ) ) ;
target + = p - s ;
memcpy ( target , to , to_len ) ;
target + = to_len ;
p + + ;
s = p ;
2006-10-05 18:23:19 +00:00
if ( replace_count ) {
* replace_count + = 1 ;
}
2006-06-10 15:29:06 +00:00
}
if ( s < e ) {
memcpy ( target , s , ( e - s ) ) ;
target + = e - s ;
}
} else {
for ( source = str ; source < source_end ; source + + ) {
if ( tolower ( * source ) = = tolower ( from ) ) {
replaced = 1 ;
if ( replace_count ) {
* replace_count + = 1 ;
}
for ( tmp = to , tmp_end = tmp + to_len ; tmp < tmp_end ; tmp + + ) {
* target = * tmp ;
target + + ;
}
} else {
* target = * source ;
1999-04-17 00:37:12 +00:00
target + + ;
}
}
}
* target = 0 ;
2001-09-09 12:55:48 +00:00
return replaced ;
1999-04-17 00:37:12 +00:00
}
2001-06-05 13:12:10 +00:00
/* }}} */
1999-04-17 00:37:12 +00:00
2003-07-25 01:03:39 +00:00
/* {{{ php_char_to_str
*/
PHPAPI int php_char_to_str ( char * str , uint len , char from , char * to , int to_len , zval * result )
{
return php_char_to_str_ex ( str , len , from , to , to_len , result , 1 , NULL ) ;
}
/* }}} */
2003-01-30 05:00:41 +00:00
/* {{{ php_str_to_str_ex
*/
PHPAPI char * php_str_to_str_ex ( char * haystack , int length ,
2003-04-13 22:59:19 +00:00
char * needle , int needle_len , char * str , int str_len , int * _new_length , int case_sensitivity , int * replace_count )
2003-01-30 05:00:41 +00:00
{
char * new_str ;
2001-07-20 01:22:29 +00:00
2003-01-30 05:00:41 +00:00
if ( needle_len < length ) {
2004-02-23 20:34:59 +00:00
char * end , * haystack_dup = NULL , * needle_dup = NULL ;
2003-01-30 05:00:41 +00:00
char * e , * s , * p , * r ;
2001-07-20 01:22:29 +00:00
2003-01-30 05:00:41 +00:00
if ( needle_len = = str_len ) {
new_str = estrndup ( haystack , length ) ;
* _new_length = length ;
2001-07-20 01:22:29 +00:00
2003-01-30 05:00:41 +00:00
if ( case_sensitivity ) {
end = new_str + length ;
for ( p = new_str ; ( r = php_memnstr ( p , needle , needle_len , end ) ) ; p = r + needle_len ) {
memcpy ( r , str , str_len ) ;
2003-04-13 22:59:19 +00:00
if ( replace_count ) {
( * replace_count ) + + ;
}
2003-01-30 05:00:41 +00:00
}
} else {
haystack_dup = estrndup ( haystack , length ) ;
needle_dup = estrndup ( needle , needle_len ) ;
php_strtolower ( haystack_dup , length ) ;
php_strtolower ( needle_dup , needle_len ) ;
end = haystack_dup + length ;
for ( p = haystack_dup ; ( r = php_memnstr ( p , needle_dup , needle_len , end ) ) ; p = r + needle_len ) {
memcpy ( new_str + ( r - haystack_dup ) , str , str_len ) ;
2003-04-13 22:59:19 +00:00
if ( replace_count ) {
( * replace_count ) + + ;
}
2003-01-30 05:00:41 +00:00
}
efree ( haystack_dup ) ;
efree ( needle_dup ) ;
}
return new_str ;
} else {
2004-03-26 19:23:42 +00:00
if ( ! case_sensitivity ) {
haystack_dup = estrndup ( haystack , length ) ;
needle_dup = estrndup ( needle , needle_len ) ;
php_strtolower ( haystack_dup , length ) ;
php_strtolower ( needle_dup , needle_len ) ;
}
2003-01-30 05:00:41 +00:00
if ( str_len < needle_len ) {
new_str = emalloc ( length + 1 ) ;
} else {
2004-02-23 20:06:01 +00:00
int count = 0 ;
2004-02-23 20:34:59 +00:00
char * o , * n , * endp ;
2004-02-23 20:06:01 +00:00
2004-02-23 20:34:59 +00:00
if ( case_sensitivity ) {
o = haystack ;
n = needle ;
} else {
o = haystack_dup ;
n = needle_dup ;
}
endp = o + length ;
while ( ( o = php_memnstr ( o , n , needle_len , endp ) ) ) {
2004-02-23 20:06:01 +00:00
o + = needle_len ;
count + + ;
}
2004-02-23 20:13:14 +00:00
if ( count = = 0 ) {
/* Needle doesn't occur, shortcircuit the actual replacement. */
2004-02-23 20:34:59 +00:00
if ( haystack_dup ) {
efree ( haystack_dup ) ;
}
if ( needle_dup ) {
efree ( needle_dup ) ;
}
2004-02-23 20:13:14 +00:00
new_str = estrndup ( haystack , length ) ;
if ( _new_length ) {
* _new_length = length ;
}
return new_str ;
} else {
new_str = safe_emalloc ( count , str_len - needle_len , length + 1 ) ;
}
2001-07-20 01:22:29 +00:00
}
2003-01-30 05:00:41 +00:00
e = s = new_str ;
2001-07-20 01:22:29 +00:00
2003-01-30 05:00:41 +00:00
if ( case_sensitivity ) {
end = haystack + length ;
for ( p = haystack ; ( r = php_memnstr ( p , needle , needle_len , end ) ) ; p = r + needle_len ) {
memcpy ( e , p , r - p ) ;
e + = r - p ;
memcpy ( e , str , str_len ) ;
e + = str_len ;
2003-04-13 22:59:19 +00:00
if ( replace_count ) {
( * replace_count ) + + ;
}
2003-01-30 05:00:41 +00:00
}
2001-07-20 01:22:29 +00:00
2003-01-30 05:00:41 +00:00
if ( p < end ) {
memcpy ( e , p , end - p ) ;
e + = end - p ;
}
} else {
end = haystack_dup + length ;
for ( p = haystack_dup ; ( r = php_memnstr ( p , needle_dup , needle_len , end ) ) ; p = r + needle_len ) {
memcpy ( e , haystack + ( p - haystack_dup ) , r - p ) ;
e + = r - p ;
memcpy ( e , str , str_len ) ;
e + = str_len ;
2003-04-13 22:59:19 +00:00
if ( replace_count ) {
( * replace_count ) + + ;
}
2003-01-30 05:00:41 +00:00
}
2001-07-20 01:22:29 +00:00
2003-01-30 05:00:41 +00:00
if ( p < end ) {
memcpy ( e , haystack + ( p - haystack_dup ) , end - p ) ;
e + = end - p ;
}
2004-02-23 20:34:59 +00:00
}
if ( haystack_dup ) {
2003-01-30 05:00:41 +00:00
efree ( haystack_dup ) ;
2004-02-23 20:34:59 +00:00
}
if ( needle_dup ) {
2003-01-30 05:00:41 +00:00
efree ( needle_dup ) ;
}
* e = ' \0 ' ;
* _new_length = e - s ;
new_str = erealloc ( new_str , * _new_length + 1 ) ;
return new_str ;
}
} else if ( needle_len > length ) {
nothing_todo :
* _new_length = length ;
new_str = estrndup ( haystack , length ) ;
return new_str ;
} else {
2006-11-24 21:59:09 +00:00
if ( case_sensitivity & & memcmp ( haystack , needle , length ) ) {
2003-01-30 05:00:41 +00:00
goto nothing_todo ;
2006-11-24 21:59:09 +00:00
} else if ( ! case_sensitivity ) {
char * l_haystack , * l_needle ;
l_haystack = estrndup ( haystack , length ) ;
l_needle = estrndup ( needle , length ) ;
php_strtolower ( l_haystack , length ) ;
php_strtolower ( l_needle , length ) ;
if ( memcmp ( l_haystack , l_needle , length ) ) {
efree ( l_haystack ) ;
efree ( l_needle ) ;
goto nothing_todo ;
2003-04-13 22:59:19 +00:00
}
2006-11-24 21:59:09 +00:00
efree ( l_haystack ) ;
efree ( l_needle ) ;
2003-01-30 05:00:41 +00:00
}
2006-11-24 21:59:09 +00:00
* _new_length = str_len ;
new_str = estrndup ( str , str_len ) ;
if ( replace_count ) {
( * replace_count ) + + ;
}
return new_str ;
2003-01-30 05:00:41 +00:00
}
2001-07-20 01:22:29 +00:00
}
/* }}} */
2001-06-05 13:12:10 +00:00
/* {{{ php_str_to_str
*/
1999-10-15 20:04:31 +00:00
PHPAPI char * php_str_to_str ( char * haystack , int length ,
1999-04-17 00:37:12 +00:00
char * needle , int needle_len , char * str , int str_len , int * _new_length )
{
2003-04-13 22:59:19 +00:00
return php_str_to_str_ex ( haystack , length , needle , needle_len , str , str_len , _new_length , 1 , NULL ) ;
2003-01-30 05:00:41 +00:00
}
2007-06-05 13:35:26 +00:00
/* }}} */
1999-04-17 00:37:12 +00:00
2001-06-05 13:12:10 +00:00
/* {{{ php_str_replace_in_subject
*/
2003-04-13 22:59:19 +00:00
static void php_str_replace_in_subject ( zval * search , zval * replace , zval * * subject , zval * result , int case_sensitivity , int * replace_count )
2001-01-22 21:39:55 +00:00
{
zval * * search_entry ,
* * replace_entry = NULL ,
temp_result ;
char * replace_value = NULL ;
int replace_len = 0 ;
/* Make sure we're dealing with strings. */
convert_to_string_ex ( subject ) ;
Z_TYPE_P ( result ) = IS_STRING ;
if ( Z_STRLEN_PP ( subject ) = = 0 ) {
2004-07-19 07:19:50 +00:00
ZVAL_STRINGL ( result , " " , 0 , 1 ) ;
2001-01-22 21:39:55 +00:00
return ;
1999-04-17 00:37:12 +00:00
}
2001-01-22 21:39:55 +00:00
/* If search is an array */
if ( Z_TYPE_P ( search ) = = IS_ARRAY ) {
/* Duplicate subject string for repeated replacement */
* result = * * subject ;
zval_copy_ctor ( result ) ;
2001-11-10 23:44:04 +00:00
INIT_PZVAL ( result ) ;
2001-01-22 21:39:55 +00:00
zend_hash_internal_pointer_reset ( Z_ARRVAL_P ( search ) ) ;
1999-04-17 00:37:12 +00:00
2001-01-22 21:39:55 +00:00
if ( Z_TYPE_P ( replace ) = = IS_ARRAY ) {
zend_hash_internal_pointer_reset ( Z_ARRVAL_P ( replace ) ) ;
} else {
/* Set replacement value to the passed one */
replace_value = Z_STRVAL_P ( replace ) ;
replace_len = Z_STRLEN_P ( replace ) ;
}
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
2001-01-22 21:39:55 +00:00
/* For each entry in the search array, get the entry */
2001-09-04 06:18:11 +00:00
while ( zend_hash_get_current_data ( Z_ARRVAL_P ( search ) , ( void * * ) & search_entry ) = = SUCCESS ) {
2001-01-22 21:39:55 +00:00
/* Make sure we're dealing with strings. */
2003-02-14 18:59:50 +00:00
SEPARATE_ZVAL ( search_entry ) ;
convert_to_string ( * search_entry ) ;
2002-10-02 17:56:04 +00:00
if ( Z_STRLEN_PP ( search_entry ) = = 0 ) {
2001-01-22 21:39:55 +00:00
zend_hash_move_forward ( Z_ARRVAL_P ( search ) ) ;
2003-06-20 15:41:43 +00:00
if ( Z_TYPE_P ( replace ) = = IS_ARRAY ) {
zend_hash_move_forward ( Z_ARRVAL_P ( replace ) ) ;
}
2001-01-22 21:39:55 +00:00
continue ;
}
2001-09-04 06:18:11 +00:00
2001-01-22 21:39:55 +00:00
/* If replace is an array. */
if ( Z_TYPE_P ( replace ) = = IS_ARRAY ) {
/* Get current entry */
if ( zend_hash_get_current_data ( Z_ARRVAL_P ( replace ) , ( void * * ) & replace_entry ) = = SUCCESS ) {
/* Make sure we're dealing with strings. */
convert_to_string_ex ( replace_entry ) ;
/* Set replacement value to the one we got from array */
replace_value = Z_STRVAL_PP ( replace_entry ) ;
replace_len = Z_STRLEN_PP ( replace_entry ) ;
zend_hash_move_forward ( Z_ARRVAL_P ( replace ) ) ;
} else {
/* We've run out of replacement strings, so use an empty one. */
2004-07-19 07:19:50 +00:00
replace_value = " " ;
2001-01-22 21:39:55 +00:00
replace_len = 0 ;
}
}
2002-10-02 17:56:04 +00:00
if ( Z_STRLEN_PP ( search_entry ) = = 1 ) {
2003-07-25 01:03:39 +00:00
php_char_to_str_ex ( Z_STRVAL_P ( result ) ,
2001-01-22 21:39:55 +00:00
Z_STRLEN_P ( result ) ,
Z_STRVAL_PP ( search_entry ) [ 0 ] ,
replace_value ,
replace_len ,
2003-07-25 01:03:39 +00:00
& temp_result ,
case_sensitivity ,
replace_count ) ;
2001-01-22 21:39:55 +00:00
} else if ( Z_STRLEN_PP ( search_entry ) > 1 ) {
2003-01-30 05:00:41 +00:00
Z_STRVAL ( temp_result ) = php_str_to_str_ex ( Z_STRVAL_P ( result ) , Z_STRLEN_P ( result ) ,
Z_STRVAL_PP ( search_entry ) , Z_STRLEN_PP ( search_entry ) ,
2003-04-13 22:59:19 +00:00
replace_value , replace_len , & Z_STRLEN ( temp_result ) , case_sensitivity , replace_count ) ;
2001-01-22 21:39:55 +00:00
}
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
2001-01-22 21:39:55 +00:00
efree ( Z_STRVAL_P ( result ) ) ;
Z_STRVAL_P ( result ) = Z_STRVAL ( temp_result ) ;
Z_STRLEN_P ( result ) = Z_STRLEN ( temp_result ) ;
2001-11-10 23:44:04 +00:00
if ( Z_STRLEN_P ( result ) = = 0 ) {
return ;
}
2001-01-22 21:39:55 +00:00
zend_hash_move_forward ( Z_ARRVAL_P ( search ) ) ;
}
} else {
if ( Z_STRLEN_P ( search ) = = 1 ) {
2003-07-25 01:03:39 +00:00
php_char_to_str_ex ( Z_STRVAL_PP ( subject ) ,
2001-01-22 21:39:55 +00:00
Z_STRLEN_PP ( subject ) ,
Z_STRVAL_P ( search ) [ 0 ] ,
Z_STRVAL_P ( replace ) ,
Z_STRLEN_P ( replace ) ,
2003-07-25 01:03:39 +00:00
result ,
case_sensitivity ,
replace_count ) ;
2001-01-22 21:39:55 +00:00
} else if ( Z_STRLEN_P ( search ) > 1 ) {
2003-01-30 05:00:41 +00:00
Z_STRVAL_P ( result ) = php_str_to_str_ex ( Z_STRVAL_PP ( subject ) , Z_STRLEN_PP ( subject ) ,
Z_STRVAL_P ( search ) , Z_STRLEN_P ( search ) ,
2003-04-13 22:59:19 +00:00
Z_STRVAL_P ( replace ) , Z_STRLEN_P ( replace ) , & Z_STRLEN_P ( result ) , case_sensitivity , replace_count ) ;
2001-01-22 21:39:55 +00:00
} else {
* result = * * subject ;
zval_copy_ctor ( result ) ;
2001-11-10 23:44:04 +00:00
INIT_PZVAL ( result ) ;
2001-01-22 21:39:55 +00:00
}
1999-04-17 00:37:12 +00:00
}
2001-01-22 21:39:55 +00:00
}
2001-06-05 13:12:10 +00:00
/* }}} */
2001-01-22 21:39:55 +00:00
2003-01-30 20:09:19 +00:00
/* {{{ php_str_replace_common
*/
static void php_str_replace_common ( INTERNAL_FUNCTION_PARAMETERS , int case_sensitivity )
2001-01-22 21:39:55 +00:00
{
2003-04-13 22:59:19 +00:00
zval * * subject , * * search , * * replace , * * subject_entry , * * zcount ;
2001-01-22 21:39:55 +00:00
zval * result ;
char * string_key ;
2001-08-21 12:57:53 +00:00
uint string_key_len ;
ulong num_key ;
2003-04-13 22:59:19 +00:00
int count = 0 ;
int argc = ZEND_NUM_ARGS ( ) ;
2001-01-22 21:39:55 +00:00
2008-06-25 12:16:17 +00:00
if ( zend_parse_parameters ( ZEND_NUM_ARGS ( ) TSRMLS_CC , " ZZZ|Z " , & search , & replace , & subject , & zcount ) = = FAILURE ) {
return ;
1999-05-12 15:40:15 +00:00
}
2003-01-30 05:00:41 +00:00
SEPARATE_ZVAL ( search ) ;
SEPARATE_ZVAL ( replace ) ;
SEPARATE_ZVAL ( subject ) ;
/* Make sure we're dealing with strings and do the replacement. */
if ( Z_TYPE_PP ( search ) ! = IS_ARRAY ) {
convert_to_string_ex ( search ) ;
convert_to_string_ex ( replace ) ;
} else if ( Z_TYPE_PP ( replace ) ! = IS_ARRAY ) {
convert_to_string_ex ( replace ) ;
2001-07-20 01:22:29 +00:00
}
2003-01-30 05:00:41 +00:00
/* if subject is an array */
if ( Z_TYPE_PP ( subject ) = = IS_ARRAY ) {
array_init ( return_value ) ;
zend_hash_internal_pointer_reset ( Z_ARRVAL_PP ( subject ) ) ;
/* For each subject entry, convert it to string, then perform replacement
and add the result to the return_value array . */
while ( zend_hash_get_current_data ( Z_ARRVAL_PP ( subject ) , ( void * * ) & subject_entry ) = = SUCCESS ) {
2003-05-16 23:30:08 +00:00
if ( Z_TYPE_PP ( subject_entry ) ! = IS_ARRAY & & Z_TYPE_PP ( subject_entry ) ! = IS_OBJECT ) {
MAKE_STD_ZVAL ( result ) ;
2003-05-25 21:48:57 +00:00
SEPARATE_ZVAL ( subject_entry ) ;
2003-05-16 23:30:08 +00:00
php_str_replace_in_subject ( * search , * replace , subject_entry , result , case_sensitivity , ( argc > 3 ) ? & count : NULL ) ;
} else {
2003-09-29 02:23:40 +00:00
ALLOC_ZVAL ( result ) ;
2007-10-07 05:22:07 +00:00
Z_ADDREF_P ( * subject_entry ) ;
2003-09-29 02:23:40 +00:00
COPY_PZVAL_TO_ZVAL ( * result , * subject_entry ) ;
2003-05-16 23:30:08 +00:00
}
2003-01-30 05:00:41 +00:00
/* Add to return array */
switch ( zend_hash_get_current_key_ex ( Z_ARRVAL_PP ( subject ) , & string_key ,
& string_key_len , & num_key , 0 , NULL ) ) {
case HASH_KEY_IS_STRING :
add_assoc_zval_ex ( return_value , string_key , string_key_len , result ) ;
break ;
case HASH_KEY_IS_LONG :
add_index_zval ( return_value , num_key , result ) ;
break ;
}
zend_hash_move_forward ( Z_ARRVAL_PP ( subject ) ) ;
}
} else { /* if subject is not an array */
2003-04-13 22:59:19 +00:00
php_str_replace_in_subject ( * search , * replace , subject , return_value , case_sensitivity , ( argc > 3 ) ? & count : NULL ) ;
2003-01-30 05:00:41 +00:00
}
2003-04-13 22:59:19 +00:00
if ( argc > 3 ) {
2003-06-23 14:09:14 +00:00
zval_dtor ( * zcount ) ;
ZVAL_LONG ( * zcount , count ) ;
2003-04-13 22:59:19 +00:00
}
2003-01-30 05:00:41 +00:00
}
/* }}} */
2003-04-13 22:59:19 +00:00
/* {{{ proto mixed str_replace(mixed search, mixed replace, mixed subject [, int &replace_count])
2003-01-30 20:09:19 +00:00
Replaces all occurrences of search in haystack with replace */
PHP_FUNCTION ( str_replace )
{
php_str_replace_common ( INTERNAL_FUNCTION_PARAM_PASSTHRU , 1 ) ;
}
/* }}} */
2003-04-13 22:59:19 +00:00
/* {{{ proto mixed str_ireplace(mixed search, mixed replace, mixed subject [, int &replace_count])
2003-01-30 05:00:41 +00:00
Replaces all occurrences of search in haystack with replace / case - insensitive */
PHP_FUNCTION ( str_ireplace )
{
2003-01-30 20:09:19 +00:00
php_str_replace_common ( INTERNAL_FUNCTION_PARAM_PASSTHRU , 0 ) ;
1999-04-17 00:37:12 +00:00
}
/* }}} */
2001-06-05 13:12:10 +00:00
/* {{{ php_hebrev
*
* Converts Logical Hebrew text ( Hebrew Windows style ) to Visual text
1999-04-17 00:37:12 +00:00
* Cheers / complaints / flames - Zeev Suraski < zeev @ php . net >
*/
2001-08-11 17:03:37 +00:00
static void php_hebrev ( INTERNAL_FUNCTION_PARAMETERS , int convert_newlines )
1999-04-17 00:37:12 +00:00
{
2008-06-25 12:16:17 +00:00
char * str ;
2002-05-04 17:38:45 +00:00
char * heb_str , * tmp , * target , * broken_str ;
1999-04-17 00:37:12 +00:00
int block_start , block_end , block_type , block_length , i ;
long max_chars = 0 ;
2001-08-11 17:03:37 +00:00
int begin , end , char_count , orig_begin ;
2008-06-25 12:16:17 +00:00
int str_len ;
1999-04-17 00:37:12 +00:00
2008-06-25 12:16:17 +00:00
if ( zend_parse_parameters ( ZEND_NUM_ARGS ( ) TSRMLS_CC , " s|l " , & str , & str_len , & max_chars ) = = FAILURE ) {
return ;
1999-04-17 00:37:12 +00:00
}
2008-06-25 12:16:17 +00:00
if ( str_len = = 0 ) {
1999-04-17 00:37:12 +00:00
RETURN_FALSE ;
}
2008-06-25 12:16:17 +00:00
tmp = str ;
1999-04-17 00:37:12 +00:00
block_start = block_end = 0 ;
2008-06-25 12:16:17 +00:00
heb_str = ( char * ) emalloc ( str_len + 1 ) ;
target = heb_str + str_len ;
1999-04-17 00:37:12 +00:00
* target = 0 ;
target - - ;
block_length = 0 ;
if ( isheb ( * tmp ) ) {
block_type = _HEB_BLOCK_TYPE_HEB ;
} else {
block_type = _HEB_BLOCK_TYPE_ENG ;
}
do {
2002-10-02 17:56:04 +00:00
if ( block_type = = _HEB_BLOCK_TYPE_HEB ) {
2008-06-25 12:16:17 +00:00
while ( ( isheb ( ( int ) * ( tmp + 1 ) ) | | _isblank ( ( int ) * ( tmp + 1 ) ) | | ispunct ( ( int ) * ( tmp + 1 ) ) | | ( int ) * ( tmp + 1 ) = = ' \n ' ) & & block_end < str_len - 1 ) {
1999-04-17 00:37:12 +00:00
tmp + + ;
block_end + + ;
block_length + + ;
}
2002-10-02 17:56:04 +00:00
for ( i = block_start ; i < = block_end ; i + + ) {
2008-06-25 12:16:17 +00:00
* target = str [ i ] ;
1999-04-17 00:37:12 +00:00
switch ( * target ) {
case ' ( ' :
* target = ' ) ' ;
break ;
case ' ) ' :
* target = ' ( ' ;
break ;
2002-03-26 07:57:07 +00:00
case ' [ ' :
* target = ' ] ' ;
break ;
case ' ] ' :
* target = ' [ ' ;
break ;
case ' { ' :
* target = ' } ' ;
break ;
case ' } ' :
* target = ' { ' ;
break ;
case ' < ' :
* target = ' > ' ;
break ;
case ' > ' :
* target = ' < ' ;
break ;
case ' \\ ' :
* target = ' / ' ;
break ;
case ' / ' :
* target = ' \\ ' ;
break ;
1999-04-17 00:37:12 +00:00
default :
break ;
}
target - - ;
}
block_type = _HEB_BLOCK_TYPE_ENG ;
} else {
2008-06-25 12:16:17 +00:00
while ( ! isheb ( * ( tmp + 1 ) ) & & ( int ) * ( tmp + 1 ) ! = ' \n ' & & block_end < str_len - 1 ) {
1999-04-17 00:37:12 +00:00
tmp + + ;
block_end + + ;
block_length + + ;
}
2002-10-02 17:56:04 +00:00
while ( ( _isblank ( ( int ) * tmp ) | | ispunct ( ( int ) * tmp ) ) & & * tmp ! = ' / ' & & * tmp ! = ' - ' & & block_end > block_start ) {
1999-04-17 00:37:12 +00:00
tmp - - ;
block_end - - ;
}
2002-10-02 17:56:04 +00:00
for ( i = block_end ; i > = block_start ; i - - ) {
2008-06-25 12:16:17 +00:00
* target = str [ i ] ;
1999-04-17 00:37:12 +00:00
target - - ;
}
block_type = _HEB_BLOCK_TYPE_HEB ;
}
block_start = block_end + 1 ;
2008-06-25 12:16:17 +00:00
} while ( block_end < str_len - 1 ) ;
1999-04-17 00:37:12 +00:00
2008-06-25 12:16:17 +00:00
broken_str = ( char * ) emalloc ( str_len + 1 ) ;
begin = end = str_len - 1 ;
1999-04-17 00:37:12 +00:00
target = broken_str ;
while ( 1 ) {
char_count = 0 ;
2002-10-02 17:56:04 +00:00
while ( ( ! max_chars | | char_count < max_chars ) & & begin > 0 ) {
1999-04-17 00:37:12 +00:00
char_count + + ;
begin - - ;
2002-10-02 17:56:04 +00:00
if ( begin < = 0 | | _isnewline ( heb_str [ begin ] ) ) {
while ( begin > 0 & & _isnewline ( heb_str [ begin - 1 ] ) ) {
1999-04-17 00:37:12 +00:00
begin - - ;
char_count + + ;
}
break ;
}
}
2002-10-02 17:56:04 +00:00
if ( char_count = = max_chars ) { /* try to avoid breaking words */
1999-04-17 00:37:12 +00:00
int new_char_count = char_count , new_begin = begin ;
2002-10-02 17:56:04 +00:00
while ( new_char_count > 0 ) {
1999-04-17 00:37:12 +00:00
if ( _isblank ( heb_str [ new_begin ] ) | | _isnewline ( heb_str [ new_begin ] ) ) {
break ;
}
new_begin + + ;
new_char_count - - ;
}
2002-10-02 17:56:04 +00:00
if ( new_char_count > 0 ) {
1999-04-17 00:37:12 +00:00
char_count = new_char_count ;
begin = new_begin ;
}
}
orig_begin = begin ;
if ( _isblank ( heb_str [ begin ] ) ) {
heb_str [ begin ] = ' \n ' ;
}
2002-10-02 17:56:04 +00:00
while ( begin < = end & & _isnewline ( heb_str [ begin ] ) ) { /* skip leading newlines */
1999-04-17 00:37:12 +00:00
begin + + ;
}
2002-10-02 17:56:04 +00:00
for ( i = begin ; i < = end ; i + + ) { /* copy content */
1999-04-17 00:37:12 +00:00
* target = heb_str [ i ] ;
target + + ;
}
2002-10-02 17:56:04 +00:00
for ( i = orig_begin ; i < = end & & _isnewline ( heb_str [ i ] ) ; i + + ) {
1999-04-17 00:37:12 +00:00
* target = heb_str [ i ] ;
target + + ;
}
begin = orig_begin ;
2002-10-02 17:56:04 +00:00
if ( begin < = 0 ) {
1999-04-17 00:37:12 +00:00
* target = 0 ;
break ;
}
begin - - ;
end = begin ;
}
efree ( heb_str ) ;
if ( convert_newlines ) {
2008-06-25 12:16:17 +00:00
php_char_to_str ( broken_str , str_len , ' \n ' , " <br /> \n " , 7 , return_value ) ;
1999-04-17 00:37:12 +00:00
efree ( broken_str ) ;
} else {
2001-09-25 21:58:48 +00:00
Z_STRVAL_P ( return_value ) = broken_str ;
2008-06-25 12:16:17 +00:00
Z_STRLEN_P ( return_value ) = str_len ;
2001-09-25 21:58:48 +00:00
Z_TYPE_P ( return_value ) = IS_STRING ;
1999-04-17 00:37:12 +00:00
}
}
2001-06-05 13:12:10 +00:00
/* }}} */
1999-04-17 00:37:12 +00:00
/* {{{ proto string hebrev(string str [, int max_chars_per_line])
2001-09-04 10:44:28 +00:00
Converts logical Hebrew text to visual text */
1999-06-15 21:51:00 +00:00
PHP_FUNCTION ( hebrev )
1999-04-17 00:37:12 +00:00
{
2001-08-11 17:03:37 +00:00
php_hebrev ( INTERNAL_FUNCTION_PARAM_PASSTHRU , 0 ) ;
1999-04-17 00:37:12 +00:00
}
/* }}} */
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
/* {{{ proto string hebrevc(string str [, int max_chars_per_line])
2001-09-04 10:44:28 +00:00
Converts logical Hebrew text to visual text with newline conversion */
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
PHP_FUNCTION ( hebrevc )
1999-04-17 00:37:12 +00:00
{
2001-08-11 17:03:37 +00:00
php_hebrev ( INTERNAL_FUNCTION_PARAM_PASSTHRU , 1 ) ;
1999-04-17 00:37:12 +00:00
}
/* }}} */
2008-08-14 02:56:23 +00:00
/* {{{ proto string nl2br(string str [, bool is_xhtml])
1999-04-17 00:37:12 +00:00
Converts newlines to HTML line breaks */
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
PHP_FUNCTION ( nl2br )
1999-04-17 00:37:12 +00:00
{
2008-08-14 02:56:23 +00:00
/* in brief this inserts <br /> or <br> before matched regexp \n\r?|\r\n? */
char * tmp , * str ;
int new_length ;
char * end , * target ;
int repl_cnt = 0 ;
int str_len ;
zend_bool is_xhtml = 1 ;
2008-06-25 12:16:17 +00:00
2008-08-14 02:56:23 +00:00
if ( zend_parse_parameters ( ZEND_NUM_ARGS ( ) TSRMLS_CC , " s|b " , & str , & str_len , & is_xhtml ) = = FAILURE ) {
2008-06-25 12:16:17 +00:00
return ;
1999-04-17 00:37:12 +00:00
}
2008-06-25 12:16:17 +00:00
tmp = str ;
end = str + str_len ;
2002-10-09 13:37:02 +00:00
2001-09-26 19:34:46 +00:00
/* it is really faster to scan twice and allocate mem once insted scanning once
and constantly reallocing */
2008-06-25 12:16:17 +00:00
while ( tmp < end ) {
if ( * tmp = = ' \r ' ) {
if ( * ( tmp + 1 ) = = ' \n ' ) {
tmp + + ;
2002-10-09 13:37:02 +00:00
}
repl_cnt + + ;
2008-06-25 12:16:17 +00:00
} else if ( * tmp = = ' \n ' ) {
if ( * ( tmp + 1 ) = = ' \r ' ) {
tmp + + ;
2002-10-09 13:37:02 +00:00
}
2001-09-26 19:34:46 +00:00
repl_cnt + + ;
2002-10-09 13:37:02 +00:00
}
2008-06-25 12:16:17 +00:00
tmp + + ;
2001-09-26 19:34:46 +00:00
}
2002-10-09 13:37:02 +00:00
2001-09-26 19:34:46 +00:00
if ( repl_cnt = = 0 ) {
2008-06-25 12:16:17 +00:00
RETURN_STRINGL ( str , str_len , 1 ) ;
2001-09-24 08:33:51 +00:00
}
2001-09-09 12:55:48 +00:00
2008-08-14 02:56:23 +00:00
if ( is_xhtml ) {
new_length = str_len + repl_cnt * ( sizeof ( " <br /> " ) - 1 ) ;
} else {
new_length = str_len + repl_cnt * ( sizeof ( " <br> " ) - 1 ) ;
}
2002-10-09 13:37:02 +00:00
tmp = target = emalloc ( new_length + 1 ) ;
2002-10-09 13:50:06 +00:00
while ( str < end ) {
switch ( * str ) {
2002-10-09 13:37:02 +00:00
case ' \r ' :
case ' \n ' :
* target + + = ' < ' ;
* target + + = ' b ' ;
* target + + = ' r ' ;
2008-08-14 02:56:23 +00:00
if ( is_xhtml ) {
* target + + = ' ' ;
* target + + = ' / ' ;
}
2002-10-09 13:37:02 +00:00
* target + + = ' > ' ;
if ( ( * str = = ' \r ' & & * ( str + 1 ) = = ' \n ' ) | | ( * str = = ' \n ' & & * ( str + 1 ) = = ' \r ' ) ) {
* target + + = * str + + ;
}
/* lack of a break; is intentional */
default :
* target + + = * str ;
}
str + + ;
}
2002-10-11 12:42:01 +00:00
* target = ' \0 ' ;
2001-09-26 19:34:46 +00:00
RETURN_STRINGL ( tmp , new_length , 0 ) ;
1999-04-17 00:37:12 +00:00
}
/* }}} */
1999-09-20 20:05:26 +00:00
/* {{{ proto string strip_tags(string str [, string allowable_tags])
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
Strips HTML and PHP tags from a string */
PHP_FUNCTION ( strip_tags )
{
char * buf ;
2008-06-25 12:16:17 +00:00
char * str ;
zval * * allow = NULL ;
2000-02-08 21:29:18 +00:00
char * allowed_tags = NULL ;
int allowed_tags_len = 0 ;
2008-06-25 12:16:17 +00:00
int str_len ;
2003-02-24 22:01:12 +00:00
size_t retval_len ;
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
2008-06-25 12:16:17 +00:00
if ( zend_parse_parameters ( ZEND_NUM_ARGS ( ) TSRMLS_CC , " s|Z " , & str , & str_len , & allow ) = = FAILURE ) {
return ;
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
}
2008-06-25 12:16:17 +00:00
/* To maintain a certain BC, we allow anything for the second parameter and return original string */
if ( allow ! = NULL ) {
convert_to_string_ex ( allow ) ;
allowed_tags = Z_STRVAL_PP ( allow ) ;
allowed_tags_len = Z_STRLEN_PP ( allow ) ;
}
buf = estrndup ( str , str_len ) ;
retval_len = php_strip_tags_ex ( buf , str_len , NULL , allowed_tags , allowed_tags_len , 0 ) ;
2003-02-24 22:01:12 +00:00
RETURN_STRINGL ( buf , retval_len , 0 ) ;
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
}
/* }}} */
2002-09-18 07:55:30 +00:00
/* {{{ proto string setlocale(mixed category, string locale [, string ...])
1999-04-17 00:37:12 +00:00
Set locale information */
1999-06-15 21:51:00 +00:00
PHP_FUNCTION ( setlocale )
1999-04-17 00:37:12 +00:00
{
2008-08-16 21:32:41 +00:00
zval * * * args = NULL ;
1999-12-23 14:59:01 +00:00
zval * * pcategory , * * plocale ;
2008-08-16 21:32:41 +00:00
int num_args , cat , i = 0 ;
1999-04-17 00:37:12 +00:00
char * loc , * retval ;
2008-08-16 21:32:41 +00:00
if ( zend_parse_parameters ( ZEND_NUM_ARGS ( ) TSRMLS_CC , " Z+ " , & pcategory , & args , & num_args ) = = FAILURE ) {
return ;
2002-09-18 07:55:30 +00:00
}
2008-08-16 21:32:41 +00:00
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
# ifdef HAVE_SETLOCALE
2000-12-21 13:46:50 +00:00
if ( Z_TYPE_PP ( pcategory ) = = IS_LONG ) {
convert_to_long_ex ( pcategory ) ;
cat = Z_LVAL_PP ( pcategory ) ;
2008-08-16 21:32:41 +00:00
} else {
/* FIXME: The following behaviour should be removed. */
2002-09-18 07:55:30 +00:00
char * category ;
2008-08-16 21:32:41 +00:00
2008-02-23 17:06:22 +00:00
php_error_docref ( NULL TSRMLS_CC , E_DEPRECATED , " Passing locale category name as string is deprecated. Use the LC_* -constants instead " ) ;
2008-08-16 21:32:41 +00:00
2000-12-21 13:46:50 +00:00
convert_to_string_ex ( pcategory ) ;
2008-08-16 21:32:41 +00:00
category = Z_STRVAL_PP ( pcategory ) ;
2000-12-21 13:46:50 +00:00
2008-08-16 21:32:41 +00:00
if ( ! strcasecmp ( " LC_ALL " , category ) ) {
2000-12-21 13:46:50 +00:00
cat = LC_ALL ;
2008-08-16 21:32:41 +00:00
} else if ( ! strcasecmp ( " LC_COLLATE " , category ) ) {
2000-12-21 13:46:50 +00:00
cat = LC_COLLATE ;
2008-08-16 21:32:41 +00:00
} else if ( ! strcasecmp ( " LC_CTYPE " , category ) ) {
2000-12-21 13:46:50 +00:00
cat = LC_CTYPE ;
2000-06-17 16:49:03 +00:00
# ifdef LC_MESSAGES
2008-08-16 21:32:41 +00:00
} else if ( ! strcasecmp ( " LC_MESSAGES " , category ) ) {
2000-12-21 13:46:50 +00:00
cat = LC_MESSAGES ;
2000-06-17 14:48:03 +00:00
# endif
2008-08-16 21:32:41 +00:00
} else if ( ! strcasecmp ( " LC_MONETARY " , category ) ) {
2000-12-21 13:46:50 +00:00
cat = LC_MONETARY ;
2008-08-16 21:32:41 +00:00
} else if ( ! strcasecmp ( " LC_NUMERIC " , category ) ) {
2000-12-21 13:46:50 +00:00
cat = LC_NUMERIC ;
2008-08-16 21:32:41 +00:00
} else if ( ! strcasecmp ( " LC_TIME " , category ) ) {
2000-12-21 13:46:50 +00:00
cat = LC_TIME ;
2008-08-16 21:32:41 +00:00
} else {
2007-09-30 05:40:23 +00:00
php_error_docref ( NULL TSRMLS_CC , E_WARNING , " Invalid locale category name %s, must be one of LC_ALL, LC_COLLATE, LC_CTYPE, LC_MONETARY, LC_NUMERIC, or LC_TIME " , category ) ;
2008-08-16 21:32:41 +00:00
if ( args ) {
efree ( args ) ;
}
2000-12-21 13:46:50 +00:00
RETURN_FALSE ;
}
1999-04-17 00:37:12 +00:00
}
2002-09-18 07:55:30 +00:00
2008-08-16 21:32:41 +00:00
if ( Z_TYPE_PP ( args [ 0 ] ) = = IS_ARRAY ) {
zend_hash_internal_pointer_reset ( Z_ARRVAL_PP ( args [ 0 ] ) ) ;
2000-12-21 13:46:50 +00:00
}
2008-08-16 21:32:41 +00:00
2002-10-02 17:56:04 +00:00
while ( 1 ) {
2008-08-16 21:32:41 +00:00
if ( Z_TYPE_PP ( args [ 0 ] ) = = IS_ARRAY ) {
if ( ! zend_hash_num_elements ( Z_ARRVAL_PP ( args [ 0 ] ) ) ) {
2003-04-03 06:21:59 +00:00
break ;
}
2008-08-16 21:32:41 +00:00
zend_hash_get_current_data ( Z_ARRVAL_PP ( args [ 0 ] ) , ( void * * ) & plocale ) ;
2002-09-18 07:55:30 +00:00
} else {
plocale = args [ i ] ;
1999-10-08 02:10:57 +00:00
}
2002-09-18 07:55:30 +00:00
convert_to_string_ex ( plocale ) ;
if ( ! strcmp ( " 0 " , Z_STRVAL_PP ( plocale ) ) ) {
loc = NULL ;
} else {
loc = Z_STRVAL_PP ( plocale ) ;
2007-09-07 02:28:42 +00:00
if ( Z_STRLEN_PP ( plocale ) > = 255 ) {
php_error_docref ( NULL TSRMLS_CC , E_WARNING , " Specified locale name is too long " ) ;
break ;
}
2002-09-18 07:55:30 +00:00
}
2007-09-07 02:28:42 +00:00
2008-08-16 21:32:41 +00:00
retval = setlocale ( cat , loc ) ;
2006-12-04 18:37:15 +00:00
zend_update_current_locale ( ) ;
2002-09-18 07:55:30 +00:00
if ( retval ) {
/* Remember if locale was changed */
if ( loc ) {
STR_FREE ( BG ( locale_string ) ) ;
BG ( locale_string ) = estrdup ( retval ) ;
}
2008-08-16 21:32:41 +00:00
if ( args ) {
efree ( args ) ;
}
RETURN_STRING ( retval , 1 ) ;
2002-09-18 07:55:30 +00:00
}
2008-08-16 21:32:41 +00:00
if ( Z_TYPE_PP ( args [ 0 ] ) = = IS_ARRAY ) {
if ( zend_hash_move_forward ( Z_ARRVAL_PP ( args [ 0 ] ) ) = = FAILURE ) break ;
2002-09-18 07:55:30 +00:00
} else {
2008-08-16 21:32:41 +00:00
if ( + + i > = num_args ) break ;
2002-09-18 07:55:30 +00:00
}
1999-04-17 00:37:12 +00:00
}
2002-09-18 07:55:30 +00:00
1999-04-17 00:37:12 +00:00
# endif
2008-08-16 21:32:41 +00:00
if ( args ) {
efree ( args ) ;
}
1999-04-17 00:37:12 +00:00
RETURN_FALSE ;
}
/* }}} */
2001-09-04 10:44:28 +00:00
/* {{{ proto void parse_str(string encoded_string [, array result])
2000-07-26 11:43:01 +00:00
Parses GET / POST / COOKIE data and sets global variables */
1999-07-24 22:16:54 +00:00
PHP_FUNCTION ( parse_str )
1999-04-17 00:37:12 +00:00
{
2008-06-25 12:16:17 +00:00
char * arg ;
zval * * arrayArg = NULL ;
1999-04-17 00:37:12 +00:00
char * res = NULL ;
2008-06-25 12:16:17 +00:00
int arglen ;
1999-04-17 00:37:12 +00:00
2008-06-25 12:16:17 +00:00
if ( zend_parse_parameters ( ZEND_NUM_ARGS ( ) TSRMLS_CC , " s|Z " , & arg , & arglen , & arrayArg ) = = FAILURE ) {
return ;
1999-04-17 00:37:12 +00:00
}
2000-09-11 14:50:26 +00:00
2008-06-25 12:16:17 +00:00
res = estrndup ( arg , arglen ) ;
if ( arrayArg = = NULL ) {
2005-09-28 22:39:52 +00:00
zval tmp ;
2008-04-29 08:15:20 +00:00
if ( ! EG ( active_symbol_table ) ) {
zend_rebuild_symbol_table ( TSRMLS_C ) ;
}
Z_ARRVAL ( tmp ) = EG ( active_symbol_table ) ;
2005-09-28 22:39:52 +00:00
sapi_module . treat_data ( PARSE_STRING , res , & tmp TSRMLS_CC ) ;
2000-09-12 10:56:25 +00:00
} else {
2000-09-11 14:50:26 +00:00
/* Clear out the array that was passed in. */
zval_dtor ( * arrayArg ) ;
array_init ( * arrayArg ) ;
2002-08-02 06:53:48 +00:00
sapi_module . treat_data ( PARSE_STRING , res , * arrayArg TSRMLS_CC ) ;
1999-04-17 00:37:12 +00:00
}
}
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
/* }}} */
1999-09-20 15:50:56 +00:00
# define PHP_TAG_BUF_SIZE 1023
2001-06-05 13:12:10 +00:00
/* {{{ php_tag_find
*
* Check if tag is in a set of tags
1999-09-20 15:50:56 +00:00
*
* states :
*
* 0 start tag
* 1 first non - whitespace char seen
*/
int php_tag_find ( char * tag , int len , char * set ) {
char c , * n , * t ;
2000-02-13 15:59:32 +00:00
int state = 0 , done = 0 ;
2006-12-20 23:36:56 +00:00
char * norm ;
if ( len < = 0 ) {
return 0 ;
}
norm = emalloc ( len + 1 ) ;
1999-09-20 15:50:56 +00:00
n = norm ;
t = tag ;
c = tolower ( * t ) ;
/*
normalize the tag removing leading and trailing whitespace
and turn any < a whatever . . . > into just < a > and any < / tag >
into < tag >
*/
2002-10-02 17:56:04 +00:00
while ( ! done ) {
switch ( c ) {
case ' < ' :
* ( n + + ) = c ;
break ;
case ' > ' :
done = 1 ;
break ;
default :
if ( ! isspace ( ( int ) c ) ) {
if ( state = = 0 ) {
state = 1 ;
if ( c ! = ' / ' )
* ( n + + ) = c ;
} else {
* ( n + + ) = c ;
}
1999-09-20 15:50:56 +00:00
} else {
2002-10-02 17:56:04 +00:00
if ( state = = 1 )
done = 1 ;
1999-09-20 15:50:56 +00:00
}
2002-10-02 17:56:04 +00:00
break ;
1999-09-20 15:50:56 +00:00
}
c = tolower ( * ( + + t ) ) ;
}
* ( n + + ) = ' > ' ;
* n = ' \0 ' ;
2002-10-02 17:56:04 +00:00
if ( strstr ( set , norm ) ) {
2000-02-13 15:56:07 +00:00
done = 1 ;
} else {
done = 0 ;
}
1999-09-20 15:50:56 +00:00
efree ( norm ) ;
return done ;
}
2001-06-05 13:12:10 +00:00
/* }}} */
1999-09-20 15:50:56 +00:00
2007-06-05 13:35:26 +00:00
PHPAPI size_t php_strip_tags ( char * rbuf , int len , int * stateptr , char * allow , int allow_len ) /* { { { */
2006-12-18 15:02:16 +00:00
{
return php_strip_tags_ex ( rbuf , len , stateptr , allow , allow_len , 0 ) ;
}
2007-06-05 13:35:26 +00:00
/* }}} */
2006-12-18 15:02:16 +00:00
2001-06-05 13:12:10 +00:00
/* {{{ php_strip_tags
2002-09-11 14:40:52 +00:00
A simple little state - machine to strip out html and php tags
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
State 0 is the output state , State 1 means we are inside a
normal html tag and state 2 means we are inside a php tag .
The state variable is passed in to allow a function like fgetss
to maintain state across calls to the function .
lc holds the last significant character read and br is a bracket
counter .
1999-09-20 15:50:56 +00:00
When an allow string is passed in we keep track of the string
in state 1 and when the tag is closed check it against the
allow string to see if we should allow it .
2001-08-22 02:03:14 +00:00
swm : Added ability to strip < ? xml tags without assuming it PHP
code .
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
*/
2006-12-18 15:02:16 +00:00
PHPAPI size_t php_strip_tags_ex ( char * rbuf , int len , int * stateptr , char * allow , int allow_len , zend_bool allow_tag_spaces )
2000-02-08 21:29:18 +00:00
{
1999-09-20 15:50:56 +00:00
char * tbuf , * buf , * p , * tp , * rp , c , lc ;
2007-02-13 02:16:22 +00:00
int br , i = 0 , depth = 0 , in_q = 0 ;
2002-04-07 10:56:30 +00:00
int state = 0 ;
2002-03-20 14:38:13 +00:00
if ( stateptr )
state = * stateptr ;
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
2001-08-11 17:03:37 +00:00
buf = estrndup ( rbuf , len ) ;
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
c = * buf ;
lc = ' \0 ' ;
p = buf ;
rp = rbuf ;
br = 0 ;
2002-10-02 17:56:04 +00:00
if ( allow ) {
2000-02-08 21:29:18 +00:00
php_strtolower ( allow , allow_len ) ;
1999-09-20 15:50:56 +00:00
tbuf = emalloc ( PHP_TAG_BUF_SIZE + 1 ) ;
tp = tbuf ;
1999-09-24 15:34:54 +00:00
} else {
tbuf = tp = NULL ;
}
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
2002-10-02 17:56:04 +00:00
while ( i < len ) {
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
switch ( c ) {
2004-06-26 07:43:02 +00:00
case ' \0 ' :
break ;
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
case ' < ' :
2008-07-15 14:46:12 +00:00
if ( in_q ) {
break ;
}
2006-12-18 15:02:16 +00:00
if ( isspace ( * ( p + 1 ) ) & & ! allow_tag_spaces ) {
2003-01-06 22:13:03 +00:00
goto reg_char ;
}
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
if ( state = = 0 ) {
lc = ' < ' ;
state = 1 ;
2002-10-02 17:56:04 +00:00
if ( allow ) {
2003-07-12 09:33:31 +00:00
tp = ( ( tp - tbuf ) > = PHP_TAG_BUF_SIZE ? tbuf : tp ) ;
1999-09-20 15:50:56 +00:00
* ( tp + + ) = ' < ' ;
2007-02-13 02:16:22 +00:00
}
2002-09-21 17:34:06 +00:00
} else if ( state = = 1 ) {
2002-09-20 11:48:47 +00:00
depth + + ;
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
}
break ;
case ' ( ' :
if ( state = = 2 ) {
2002-09-21 17:34:06 +00:00
if ( lc ! = ' " ' & & lc ! = ' \' ' ) {
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
lc = ' ( ' ;
br + + ;
}
2001-04-29 13:16:05 +00:00
} else if ( allow & & state = = 1 ) {
2003-07-12 09:33:31 +00:00
tp = ( ( tp - tbuf ) > = PHP_TAG_BUF_SIZE ? tbuf : tp ) ;
2001-04-28 23:07:51 +00:00
* ( tp + + ) = c ;
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
} else if ( state = = 0 ) {
* ( rp + + ) = c ;
}
break ;
case ' ) ' :
if ( state = = 2 ) {
2002-09-21 17:34:06 +00:00
if ( lc ! = ' " ' & & lc ! = ' \' ' ) {
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
lc = ' ) ' ;
br - - ;
}
2001-04-29 13:16:05 +00:00
} else if ( allow & & state = = 1 ) {
2003-07-12 09:33:31 +00:00
tp = ( ( tp - tbuf ) > = PHP_TAG_BUF_SIZE ? tbuf : tp ) ;
2001-04-28 23:07:51 +00:00
* ( tp + + ) = c ;
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
} else if ( state = = 0 ) {
* ( rp + + ) = c ;
}
break ;
case ' > ' :
2002-09-20 11:48:47 +00:00
if ( depth ) {
depth - - ;
break ;
}
2007-02-13 02:16:22 +00:00
if ( in_q ) {
break ;
}
2002-10-03 18:15:18 +00:00
switch ( state ) {
2002-09-21 17:34:06 +00:00
case 1 : /* HTML/XML */
lc = ' > ' ;
2007-03-03 15:46:29 +00:00
in_q = state = 0 ;
2002-10-02 17:56:04 +00:00
if ( allow ) {
2003-07-12 09:33:31 +00:00
tp = ( ( tp - tbuf ) > = PHP_TAG_BUF_SIZE ? tbuf : tp ) ;
2002-09-21 17:34:06 +00:00
* ( tp + + ) = ' > ' ;
* tp = ' \0 ' ;
2002-10-02 17:56:04 +00:00
if ( php_tag_find ( tbuf , tp - tbuf , allow ) ) {
2002-09-21 17:34:06 +00:00
memcpy ( rp , tbuf , tp - tbuf ) ;
rp + = tp - tbuf ;
}
tp = tbuf ;
}
break ;
case 2 : /* PHP */
2002-10-02 17:56:04 +00:00
if ( ! br & & lc ! = ' \" ' & & * ( p - 1 ) = = ' ? ' ) {
2007-03-03 15:46:29 +00:00
in_q = state = 0 ;
2002-09-21 17:34:06 +00:00
tp = tbuf ;
}
break ;
2003-05-04 12:44:36 +00:00
case 3 :
2007-03-03 15:46:29 +00:00
in_q = state = 0 ;
2003-05-04 11:45:58 +00:00
tp = tbuf ;
2002-09-21 17:34:06 +00:00
break ;
2003-05-04 12:44:36 +00:00
case 4 : /* JavaScript/CSS/etc... */
if ( p > = buf + 2 & & * ( p - 1 ) = = ' - ' & & * ( p - 2 ) = = ' - ' ) {
2007-03-03 15:46:29 +00:00
in_q = state = 0 ;
2003-05-04 12:44:36 +00:00
tp = tbuf ;
}
break ;
2002-09-21 17:34:06 +00:00
default :
* ( rp + + ) = c ;
break ;
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
}
break ;
2002-09-21 17:34:06 +00:00
case ' " ' :
case ' \' ' :
if ( state = = 2 & & * ( p - 1 ) ! = ' \\ ' ) {
if ( lc = = c ) {
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
lc = ' \0 ' ;
} else if ( lc ! = ' \\ ' ) {
2002-09-21 17:34:06 +00:00
lc = c ;
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
}
} else if ( state = = 0 ) {
* ( rp + + ) = c ;
1999-09-20 15:50:56 +00:00
} else if ( allow & & state = = 1 ) {
2003-07-12 09:33:31 +00:00
tp = ( ( tp - tbuf ) > = PHP_TAG_BUF_SIZE ? tbuf : tp ) ;
1999-09-20 15:50:56 +00:00
* ( tp + + ) = c ;
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
}
2007-03-03 15:46:29 +00:00
if ( state & & p ! = buf & & * ( p - 1 ) ! = ' \\ ' & & ( ! in_q | | * p = = in_q ) ) {
2007-02-27 00:15:21 +00:00
if ( in_q ) {
in_q = 0 ;
} else {
in_q = * p ;
}
2007-02-13 02:16:22 +00:00
}
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
break ;
2002-09-21 17:34:06 +00:00
case ' ! ' :
/* JavaScript & Other HTML scripting languages */
if ( state = = 1 & & * ( p - 1 ) = = ' < ' ) {
state = 3 ;
2002-12-31 15:18:52 +00:00
lc = c ;
2002-11-27 06:20:19 +00:00
} else {
2003-01-19 11:32:54 +00:00
if ( state = = 0 ) {
* ( rp + + ) = c ;
} else if ( allow & & state = = 1 ) {
2003-07-12 09:33:31 +00:00
tp = ( ( tp - tbuf ) > = PHP_TAG_BUF_SIZE ? tbuf : tp ) ;
2003-01-19 11:32:54 +00:00
* ( tp + + ) = c ;
}
}
2002-09-21 17:34:06 +00:00
break ;
2002-12-31 15:18:52 +00:00
2003-05-04 12:44:36 +00:00
case ' - ' :
if ( state = = 3 & & p > = buf + 2 & & * ( p - 1 ) = = ' - ' & & * ( p - 2 ) = = ' ! ' ) {
state = 4 ;
2003-05-16 06:19:51 +00:00
} else {
goto reg_char ;
2003-05-04 12:44:36 +00:00
}
break ;
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
case ' ? ' :
2001-08-22 02:03:14 +00:00
2003-07-12 09:33:31 +00:00
if ( state = = 1 & & * ( p - 1 ) = = ' < ' ) {
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
br = 0 ;
state = 2 ;
break ;
}
2001-08-22 05:47:11 +00:00
2002-12-31 15:18:52 +00:00
case ' E ' :
case ' e ' :
/* !DOCTYPE exception */
if ( state = = 3 & & p > buf + 6
& & tolower ( * ( p - 1 ) ) = = ' p '
& & tolower ( * ( p - 2 ) ) = = ' y '
& & tolower ( * ( p - 3 ) ) = = ' t '
& & tolower ( * ( p - 4 ) ) = = ' c '
& & tolower ( * ( p - 5 ) ) = = ' o '
& & tolower ( * ( p - 6 ) ) = = ' d ' ) {
state = 1 ;
break ;
}
/* fall-through */
2001-08-22 05:47:11 +00:00
case ' l ' :
2008-07-11 12:25:38 +00:00
case ' L ' :
2001-08-22 05:47:11 +00:00
/* swm: If we encounter '<?xml' then we shouldn't be in
* state = = 2 ( PHP ) . Switch back to HTML .
*/
2008-07-11 12:25:38 +00:00
if ( state = = 2 & & p > buf + 2 & & strncasecmp ( p - 2 , " xm " , 2 ) = = 0 ) {
2001-08-22 05:47:11 +00:00
state = 1 ;
break ;
}
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
2001-08-22 02:03:14 +00:00
/* fall-through */
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
default :
2003-01-06 22:13:03 +00:00
reg_char :
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
if ( state = = 0 ) {
* ( rp + + ) = c ;
2002-10-02 17:56:04 +00:00
} else if ( allow & & state = = 1 ) {
2003-07-12 09:33:31 +00:00
tp = ( ( tp - tbuf ) > = PHP_TAG_BUF_SIZE ? tbuf : tp ) ;
1999-09-20 15:50:56 +00:00
* ( tp + + ) = c ;
2001-08-22 02:03:14 +00:00
}
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
break ;
}
c = * ( + + p ) ;
1999-09-20 15:50:56 +00:00
i + + ;
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
}
2003-02-24 22:19:36 +00:00
if ( rp < rbuf + len ) {
* rp = ' \0 ' ;
}
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
efree ( buf ) ;
2002-10-02 17:56:04 +00:00
if ( allow )
efree ( tbuf ) ;
2002-03-20 14:38:13 +00:00
if ( stateptr )
* stateptr = state ;
2003-02-24 22:01:12 +00:00
return ( size_t ) ( rp - rbuf ) ;
* fixed some #if/#ifdef issues
* hand-patched in php3 changes from 3.0.6 to HEAD in these files:
fopen-wrappers.[ch] ext/standard/file.[ch] ext/standard/fsock.[ch]
ext/standard/php3_string.h ext/standard/string.c
* added some new file/socket macros for more readable code:
FP_FGETS(buf,len,sock,fp,issock)
FP_FREAD(buf,len,sock,fp,issock)
FP_FEOF(sock,fp,issock)
FP_FGETC(sock,fp,issock)
1999-06-16 17:06:53 +00:00
}
2001-06-05 13:12:10 +00:00
/* }}} */
1999-04-17 00:37:12 +00:00
1999-10-27 22:06:05 +00:00
/* {{{ proto string str_repeat(string input, int mult)
Returns the input string repeat mult times */
PHP_FUNCTION ( str_repeat )
{
2008-06-25 12:16:17 +00:00
char * input_str ; /* Input string */
int input_len ;
2008-06-30 10:39:34 +00:00
long mult ; /* Multiplier */
2002-10-03 13:59:31 +00:00
char * result ; /* Resulting string */
2006-08-10 14:40:13 +00:00
size_t result_len ; /* Length of the resulting string */
1999-10-27 22:06:05 +00:00
2008-06-25 12:16:17 +00:00
if ( zend_parse_parameters ( ZEND_NUM_ARGS ( ) TSRMLS_CC , " sl " , & input_str , & input_len , & mult ) = = FAILURE ) {
return ;
1999-10-27 22:06:05 +00:00
}
2008-06-25 12:16:17 +00:00
if ( mult < 0 ) {
2007-09-30 05:40:23 +00:00
php_error_docref ( NULL TSRMLS_CC , E_WARNING , " Second argument has to be greater than or equal to 0 " ) ;
1999-10-27 22:06:05 +00:00
return ;
}
/* Don't waste our time if it's empty */
2000-09-05 18:25:58 +00:00
/* ... or if the multiplier is zero */
2008-06-25 12:16:17 +00:00
if ( input_len = = 0 | | mult = = 0 )
RETURN_EMPTY_STRING ( ) ;
1999-10-27 22:06:05 +00:00
/* Initialize the result string */
2008-06-25 12:16:17 +00:00
result_len = input_len * mult ;
result = ( char * ) safe_emalloc ( input_len , mult , 1 ) ;
1999-10-27 22:06:05 +00:00
2002-10-04 17:10:51 +00:00
/* Heavy optimization for situations where input string is 1 byte long */
2008-06-25 12:16:17 +00:00
if ( input_len = = 1 ) {
memset ( result , * ( input_str ) , mult ) ;
2002-10-03 13:59:31 +00:00
} else {
char * s , * e , * ee ;
int l = 0 ;
2008-06-25 12:16:17 +00:00
memcpy ( result , input_str , input_len ) ;
2002-10-03 13:59:31 +00:00
s = result ;
2008-06-25 12:16:17 +00:00
e = result + input_len ;
2002-10-03 13:59:31 +00:00
ee = result + result_len ;
while ( e < ee ) {
l = ( e - s ) < ( ee - e ) ? ( e - s ) : ( ee - e ) ;
memmove ( e , s , l ) ;
e + = l ;
}
1999-10-27 22:06:05 +00:00
}
2002-10-03 13:59:31 +00:00
1999-10-27 22:06:05 +00:00
result [ result_len ] = ' \0 ' ;
2000-01-04 09:45:28 +00:00
RETURN_STRINGL ( result , result_len , 0 ) ;
1999-10-27 22:06:05 +00:00
}
/* }}} */
2000-02-24 10:11:42 +00:00
/* {{{ proto mixed count_chars(string input [, int mode])
1999-12-14 03:52:12 +00:00
Returns info about what characters are used in input */
PHP_FUNCTION ( count_chars )
{
2008-06-25 12:16:17 +00:00
char * input ;
1999-12-14 03:52:12 +00:00
int chars [ 256 ] ;
2008-06-30 10:39:34 +00:00
long mymode = 0 ;
1999-12-14 03:52:12 +00:00
unsigned char * buf ;
int len , inx ;
char retstr [ 256 ] ;
int retlen = 0 ;
2008-06-25 12:16:17 +00:00
if ( zend_parse_parameters ( ZEND_NUM_ARGS ( ) TSRMLS_CC , " s|l " , & input , & len , & mymode ) = = FAILURE ) {
return ;
1999-12-14 03:52:12 +00:00
}
2008-06-25 12:16:17 +00:00
if ( mymode < 0 | | mymode > 4 ) {
php_error_docref ( NULL TSRMLS_CC , E_WARNING , " Unknown mode " ) ;
RETURN_FALSE ;
1999-12-14 03:52:12 +00:00
}
2008-06-25 12:16:17 +00:00
buf = ( unsigned char * ) input ;
2001-08-11 17:03:37 +00:00
memset ( ( void * ) chars , 0 , sizeof ( chars ) ) ;
1999-12-14 03:52:12 +00:00
while ( len > 0 ) {
chars [ * buf ] + + ;
buf + + ;
len - - ;
}
if ( mymode < 3 ) {
array_init ( return_value ) ;
}
2002-10-02 17:56:04 +00:00
for ( inx = 0 ; inx < 256 ; inx + + ) {
1999-12-14 03:52:12 +00:00
switch ( mymode ) {
2002-10-03 18:15:18 +00:00
case 0 :
2001-08-11 17:03:37 +00:00
add_index_long ( return_value , inx , chars [ inx ] ) ;
2002-10-03 18:15:18 +00:00
break ;
case 1 :
if ( chars [ inx ] ! = 0 ) {
add_index_long ( return_value , inx , chars [ inx ] ) ;
}
break ;
case 2 :
if ( chars [ inx ] = = 0 ) {
add_index_long ( return_value , inx , chars [ inx ] ) ;
}
break ;
case 3 :
if ( chars [ inx ] ! = 0 ) {
retstr [ retlen + + ] = inx ;
}
break ;
case 4 :
if ( chars [ inx ] = = 0 ) {
retstr [ retlen + + ] = inx ;
}
break ;
1999-12-14 03:52:12 +00:00
}
}
if ( mymode > = 3 & & mymode < = 4 ) {
2001-08-11 17:03:37 +00:00
RETURN_STRINGL ( retstr , retlen , 1 ) ;
1999-12-14 03:52:12 +00:00
}
}
/* }}} */
2000-04-12 19:39:02 +00:00
2001-06-05 13:12:10 +00:00
/* {{{ php_strnatcmp
*/
2000-04-12 19:39:02 +00:00
static void php_strnatcmp ( INTERNAL_FUNCTION_PARAMETERS , int fold_case )
{
2008-06-25 12:16:17 +00:00
char * s1 , * s2 ;
int s1_len , s2_len ;
2000-04-12 19:39:02 +00:00
2008-06-25 12:16:17 +00:00
if ( zend_parse_parameters ( ZEND_NUM_ARGS ( ) TSRMLS_CC , " ss " , & s1 , & s1_len , & s2 , & s2_len ) = = FAILURE ) {
return ;
2000-04-12 19:39:02 +00:00
}
2008-06-25 12:16:17 +00:00
RETURN_LONG ( strnatcmp_ex ( s1 , s1_len ,
s2 , s2_len ,
2000-04-12 19:39:02 +00:00
fold_case ) ) ;
}
2001-06-05 13:12:10 +00:00
/* }}} */
2000-04-26 00:29:59 +00:00
/* {{{ proto int strnatcmp(string s1, string s2)
Returns the result of string comparison using ' natural ' algorithm */
2000-04-12 19:39:02 +00:00
PHP_FUNCTION ( strnatcmp )
{
php_strnatcmp ( INTERNAL_FUNCTION_PARAM_PASSTHRU , 0 ) ;
}
2000-04-26 00:29:59 +00:00
/* }}} */
2000-04-12 19:39:02 +00:00
2001-09-04 10:44:28 +00:00
/* {{{ proto array localeconv(void)
2001-04-29 13:30:56 +00:00
Returns numeric formatting information based on the current locale */
2001-01-14 16:36:30 +00:00
PHP_FUNCTION ( localeconv )
{
zval * grouping , * mon_grouping ;
int len , i ;
/* We don't need no stinkin' parameters... */
2008-03-10 22:15:36 +00:00
if ( zend_parse_parameters_none ( ) = = FAILURE ) {
return ;
2001-01-14 16:36:30 +00:00
}
2003-01-05 04:29:14 +00:00
MAKE_STD_ZVAL ( grouping ) ;
MAKE_STD_ZVAL ( mon_grouping ) ;
2002-12-05 22:28:02 +00:00
array_init ( return_value ) ;
array_init ( grouping ) ;
array_init ( mon_grouping ) ;
2001-01-14 16:36:30 +00:00
# ifdef HAVE_LOCALECONV
{
struct lconv currlocdata ;
localeconv_r ( & currlocdata ) ;
/* Grab the grouping data out of the array */
len = strlen ( currlocdata . grouping ) ;
2002-10-02 17:56:04 +00:00
for ( i = 0 ; i < len ; i + + ) {
2001-01-14 16:36:30 +00:00
add_index_long ( grouping , i , currlocdata . grouping [ i ] ) ;
}
/* Grab the monetary grouping data out of the array */
len = strlen ( currlocdata . mon_grouping ) ;
2002-10-02 17:56:04 +00:00
for ( i = 0 ; i < len ; i + + ) {
2001-01-14 16:36:30 +00:00
add_index_long ( mon_grouping , i , currlocdata . mon_grouping [ i ] ) ;
}
add_assoc_string ( return_value , " decimal_point " , currlocdata . decimal_point , 1 ) ;
add_assoc_string ( return_value , " thousands_sep " , currlocdata . thousands_sep , 1 ) ;
add_assoc_string ( return_value , " int_curr_symbol " , currlocdata . int_curr_symbol , 1 ) ;
add_assoc_string ( return_value , " currency_symbol " , currlocdata . currency_symbol , 1 ) ;
add_assoc_string ( return_value , " mon_decimal_point " , currlocdata . mon_decimal_point , 1 ) ;
add_assoc_string ( return_value , " mon_thousands_sep " , currlocdata . mon_thousands_sep , 1 ) ;
add_assoc_string ( return_value , " positive_sign " , currlocdata . positive_sign , 1 ) ;
add_assoc_string ( return_value , " negative_sign " , currlocdata . negative_sign , 1 ) ;
add_assoc_long ( return_value , " int_frac_digits " , currlocdata . int_frac_digits ) ;
add_assoc_long ( return_value , " frac_digits " , currlocdata . frac_digits ) ;
add_assoc_long ( return_value , " p_cs_precedes " , currlocdata . p_cs_precedes ) ;
add_assoc_long ( return_value , " p_sep_by_space " , currlocdata . p_sep_by_space ) ;
add_assoc_long ( return_value , " n_cs_precedes " , currlocdata . n_cs_precedes ) ;
add_assoc_long ( return_value , " n_sep_by_space " , currlocdata . n_sep_by_space ) ;
add_assoc_long ( return_value , " p_sign_posn " , currlocdata . p_sign_posn ) ;
add_assoc_long ( return_value , " n_sign_posn " , currlocdata . n_sign_posn ) ;
}
# else
/* Ok, it doesn't look like we have locale info floating around, so I guess it
wouldn ' t hurt to just go ahead and return the POSIX locale information ? */
add_index_long ( grouping , 0 , - 1 ) ;
add_index_long ( mon_grouping , 0 , - 1 ) ;
add_assoc_string ( return_value , " decimal_point " , " \x2E " , 1 ) ;
add_assoc_string ( return_value , " thousands_sep " , " " , 1 ) ;
add_assoc_string ( return_value , " int_curr_symbol " , " " , 1 ) ;
add_assoc_string ( return_value , " currency_symbol " , " " , 1 ) ;
add_assoc_string ( return_value , " mon_decimal_point " , " \x2E " , 1 ) ;
add_assoc_string ( return_value , " mon_thousands_sep " , " " , 1 ) ;
add_assoc_string ( return_value , " positive_sign " , " " , 1 ) ;
add_assoc_string ( return_value , " negative_sign " , " " , 1 ) ;
add_assoc_long ( return_value , " int_frac_digits " , CHAR_MAX ) ;
add_assoc_long ( return_value , " frac_digits " , CHAR_MAX ) ;
add_assoc_long ( return_value , " p_cs_precedes " , CHAR_MAX ) ;
add_assoc_long ( return_value , " p_sep_by_space " , CHAR_MAX ) ;
add_assoc_long ( return_value , " n_cs_precedes " , CHAR_MAX ) ;
add_assoc_long ( return_value , " n_sep_by_space " , CHAR_MAX ) ;
add_assoc_long ( return_value , " p_sign_posn " , CHAR_MAX ) ;
add_assoc_long ( return_value , " n_sign_posn " , CHAR_MAX ) ;
# endif
2001-09-25 21:58:48 +00:00
zend_hash_update ( Z_ARRVAL_P ( return_value ) , " grouping " , 9 , & grouping , sizeof ( zval * ) , NULL ) ;
zend_hash_update ( Z_ARRVAL_P ( return_value ) , " mon_grouping " , 13 , & mon_grouping , sizeof ( zval * ) , NULL ) ;
2001-01-14 16:36:30 +00:00
}
2001-06-05 13:12:10 +00:00
/* }}} */
2000-04-26 00:29:59 +00:00
/* {{{ proto int strnatcasecmp(string s1, string s2)
Returns the result of case - insensitive string comparison using ' natural ' algorithm */
2000-04-12 19:39:02 +00:00
PHP_FUNCTION ( strnatcasecmp )
{
php_strnatcmp ( INTERNAL_FUNCTION_PARAM_PASSTHRU , 1 ) ;
}
2000-04-26 00:29:59 +00:00
/* }}} */
2005-06-18 18:23:12 +00:00
/* {{{ proto int substr_count(string haystack, string needle [, int offset [, int length]])
2000-08-06 14:36:10 +00:00
Returns the number of times a substring occurs in the string */
2000-04-26 00:29:59 +00:00
PHP_FUNCTION ( substr_count )
{
2008-06-25 12:16:17 +00:00
char * haystack , * needle ;
2008-06-30 10:39:34 +00:00
long offset = 0 , length ;
2005-06-18 18:23:12 +00:00
int ac = ZEND_NUM_ARGS ( ) ;
2002-10-09 13:37:02 +00:00
int count = 0 ;
2008-06-25 12:16:17 +00:00
int haystack_len , needle_len ;
2000-04-26 00:29:59 +00:00
char * p , * endp , cmp ;
2008-06-25 12:16:17 +00:00
if ( zend_parse_parameters ( ZEND_NUM_ARGS ( ) TSRMLS_CC , " ss|ll " , & haystack , & haystack_len , & needle , & needle_len , & offset , & length ) = = FAILURE ) {
return ;
2000-04-26 00:29:59 +00:00
}
2008-06-25 12:16:17 +00:00
if ( needle_len = = 0 ) {
2007-09-30 05:40:23 +00:00
php_error_docref ( NULL TSRMLS_CC , E_WARNING , " Empty substring " ) ;
2000-04-26 00:29:59 +00:00
RETURN_FALSE ;
2002-10-09 13:37:02 +00:00
}
2008-06-25 12:16:17 +00:00
p = haystack ;
endp = p + haystack_len ;
if ( offset < 0 ) {
php_error_docref ( NULL TSRMLS_CC , E_WARNING , " Offset should be greater than or equal to 0 " ) ;
RETURN_FALSE ;
}
2007-03-08 00:06:41 +00:00
2008-06-25 12:16:17 +00:00
if ( offset > haystack_len ) {
php_error_docref ( NULL TSRMLS_CC , E_WARNING , " Offset value %ld exceeds string length " , offset ) ;
RETURN_FALSE ;
}
p + = offset ;
if ( ac = = 4 ) {
if ( length < = 0 ) {
php_error_docref ( NULL TSRMLS_CC , E_WARNING , " Length should be greater than 0 " ) ;
2005-06-18 18:23:12 +00:00
RETURN_FALSE ;
}
2008-06-25 12:16:17 +00:00
if ( length > ( haystack_len - offset ) ) {
php_error_docref ( NULL TSRMLS_CC , E_WARNING , " Length value %ld exceeds string length " , length ) ;
RETURN_FALSE ;
2005-06-18 18:23:12 +00:00
}
2008-06-25 12:16:17 +00:00
endp = p + length ;
2005-06-18 18:23:12 +00:00
}
2008-06-25 12:16:17 +00:00
if ( needle_len = = 1 ) {
cmp = needle [ 0 ] ;
2005-06-19 16:31:51 +00:00
while ( ( p = memchr ( p , cmp , endp - p ) ) ) {
count + + ;
p + + ;
2000-04-26 00:29:59 +00:00
}
} else {
2008-06-25 12:16:17 +00:00
while ( ( p = php_memnstr ( p , needle , needle_len , endp ) ) ) {
p + = needle_len ;
2002-10-09 13:37:02 +00:00
count + + ;
2000-04-26 00:29:59 +00:00
}
}
RETURN_LONG ( count ) ;
}
2000-06-06 20:42:33 +00:00
/* }}} */
2000-07-08 22:55:40 +00:00
/* {{{ proto string str_pad(string input, int pad_length [, string pad_string [, int pad_type]])
2000-06-06 20:42:33 +00:00
Returns input string padded on the left or right to specified length with pad_string */
PHP_FUNCTION ( str_pad )
{
2000-07-08 20:38:23 +00:00
/* Input arguments */
2008-06-25 12:16:17 +00:00
char * input ; /* Input string */
int input_len ;
2008-06-30 10:39:34 +00:00
long pad_length ; /* Length to pad to */
2000-07-08 20:38:23 +00:00
/* Helper variables */
int num_pad_chars ; /* Number of padding characters (total - input size) */
2000-06-06 20:42:33 +00:00
char * result = NULL ; /* Resulting string */
int result_len = 0 ; /* Length of the resulting string */
char * pad_str_val = " " ; /* Pointer to padding string */
int pad_str_len = 1 ; /* Length of the padding string */
2008-06-30 10:39:34 +00:00
long pad_type_val = STR_PAD_RIGHT ; /* The padding type value */
2000-07-18 20:40:23 +00:00
int i , left_pad = 0 , right_pad = 0 ;
2000-06-06 20:42:33 +00:00
2008-06-25 12:16:17 +00:00
if ( zend_parse_parameters ( ZEND_NUM_ARGS ( ) TSRMLS_CC , " sl|sl " , & input , & input_len , & pad_length ,
& pad_str_val , & pad_str_len , & pad_type_val ) = = FAILURE ) {
return ;
2000-06-06 20:42:33 +00:00
}
2008-06-25 12:16:17 +00:00
num_pad_chars = pad_length - input_len ;
2000-06-06 20:42:33 +00:00
/* If resulting string turns out to be shorter than input string,
we simply copy the input and return . */
2008-06-25 12:16:17 +00:00
if ( pad_length < 0 | | num_pad_chars < 0 ) {
RETURN_STRINGL ( input , input_len , 1 ) ;
2000-06-06 20:42:33 +00:00
}
2008-06-25 12:16:17 +00:00
if ( pad_str_len = = 0 ) {
php_error_docref ( NULL TSRMLS_CC , E_WARNING , " Padding string cannot be empty " ) ;
return ;
}
if ( pad_type_val < STR_PAD_LEFT | | pad_type_val > STR_PAD_BOTH ) {
php_error_docref ( NULL TSRMLS_CC , E_WARNING , " Padding type has to be STR_PAD_LEFT, STR_PAD_RIGHT, or STR_PAD_BOTH " ) ;
return ;
2000-06-06 20:42:33 +00:00
}
2008-06-25 12:16:17 +00:00
result = ( char * ) emalloc ( input_len + num_pad_chars + 1 ) ;
2000-06-06 20:42:33 +00:00
2000-07-08 20:38:23 +00:00
/* We need to figure out the left/right padding lengths. */
switch ( pad_type_val ) {
case STR_PAD_RIGHT :
left_pad = 0 ;
right_pad = num_pad_chars ;
break ;
case STR_PAD_LEFT :
left_pad = num_pad_chars ;
right_pad = 0 ;
break ;
case STR_PAD_BOTH :
left_pad = num_pad_chars / 2 ;
right_pad = num_pad_chars - left_pad ;
break ;
2000-06-06 20:42:33 +00:00
}
2000-07-08 20:38:23 +00:00
/* First we pad on the left. */
for ( i = 0 ; i < left_pad ; i + + )
result [ result_len + + ] = pad_str_val [ i % pad_str_len ] ;
/* Then we copy the input string. */
2008-06-25 12:16:17 +00:00
memcpy ( result + result_len , input , input_len ) ;
result_len + = input_len ;
2000-07-08 20:38:23 +00:00
/* Finally, we pad on the right. */
for ( i = 0 ; i < right_pad ; i + + )
2000-06-06 20:42:33 +00:00
result [ result_len + + ] = pad_str_val [ i % pad_str_len ] ;
2000-06-12 16:06:27 +00:00
result [ result_len ] = ' \0 ' ;
2000-06-06 20:42:33 +00:00
RETURN_STRINGL ( result , result_len , 0 ) ;
}
2000-06-06 18:58:15 +00:00
/* }}} */
2000-07-09 19:33:19 +00:00
/* {{{ proto mixed sscanf(string str, string format [, string ...])
Implements an ANSI C compatible sscanf */
2000-06-06 18:58:15 +00:00
PHP_FUNCTION ( sscanf )
{
2008-08-16 21:32:41 +00:00
zval * * * args = NULL ;
char * str , * format ;
int str_len , format_len , result , num_args = 0 ;
2001-09-03 04:49:36 +00:00
2008-08-16 21:32:41 +00:00
if ( zend_parse_parameters ( ZEND_NUM_ARGS ( ) TSRMLS_CC , " ss* " , & str , & str_len , & format , & format_len ,
& args , & num_args ) = = FAILURE ) {
return ;
2000-06-06 18:58:15 +00:00
}
2008-08-16 21:32:41 +00:00
result = php_sscanf_internal ( str , format , num_args , args , 0 , & return_value TSRMLS_CC ) ;
if ( args ) {
2001-09-03 04:49:36 +00:00
efree ( args ) ;
2000-06-06 18:58:15 +00:00
}
if ( SCAN_ERROR_WRONG_PARAM_COUNT = = result ) {
2000-06-12 16:06:27 +00:00
WRONG_PARAM_COUNT ;
2000-06-06 18:58:15 +00:00
}
}
/* }}} */
2002-08-20 20:47:47 +00:00
static char rot13_from [ ] = " abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ " ;
static char rot13_to [ ] = " nopqrstuvwxyzabcdefghijklmNOPQRSTUVWXYZABCDEFGHIJKLM " ;
2001-12-06 21:39:01 +00:00
/* {{{ proto string str_rot13(string str)
2001-12-06 19:02:27 +00:00
Perform the rot13 transform on a string */
2001-12-06 21:39:01 +00:00
PHP_FUNCTION ( str_rot13 )
2001-12-06 19:02:27 +00:00
{
2008-06-25 12:16:17 +00:00
char * arg ;
int arglen ;
2002-07-30 10:51:33 +00:00
2008-06-25 12:16:17 +00:00
if ( zend_parse_parameters ( ZEND_NUM_ARGS ( ) TSRMLS_CC , " s " , & arg , & arglen ) = = FAILURE ) {
return ;
2001-12-06 19:02:27 +00:00
}
2006-01-28 00:14:01 +00:00
2008-06-25 12:16:17 +00:00
RETVAL_STRINGL ( arg , arglen , 1 ) ;
2001-12-06 19:02:27 +00:00
2002-09-11 14:40:52 +00:00
php_strtr ( Z_STRVAL_P ( return_value ) , Z_STRLEN_P ( return_value ) , rot13_from , rot13_to , 52 ) ;
2001-12-06 19:02:27 +00:00
}
/* }}} */
2007-06-05 13:35:26 +00:00
static void php_string_shuffle ( char * str , long len TSRMLS_DC ) /* { { { */
2002-09-25 18:06:05 +00:00
{
2002-10-08 09:52:59 +00:00
long n_elems , rnd_idx , n_left ;
char temp ;
/* The implementation is stolen from array_data_shuffle */
/* Thus the characteristics of the randomization are the same */
n_elems = len ;
if ( n_elems < = 1 ) {
return ;
}
n_left = n_elems ;
while ( - - n_left ) {
rnd_idx = php_rand ( TSRMLS_C ) ;
RAND_RANGE ( rnd_idx , 0 , n_left , PHP_RAND_MAX ) ;
if ( rnd_idx ! = n_left ) {
temp = str [ n_left ] ;
str [ n_left ] = str [ rnd_idx ] ;
str [ rnd_idx ] = temp ;
}
}
2002-09-25 18:06:05 +00:00
}
2007-06-05 13:35:26 +00:00
/* }}} */
2002-10-08 09:52:59 +00:00
/* {{{ proto void str_shuffle(string str)
2002-09-25 18:06:05 +00:00
Shuffles string . One permutation of all possible is created */
PHP_FUNCTION ( str_shuffle )
{
2008-06-25 12:16:17 +00:00
char * arg ;
int arglen ;
if ( zend_parse_parameters ( ZEND_NUM_ARGS ( ) TSRMLS_CC , " s " , & arg , & arglen ) = = FAILURE ) {
return ;
2002-09-25 18:06:05 +00:00
}
2008-06-25 12:16:17 +00:00
RETVAL_STRINGL ( arg , arglen , 1 ) ;
2002-10-09 10:33:22 +00:00
if ( Z_STRLEN_P ( return_value ) > 1 ) {
2003-01-24 12:19:59 +00:00
php_string_shuffle ( Z_STRVAL_P ( return_value ) , ( long ) Z_STRLEN_P ( return_value ) TSRMLS_CC ) ;
2002-10-09 10:33:22 +00:00
}
2002-09-25 18:06:05 +00:00
}
/* }}} */
2005-03-12 14:41:20 +00:00
/* {{{ proto mixed str_word_count(string str, [int format [, string charlist]])
2002-10-17 03:27:19 +00:00
Counts the number of words inside a string . If format of 1 is specified ,
then the function will return an array containing all the words
found inside the string . If format of 2 is specified , then the function
will return an associated array where the position of the word is the key
and the word itself is the value .
For the purpose of this function , ' word ' is defined as a locale dependent
string containing alphabetic characters , which also may contain , but not start
with " ' " and " - " characters .
*/
2002-10-17 22:44:44 +00:00
PHP_FUNCTION ( str_word_count )
2002-10-17 03:27:19 +00:00
{
2005-03-12 17:51:19 +00:00
char * buf , * str , * char_list = NULL , * p , * e , * s , ch [ 256 ] ;
int str_len , char_list_len , word_count = 0 ;
long type = 0 ;
if ( zend_parse_parameters ( ZEND_NUM_ARGS ( ) TSRMLS_CC , " s|ls " , & str , & str_len , & type , & char_list , & char_list_len ) = = FAILURE ) {
2006-10-11 13:15:30 +00:00
return ;
2002-10-17 03:27:19 +00:00
}
2005-03-12 17:51:19 +00:00
2006-10-11 13:15:30 +00:00
switch ( type ) {
case 1 :
case 2 :
array_init ( return_value ) ;
2006-10-11 14:19:55 +00:00
if ( ! str_len ) {
return ;
}
2006-10-11 13:15:30 +00:00
break ;
case 0 :
2006-10-11 14:19:55 +00:00
if ( ! str_len ) {
RETURN_LONG ( 0 ) ;
}
2006-10-11 13:15:30 +00:00
/* nothing to be done */
break ;
default :
php_error_docref ( NULL TSRMLS_CC , E_WARNING , " Invalid format value %ld " , type ) ;
RETURN_FALSE ;
2002-10-17 03:27:19 +00:00
}
2005-11-29 16:14:19 +00:00
2006-10-11 14:19:55 +00:00
if ( char_list ) {
php_charmask ( char_list , char_list_len , ch TSRMLS_CC ) ;
}
p = str ;
e = str + str_len ;
2005-11-29 16:14:19 +00:00
/* first character cannot be ' or -, unless explicitly allowed by the user */
if ( ( * p = = ' \' ' & & ( ! char_list | | ! ch [ ' \' ' ] ) ) | | ( * p = = ' - ' & & ( ! char_list | | ! ch [ ' - ' ] ) ) ) {
p + + ;
}
/* last character cannot be -, unless explicitly allowed by the user */
2006-10-11 14:19:55 +00:00
if ( * ( e - 1 ) = = ' - ' & & ( ! char_list | | ! ch [ ' - ' ] ) ) {
2005-11-29 16:14:19 +00:00
e - - ;
}
2002-10-17 03:27:19 +00:00
while ( p < e ) {
2005-11-29 16:14:19 +00:00
s = p ;
2008-01-16 08:34:33 +00:00
while ( p < e & & ( isalpha ( ( unsigned char ) * p ) | | ( char_list & & ch [ ( unsigned char ) * p ] ) | | * p = = ' \' ' | | * p = = ' - ' ) ) {
2005-11-29 16:14:19 +00:00
p + + ;
}
if ( p > s ) {
2002-10-17 03:27:19 +00:00
switch ( type )
{
case 1 :
buf = estrndup ( s , ( p - s ) ) ;
2005-11-29 16:14:19 +00:00
add_next_index_stringl ( return_value , buf , ( p - s ) , 0 ) ;
2002-10-17 03:27:19 +00:00
break ;
case 2 :
buf = estrndup ( s , ( p - s ) ) ;
2005-11-29 16:14:19 +00:00
add_index_stringl ( return_value , ( s - str ) , buf , p - s , 0 ) ;
2002-10-17 03:27:19 +00:00
break ;
default :
word_count + + ;
break ;
}
2005-07-23 19:44:13 +00:00
}
2005-11-29 16:14:19 +00:00
p + + ;
2002-10-17 03:27:19 +00:00
}
if ( ! type ) {
RETURN_LONG ( word_count ) ;
}
}
/* }}} */
2002-09-25 18:06:05 +00:00
2002-08-02 10:08:53 +00:00
# if HAVE_STRFMON
/* {{{ proto string money_format(string format , float value)
Convert monetary value ( s ) to string */
2003-02-08 15:26:17 +00:00
PHP_FUNCTION ( money_format )
{
2002-08-21 13:14:57 +00:00
int format_len = 0 , str_len ;
2007-06-06 17:59:07 +00:00
char * format , * str , * p , * e ;
2002-08-02 10:08:53 +00:00
double value ;
2007-06-06 17:59:07 +00:00
zend_bool check = 0 ;
2002-08-02 10:08:53 +00:00
2003-02-08 15:26:17 +00:00
if ( zend_parse_parameters ( ZEND_NUM_ARGS ( ) TSRMLS_CC , " sd " , & format , & format_len , & value ) = = FAILURE ) {
2002-08-02 10:08:53 +00:00
return ;
}
2007-06-06 17:59:07 +00:00
p = format ;
e = p + format_len ;
while ( ( p = memchr ( p , ' % ' , ( e - p ) ) ) ) {
if ( * ( p + 1 ) = = ' % ' ) {
p + = 2 ;
} else if ( ! check ) {
check = 1 ;
p + + ;
} else {
php_error_docref ( NULL TSRMLS_CC , E_WARNING , " Only a single %%i or %%n token can be used " ) ;
RETURN_FALSE ;
}
}
2002-08-21 13:14:57 +00:00
str_len = format_len + 1024 ;
str = emalloc ( str_len ) ;
2003-04-16 01:07:03 +00:00
if ( ( str_len = strfmon ( str , str_len , format , value ) ) < 0 ) {
efree ( str ) ;
RETURN_FALSE ;
}
2002-08-21 13:14:57 +00:00
str [ str_len ] = 0 ;
2002-08-02 10:08:53 +00:00
2002-08-21 13:14:57 +00:00
RETURN_STRINGL ( erealloc ( str , str_len + 1 ) , str_len , 0 ) ;
2002-08-02 10:08:53 +00:00
}
/* }}} */
# endif
2003-02-07 21:36:18 +00:00
/* {{{ proto array str_split(string str [, int split_length])
Convert a string to an array . If split_length is specified , break the string down into chunks each split_length characters long . */
2003-02-08 15:26:17 +00:00
PHP_FUNCTION ( str_split )
{
2003-02-07 21:36:18 +00:00
char * str ;
int str_len ;
long split_length = 1 ;
char * p ;
int n_reg_segments ;
if ( zend_parse_parameters ( ZEND_NUM_ARGS ( ) TSRMLS_CC , " s|l " , & str , & str_len , & split_length ) = = FAILURE ) {
return ;
}
if ( split_length < = 0 ) {
2007-09-30 05:40:23 +00:00
php_error_docref ( NULL TSRMLS_CC , E_WARNING , " The length of each segment must be greater than zero " ) ;
2003-02-07 21:36:18 +00:00
RETURN_FALSE ;
}
2008-05-27 10:29:33 +00:00
array_init_size ( return_value , ( ( str_len - 1 ) / split_length ) + 1 ) ;
2003-02-07 21:36:18 +00:00
2004-10-20 22:44:43 +00:00
if ( split_length > = str_len ) {
add_next_index_stringl ( return_value , str , str_len , 1 ) ;
return ;
}
2008-05-27 10:29:33 +00:00
n_reg_segments = str_len / split_length ;
2003-02-07 21:36:18 +00:00
p = str ;
while ( n_reg_segments - - > 0 ) {
add_next_index_stringl ( return_value , p , split_length , 1 ) ;
p + = split_length ;
}
if ( p ! = ( str + str_len ) ) {
add_next_index_stringl ( return_value , p , ( str + str_len - p ) , 1 ) ;
}
}
/* }}} */
2003-02-11 22:47:26 +00:00
/* {{{ proto array strpbrk(string haystack, string char_list)
Search a string for any of a set of characters */
PHP_FUNCTION ( strpbrk )
{
char * haystack , * char_list ;
int haystack_len , char_list_len ;
char * p ;
if ( zend_parse_parameters ( ZEND_NUM_ARGS ( ) TSRMLS_CC , " ss " , & haystack , & haystack_len , & char_list , & char_list_len ) = = FAILURE ) {
RETURN_FALSE ;
}
if ( ! char_list_len ) {
2007-09-30 05:40:23 +00:00
php_error_docref ( NULL TSRMLS_CC , E_WARNING , " The character list cannot be empty " ) ;
2003-02-11 22:47:26 +00:00
RETURN_FALSE ;
}
if ( ( p = strpbrk ( haystack , char_list ) ) ) {
RETURN_STRINGL ( p , ( haystack + haystack_len - p ) , 1 ) ;
} else {
RETURN_FALSE ;
}
}
/* }}} */
2003-02-07 21:36:18 +00:00
2003-10-30 00:49:33 +00:00
/* {{{ proto int substr_compare(string main_str, string str, int offset [, int length [, bool case_sensitivity]])
Binary safe optionally case insensitive comparison of 2 strings from an offset , up to length characters */
PHP_FUNCTION ( substr_compare )
{
char * s1 , * s2 ;
int s1_len , s2_len ;
long offset , len = 0 ;
zend_bool cs = 0 ;
uint cmp_len ;
if ( zend_parse_parameters ( ZEND_NUM_ARGS ( ) TSRMLS_CC , " ssl|lb " , & s1 , & s1_len , & s2 , & s2_len , & offset , & len , & cs ) = = FAILURE ) {
RETURN_FALSE ;
}
2006-04-25 12:48:42 +00:00
if ( ZEND_NUM_ARGS ( ) > = 4 & & len < = 0 ) {
php_error_docref ( NULL TSRMLS_CC , E_WARNING , " The length must be greater than zero " ) ;
2003-10-30 00:49:33 +00:00
RETURN_FALSE ;
}
2005-09-28 22:39:52 +00:00
if ( offset < 0 ) {
offset = s1_len + offset ;
2006-04-25 12:48:42 +00:00
offset = ( offset < 0 ) ? 0 : offset ;
}
2008-02-13 17:02:16 +00:00
if ( offset > = s1_len ) {
2006-04-25 12:48:42 +00:00
php_error_docref ( NULL TSRMLS_CC , E_WARNING , " The start position cannot exceed initial string length " ) ;
RETURN_FALSE ;
2005-09-28 22:39:52 +00:00
}
2007-10-01 13:38:14 +00:00
if ( len > s1_len - offset ) {
2008-02-13 17:02:16 +00:00
len = s1_len - offset ;
2007-03-08 00:47:04 +00:00
}
2003-10-30 00:49:33 +00:00
cmp_len = ( uint ) ( len ? len : MAX ( s2_len , ( s1_len - offset ) ) ) ;
if ( ! cs ) {
RETURN_LONG ( zend_binary_strncmp ( s1 + offset , ( s1_len - offset ) , s2 , s2_len , cmp_len ) ) ;
} else {
RETURN_LONG ( zend_binary_strncasecmp ( s1 + offset , ( s1_len - offset ) , s2 , s2_len , cmp_len ) ) ;
}
}
/* }}} */
2000-06-01 10:07:44 +00:00
/*
* Local variables :
* tab - width : 4
* c - basic - offset : 4
* End :
2001-09-09 12:55:48 +00:00
* vim600 : noet sw = 4 ts = 4 fdm = marker
* vim < 600 : noet sw = 4 ts = 4
2000-06-01 10:07:44 +00:00
*/