具体代码差异，参考：http://blog.chinaunix.net/uid-14735472-id-5212202.html
----------------------接着调试，调试到此处，出现如下问题 （段错误）
at /opt/cBPM-android/criteria-lin/src/Criteria/Criteria.WorkflowEngine/DataBase/DataBaseHelper.cpp:236236 CM_TRACE_CODEPATH("Process [" << acWorkflowName << "] retrieved. [" << workflow->getProcessId() << "]")
Program terminated with signal SIGSEGV, Segmentation fault.
The program no longer exists.
(gdb)
是因为Connection Nr[0]
具体错误（在Executor-7033-20150407-163826.trace文件中）
10:39:39.550-1073824092- DataBaseHelper::open-INFO-DataBaseHelper.cpp[106]-Connection Nr[0]
应该为
16:38:26.424--134334400- DataBaseHelper::open-INFO-DataBaseHelper.cpp[106]-Connection Nr[1]
0:45:44.772--134334400- DataBaseHelper::open-INFO-DataBaseHelper.cpp[106]-Connection Nr[1]
20:45:44.772--134334400- DataBaseHelper::open-INFO-DataBaseHelper.cpp[171]-Analysing FileSsystem Connection
因为[106]出了问题，所以[171]没有执行，即，[111]行的 for 循环的 循环体 没有执行。
下面调试，找问题
(gdb) break DataBaseHelper.cpp:236
(gdb) break DataBaseHelper.cpp:109
--------------使用如下断点找问题
break DataBaseHelper.cpp:102
break bOSXMLFile.cpp:52
break bOSCollection.cpp:37
break bOSCollection.cpp:44
break bOSXMLFile.cpp:59
break DataBaseHelper.cpp:104
break bOSXMLObject.cpp:73 //初始化 vConnections 的 地方
break bOSXMLObject.cpp:89 //初始化 vConnections 的 地方，是虚函数，因此，执行时 定位 实际函数
// at /opt/cBPM-android/criteria-lin/src/Criteria/Criteria.WorkflowEngine/DataBase/DataBase.cpp:27
-----------------------找到了故障点 DataBase.cpp:27
if ( strcmp(node->getName(),XMLConnections::MAIN_NODE.c_str()) == 0 )
----------函数strcmp的 两个 参数 不同："C" 和 "Connections"
_M_data = 0x5f6510 "C"
_M_data = 0x5813f8 <DataManager::Panorama::DataBase::XMLConnections::MAIN_NODE> "Connections"}
----------下面查找，第一个参数 为什么 是"C"
break bOSXMLNode.cpp:223 //void XMLNode::setName( const char* acName )
break setName
break bOSXMLHelper.cpp:157
break bOSXMLHelper.cpp:170
break XMLString.cpp:600
break IconvTransService.cpp:451
先设置断点
break bOSXMLHelper.cpp:170
执行后，再设置断点
break IconvTransService.cpp:529
break IconvTransService.cpp:569
//终于找到故障点： 文件 IconvTransService.cpp:451
size_t len = ::wcsrtombs(resultString + dstCursor, &src, resultSize - dstCursor, &st);
//Android中，wcsrtombs 有问题，所以 替换之
//修改如下文件：
/opt/cBPM-android/xerces-c-3.1.2/src/xercesc/util/Transcoders/Iconv/IconvTransService.cpp
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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.
*/
/*
* $Id: IconvTransService.cpp 695885 2008-09-16 14:00:19Z borisk $
*/
// ---------------------------------------------------------------------------
// Includes
// ---------------------------------------------------------------------------
#if HAVE_CONFIG_H
# include <config.h>
#endif
#if HAVE_WCHAR_H
# include <wchar.h>
#endif
#if HAVE_WCTYPE_H
# include <wctype.h>
#endif
// Fill in for broken or missing wctype functions on some platforms
#if !HAVE_TOWUPPER
# include <towupper.h>
#endif
#if !HAVE_TOWLOWER
# include <towlower.h>
#endif
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include "IconvTransService.hpp"
#include <xercesc/util/XMLUniDefs.hpp>
#include <xercesc/util/XMLUni.hpp>
#include <xercesc/framework/MemoryManager.hpp>
#include <errno.h>
XERCES_CPP_NAMESPACE_BEGIN
// ---------------------------------------------------------------------------
// Local, const data
// ---------------------------------------------------------------------------
static const int gTempBuffArraySize = 1024;
static const XMLCh gMyServiceId[] =
{
chLatin_I, chLatin_C, chLatin_o, chLatin_n, chLatin_v, chNull
};
// ---------------------------------------------------------------------------
// the following is defined by 'man mbrtowc':
// ---------------------------------------------------------------------------
static const size_t TRANSCODING_ERROR = (size_t)(-1);
// ---------------------------------------------------------------------------
// Local methods
// ---------------------------------------------------------------------------
static unsigned int getWideCharLength(const XMLCh* const src)
{
if (!src)
return 0;
unsigned int len = 0;
const XMLCh* pTmp = src;
while (*pTmp++)
len++;
return len;
}
size_t l_wcrtomb(char *s, wchar_t wc, mbstate_t *ps)
{
if (!s) return 1;
if ((unsigned)wc < 0x80) {
*s = wc;
return 1;
} else if ((unsigned)wc < 0x800) {
*s++ = 0xc0 | (wc>>6);
*s = 0x80 | (wc&0x3f);
return 2;
} else if ((unsigned)wc < 0xd800 || (unsigned)wc-0xe000 < 0x2000) {
*s++ = 0xe0 | (wc>>12);
*s++ = 0x80 | ((wc>>6)&0x3f);
*s = 0x80 | (wc&0x3f);
return 3;
} else if ((unsigned)wc-0x10000 < 0x100000) {
*s++ = 0xf0 | (wc>>18);
*s++ = 0x80 | ((wc>>12)&0x3f);
*s++ = 0x80 | ((wc>>6)&0x3f);
*s = 0x80 | (wc&0x3f);
return 4;
}
errno = EILSEQ;
return -1;
}
size_t l_wcsrtombs(char *s, const wchar_t **ws, size_t n, mbstate_t *st)
{
const wchar_t *ws2;
char buf[4];
size_t N = n, l;
if (!s) {
for (n=0, ws2=*ws; *ws2; ws2++) {
if (*ws2 >= 0x80u) {
l = l_wcrtomb(buf, *ws2, 0);
if (!(l+1)) return -1;
n += l;
} else n++;
}
return n;
}
while (n>=4) {
if (**ws-1u >= 0x7fu) {
if (!**ws) {
*s = 0;
*ws = 0;
return N-n;
}
l = l_wcrtomb(s, **ws, 0);
if (!(l+1)) return -1;
s += l;
n -= l;
} else {
*s++ = **ws;
n--;
}
(*ws)++;
}
while (n) {
if (**ws-1u >= 0x7fu) {
if (!**ws) {
*s = 0;
*ws = 0;
return N-n;
}
l = l_wcrtomb(buf, **ws, 0);
if (!(l+1)) return -1;
if (l>n) return N-n;
l_wcrtomb(s, **ws, 0);
s += l;
n -= l;
} else {
*s++ = **ws;
n--;
}
(*ws)++;
}
return N;
}
// ---------------------------------------------------------------------------
// IconvTransService: Constructors and Destructor
// ---------------------------------------------------------------------------
IconvTransService::IconvTransService(MemoryManager* /* manager */)
{
}
IconvTransService::~IconvTransService()
{
}
// ---------------------------------------------------------------------------
// IconvTransService: The virtual transcoding service API
// ---------------------------------------------------------------------------
int IconvTransService::compareIString( const XMLCh* const comp1
, const XMLCh* const comp2)
{
const XMLCh* cptr1 = comp1;
const XMLCh* cptr2 = comp2;
while ( (*cptr1 != 0) && (*cptr2 != 0) )
{
wint_t wch1 = towupper(*cptr1);
wint_t wch2 = towupper(*cptr2);
if (wch1 != wch2)
break;
cptr1++;
cptr2++;
}
return (int) ( towupper(*cptr1) - towupper(*cptr2) );
}
int IconvTransService::compareNIString( const XMLCh* const comp1
, const XMLCh* const comp2
, const XMLSize_t maxChars)
{
unsigned int n = 0;
const XMLCh* cptr1 = comp1;
const XMLCh* cptr2 = comp2;
while (true && maxChars)
{
wint_t wch1 = towupper(*cptr1);
wint_t wch2 = towupper(*cptr2);
if (wch1 != wch2)
return (int) (wch1 - wch2);
// If either ended, then both ended, so equal
if (!*cptr1 || !*cptr2)
break;
cptr1++;
cptr2++;
// Bump the count of chars done. If it equals the count then we
// are equal for the requested count, so break out and return
// equal.
n++;
if (n == maxChars)
break;
}
return 0;
}
const XMLCh* IconvTransService::getId() const
{
return gMyServiceId;
}
XMLLCPTranscoder* IconvTransService::makeNewLCPTranscoder(MemoryManager* manager)
{
// Just allocate a new transcoder of our type
return new (manager) IconvLCPTranscoder;
}
bool IconvTransService::supportsSrcOfs() const
{
return true;
}
// ---------------------------------------------------------------------------
// IconvTransService: The protected virtual transcoding service API
// ---------------------------------------------------------------------------
XMLTranscoder*
IconvTransService::makeNewXMLTranscoder(const XMLCh* const
, XMLTransService::Codes& resValue
, const XMLSize_t
, MemoryManager* const)
{
//
// NOTE: We don't use the block size here
//
// This is a minimalist transcoding service, that only supports a local
// default transcoder. All named encodings return zero as a failure,
// which means that only the intrinsic encodings supported by the parser
// itself will work for XML data.
//
resValue = XMLTransService::UnsupportedEncoding;
return 0;
}
void IconvTransService::upperCase(XMLCh* const toUpperCase)
{
XMLCh* outPtr = toUpperCase;
while (*outPtr)
{
*outPtr = towupper(*outPtr);
outPtr++;
}
}
void IconvTransService::lowerCase(XMLCh* const toLowerCase)
{
XMLCh* outPtr = toLowerCase;
while (*outPtr)
{
*outPtr = towlower(*outPtr);
outPtr++;
}
}
// ---------------------------------------------------------------------------
// IconvLCPTranscoder: The virtual transcoder API
// ---------------------------------------------------------------------------
XMLSize_t IconvLCPTranscoder::calcRequiredSize(const char* const srcText
, MemoryManager* const)
{
if (!srcText)
return 0;
XMLSize_t len = 0;
const char *src = srcText;
#if HAVE_MBRLEN
mbstate_t st;
memset(&st, 0, sizeof(st));
#endif
for ( ; *src; ++len)
{
#if HAVE_MBRLEN
int l=::mbrlen( src, MB_CUR_MAX, &st );
#else
int l=::mblen( src, MB_CUR_MAX );
#endif
if( l == TRANSCODING_ERROR )
return 0;
src += l;
}
return len;
}
XMLSize_t IconvLCPTranscoder::calcRequiredSize(const XMLCh* const srcText
, MemoryManager* const manager)
{
if (!srcText)
return 0;
XMLSize_t wLent = getWideCharLength(srcText);
wchar_t tmpWideCharArr[gTempBuffArraySize];
wchar_t* allocatedArray = 0;
wchar_t* wideCharBuf = 0;
if (wLent >= gTempBuffArraySize)
wideCharBuf = allocatedArray = (wchar_t*)
manager->allocate
(
(wLent + 1) * sizeof(wchar_t)
);//new wchar_t[wLent + 1];
else
wideCharBuf = tmpWideCharArr;
for (XMLSize_t i = 0; i < wLent; i++)
{
wideCharBuf[i] = srcText[i];
}
wideCharBuf[wLent] = 0x00;
const XMLSize_t retVal = ::wcstombs(NULL, wideCharBuf, 0);
if (allocatedArray)
manager->deallocate(allocatedArray);
if (retVal == ~0)
return 0;
return retVal;
}
bool IconvLCPTranscoder::transcode( const XMLCh* const toTranscode
, char* const toFill
, const XMLSize_t maxBytes
, MemoryManager* const manager)
{
// Watch for a couple of pyscho corner cases
if (!toTranscode || !maxBytes)
{
toFill[0] = 0;
return true;
}
if (!*toTranscode)
{
toFill[0] = 0;
return true;
}
unsigned int wLent = getWideCharLength(toTranscode);
wchar_t tmpWideCharArr[gTempBuffArraySize];
wchar_t* allocatedArray = 0;
wchar_t* wideCharBuf = 0;
if (wLent > maxBytes) {
wLent = maxBytes;
}
if (maxBytes >= gTempBuffArraySize) {
wideCharBuf = allocatedArray = (wchar_t*)
manager->allocate
(
(maxBytes + 1) * sizeof(wchar_t)
);//new wchar_t[maxBytes + 1];
}
else
wideCharBuf = tmpWideCharArr;
for (unsigned int i = 0; i < wLent; i++)
{
wideCharBuf[i] = toTranscode[i];
}
wideCharBuf[wLent] = 0x00;
// Ok, go ahead and try the transcoding. If it fails, then ...
size_t mblen = ::wcstombs(toFill, wideCharBuf, maxBytes);
if (mblen == (size_t)-1)
{
if (allocatedArray)
manager->deallocate(allocatedArray);
return false;
}
// Cap it off just in case
toFill[mblen] = 0;
if (allocatedArray)
manager->deallocate(allocatedArray);
return true;
}
bool IconvLCPTranscoder::transcode( const char* const toTranscode
, XMLCh* const toFill
, const XMLSize_t maxChars
, MemoryManager* const manager)
{
// Check for a couple of psycho corner cases
if (!toTranscode || !maxChars)
{
toFill[0] = 0;
return true;
}
if (!*toTranscode)
{
toFill[0] = 0;
return true;
}
XMLSize_t len = calcRequiredSize(toTranscode);
wchar_t tmpWideCharArr[gTempBuffArraySize];
wchar_t* allocatedArray = 0;
wchar_t* wideCharBuf = 0;
if (len > maxChars) {
len = maxChars;
}
if (maxChars >= gTempBuffArraySize)
wideCharBuf = allocatedArray = (wchar_t*) manager->allocate
(
(maxChars + 1) * sizeof(wchar_t)
);//new wchar_t[maxChars + 1];
else
wideCharBuf = tmpWideCharArr;
if (::mbstowcs(wideCharBuf, toTranscode, maxChars) == (size_t)-1)
{
if (allocatedArray)
manager->deallocate(allocatedArray);
return false;
}
for (XMLSize_t i = 0; i < len; i++)
{
toFill[i] = (XMLCh) wideCharBuf[i];
}
toFill[len] = 0x00;
if (allocatedArray)
manager->deallocate(allocatedArray);
return true;
}
template <typename T>
void reallocString(T *&ref, size_t &size, MemoryManager* const manager, bool releaseOld)
{
T *tmp = (T*)manager->allocate(2 * size * sizeof(T));
memcpy(tmp, ref, size * sizeof(T));
if (releaseOld) manager->deallocate(ref);
ref = tmp;
size *= 2;
}
char* IconvLCPTranscoder::transcode(const XMLCh* const toTranscode,
MemoryManager* const manager)
{
if (!toTranscode)
return 0;
size_t srcCursor = 0, dstCursor = 0;
size_t resultSize = gTempBuffArraySize;
char localBuffer[gTempBuffArraySize];
char* resultString = localBuffer;
#if HAVE_WCSRTOMBS
mbstate_t st;
memset((void*)&st, 0, sizeof(st)); // Reset to initial shift state
wchar_t srcBuffer[gTempBuffArraySize];
srcBuffer[gTempBuffArraySize - 1] = 0;
const wchar_t *src = 0;
// while (toTranscode[srcCursor] || src)
while (toTranscode[srcCursor])
{
if (src == 0) // copy a piece of the source string into a local
// buffer, converted to wchar_t and NULL-terminated.
// after that, src points to the beginning of the
// local buffer and is used for the call to ::wcsrtombs
{
size_t i;
for (i=0; i<gTempBuffArraySize-1; ++i)
{
srcBuffer[i] = toTranscode[srcCursor];
if (srcBuffer[i] == '\0')
break;
++srcCursor;
}
src = srcBuffer;
}
size_t len = l_wcsrtombs(resultString + dstCursor, &src, resultSize - dstCursor, &st);
// size_t len = ::wcsrtombs(resultString + dstCursor, &src, resultSize - dstCursor, &st);
if (len == TRANSCODING_ERROR)
{
dstCursor = 0;
break;
}
dstCursor += len;
// if (src != 0) // conversion not finished. This *always* means there
// was not enough room in the destination buffer.
if (len == (resultSize - dstCursor))
{
reallocString<char>(resultString, resultSize, manager, resultString != localBuffer);
}
}
#else
while (toTranscode[srcCursor])
{
char mbBuf[16]; // MB_CUR_MAX is not defined as a constant on some platforms
int len = wctomb(mbBuf, toTranscode[srcCursor++]);
if (len < 0)
{
dstCursor = 0;
break;
}
if (dstCursor + len >= resultSize - 1)
reallocString<char>(resultString, resultSize, manager, resultString != localBuffer);
for (int j=0; j<len; ++j)
resultString[dstCursor++] = mbBuf[j];
}
#endif
if (resultString == localBuffer)
{
resultString = (char*)manager->allocate((dstCursor + 1) * sizeof(char));
memcpy(resultString, localBuffer, dstCursor * sizeof(char));
}
resultString[dstCursor] = '\0';
return resultString;
}
XMLCh* IconvLCPTranscoder::transcode(const char* const toTranscode,
MemoryManager* const manager)
{
if (!toTranscode)
return 0;
size_t resultSize = gTempBuffArraySize;
size_t srcCursor = 0, dstCursor = 0;
#if HAVE_MBSRTOWCS
wchar_t localBuffer[gTempBuffArraySize];
wchar_t *tmpString = localBuffer;
mbstate_t st;
memset(&st, 0, sizeof(st));
const char *src = toTranscode;
while(true)
{
size_t len = ::mbsrtowcs(tmpString + dstCursor, &src, resultSize - dstCursor, &st);
if (len == TRANSCODING_ERROR)
{
dstCursor = 0;
break;
}
dstCursor += len;
// if (src == 0) // conversion finished
if ((len >= 0) && (len < (resultSize - dstCursor)))
break;
// if (dstCursor >= resultSize - 1)
if (len == (resultSize - dstCursor))
reallocString<wchar_t>(tmpString, resultSize, manager, tmpString != localBuffer);
}
// make a final copy, converting from wchar_t to XMLCh:
XMLCh* resultString = (XMLCh*)manager->allocate((dstCursor + 1) * sizeof(XMLCh));
size_t i;
for (i=0; i<dstCursor; ++i)
resultString[i] = tmpString[i];
if (tmpString != localBuffer) // did we allocate something?
manager->deallocate(tmpString);
#else
XMLCh localBuffer[gTempBuffArraySize];
XMLCh* resultString = localBuffer;
size_t srcLen = strlen(toTranscode);
while(srcLen > srcCursor)
{
wchar_t wcBuf[1];
int len = mbtowc(wcBuf, toTranscode + srcCursor, srcLen - srcCursor);
if (len <= 0)
{
if (len < 0)
dstCursor = 0;
break;
}
srcCursor += len;
if (dstCursor + 1 >= resultSize - 1)
reallocString<XMLCh>(resultString, resultSize, manager, resultString != localBuffer);
resultString[dstCursor++] = wcBuf[0];
}
if (resultString == localBuffer)
{
resultString = (XMLCh*)manager->allocate((dstCursor + 1) * sizeof(XMLCh));
memcpy(resultString, localBuffer, dstCursor * sizeof(XMLCh));
}
#endif
resultString[dstCursor] = L'\0';
return resultString;
}
// ---------------------------------------------------------------------------
// IconvLCPTranscoder: Constructors and Destructor
// ---------------------------------------------------------------------------
IconvLCPTranscoder::IconvLCPTranscoder()
{
}
IconvLCPTranscoder::~IconvLCPTranscoder()
{
}
XERCES_CPP_NAMESPACE_END