diff -r 000000000000 -r e4d67989cc36 stdcpp/src/c_locale_libc.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/stdcpp/src/c_locale_libc.cpp	Tue Feb 02 02:01:42 2010 +0200
@@ -0,0 +1,1309 @@
+/*
+* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description: 
+*
+*/
+
+
+# include "stlport_prefix.h" 
+#include <limits.h>
+
+//madhu - 18/8/06
+#include "locale.h"
+#include "langinfo.h"
+#include <string.h>
+#include <stdlib.h>
+#include <cwctype>
+#include "c_locale.h"
+#define	CODECVT_ICONV //Define CODECVT_ICONV to use ICONV APIs for code conversion.
+
+//#define _MESSAGE_CATALOG_
+#ifdef	_MESSAGE_CATALOG_
+#include <libintl.h>
+#endif
+
+# ifdef _STLP_REAL_LOCALE_IMPLEMENTED
+
+// here, we'll put C locale implementation for those compilers where
+// it has to be done in C++
+
+# else
+
+/* This is a "stub" implementation of the "c_locale.h" interface,
+   intended for operating systems where we have not yet written
+   a real implementation.  A C++ library using this stub implementation
+   is still standard-conforming, since the C++ standard does not require
+   that any locales other than "C" be supported.
+*/
+
+#if 0 //Madhu - 18/8/06
+/* Framework functions */
+
+struct _Locale_ctype    /* { } */ ;
+struct _Locale_numeric  /* { } */;
+struct _Locale_time      /* { } */;
+struct _Locale_collate   /*{ } */;
+struct _Locale_monetary  /* { } */;
+struct _Locale_messages  /* { } */;
+
+#endif //#if 0
+
+
+#ifdef CODECVT_ICONV
+#include <iconv.h>
+#include <errno.h>
+#define	UNICODESTR	"UCS2"
+struct node;
+enum CONVWAY
+{
+	
+	IN = 0,
+	OUT
+
+};
+typedef struct node
+{
+	mbstate_t	*state;
+	iconv_t		in_iconvstate;
+	iconv_t		out_iconvstate;
+	struct node  *next;
+}StateList;
+
+void BEtoLE(wchar_t* src, int size)
+{
+	int i = 0;
+	
+	for (i = 0;i<size;i++)
+		src[i] = (src[i]>>8) | (src[i]<<8);
+}
+
+void ExtractCodeset(char* name, char* codeset)
+{
+	char* temp = strstr(name,".");
+	if( temp != NULL)
+		{
+		temp++;
+		while ( (*temp)&&(*temp!='=') )
+		*codeset++ = *temp++;
+		}
+}
+
+int AddState(StateList **list, iconv_t icnvstate, mbstate_t* state, enum CONVWAY way)
+{
+	StateList *temp = *list;
+	StateList *newnode = NULL;
+	while(temp)
+	{
+		if (temp->state == state)	
+			break;
+		temp = temp->next;
+	}
+	
+	if (!temp)
+	{		
+		newnode = new StateList;
+		if (newnode == NULL)
+			return 0;
+		newnode->next = NULL;
+		newnode->state = state;
+		newnode->in_iconvstate = newnode->out_iconvstate = NULL;
+	}
+	if(newnode)
+		temp = newnode;
+	if (!way)
+		temp->in_iconvstate = icnvstate;
+	else
+		temp->out_iconvstate = icnvstate;
+	
+	if (*list == NULL)
+	{
+		*list = temp;
+		return 1;	
+	}
+	else if(newnode)
+	{
+			
+		StateList *move = *list;
+		while(move->next)
+			move = move->next;
+			
+		move->next = temp;
+	}
+	return 1;	
+	
+}
+
+iconv_t	GetState(StateList *list, mbstate_t* state, enum CONVWAY way)
+{
+	while(list)
+	{
+		if (list->state == state)
+		{
+			if (!way)
+				return (iconv_t)list->in_iconvstate;
+			else
+				return (iconv_t)list->out_iconvstate;
+		}
+			
+		list = list->next;
+	}
+	return NULL;
+}
+
+void DeleteAllStates(StateList *list)
+{	
+	while(list)
+	{
+		StateList *temp =list ;
+		iconv_close(temp->in_iconvstate);
+		iconv_close(temp->out_iconvstate);
+		list = list->next;
+		delete temp;
+	}
+}
+
+
+#endif
+
+
+
+//Madhu - locale function definitions - START
+//Madhu - temporarily hardcoded system default locale - 18/8/06
+#define LOCALE_SYSTEM_DEFAULT	"C"
+#define	MAX_NAME_LEN	64	
+char	presentLocaleName[64]; // Stores present locale name.
+ 
+
+
+#if defined (__GNUC__) || defined (_KCC) || defined(__ICC)
+typedef unsigned short int _Locale_mask_t;
+#else
+typedef unsigned int _Locale_mask_t;
+#endif
+
+typedef struct _Locale_ctype { 
+	char name[MAX_NAME_LEN];
+	_Locale_mask_t	ctable[257];	
+#ifdef CODECVT_ICONV
+	StateList *statelist;
+	~_Locale_ctype() 
+	{
+		DeleteAllStates(statelist);
+	}
+#endif
+  
+} L_ctype_t;
+
+
+typedef struct _Locale_numeric	{  
+  char name[MAX_NAME_LEN];
+  char decimal_point[4];
+  char thousands_sep[4];
+  char *grouping;
+} L_numeric_t;
+
+typedef struct _Locale_time	{  
+  char name[MAX_NAME_LEN];
+  char *month[12];
+  char *abbrev_month[12];
+  char *dayofweek[7];
+  char *abbrev_dayofweek[7];
+} L_time_t;
+
+typedef struct _Locale_collate	{
+  char name[MAX_NAME_LEN];
+} L_collate_t;
+
+typedef struct _Locale_monetary	{  
+  char name[MAX_NAME_LEN]; 
+  char decimal_point[4];
+  char thousands_sep[4];
+  char *grouping;
+  char int_curr_symbol[5]; // 3+1+1
+  char curr_symbol[6];
+  char negative_sign[5];
+  char positive_sign[5];
+  int frac_digits; 
+  int int_frac_digits;
+} L_monetary_t;
+
+typedef struct _Locale_messages	{
+  char name[MAX_NAME_LEN];
+  char* domain;
+} L_messages_t;
+
+
+char* __getString(char* str)
+{
+	int len = strlen(str)+1;
+	char* temp = (char*) new char[len];
+	strcpy(temp, str);
+	
+	return temp;
+	
+}
+
+/* Common function to set locale information */
+#if 0
+static void* Locale_Common_Create(const char* locale)
+{
+		
+	setlocale(LC_ALL, locale);
+	
+	return (void*) localeconv();
+	
+		
+}
+#endif
+
+/* Gets the system locale name */
+static const char* Locale_common_default( char* name)
+{
+#if 0
+	char* presentLocalename = NULL;
+	char* defaultLocalename = NULL;
+	
+	//Madhu - going round to get default system locale, need to find alternative - 18/8/96
+	presentLocalename = setlocale(LC_ALL, NULL);
+	defaultLocalename = setlocale(LC_ALL, "");
+	setlocale(LC_ALL, presentLocalename);
+#endif
+
+	if(name!=NULL)
+		strcpy(name,LOCALE_SYSTEM_DEFAULT);
+	
+	return LOCALE_SYSTEM_DEFAULT;
+	
+}
+
+#if 0
+/* Gets the present locale name */ 
+static char* Locale_common_name(const void* cat, char* name)
+{
+#if 0
+	char* presentLocalename = NULL;
+	
+	presentLocalename = setlocale(LC_ALL, NULL);
+	strcpy(name,presentLocalename);
+	
+	return presentLocalename;
+#endif	
+	L_ctype_t* locale = (L_ctype_t*) cat;
+	strcpy(name,locale->name);
+	return name;
+}
+#endif
+/* */
+static char * Locale_extract_name ( const char *cname, char *into, int category )
+{
+  int i = 0;
+  const char * end;
+const char* strstar = "*", *strnull = "";
+  
+  if ( cname[0] != '/' )
+  {
+  	if (strcmp(cname,strnull) == 0)
+  		return strcpy(into, strstar);
+  	else
+  		return strcpy(into, cname); /* simple locale name */
+  }
+  
+  for ( i = 0; i <= category; i ++ ) {
+    while ( *cname != '\0' && *cname != '/' )
+      cname++;
+    if ( *cname == '\0' )
+      return into;
+    cname++;
+  }
+  
+  if ( *cname == '\0' )
+    return into;
+  
+  end = cname;
+  while ( *end != '\0' && *end != '/' )
+    end++;
+  
+  strncpy ( into, cname, end - cname );
+  into [ end - cname ] = '\0';
+  
+  return into;
+}
+
+# ifdef __cplusplus
+_STLP_BEGIN_NAMESPACE //Madhu - moved to here
+extern "C" {
+
+_Locale_mask_t  Get_locale_wchar_ctype(wint_t wc, _Locale_mask_t  /*mask*/)
+
+{
+	_Locale_mask_t  ret = 0;
+	
+	if (iswcntrl(wc))  ret |= _Locale_CNTRL;
+	if (iswupper(wc))  ret |= _Locale_UPPER;
+	if (iswlower(wc))  ret |= _Locale_LOWER;
+	if (iswdigit(wc))  ret |= _Locale_DIGIT;
+	if (iswxdigit(wc)) ret |= _Locale_XDIGIT;
+	if (iswpunct(wc))  ret |= _Locale_PUNCT;
+	if (iswspace(wc))  ret |= _Locale_SPACE;
+	if (iswprint(wc))  ret |= _Locale_PRINT;
+	if (iswalpha(wc))  ret |= _Locale_ALPHA;
+	
+	return ret;
+  
+}
+
+_Locale_mask_t  Get_locale_char_ctype(unsigned char c)
+
+{
+	_Locale_mask_t  ret = 0;
+	
+	if (iscntrl(c))  ret |= _Locale_CNTRL;
+	if (isupper(c))  ret |= _Locale_UPPER;
+	if (islower(c))  ret |= _Locale_LOWER;
+	if (isdigit(c))  ret |= _Locale_DIGIT;
+	if (isxdigit(c)) ret |= _Locale_XDIGIT;
+	if (ispunct(c))  ret |= _Locale_PUNCT;
+	if (isspace(c))  ret |= _Locale_SPACE;
+	if (isprint(c))  ret |= _Locale_PRINT;
+	if (isalpha(c))  ret |= _Locale_ALPHA;
+	
+	return ret;
+  
+}
+//Madhu - locale function definitions - END
+
+
+//# ifdef __cplusplus
+//_STLP_BEGIN_NAMESPACE
+
+# define __DUMMY_PAR
+# define __DUMMY_PAR1
+# define __DUMMY_PAR2
+# define __DUMMY_PAR3
+# define __DUMMY_PAR4
+# define __DUMMY_PAR5
+# define __DUMMY_PAR6
+# define __DUMMY_PAR7
+# define __DUMMY_PAR8
+# endif
+    
+ void* _Locale_ctype_create(const char * name)
+ { 
+ 
+ 	unsigned char buffer[256];
+	int i;
+	_Locale_mask_t* ctable;
+	
+ 	L_ctype_t *plocCType = (L_ctype_t*) new (L_ctype_t);
+ 	
+ 	if (!plocCType)
+		return NULL;
+ 	
+ 	strcpy(plocCType->name, name);
+	char* ptemp = setlocale(LC_CTYPE, name); 
+	if (!ptemp)
+		return NULL;
+ 	ctable = plocCType->ctable;
+ 	
+	/* Partial implementation for ANSI code page, need to implement for DBCS code pages*/
+	
+	/* Make table with all characters. */
+    for(i = 0; i < 256; i++) buffer[i] = i;
+    
+    for (i=0;i<256;i++)
+    {
+    	
+    	ctable[i+1] = Get_locale_char_ctype(buffer[i]);	
+    }	
+ 	ctable[0] = 0; //EOF
+#ifdef CODECVT_ICONV
+	plocCType->statelist = NULL;	
+#endif 	
+ 	return plocCType;
+ }
+  
+ void* _Locale_numeric_create(const char *name)
+ { 
+ 	L_numeric_t *plocNumeric = (L_numeric_t *)new (L_numeric_t);
+ 	struct lconv *plconv;
+ 	
+ 	if (!plocNumeric)
+		return NULL; 	
+ 	strcpy(plocNumeric->name, name);
+ 	
+	char* ptemp = setlocale(LC_NUMERIC, name); 
+	if (!ptemp)
+		return NULL;
+ 	plconv = localeconv();
+ 	
+ 	//copy locale numeric data to local structure
+ 	strcpy(plocNumeric->decimal_point, plconv->decimal_point);
+ 	plocNumeric->grouping = __getString(plconv->grouping);
+ 	strcpy(plocNumeric->thousands_sep, plconv->thousands_sep);
+ 	
+  	return plocNumeric; 
+ }
+ 
+ void*_Locale_time_create(const char * name)
+ { 
+ 	L_time_t *plocTime = (L_time_t *)new(L_time_t);
+ 	//struct lconv *plconv;
+ 	
+ 	if (!plocTime )
+		return NULL; 	
+ 	strcpy(plocTime ->name, name);
+ 	
+	char* ptemp = setlocale(LC_TIME, name); 
+	if (!ptemp)
+		return NULL;
+ 	//plconv = localeconv();
+ 	
+ 	int i;
+ 	int index = (MON_1);
+ 	//Get all month names
+ 	for (i = 0;i<12;i++,index++)
+ 		plocTime->month[i] = __getString(nl_langinfo(index)); 	
+ 	
+ 	//Get all abbrevated month names
+ 	index = (ABMON_1);
+ 	for (i = 0;i<12;i++,index++)
+ 		plocTime->abbrev_month[i] = __getString(nl_langinfo(index));
+ 		
+  	//Get all weekday names
+ 	index = (DAY_1);
+ 	for (i = 0;i<7;i++,index++)
+ 		plocTime->dayofweek[i] = __getString(nl_langinfo(index));
+ 	
+  	//Get all weekday names
+ 	index = (ABDAY_1);
+ 	for (i = 0;i<7;i++,index++)
+ 		plocTime->abbrev_dayofweek[i] = __getString(nl_langinfo(index));
+ 	
+  	 	
+ 	return plocTime;
+ }
+ 
+ void* _Locale_collate_create(const char *name)
+ { 
+ 	L_collate_t *plocCollate = (L_collate_t *)new(L_collate_t);
+ 	
+ 	if (!plocCollate)
+		return NULL; 	
+ 	strcpy(plocCollate->name, name);
+ 	
+ 	return plocCollate;
+ }
+ 
+ void* _Locale_monetary_create(const char * name)
+ { 
+ 	L_monetary_t *plocMonetary = (L_monetary_t *)new(L_monetary_t);
+ 	struct lconv *plconv;
+ 	
+ 	if (!plocMonetary)
+		return NULL; 	
+ 	strcpy(plocMonetary->name, name);
+ 	
+	char* ptemp = setlocale(LC_MONETARY, name); 
+	if (!ptemp)
+		return NULL;
+ 	plconv = localeconv();
+ 	
+ 	strcpy(plocMonetary->decimal_point,plconv->mon_decimal_point);
+  	strcpy(plocMonetary->thousands_sep, plconv->mon_thousands_sep);
+  	plocMonetary->grouping = __getString(plconv->mon_grouping);
+  	strcpy(plocMonetary->int_curr_symbol, plconv->int_curr_symbol); // 3+1+1
+  	strcpy(plocMonetary->curr_symbol, plconv->currency_symbol);
+  	strcpy(plocMonetary->negative_sign, plconv->negative_sign);
+  	strcpy(plocMonetary->positive_sign, plconv->positive_sign);
+  	plocMonetary->frac_digits = plconv->frac_digits;
+  	plocMonetary->int_frac_digits = plconv->int_frac_digits;
+ 	
+ 	return plocMonetary;
+ }
+ void* _Locale_messages_create(const char *name)
+ { 
+ 	L_messages_t *plocMessages= (L_messages_t *)new(L_messages_t);
+ 	
+ 	if (!plocMessages)
+		return NULL; 	
+ 	strcpy(plocMessages->name, name);
+ 	
+ 	return plocMessages;
+ }
+
+ const char* _Locale_ctype_default(char* buff)
+ { 
+ 	return Locale_common_default(buff);
+ }
+ 
+ const char* _Locale_numeric_default(char *buff)
+ { 
+ 	return Locale_common_default(buff);
+ }
+ 
+ const char* _Locale_time_default(char* buff)
+ { 
+ 	return Locale_common_default(buff);
+ }
+ 
+ const char* _Locale_collate_default(char* buff)
+ { 
+ 	return Locale_common_default(buff); 
+ }
+ 
+ const char* _Locale_monetary_default(char* buff)
+ { 
+ 	return Locale_common_default(buff);
+ }
+ 
+ const char* _Locale_messages_default(char* buff) 
+ { 
+ 	return Locale_common_default(buff);
+ }
+
+ char* _Locale_ctype_name(const void* cat, char* buff)
+ { 
+ 	L_ctype_t* locale = (L_ctype_t*) cat;
+	strcpy(buff,locale->name);
+	return buff;
+ 	//return Locale_common_name(locale,buff);
+ }
+ 
+ char* _Locale_numeric_name(const void* cat, char* buff)
+ { 
+ 	L_numeric_t* locale = (L_numeric_t*) cat;
+	strcpy(buff,locale->name);
+	return buff;
+ 	//return Locale_common_name(locale,buff);
+ }
+ 
+ char* _Locale_time_name(const void* cat, char* buff)
+ { 
+ 	L_time_t* locale = (L_time_t*) cat;
+	strcpy(buff,locale->name);
+	return buff;
+ 	//return Locale_common_name(locale,buff);
+ }
+ 
+ char* _Locale_collate_name(const void* cat, char* buff)
+ { 
+ 	L_collate_t* locale = (L_collate_t*) cat;
+	strcpy(buff,locale->name);
+	return buff;
+ 	//return Locale_common_name(locale,buff);
+ }
+ 
+ char* _Locale_monetary_name(const void* cat, char* buff)
+ { 
+ 	L_monetary_t* locale = (L_monetary_t*) cat;
+	strcpy(buff,locale->name);
+	return buff;
+ 	//return Locale_common_name(locale,buff);
+ }
+ 
+ char* _Locale_messages_name(const void* cat, char* buff)
+ { 
+ 	L_messages_t* locale = (L_messages_t*) cat;
+	strcpy(buff,locale->name);
+	return buff;
+ 	//return Locale_common_name(locale,buff);
+ }
+
+ void _Locale_ctype_destroy(void* locale)
+ {
+ #ifdef	CODECVT_ICONV
+ 	DeleteAllStates(((L_ctype_t*)locale)->statelist);
+#endif 	
+ 	delete((L_ctype_t*)locale);
+ }
+ 
+ void _Locale_numeric_destroy(void* locale)
+ {
+ 	delete ((L_numeric_t*)locale)->grouping;
+ 	delete (L_numeric_t*)locale;
+ }
+ 
+ void _Locale_time_destroy(void* locale)
+ {
+ 	int i;
+ 	L_time_t* plocTime =(L_time_t*)locale; 
+ 	//delete months
+ 	for (i = 0;i<12;i++)
+ 		delete (plocTime->month[i]);
+ 	//delete abbrevated months
+ 	for (i = 0;i<12;i++)
+ 		delete (plocTime->abbrev_month[i]);
+ 	//delete week day
+ 	for (i = 0;i<7;i++)
+ 		delete (plocTime->dayofweek[i]);
+ 	//delete abbrevated week day
+ 	for (i = 0;i<7;i++)
+ 		delete (plocTime->abbrev_dayofweek[i]);
+ 	 		
+ 	delete((L_time_t*)locale);
+ }
+ 
+ void _Locale_collate_destroy(void* locale)
+ {
+ 	delete((L_collate_t*)locale);
+ }
+ 
+ void _Locale_monetary_destroy(void* locale)
+ {
+ 	delete ((L_monetary_t*)locale)->grouping;
+ 	delete((L_monetary_t*)locale);
+ }
+ 
+ void _Locale_messages_destroy(void* locale)
+ {
+ 	delete((L_messages_t*)locale);
+ }
+
+ char* _Locale_extract_ctype_name(const char* cname, char* buf) 
+ { 
+ 	return Locale_extract_name(cname, buf, LC_CTYPE);
+ }
+ 
+ char* _Locale_extract_numeric_name(const char* cname, char* buf) 
+ { 
+ 	return Locale_extract_name(cname, buf, LC_NUMERIC);
+ }
+ 
+ char* _Locale_extract_time_name(const char* cname, char* buf) 
+ { 
+ 	return Locale_extract_name(cname, buf, LC_TIME);
+ }
+ 
+ char* _Locale_extract_collate_name(const char* cname, char* buf) 
+ { 
+ 	return Locale_extract_name(cname, buf, LC_COLLATE); 
+ }
+ 
+ char* _Locale_extract_monetary_name(const char* cname, char* buf) 
+ { 
+ 	return Locale_extract_name(cname, buf, LC_MONETARY);
+ }
+ 
+ char* _Locale_extract_messages_name(const char* cname, char* buf) 
+ { 
+ 	return Locale_extract_name(cname, buf, LC_MESSAGES);
+ }
+
+ char* _Locale_compose_name(char* buf,
+			     const char* ctype, const char* numeric,
+			     const char* time, const char* collate,
+			     const char* monetary, const char* messages,
+			     const char* /*default_name*/)
+ { 
+ 
+ 	if ( !strcmp ( ctype, numeric ) &&
+	 !strcmp ( ctype, time ) &&
+	 !strcmp ( ctype, collate ) &&
+	 !strcmp ( ctype, monetary ) &&
+	 !strcmp ( ctype, messages ) )
+	return strcpy ( buf, ctype );
+
+    strcpy ( buf, "/" );
+    strcat ( buf, ctype );
+
+    strcat ( buf, "/" );
+    strcat ( buf, numeric );
+
+    strcat ( buf, "/" );
+    strcat ( buf, time );
+
+    strcat ( buf, "/" );
+    strcat ( buf, collate );
+
+    strcat ( buf, "/" );
+    strcat ( buf, monetary );
+
+    strcat ( buf, "/" );
+    strcat ( buf, messages );
+
+    return buf;
+ }
+
+
+/* ctype */
+
+const  _Locale_mask_t* _Locale_ctype_table(struct _Locale_ctype* lctype)
+{ 
+	    
+	return lctype->ctable; 
+}
+
+int _Locale_toupper(struct _Locale_ctype* /*lctype*/, int c)
+{ 
+	return toupper(c); 
+}
+
+int _Locale_tolower(L_ctype_t* /*lctype*/, int c) 
+{ 
+	return tolower(c); 
+}
+
+#ifndef _STLP_NO_WCHAR_T
+
+ _Locale_mask_t  _Locale_wchar_ctype(L_ctype_t* /*lctype*/, wint_t c, _Locale_mask_t  which_bits)
+ { 
+ 	_Locale_mask_t mask = Get_locale_wchar_ctype(c,which_bits);
+ 	
+ 	return mask & which_bits; 
+ }
+ 
+ wint_t _Locale_wchar_tolower(L_ctype_t* lctype, wint_t c)
+ { 
+ 	setlocale(LC_CTYPE, lctype->name);
+ 	return towlower(c); 
+ }
+ 
+ wint_t _Locale_wchar_toupper(L_ctype_t* /*lctype*/, wint_t c)
+ { 
+ 	return towupper(c); 
+ }
+ 
+# endif
+
+# ifndef _STLP_NO_MBSTATE_T
+
+int _Locale_mb_cur_max (L_ctype_t * /*lctype*/) 
+{ 
+	return MB_CUR_MAX;
+}
+
+int _Locale_mb_cur_min (L_ctype_t * /*lctype*/) 
+{ 
+	return 1; 
+}
+
+int _Locale_is_stateless (L_ctype_t * /*lctype*/) 
+{ 
+	return (MB_CUR_MAX == 1)?1:0; 
+}
+
+#ifndef _STLP_NO_WCHAR_T
+wint_t _Locale_btowc(L_ctype_t * lctype, int c) 
+{ 
+	setlocale(LC_CTYPE, lctype->name);
+	return btowc(c); 
+}
+
+int _Locale_wctob(L_ctype_t * lctype, wint_t wc) 
+{ 
+	setlocale(LC_CTYPE, lctype->name);
+	return wctob(wc); 
+}
+
+size_t _Locale_mbtowc(L_ctype_t *lctype,
+                                 wchar_t *to, size_t n1,
+                                 const char *from, size_t n, int* chars_write,
+                                 mbstate_t * shift_state) 
+{
+#ifdef CODECVT_ICONV
+	char	codeset[64] = 
+	{
+		0
+	};
+	iconv_t state = GetState(lctype->statelist, shift_state, IN);
+	if (state == NULL)
+	{
+			ExtractCodeset(lctype->name, codeset);
+			state= iconv_open(UNICODESTR,codeset);
+			if (state==NULL)
+				return (size_t)-1;
+			if (AddState(&lctype->statelist,state,shift_state,IN) == 0)
+				return (size_t)-1;
+					
+	}
+	char* outbuf = (char*)to;
+	const char* inbuf = (char*)from;
+	unsigned int inbytes = n;
+	unsigned int outbytes = n1*sizeof(wchar_t);
+	unsigned int chars_read = iconv((void*)state,&inbuf,&inbytes,&outbuf,&outbytes);
+	*chars_write = (wchar_t*)outbuf - to; 
+	if (chars_read == (size_t)-1)
+	{
+		if ( (errno == EINVAL) || (outbuf!=(char*)to) )
+		{
+			BEtoLE(to,(wchar_t*)outbuf-to);
+			return inbuf-from;
+		}			
+		
+		return (size_t)-1;	
+		 
+	}
+	BEtoLE(to,(wchar_t*)outbuf-to);
+	//return (wchar_t*)outbuf-to;
+	return inbuf-from;
+
+#else
+	setlocale(LC_CTYPE, lctype->name);
+  return (size_t) mbtowc(to, from,n); 
+#endif
+}
+
+size_t _Locale_wctomb(L_ctype_t* lctype,
+                                 char *to, size_t n,
+                                 const wchar_t c,
+                                 mbstate_t *shift_state) 
+{
+#ifdef CODECVT_ICONV
+  	char	codeset[64] = 
+	{
+		0
+	};
+	iconv_t state = GetState(lctype->statelist, shift_state,OUT);
+	if (state == NULL)
+	{
+			ExtractCodeset(lctype->name, codeset);
+			state= iconv_open(codeset, UNICODESTR);
+			if (state==NULL)
+				return (size_t)-1;
+			if (AddState(&lctype->statelist,state,shift_state,OUT) == 0)
+				return (size_t)-1;
+					
+	}
+	char* outbuf = to;
+	const char* inbuf = (char*)&c;
+	unsigned int inbytes = 2;
+	unsigned int outbytes = n;
+	unsigned int chars_read = iconv((void*)state,&inbuf,&inbytes,&outbuf,&outbytes);
+	if (chars_read == (size_t)-1)
+	{
+		if (errno == EINVAL)
+			return outbuf-to;
+		else
+			return (size_t)-1;	
+		
+	}
+	//BEtoLE(to,(wchar_t*)outbuf-to);
+	return outbuf-to;
+#else
+	setlocale(LC_CTYPE, lctype->name);
+  	return (size_t) wctomb(to, c);
+
+#endif
+}
+
+# endif
+
+//Madhu - Need to double check the implementation. 
+size_t _Locale_unshift(L_ctype_t * /*lctype*/,
+                                  mbstate_t *st,
+                                  char *buff, size_t n, char ** next) 
+{
+#if 0	
+    if(*st == 0)
+    {
+		*next = buff;
+		return 0;
+    }
+    else
+    {
+		if(n < 1) 
+		{ 
+			*next = buff; 
+			return (size_t)-2; 
+		}
+
+		*next = buff + 1;
+		return 1;
+    }
+#endif
+//Conversion is not required, because iconv will not do partial conversion.
+	*next = buff;
+	return 0;
+}
+
+# endif /*  _STLP_NO_MBSTATE_T */
+
+
+/* Collate */
+ int _Locale_strcmp(L_collate_t* lcol,
+                    const char* pStr1, size_t len1, const char* pStr2,
+                    size_t len2) 
+{
+
+	char *ptempStr1, *ptempStr2;
+	int tempLen1,tempLen2;
+
+	tempLen1 = _Locale_strxfrm(lcol, NULL,0,pStr1,len1);
+	tempLen2 = _Locale_strxfrm(lcol, NULL,0,pStr2,len2);
+	ptempStr1 = (char*) new char[tempLen1];
+	ptempStr2 = (char*) new char[tempLen2];
+	int ret;
+	int minN = tempLen1 < tempLen2 ? tempLen1 : tempLen2;	
+	setlocale(LC_COLLATE, lcol->name);
+	_Locale_strxfrm(lcol, ptempStr1,tempLen1,pStr1,len1);
+	_Locale_strxfrm(lcol, ptempStr2,tempLen2,pStr2,len2);
+	ret = strncmp(ptempStr1, ptempStr2, minN);
+	if (ret == 0) 
+	{
+		if (len1 < len2) 
+			return -1;
+		else if (len1 > len2) 
+			return 1;
+		else 
+			return 0;
+	} else
+		return ret;
+
+}
+
+# ifndef _STLP_NO_WCHAR_T
+
+ int _Locale_strwcmp(L_collate_t* lcol,
+                     const wchar_t* pStr1, size_t len1,
+                     const wchar_t* pStr2, size_t len2) 
+{
+	wchar_t *ptempStr1, *ptempStr2;
+	int tempLen1,tempLen2;
+
+	tempLen1 = _Locale_strwxfrm(lcol, NULL,0,pStr1,len1);
+	tempLen2 = _Locale_strwxfrm(lcol, NULL,0,pStr2,len2);
+	ptempStr1 = (wchar_t*) new wchar_t[tempLen1+1];
+	ptempStr2 = (wchar_t*) new wchar_t[tempLen2+1];
+	int ret;
+	int minN = tempLen1 < tempLen2 ? tempLen1 : tempLen2;
+	setlocale(LC_COLLATE, lcol->name);
+	_Locale_strwxfrm(lcol, ptempStr1,tempLen1,pStr1,len1);
+	_Locale_strwxfrm(lcol, ptempStr2,tempLen2,pStr2,len2);
+	ret = wcsncmp(ptempStr1, ptempStr2, minN);
+	if (ret == 0) 
+	{
+		if (len1 < len2) 
+			return -1;
+		else if (len1 > len2) 
+			return 1;
+		else 
+			return 0;
+	} else
+		return ret;
+
+	
+}
+
+# endif
+
+ size_t _Locale_strxfrm(L_collate_t* lcol,
+                        char* pDestStr, size_t destLen,
+                        const char* pSrcStr, size_t srcLen) 
+{
+	size_t n;
+	setlocale(LC_COLLATE, lcol->name);
+
+	char* ptemp = (char*) new char[srcLen+1];
+	if(ptemp == NULL)
+		return 0;
+	memmove(ptemp,pSrcStr,srcLen);
+	*(ptemp+srcLen) = 0;
+	
+	n = strxfrm(pDestStr, ptemp, destLen);
+	
+	delete []ptemp;
+	
+	if ((pDestStr == NULL) || (destLen ==0) )
+		return n;
+	else if(n > destLen)
+		return (size_t)-1;
+	
+	pDestStr[n] = 0;
+	return n;
+}
+
+# ifndef _STLP_NO_WCHAR_T
+
+  size_t _Locale_strwxfrm(L_collate_t* lcol,
+                          wchar_t* pDestStr, size_t destLen,
+                          const wchar_t* pSrcStr, size_t srcLen)
+{
+	size_t n;
+	setlocale(LC_COLLATE, lcol->name);
+	wchar_t* ptemp = (wchar_t*) new wchar_t[srcLen+1];
+	if(ptemp == NULL)
+		return 0;
+	memmove(ptemp,pSrcStr,srcLen*sizeof(wchar_t));
+	*(ptemp+srcLen) = 0;
+	n = wcsxfrm(pDestStr, ptemp, destLen);
+	
+	delete []ptemp;
+	if ((pDestStr == NULL) || (destLen ==0) )
+		return n;
+	else if(n > destLen)
+		return (size_t)-1;
+	
+	pDestStr[n] = 0;
+	return n;
+}
+
+# endif
+
+/* Numeric */
+  
+ char _Locale_decimal_point(L_numeric_t* lnum)
+ { 
+ 	
+ 	return lnum->decimal_point[0];
+ }
+ 
+ char _Locale_thousands_sep(L_numeric_t* lnum) 
+ { 
+ 	 	
+ 	return lnum->thousands_sep[0]; 
+ }
+ const char* _Locale_grouping(L_numeric_t*lnum) 
+ { 
+ 	 	
+ 	return lnum->grouping;
+ }
+
+ const char * _Locale_true(L_numeric_t * /*lnum*/)  
+ { 
+ 	const char* __true_name="true"; //glib and NT doing the same
+  	
+	
+ 	return __true_name; 
+ }
+ 
+ const char * _Locale_false(L_numeric_t * /*lnum*/) 
+ {
+ 	const char* __false_name="false"; //glib and NT doing the same
+ 	
+ 	return __false_name;
+ }
+
+
+/* Monetary */
+
+ const char* _Locale_int_curr_symbol(L_monetary_t * lmon)
+ { 
+ 	 	
+ 	return lmon->int_curr_symbol;
+ }
+ 
+ const char* _Locale_currency_symbol(L_monetary_t * lmon)
+ { 
+ 	 	
+ 	return lmon->curr_symbol;
+ }
+ 
+ char   _Locale_mon_decimal_point(L_monetary_t * lmon)
+ { 
+ 	return lmon->decimal_point[0];
+ }
+ 
+ char    _Locale_mon_thousands_sep(L_monetary_t * lmon)
+ { 
+ 	 	
+ 	return lmon->thousands_sep[0];
+ }
+ 
+ const char* _Locale_mon_grouping(L_monetary_t * lmon)
+ { 
+ 	 	
+ 	return lmon->grouping;
+ }
+ 
+ const char* _Locale_positive_sign(L_monetary_t * lmon)
+ { 
+ 	 	
+ 	return lmon->positive_sign;
+ }
+ 
+ const char* _Locale_negative_sign(L_monetary_t * lmon)
+ { 
+ 	 	
+ 	return lmon->negative_sign;
+ }
+ 
+ char   _Locale_int_frac_digits(L_monetary_t * lmon)
+ { 
+ 	 	
+ 	return lmon->int_frac_digits;
+ }
+ 
+ char        _Locale_frac_digits(L_monetary_t * lmon)
+ { 
+ 	 	
+ 	return lmon->frac_digits;
+ }
+ 
+ int         _Locale_p_cs_precedes(L_monetary_t * lmon)
+ { 
+ 	struct lconv* plconv;
+ 	setlocale(LC_MONETARY, lmon->name);
+ 	plconv = localeconv();
+ 	 	
+ 	return plconv->p_cs_precedes;
+ }
+ 
+ int         _Locale_p_sep_by_space(L_monetary_t * lmon)
+ { 
+ 	struct lconv* plconv;
+ 	setlocale(LC_MONETARY, lmon->name);
+ 	plconv = localeconv();
+ 		 	
+ 	return plconv->p_sep_by_space;
+ }
+ 
+ int         _Locale_p_sign_posn(L_monetary_t * lmon)
+ { 
+	struct lconv* plconv;
+ 	setlocale(LC_MONETARY, lmon->name);
+ 	plconv = localeconv();
+ 	 	 	
+ 	return plconv->p_sign_posn;
+ }
+ 
+ int         _Locale_n_cs_precedes(L_monetary_t * lmon)
+ { 
+	struct lconv* plconv;
+ 	setlocale(LC_MONETARY, lmon->name);
+ 	plconv = localeconv();
+ 	
+ 	return plconv->n_cs_precedes;
+ }
+ 
+ int          _Locale_n_sep_by_space(L_monetary_t * lmon)
+ { 
+	struct lconv* plconv;
+ 	setlocale(LC_MONETARY, lmon->name);
+ 	plconv = localeconv();
+ 	 	 	 	
+ 	return plconv->n_sep_by_space; 
+ }
+ 
+ int          _Locale_n_sign_posn(L_monetary_t * lmon)
+ { 
+ 	struct lconv* plconv;
+ 	setlocale(LC_MONETARY, lmon->name);
+ 	plconv = localeconv();
+ 	
+ 	return plconv->n_sign_posn; 
+ }
+
+
+/* Time */
+ const char * _Locale_full_monthname(L_time_t * ltime, int month)
+ { 
+ 	 	
+ 	return ltime->month[month];
+ }
+ 
+ const char * _Locale_abbrev_monthname(L_time_t * ltime, int month)
+ { 
+ 	 	
+ 	return ltime->abbrev_month[month];
+ }
+ 
+ const char * _Locale_full_dayofweek(L_time_t * ltime, int day)
+ { 
+ 	 	
+ 	return ltime->dayofweek[day];
+ }
+ 
+ const char * _Locale_abbrev_dayofweek(L_time_t * ltime, int day)
+ { 
+ 	 	
+ 	return ltime->abbrev_dayofweek[day];
+ }
+
+ const char* _Locale_d_t_fmt(L_time_t* ltime)    
+ { 
+ 	setlocale(LC_TIME, ltime->name);
+ 	return nl_langinfo(D_T_FMT);
+ }
+ 
+ const char* _Locale_d_fmt(L_time_t* ltime)
+ {
+ 	setlocale(LC_TIME, ltime->name); 
+	return nl_langinfo(D_FMT);
+ }
+ 
+ const char* _Locale_t_fmt(L_time_t* ltime)
+ { 
+ 	setlocale(LC_TIME, ltime->name);
+ 	return nl_langinfo(T_FMT);
+ }
+ 
+ const char* _Locale_long_d_t_fmt(L_time_t* ltime)
+ { 
+ 	setlocale(LC_TIME, ltime->name);
+ 	return nl_langinfo(D_T_FMT); //Madhu--now same as D_T_FMT, need to check
+ }
+ 
+const char* _Locale_long_d_fmt(L_time_t* ltime)
+{ 
+	setlocale(LC_TIME, ltime->name);
+	return nl_langinfo(D_FMT); //Madhu--now same as D_FMT, need to check
+}
+const char* _Locale_am_str(L_time_t* ltime)     
+{ 
+	setlocale(LC_TIME, ltime->name);
+	return nl_langinfo(AM_STR);
+}
+
+const char* _Locale_pm_str(L_time_t* ltime)     
+{ 
+	setlocale(LC_TIME, ltime->name);
+	return nl_langinfo(PM_STR);
+}
+
+const char* _Locale_t_fmt_ampm(L_time_t* ltime) 
+{ 
+	setlocale(LC_TIME, ltime->name);
+	return nl_langinfo(T_FMT_AMPM);
+}
+
+/* Messages */ // Madhu - support after libc team supported.
+
+ 
+
+ int _Locale_catopen(L_messages_t* lmessage, const char* catalogName)
+ { 
+ 	lmessage->domain = __getString((char*)catalogName);
+ 	return 1;//catopen(catalogName,/*NL_CAT_LOCALE*/1); 
+ }
+ 
+ void _Locale_catclose(L_messages_t* lmessage, int /*catalog_desc*/) 
+ {
+ 	//setlocale(LC_MESSAGES, lmessage->name);
+ 	delete(lmessage->domain);
+ 	lmessage->domain = NULL;
+ 	//catclose(catalog_desc);
+ 
+ }
+ 
+ const char* _Locale_catgets(L_messages_t* lmessage, int /*catalog_desc*/,
+                                       int /*set*/, int /*message*/,
+                                       const char *dfault)
+ { 
+ 	char* locale = setlocale(LC_ALL, lmessage->name);
+#ifdef _MESSAGE_CATALOG_ 	
+ 	textdomain(lmessage->domain);	
+	
+ 	return gettext(dfault);
+#else
+	return NULL;
+#endif
+
+ }
+
+#ifdef __cplusplus    
+} /* extern C */
+_STLP_END_NAMESPACE
+#endif
+
+#endif /* real locale */