void CBC_OneDimWriter::RenderDeviceResult(CFX_RenderDevice* device,
const CFX_Matrix* matrix,
const CFX_WideStringC& contents,
int32_t& e) {
if (!m_output)
BC_EXCEPTION_CHECK_ReturnVoid(e);
CFX_GraphStateData stateData;
CFX_PathData path;
path.AppendRect(0, 0, (FX_FLOAT)m_Width, (FX_FLOAT)m_Height);
device->DrawPath(&path, matrix, &stateData, m_backgroundColor,
m_backgroundColor, FXFILL_ALTERNATE);
CFX_Matrix matri(m_outputHScale, 0.0, 0.0, (FX_FLOAT)m_Height, 0.0, 0.0);
matri.Concat(*matrix);
for (int32_t x = 0; x < m_output->GetWidth(); x++) {
for (int32_t y = 0; y < m_output->GetHeight(); y++) {
CFX_PathData rect;
rect.AppendRect((FX_FLOAT)x, (FX_FLOAT)y, (FX_FLOAT)(x + 1),
(FX_FLOAT)(y + 1));
if (m_output->Get(x, y)) {
CFX_GraphStateData data;
device->DrawPath(&rect, &matri, &data, m_barColor, 0, FXFILL_WINDING);
}
}
}
int32_t i = 0;
for (; i < contents.GetLength(); i++)
if (contents.GetAt(i) != ' ') {
break;
}
if (m_locTextLoc != BC_TEXT_LOC_NONE && i < contents.GetLength()) {
ShowChars(contents, nullptr, device, matrix, m_barWidth, m_multiple, e);
BC_EXCEPTION_CHECK_ReturnVoid(e);
}
}
void CBC_OneDimWriter::RenderBitmapResult(CFX_DIBitmap*& pOutBitmap,
const CFX_WideStringC& contents,
int32_t& e) {
if (!m_output)
BC_EXCEPTION_CHECK_ReturnVoid(e);
pOutBitmap = CreateDIBitmap(m_output->GetWidth(), m_output->GetHeight());
pOutBitmap->Clear(m_backgroundColor);
if (!pOutBitmap) {
e = BCExceptionFailToCreateBitmap;
return;
}
for (int32_t x = 0; x < m_output->GetWidth(); x++) {
for (int32_t y = 0; y < m_output->GetHeight(); y++) {
if (m_output->Get(x, y)) {
pOutBitmap->SetPixel(x, y, m_barColor);
}
}
}
int32_t i = 0;
for (; i < contents.GetLength(); i++)
if (contents.GetAt(i) != ' ') {
break;
}
if (m_locTextLoc != BC_TEXT_LOC_NONE && i < contents.GetLength()) {
ShowChars(contents, pOutBitmap, nullptr, nullptr, m_barWidth, m_multiple,
e);
BC_EXCEPTION_CHECK_ReturnVoid(e);
}
CFX_DIBitmap* pStretchBitmap = pOutBitmap->StretchTo(m_Width, m_Height);
delete pOutBitmap;
pOutBitmap = pStretchBitmap;
}
CFX_WideString::CFX_WideString(const CFX_WideStringC& str)
{
if (str.IsEmpty()) {
m_pData = NULL;
return;
}
m_pData = StringData::Create(str.GetLength());
if (m_pData) {
FXSYS_memcpy(m_pData->m_String, str.GetPtr(), str.GetLength()*sizeof(FX_WCHAR));
}
}
CFX_WideString::CFX_WideString(const CFX_WideStringC& str1, const CFX_WideStringC& str2)
{
m_pData = NULL;
int nNewLen = str1.GetLength() + str2.GetLength();
if (nNewLen == 0) {
return;
}
m_pData = StringData::Create(nNewLen);
if (m_pData) {
FXSYS_memcpy(m_pData->m_String, str1.GetPtr(), str1.GetLength()*sizeof(FX_WCHAR));
FXSYS_memcpy(m_pData->m_String + str1.GetLength(), str2.GetPtr(), str2.GetLength()*sizeof(FX_WCHAR));
}
}
// Static.
FX_ARGB CXFA_Data::ToColor(const CFX_WideStringC& wsValue) {
uint8_t r = 0, g = 0, b = 0;
if (wsValue.GetLength() == 0)
return 0xff000000;
int cc = 0;
const FX_WCHAR* str = wsValue.c_str();
int len = wsValue.GetLength();
while (FXSYS_iswspace(str[cc]) && cc < len)
cc++;
if (cc >= len)
return 0xff000000;
while (cc < len) {
if (str[cc] == ',' || !FXSYS_isDecimalDigit(str[cc]))
break;
r = r * 10 + str[cc] - '0';
cc++;
}
if (cc < len && str[cc] == ',') {
cc++;
while (FXSYS_iswspace(str[cc]) && cc < len)
cc++;
while (cc < len) {
if (str[cc] == ',' || !FXSYS_isDecimalDigit(str[cc]))
break;
g = g * 10 + str[cc] - '0';
cc++;
}
if (cc < len && str[cc] == ',') {
cc++;
while (FXSYS_iswspace(str[cc]) && cc < len)
cc++;
while (cc < len) {
if (str[cc] == ',' || !FXSYS_isDecimalDigit(str[cc]))
break;
b = b * 10 + str[cc] - '0';
cc++;
}
}
}
return (0xff << 24) | (r << 16) | (g << 8) | b;
}
bool CFX_WideString::Equal(const CFX_WideStringC& str) const {
if (m_pData == NULL) {
return str.IsEmpty();
}
return str.GetLength() == m_pData->m_nDataLength &&
wmemcmp(str.GetPtr(), m_pData->m_String, m_pData->m_nDataLength) == 0;
}
FX_BOOL CXFA_ScriptContext::RunVariablesScript(CXFA_Node* pScriptNode) {
if (!pScriptNode)
return FALSE;
if (pScriptNode->GetElementType() != XFA_Element::Script)
return TRUE;
CXFA_Node* pParent = pScriptNode->GetNodeItem(XFA_NODEITEM_Parent);
if (!pParent || pParent->GetElementType() != XFA_Element::Variables)
return FALSE;
if (m_mapVariableToContext.GetValueAt(pScriptNode))
return TRUE;
CXFA_Node* pTextNode = pScriptNode->GetNodeItem(XFA_NODEITEM_FirstChild);
if (!pTextNode)
return FALSE;
CFX_WideStringC wsScript;
if (!pTextNode->TryCData(XFA_ATTRIBUTE_Value, wsScript))
return FALSE;
CFX_ByteString btScript =
FX_UTF8Encode(wsScript.c_str(), wsScript.GetLength());
std::unique_ptr<CFXJSE_Value> hRetValue(new CFXJSE_Value(m_pIsolate));
CXFA_Node* pThisObject = pParent->GetNodeItem(XFA_NODEITEM_Parent);
CFXJSE_Context* pVariablesContext =
CreateVariablesContext(pScriptNode, pThisObject);
CXFA_Object* pOriginalObject = m_pThisObject;
m_pThisObject = pThisObject;
FX_BOOL bRet =
pVariablesContext->ExecuteScript(btScript.c_str(), hRetValue.get());
m_pThisObject = pOriginalObject;
return bRet;
}
FX_BOOL CXFA_ScriptContext::RunScript(XFA_SCRIPTLANGTYPE eScriptType,
const CFX_WideStringC& wsScript,
CFXJSE_Value* hRetValue,
CXFA_Object* pThisObject) {
CFX_ByteString btScript;
XFA_SCRIPTLANGTYPE eSaveType = m_eScriptType;
m_eScriptType = eScriptType;
if (eScriptType == XFA_SCRIPTLANGTYPE_Formcalc) {
if (!m_FM2JSContext) {
m_FM2JSContext.reset(
new CXFA_FM2JSContext(m_pIsolate, m_JsContext.get(), m_pDocument));
}
CFX_WideTextBuf wsJavaScript;
CFX_WideString wsErrorInfo;
int32_t iFlags =
CXFA_FM2JSContext::Translate(wsScript, wsJavaScript, wsErrorInfo);
if (iFlags) {
hRetValue->SetUndefined();
return FALSE;
}
btScript =
FX_UTF8Encode(wsJavaScript.GetBuffer(), wsJavaScript.GetLength());
} else {
btScript = FX_UTF8Encode(wsScript.c_str(), wsScript.GetLength());
}
CXFA_Object* pOriginalObject = m_pThisObject;
m_pThisObject = pThisObject;
CFXJSE_Value* pValue = pThisObject ? GetJSValueFromMap(pThisObject) : nullptr;
FX_BOOL bRet =
m_JsContext->ExecuteScript(btScript.c_str(), hRetValue, pValue);
m_pThisObject = pOriginalObject;
m_eScriptType = eSaveType;
return bRet;
}
CFX_WideString CPDF_FileSpec::DecodeFileName(const CFX_WideStringC& filepath) {
if (filepath.GetLength() <= 1)
return CFX_WideString();
#if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
if (filepath.Left(sizeof("/Mac") - 1) == CFX_WideStringC(L"/Mac"))
return ChangeSlashToPlatform(filepath.c_str() + 1);
return ChangeSlashToPlatform(filepath.c_str());
#elif _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_
if (filepath.GetAt(0) != '/')
return ChangeSlashToPlatform(filepath.c_str());
if (filepath.GetAt(1) == '/')
return ChangeSlashToPlatform(filepath.c_str() + 1);
if (filepath.GetAt(2) == '/') {
CFX_WideString result;
result += filepath.GetAt(1);
result += ':';
result += ChangeSlashToPlatform(filepath.c_str() + 2);
return result;
}
CFX_WideString result;
result += '\\';
result += ChangeSlashToPlatform(filepath.c_str());
return result;
#else
return CFX_WideString(filepath);
#endif
}
static CFX_WideString FILESPEC_DecodeFileName(const CFX_WideStringC& filepath) {
if (filepath.GetLength() <= 1) {
return CFX_WideString();
}
#if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
if (filepath.Left(sizeof("/Mac") - 1) == CFX_WideStringC(L"/Mac")) {
return ChangeSlashToPlatform(filepath.GetPtr() + 1);
}
return ChangeSlashToPlatform(filepath.GetPtr());
#elif _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_
if (filepath.GetAt(0) != '/') {
return ChangeSlashToPlatform(filepath.GetPtr());
}
if (filepath.GetAt(1) == '/') {
return ChangeSlashToPlatform(filepath.GetPtr() + 1);
}
if (filepath.GetAt(2) == '/') {
CFX_WideString result;
result += filepath.GetAt(1);
result += ':';
result += ChangeSlashToPlatform(filepath.GetPtr() + 2);
return result;
}
CFX_WideString result;
result += '\\';
result += ChangeSlashToPlatform(filepath.GetPtr());
return result;
#else
return filepath;
#endif
}
FX_BOOL CBC_OnedUPCAWriter::CheckContentValidity(
const CFX_WideStringC& contents) {
for (FX_STRSIZE i = 0; i < contents.GetLength(); ++i) {
if (contents.GetAt(i) < '0' || contents.GetAt(i) > '9')
return FALSE;
}
return TRUE;
}
bool CFX_WideString::Equal(const CFX_WideStringC& str) const
{
if (m_pData == NULL) {
return str.IsEmpty();
}
return str.GetLength() == m_pData->m_nDataLength &&
FXSYS_memcmp32(str.GetPtr(), m_pData->m_String, m_pData->m_nDataLength * sizeof(FX_WCHAR)) == 0;
}
FX_BOOL CBC_OnedEAN8Writer::CheckContentValidity(
const CFX_WideStringC& contents) {
for (int32_t i = 0; i < contents.GetLength(); i++) {
if (contents.GetAt(i) >= '0' && contents.GetAt(i) <= '9') {
continue;
} else {
return FALSE;
}
}
return TRUE;
}
FX_STRSIZE FX_WideString_GetNormalization(const CFX_WideStringC& wsSrc,
FX_WCHAR* pDst) {
FX_STRSIZE nCount = 0;
for (FX_STRSIZE len = 0; len < wsSrc.GetLength(); len++) {
FX_WCHAR wch = wsSrc.GetAt(len);
if (pDst) {
nCount += FX_Unicode_GetNormalization(wch, pDst + nCount);
} else {
nCount += FX_Unicode_GetNormalization(wch, pDst);
}
}
return nCount;
}
CFX_WideString CBC_OnedUPCAWriter::FilterContents(
const CFX_WideStringC& contents) {
CFX_WideString filtercontents;
FX_WCHAR ch;
for (int32_t i = 0; i < contents.GetLength(); i++) {
ch = contents.GetAt(i);
if (ch > 175) {
i++;
continue;
}
if (ch >= '0' && ch <= '9') {
filtercontents += ch;
}
}
return filtercontents;
}
static XFA_LPCBARCODETYPEENUMINFO XFA_GetBarcodeTypeByName(
const CFX_WideStringC& wsName) {
int32_t iLength = wsName.GetLength();
if (iLength == 0) {
return NULL;
}
uint32_t uHash = FX_HashCode_String_GetW(wsName.GetPtr(), iLength, TRUE);
int32_t iStart = 0, iEnd = g_iXFABarcodeTypeCount - 1;
do {
int32_t iMid = (iStart + iEnd) / 2;
XFA_LPCBARCODETYPEENUMINFO pInfo = g_XFABarCodeTypeEnumData + iMid;
if (uHash == pInfo->uHash) {
return pInfo;
} else if (uHash < pInfo->uHash) {
iEnd = iMid - 1;
} else {
iStart = iMid + 1;
}
} while (iStart <= iEnd);
return NULL;
}
FX_BOOL CBC_OnedCode128Writer::CheckContentValidity(
const CFX_WideStringC& contents) {
FX_BOOL ret = TRUE;
int32_t position = 0;
int32_t patternIndex = -1;
if (m_codeFormat == BC_CODE128_B || m_codeFormat == BC_CODE128_C) {
while (position < contents.GetLength()) {
patternIndex = (int32_t)contents.GetAt(position);
if (patternIndex >= 32 && patternIndex <= 126 && patternIndex != 34) {
position++;
continue;
} else {
ret = FALSE;
break;
}
position++;
}
} else {
ret = FALSE;
}
return ret;
}
CFX_WideString FILESPEC_EncodeFileName(const CFX_WideStringC& filepath) {
if (filepath.GetLength() <= 1) {
return CFX_WideString();
}
#if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_
if (filepath.GetAt(1) == ':') {
CFX_WideString result;
result = '/';
result += filepath.GetAt(0);
if (filepath.GetAt(2) != '\\') {
result += '/';
}
result += ChangeSlashToPDF(filepath.GetPtr() + 2);
return result;
}
if (filepath.GetAt(0) == '\\' && filepath.GetAt(1) == '\\') {
return ChangeSlashToPDF(filepath.GetPtr() + 1);
}
if (filepath.GetAt(0) == '\\') {
CFX_WideString result;
result = '/';
result += ChangeSlashToPDF(filepath.GetPtr());
return result;
}
return ChangeSlashToPDF(filepath.GetPtr());
#elif _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
if (filepath.Left(sizeof("Mac") - 1) == FX_WSTRC(L"Mac")) {
CFX_WideString result;
result = '/';
result += ChangeSlashToPDF(filepath.GetPtr());
return result;
}
return ChangeSlashToPDF(filepath.GetPtr());
#else
return filepath;
#endif
}
CFX_WideString CBC_OnedCode128Writer::FilterContents(
const CFX_WideStringC& contents) {
CFX_WideString filterChineseChar;
FX_WCHAR ch;
for (int32_t i = 0; i < contents.GetLength(); i++) {
ch = contents.GetAt(i);
if (ch > 175) {
i++;
continue;
}
filterChineseChar += ch;
}
CFX_WideString filtercontents;
if (m_codeFormat == BC_CODE128_B) {
for (int32_t i = 0; i < filterChineseChar.GetLength(); i++) {
ch = filterChineseChar.GetAt(i);
if (ch >= 32 && ch <= 126) {
filtercontents += ch;
} else {
continue;
}
}
} else if (m_codeFormat == BC_CODE128_C) {
for (int32_t i = 0; i < filterChineseChar.GetLength(); i++) {
ch = filterChineseChar.GetAt(i);
if (ch >= 32 && ch <= 106) {
filtercontents += ch;
} else {
continue;
}
}
} else {
filtercontents = contents;
}
return filtercontents;
}
static int32_t XFA_FilterName(const CFX_WideStringC& wsExpression,
int32_t nStart,
CFX_WideString& wsFilter) {
FXSYS_assert(nStart > -1);
int32_t iLength = wsExpression.GetLength();
if (nStart >= iLength) {
return iLength;
}
FX_WCHAR* pBuf = wsFilter.GetBuffer(iLength - nStart);
int32_t nCount = 0;
const FX_WCHAR* pSrc = wsExpression.GetPtr();
FX_WCHAR wCur;
while (nStart < iLength) {
wCur = pSrc[nStart++];
if (wCur == ',') {
break;
}
pBuf[nCount++] = wCur;
}
wsFilter.ReleaseBuffer(nCount);
wsFilter.TrimLeft();
wsFilter.TrimRight();
return nStart;
}
void CFX_WideTextBuf::operator=(const CFX_WideStringC& str) {
CopyData(str.GetPtr(), str.GetLength() * sizeof(FX_WCHAR));
}
int32_t CXFA_ResolveProcessor::XFA_ResolveNodes_GetFilter(
const CFX_WideStringC& wsExpression,
int32_t nStart,
CXFA_ResolveNodesData& rnd) {
FXSYS_assert(nStart > -1);
int32_t iLength = wsExpression.GetLength();
if (nStart >= iLength) {
return 0;
}
CFX_WideString& wsName = rnd.m_wsName;
CFX_WideString& wsCondition = rnd.m_wsCondition;
FX_WCHAR* pNameBuf = wsName.GetBuffer(iLength - nStart);
FX_WCHAR* pConditionBuf = wsCondition.GetBuffer(iLength - nStart);
int32_t nNameCount = 0;
int32_t nConditionCount = 0;
CFX_Int32Array stack;
int32_t nType = -1;
const FX_WCHAR* pSrc = wsExpression.GetPtr();
FX_WCHAR wPrev = 0, wCur;
FX_BOOL bIsCondition = FALSE;
while (nStart < iLength) {
wCur = pSrc[nStart++];
if (wCur == '.') {
if (wPrev == '\\') {
pNameBuf[nNameCount - 1] = wPrev = '.';
continue;
}
if (nNameCount == 0) {
pNameBuf[nNameCount++] = wCur;
continue;
}
FX_WCHAR wLookahead = nStart < iLength ? pSrc[nStart] : 0;
if (wLookahead != '[' && wLookahead != '(') {
if (nType < 0) {
break;
}
}
}
if (wCur == '[' || wCur == '(') {
bIsCondition = TRUE;
} else if (wCur == '.' && nStart < iLength &&
(pSrc[nStart] == '[' || pSrc[nStart] == '(')) {
bIsCondition = TRUE;
}
if (bIsCondition) {
pConditionBuf[nConditionCount++] = wCur;
} else {
pNameBuf[nNameCount++] = wCur;
}
FX_BOOL bRecursive = TRUE;
switch (nType) {
case 0:
if (wCur == ']') {
nType = XFA_ResolveNodes_PopStack(stack);
bRecursive = FALSE;
}
break;
case 1:
if (wCur == ')') {
nType = XFA_ResolveNodes_PopStack(stack);
bRecursive = FALSE;
}
break;
case 2:
if (wCur == '"') {
nType = XFA_ResolveNodes_PopStack(stack);
bRecursive = FALSE;
}
break;
}
if (bRecursive) {
switch (wCur) {
case '[':
stack.Add(nType);
nType = 0;
break;
case '(':
stack.Add(nType);
nType = 1;
break;
case '"':
stack.Add(nType);
nType = 2;
break;
}
}
wPrev = wCur;
}
if (stack.GetSize() > 0) {
return -1;
}
wsName.ReleaseBuffer(nNameCount);
wsName.TrimLeft();
wsName.TrimRight();
wsCondition.ReleaseBuffer(nConditionCount);
wsCondition.TrimLeft();
wsCondition.TrimRight();
rnd.m_uHashName = FX_HashCode_String_GetW(wsName, wsName.GetLength());
return nStart;
}
void CBC_OneDimWriter::RenderResult(const CFX_WideStringC& contents,
uint8_t* code,
int32_t codeLength,
bool isDevice,
int32_t& e) {
if (codeLength < 1) {
BC_EXCEPTION_CHECK_ReturnVoid(e);
}
if (m_ModuleHeight < 20.0) {
m_ModuleHeight = 20;
}
int32_t codeOldLength = codeLength;
int32_t leftPadding = 0;
int32_t rightPadding = 0;
if (m_bLeftPadding) {
leftPadding = 7;
}
if (m_bRightPadding) {
rightPadding = 7;
}
codeLength += leftPadding;
codeLength += rightPadding;
m_outputHScale = 1.0;
if (m_Width > 0) {
m_outputHScale = (FX_FLOAT)m_Width / (FX_FLOAT)codeLength;
}
if (!isDevice) {
m_outputHScale =
std::max(m_outputHScale, static_cast<FX_FLOAT>(m_ModuleWidth));
}
FX_FLOAT dataLengthScale = 1.0;
if (m_iDataLenth > 0 && contents.GetLength() != 0) {
dataLengthScale = FX_FLOAT(contents.GetLength()) / FX_FLOAT(m_iDataLenth);
}
if (m_iDataLenth > 0 && contents.GetLength() == 0) {
dataLengthScale = FX_FLOAT(1) / FX_FLOAT(m_iDataLenth);
}
m_multiple = 1;
if (!isDevice) {
m_multiple = (int32_t)ceil(m_outputHScale * dataLengthScale);
}
int32_t outputHeight = 1;
if (!isDevice) {
if (m_Height == 0) {
outputHeight = std::max(20, m_ModuleHeight);
} else {
outputHeight = m_Height;
}
}
int32_t outputWidth = codeLength;
if (!isDevice) {
outputWidth = (int32_t)(codeLength * m_multiple / dataLengthScale);
}
m_barWidth = m_Width;
if (!isDevice) {
m_barWidth = codeLength * m_multiple;
}
m_output.reset(new CBC_CommonBitMatrix);
m_output->Init(outputWidth, outputHeight);
int32_t outputX = leftPadding * m_multiple;
for (int32_t inputX = 0; inputX < codeOldLength; inputX++) {
if (code[inputX] == 1) {
if (outputX >= outputWidth) {
break;
}
if (outputX + m_multiple > outputWidth && outputWidth - outputX > 0) {
m_output->SetRegion(outputX, 0, outputWidth - outputX, outputHeight, e);
break;
}
m_output->SetRegion(outputX, 0, m_multiple, outputHeight, e);
BC_EXCEPTION_CHECK_ReturnVoid(e);
}
outputX += m_multiple;
}
}
int32_t CXFA_ScriptContext::ResolveObjects(CXFA_Object* refNode,
const CFX_WideStringC& wsExpression,
XFA_RESOLVENODE_RS& resolveNodeRS,
uint32_t dwStyles,
CXFA_Node* bindNode) {
if (wsExpression.IsEmpty()) {
return 0;
}
if (m_eScriptType != XFA_SCRIPTLANGTYPE_Formcalc ||
(dwStyles & (XFA_RESOLVENODE_Parent | XFA_RESOLVENODE_Siblings))) {
m_upObjectArray.RemoveAll();
}
if (refNode && refNode->IsNode() &&
(dwStyles & (XFA_RESOLVENODE_Parent | XFA_RESOLVENODE_Siblings))) {
m_upObjectArray.Add(refNode->AsNode());
}
FX_BOOL bNextCreate = FALSE;
if (dwStyles & XFA_RESOLVENODE_CreateNode) {
m_ResolveProcessor->GetNodeHelper()->SetCreateNodeType(bindNode);
}
m_ResolveProcessor->GetNodeHelper()->m_pCreateParent = nullptr;
m_ResolveProcessor->GetNodeHelper()->m_iCurAllStart = -1;
CXFA_ResolveNodesData rndFind;
int32_t nStart = 0;
int32_t nLevel = 0;
int32_t nRet = -1;
rndFind.m_pSC = this;
CXFA_ObjArray findNodes;
findNodes.Add(refNode ? refNode : m_pDocument->GetRoot());
int32_t nNodes = 0;
while (TRUE) {
nNodes = findNodes.GetSize();
int32_t i = 0;
rndFind.m_dwStyles = dwStyles;
m_ResolveProcessor->SetCurStart(nStart);
nStart = m_ResolveProcessor->GetFilter(wsExpression, nStart, rndFind);
if (nStart < 1) {
if ((dwStyles & XFA_RESOLVENODE_CreateNode) && !bNextCreate) {
CXFA_Node* pDataNode = nullptr;
nStart = m_ResolveProcessor->GetNodeHelper()->m_iCurAllStart;
if (nStart != -1) {
pDataNode = m_pDocument->GetNotBindNode(findNodes);
if (pDataNode) {
findNodes.RemoveAll();
findNodes.Add(pDataNode);
break;
}
} else {
pDataNode = findNodes[0]->AsNode();
findNodes.RemoveAll();
findNodes.Add(pDataNode);
break;
}
dwStyles |= XFA_RESOLVENODE_Bind;
findNodes.RemoveAll();
findNodes.Add(m_ResolveProcessor->GetNodeHelper()->m_pAllStartParent);
continue;
} else {
break;
}
}
if (bNextCreate) {
FX_BOOL bCreate =
m_ResolveProcessor->GetNodeHelper()->ResolveNodes_CreateNode(
rndFind.m_wsName, rndFind.m_wsCondition,
nStart == wsExpression.GetLength(), this);
if (bCreate) {
continue;
} else {
break;
}
}
CXFA_ObjArray retNodes;
while (i < nNodes) {
FX_BOOL bDataBind = FALSE;
if (((dwStyles & XFA_RESOLVENODE_Bind) ||
(dwStyles & XFA_RESOLVENODE_CreateNode)) &&
nNodes > 1) {
CXFA_ResolveNodesData rndBind;
m_ResolveProcessor->GetFilter(wsExpression, nStart, rndBind);
m_ResolveProcessor->SetIndexDataBind(rndBind.m_wsCondition, i, nNodes);
bDataBind = TRUE;
}
rndFind.m_CurNode = findNodes[i++];
rndFind.m_nLevel = nLevel;
rndFind.m_dwFlag = XFA_RESOVENODE_RSTYPE_Nodes;
nRet = m_ResolveProcessor->Resolve(rndFind);
if (nRet < 1) {
continue;
}
if (rndFind.m_dwFlag == XFA_RESOVENODE_RSTYPE_Attribute &&
rndFind.m_pScriptAttribute && nStart < wsExpression.GetLength()) {
std::unique_ptr<CFXJSE_Value> pValue(new CFXJSE_Value(m_pIsolate));
(rndFind.m_Nodes[0]->*(rndFind.m_pScriptAttribute->lpfnCallback))(
pValue.get(), FALSE,
(XFA_ATTRIBUTE)rndFind.m_pScriptAttribute->eAttribute);
rndFind.m_Nodes.SetAt(0, ToObject(pValue.get(), nullptr));
}
int32_t iSize = m_upObjectArray.GetSize();
if (iSize) {
m_upObjectArray.RemoveAt(iSize - 1);
}
retNodes.Append(rndFind.m_Nodes);
rndFind.m_Nodes.RemoveAll();
if (bDataBind) {
break;
}
}
findNodes.RemoveAll();
nNodes = retNodes.GetSize();
if (nNodes < 1) {
if (dwStyles & XFA_RESOLVENODE_CreateNode) {
bNextCreate = TRUE;
if (!m_ResolveProcessor->GetNodeHelper()->m_pCreateParent) {
m_ResolveProcessor->GetNodeHelper()->m_pCreateParent =
ToNode(rndFind.m_CurNode);
m_ResolveProcessor->GetNodeHelper()->m_iCreateCount = 1;
}
FX_BOOL bCreate =
m_ResolveProcessor->GetNodeHelper()->ResolveNodes_CreateNode(
rndFind.m_wsName, rndFind.m_wsCondition,
nStart == wsExpression.GetLength(), this);
if (bCreate) {
continue;
} else {
break;
}
} else {
break;
}
}
findNodes.Copy(retNodes);
rndFind.m_Nodes.RemoveAll();
if (nLevel == 0) {
dwStyles &= ~(XFA_RESOLVENODE_Parent | XFA_RESOLVENODE_Siblings);
}
nLevel++;
}
if (!bNextCreate) {
resolveNodeRS.dwFlags = rndFind.m_dwFlag;
if (nNodes > 0) {
resolveNodeRS.nodes.Append(findNodes);
}
if (rndFind.m_dwFlag == XFA_RESOVENODE_RSTYPE_Attribute) {
resolveNodeRS.pScriptAttribute = rndFind.m_pScriptAttribute;
return 1;
}
}
if (dwStyles & (XFA_RESOLVENODE_CreateNode | XFA_RESOLVENODE_Bind |
XFA_RESOLVENODE_BindNew)) {
m_ResolveProcessor->SetResultCreateNode(resolveNodeRS,
rndFind.m_wsCondition);
if (!bNextCreate && (dwStyles & XFA_RESOLVENODE_CreateNode)) {
resolveNodeRS.dwFlags = XFA_RESOVENODE_RSTYPE_ExistNodes;
}
return resolveNodeRS.nodes.GetSize();
}
return nNodes;
}