/*

 * Copyright (c) 1997-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:

 * NAME:

 * strftime - convert date and time to a string 

 * SYNOPSIS:

 * size_t strftime (char *array, size_t limitsize,const char*pattern,const struct tm *tme)

 * Formats  Time into string for  the given tags[options] with a  limit of  Limitsize bytes.

 * Options:

 * %a - Abbreviated weekday name (eg:Mon)

 * %A - Full weekday name (eg:Monday)

 * %b - Abbreviated month name (eg:Jan)

 * %B - full month name (eg:January)

 * %c - preferred date and time representation (eg:Tue 06 12:34:45 2009)

 * %C - century number (the year divided by 100 and truncated to an integer, range 00 to 99)

 * %d - Day of the month as a decimal number (range 01 to 31)

 * %D - Same as %m/%d/%y

 * %e - Day of the month as a decimal number, a single digit is preceded by a space (range ' 1' to '31')

 * %F- Equivalent to %Y-%m-%d 

 * %g - Same As %G, but without the century.

 * %G - The 4-digit year corresponding to the ISO week number (see %V). This has the same format and value as %Y, except that if the ISO week number belongs to the previous or next year, that year is used instead.

 * %h - Same as %b

 * %H - Hour as a decimal number using a 24-hour clock (range 00 to 23)

 * %I - Hour as a decimal number using a 12-hour clock (range 01 to 12)

 * %j - Day of the year as a decimal number (range 001 to 366)

 * %m - Month as a decimal number (range 01 to 12)

 * %M - Minute as a decimal number

 * %n - Newline character

 * %p - UPPER-CASE `AM' or `PM' according to the given time value

 * %P - Lower-case `am' or `pm' according to the given time value

 * %r - Time in a.m. and p.m. notation

 * %R - Time in 24 hour notation

 * %S - Second as a decimal number

 * %t - Tab character

 * %T - Current time, Equal to %H:%M:%S

 * %u - Weekday as a decimal number [1,7], with 1 representing Monday

 * %U - Week number of the current year as a decimal number, starting with the first Sunday as the first day of the first week

 * %V - The ISO 8601:1988 week number of the current year as a decimal number, range 01 to 53, where week 1 is the first week that has at least 4 days in the current year, and with Monday as the first day of the week. (Use %G or %g for the year component that corresponds to the week number for the specified timestamp.)

 * %W - Week number of the current year as a decimal number, starting with the first Monday as the first day of the first week

 * %w - Day of the week as a decimal, Sunday being 0

 * %x - Preferred date representation for the current locale without the time

 * %X - Preferred time representation for the current locale without the date

 * %y - Year as a decimal number without a century (range 00 to 99)

 * %Y - Year as a decimal number including the century

 * %Z or %z - Time zone offset or name or abbreviation (Operating System dependent)

 * %% - percent sign

 * Maximum length of this parameter is 1023 characters. 

 * 

 *

 */

 #include <time.h>

 #include <stdio.h>

 #include <stddef.h>

 #include <stdlib.h>  

 #include <string.h>

 static const int dayname_length[7] ={6, 6, 7, 9, 8, 6, 8};

 static const char*const  adayname[7]={"Sun","Mon","Tue","Wed","Thu","Fri","Sat"};

 static const char *const dayname[7] ={"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"};

 static const int monthname_length[12] ={7, 8, 5, 5, 3, 4, 4, 6, 9, 7, 8, 8};

 static const char *const amonthname[12]={"Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"};

 static const char *const monthname[12] ={"January", "February", "March", "April","May", "June", "July", "August", "September", "October", "November","December"};

 //  The Function Stores all characters  in Char * array,until it finds %.

 int splitter(char *array,size_t limitsize,const char** format,size_t* counter)

 {

 	while(**format!='%' && **format)

 	   {

 		 if(*counter<limitsize-1 )

 			{

 				array[*counter]=**format;

 				 (*counter)++;

 				(*format)++;

 			}

 		 else

 			{

 				return  1;

 			}		

 	  }

 	 array[*counter]='\0';

 	 return 0;

 }

 // The Funtion is Used for Storing Abbreviated WeekDay Nname in Place of %a. (eg:Mon)

 int funa(char *array,size_t limitsize,size_t *counter,const struct tm*tme)

 {

 	 if(*counter<limitsize-1)

 		{   

 			strcat(array,adayname[tme->tm_wday]);

 			*counter+=3;

 		}

 	else

 		{

 			return 1;

 		}	

 	return 0;

 }

 //The Function is Used for Stroring WeekDay Name in Place of %A. (eg:Monday)

 int funA(char *array,size_t limitsize,size_t *counter,const struct tm*tme)

 {

 	 if(*counter<limitsize-1)

 		{

 			strcat(array,dayname[tme->tm_wday]);

 			*counter+=dayname_length[tme->tm_wday];                         

 		}

 	else

 		{

 			return 1;

 		}

 	return 0;

 }  

 // The  Function  is Used for Storing Abbreviated Month Name in Place of %b.(eg:Jan)

 int funb(char *array,size_t limitsize,size_t *counter,const struct tm*tme)

 {

 	if(*counter<limitsize-1)

 		{

 			strcat(array,amonthname[tme->tm_mon]);

 			*counter+=3;                        

 		}

 	else

 		{

 			return  1;

 		}	

 	return 0;

 }

 // The  Function  is Used for Storing Month Name in Place of %B .(eg:January) 

 int funB(char *array,size_t limitsize,size_t *counter,const struct tm*tme)

 {

 	if(*counter<limitsize-1)

 		{

 			strcat(array,monthname[tme->tm_mon]);

 			*counter+=monthname_length[tme->tm_mon];                         

 		}

 	else

 		{

 			return 1;

 		}

 	return 0;

 }

 // The Function is Used for Storing preferred date and time representation  in Place of %c.(eg:Tue 06 12:34:45 2009)

 int func(char *array,size_t limitsize,size_t *counter,const struct tm*tme)

 {

 	if(*counter<limitsize-24)

 		{

 			strcat(array,adayname[tme->tm_wday]);

 			strcat(array," ");

 			strcat(array,amonthname[tme->tm_mon]);

 			*counter+=7;

 			sprintf(&array[*counter]," %.2d %.2d %.2d %.2d %.4d",tme->tm_mday,tme->tm_hour,tme->tm_min,tme->tm_sec,1900+tme->tm_year);

 			*counter+=17;

 			array[*counter]='\0';

 		}  	

 	else

 		{	

 			return  1;

 		}

 	return 0; 

 }

 // The Function is Used for Storing  Century number in place of %C .(eg:he year divided by 100 and truncated to an integer, range 00 to 99)

 int funC(char *array,size_t limitsize,size_t *counter,const struct tm*tme)

 {

 	if(*counter<limitsize-1)

 		{

 			sprintf(&array[*counter],"%.2d",(1900+tme->tm_year)/100);

 			*counter+=2;

 			array[*counter]='\0';

 		}

 	else

 		{

 		return  1;

 		}

 	return 0;

 }

 // The Function is Used for Storing Day of the month as a decimal number in Place of %d.(eg:range 01 to 31)	

 int fund(char *array,size_t limitsize,size_t *counter,const struct tm*tme)

 {

 	if (*counter < limitsize - 2)

 		{

 		sprintf (&array[*counter], "%.2d", tme->tm_mday);

 		*counter += 2;

 		array[*counter]='\0';

 		}

 	else

 		{

 		return  1;

 		}

 	return 0;    	

 }

 // The Function is Used for Storing  Date in form of %m/%d/%y in Place of %D.

 int funD(char *array,size_t limitsize,size_t *counter,const struct tm*tme)

 {

 	if(*counter<limitsize-8)

 		{

 			sprintf(&array[*counter],"%.2d/%.2d/%.2d",tme->tm_mon,tme->tm_mday,(1900+tme->tm_year)%100);  

 			*counter+=8;

 			array[*counter]='\0';        

 		}

 	else

 		{

 			return  1;

 		}	

 	return 0;

 }

 // The Function is Used for Storing Day of the month as a Decimal number, a single digit is preceded by a space in Place of %e. (eg:range ' 1' to '31')

 int fune(char *array,size_t limitsize,size_t *counter,const struct tm*tme)

 {

 	if(*counter<limitsize-2)

 		{

 			if(tme->tm_mday<10)

 				sprintf(&array[*counter]," %d",tme->tm_mday);

 			else

 				sprintf(&array[*counter],"%2d",tme->tm_mday);  

 			*counter+=2; 

 			array[*counter]='\0';                      

 		}

 	else

 		{

 			return  1;

 		}

 	return 0; 

 }

 // The Function is Used for Storing date in form of  %Y-%m-%d 

 int funF(char *array,size_t limitsize,size_t *counter,const struct tm*tme)

 {

 	if(*counter<limitsize-10)

 		{

 			sprintf(&array[*counter],"%4d/%.2d/%.2d",1900+tme->tm_year,tme->tm_mon,tme->tm_mday);

 			*counter+=10;

 			array[*counter]='\0';

 		}   

 	else

 		{

 		return  1;

 		}

 	return 0;

 }

 // The Function is  same as that of funG but without Century

 int fung(char*array,size_t limitsize,size_t *counter,const struct tm*tme)

 {

 	if(*counter<limitsize-2)

 		{

 			sprintf(&array[*counter],"%.2d",(1900+tme->tm_year)%100);

 			*counter+=2;

 			array[*counter]='\0';

 		}

 	else

 		{

 			return  1;

 		}	

 	return 0;

 }

 // The Function is Used For Storing  4-digit year corresponding to the ISO week number  in place of %G

 int funG(char*array,size_t limitsize,size_t *counter,const struct tm*tme)

 {

 	if(*counter<limitsize-4)

 		{

 			sprintf(&array[*counter],"%4d",1900+tme->tm_year);

 			*counter+=4;

 			array[*counter]='\0';

 		}

 	else

 		{	

 			return  1;

 		}	

 	return 0;

 }

 // The Function is same as funb

 int funh(char*array,size_t limitsize,size_t *counter,const struct tm*tme)

 {

 	if(*counter<limitsize-1)

 		{

 		strcat(array,amonthname[tme->tm_mon]);

 		*counter+=3;

 		array[*counter]='\0';

 		}

 	else

 		{

 			return  1;

 		}	

 	return 0;   

 }

 // The Function is Used for Storing Hour as a decimal number using a 24-hour clock in Place of %H (eg:range 00 to 23)	

 int funH(char *array,size_t limitsize,size_t *counter,const struct tm*tme)

 {	

 	if (*counter < limitsize - 2)

 		{

 			sprintf (&array[*counter], "%.2d",

 			tme->tm_hour);

 			*counter += 2;

 			array[*counter]='\0';

 		}

 	else

 		{

 			return  1;

 		}

 	return 0;  	

 }

 // The Function is Used for Storing Hour as a decimal number using a 12-hour clock in Place of %I(eg:range 01 to 12)

 int funI(char *array,size_t limitsize,size_t *counter,const struct tm*tme)

 {

 	if (*counter < limitsize - 2)

 		{

 			if(tme->tm_hour%12)

 				sprintf(&array[*counter],"%.2d",tme->tm_hour%12);

 			else

 				strcat(array,"12");

 			*counter+=2;

 			array[*counter]='\0';

 		}

 	else

 		{

 			return  1;

 		}

 	return 0;   

 }

 // The Function is Used for Storing Day of the year as a decimal number in Place of %j (eg:range 001 to 366)

 int funj(char *array,size_t limitsize,size_t *counter,const struct tm*tme)

 {

 	if (*counter < limitsize - 3)

 		{

 			sprintf (&array[*counter], "%.3d", tme->tm_yday + 1);

 			*counter += 3;

 			array[*counter]='\0';

 		}

 	else

 		{

 			return  1;

 		}

 	return 0;  	

 }

 // The Function is Used for StoringThe hour (24-hour clock) as a decimal number (range  0  to  23);single digits are preceded by a blankin Place of %k

 int funk(char *array,size_t limitsize,size_t *counter,const struct tm*tme)

 {

 	if(*counter<limitsize-2)

 		{

 			if(tme->tm_hour<10)

 				sprintf(&array[*counter]," %d",tme->tm_hour);

 			else

 				sprintf(&array[*counter],"%2d",tme->tm_hour);

 			*counter+=2; 

 			array[*counter]='\0';

 		}

 	else

 		{

 			return  1;

 		}	

 	return 0;    

 }

 // The Function is Used for Storing The  hour  (12-hour  clock) as a decimal number (range 1 to 12);single digits are preceded by a blank in Place of %l

 int funl(char *array,size_t limitsize,size_t *counter,const struct tm*tme)

 {

 	if (*counter < limitsize - 2)

 		{

 			if(tme->tm_hour%12)

 				{

 					if(tme->tm_hour%12<10)

 						sprintf(&array[*counter],"% d",tme->tm_hour%12);

 					else

 						sprintf(&array[*counter],"%d",tme->tm_hour%12);

 				}

 			else

 				strcat(array,"12");

 			*counter+=2;

 			array[*counter]='\0';

 		}

 	else

 		{

 			return  1;

 		}

 	return 0;       

 }

 // The Function is Used for Storing Month as a decimal number in Place of %m (eg:range 01 to 12)

 int funm(char *array,size_t limitsize,size_t *counter,const struct tm*tme)

 {

 	if (*counter < limitsize - 2)

 		{

 			sprintf (&array[*counter], "%.2d", tme->tm_mon + 1);

 			*counter += 2;

 			array[*counter]='\0';

 		}

 	else

 		{

 		return  1;

 		}

 	return 0;   	

 }

 // The Function is Used for Storing Minute as a decimal number in Place of %M

 int funM(char *array,size_t limitsize,size_t *counter,const struct tm*tme)

 {

 	if (*counter < limitsize - 2)

 		{

 			sprintf (&array[*counter], "%.2d", tme->tm_min);

 			*counter += 2;

 			array[*counter]='\0';

 		}

 	else

 		{

 			return  1;

 		}

 	return 0;  	

 }

 // The Function is Used for Storing `AM' or `PM' according to the given time  value,  or  the corresponding  strings  for the current locale.  Noon is treated as `pm' and midnight as `am'.

 int funp(char *array,size_t limitsize,size_t *counter,const struct tm*tme)

 {

 	if (*counter< limitsize - 2)

 		{

 			if (tme->tm_hour < 12)

 				strcat(array,"A");

 			else

 				strcat(array,"P");

 			strcat(array,"M");

 			*counter+=2;

 		}

 	else

 		{

 			return  1;

 		}

 	return 0;   	

 }

 // The Function is Used for Storing `am' or `pm' according to the given time  value,  or  the corresponding  strings  for the current locale.  Noon is treated as `pm' and midnight as `am'.

 int funP(char*array,size_t limitsize,size_t *counter,const struct tm*tme)

 {	

 	if (*counter< limitsize - 2)

 		{

 			if (tme->tm_hour < 12)

 				strcat(array,"a");

 			else

 				strcat(array,"p");

 			strcat(array,"m");

 			*counter+=2;

 		}

 	else

 		{

 			return  1;

 		}

 	return 0;

 }

 //The Function is Used for Storing  Hour,minute,second,time value in place of %r,same as %I:%M:%S %p'

 int funr(char*array,size_t limitsize,size_t *counter,const struct tm*tme)

 {

 	if (*counter< limitsize - 11)

 		{

 			if(tme->tm_hour%12)

 				{

 					if(tme->tm_hour%12<10)

 						sprintf(&array[*counter],"% d",tme->tm_hour);

 					else

 						sprintf(&array[*counter],"%d",tme->tm_hour);

 				}

 			else

 				strcat(array,"12");  

 			*counter+=2;

 			array[*counter]='\0';

 			strcat(array,":");

 			*counter+=1;

 			sprintf (&array[*counter], "%.2d", tme->tm_min);

 			*counter += 2;

 			array[*counter]='\0';

 			strcat(array,":");

 			*counter+=1;

 			sprintf (&array[*counter], "%2.2d",tme->tm_sec);

 			*counter += 2;

 			array[*counter]='\0';

 			strcat(array," ");

 			*counter+=1;

 			if (tme->tm_hour < 12)

 				strcat(array,"A");

 			else

 				strcat(array,"P");

 			strcat(array,"M");

 			*counter+=2;

 		}

 	else

 		{

 			return  1;

 		}

 	return 0; 

 }

 //   The Function is Used for Storing  The time in 24-hour notation in Place of %R .Same as (%H:%M)..

 int funR(char*array,size_t limitsize,size_t *counter,const struct tm*tme)

 {

     if (*counter< limitsize - 5)

     {

      sprintf (&array[*counter], "%.2d",

 		       tme->tm_hour);

      strcat(array,":");

      *counter+=3;

       sprintf (&array[*counter], "%.2d", tme->tm_min);

 	      *counter += 2;

 	      array[*counter]='\0';

        }

        else

 	       {

 		   return  1;

 		}	   

     return 0;

 }

 //   The Function is Used for Storing The  number  of  seconds since the Epoch, i.e., since 1970-01-0  0:00:00 UTC.in place of %s

 int funs(char*array,size_t limitsize,size_t *counter,const struct tm*tme)

 {

 	size_t count=0;

 	size_t temptime;

 	time_t timeinseconds;

 	timeinseconds = time (NULL);

 	temptime=timeinseconds;

 	while(temptime>0)

 		{

 			count++;

 			temptime/=10;

 		}

 	if(*counter<limitsize-count)

 		{

 			sprintf(&array[*counter],"%ld",timeinseconds);

 			*counter+=count;

 			array[*counter]='\0';

 		}

 	else

 		{

 		return  1;

 		}

 	return 0;

 }

 //   The Function is Used for Storing   The second as a decimal number (eg:range 00 to 60)

 int funS(char *array,size_t limitsize,size_t *counter,const struct tm*tme)

 {

 	if (*counter < limitsize - 2)

 		{

 			sprintf (&array[*counter], "%.2d", tme->tm_sec);

 			*counter += 2;

 			array[*counter]='\0';

 		}

 	else

 		{

 			return  1;

 		}

 	return 0;     	

 }

 //   The Function is Used for Storing  The time in 24-hour notation (%H:%M:%S) in place of %T

 int funT(char *array,size_t limitsize,size_t *counter,const struct tm*tme)

 {

 	 if (*counter < limitsize - 2)

 		 {

 			 sprintf (&array[*counter], "%.2d",tme->tm_hour);

 			 *counter+=2;

 			 array[*counter]='\0';

 			 strcat(array,":");

 			 *counter += 1; 

 			 sprintf (&array[*counter], "%.2d", tme->tm_min);

 			 *counter+=2;

 			 array[*counter]='\0';

 			 strcat(array,":");

 			 *counter += 1;

 			 sprintf (&array[*counter], "%.2d", tme->tm_sec);

 			 *counter += 2;

 			 array[*counter]='\0';

 		} 

 	else

 		{

 			return  1;

 		}

 	return 0;

 }

 //   The Function is Used for Storing The  day of the week as a decimal, range 1 to 7, Monday being 1 in Place of %U.

 int funu(char *array,size_t limitsize,size_t *counter,const struct tm*tme)

 {

 	if (*counter < limitsize - 1)

 		{

 			sprintf (&array[*counter], "%.1d",tme->tm_wday);

 			*counter+=1;

 			array[*counter]='\0';

 		}

 	else

 		{

 			return  1;

 		}

 	return 0;    

 }

 //   The Function is Used for Storing The week number of the current year as a decimal  number,  range  00  to  53,  starting  with the first Sunday as the first day of week 01 in Place of %U

 int funU(char *array,size_t limitsize,size_t *counter,const struct tm*tme)

 {

 	if (*counter < limitsize - 2) 

 		{

 			int  temp= tme->tm_yday/7;

 			if (tme->tm_yday%7 >tme->tm_wday)

 				temp++;

 			sprintf(&array[*counter],"%.2d",temp);

 			*counter+=2;

 			array[*counter]='\0';

 		}

 	else

 		{

 			return   1;

 		}

 	return 0;      	

 }

 //   The Function is Used for Storing The  day of the week as a decimal, range 0 to 6, Sunday being 0 in Place of %w

 int funw(char *array,size_t limitsize,size_t *counter,const struct tm*tme)

 {

 	if (*counter < limitsize - 1)

 		{

 			sprintf (&array[*counter], "%.1d",tme->tm_wday);

 			*counter+=1;

 			array[*counter]='\0';

 		}

 	else

 		{

 			return  1;

 		}

 	return 0;    	

 }

 //   The Function is Used for Storing The week number of the current year as a decimal  number,  range 00  to  53,  starting  with the first Monday as the first day of week 01 in Place of %W

 int funW(char *array,size_t limitsize,size_t *counter,const struct tm*tme)

 {

 	if (*counter < limitsize - 2) 

 		{

 			int temp= tme->tm_yday/7;

 			if (tme->tm_yday%7 > (tme->tm_wday+6)%7)

 				temp++;

 			sprintf(&array[*counter],"%.2d",temp);

 			*counter+=2;

 			array[*counter]='\0';

 		}

 	else

 		{

 			return  1;

 		}

 	return 0;

 }

 // The Function is Used for Storing preferred date representation for the current locale without   the time in Place of %x

 int funx(char *array,size_t limitsize,size_t *counter,const struct tm*tme)

 {

 	if (*counter < limitsize - 15)

 		{

 			strcat(array,adayname[tme->tm_wday]);

 			*counter+=3;

 			array[*counter]='\0';

 			strcat(array," ");

 			*counter+=1;

 			strcat(array,amonthname[tme->tm_mon]);

 			strcat(array," ");

 			*counter+=4;

 			sprintf (&array[*counter]," %.2d %.4d", tme->tm_mday,1900 + tme->tm_year);

 			*counter += 8;

 			array[*counter]='\0';

 		}

 	else

 		{	

 			return  1;

 		}

 	return 0;    	

 }

 // The Function is Used for Storing  preferred time representation for the current locale without the date in Place of %X

 int funX(char *array,size_t limitsize,size_t *counter,const struct tm*tme)

 {

 	if (*counter < limitsize - 8)

 		{

 			sprintf (&array[*counter],"%2.2d:%2.2d:%2.2d",tme->tm_hour, tme->tm_min,tme->tm_sec);

 			*counter += 8;

 			array[*counter]='\0';

 		}

 	else

 		{

 			return  1;

 		}

 	return 0;     	

 }

 // The Function is Used for Storing  year as a decimal number without a century (range 00 to 99). in Place of %y

 int funy(char *array,size_t limitsize,size_t *counter,const struct tm*tme)

 {

 	if (*counter < limitsize - 2)

 		{

 			sprintf (&array[*counter], "%.2d",tme->tm_year);

 			*counter += 2;

 			array[*counter]='\0';

 		}

 	else

 		{

 			return  1;

 		}

 	return 0;   	

 }

 // The Function is Used for Storing  The year as a decimal number including the century in Place of %Y

 int funY(char *array,size_t limitsize,size_t *counter,const struct tm*tme)

 {

 	if (*counter < limitsize - 4)

 		{

 			sprintf (&array[*counter], "%.4d",1900 + tme->tm_year);

 			*counter += 4;

 			array[*counter]='\0';

 		}

 	else

 		{

 			return  1;

 		}

 	return 0;   	

 }

 //- convert/Formats date and time to a string for  the given tags[options] with a  limit of  Limitsize bytes

 // It formats the broken-down time  according to the format specification format and places the result in the  character  array of  Limitsize .The Function returns the number of characters written in the array,

 // if successful and 0 if  the size exceeeds the limit .

 EXPORT_C size_t strftime (char *array, size_t limitsize,const char*pattern,const struct tm *tme)

 {          

 	size_t* counter=(size_t* )malloc(sizeof(size_t));

 	size_t error=0,funerror=0;

 	*counter=0;

 	array[*counter]='\0';

 	while(1)

 		{

 			error=splitter(array,limitsize,&pattern,counter);

 			if(!error)

 				{

 					if(*pattern=='\0')

 						break;

 					else

 						{

 							pattern++;

 							switch(*pattern)

 								{

 									case '%':

 										if(*counter<limitsize-1)

 											array[(*counter)++]='%';

 										else

 											return  0;

 										break;

 									case 'a':

 										funerror= funa(array,limitsize,counter,tme);

 										if(funerror)

 											return  0;

 										break;

 									case 'A':

 										funerror=funA(array,limitsize,counter,tme);

 										if(funerror)

 											return 0;

 										break;

 									case 'b':

 										funerror=funb(array,limitsize,counter,tme);

 										if(funerror)

 											return  0;

 										break;

 									case 'B':

 										funerror=funB(array,limitsize,counter,tme);

 										if(funerror)

 											return  0;

 										break;

 									case 'c':

 										funerror=func(array,limitsize,counter,tme);

 										if(funerror)

 											return  0;

 										break;

 									case 'C':

 										funerror=funC(array,limitsize,counter,tme);

 										if(funerror)

 											return  0;

 										break;

 									case 'd':

 										funerror=fund(array,limitsize,counter,tme);

 										if(funerror)

 											return  0;

 										break;

 									case 'D':

 										funerror=funD(array,limitsize,counter,tme);

 										if(funerror)

 											return  0;

 										break; 

 									case 'e':

 										funerror=fune(array,limitsize,counter,tme);

 										if(funerror)

 											return  0;

 										break;

 									case 'F':

 										funerror=funF(array,limitsize,counter,tme);

 										if(funerror)

 											return  0;

 										break;         

 									case 'g':

 										funerror=fung(array,limitsize,counter,tme);

 										if(funerror)

 											return  0;

 										break;  

 									case 'G':

 										funerror=funG(array,limitsize,counter,tme);

 										if(funerror)

 											return  0;

 										break;

 									case 'H':

 										funerror=funH(array,limitsize,counter,tme);

 										if(funerror)

 											return  0;

 										break;

 									case 'I':

 										funerror=funI(array,limitsize,counter,tme);

 										if(funerror)

 											return  0;

 										break;

 									case 'j':

 										funerror=funj(array,limitsize,counter,tme);

 										if(funerror)

 											return  0;

 										break;

 									case 'k':

 										funerror=funk(array,limitsize,counter,tme);

 										if(funerror)

 											return  0;

 										break;

 									case 'l':

 										funerror=funl(array,limitsize,counter,tme);

 										if(funerror)

 											return  0;

 										break;

 									case 'm':

 										funerror=funm(array,limitsize,counter,tme);

 										if(funerror)

 											return  0;

 										break;

 									case 'M':

 										funerror=funM(array,limitsize,counter,tme);

 										if(funerror)

 											return  0;

 										break;

 									case 'p':

 										funerror=funp(array,limitsize,counter,tme);

 										if(funerror)

 											return  0;

 										break;

 									case 'P':

 										funerror=funP(array,limitsize,counter,tme);

 										if(funerror)

 											return  0;

 										break;

 									case 'r':

 										funerror=funr(array,limitsize,counter,tme);

 										if(funerror)

 											return  0;

 										break;

 									case 'R':

 										funerror=funR(array,limitsize,counter,tme);

 										if(funerror)

 											return  0;

 										break; 

 									case 's':

 										funerror=funs(array,limitsize,counter,tme);

 										if(funerror)

 											return  0;

 										break;

 									case 'S':

 										funerror=funS(array,limitsize,counter,tme);

 										if(funerror)

 											return  0;

 										break;

 									case 'T':

 										funerror=funT(array,limitsize,counter,tme);

 										if(funerror)

 											return  0;

 										break;

 									case 'u':

 										funerror=funu(array,limitsize,counter,tme);

 										if(funerror)

 											return  0;

 										break;

 									case 'U':

 										funerror=funU(array,limitsize,counter,tme);

 										if(funerror)

 											return  0;

 										break;

 									case 'w':

 										funerror=funw(array,limitsize,counter,tme);

 										if(funerror)

 											return  0;

 										break;

 									case 'W':

 										funerror=funW(array,limitsize,counter,tme);

 										if(funerror)

 											return  0;

 										break;

 									case 'x':

 										funerror=funx(array,limitsize,counter,tme);

 										if(funerror)

 											return  0;

 										break;

 									case 'X':

 										funerror=funX(array,limitsize,counter,tme);

 										if(funerror)

 											return  0;

 										break;

 									case'y':

 										funerror=funy(array,limitsize,counter,tme);

 										if(funerror)

 											return  0;

 										break;

 									case 'Y':

 										funerror=funY(array,limitsize,counter,tme);

 										if(funerror)

 											return  0;

 										break;

 									case 'Z':

 										break;

 								}		

 						}

 				}		

 			else

 				{

 					return  0;

 				}

 			if (*pattern)

 				pattern++;

 			else

 				break;

 		}

 	array[*counter]='\0';

 	error=*counter;

 	free (counter);

 	counter=NULL;

 	return error;

 }