Back to index

php5  5.3.10
Defines | Functions | Variables
locale_methods.c File Reference
#include <unicode/ustring.h>
#include <unicode/udata.h>
#include <unicode/putil.h>
#include <unicode/ures.h>
#include "php_intl.h"
#include "locale.h"
#include "locale_class.h"
#include "locale_methods.h"
#include "intl_convert.h"
#include "intl_data.h"
#include <zend_API.h>
#include <zend.h>
#include <php.h>
#include "main/php_ini.h"
#include "ext/standard/php_smart_str.h"

Go to the source code of this file.

Defines

#define SEPARATOR   "_"
#define SEPARATOR1   "-"
#define DELIMITER   "-_"
#define EXTLANG_PREFIX   "a"
#define PRIVATE_PREFIX   "x"
#define DISP_NAME   "name"
#define MAX_NO_VARIANT   15
#define MAX_NO_EXTLANG   3
#define MAX_NO_PRIVATE   15
#define MAX_NO_LOOKUP_LANG_TAG   100
#define LOC_NOT_FOUND   1
#define VARIANT_KEYNAME_LEN   11
#define EXTLANG_KEYNAME_LEN   10
#define PRIVATE_KEYNAME_LEN   11
#define isIDSeparator(a)   (a == '_' || a == '-')
#define isKeywordSeparator(a)   (a == '@' )
#define isEndOfTag(a)   (a == '\0' )
#define isPrefixLetter(a)   ((a=='x')||(a=='X')||(a=='i')||(a=='I'))
#define isIDPrefix(s)   (isPrefixLetter(s[0])&&isIDSeparator(s[1]))
#define isKeywordPrefix(s)   ( isKeywordSeparator(s[0]) )
#define isTerminator(a)   ((a==0)||(a=='.')||(a=='@'))
#define RETURN_SMART_STR(s)   smart_str_0((s)); RETURN_STRINGL((s)->c, (s)->len, 0)
#define LOOKUP_CLEAN_RETURN(value)   array_cleanup(cur_arr, cur_arr_len); return (value)

Functions

static int16_t findOffset (const char *const *list, const char *key)
static char * getPreferredTag (char *gf_tag)
static int getStrrtokenPos (char *str, int savedPos)
static int getSingletonPos (char *str)
 PHP_NAMED_FUNCTION (zif_locale_get_default)
 PHP_NAMED_FUNCTION (zif_locale_set_default)
static char * get_icu_value_internal (char *loc_name, char *tag_name, int *result, int fromParseLocale)
static void get_icu_value_src_php (char *tag_name, INTERNAL_FUNCTION_PARAMETERS)
 PHP_FUNCTION (locale_get_script)
 PHP_FUNCTION (locale_get_region)
 PHP_FUNCTION (locale_get_primary_language)
static void get_icu_disp_value_src_php (char *tag_name, INTERNAL_FUNCTION_PARAMETERS)
 PHP_FUNCTION (locale_get_display_name)
 PHP_FUNCTION (locale_get_display_language)
 PHP_FUNCTION (locale_get_display_script)
 PHP_FUNCTION (locale_get_display_region)
 PHP_FUNCTION (locale_get_display_variant)
 PHP_FUNCTION (locale_get_keywords)
 PHP_FUNCTION (locale_canonicalize)
static int append_key_value (smart_str *loc_name, HashTable *hash_arr, char *key_name)
static void add_prefix (smart_str *loc_name, char *key_name)
static int append_multiple_key_values (smart_str *loc_name, HashTable *hash_arr, char *key_name TSRMLS_DC)
static int handleAppendResult (int result, smart_str *loc_name TSRMLS_DC)
 PHP_FUNCTION (locale_compose)
static char * get_private_subtags (char *loc_name)
static int add_array_entry (char *loc_name, zval *hash_arr, char *key_name TSRMLS_DC)
 PHP_FUNCTION (locale_parse)
 PHP_FUNCTION (locale_get_all_variants)
static int strToMatch (char *str, char *retstr)
 PHP_FUNCTION (locale_filter_matches)
static void array_cleanup (char *arr[], int arr_size)
static char * lookup_loc_range (char *loc_range, HashTable *hash_arr, int canonicalize TSRMLS_DC)
 PHP_FUNCTION (locale_lookup)
 PHP_FUNCTION (locale_accept_from_http)

Variables

static const char *const LOC_GRANDFATHERED []
static const int LOC_PREFERRED_GRANDFATHERED_LEN = 6
static const char *const LOC_PREFERRED_GRANDFATHERED []

Define Documentation

#define DELIMITER   "-_"

Definition at line 46 of file locale_methods.c.

#define DISP_NAME   "name"

Definition at line 49 of file locale_methods.c.

#define EXTLANG_KEYNAME_LEN   10

Definition at line 60 of file locale_methods.c.

#define EXTLANG_PREFIX   "a"

Definition at line 47 of file locale_methods.c.

#define isEndOfTag (   a)    (a == '\0' )

Definition at line 94 of file locale_methods.c.

#define isIDPrefix (   s)    (isPrefixLetter(s[0])&&isIDSeparator(s[1]))

Definition at line 100 of file locale_methods.c.

#define isIDSeparator (   a)    (a == '_' || a == '-')

Definition at line 92 of file locale_methods.c.

#define isKeywordPrefix (   s)    ( isKeywordSeparator(s[0]) )

Definition at line 101 of file locale_methods.c.

#define isKeywordSeparator (   a)    (a == '@' )

Definition at line 93 of file locale_methods.c.

#define isPrefixLetter (   a)    ((a=='x')||(a=='X')||(a=='i')||(a=='I'))

Definition at line 96 of file locale_methods.c.

#define isTerminator (   a)    ((a==0)||(a=='.')||(a=='@'))

Definition at line 105 of file locale_methods.c.

#define LOC_NOT_FOUND   1

Definition at line 56 of file locale_methods.c.

#define LOOKUP_CLEAN_RETURN (   value)    array_cleanup(cur_arr, cur_arr_len); return (value)

Definition at line 1398 of file locale_methods.c.

#define MAX_NO_EXTLANG   3

Definition at line 52 of file locale_methods.c.

#define MAX_NO_LOOKUP_LANG_TAG   100

Definition at line 54 of file locale_methods.c.

#define MAX_NO_PRIVATE   15

Definition at line 53 of file locale_methods.c.

#define MAX_NO_VARIANT   15

Definition at line 51 of file locale_methods.c.

#define PRIVATE_KEYNAME_LEN   11

Definition at line 61 of file locale_methods.c.

#define PRIVATE_PREFIX   "x"

Definition at line 48 of file locale_methods.c.

#define RETURN_SMART_STR (   s)    smart_str_0((s)); RETURN_STRINGL((s)->c, (s)->len, 0)

Definition at line 884 of file locale_methods.c.

#define SEPARATOR   "_"

Definition at line 44 of file locale_methods.c.

#define SEPARATOR1   "-"

Definition at line 45 of file locale_methods.c.

#define VARIANT_KEYNAME_LEN   11

Definition at line 59 of file locale_methods.c.


Function Documentation

static int add_array_entry ( char *  loc_name,
zval *  hash_arr,
char *key_name  TSRMLS_DC 
) [static]

Definition at line 1021 of file locale_methods.c.

{
       char*   key_value    = NULL;
       char*   cur_key_name = NULL;
       char*   token               = NULL;
       char*   last_ptr     = NULL;

       int    result        = 0;
       int    cur_result    = 0;
       int    cnt           = 0;


       if( strcmp(key_name , LOC_PRIVATE_TAG)==0 ){
              key_value = get_private_subtags( loc_name );
              result = 1;
       } else {
              key_value = get_icu_value_internal( loc_name , key_name , &result,1 );
       }
       if( (strcmp(key_name , LOC_PRIVATE_TAG)==0) || 
              ( strcmp(key_name , LOC_VARIANT_TAG)==0) ){
              if( result > 0 && key_value){
                     /* Tokenize on the "_" or "-"  */
                     token = php_strtok_r( key_value , DELIMITER ,&last_ptr);       
                     if( cur_key_name ){
                            efree( cur_key_name);
                     }
                     cur_key_name = (char*)ecalloc( 25,  25);
                     sprintf( cur_key_name , "%s%d", key_name , cnt++);      
                     add_assoc_string( hash_arr, cur_key_name , token ,TRUE );
                     /* tokenize on the "_" or "-" and stop  at singleton if any */
                     while( (token = php_strtok_r(NULL , DELIMITER , &last_ptr)) && (strlen(token)>1) ){
                            sprintf( cur_key_name , "%s%d", key_name , cnt++);      
                            add_assoc_string( hash_arr, cur_key_name , token , TRUE );
                     }
/*
                     if( strcmp(key_name, LOC_PRIVATE_TAG) == 0 ){
                     }
*/
              }
       } else {
              if( result == 1 ){
                     add_assoc_string( hash_arr, key_name , key_value , TRUE );
                     cur_result = 1;
              }
       }

       if( cur_key_name ){
              efree( cur_key_name);
       }
       /*if( key_name != LOC_PRIVATE_TAG && key_value){*/
       if( key_value){
              efree(key_value);    
       }
       return cur_result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void add_prefix ( smart_str loc_name,
char *  key_name 
) [static]

Definition at line 778 of file locale_methods.c.

{
       if( strncmp(key_name , LOC_PRIVATE_TAG , 7) == 0 ){
              smart_str_appendl(loc_name, SEPARATOR , sizeof(SEPARATOR)-1);
              smart_str_appendl(loc_name, PRIVATE_PREFIX , sizeof(PRIVATE_PREFIX)-1);
       }
}

Here is the caller graph for this function:

static int append_key_value ( smart_str loc_name,
HashTable hash_arr,
char *  key_name 
) [static]

Definition at line 753 of file locale_methods.c.

{
       zval** ele_value     = NULL;

       if(zend_hash_find(hash_arr , key_name , strlen(key_name) + 1 ,(void **)&ele_value ) == SUCCESS ) {
              if(Z_TYPE_PP(ele_value)!= IS_STRING ){
                     /* element value is not a string */
                     return FAILURE;
              }
              if(strcmp(key_name, LOC_LANG_TAG) != 0 && 
                 strcmp(key_name, LOC_GRANDFATHERED_LANG_TAG)!=0 ) {
                     /* not lang or grandfathered tag */
                     smart_str_appendl(loc_name, SEPARATOR , sizeof(SEPARATOR)-1);
              }
              smart_str_appendl(loc_name, Z_STRVAL_PP(ele_value) , Z_STRLEN_PP(ele_value));
              return SUCCESS;
       }

       return LOC_NOT_FOUND;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int append_multiple_key_values ( smart_str loc_name,
HashTable hash_arr,
char *key_name  TSRMLS_DC 
) [static]

Definition at line 794 of file locale_methods.c.

{
       zval** ele_value     = NULL;
       int    i             = 0;
       int    isFirstSubtag        = 0;
       int    max_value     = 0;

       /* Variant/ Extlang/Private etc. */
       if( zend_hash_find( hash_arr , key_name , strlen(key_name) + 1 ,(void **)&ele_value ) == SUCCESS ) {
              if( Z_TYPE_PP(ele_value) == IS_STRING ){
                     add_prefix( loc_name , key_name);

                     smart_str_appendl(loc_name, SEPARATOR , sizeof(SEPARATOR)-1);
                     smart_str_appendl(loc_name, Z_STRVAL_PP(ele_value) , Z_STRLEN_PP(ele_value));
                     return SUCCESS;
              } else if(Z_TYPE_PP(ele_value) == IS_ARRAY ) {
                     HashPosition pos;
                     HashTable *arr = HASH_OF(*ele_value);
                     zval **data = NULL;

                     zend_hash_internal_pointer_reset_ex(arr, &pos);
                     while(zend_hash_get_current_data_ex(arr, (void **)&data, &pos) != FAILURE) {
                            if(Z_TYPE_PP(data) != IS_STRING) {
                                   return FAILURE;
                            }
                            if (isFirstSubtag++ == 0){
                                   add_prefix(loc_name , key_name);
                            }
                            smart_str_appendl(loc_name, SEPARATOR , sizeof(SEPARATOR)-1);
                            smart_str_appendl(loc_name, Z_STRVAL_PP(data) , Z_STRLEN_PP(data));
                            zend_hash_move_forward_ex(arr, &pos);
                     }
                     return SUCCESS;
              } else {
                     return FAILURE;
              }
       } else {
              char cur_key_name[31];
              /* Decide the max_value: the max. no. of elements allowed */
              if( strcmp(key_name , LOC_VARIANT_TAG) ==0 ){
                     max_value  = MAX_NO_VARIANT;
              }
              if( strcmp(key_name , LOC_EXTLANG_TAG) ==0 ){
                     max_value  = MAX_NO_EXTLANG;
              }
              if( strcmp(key_name , LOC_PRIVATE_TAG) ==0 ){
                     max_value  = MAX_NO_PRIVATE;
              }

              /* Multiple variant values as variant0, variant1 ,variant2 */
              isFirstSubtag = 0;
              for( i=0 ; i< max_value; i++ ){  
                     snprintf( cur_key_name , 30, "%s%d", key_name , i);     
                     if( zend_hash_find( hash_arr , cur_key_name , strlen(cur_key_name) + 1,(void **)&ele_value ) == SUCCESS ){
                            if( Z_TYPE_PP(ele_value)!= IS_STRING ){
                                   /* variant is not a string */
                                   return FAILURE;
                            }
                            /* Add the contents */
                            if (isFirstSubtag++ == 0){
                                   add_prefix(loc_name , cur_key_name);
                            }
                            smart_str_appendl(loc_name, SEPARATOR , sizeof(SEPARATOR)-1);
                            smart_str_appendl(loc_name, Z_STRVAL_PP(ele_value) , Z_STRLEN_PP(ele_value));
                     }
              } /* end of for */
       } /* end of else */

       return SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void array_cleanup ( char *  arr[],
int  arr_size 
) [static]

Definition at line 1387 of file locale_methods.c.

{
       int i=0;
       for( i=0; i< arr_size; i++ ){ 
              if( arr[i*2] ){
                     efree( arr[i*2]);
              }
       }
       efree(arr);
}
static int16_t findOffset ( const char *const *  list,
const char *  key 
) [static]

Definition at line 109 of file locale_methods.c.

{
       const char* const* anchor = list;
       while (*list != NULL) {
              if (strcmp(key, *list) == 0) {
                     return (int16_t)(list - anchor);
              }
              list++;
       }

       return -1;

}

Here is the caller graph for this function:

static void get_icu_disp_value_src_php ( char *  tag_name,
INTERNAL_FUNCTION_PARAMETERS   
) [static]

Definition at line 466 of file locale_methods.c.

{
       char*       loc_name               = NULL;
       int         loc_name_len           = 0;

       char*       disp_loc_name       = NULL;
       int         disp_loc_name_len   = 0;
       int         free_loc_name       = 0;

       UChar*      disp_name       = NULL;
       int32_t     disp_name_len   = 0;

       char*       mod_loc_name        = NULL;

       int32_t     buflen                 = 512;
       UErrorCode  status                 = U_ZERO_ERROR;

       char*       utf8value              = NULL;
       int         utf8value_len          = 0;

       char*       msg                    = NULL;
       int         grOffset        = 0;

       intl_error_reset( NULL TSRMLS_CC );

       if(zend_parse_parameters( ZEND_NUM_ARGS() TSRMLS_CC, "s|s",
              &loc_name, &loc_name_len , 
              &disp_loc_name ,&disp_loc_name_len ) == FAILURE)
       {
              spprintf(&msg , 0, "locale_get_display_%s : unable to parse input params", tag_name );
              intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR,  msg , 1 TSRMLS_CC );
              efree(msg);
              RETURN_FALSE;
       }

       if(loc_name_len == 0) {
       loc_name = INTL_G(default_locale);
       }

       if( strcmp(tag_name, DISP_NAME) != 0 ){
              /* Handle grandfathered languages */
              grOffset = findOffset( LOC_GRANDFATHERED , loc_name );
              if( grOffset >= 0 ){
                     if( strcmp(tag_name , LOC_LANG_TAG)==0 ){
                            mod_loc_name = getPreferredTag( loc_name );
                     } else {
                            /* Since Grandfathered, no value, do nothing, retutn NULL */
                            RETURN_FALSE;
                     }
              }
       } /* end of if != LOC_CANONICAL_TAG */

       if( mod_loc_name==NULL ){
              mod_loc_name = estrdup( loc_name );
       }
       
       /* Check if disp_loc_name passed , if not use default locale */
       if( !disp_loc_name){
              disp_loc_name = estrdup(INTL_G(default_locale));
              free_loc_name = 1;
       }

    /* Get the disp_value for the given locale */
    do{
        disp_name = erealloc( disp_name , buflen  );
        disp_name_len = buflen;

              if( strcmp(tag_name , LOC_LANG_TAG)==0 ){
                     buflen = uloc_getDisplayLanguage ( mod_loc_name , disp_loc_name , disp_name , disp_name_len , &status);
              } else if( strcmp(tag_name , LOC_SCRIPT_TAG)==0 ){
                     buflen = uloc_getDisplayScript ( mod_loc_name , disp_loc_name , disp_name , disp_name_len , &status);
              } else if( strcmp(tag_name , LOC_REGION_TAG)==0 ){
                     buflen = uloc_getDisplayCountry ( mod_loc_name , disp_loc_name , disp_name , disp_name_len , &status);
              } else if( strcmp(tag_name , LOC_VARIANT_TAG)==0 ){
                     buflen = uloc_getDisplayVariant ( mod_loc_name , disp_loc_name , disp_name , disp_name_len , &status);
              } else if( strcmp(tag_name , DISP_NAME)==0 ){
                     buflen = uloc_getDisplayName ( mod_loc_name , disp_loc_name , disp_name , disp_name_len , &status);
              }

              if( U_FAILURE( status ) )
              {
                     if( status == U_BUFFER_OVERFLOW_ERROR )
                     {
                            status = U_ZERO_ERROR;
                            continue;
                     }

                     spprintf(&msg, 0, "locale_get_display_%s : unable to get locale %s", tag_name , tag_name );
                     intl_error_set( NULL, status, msg , 1 TSRMLS_CC );
                     efree(msg);
                     if( disp_name){
                            efree( disp_name );
                     }
                     if( mod_loc_name){
                            efree( mod_loc_name );
                     }
                     if (free_loc_name) {
                            efree(disp_loc_name);
                            disp_loc_name = NULL;
                     }
                     RETURN_FALSE;
              }
       } while( buflen > disp_name_len );

       if( mod_loc_name){
              efree( mod_loc_name );
       }
       if (free_loc_name) {
              efree(disp_loc_name);
              disp_loc_name = NULL;
       }
       /* Convert display locale name from UTF-16 to UTF-8. */
       intl_convert_utf16_to_utf8( &utf8value, &utf8value_len, disp_name, buflen, &status );
       efree( disp_name );
       if( U_FAILURE( status ) )
       {
              spprintf(&msg, 0, "locale_get_display_%s :error converting display name for %s to UTF-8", tag_name , tag_name );
              intl_error_set( NULL, status, msg , 1 TSRMLS_CC );
              efree(msg);
              RETURN_FALSE;
       }

       RETVAL_STRINGL( utf8value, utf8value_len , FALSE);

}

Here is the call graph for this function:

Here is the caller graph for this function:

static char* get_icu_value_internal ( char *  loc_name,
char *  tag_name,
int result,
int  fromParseLocale 
) [static]

Definition at line 254 of file locale_methods.c.

{
       char*         tag_value     = NULL;
       int32_t       tag_value_len   = 512;

       int           singletonPos         = 0;
       char*         mod_loc_name  = NULL;
       int           grOffset      = 0;

       int32_t       buflen          = 512;
       UErrorCode    status          = U_ZERO_ERROR;


       if( strcmp(tag_name, LOC_CANONICALIZE_TAG) != 0 ){
              /* Handle  grandfathered languages */
              grOffset =  findOffset( LOC_GRANDFATHERED , loc_name );
              if( grOffset >= 0 ){
                     if( strcmp(tag_name , LOC_LANG_TAG)==0 ){
                            tag_value = estrdup(loc_name);
                            return tag_value;
                     } else {
                            /* Since Grandfathered , no value , do nothing , retutn NULL */
                            return NULL;
                     }
              }

       if( fromParseLocale==1 ){
              /* Handle singletons */
              if( strcmp(tag_name , LOC_LANG_TAG)==0 ){
                     if( strlen(loc_name)>1 && (isIDPrefix(loc_name) ==1 ) ){
                            return loc_name;
                     }
              }

              singletonPos = getSingletonPos( loc_name );      
              if( singletonPos == 0){
                     /* singleton at start of script, region , variant etc.
                      * or invalid singleton at start of language */
                     return NULL;
              } else if( singletonPos > 0 ){
                     /* singleton at some position except at start
                      * strip off the singleton and rest of the loc_name */
                     mod_loc_name = estrndup ( loc_name , singletonPos-1);
              }
       } /* end of if fromParse */

       } /* end of if != LOC_CANONICAL_TAG */

       if( mod_loc_name == NULL){
              mod_loc_name = estrdup(loc_name ); 
       }

       /* Proceed to ICU */
    do{
              tag_value = erealloc( tag_value , buflen  );
              tag_value_len = buflen;

              if( strcmp(tag_name , LOC_SCRIPT_TAG)==0 ){
                     buflen = uloc_getScript ( mod_loc_name ,tag_value , tag_value_len , &status);
              }
              if( strcmp(tag_name , LOC_LANG_TAG )==0 ){
                     buflen = uloc_getLanguage ( mod_loc_name ,tag_value , tag_value_len , &status);
              }
              if( strcmp(tag_name , LOC_REGION_TAG)==0 ){
                     buflen = uloc_getCountry ( mod_loc_name ,tag_value , tag_value_len , &status);
              }
              if( strcmp(tag_name , LOC_VARIANT_TAG)==0 ){
                     buflen = uloc_getVariant ( mod_loc_name ,tag_value , tag_value_len , &status);
              }
              if( strcmp(tag_name , LOC_CANONICALIZE_TAG)==0 ){
                     buflen = uloc_canonicalize ( mod_loc_name ,tag_value , tag_value_len , &status);
              }

              if( U_FAILURE( status ) ) {
                     if( status == U_BUFFER_OVERFLOW_ERROR ) {
                            status = U_ZERO_ERROR;
                            continue;
                     }

                     /* Error in retriving data */
                     *result = 0;
                     if( tag_value ){
                            efree( tag_value );
                     }
                     if( mod_loc_name ){
                            efree( mod_loc_name);
                     }
                     return NULL;
              }
       } while( buflen > tag_value_len );

       if(  buflen ==0 ){
              /* No value found */
              *result = -1;
              if( tag_value ){
                     efree( tag_value );
              }
              if( mod_loc_name ){
                     efree( mod_loc_name);
              }
              return NULL;
       } else {
              *result = 1;
       }

       if( mod_loc_name ){
              efree( mod_loc_name);
       }
       return tag_value;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void get_icu_value_src_php ( char *  tag_name,
INTERNAL_FUNCTION_PARAMETERS   
) [static]

Definition at line 370 of file locale_methods.c.

{

       char*       loc_name               = NULL;
       int         loc_name_len           = 0;

       char*       tag_value              = NULL;
       char*       empty_result    = "";

       int         result                 = 0;
       char*       msg                    = NULL;

       UErrorCode  status                 = U_ZERO_ERROR;

       intl_error_reset( NULL TSRMLS_CC );

       if(zend_parse_parameters( ZEND_NUM_ARGS() TSRMLS_CC, "s",
       &loc_name ,&loc_name_len ) == FAILURE) {
              spprintf(&msg , 0, "locale_get_%s : unable to parse input params", tag_name );
              intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR,  msg , 1 TSRMLS_CC );
              efree(msg);

              RETURN_FALSE;
    }

       if(loc_name_len == 0) {
              loc_name = INTL_G(default_locale);
       }

       /* Call ICU get */
       tag_value = get_icu_value_internal( loc_name , tag_name , &result ,0);

       /* No value found */
       if( result == -1 ) {
              if( tag_value){
                     efree( tag_value);
              }
              RETURN_STRING( empty_result , TRUE);
       }

       /* value found */
       if( tag_value){
              RETURN_STRING( tag_value , FALSE);
       }

       /* Error encountered while fetching the value */
       if( result ==0) {
              spprintf(&msg , 0, "locale_get_%s : unable to get locale %s", tag_name , tag_name );
              intl_error_set( NULL, status, msg , 1 TSRMLS_CC );
              efree(msg);
              RETURN_NULL();
       }

}

Here is the call graph for this function:

Here is the caller graph for this function:

static char* get_private_subtags ( char *  loc_name) [static]

Definition at line 976 of file locale_methods.c.

{
       char*  result =NULL;
       int    singletonPos = 0;
       int    len =0; 
       char*  mod_loc_name =NULL;

       if( loc_name && (len = strlen(loc_name)>0 ) ){
              mod_loc_name = loc_name ; 
              len   = strlen(mod_loc_name);
              while( (singletonPos = getSingletonPos(mod_loc_name))!= -1){

                     if( singletonPos!=-1){ 
                            if( (*(mod_loc_name+singletonPos)=='x') || (*(mod_loc_name+singletonPos)=='X') ){          
                                   /* private subtag start found */
                                   if( singletonPos + 2 ==  len){
                                          /* loc_name ends with '-x-' ; return  NULL */
                                   }
                                   else{
                                          /* result = mod_loc_name + singletonPos +2; */
                                          result = estrndup(mod_loc_name + singletonPos+2  , (len -( singletonPos +2) ) );
                                   }
                                   break;
                            }
                            else{
                                   if( singletonPos + 1 >=  len){
                                          /* String end */
                                          break;
                                   } else {
                                          /* singleton found but not a private subtag , hence check further in the string for the private subtag */
                                          mod_loc_name = mod_loc_name + singletonPos +1;
                                          len = strlen(mod_loc_name);
                                   }
                            }
                     }

              } /* end of while */
       }
       
       return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static char* getPreferredTag ( char *  gf_tag) [static]

Definition at line 124 of file locale_methods.c.

{ 
       char* result = NULL;
       int grOffset = 0;

       grOffset = findOffset( LOC_GRANDFATHERED ,gf_tag);
       if( grOffset < LOC_PREFERRED_GRANDFATHERED_LEN ){
              /* return preferred tag */
              result = estrdup( LOC_PREFERRED_GRANDFATHERED[grOffset] );
       } else {
              /* Return correct grandfathered language tag */
              result = estrdup( LOC_GRANDFATHERED[grOffset] );
       }
       return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int getSingletonPos ( char *  str) [static]

Definition at line 175 of file locale_methods.c.

{
       int result =-1;
       int i=0;
       int len = 0;
       
       if( str && ((len=strlen(str))>0) ){
              for( i=0; i<len ; i++){
                     if( isIDSeparator(*(str+i)) ){
                            if( i==1){
                                   /* string is of the form x-avy or a-prv1 */
                                   result =0;
                                   break;
                            } else {
                                   /* delimiter found; check for singleton */
                                   if( isIDSeparator(*(str+i+2)) ){
                                          /* a singleton; so send the position of separator before singleton */
                                          result = i+1;
                                          break;
                                   }
                            }
                     }
              }/* end of for */
              
       }
       return result;
}

Here is the caller graph for this function:

static int getStrrtokenPos ( char *  str,
int  savedPos 
) [static]

Definition at line 145 of file locale_methods.c.

{
       int result =-1;
       int i;
       
       for(i=savedPos-1; i>=0; i--) {
              if(isIDSeparator(*(str+i)) ){
                     /* delimiter found; check for singleton */
                     if(i>=2 && isIDSeparator(*(str+i-2)) ){
                            /* a singleton; so send the position of token before the singleton */
                            result = i-2;
                     } else {
                            result = i;
                     }
                     break;
              }
       }
       if(result < 1){
              /* Just in case inavlid locale e.g. '-x-xyz' or '-sl_Latn' */
              result =-1;
       }
       return result;
}

Here is the caller graph for this function:

static int handleAppendResult ( int  result,
smart_str *loc_name  TSRMLS_DC 
) [static]

Definition at line 871 of file locale_methods.c.

{
       intl_error_reset( NULL TSRMLS_CC );
       if( result == FAILURE) {
              intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR,
                      "locale_compose: parameter array element is not a string", 0 TSRMLS_CC );
              smart_str_free(loc_name);
              return 0;
       }
       return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static char* lookup_loc_range ( char *  loc_range,
HashTable hash_arr,
int canonicalize  TSRMLS_DC 
) [static]

Definition at line 1403 of file locale_methods.c.

{
       int    i = 0;
       int    cur_arr_len = 0;
       int result = 0;

       char* lang_tag = NULL;
       zval** ele_value = NULL;
       char** cur_arr = NULL;

       char* cur_loc_range  = NULL;
       char* can_loc_range  = NULL;
       int    saved_pos = 0;

       char* return_value = NULL;

       cur_arr = ecalloc(zend_hash_num_elements(hash_arr)*2, sizeof(char *));
       /* convert the array to lowercase , also replace hyphens with the underscore and store it in cur_arr */
       for(zend_hash_internal_pointer_reset(hash_arr);
              zend_hash_has_more_elements(hash_arr) == SUCCESS;
              zend_hash_move_forward(hash_arr)) {
              
              if (zend_hash_get_current_data(hash_arr, (void**)&ele_value) == FAILURE) {
                     /* Should never actually fail since the key is known to exist.*/
                     continue;
              }
              if(Z_TYPE_PP(ele_value)!= IS_STRING) {
                     /* element value is not a string */
                     intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, "lookup_loc_range: locale array element is not a string", 0 TSRMLS_CC);
                     LOOKUP_CLEAN_RETURN(NULL);
              } 
              cur_arr[cur_arr_len*2] = estrndup(Z_STRVAL_PP(ele_value), Z_STRLEN_PP(ele_value));
              result = strToMatch(Z_STRVAL_PP(ele_value), cur_arr[cur_arr_len*2]);
              if(result == 0) {
                     intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, "lookup_loc_range: unable to canonicalize lang_tag", 0 TSRMLS_CC);
                     LOOKUP_CLEAN_RETURN(NULL);
              }
              cur_arr[cur_arr_len*2+1] = Z_STRVAL_PP(ele_value);
              cur_arr_len++ ; 
       } /* end of for */

       /* Canonicalize array elements */
       if(canonicalize) {
              for(i=0; i<cur_arr_len; i++) { 
                     lang_tag = get_icu_value_internal(cur_arr[i*2], LOC_CANONICALIZE_TAG, &result, 0);
                     if(result != 1 || lang_tag == NULL || !lang_tag[0]) {
                            if(lang_tag) {
                                   efree(lang_tag);
                            }
                            intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, "lookup_loc_range: unable to canonicalize lang_tag" , 0 TSRMLS_CC);
                            LOOKUP_CLEAN_RETURN(NULL);
                     }
                     cur_arr[i*2] = erealloc(cur_arr[i*2], strlen(lang_tag)+1);
                     result = strToMatch(lang_tag, cur_arr[i*2]);     
                     efree(lang_tag);
                     if(result == 0) {
                            intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, "lookup_loc_range: unable to canonicalize lang_tag" , 0 TSRMLS_CC);
                            LOOKUP_CLEAN_RETURN(NULL);
                     }
              }

       }

       if(canonicalize) {
              /* Canonicalize the loc_range */
              can_loc_range = get_icu_value_internal(loc_range, LOC_CANONICALIZE_TAG, &result , 0);
              if( result != 1 || can_loc_range == NULL || !can_loc_range[0]) {
                     /* Error */
                     intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, "lookup_loc_range: unable to canonicalize loc_range" , 0 TSRMLS_CC );
                     if(can_loc_range) {
                            efree(can_loc_range);
                     }
                     LOOKUP_CLEAN_RETURN(NULL);
              } else {
                     loc_range = can_loc_range;
              }
       } 

       cur_loc_range = ecalloc(1, strlen(loc_range)+1);
       /* convert to lower and replace hyphens */
       result = strToMatch(loc_range, cur_loc_range);   
       if(can_loc_range) {
              efree(can_loc_range);
       }
       if(result == 0) {
              intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, "lookup_loc_range: unable to canonicalize lang_tag" , 0 TSRMLS_CC);
              LOOKUP_CLEAN_RETURN(NULL);
       }

       /* Lookup for the lang_tag match */
       saved_pos = strlen(cur_loc_range);
       while(saved_pos > 0) {
              for(i=0; i< cur_arr_len; i++){ 
                     if(cur_arr[i*2] != NULL && strlen(cur_arr[i*2]) == saved_pos && strncmp(cur_loc_range, cur_arr[i*2], saved_pos) == 0) {       
                            /* Match found */
                            return_value = estrdup(canonicalize?cur_arr[i*2]:cur_arr[i*2+1]);
                            efree(cur_loc_range);
                            LOOKUP_CLEAN_RETURN(return_value);
                     }
              }
              saved_pos = getStrrtokenPos(cur_loc_range, saved_pos);
       }

       /* Match not found */
       efree(cur_loc_range);
       LOOKUP_CLEAN_RETURN(NULL);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 432 of file locale_methods.c.

Here is the call graph for this function:

Definition at line 444 of file locale_methods.c.

Here is the call graph for this function:

Definition at line 456 of file locale_methods.c.

Here is the call graph for this function:

Definition at line 599 of file locale_methods.c.

Here is the call graph for this function:

Definition at line 611 of file locale_methods.c.

Here is the call graph for this function:

Definition at line 623 of file locale_methods.c.

Here is the call graph for this function:

Definition at line 635 of file locale_methods.c.

Here is the call graph for this function:

Definition at line 649 of file locale_methods.c.

Here is the call graph for this function:

Definition at line 663 of file locale_methods.c.

{
    UEnumeration*   e        = NULL;
    UErrorCode      status   = U_ZERO_ERROR;

       const char*          kw_key        = NULL;
    int32_t         kw_key_len    = 0;

    char*            loc_name        = NULL;
    int                     loc_name_len    = 0;

/* 
       ICU expects the buffer to be allocated  before calling the function 
       and so the buffer size has been explicitly specified 
       ICU uloc.h #define   ULOC_KEYWORD_AND_VALUES_CAPACITY   100 
       hence the kw_value buffer size is 100
*/
       char*         kw_value        = NULL;
    int32_t     kw_value_len    = 100;

    intl_error_reset( NULL TSRMLS_CC );

    if(zend_parse_parameters( ZEND_NUM_ARGS() TSRMLS_CC, "s",
        &loc_name, &loc_name_len ) == FAILURE)
    {
        intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR,
             "locale_get_keywords: unable to parse input params", 0 TSRMLS_CC );

        RETURN_FALSE;
    }

    if(loc_name_len == 0) {
        loc_name = INTL_G(default_locale);
    }

       /* Get the keywords */
    e = uloc_openKeywords( loc_name, &status );
    if( e != NULL )
    {
              /* Traverse it, filling the return array. */
       array_init( return_value );

       while( ( kw_key = uenum_next( e, &kw_key_len, &status ) ) != NULL ){
                     kw_value = ecalloc( 1 , kw_value_len  );

                     /* Get the keyword value for each keyword */
                     kw_value_len=uloc_getKeywordValue( loc_name,kw_key, kw_value, kw_value_len ,  &status );
                     if (status == U_BUFFER_OVERFLOW_ERROR) {
                            status = U_ZERO_ERROR;
                            kw_value = erealloc( kw_value , kw_value_len+1);
                            kw_value_len=uloc_getKeywordValue( loc_name,kw_key, kw_value, kw_value_len+1 ,  &status );
                     } else if(!U_FAILURE(status)) {
                            kw_value = erealloc( kw_value , kw_value_len+1);
                     } 
                     if (U_FAILURE(status)) {
                     intl_error_set( NULL, FAILURE, "locale_get_keywords: Error encountered while getting the keyword  value for the  keyword", 0 TSRMLS_CC );
                            if( kw_value){
                                   efree( kw_value );
                            }
                            zval_dtor(return_value);
                     RETURN_FALSE;
                     }

                     add_assoc_stringl( return_value, (char *)kw_key, kw_value , kw_value_len, 0);
              } /* end of while */

       } /* end of if e!=NULL */

    uenum_close( e );
}

Here is the call graph for this function:

PHP_FUNCTION ( locale_canonicalize  )

Definition at line 741 of file locale_methods.c.

Here is the call graph for this function:

PHP_FUNCTION ( locale_compose  )

Definition at line 891 of file locale_methods.c.

{
       smart_str            loc_name_s = {0};
       smart_str *loc_name = &loc_name_s;
       zval*                arr    = NULL;
       HashTable*           hash_arr = NULL;
       int                  result = 0;

       intl_error_reset( NULL TSRMLS_CC );

       if(zend_parse_parameters( ZEND_NUM_ARGS() TSRMLS_CC, "a",
              &arr) == FAILURE)
       {
              intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR,
                      "locale_compose: unable to parse input params", 0 TSRMLS_CC );
              RETURN_FALSE;
       }

       hash_arr = HASH_OF( arr );

       if( !hash_arr || zend_hash_num_elements( hash_arr ) == 0 )
              RETURN_FALSE;

       /* Check for grandfathered first */
       result = append_key_value(loc_name, hash_arr,  LOC_GRANDFATHERED_LANG_TAG);  
       if( result == SUCCESS){
              RETURN_SMART_STR(loc_name);
       }
       if( !handleAppendResult( result, loc_name TSRMLS_CC)){
              RETURN_FALSE;
       }

       /* Not grandfathered */
       result = append_key_value(loc_name, hash_arr , LOC_LANG_TAG);  
       if( result == LOC_NOT_FOUND ){
              intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR,
              "locale_compose: parameter array does not contain 'language' tag.", 0 TSRMLS_CC );
              smart_str_free(loc_name);
              RETURN_FALSE;
       }
       if( !handleAppendResult( result, loc_name TSRMLS_CC)){
              RETURN_FALSE;
       }

       /* Extlang */
       result = append_multiple_key_values(loc_name, hash_arr , LOC_EXTLANG_TAG TSRMLS_CC);
       if( !handleAppendResult( result, loc_name TSRMLS_CC)){
              RETURN_FALSE;
       }

       /* Script */
       result = append_key_value(loc_name, hash_arr , LOC_SCRIPT_TAG); 
       if( !handleAppendResult( result, loc_name TSRMLS_CC)){
              RETURN_FALSE;
       }
       
       /* Region */
       result = append_key_value( loc_name, hash_arr , LOC_REGION_TAG);
       if( !handleAppendResult( result, loc_name TSRMLS_CC)){
              RETURN_FALSE;
       }

       /* Variant */
       result = append_multiple_key_values( loc_name, hash_arr , LOC_VARIANT_TAG TSRMLS_CC); 
       if( !handleAppendResult( result, loc_name TSRMLS_CC)){
              RETURN_FALSE;
       }

       /* Private */
       result = append_multiple_key_values( loc_name, hash_arr , LOC_PRIVATE_TAG TSRMLS_CC);
       if( !handleAppendResult( result, loc_name TSRMLS_CC)){
              RETURN_FALSE;
       }

       RETURN_SMART_STR(loc_name);
}

Here is the call graph for this function:

PHP_FUNCTION ( locale_parse  )

Definition at line 1084 of file locale_methods.c.

{
    char*       loc_name        = NULL;
    int         loc_name_len    = 0;
    int         grOffset           = 0;

    intl_error_reset( NULL TSRMLS_CC );

    if(zend_parse_parameters( ZEND_NUM_ARGS() TSRMLS_CC, "s",
        &loc_name, &loc_name_len ) == FAILURE)
    {
        intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR,
             "locale_parse: unable to parse input params", 0 TSRMLS_CC );

        RETURN_FALSE;
    }

    if(loc_name_len == 0) {
        loc_name = INTL_G(default_locale);
    }

       array_init( return_value );

       grOffset =  findOffset( LOC_GRANDFATHERED , loc_name );
       if( grOffset >= 0 ){
              add_assoc_string( return_value , LOC_GRANDFATHERED_LANG_TAG , estrdup(loc_name) ,FALSE );
       }
       else{
              /* Not grandfathered */
              add_array_entry( loc_name , return_value , LOC_LANG_TAG TSRMLS_CC);
              add_array_entry( loc_name , return_value , LOC_SCRIPT_TAG TSRMLS_CC);
              add_array_entry( loc_name , return_value , LOC_REGION_TAG TSRMLS_CC);
              add_array_entry( loc_name , return_value , LOC_VARIANT_TAG TSRMLS_CC);
              add_array_entry( loc_name , return_value , LOC_PRIVATE_TAG TSRMLS_CC);
       }
}

Here is the call graph for this function:

Definition at line 1128 of file locale_methods.c.

{
       char*         loc_name        = NULL;
       int           loc_name_len    = 0;

       int    result        = 0;
       char*  token         = NULL;
       char*  variant              = NULL;
       char*  saved_ptr     = NULL;

       intl_error_reset( NULL TSRMLS_CC );
       
       if(zend_parse_parameters( ZEND_NUM_ARGS() TSRMLS_CC, "s",
       &loc_name, &loc_name_len ) == FAILURE)
       {
              intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR,
            "locale_parse: unable to parse input params", 0 TSRMLS_CC );

              RETURN_FALSE;
       }

       if(loc_name_len == 0) {
              loc_name = INTL_G(default_locale);
       }


       array_init( return_value );

       /* If the locale is grandfathered, stop, no variants */
       if( findOffset( LOC_GRANDFATHERED , loc_name ) >=  0 ){ 
              /* ("Grandfathered Tag. No variants."); */
       }
       else { 
       /* Call ICU variant */
              variant = get_icu_value_internal( loc_name , LOC_VARIANT_TAG , &result ,0);
              if( result > 0 && variant){
                     /* Tokenize on the "_" or "-" */
                     token = php_strtok_r( variant , DELIMITER , &saved_ptr);       
                     add_next_index_stringl( return_value, token , strlen(token) ,TRUE );
                     /* tokenize on the "_" or "-" and stop  at singleton if any    */
                     while( (token = php_strtok_r(NULL , DELIMITER, &saved_ptr)) && (strlen(token)>1) ){
                            add_next_index_stringl( return_value, token , strlen(token) ,TRUE );
                     }
              }
              if( variant ){
                     efree( variant );
              }
       }
                     

}

Here is the call graph for this function:

Definition at line 1223 of file locale_methods.c.

{
       char*         lang_tag        = NULL;
       int           lang_tag_len    = 0;
       char*         loc_range       = NULL;
       int           loc_range_len   = 0;

       int           result        = 0;
       char*         token         = 0;
       char*         chrcheck      = NULL;

       char*         can_lang_tag    = NULL;
       char*         can_loc_range   = NULL;

       char*         cur_lang_tag    = NULL;
       char*         cur_loc_range   = NULL;

       zend_bool     boolCanonical        = 0;   
       UErrorCode    status        = U_ZERO_ERROR;

       intl_error_reset( NULL TSRMLS_CC );
       
       if(zend_parse_parameters( ZEND_NUM_ARGS() TSRMLS_CC, "ss|b",
              &lang_tag, &lang_tag_len , &loc_range , &loc_range_len , 
              &boolCanonical) == FAILURE)
       {
              intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR,
              "locale_filter_matches: unable to parse input params", 0 TSRMLS_CC );

              RETURN_FALSE;
       }

       if(loc_range_len == 0) {
              loc_range = INTL_G(default_locale);
       }

       if( strcmp(loc_range,"*")==0){
              RETURN_TRUE;
       }

       if( boolCanonical ){
              /* canonicalize loc_range */
              can_loc_range=get_icu_value_internal( loc_range , LOC_CANONICALIZE_TAG , &result , 0);
              if( result ==0) {
                     intl_error_set( NULL, status, 
                            "locale_filter_matches : unable to canonicalize loc_range" , 0 TSRMLS_CC );
                     RETURN_FALSE;
              }

              /* canonicalize lang_tag */
              can_lang_tag = get_icu_value_internal( lang_tag , LOC_CANONICALIZE_TAG , &result ,  0);
              if( result ==0) {
                     intl_error_set( NULL, status, 
                            "locale_filter_matches : unable to canonicalize lang_tag" , 0 TSRMLS_CC );
                     RETURN_FALSE;
              }

              /* Convert to lower case for case-insensitive comparison */
              cur_lang_tag = ecalloc( 1, strlen(can_lang_tag) + 1);

              /* Convert to lower case for case-insensitive comparison */
              result = strToMatch( can_lang_tag , cur_lang_tag);
              if( result == 0) {
                     efree( cur_lang_tag );
                     efree( can_lang_tag );
                     RETURN_FALSE;
              }

              cur_loc_range = ecalloc( 1, strlen(can_loc_range) + 1);
              result = strToMatch( can_loc_range , cur_loc_range );
              if( result == 0) {
                     efree( cur_lang_tag );
                     efree( can_lang_tag );
                     efree( cur_loc_range );
                     efree( can_loc_range );
                     RETURN_FALSE;
              }

              /* check if prefix */
              token  = strstr( cur_lang_tag , cur_loc_range );
       
              if( token && (token==cur_lang_tag) ){
                     /* check if the char. after match is SEPARATOR */
                     chrcheck = token + (strlen(cur_loc_range));
                     if( isIDSeparator(*chrcheck) || isEndOfTag(*chrcheck) ){ 
                            if( cur_lang_tag){
                                   efree( cur_lang_tag );
                            }
                            if( cur_loc_range){
                                   efree( cur_loc_range );
                            }
                            if( can_lang_tag){
                                   efree( can_lang_tag );
                            }
                            if( can_loc_range){
                                   efree( can_loc_range );
                            }
                            RETURN_TRUE;
                     }
              }

              /* No prefix as loc_range */
              if( cur_lang_tag){
                     efree( cur_lang_tag );
              }
              if( cur_loc_range){
                     efree( cur_loc_range );
              }
              if( can_lang_tag){
                     efree( can_lang_tag );
              }
              if( can_loc_range){
                     efree( can_loc_range );
              }
              RETURN_FALSE;

       } /* end of if isCanonical */
       else{
              /* Convert to lower case for case-insensitive comparison */
              cur_lang_tag = ecalloc( 1, strlen(lang_tag ) + 1);
              
              result = strToMatch( lang_tag , cur_lang_tag);
              if( result == 0) {
                     efree( cur_lang_tag );
                     RETURN_FALSE;
              }
              cur_loc_range = ecalloc( 1, strlen(loc_range ) + 1);
              result = strToMatch( loc_range , cur_loc_range );
              if( result == 0) {
                     efree( cur_lang_tag );
                     efree( cur_loc_range );
                     RETURN_FALSE;
              }

              /* check if prefix */
              token  = strstr( cur_lang_tag , cur_loc_range );
              
              if( token && (token==cur_lang_tag) ){
                     /* check if the char. after match is SEPARATOR */
                     chrcheck = token + (strlen(cur_loc_range));
                     if( isIDSeparator(*chrcheck) || isEndOfTag(*chrcheck) ){ 
                            if( cur_lang_tag){
                                   efree( cur_lang_tag );
                            }
                            if( cur_loc_range){
                                   efree( cur_loc_range );
                            }
                            RETURN_TRUE;
                     }
              }

              /* No prefix as loc_range */
              if( cur_lang_tag){
                     efree( cur_lang_tag );
              }
              if( cur_loc_range){
                     efree( cur_loc_range );
              }
              RETURN_FALSE;

       }
}

Here is the call graph for this function:

Definition at line 1521 of file locale_methods.c.

{
       char*         fallback_loc                = NULL;
       int           fallback_loc_len     = 0;
       char*         loc_range                   = NULL;
       int           loc_range_len               = 0;

       zval*         arr                         = NULL;
       HashTable*    hash_arr             = NULL;
       zend_bool     boolCanonical = 0;
       char*         result               =NULL;

       intl_error_reset( NULL TSRMLS_CC );

       if(zend_parse_parameters( ZEND_NUM_ARGS() TSRMLS_CC, "as|bs", &arr, &loc_range, &loc_range_len,
              &boolCanonical,      &fallback_loc, &fallback_loc_len) == FAILURE) {
              intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR,  "locale_lookup: unable to parse input params", 0 TSRMLS_CC );
              RETURN_FALSE;
       }

       if(loc_range_len == 0) {
              loc_range = INTL_G(default_locale);
       }

       hash_arr = HASH_OF(arr);

       if( !hash_arr || zend_hash_num_elements( hash_arr ) == 0 ) {
              RETURN_EMPTY_STRING();
       } 
       
       result = lookup_loc_range(loc_range, hash_arr, boolCanonical TSRMLS_CC);
       if(result == NULL || result[0] == '\0') {
              if( fallback_loc ) {
                     result = estrndup(fallback_loc, fallback_loc_len);
              } else {
                     RETURN_EMPTY_STRING();
              }
       }

       RETVAL_STRINGL(result, strlen(result), 0);
}

Here is the call graph for this function:

PHP_FUNCTION ( locale_accept_from_http  )

Definition at line 1571 of file locale_methods.c.

{
       UEnumeration *available;
       char *http_accept = NULL;
       int http_accept_len;
       UErrorCode status = 0;
       int len;
       char resultLocale[INTL_MAX_LOCALE_LEN+1];
       UAcceptResult outResult;

       if(zend_parse_parameters( ZEND_NUM_ARGS() TSRMLS_CC, "s", &http_accept, &http_accept_len) == FAILURE)
       {
              intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR,
              "locale_accept_from_http: unable to parse input parameters", 0 TSRMLS_CC );
              RETURN_FALSE;
       }
       
       available = ures_openAvailableLocales(NULL, &status);
       INTL_CHECK_STATUS(status, "locale_accept_from_http: failed to retrieve locale list");
       len = uloc_acceptLanguageFromHTTP(resultLocale, INTL_MAX_LOCALE_LEN, 
                                          &outResult, http_accept, available, &status);
       uenum_close(available);
       INTL_CHECK_STATUS(status, "locale_accept_from_http: failed to find acceptable locale");
       if (len < 0 || outResult == ULOC_ACCEPT_FAILED) {
              RETURN_FALSE;
       }
       RETURN_STRINGL(resultLocale, len, 1);
}

Here is the call graph for this function:

PHP_NAMED_FUNCTION ( zif_locale_get_default  )

Definition at line 209 of file locale_methods.c.

{
       if( INTL_G(default_locale) == NULL ) {
              INTL_G(default_locale) = pestrdup( uloc_getDefault(), 1);
       }
       RETURN_STRING( INTL_G(default_locale), TRUE );
}
PHP_NAMED_FUNCTION ( zif_locale_set_default  )

Definition at line 224 of file locale_methods.c.

{
       char* locale_name = NULL;
       int   len=0;  

       if(zend_parse_parameters( ZEND_NUM_ARGS() TSRMLS_CC,  "s",
              &locale_name ,&len ) == FAILURE)
       {
              intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR,
                            "locale_set_default: unable to parse input params", 0 TSRMLS_CC );

              RETURN_FALSE;
       }

       if(len == 0) {
              locale_name =  (char *)uloc_getDefault() ;
              len = strlen(locale_name);
       }

       zend_alter_ini_entry(LOCALE_INI_NAME, sizeof(LOCALE_INI_NAME), locale_name, len, PHP_INI_USER, PHP_INI_STAGE_RUNTIME); 

       RETURN_TRUE;
}

Here is the call graph for this function:

static int strToMatch ( char *  str,
char *  retstr 
) [static]

Definition at line 1184 of file locale_methods.c.

{
       char*  anchor        = NULL;
       char*  anchor1 = NULL;
       int    result        = 0;
       int    len    = 0;

    if( (!str) || str[0] == '\0'){
        return result;
    } else {
       anchor = retstr;
       anchor1 = str;
        len = strlen(str);
        while( (*str)!='\0' ){
              if( *str == '-' ){
                     *retstr =  '_';
              } else {
                     *retstr = tolower(*str);
              }
            str++;
            retstr++;
       }
       *retstr = '\0';
       retstr=  anchor;
       str=  anchor1;
       result = 1;
    }

    return(result);
}

Here is the caller graph for this function:


Variable Documentation

const char* const LOC_GRANDFATHERED[] [static]
Initial value:
 {
       "art-lojban",        "i-klingon",         "i-lux",                    "i-navajo",          "no-bok",            "no-nyn",
       "cel-gaulish",              "en-GB-oed",         "i-ami",             
       "i-bnn",             "i-default",         "i-enochian", 
       "i-mingo",           "i-pwn",             "i-tao", 
       "i-tay",             "i-tsu",             "sgn-BE-fr",
       "sgn-BE-nl",         "sgn-CH-de",         "zh-cmn",
       "zh-cmn-Hans",              "zh-cmn-Hant",              "zh-gan" ,
       "zh-guoyu",          "zh-hakka",          "zh-min",
       "zh-min-nan",               "zh-wuu",            "zh-xiang",   
       "zh-yue",            NULL
}

Definition at line 66 of file locale_methods.c.

const char* const LOC_PREFERRED_GRANDFATHERED[] [static]
Initial value:
 {
       "jbo",               "tlh",               "lb",
       "nv",                "nb",                "nn",                
       NULL
}

Definition at line 85 of file locale_methods.c.

Definition at line 84 of file locale_methods.c.