diff options
Diffstat (limited to 'libvideoeditor/osal/src/M4OSA_String_priv.c')
| -rwxr-xr-x | libvideoeditor/osal/src/M4OSA_String_priv.c | 1136 |
1 files changed, 1136 insertions, 0 deletions
diff --git a/libvideoeditor/osal/src/M4OSA_String_priv.c b/libvideoeditor/osal/src/M4OSA_String_priv.c new file mode 100755 index 0000000..07cef33 --- /dev/null +++ b/libvideoeditor/osal/src/M4OSA_String_priv.c @@ -0,0 +1,1136 @@ +/* + * Copyright (C) 2004-2011 NXP Software + * Copyright (C) 2011 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +/** + ************************************************************************ + * @file M4OSA_String_priv.c + ************************************************************************ +*/ + +#include "M4OSA_Debug.h" +#include "M4OSA_Types.h" +#include "M4OSA_Memory.h" +#include "M4OSA_Error.h" +#include "M4OSA_String_priv.h" +#include "M4OSA_String.h" + +/** + ************************************************************************ + * @brief This function replaces a string buffer by a new "C-String" + * and manage memory if needed + * @note + * @param pstr_src + * @param pac_in + * @return M4OSA_ERROR + ************************************************************************ + */ +M4OSA_ERR M4OSA_strPrivRealloc(M4OSA_strStruct* str, + M4OSA_UInt32 ui32_length) +{ + M4OSA_UInt32 ui32_size; + M4OSA_Char* buffer; + + M4OSA_TRACE2_2("M4OSA_strPrivRealloc\t\tM4OSA_strStruct* 0x%x\t" + "M4OSA_UInt32* %d", str, ui32_length); + + ui32_size = str->ui32_size; + + /* Realloc if size is not sufficient to contain it entirely */ + if(ui32_length >= ui32_size) + { + if(ui32_size == 0) + { + ui32_size = 16; + } + + while(ui32_length >= ui32_size) + { + ui32_size <<= 1; + } + + buffer = str->pui8_buffer; + + if(buffer != M4OSA_NULL) + { + M4OSA_free((M4OSA_MemAddr32)buffer); + } + + /* Allocate the actual M4OSA_String content */ + buffer = (M4OSA_Char*)M4OSA_malloc(ui32_size * sizeof(M4OSA_Char), + M4OSA_STRING, (M4OSA_Char*)"M4OSA_strPrivRealloc"); + + /* Check memory allocation error */ + if(buffer == M4OSA_NULL) + { + M4OSA_DEBUG(M4ERR_ALLOC, "M4OSA_strPrivRealloc"); + + str->pui8_buffer = M4OSA_NULL; + str->ui32_size = 0; + str->ui32_length = 0; + + return M4ERR_ALLOC; + } + + str->pui8_buffer = buffer; + str->ui32_size = ui32_size; + } + + return M4NO_ERROR; +} + +/** + ************************************************************************ + * @brief This function replaces a string buffer by a new "C-String" + * and manage memory if needed + * @note + * @param pstr_src + * @param pac_in + * @return M4OSA_ERROR + ************************************************************************ + */ +M4OSA_ERR M4OSA_strPrivReallocCopy(M4OSA_strStruct* str, + M4OSA_UInt32 ui32_length) +{ + M4OSA_UInt32 ui32_size; + M4OSA_Char* buffer; + M4OSA_Char* pui8_buffer; + + M4OSA_TRACE2_2("M4OSA_strPrivReallocCopy\t\tM4OSA_strStruct* 0x%x\t" + "M4OSA_UInt32* %d", str, ui32_length); + + + ui32_size = str->ui32_size; + + /* Realloc if size is not sufficient to contain it entirely */ + if(ui32_length >= ui32_size) + { + if(ui32_size == 0) + { + ui32_size = 16; + } + + while(ui32_length >= ui32_size) + { + ui32_size <<= 1; + } + + /* Allocate the actual M4OSA_String content */ + buffer = (M4OSA_Char*)M4OSA_malloc(ui32_size * sizeof(M4OSA_Char), + M4OSA_STRING, (M4OSA_Char*)"M4OSA_strPrivReallocCopy"); + + /* Check memory allocation error */ + if(buffer == M4OSA_NULL) + { + M4OSA_DEBUG(M4ERR_ALLOC, "M4OSA_strPrivReallocCopy"); + + str->pui8_buffer = M4OSA_NULL; + str->ui32_size = 0; + str->ui32_length = 0; + + return M4ERR_ALLOC; + } + + pui8_buffer = str->pui8_buffer; + + if(pui8_buffer != M4OSA_NULL) + { + M4OSA_memcpy(buffer, pui8_buffer, str->ui32_length + 1); + + M4OSA_free((M4OSA_MemAddr32)pui8_buffer); + } + + str->pui8_buffer = buffer; + str->ui32_size = ui32_size; + } + + return M4NO_ERROR; +} + + +M4OSA_ERR M4OSA_strPrivDuplicate(M4OSA_strStruct** ostr, + M4OSA_strStruct* istr) +{ + M4OSA_strStruct* str; + M4OSA_ERR err_code; + + M4OSA_TRACE2_2("M4OSA_strPrivDuplicate\t\tM4OSA_strStruct** 0x%x\t" + "M4OSA_strStruct** 0x%x", ostr, istr); + + /* Allocate the output M4OSA_String */ + str = (M4OSA_strStruct*)M4OSA_malloc(sizeof(M4OSA_strStruct), M4OSA_STRING, + (M4OSA_Char*)"M4OSA_strPrivDuplicate: output string"); + + /* Check memory allocation error */ + if(str == M4OSA_NULL) + { + *ostr = M4OSA_NULL ; + + M4OSA_DEBUG(M4ERR_ALLOC, "M4OSA_strPrivDuplicate"); + + return M4ERR_ALLOC; + } + + str->coreID = M4OSA_STRING; + str->pui8_buffer = M4OSA_NULL; + str->ui32_length = 0; + str->ui32_size = 0; + + err_code = M4OSA_strPrivSet(str, istr->pui8_buffer, istr->ui32_length); + + if(err_code != M4NO_ERROR) + { + return err_code; + } + + *ostr = str; + + return M4NO_ERROR; +} + +/** + ************************************************************************ + * @brief This function replaces a string buffer by a new "C-String" + * and manage memory if needed + * @note + * @param pstr_src + * @param pac_in + * @return M4OSA_ERROR + ************************************************************************ +*/ +M4OSA_ERR M4OSA_strPrivSet(M4OSA_strStruct* str, + M4OSA_Char* pchar, + M4OSA_UInt32 ui32_length) +{ + M4OSA_UInt32 length; + M4OSA_Char* buffer; + + M4OSA_TRACE2_3("M4OSA_strPrivSet\t\tM4OSA_strStruct* 0x%x\tM4OSA_Char* " + "0x%x\tM4OSA_UInt32 %d", str, pchar, ui32_length); + + if(ui32_length != 0) + { + length = M4OSA_chrLength(pchar); + + if(length < ui32_length) + { + ui32_length = length; + } + + if(M4OSA_strPrivRealloc(str, ui32_length) != M4NO_ERROR) + { + M4OSA_DEBUG(M4ERR_ALLOC, "M4OSA_strPrivSet"); + + return M4ERR_ALLOC; + } + + buffer = str->pui8_buffer; + + /* Fill the actual M4OSA_String content */ + M4OSA_memcpy(buffer, pchar, ui32_length); + + buffer[ui32_length] = '\0'; + } + else if(str->pui8_buffer != M4OSA_NULL) + { + str->pui8_buffer[0] = '\0'; + } + + str->ui32_length = ui32_length; + + return M4NO_ERROR; +} + +/** + ************************************************************************ + * @brief This function replaces a string buffer by a new "C-String" + * and manage memory if needed + * @note + * @param pstr_src + * @param pac_in + * @return M4OSA_ERROR + ************************************************************************ +*/ +M4OSA_Int32 M4OSA_strPrivFindLastSubStr(M4OSA_strStruct* str1, + M4OSA_strStruct* str2, + M4OSA_UInt32 ui32_pos) +{ + M4OSA_Char *pchar; + M4OSA_Char *buffer1; + M4OSA_Char *buffer2; + M4OSA_Int32 i32_result; + M4OSA_UInt32 length1, length2; + M4OSA_Int32 dist; + + M4OSA_TRACE2_3("M4OSA_strPrivFindLastSubStr\t\tM4OSA_strStruct* 0x%x\t" + "M4OSA_strStruct* 0x%x\tM4OSA_UInt32 %d", + str1, str2, ui32_pos); + + length1 = str1->ui32_length; + length2 = str2->ui32_length; + + if((length1 == 0) || (length2 == 0)) + { + return -1; + } + + buffer1 = str1->pui8_buffer; + buffer2 = str2->pui8_buffer; + + dist = length1 - length2; + + if(dist < 0) + { + return -1; + } + + if((M4OSA_Int32)ui32_pos > dist) + { + ui32_pos = dist; + } + + for(pchar = buffer1 + ui32_pos; pchar != buffer1; pchar--) + { + M4OSA_chrNCompare(pchar, buffer2, length2, &i32_result); + + if(i32_result == 0) + { + return pchar - buffer1; + } + } + + return -1; +} + +/** + ************************************************************************ + * @brief This function replaces a string buffer by a new "C-String" + * and manage memory if needed + * @note + * @param pstr_src + * @param pac_in + * @return M4OSA_ERROR + ************************************************************************ + */ +M4OSA_ERR M4OSA_strPrivSetAndRepleceStr(M4OSA_strStruct* istr, + M4OSA_UInt32 ui32_pos, + M4OSA_UInt32 olength, + M4OSA_Char* nbuff, + M4OSA_UInt32 nlength) +{ + M4OSA_Char* buffer; + M4OSA_Char* ibuffer; + M4OSA_UInt32 ui32_length, ui32_size, ui32_lend, ui32_poso, ui32_posn; + + M4OSA_TRACE2_5("M4OSA_strPrivSetAndRepleceStr\t\tM4OSA_strStruct* 0x%x\t" + "M4OSA_UInt32 %d\tM4OSA_UInt32 %d\tM4OSA_Char* 0x%x\t" + "M4OSA_UInt32 %d", istr, ui32_pos, olength, nbuff, nlength); + + ui32_length = istr->ui32_length - olength + nlength; + + ibuffer = istr->pui8_buffer; + + /* string to replace has the same this that new string */ + if(nlength == olength) + { + if(nlength == 0) + { + return M4NO_ERROR; + } + + M4OSA_memcpy(ibuffer + ui32_pos, nbuff, nlength); + } + else + { + ui32_lend = istr->ui32_length - ui32_pos - olength; + ui32_poso = ui32_pos + olength; + ui32_posn = ui32_pos + nlength; + + /* string to replace is bigger that new string */ + if(nlength < olength) + { + if(nlength > 0) + { + M4OSA_memcpy(ibuffer + ui32_pos, nbuff, nlength); + } + + if((olength - nlength) >= ui32_lend) + { + M4OSA_memcpy(ibuffer + ui32_posn, ibuffer + ui32_poso, ui32_lend); + } + else + { + buffer = (M4OSA_Char*)M4OSA_malloc(ui32_lend * sizeof(M4OSA_Char), + M4OSA_STRING, (M4OSA_Char*)"M4OSA_strPrivSetAndRepleceStr"); + + M4OSA_CHECK_MALLOC(buffer, "M4OSA_strPrivSetAndRepleceStr"); + M4OSA_memcpy(buffer, ibuffer + ui32_poso, ui32_lend); + M4OSA_memcpy(ibuffer + ui32_posn, buffer, ui32_lend); + M4OSA_free((M4OSA_MemAddr32)buffer); + } + } + /* string to replace is smaller that new string */ + else + { + ui32_size = istr->ui32_size; + + /* check if there is enough memory allocated in istr */ + if(ui32_length >= ui32_size) + { + if(ui32_size == 0) + { + ui32_size = 16; + } + + while(ui32_length >= ui32_size) + { + ui32_size <<= 1; + } + + buffer = (M4OSA_Char*)M4OSA_malloc(ui32_size * sizeof(M4OSA_Char), + M4OSA_STRING, (M4OSA_Char*)"M4OSA_strPrivSetAndRepleceStr"); + + M4OSA_CHECK_MALLOC(buffer, "M4OSA_strPrivSetAndRepleceStr"); + + M4OSA_memcpy(buffer, ibuffer, ui32_pos); + + M4OSA_memcpy(buffer + ui32_pos, nbuff, nlength); + + M4OSA_memcpy(buffer + ui32_posn, ibuffer + ui32_poso, ui32_lend); + + M4OSA_free((M4OSA_MemAddr32)ibuffer); + + istr->pui8_buffer = buffer; + + istr->ui32_size = ui32_size; + } + else + { + buffer = (M4OSA_Char*)M4OSA_malloc(ui32_lend * sizeof(M4OSA_Char), + M4OSA_STRING, (M4OSA_Char*)"M4OSA_strPrivSetAndRepleceStr"); + + M4OSA_CHECK_MALLOC(buffer, "M4OSA_strPrivSetAndRepleceStr"); + + M4OSA_memcpy(buffer, ibuffer + ui32_poso, ui32_lend); + + M4OSA_memcpy(ibuffer + ui32_pos, nbuff, nlength); + + M4OSA_memcpy(ibuffer + ui32_posn, buffer, ui32_lend); + + M4OSA_free((M4OSA_MemAddr32)buffer); + } + } + } + + + istr->pui8_buffer[ui32_length] = '\0'; + + istr->ui32_length = ui32_length; + + return M4NO_ERROR; +} + +/** + ************************************************************************ + * @brief This function replaces a string buffer by a new "C-String" + * and manage memory if needed + * @note + * @param pstr_src + * @param pac_in + * @return M4OSA_ERROR + ************************************************************************ + */ +M4OSA_ERR M4OSA_strPrivReplaceSameSizeStr(M4OSA_strStruct* istr, + M4OSA_strStruct* ostr, + M4OSA_strStruct* nstr, + M4OSA_strMode mode) +{ + M4OSA_Char* ibuffer; + M4OSA_Char* obuffer; + M4OSA_Char* nbuffer; + M4OSA_Char* ptr; + M4OSA_UInt32 ilength, nlength; + M4OSA_Int32 i32_pos; + M4OSA_ERR err_code; + + M4OSA_TRACE2_4("M4OSA_strPrivReplaceSameSizeStr\t\tM4OSA_strStruct* 0x%x\t" + "M4OSA_strStruct* 0x%x\tM4OSA_strStruct* 0x%x\t" + "M4OSA_strMode %d", istr, ostr, nstr, mode); + + ibuffer = istr->pui8_buffer; + obuffer = ostr->pui8_buffer; + nbuffer = nstr->pui8_buffer; + + ilength = istr->ui32_length; + nlength = nstr->ui32_length; + + if(mode != M4OSA_kstrEnd) + { + err_code = M4OSA_chrFindPattern(ibuffer, obuffer, &ptr); + + M4OSA_DEBUG_IF2(M4OSA_ERR_IS_ERROR(err_code), err_code, + "M4OSA_strPrivReplaceSameSizeStr"); + + if(err_code == M4WAR_CHR_NOT_FOUND) + { + return M4WAR_STR_NOT_FOUND; + } + + if(mode == M4OSA_kstrAll) + { + do + { + M4OSA_memcpy(ptr, nbuffer, nlength); + + err_code = M4OSA_chrFindPattern(ptr+nlength, obuffer, &ptr); + + M4OSA_DEBUG_IF2(M4OSA_ERR_IS_ERROR(err_code), err_code, + "M4OSA_strPrivReplaceSameSizeStr"); + + } while(err_code != M4WAR_CHR_NOT_FOUND); + } + else + { + M4OSA_memcpy(ptr, nbuffer, nlength); + } + } + else + { + i32_pos = M4OSA_strPrivFindLastSubStr(istr, ostr, ilength-1); + + if(i32_pos < 0) + { + return M4WAR_STR_NOT_FOUND; + } + + M4OSA_memcpy(ibuffer + i32_pos, nbuffer, nlength); + } + + + return M4NO_ERROR; +} + +/** + ************************************************************************ + * @brief This function replaces a string buffer by a new "C-String" + * and manage memory if needed + * @note + * @param pstr_src + * @param pac_in + * @return M4OSA_ERROR + ************************************************************************ + */ +M4OSA_ERR M4OSA_strPrivReplaceSmallerStr(M4OSA_strStruct* istr, + M4OSA_strStruct* ostr, + M4OSA_strStruct* nstr, + M4OSA_strMode mode) +{ + M4OSA_Char* ibuffer; + M4OSA_Char* obuffer; + M4OSA_Char* nbuffer; + M4OSA_Char* buffer; + M4OSA_Char* ptr_src; + M4OSA_Char* ptr_dest; + M4OSA_UInt32 ilength, nlength, olength, size, length; + M4OSA_Int32 i32_pos; + M4OSA_ERR err_code; + + M4OSA_TRACE2_4("M4OSA_strPrivReplaceSmallerStr\t\tM4OSA_strStruct* 0x%x\t" + "M4OSA_strStruct* 0x%x\tM4OSA_strStruct* 0x%x\t" + "M4OSA_strMode %d", istr, ostr, nstr, mode); + + ibuffer = istr->pui8_buffer; + obuffer = ostr->pui8_buffer; + nbuffer = nstr->pui8_buffer; + + ilength = istr->ui32_length; + olength = ostr->ui32_length; + nlength = nstr->ui32_length; + + length = ilength; + + if(mode == M4OSA_kstrAll) + { + err_code = M4OSA_chrFindPattern(ibuffer, obuffer, &ptr_src); + + M4OSA_DEBUG_IF2(M4OSA_ERR_IS_ERROR(err_code), err_code, + "M4OSA_strPrivReplaceSameSizeStr"); + + if(err_code == M4WAR_CHR_NOT_FOUND) + { + return M4WAR_STR_NOT_FOUND; + } + + /* Allocate the actual M4OSA_String content */ + buffer = (M4OSA_Char*)M4OSA_malloc(istr->ui32_size * sizeof(M4OSA_Char), + M4OSA_STRING, (M4OSA_Char*)"M4OSA_strPrivReplaceSmallerStr"); + + M4OSA_CHECK_MALLOC(buffer, "M4OSA_strPrivReplaceSmallerStr"); + + ptr_dest = buffer; + + do + { + size = (M4OSA_UInt32)ptr_src - (M4OSA_UInt32)ibuffer; + + length += (nlength - olength); + + M4OSA_memcpy(ptr_dest, ibuffer, size); + + ptr_dest += size; + + M4OSA_memcpy(ptr_dest, nbuffer, nlength); + + ptr_dest += nlength; + + ibuffer += (size + olength); + + err_code = M4OSA_chrFindPattern(ibuffer, obuffer, &ptr_src); + + M4OSA_DEBUG_IF2(M4OSA_ERR_IS_ERROR(err_code), err_code, + "M4OSA_strPrivReplaceSameSizeStr"); + + } while(err_code != M4WAR_CHR_NOT_FOUND); + + size = ilength - (M4OSA_UInt32)(ibuffer - istr->pui8_buffer); + + M4OSA_memcpy(ptr_dest, ibuffer, size); + + M4OSA_free((M4OSA_MemAddr32)istr->pui8_buffer); + + istr->ui32_length = length ; + + buffer[length] = '\0'; + + istr->pui8_buffer = buffer; + } + else + { + if(mode == M4OSA_kstrBegin) + { + err_code = M4OSA_chrFindPattern(ibuffer, obuffer, &ptr_src); + + M4OSA_DEBUG_IF2(M4OSA_ERR_IS_ERROR(err_code), err_code, + "M4OSA_strPrivReplaceSameSizeStr"); + + if(err_code == M4WAR_CHR_NOT_FOUND) + { + return M4WAR_STR_NOT_FOUND; + } + + i32_pos = (M4OSA_UInt32)ptr_src - (M4OSA_UInt32)ibuffer; + } + else + { + i32_pos = M4OSA_strPrivFindLastSubStr(istr, ostr, ilength-1); + + if(i32_pos == -1) + { + return M4WAR_STR_NOT_FOUND; + } + } + + err_code = M4OSA_strPrivSetAndRepleceStr(istr, i32_pos, olength, + nbuffer, nlength); + + if(M4OSA_ERR_IS_ERROR(err_code)) + { + M4OSA_DEBUG(err_code, "M4OSA_strPrivReplaceSmallerStr"); + + return err_code; + } + } + + return M4NO_ERROR; +} + +/** + ************************************************************************ + * @brief This function replaces a string buffer by a new "C-String" + * and manage memory if needed + * @note + * @param pstr_src + * @param pac_in + * @return M4OSA_ERROR + ************************************************************************ + */ +M4OSA_ERR M4OSA_strPrivReplaceBiggerStr(M4OSA_strStruct* istr, + M4OSA_strStruct* ostr, + M4OSA_strStruct* nstr, + M4OSA_strMode mode) +{ + M4OSA_Char* ibuffer; + M4OSA_Char* obuffer; + M4OSA_Char* nbuffer; + M4OSA_Char* buffer; + M4OSA_Char* ptr; + M4OSA_UInt32 ilength, nlength, olength, length; + M4OSA_Int32 i32_pos; + M4OSA_ERR err_code; + + M4OSA_TRACE2_4("M4OSA_strPrivReplaceBiggerStr\t\tM4OSA_strStruct* 0x%x\t" + "M4OSA_strStruct* 0x%x\tM4OSA_strStruct* 0x%x\t" + "M4OSA_strMode %d", istr, ostr, nstr, mode); + + ibuffer = istr->pui8_buffer; + obuffer = ostr->pui8_buffer; + nbuffer = nstr->pui8_buffer; + + ilength = istr->ui32_length; + olength = ostr->ui32_length; + nlength = nstr->ui32_length; + + + if(mode == M4OSA_kstrAll) + { + M4OSA_UInt32 n=0, i; + M4OSA_Int32* patterns; + M4OSA_UInt32 pos=0, size; + M4OSA_UInt32 max_pattern = ilength / olength; + M4OSA_UInt32 ui32_size = istr->ui32_size; + M4OSA_Char* src; + M4OSA_Char* dest; + + /* Allocate the actual M4OSA_String content */ + patterns = (M4OSA_Int32*)M4OSA_malloc(max_pattern * sizeof(M4OSA_UInt32), + M4OSA_STRING, (M4OSA_Char*)"M4OSA_strPrivReplaceBiggerStr"); + + M4OSA_CHECK_MALLOC(patterns, (M4OSA_Char*)"M4OSA_strPrivReplaceBiggerStr"); + + + err_code = M4OSA_chrFindPattern(ibuffer, obuffer, &ptr); + + M4OSA_DEBUG_IF2(M4OSA_ERR_IS_ERROR(err_code), err_code, + "M4OSA_strPrivReplaceBiggerStr"); + + if(err_code == M4WAR_CHR_NOT_FOUND) + { + return M4WAR_STR_NOT_FOUND; + } + + do + { + patterns[n] = (M4OSA_UInt32)ptr - (M4OSA_UInt32)ibuffer; + + n++; + + err_code = M4OSA_chrFindPattern(ptr + olength, obuffer, &ptr); + + M4OSA_DEBUG_IF2(M4OSA_ERR_IS_ERROR(err_code), err_code, + "M4OSA_strPrivReplaceBiggerStr"); + + } while(err_code != M4WAR_CHR_NOT_FOUND); + + length = ilength - (n * olength) + (n * nlength); + + + if(length >= ui32_size) + { + do + { + ui32_size <<= 1; + + } while(length >= ui32_size); + } + + /* Allocate the actual M4OSA_String content */ + buffer = (M4OSA_Char*)M4OSA_malloc(ui32_size * sizeof(M4OSA_Char), + M4OSA_STRING, (M4OSA_Char*)"M4OSA_strPrivReplaceBiggerStr"); + + M4OSA_CHECK_MALLOC(buffer, "M4OSA_strPrivReplaceBiggerStr"); + + src = ibuffer; + dest = buffer; + + for(i=0; i<n; i++) + { + size = patterns[i] - pos; + + M4OSA_memcpy(dest, src, size); + + pos = patterns[i] + olength; + + src = ibuffer + pos; + + dest += size; + + M4OSA_memcpy(dest, nbuffer, nlength); + + dest += nlength; + } + + size = ilength - (M4OSA_UInt32)(src - ibuffer); + + M4OSA_memcpy(dest, src, size); + + M4OSA_free((M4OSA_MemAddr32)patterns); + + M4OSA_free((M4OSA_MemAddr32)ibuffer); + + istr->ui32_length = length; + + istr->pui8_buffer = buffer; + + istr->pui8_buffer[length] = '\0'; + } + else + { + if(mode == M4OSA_kstrBegin) + { + err_code = M4OSA_chrFindPattern(ibuffer, obuffer, &ptr); + + M4OSA_DEBUG_IF2(M4OSA_ERR_IS_ERROR(err_code), err_code, + "M4OSA_strPrivReplaceSameSizeStr"); + + if(err_code == M4WAR_CHR_NOT_FOUND) + { + return M4WAR_STR_NOT_FOUND; + } + + i32_pos = (M4OSA_UInt32)ptr - (M4OSA_UInt32)ibuffer; + } + else + { + i32_pos = M4OSA_strPrivFindLastSubStr(istr, ostr, ilength-1); + + if(i32_pos == -1) + { + return M4WAR_STR_NOT_FOUND; + } + } + + err_code = M4OSA_strPrivSetAndRepleceStr(istr, i32_pos, olength, + nbuffer, nlength); + + if(M4OSA_ERR_IS_ERROR(err_code)) + { + M4OSA_DEBUG(err_code, "M4OSA_strPrivReplaceSmallerStr"); + + return err_code; + } + } + + return M4NO_ERROR; +} + + +M4OSA_ERR M4OSA_strPrivSPrintf(M4OSA_strStruct* str, + M4OSA_Char *format, + va_list marker) +{ + M4OSA_Char *temp; + M4OSA_Char *percentPointer; + M4OSA_Char *newFormat; + M4OSA_Char* strOut = str->pui8_buffer + str->ui32_length; + M4OSA_UInt32 strOutMaxLen = str->ui32_size-1; + M4OSA_Int32 newFormatLength = 0; + M4OSA_UInt32 count_ll = 0; + M4OSA_UInt32 count_tm = 0; + M4OSA_UInt32 count_aa = 0; + M4OSA_UInt32 count; + M4OSA_UInt32 nbChar; + M4OSA_Int32 iResult; + + M4OSA_Int32 err; + M4OSA_Char flagChar[] = "'-+ #0"; + M4OSA_Char widthOrPrecisionChar[] = "*0123456789"; + M4OSA_Char otherPrefixChar[] = "hlL"; + M4OSA_Char conversionChar[] = "diouxXnfeEgGcCsSp%"; + + M4OSA_TRACE2_2("M4OSA_strSPrintf\t\tM4OSA_String 0x%x\tM4OSA_Char* 0x%x", + str, format); + + + /* count the number of %[flags][width][.precision]ll[conversion] */ + temp = format; + + while(*temp) + { + /* get the next percent character */ + err = M4OSA_chrFindChar (temp, '%', &percentPointer); + + if((!percentPointer) || (M4WAR_CHR_NOT_FOUND == err)) + { + break; /* "This is the End", (c) J. Morrisson */ + } + + temp = percentPointer+1; /* span it */ + if(!*temp) /* "This is the End", (c) J. Morrisson */ + { + break; + } + + /* span the optional flags */ + M4OSA_chrSpan(format, conversionChar, &nbChar); + temp += nbChar; + + if(!*temp) /* "This is the End", (c) J. Morrisson */ + { + break; + } + + /* span the optional width */ + M4OSA_chrSpan(temp, widthOrPrecisionChar, &nbChar); + temp += nbChar; + if(!*temp) /* "This is the End", (c) J. Morrisson */ + { + break; + } + + if(*temp=='.') + { + /* span the optional precision */ + M4OSA_chrSpan(++temp, widthOrPrecisionChar, &nbChar); + temp += nbChar; + } + if(!*temp) /* "This is the End", (c) J. Morrisson */ + { + break; + } + + if(M4OSA_chrLength(temp)>=2) + { + + M4OSA_chrNCompare(temp, (M4OSA_Char*)"ll",2, &iResult); + if (iResult != 0) + { + count_ll++; /* I got ONE */ + temp +=2; /* span the "ll" prefix */ + } + else + { + M4OSA_chrNCompare(temp, (M4OSA_Char*)"tm",2, &iResult); + if (iResult != 0) /* à voir si ce n'est pas == 0 */ + { + count_tm++; + temp +=2; + } + else + { + M4OSA_chrNCompare(temp, (M4OSA_Char*)"aa",2, &iResult); + if (iResult != 0) /* à voir si ce n'est pas == 0 */ + { + count_aa++; + temp +=2; + } + } + } + } + + /* span the other optional prefix */ + M4OSA_chrSpan(temp, otherPrefixChar, &nbChar); + temp += nbChar; + if(!*temp) /* "This is the End", (c) J. Morrisson */ + { + break; + } + + M4OSA_chrSpan(temp, conversionChar, &nbChar); + temp += nbChar; + if(!*temp) /* "This is the End", (c) J. Morrisson */ + { + break; + } + + } + + count = count_ll + count_tm + count_aa; + + if(!count) + { + err = M4OSA_chrSPrintf(strOut,strOutMaxLen,format,marker); + + if(M4ERR_CHR_STR_OVERFLOW == err) + { + return M4ERR_STR_OVERFLOW; + } + + return M4NO_ERROR; + } + + + newFormatLength = M4OSA_chrLength(format) + 1; + +#ifdef M4OSA_64BITS_SUPPORTED +#ifdef M4OSA_FILE_POS_64_BITS_SUPPORTED + newFormatLength += (count_ll+count_tm+count_aa); +#else + newFormatLength += (count_ll+count_tm-count_aa); +#endif +#elif defined M4OSA_64BITS_NOT_SUPPORTED + newFormatLength -= (count_ll+count_tm+count_aa); +#else + return M4ERR_NOT_IMPLEMENTED; +#endif + + newFormat =(M4OSA_Char*)M4OSA_malloc(newFormatLength, + M4OSA_CHARSTAR, (M4OSA_Char*)"M4OSA_chrPrintf: newFormat"); + if(newFormat == M4OSA_NULL) return M4ERR_ALLOC; + newFormat[newFormatLength-1] = '\0'; + temp = newFormat; + /* copy format to newFormat, replacing + %[flags][width][.precision]ll[conversion] + by %[flags][width][.precision]I64[conversion] */ + while(*format) + { + M4OSA_chrSpanComplement(format, (M4OSA_Char*)"%", &nbChar); + if(nbChar) + { + M4OSA_chrNCopy(temp,format,nbChar); /* copy characters before the % character */ + format +=nbChar; + temp +=nbChar; + } + if(!*format) + { + break; + } + *temp++ = *format++; /* copy the % character */ + + M4OSA_chrSpan(format, flagChar, &nbChar); + if(nbChar) + { + M4OSA_chrNCopy(temp,format,nbChar); /* copy the flag characters */ + format +=nbChar; + temp +=nbChar; + } + if(!*format) + { + break; + } + + M4OSA_chrSpan(format, widthOrPrecisionChar, &nbChar); + if(nbChar) + { + M4OSA_chrNCopy(temp,format,nbChar); /* copy the width characters */ + format +=nbChar; + temp +=nbChar; + } + if(!*format) + { + break; + } + if(*format=='.') + { + *temp++ = *format++; /* copy the dot character */ + if(!*format) + { + break; + } + + M4OSA_chrSpan(format, widthOrPrecisionChar, &nbChar); + if(nbChar) + { + M4OSA_chrNCopy(temp,format,nbChar); /* copy the width characters */ + format +=nbChar; + temp +=nbChar; + } + if(!*format) + { + break; + } + } + if(M4OSA_chrLength(format)>=2) + { + + M4OSA_chrNCompare(format, (M4OSA_Char*)"ll",2, &iResult); + if (iResult != 0) + { +#ifdef M4OSA_64BITS_SUPPORTED + *temp++ = 'I'; /* %I64 */ + *temp++ = '6'; + *temp++ = '4'; +#else + *temp++ = 'l'; /* %l */ +#endif + format +=2; /* span the "ll" prefix */ + } + else + { + M4OSA_chrNCompare(format, (M4OSA_Char*)"tm",2, &iResult); + if (iResult != 0) + { +#ifdef M4OSA_64BITS_SUPPORTED + *temp++ = 'I'; /* %I64 */ + *temp++ = '6'; + *temp++ = '4'; +#else + *temp++ = 'l'; /* %l */ +#endif + format +=2; /* span the "tm" prefix */ + } + else + { + M4OSA_chrNCompare(format, (M4OSA_Char*)"aa",2, &iResult); + if (iResult != 0) /* à voir si ce n'est pas != 0 */ + { +#ifdef M4OSA_64BITS_SUPPORTED +#ifdef M4OSA_FILE_POS_64_BITS_SUPPORTED + *temp++ = 'I'; /* %I64 */ + *temp++ = '6'; + *temp++ = '4'; +#else + *temp++ = 'l'; +#endif +#else + *temp++ = 'l'; +#endif + format +=2; /* span the "aa" prefix */ + } + } + } + } + + M4OSA_chrSpan(format, otherPrefixChar, &nbChar); + + if(nbChar) + { + M4OSA_chrNCopy(temp,format,nbChar); /* copy the other Prefix */ + format +=nbChar; + temp +=nbChar; + } + + if(!*format) + { + break; + } + + M4OSA_chrSpan(format, conversionChar, &nbChar); + if(nbChar) + { + M4OSA_chrNCopy(temp,format,nbChar); + format += nbChar; + temp += nbChar; + } + + if(!*format) + { + break; + } + } + + err = M4OSA_chrSPrintf(strOut,strOutMaxLen,newFormat,marker); + + M4OSA_free((M4OSA_MemAddr32)newFormat); + + if (M4ERR_CHR_STR_OVERFLOW == err) + { + return M4ERR_STR_OVERFLOW; + } + else + { + return M4NO_ERROR; + } +} + |