X-Git-Url: https://git.saurik.com/apple/icu.git/blobdiff_plain/374ca955a76ecab1204ca8bfa63ff9238d998416..ef6cf650f4a75c3f97de06b51fa104f2069b9ea2:/icuSources/test/perf/ustrperf/stringperf.h

diff --git a/icuSources/test/perf/ustrperf/stringperf.h b/icuSources/test/perf/ustrperf/stringperf.h
index f3b83ad0..8dc316f3 100644
--- a/icuSources/test/perf/ustrperf/stringperf.h
+++ b/icuSources/test/perf/ustrperf/stringperf.h
@@ -1,25 +1,28 @@
 /*
 **********************************************************************
-* Copyright (c) 2002-2004, International Business Machines
+* Copyright (c) 2002-2016, International Business Machines
 * Corporation and others.  All Rights Reserved.
 **********************************************************************
-**********************************************************************
 */
 #ifndef _STRINGPERF_H
 #define _STRINGPERF_H
 
-#include <string>
-
-#include "uperf.h"
+#include "cmemory.h"
 #include "unicode/utypes.h"
 #include "unicode/unistr.h"
 
+#include "unicode/uperf.h"
+
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+
 typedef std::wstring stlstring;	
 
 /* Define all constants for test case operations */
 #define MAXNUMLINES	40000	//Max number of lines in a test data file
 #define MAXSRCLEN 20		//Max length of one line. maybe a larger number, but it need more mem
-#define LOOPS 100			//Iterations 
+#define LOOPS 100			//Iterations
 //#define LOOPS 10
 #define catenate_STRLEN 2
 
@@ -61,385 +64,385 @@ class StringPerfFunction : public UPerfFunction
 {
 public:
 
-	virtual long getEventsPerIteration(){
-		int loops = LOOPS;
-		if (catICU) { delete catICU;}
-		if (catStd) { delete catStd;}
-
-		if (bCatenatePrealloc) {
-	
-			int to_alloc = loops * MAXNUMLINES * (MAXSRCLEN + catenate_STRLEN);
-			catICU = new UnicodeString(to_alloc,'a',0);
-			//catICU = new UnicodeString();
-
-			catStd = new stlstring();
-			//catStd -> reserve(loops * MAXNUMLINES * (MAXSRCLEN + catenate_STRLEN));
-			catStd -> reserve(110000000);
-		} else {
-			catICU = new UnicodeString();
-			catStd = new stlstring();
-		}
-
-		return -1;
+    virtual long getEventsPerIteration(){
+        int loops = LOOPS;
+        if (catICU) { delete catICU;}
+        if (catStd) { delete catStd;}
+
+        if (bCatenatePrealloc) {
+
+            int to_alloc = loops * MAXNUMLINES * (MAXSRCLEN + catenate_STRLEN);
+            catICU = new UnicodeString(to_alloc,'a',0);
+            //catICU = new UnicodeString();
+
+            catStd = new stlstring();
+            //catStd -> reserve(loops * MAXNUMLINES * (MAXSRCLEN + catenate_STRLEN));
+            catStd -> reserve(110000000);
+        } else {
+            catICU = new UnicodeString();
+            catStd = new stlstring();
+        }
+
+        return -1;
     }
 
-	virtual void call(UErrorCode* status)
-	{
+    virtual void call(UErrorCode* status)
+    {
         if(line_mode_==TRUE){
             if(uselen_){
                 for(int32_t i = 0; i< numLines_; i++){
-					if (fnType_==Fn_ICU) {
-						(*fn1_)(lines_[i].name,lines_[i].len,uS0_[i]);
-					} else {
-						(*fn2_)(wlines_[i].name,wlines_[i].len,sS0_[i]);
-					}
+                    if (fnType_==Fn_ICU) {
+                        (*fn1_)(lines_[i].name,lines_[i].len,uS0_[i]);
+                    } else {
+                        (*fn2_)(wlines_[i].name,wlines_[i].len,sS0_[i]);
+                    }
                 }
             }else{
                 for(int32_t i = 0; i< numLines_; i++){
                     if (fnType_==Fn_ICU) {
-						(*fn1_)(lines_[i].name,-1,uS0_[i]);
-					} else {
-						(*fn2_)(wlines_[i].name,-1,sS0_[i]);
-					}
+                        (*fn1_)(lines_[i].name,-1,uS0_[i]);
+                    } else {
+                        (*fn2_)(wlines_[i].name,-1,sS0_[i]);
+                    }
                 }
             }
         }else{
             if(uselen_){
-				if (fnType_==Fn_ICU) {
-					(*fn1_)(src_,srcLen_,*ubulk_);
-				} else {
-					(*fn2_)(wsrc_,wsrcLen_,*sbulk_);
-				}
+                if (fnType_==Fn_ICU) {
+                    (*fn1_)(src_,srcLen_,*ubulk_);
+                } else {
+                    (*fn2_)(wsrc_,wsrcLen_,*sbulk_);
+                }
             }else{
-				if (fnType_==Fn_ICU) {
-					(*fn1_)(src_,-1,*ubulk_);
-				} else {
-					(*fn2_)(wsrc_,-1,*sbulk_);
-				}
+                if (fnType_==Fn_ICU) {
+                    (*fn1_)(src_,-1,*ubulk_);
+                } else {
+                    (*fn2_)(wsrc_,-1,*sbulk_);
+                }
             }
         }
-	}
+    }
 
-	virtual long getOperationsPerIteration()
-	{
+    virtual long getOperationsPerIteration()
+    {
         if(line_mode_==TRUE){
             return numLines_;
         }else{
             return 1;
         }
-	}
-
-	StringPerfFunction(ICUStringPerfFn func, ULine* srcLines, int32_t srcNumLines, UBool uselen)
-	{
-		
-		fn1_ = func;
-		lines_=srcLines;
-		wlines_=NULL;
-		numLines_=srcNumLines;
-		uselen_=uselen;
-		line_mode_=TRUE;
+    }
+
+    StringPerfFunction(ICUStringPerfFn func, ULine* srcLines, int32_t srcNumLines, UBool uselen)
+    {
+
+        fn1_ = func;
+        lines_=srcLines;
+        wlines_=NULL;
+        numLines_=srcNumLines;
+        uselen_=uselen;
+        line_mode_=TRUE;
         src_ = NULL;
         srcLen_ = 0;
-		wsrc_ = NULL;
-		wsrcLen_ = 0;
-		fnType_ = Fn_ICU;
-		
-		uS0_=new UnicodeString[numLines_];
-		for(int32_t i=0; i<numLines_; i++) {
-			uS0_[i]=UnicodeString(lines_[i].name, lines_[i].len);
-		} 
-		sS0_=NULL;
-		ubulk_=NULL;
-		sbulk_=NULL;
-	} 
-
-	StringPerfFunction(StdStringPerfFn func, ULine* srcLines, int32_t srcNumLines, UBool uselen)
-	{
-		
-		fn2_ = func;
-		lines_=srcLines;
-		wlines_=NULL;
-		numLines_=srcNumLines;
-		uselen_=uselen;
-		line_mode_=TRUE;
+        wsrc_ = NULL;
+        wsrcLen_ = 0;
+        fnType_ = Fn_ICU;
+
+        uS0_=new UnicodeString[numLines_];
+        for(int32_t i=0; i<numLines_; i++) {
+            uS0_[i]=UnicodeString(lines_[i].name, lines_[i].len);
+        }
+        sS0_=NULL;
+        ubulk_=NULL;
+        sbulk_=NULL;
+    }
+
+    StringPerfFunction(StdStringPerfFn func, ULine* srcLines, int32_t srcNumLines, UBool uselen)
+    {
+
+        fn2_ = func;
+        lines_=srcLines;
+        wlines_=NULL;
+        numLines_=srcNumLines;
+        uselen_=uselen;
+        line_mode_=TRUE;
         src_ = NULL;
         srcLen_ = 0;
-		wsrc_ = NULL;
-		wsrcLen_ = 0;
-		fnType_ = Fn_STD;
-
-		uS0_=NULL;
-		ubulk_=NULL;
-		sbulk_=NULL;
-		
-		//fillin wlines_[], sS0_[]
-		prepareLinesForStd();
-	} 
-
-	StringPerfFunction(ICUStringPerfFn func, UChar* source, int32_t sourceLen, UBool uselen)
-	{
-		
-		fn1_ = func;
-		lines_=NULL;
-		wlines_=NULL;
-		numLines_=0;
-		uselen_=uselen;
-		line_mode_=FALSE;
-		src_ = new UChar[sourceLen];
-		memcpy(src_, source, sourceLen * U_SIZEOF_UCHAR);
+        wsrc_ = NULL;
+        wsrcLen_ = 0;
+        fnType_ = Fn_STD;
+
+        uS0_=NULL;
+        ubulk_=NULL;
+        sbulk_=NULL;
+
+        //fillin wlines_[], sS0_[]
+        prepareLinesForStd();
+    }
+
+    StringPerfFunction(ICUStringPerfFn func, UChar* source, int32_t sourceLen, UBool uselen)
+    {
+
+        fn1_ = func;
+        lines_=NULL;
+        wlines_=NULL;
+        numLines_=0;
+        uselen_=uselen;
+        line_mode_=FALSE;
+        src_ = new UChar[sourceLen];
+        memcpy(src_, source, sourceLen * U_SIZEOF_UCHAR);
         srcLen_ = sourceLen;
-		wsrc_ = NULL;
-		wsrcLen_ = 0;
-		fnType_ = Fn_ICU;
-
-		uS0_=NULL;
-		sS0_=NULL;	
-		ubulk_=new UnicodeString(src_,srcLen_);
-		sbulk_=NULL;
-	}
-
-	StringPerfFunction(StdStringPerfFn func, UChar* source, int32_t sourceLen, UBool uselen)
-	{
-		
-		fn2_ = func;
-		lines_=NULL;
-		wlines_=NULL;
-		numLines_=0;
-		uselen_=uselen;
-		line_mode_=FALSE;
-		src_ = new UChar[sourceLen];
-		memcpy(src_, source, sourceLen * U_SIZEOF_UCHAR);
+        wsrc_ = NULL;
+        wsrcLen_ = 0;
+        fnType_ = Fn_ICU;
+
+        uS0_=NULL;
+        sS0_=NULL;	
+        ubulk_=new UnicodeString(src_,srcLen_);
+        sbulk_=NULL;
+    }
+
+    StringPerfFunction(StdStringPerfFn func, UChar* source, int32_t sourceLen, UBool uselen)
+    {
+
+        fn2_ = func;
+        lines_=NULL;
+        wlines_=NULL;
+        numLines_=0;
+        uselen_=uselen;
+        line_mode_=FALSE;
+        src_ = new UChar[sourceLen];
+        memcpy(src_, source, sourceLen * U_SIZEOF_UCHAR);
         srcLen_ = sourceLen;
-		fnType_ = Fn_STD;
-
-		uS0_=NULL;
-		sS0_=NULL;
-		ubulk_=NULL;
-
-		//fillin wsrc_, sbulk_
-		prepareBulkForStd();
-					 
-	}
-
-	~StringPerfFunction()
-	{
-		//free(src_);
-		free(wsrc_);
-		delete[] src_;
-		delete ubulk_;
-		delete sbulk_;
-		delete[] uS0_;
-		delete[] sS0_;
-		delete[] wlines_;
-	}
+        fnType_ = Fn_STD;
+
+        uS0_=NULL;
+        sS0_=NULL;
+        ubulk_=NULL;
+
+        //fillin wsrc_, sbulk_
+        prepareBulkForStd();
+
+    }
+
+    ~StringPerfFunction()
+    {
+        //free(src_);
+        free(wsrc_);
+        delete[] src_;
+        delete ubulk_;
+        delete sbulk_;
+        delete[] uS0_;
+        delete[] sS0_;
+        delete[] wlines_;
+    }
 
 private:
-	void prepareLinesForStd(void)
-	{
-		UErrorCode err=U_ZERO_ERROR;
-		
-		wlines_=new WLine[numLines_];
+    void prepareLinesForStd(void)
+    {
+        UErrorCode err=U_ZERO_ERROR;
+
+        wlines_=new WLine[numLines_];
         wchar_t ws[100];
-        int32_t wcap = sizeof(ws) / sizeof(*ws);
+        int32_t wcap = UPRV_LENGTHOF(ws);
         int32_t wl;
-		wchar_t* wcs;
-        
-		sS0_=new stlstring[numLines_];
-		for(int32_t i=0; i<numLines_; i++) {		
-			if(uselen_) {
-				wcs = u_strToWCS(ws, wcap, &wl, lines_[i].name, lines_[i].len, &err);
-				memcpy(wlines_[i].name, wcs, wl * sizeof(wchar_t));
-				wlines_[i].len = wl;
-				sS0_[i]=stlstring(wlines_[i].name, wlines_[i].len);
-			} else {
-				wcs = u_strToWCS(ws, wcap, &wl, lines_[i].name, lines_[i].len-1, &err);
-				memcpy(wlines_[i].name, wcs, wl*sizeof(wchar_t));
-				wlines_[i].len = wl;
-				sS0_[i]=stlstring(wlines_[i].name, wlines_[i].len+1);
-			}
-
-			if (U_FAILURE(err)) {
-				return;
-			}
-		}
-
-	}
-
-	void prepareBulkForStd(void)
-	{
-		UErrorCode err=U_ZERO_ERROR;
-
-		const UChar* uSrc = src_;
-		int32_t uSrcLen = srcLen_;
-		wchar_t* wDest = NULL;
-		int32_t wDestLen = 0;
-		int32_t reqLen= 0 ;
-
-		if(uselen_) {
-			/* pre-flight*/
-			u_strToWCS(wDest,wDestLen,&reqLen,uSrc,uSrcLen,&err);
-
-			if(err == U_BUFFER_OVERFLOW_ERROR){
-				err=U_ZERO_ERROR;
-				wDest =(wchar_t*) malloc(sizeof(wchar_t) * (reqLen));
-				wDestLen = reqLen;
-				u_strToWCS(wDest,wDestLen,&reqLen,uSrc,uSrcLen,&err);
-			}
-
-			if (U_SUCCESS(err)) { 
-				wsrc_ = wDest;
-				wsrcLen_ = wDestLen;
-				sbulk_=new stlstring(wsrc_,wsrcLen_); 
-			}
-
-		} else {
-			/* pre-flight*/
-			u_strToWCS(wDest,wDestLen,&reqLen,uSrc,uSrcLen-1,&err);
-
-			if(err == U_BUFFER_OVERFLOW_ERROR){
-				err=U_ZERO_ERROR;
-				wDest =(wchar_t*) malloc(sizeof(wchar_t) * (reqLen+1));
-				wDestLen = reqLen+1;
-				u_strToWCS(wDest,wDestLen,&reqLen,uSrc,uSrcLen-1,&err);
-			}
-
-			if (U_SUCCESS(err)) { 
-				wsrc_ = wDest;
-				wsrcLen_ = wDestLen;
-				sbulk_=new stlstring(wsrc_); 
-			}
-		}
-
-		//free(wDest);
-	}
+        wchar_t* wcs;
+
+        sS0_=new stlstring[numLines_];
+        for(int32_t i=0; i<numLines_; i++) {
+            if(uselen_) {
+                wcs = u_strToWCS(ws, wcap, &wl, lines_[i].name, lines_[i].len, &err);
+                memcpy(wlines_[i].name, wcs, wl * sizeof(wchar_t));
+                wlines_[i].len = wl;
+                sS0_[i]=stlstring(wlines_[i].name, wlines_[i].len);
+            } else {
+                wcs = u_strToWCS(ws, wcap, &wl, lines_[i].name, lines_[i].len-1, &err);
+                memcpy(wlines_[i].name, wcs, wl*sizeof(wchar_t));
+                wlines_[i].len = wl;
+                sS0_[i]=stlstring(wlines_[i].name, wlines_[i].len+1);
+            }
+
+            if (U_FAILURE(err)) {
+                return;
+            }
+        }
+
+    }
+
+    void prepareBulkForStd(void)
+    {
+        UErrorCode err=U_ZERO_ERROR;
+
+        const UChar* uSrc = src_;
+        int32_t uSrcLen = srcLen_;
+        wchar_t* wDest = NULL;
+        int32_t wDestLen = 0;
+        int32_t reqLen= 0 ;
+
+        if(uselen_) {
+            /* pre-flight*/
+            u_strToWCS(wDest,wDestLen,&reqLen,uSrc,uSrcLen,&err);
+
+            if(err == U_BUFFER_OVERFLOW_ERROR){
+                err=U_ZERO_ERROR;
+                wDest =(wchar_t*) malloc(sizeof(wchar_t) * (reqLen));
+                wDestLen = reqLen;
+                u_strToWCS(wDest,wDestLen,&reqLen,uSrc,uSrcLen,&err);
+            }
+
+            if (U_SUCCESS(err)) {
+                wsrc_ = wDest;
+                wsrcLen_ = wDestLen;
+                sbulk_=new stlstring(wsrc_,wsrcLen_);
+            }
+
+        } else {
+            /* pre-flight*/
+            u_strToWCS(wDest,wDestLen,&reqLen,uSrc,uSrcLen-1,&err);
+
+            if(err == U_BUFFER_OVERFLOW_ERROR){
+                err=U_ZERO_ERROR;
+                wDest =(wchar_t*) malloc(sizeof(wchar_t) * (reqLen+1));
+                wDestLen = reqLen+1;
+                u_strToWCS(wDest,wDestLen,&reqLen,uSrc,uSrcLen-1,&err);
+            }
+
+            if (U_SUCCESS(err)) {
+                wsrc_ = wDest;
+                wsrcLen_ = wDestLen;
+                sbulk_=new stlstring(wsrc_);
+            }
+        }
+
+        //free(wDest);
+    }
 
 
 private:
-	ICUStringPerfFn fn1_;
-	StdStringPerfFn fn2_;
-
-	ULine* lines_;
-	WLine* wlines_;
-	int32_t numLines_;
-
-	UBool uselen_;
-	UChar* src_;
-	int32_t srcLen_;
-	wchar_t* wsrc_;
-	int32_t wsrcLen_;
+    ICUStringPerfFn fn1_;
+    StdStringPerfFn fn2_;
+
+    ULine* lines_;
+    WLine* wlines_;
+    int32_t numLines_;
+
+    UBool uselen_;
+    UChar* src_;
+    int32_t srcLen_;
+    wchar_t* wsrc_;
+    int32_t wsrcLen_;
     UBool line_mode_;
-	
-	//added for preparing testing data
-	UnicodeString* uS0_;
-	stlstring* sS0_;
-	UnicodeString* ubulk_;
-	stlstring* sbulk_;
-	FnType fnType_;
-}; 
+
+    //added for preparing testing data
+    UnicodeString* uS0_;
+    stlstring* sS0_;
+    UnicodeString* ubulk_;
+    stlstring* sbulk_;
+    FnType fnType_;
+};
 
 
 class StringPerformanceTest : public UPerfTest
 {
 public:
-	StringPerformanceTest(int32_t argc, const char *argv[], UErrorCode &status);
-	~StringPerformanceTest();
-	virtual UPerfFunction* runIndexedTest(int32_t index, UBool exec,
-		                                  const char *&name, 
-										  char *par = NULL);     
-	UPerfFunction* TestCtor();
-	UPerfFunction* TestCtor1();
-	UPerfFunction* TestCtor2();
-	UPerfFunction* TestCtor3();
-	UPerfFunction* TestAssign();
-	UPerfFunction* TestAssign1();
-	UPerfFunction* TestAssign2();
-	UPerfFunction* TestGetch();
-	UPerfFunction* TestCatenate();
-	UPerfFunction* TestScan();
-	UPerfFunction* TestScan1();
-	UPerfFunction* TestScan2();
-
-	UPerfFunction* TestStdLibCtor();
-	UPerfFunction* TestStdLibCtor1();
-	UPerfFunction* TestStdLibCtor2();
-	UPerfFunction* TestStdLibCtor3();
-	UPerfFunction* TestStdLibAssign();
-	UPerfFunction* TestStdLibAssign1();
-	UPerfFunction* TestStdLibAssign2();
-	UPerfFunction* TestStdLibGetch();
-	UPerfFunction* TestStdLibCatenate();
-	UPerfFunction* TestStdLibScan();
-	UPerfFunction* TestStdLibScan1();
-	UPerfFunction* TestStdLibScan2();
+    StringPerformanceTest(int32_t argc, const char *argv[], UErrorCode &status);
+    ~StringPerformanceTest();
+    virtual UPerfFunction* runIndexedTest(int32_t index, UBool exec,
+                                          const char *&name,
+                                          char *par = NULL);
+    UPerfFunction* TestCtor();
+    UPerfFunction* TestCtor1();
+    UPerfFunction* TestCtor2();
+    UPerfFunction* TestCtor3();
+    UPerfFunction* TestAssign();
+    UPerfFunction* TestAssign1();
+    UPerfFunction* TestAssign2();
+    UPerfFunction* TestGetch();
+    UPerfFunction* TestCatenate();
+    UPerfFunction* TestScan();
+    UPerfFunction* TestScan1();
+    UPerfFunction* TestScan2();
+
+    UPerfFunction* TestStdLibCtor();
+    UPerfFunction* TestStdLibCtor1();
+    UPerfFunction* TestStdLibCtor2();
+    UPerfFunction* TestStdLibCtor3();
+    UPerfFunction* TestStdLibAssign();
+    UPerfFunction* TestStdLibAssign1();
+    UPerfFunction* TestStdLibAssign2();
+    UPerfFunction* TestStdLibGetch();
+    UPerfFunction* TestStdLibCatenate();
+    UPerfFunction* TestStdLibScan();
+    UPerfFunction* TestStdLibScan1();
+    UPerfFunction* TestStdLibScan2();
 
 private:
-	long COUNT_;
-	ULine* filelines_;
-	UChar* StrBuffer;
-	int32_t StrBufferLen;
+    long COUNT_;
+    ULine* filelines_;
+    UChar* StrBuffer;
+    int32_t StrBufferLen;
 
 };
 
 
-inline void ctor(const UChar* src,int32_t srcLen, UnicodeString s0) 
+inline void ctor(const UChar* src,int32_t srcLen, UnicodeString s0)
 {
-	UnicodeString a;		
+    UnicodeString a;
 }
 
-inline void ctor1(const UChar* src,int32_t srcLen, UnicodeString s0) 
+inline void ctor1(const UChar* src,int32_t srcLen, UnicodeString s0)
 {
-	UnicodeString b(uTESTCHAR1);
+    UnicodeString b(uTESTCHAR1);
 }
 
-inline void ctor2(const UChar* src,int32_t srcLen, UnicodeString s0) 
+inline void ctor2(const UChar* src,int32_t srcLen, UnicodeString s0)
 {
-	UnicodeString c(uEMPTY);
+    UnicodeString c(uEMPTY);
 }
 
-inline void ctor3(const UChar* src,int32_t srcLen, UnicodeString s0) 
+inline void ctor3(const UChar* src,int32_t srcLen, UnicodeString s0)
 {
-	UnicodeString d(src,srcLen);
+    UnicodeString d(src,srcLen);
 }
 
 inline UnicodeString icu_assign_helper(const UChar* src,int32_t srcLen)
 {
-	if (srcLen==-1) { return src;} 
-	else { return UnicodeString(src, srcLen);}
+    if (srcLen==-1) { return src;}
+    else { return UnicodeString(src, srcLen);}
 }
 
-inline void assign(const UChar* src,int32_t srcLen, UnicodeString s0) 
+inline void assign(const UChar* src,int32_t srcLen, UnicodeString s0)
 {
-	unistr = icu_assign_helper(src,srcLen);
+    unistr = icu_assign_helper(src,srcLen);
 }
 
-inline void assign1(const UChar* src,int32_t srcLen, UnicodeString s0) 
+inline void assign1(const UChar* src,int32_t srcLen, UnicodeString s0)
 {
-	unistr.setTo(src, srcLen);
+    unistr.setTo(src, srcLen);
 }
 
-inline void assign2(const UChar* src,int32_t srcLen, UnicodeString s0) 
+inline void assign2(const UChar* src,int32_t srcLen, UnicodeString s0)
 {
-	unistr = s0;
+    unistr = s0;
 }
 
 inline void getch(const UChar* src,int32_t srcLen, UnicodeString s0)
 {
-	s0.charAt(0);
+    s0.charAt(0);
 }
 
 
 inline void catenate(const UChar* src,int32_t srcLen, UnicodeString s0)
 {
-	UTimer mystart, mystop;
-	utimer_getTime(&mystart); 
-	
-	*catICU += s0;
-	
-	utimer_getTime(&mystop);
+    UTimer mystart, mystop;
+    utimer_getTime(&mystart);
+
+    *catICU += s0;
+
+    utimer_getTime(&mystop);
     double mytime = utimer_getDeltaSeconds(&mystart,&mystop);
-	printf("\nmytime=%f \n", mytime);
+    printf("\nmytime=%f \n", mytime);
 
-	*catICU += uCatenate_STR;
+    *catICU += uCatenate_STR;
 }
 
 volatile int scan_idx;
@@ -447,103 +450,103 @@ U_STRING_DECL(SCAN1, "123", 3);
 
 inline void scan(const UChar* src,int32_t srcLen, UnicodeString s0)
 {
-	UChar c='.';
-	scan_idx = uScan_STRING.indexOf(c);
+    UChar c='.';
+    scan_idx = uScan_STRING.indexOf(c);
 }
 
 inline void scan1(const UChar* src,int32_t srcLen, UnicodeString s0)
 {
-	scan_idx = uScan_STRING.indexOf(SCAN1,3);
+    scan_idx = uScan_STRING.indexOf(SCAN1,3);
 }
 
 inline void scan2(const UChar* src,int32_t srcLen, UnicodeString s0)
 {
-	UChar c1='s';
-	UChar c2='m';
-	scan_idx = uScan_STRING.indexOf(c1);
-	scan_idx = uScan_STRING.indexOf(c2);
+    UChar c1='s';
+    UChar c2='m';
+    scan_idx = uScan_STRING.indexOf(c1);
+    scan_idx = uScan_STRING.indexOf(c2);
 }
 
 
 inline void StdLibCtor(const wchar_t* src,int32_t srcLen, stlstring s0)
 {
-	stlstring a;
+    stlstring a;
 }
 
 inline void StdLibCtor1(const wchar_t* src,int32_t srcLen, stlstring s0)
 {
-
-	stlstring b(simulate);
+    stlstring b(simulate);
 }
 
 inline void StdLibCtor2(const wchar_t* src,int32_t srcLen, stlstring s0)
 {
-	stlstring c(sEMPTY);
+    stlstring c(sEMPTY);
 }
 
 inline void StdLibCtor3(const wchar_t* src,int32_t srcLen, stlstring s0)
 {
-	if (srcLen==-1) {	
-		stlstring d(src); 
-	}else {
-		stlstring d(src, srcLen); 
-	}
+    if (srcLen==-1) {
+        stlstring d(src);
+    }else {
+        stlstring d(src, srcLen);
+    }
 }
 
 inline stlstring stl_assign_helper(const wchar_t* src,int32_t srcLen)
 {
-	if (srcLen==-1) { return src;}
-	else { return stlstring(src, srcLen);}
+    if (srcLen==-1) { return src;}
+    else { return stlstring(src, srcLen);}
 }
 
-inline void StdLibAssign(const wchar_t* src,int32_t srcLen, stlstring s0) 
+inline void StdLibAssign(const wchar_t* src,int32_t srcLen, stlstring s0)
 {
-	stlstr = stl_assign_helper(src,srcLen);
+    stlstr = stl_assign_helper(src,srcLen);
 }
 
-inline void StdLibAssign1(const wchar_t* src,int32_t srcLen, stlstring s0) 
+inline void StdLibAssign1(const wchar_t* src,int32_t srcLen, stlstring s0)
 {
-	if (srcLen==-1) { stlstr=src;}
-	else { stlstr.assign(src, srcLen);}
+    if (srcLen==-1) { stlstr=src;}
+    else { stlstr.assign(src, srcLen);}
 }
 
-inline void StdLibAssign2(const wchar_t* src,int32_t srcLen, stlstring s0) 
+inline void StdLibAssign2(const wchar_t* src,int32_t srcLen, stlstring s0)
 {
-	stlstr=s0;
+    stlstr=s0;
 }
 
 inline void StdLibGetch(const wchar_t* src,int32_t srcLen, stlstring s0)
 {
-	s0.at(0);
+    s0.at(0);
 }
 
 inline void StdLibCatenate(const wchar_t* src,int32_t srcLen, stlstring s0)
 {
-	UTimer mystart, mystop;
-	utimer_getTime(&mystart); 
+    UTimer mystart, mystop;
+    utimer_getTime(&mystart);
 
     *catStd += s0;
-	*catStd += sCatenate_STR;
+    *catStd += sCatenate_STR;
 
-	utimer_getTime(&mystop);
+    utimer_getTime(&mystop);
     double mytime = utimer_getDeltaSeconds(&mystart,&mystop);
-	printf("\nmytime=%f \n", mytime);
-	
+    printf("\nmytime=%f \n", mytime);
+
 }
 
 inline void StdLibScan(const wchar_t* src,int32_t srcLen, stlstring s0)
 {
-	scan_idx = (int) sScan_STRING.find('.');	
+    scan_idx = (int) sScan_STRING.find('.');	
 }
 
 inline void StdLibScan1(const wchar_t* src,int32_t srcLen, stlstring s0)
 {
-	scan_idx = (int) sScan_STRING.find(L"123");
+    scan_idx = (int) sScan_STRING.find(L"123");
 }
 
 inline void StdLibScan2(const wchar_t* src,int32_t srcLen, stlstring s0)
 {	
-	scan_idx = (int) sScan_STRING.find_first_of(L"sm");
+    scan_idx = (int) sScan_STRING.find_first_of(L"sm");
 }
 
-#endif // STRINGPERF_H
\ No newline at end of file
+#endif // STRINGPERF_H
+