// utf8 的编码

#include "../include/zgl_language.hpp"


bool CZGLanguage::doWithFh()
{
// printf("doWithFh !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! %d \n", iLineNum);

    iLineNum ++ ;
    pLineHead = pText + 1;
    iLineHeadKgf = 0;
    for(char *pTmp=pLineHead; *pTmp == ' ' || *pTmp == '\t'; pTmp ++ ) iLineHeadKgf ++ ;

    //////////////////////////////////////
    // 比较上一行缩进
    // 是否为空行
// printf("iLineHeadKgf=[%d] | pstIndentTail->iStrLen=[%d]\n", iLineHeadKgf, pstIndentTail->iStrLen);  // debug
// printStrForDebug("pLineHead", pLineHead, iLineHeadKgf + 4);

    if( *(pLineHead + iLineHeadKgf) == '\n' || *(pLineHead + iLineHeadKgf) == '\r' ) {
        // cCmpIndentFlag = CMP_INDENT_BLANK;

    // 是否为注释
    } else if(  (pLineComment && ! strncmp(pLineHead+iLineHeadKgf, pLineComment, iLineCommentLen) )
             || (pLinesCommentStart && ! strncmp(pLineHead+iLineHeadKgf, pLinesCommentStart, iLinesCommentStartLen)) ) {
        // pass

    // 是否缩进相同
    } else if( iLineHeadKgf == pstIndentTail->iStrLen && ! strncmp(pLineHead, pstIndentTail->pStr, pstIndentTail->iStrLen)  )
        cCmpIndentFlag = CMP_INDENT_SAME;
    // 是否缩进增加
    else if( iLineHeadKgf > pstIndentTail->iStrLen && ! strncmp(pLineHead, pstIndentTail->pStr, pstIndentTail->iStrLen)  )
        cCmpIndentFlag = CMP_INDENT_ADD;
    // 是否缩进减少
    else if( iLineHeadKgf < pstIndentTail->iStrLen && ! strncmp(pLineHead, pstIndentTail->pStr, iLineHeadKgf)  )
        cCmpIndentFlag = CMP_INDENT_SUB;
    else
        cCmpIndentFlag = CMP_INDENT_ERROR;

    return true;
}

bool CZGLanguage::passKgf()
{
    for( ; *pText == ' ' || *pText == '\t' || *pText == '\r' || *pText == '\n'; pText ++ )
    {
        if( *pText == '\n')
            doWithFh();
    }

    return true;
}

bool CZGLanguage::passKgf_Comment()
{
    passKgf();

    while( isComment() )
        passKgf();

    return true;
}

bool CZGLanguage::makePathHeadListByType()
{
    struct stPathHead *pPathHeadTmp = pstPathHeadList;
    struct stPath *pPathNext = NULL;
    struct stPath *pPathNextNode = NULL;

    // unsigned int iNodeNum = 0;
    for( ; pPathHeadTmp; pPathHeadTmp=pPathHeadTmp->next )
    {
        // iNodeNum = 0;

        // 循环Tree下每1条路径
        pPathNext = pPathHeadTmp->pPathList;
        for( ; pPathNext; pPathNext=pPathNext->next )
        {
            // 循环每1条路径的并行
            pPathNextNode = pPathNext;
            for( ; pPathNextNode; pPathNextNode=pPathNextNode->nextNode )
            {
                struct stString * pNew = getStringNode();
                memset(pNew, 0x00, sizeof(struct stString));
                pNew->pStr = pPathNextNode->pOneTreeCplLevel->pKeyword;
                pNew->iStrLen = pPathNextNode->pOneTreeCplLevel->iKeywordLen;
                pNew->pp = pPathHeadTmp;
                pNew->cFlag = pPathNext->pOneTreeCplLevel->cSplitFlag;  // is pPathNext not pPathNextNode

                // 无实际用途
                // pNew->iNum = iNodeNum;

                if( pPathNextNode->pOneTreeCplLevel->cType == TYPE_CONT )
                {
                    pNew->next = pPathHeadList4Cont;
                    pPathHeadList4Cont = pNew;
                }
                else if( pPathNextNode->pOneTreeCplLevel->cType == TYPE_STR )
                {
                    pNew->next = pPathHeadList4Str;
                    pPathHeadList4Str = pNew;
                }
                else if( pPathNextNode->pOneTreeCplLevel->cType == TYPE_PATH )
                {
                    pNew->next = pPathHeadList4Tree;
                    pPathHeadList4Tree = pNew;
                }
                else if( pPathNextNode->pOneTreeCplLevel->cType == TYPE_EXPR )
                {
                    pNew->next = pPathHeadList4Line;
                    pPathHeadList4Line = pNew;
                }
                else if( pPathNextNode->pOneTreeCplLevel->cType == TYPE_B )
                {
                    pNew->next = pPathHeadList4B;
                    pPathHeadList4B = pNew;
                }
                else if( pPathNextNode->pOneTreeCplLevel->cType == TYPE_T )
                {
                    pNew->next = pPathHeadList4T;
                    pPathHeadList4T = pNew;
                }
                else if( pPathNextNode->pOneTreeCplLevel->cType == TYPE_N )
                {
                    pNew->next = pPathHeadList4N;
                    pPathHeadList4N = pNew;
                }
                else if( pPathNextNode->pOneTreeCplLevel->cType == TYPE_BLANK )
                {
                    pNew->next = pPathHeadList4Blank;
                    pPathHeadList4Blank = pNew;
                }
                else if( pPathNextNode->pOneTreeCplLevel->cType == TYPE_ANY )
                {
                    pNew->next = pPathHeadList4Any;
                    pPathHeadList4Any = pNew;
                }
                else
                {
                    printf("Something error [makePathHeadListByType] 222\n");
                    return false;
                }

                if( pPathNextNode->nextNode == NULL || pPathNextNode->nextNode->pOneTreeCplLevel->cSplitFlag != '+' )
                    break;
            }
        }
    }

/***************************************************
struct stString *pTmp = NULL;

printf("pPathHeadList4Any\n");
pTmp = pPathHeadList4Any;
for( ; pTmp; pTmp=pTmp->next ) {
    // printf("%c %d", pTmp->cFlag, pTmp->iNum);
    printf("%c ", pTmp->cFlag);
    printStrForDebug("", pTmp->pStr, pTmp->iStrLen );
}
printf("pPathHeadList4Blank\n");
pTmp = pPathHeadList4Blank;
for( ; pTmp; pTmp=pTmp->next ) {
    // printf("%c %d", pTmp->cFlag, pTmp->iNum);
    printf("%c ", pTmp->cFlag);
    printStrForDebug("", pTmp->pStr, pTmp->iStrLen );
}
printf("pPathHeadList4Cont\n");
pTmp = pPathHeadList4Cont;
for( ; pTmp; pTmp=pTmp->next ) {
    // printf("%c %d", pTmp->cFlag, pTmp->iNum);
    printf("%c ", pTmp->cFlag);
    printStrForDebug("", pTmp->pStr, pTmp->iStrLen );
}
printf("pPathHeadList4Tree\n");
pTmp = pPathHeadList4Tree;
for( ; pTmp; pTmp=pTmp->next ) {
    // printf("%c %d", pTmp->cFlag, pTmp->iNum);
    printStrForDebug("", pTmp->pStr, pTmp->iStrLen );
    printf("%c ", pTmp->cFlag);
}
printf("pPathHeadList4Line\n");
pTmp = pPathHeadList4Line;
for( ; pTmp; pTmp=pTmp->next ) {
    // printf("%c %d", pTmp->cFlag, pTmp->iNum);
    printf("%c ", pTmp->cFlag);
    printStrForDebug("", pTmp->pStr, pTmp->iStrLen );
}
printf("pPathHeadList4Str\n");
pTmp = pPathHeadList4Str;
for( ; pTmp; pTmp=pTmp->next ) {
    // printf("%c %d", pTmp->cFlag, pTmp->iNum);
    printf("%c ", pTmp->cFlag);
    printStrForDebug("", pTmp->pStr, pTmp->iStrLen );
}
/***************************************************/

    return true;
}

bool CZGLanguage::isCanSplitHere4LineCpl(char *pp)
{
    if( *pp != ' ' && *pp != '\t' && *pp != '\r' && *pp != '\n' || *pp != '\0' )
    {
        if( ( *(pp-1) >= 'a' && *(pp-1) <= 'z' ) || ( *(pp-1) >= 'A' && *(pp-1) <= 'Z' )
         || ( *(pp-1) >= '0' && *(pp-1) <= '9' )
         || *(pp-1) == '_' || *(pp-1) == '$' || *(pp-1) < 0 )
        {
            if( ( *pp >= 'a' && *pp <= 'z' ) || ( *pp >= 'A' && *pp <= 'Z' )
             || ( *pp >= '0' && *pp <= '9' )
             || *pp == '_' || *pp == '$' || *pp < 0 )
            {
                return false;
            }
        }
    }

    return true;
}

unsigned int CZGLanguage::getStrObjLen(struct stStr *pStrObj, char *pp)
{
// printf("getStrObjLen = %c\n", *pText);  // debug

    unsigned int iLen = 0;
    struct stStrLevel *pStrLevel = pStrObj->pstStrLevelList;

    for( ; pStrLevel; pStrLevel=pStrLevel->next )
    {
        unsigned int iLvlLen = 0;

        for( ; (*pp < 0 && pStrLevel->mMap[128]) || (*pp > 0 && pStrLevel->mMap[*pp]); pp ++ )
        {
// printf("*pp = [%c]\n", *pp);   // debug
            iLvlLen ++ ;

            if( iLvlLen == pStrLevel->iMaxLen )
            {
                pp ++ ;
                break ;
            }
        }
// printf("iLvlLen=%d, iMinLen=%d, iMaxLen=%d\n", iLvlLen, pStrLevel->iMinLen, pStrLevel->iMaxLen);  // debug

        if( iLvlLen >= pStrLevel->iMinLen && iLvlLen <= pStrLevel->iMaxLen )
            iLen += iLvlLen;
        else
            return 0;
    }
// printf("iLen = [%d]\n", iLen);   // debug

    struct stString * pNoKeyWordTmp = pStrObj->pNoKeyWord;
    for( ; pNoKeyWordTmp; pNoKeyWordTmp=pNoKeyWordTmp->next )
    {
        if( iLen != pNoKeyWordTmp->iStrLen )
            continue ;

        if( ! isCaseSensitive ) {
            char * pSrc = pp - iLen;
            char * pTar = pNoKeyWordTmp->pStr;

            int i = iLen;
            for( ; i; i -- )
            {
                char cSrc = *pSrc >= 'a' && *pSrc <= 'z' ? (*pSrc) - 32 : *pSrc;
                char cTar = *pTar >= 'a' && *pTar <= 'z' ? (*pTar) - 32 : *pTar;

                if( cSrc == cTar ) {
                    pSrc ++ ;
                    pTar ++ ;
                } else
                    break ;
            }

            if( i == 0 )
                return 0;

        } else if( ! strncmp(pp-iLen, pNoKeyWordTmp->pStr, iLen) )
            return 0;
    }
// printf("iLen222 = [%d]\n", iLen);   // debug

    if( iLen >= pStrObj->iMinLen && iLen <= pStrObj->iMaxLen )
        return iLen;
    else
        return 0;
}

bool CZGLanguage::checkLineEnd(struct stPath *pLineEnd, unsigned int iPathY)
{
// printf("checkLineEnd [%p] !!!!!!!!!!!!!!!!!!!!!!!!!!\n", pLineEnd);  // debug

    if( ! pLineEnd )
        return false;

    char cSplitFlag = pLineEnd->pOneTreeCplLevel->cSplitFlag;  //  | or /
    struct stPath *pLineEndTmp = pLineEnd;

    char mBlankEnd[8];
    memset(mBlankEnd, 0x00, sizeof(mBlankEnd));

    while( true )
    {
/************************************************
printStrForDebug("pLineEndTmp END", pLineEndTmp->pOneTreeCplLevel->pKeyword, pLineEndTmp->pOneTreeCplLevel->iKeywordLen);  // debug
printf("Path x = [%c]\n", *(pLineEndTmp->pOneTreeCplLevel->pPathY + iPathY) );
if( pLineEndTmp->nextNode )
    printStrForDebug("pLineEndTmp nextNode", pLineEndTmp->nextNode->pOneTreeCplLevel->pKeyword, pLineEndTmp->nextNode->pOneTreeCplLevel->iKeywordLen);  // debug
/************************************************/

        if( pLineEndTmp->pOneTreeCplLevel->cType == TYPE_B )
        {
            mBlankEnd[0] = ' ';
            *(pLineEndTmp->pOneTreeCplLevel->pKeyword) = '\0';  // \0_\b__
        }
        else if( pLineEndTmp->pOneTreeCplLevel->cType == TYPE_T )
        {
            mBlankEnd[1] = '\t';
            *(pLineEndTmp->pOneTreeCplLevel->pKeyword) = '\0';  // \0_\t__
        }
        else if( pLineEndTmp->pOneTreeCplLevel->cType == TYPE_N )
        {
            mBlankEnd[2] = '\n';
            *(pLineEndTmp->pOneTreeCplLevel->pKeyword) = '\0';  // \0_\n__
        }
        else if( pLineEndTmp->pOneTreeCplLevel->cType == TYPE_BLANK )
        {
            mBlankEnd[3] = 'B';
            *(pLineEndTmp->pOneTreeCplLevel->pKeyword) = '\0';  // \0_BLANK__
        }

        if( pLineEndTmp->nextNode && pLineEndTmp->nextNode->pOneTreeCplLevel->cSplitFlag == '+' )
            pLineEndTmp = pLineEndTmp->nextNode;
        else if( pLineEndTmp->nextNode && (  *(pLineEndTmp->pOneTreeCplLevel->pPathY + iPathY) == 'e'
                                          || *(pLineEndTmp->pOneTreeCplLevel->pPathY + iPathY) == 'E') )
            pLineEndTmp = pLineEndTmp->nextNode;
        else
            break ;
    }

    //////////////////////////////////////////////////////////////////

    bool isLineEnd = false;

    if( *pText == ' ' && mBlankEnd[0] == ' ' )
    {
        isLineEnd = true;
    }
    else if( *pText == '\t' && mBlankEnd[1] == '\t' )
    {
        isLineEnd = true;
    }
    else if( (*pText == ' ' || *pText == '\t' || *pText == '\r' || *pText == '\n')  && mBlankEnd[2] == '\n' )
    {
        for( ; *pText == ' ' || *pText == '\t' || *pText == '\r'; pText ++ ); 

        if( *pText == '\n' || *pText == '\0' )
            isLineEnd = true;
    }
    else if( (*pText == ' ' || *pText == '\t' || *pText == '\r' || *pText == '\n')  && mBlankEnd[3] == 'B' )
    {
        isLineEnd = true;
    }

    if( isLineEnd )
    {
        pLineEndTmp = pLineEnd;

        while( true )
        {
            if( *(pLineEndTmp->pOneTreeCplLevel->pKeyword) == '\0' )
                *(pLineEndTmp->pOneTreeCplLevel->pKeyword) = '_';       // For : *(pLineEndTmp->pOneTreeCplLevel->pKeyword) = '\0'

            if( pLineEndTmp->nextNode && pLineEndTmp->nextNode->pOneTreeCplLevel->cSplitFlag == '+' )
                pLineEndTmp = pLineEndTmp->nextNode;
            else
                break ;
        }

        // return isLineEnd;
        return true;
    }

    ////////////////////////////////////////////////////////////
    // passKgf();
    passKgf_Comment();

    // 检查左右括号完整性
    // if( ( *pText == '(' || *pText == ')' ) && pstSubLineCountList->iNum )
    if( pstSubLineCountList->iNum )
        return false;

    pLineEndTmp = pLineEnd;

    while( true )
    {
        if( *(pLineEndTmp->pOneTreeCplLevel->pKeyword) == '\0' )
            *(pLineEndTmp->pOneTreeCplLevel->pKeyword) = '_';
        else if( ! isLineEnd && cmpStr(pText, pLineEndTmp->pOneTreeCplLevel->pKeyword, pLineEndTmp->pOneTreeCplLevel->iKeywordLen) )
        {
            isLineEnd = true;

            if( ! isCanSplitHere4LineCpl(pText) ) {
                isLineEnd = false;
            } else {
// printStrForDebug("The end of line", pLineEndTmp->pOneTreeCplLevel->pKeyword, pLineEndTmp->pOneTreeCplLevel->iKeywordLen);  // debug
                if( ATTR_NOT_EXPR_END & pLineEndTmp->pOneTreeCplLevel->iAttrFlag )
                {
                    pstSubLineCountList->cFlag = 1;
                    pstSubLineCountList->pp = pText;
                    return false;
                }

                return true;
            }
        }

/***********************************************
printf("\niPathY = %d\n", iPathY);  // debug
printf("Path x 222 = [%c]\n", *(pLineEndTmp->pOneTreeCplLevel->pPathY + iPathY) );
printStrForDebug("pLineEndTmp END 222", pLineEndTmp->pOneTreeCplLevel->pKeyword, pLineEndTmp->pOneTreeCplLevel->iKeywordLen);  // debug
printf("cSplitFlag = [%c]\n", pLineEndTmp->pOneTreeCplLevel->cSplitFlag);
***********************************************/

        if( pLineEndTmp->nextNode && pLineEndTmp->nextNode->pOneTreeCplLevel->cSplitFlag == '+' )
            pLineEndTmp = pLineEndTmp->nextNode;
        else if( pLineEndTmp->nextNode && (*(pLineEndTmp->pOneTreeCplLevel->pPathY + iPathY) == 'e' || *(pLineEndTmp->pOneTreeCplLevel->pPathY + iPathY) == 'E') ) {
            pLineEndTmp = pLineEndTmp->nextNode;
            cSplitFlag = pLineEndTmp->pOneTreeCplLevel->cSplitFlag;  //  | or /
        } else
            break ;
    }

    return isLineEnd;
}

// 处理 行 解析中的 左右括号
bool CZGLanguage::doWithLRkh4Line(struct stLine *pLineNode)
{
// printf("doWithLRkh4Line = !!!!!!!!!!!!!!!!!!!!\n");  // debug

    if( *pText == ')' )
    {
/*************************************
* 20230623
        if( pstSubLineCountList->iNum == 0 )
        {
            pText ++ ;
            return retErrInfo4CodeFile("Miss '(' for ')'");
        }
*************************************/

        // Check : ( NULL )
        struct stCompileInfo * pCompileInfoBf = (struct stCompileInfo *)(pstCompileInfoTail->pVal3);
        if( pCompileInfoBf->mType[IDX_LEFT_PARM] == '(' )
        {
            pText ++ ;
            return retErrInfo4CodeFile("Miss content before ')' !");
        }

        // Make : ( OneNode )   >>  OneNode
        pCompileInfoBf = (struct stCompileInfo *)(pCompileInfoBf->pVal3);
        if( pCompileInfoBf && pCompileInfoBf->mType[IDX_LEFT_PARM] == '(' )
        {
            if( pCompileInfoBf->pVal3 ) {
                pCompileInfoBf = (struct stCompileInfo *)(pCompileInfoBf->pVal3);
                pCompileInfoBf->next = pCompileInfoBf->next->next;    // pass (
                pCompileInfoBf->next->pVal3 = (char *)pCompileInfoBf;
            } else
                pCompileInfoBf->next->pVal3 = NULL;

            pstSubLineCountList->iNum -- ;
            pText ++ ;

            // 保存表达式最后非空字符信息
            mLastTextInfo4Expr.pTextBf = pText;
            mLastTextInfo4Expr.pLineHeadBf = pLineHead;
            mLastTextInfo4Expr.iLineHeadKgfBf = iLineHeadKgf;
            mLastTextInfo4Expr.iLineNumBf = iLineNum;
            mLastTextInfo4Expr.cCmpIndentFlagBf = cCmpIndentFlag;

            return true;
        }

        pstCompileInfoTail->mType[IDX_LEFT_PARM] = ')';
        pstCompileInfoTail->next =
        newCompileInfo4Line(
          'E'                   // char cObjType
        , pLineNode->pName      // char *pObjName
        , pLineNode->iNameLen   // unsigned int iObjNameLen
        );

        pstCompileInfoTail->next->pVal3 = (char *)pstCompileInfoTail;  // 当BEFORE用，形成双向链表
        pstCompileInfoTail = pstCompileInfoTail->next;

        pstSubLineCountList->iNum -- ;
        pText ++ ;
    }
    else // if( *pText == '(' )
    {
// printf("pstCompileInfoTail->mType[IDX_LEFT_PARM] = '('\n"); // debug

        pstCompileInfoTail->mType[IDX_LEFT_PARM] = '(';

        pstCompileInfoTail->next =
        newCompileInfo4Line(
          'E'                   // char cObjType
        , pLineNode->pName      // char *pObjName
        , pLineNode->iNameLen   // unsigned int iObjNameLen
        );

        pstCompileInfoTail->next->pVal3 = (char *)pstCompileInfoTail;  // 当BEFORE用，形成双向链表
        pstCompileInfoTail = pstCompileInfoTail->next;

        pstSubLineCountList->iNum ++ ;
        pText ++ ;
    }

    // 保存表达式最后非空字符信息
    mLastTextInfo4Expr.pTextBf = pText;
    mLastTextInfo4Expr.pLineHeadBf = pLineHead;
    mLastTextInfo4Expr.iLineHeadKgfBf = iLineHeadKgf;
    mLastTextInfo4Expr.iLineNumBf = iLineNum;
    mLastTextInfo4Expr.cCmpIndentFlagBf = cCmpIndentFlag;

    return true;
}

bool CZGLanguage::doWithOneLineNode
(
  struct stLine *pLineNode
, struct stPath *pLineEnd
, unsigned int iPathY
)
{

/********************************************************

                 END
                  *
                  |
--> BEF(0/N) --> ELE(1) --> AFT(0/N) --> END
     *                       |
     |                       |
     ----------- OPR(1) <-----

********************************************************/

// printf("doWithOneLineNode !!!!!!! [%c],[%d],[%d],[%c]\n", *pText, cTreeLevelType, pstCompileInfoTail->mType[IDX_LEFT_PARM], cSplitFlag);  // debug
// printStrForDebug("Tree of This Line", pstCompileInfoTail->pObjName, pstCompileInfoTail->iObjNameLen);  // debug

    bool isInDebugLimit = inDebugLimit(pstCompileInfoTail->pObjName, pstCompileInfoTail->iObjNameLen, iPathY+1);
    bool isDebug4ThisLine = isDebug && isInDebugLimit && ! iCloseDebugTimes;

    // 20220821
    for( pLineEnd = pLineEnd->nextNode
       ; pLineEnd && pLineEnd->pOneTreeCplLevel->cSplitFlag == '+'
       ; pLineEnd = pLineEnd->nextNode ) ;

    // Fork one Line info 
    pstCompileInfoTail->pFork = 
    newCompileInfo4Line( 
      'E'                   // char cObjType
    , pLineNode->pName      // char *pObjName
    , pLineNode->iNameLen   // unsigned int iObjNameLen
    );

    pstCompileInfoTail = pstCompileInfoTail->pFork;
    pstCompileInfoTail->next = 
    newCompileInfo4Line(
      'E'                  // char cObjType
    , pLineNode->pName     // char *pObjName
    , pLineNode->iNameLen  // unsigned int iObjNameLen
    );
    pstCompileInfoTail = pstCompileInfoTail->next;

    struct stLineLevel *pLineLevelTmp = NULL;
    bool isDone = false;

while( true )
{
    isDone = false;

    /////////////////////////////////////////////////////////////////
    // __SPL__
    /////////////////////////////////////////////////////////////////
    
    for( ; *pText == ' ' || *pText == '\t'; pText ++ );

    if( pLineNode->pSplit && ! strncmp(pText, pLineNode->pSplit, pLineNode->iSplitLen) )
    {
        if( *(pText+pLineNode->iSplitLen) == '\r' || *(pText+pLineNode->iSplitLen) == '\n' )
        {
            if( *(pText+pLineNode->iSplitLen) == '\r' )
                pText += pLineNode->iSplitLen + 2;
            else  // *(pText+pLineNode->iSplitLen) == '\n'
                pText += pLineNode->iSplitLen + 1;

            iLineNum ++ ;
            pLineHead = pText;
            iLineHeadKgf = 0;
            for(char *pTmp=pLineHead; *pTmp == ' ' || *pTmp == '\t'; pTmp ++ ) iLineHeadKgf ++ ;

            continue ;
        }
    }

    passKgf_Comment();

    /////////////////////////////////////////////////////////////////
    // __BEF__
    /////////////////////////////////////////////////////////////////
// printStrForDebug("__BEF__ pText", pText, 8);   // debug

    pLineLevelTmp = pLineNode->pstBefList;
    while( pLineLevelTmp )
    {
        struct stString * pContentTmp = pLineLevelTmp->pContentList;
        if( ! cmpStr(pText, pContentTmp->pStr, pContentTmp->iStrLen) )
        {
            pLineLevelTmp = pLineLevelTmp->next;
            continue ;
        }

        isDone = true;
// printStrForDebug("__BEF__", pText, pContentTmp->iStrLen);  // debug

        char *pTextSave = pText;

        pText += pContentTmp->iStrLen;

        pContentTmp = pContentTmp->next;
        for( ; pContentTmp; pContentTmp=pContentTmp->next )
        {
            if( ! isCanSplitHere4LineCpl(pText) )
            {
                isDone = false;
                break ;
            }

            passKgf_Comment();

            if( ! cmpStr(pText, pContentTmp->pStr, pContentTmp->iStrLen) )
            {
                isDone = false;
                break ;
            }
// printStrForDebug("__BEF__    ", pText, pContentTmp->iStrLen);  // debug

            pText += pContentTmp->iStrLen;

        } // for( ; pContentTmp; pContentTmp=pContentTmp->next )
        
        if( ! isCanSplitHere4LineCpl(pText) )
            isDone = false;

        if( isDone )
        {
            if( isDebug4ThisLine )
            {
                printf("%s __BEF__ :", pLineNode->pName);

                struct stString * pContentTmp = pLineLevelTmp->pContentList;
                for( ; pContentTmp; pContentTmp=pContentTmp->next )
                {
                    char cTmp = *(pContentTmp->pStr + pContentTmp->iStrLen);
                    *(pContentTmp->pStr+ pContentTmp->iStrLen) = '\0';
                    printf(" %s", pContentTmp->pStr);
                    *(pContentTmp->pStr + pContentTmp->iStrLen) = cTmp;
                }

                printf("\n\n");
            }

            pstCompileInfoTail->mType[IDX_LEFT_PARM] = 'B';    // __BEF__
            ((struct stCplInfo4Line *)(&(pstCompileInfoTail->pVal1)))->pOpr = pLineLevelTmp->pContentList;

            pstCompileInfoTail->pTranPartList4Line = pLineLevelTmp->pTranPartList;

            pstCompileInfoTail->next =
            newCompileInfo4Line(
             'E'                   // char cObjType
            , pLineNode->pName     // char *pObjName
            , pLineNode->iNameLen  // unsigned int iObjNameLen
            );
            pstCompileInfoTail->next->pVal3 = (char *)pstCompileInfoTail;  // 当BEFORE用，形成双向链表
            pstCompileInfoTail = pstCompileInfoTail->next;

            // 这里不能结束
            if( checkLineEnd(pLineEnd, iPathY) )
                return retErrInfo4CodeFile("Miss __ELE__ after __BEF__ !");

            pLineLevelTmp = pLineNode->pstBefList;  // Go back the first node

            passKgf_Comment();

            continue ;

        } // if( isDone )

        pText = pTextSave;
        pLineLevelTmp = pLineLevelTmp->next;

    } // while( pLineLevelTmp )

// printf("__BEF__ isDone = [%d]\n", isDone);  // debug
// printStrForDebug("pText", pText, 8);   // debug

    /////////////////////////////////////////////////////////////////
    // __ELE__
    /////////////////////////////////////////////////////////////////

    isDone = false;

    // Tree node
    pLineLevelTmp = pLineNode->pstEleList;
    for( ; pLineLevelTmp; pLineLevelTmp=pLineLevelTmp->next )
    {
// printStrForDebug("Tree ELE of Line", pLineLevelTmp->pContentList->pStr, pLineLevelTmp->pContentList->iStrLen);  // debug

        struct stCompileInfo * pCompileInfo4Next = pstCompileInfoTail;

        struct stTree * pOneTree = findTreeName(pLineLevelTmp->pContentList->pStr, pLineLevelTmp->pContentList->iStrLen);

        if( isFailText4ObjPoint(pOneTree) )
            continue ;

        if( compileTextByTree(pOneTree, NULL) )
        {
            pstCompileInfoTail = pCompileInfo4Next;

            pstCompileInfoTail->mType[IDX_LEFT_PARM] = 'P';    // Tree
            ((struct stCplInfo4Line *)(&(pstCompileInfoTail->pVal1)))->pLeftParm = pLineLevelTmp->pContentList->pStr;
            ((struct stCplInfo4Line *)(&(pstCompileInfoTail->pVal1)))->iLeftParmLen = pLineLevelTmp->pContentList->iStrLen;
            pstCompileInfoTail->pTranPartList4Line = pLineLevelTmp->pTranPartList;

            orderTreeNodeByPriority(pCompileInfo4Next);

            pstCompileInfoTail->next =
            newCompileInfo4Line(
              'E'                  // char cObjType
            , pLineNode->pName     // char *pObjName
            , pLineNode->iNameLen  // unsigned int iObjNameLen
            );
            pstCompileInfoTail->next->pVal3 = (char *)pstCompileInfoTail;  // 当BEFORE用，形成双向链表
            pstCompileInfoTail = pstCompileInfoTail->next;

            isDone = true;

            // 保存表达式最后非空字符信息
            mLastTextInfo4Expr.pTextBf = pText;
            mLastTextInfo4Expr.pLineHeadBf = pLineHead;
            mLastTextInfo4Expr.iLineHeadKgfBf = iLineHeadKgf;
            mLastTextInfo4Expr.iLineNumBf = iLineNum;
            mLastTextInfo4Expr.cCmpIndentFlagBf = cCmpIndentFlag;

            break ;
        }
        else
        {
            freeCompileInfoList( &(pCompileInfo4Next->pFork) );
            pstCompileInfoTail = pCompileInfo4Next;

            addFailText4ObjPoint(pOneTree);
        }
    }

// printf("Tree ELE of Line isDone=[%d]\n", isDone);  // debug
// printStrForDebug("\npText", pText, 8);   // debug

    // key word node
    if( ! isDone )
    {
        passKgf_Comment();

        pLineLevelTmp = pLineNode->pstContEleList;
        for( ; pLineLevelTmp; pLineLevelTmp=pLineLevelTmp->next )
        {
            if( cmpStr(pText, pLineLevelTmp->pContentList->pStr, pLineLevelTmp->pContentList->iStrLen)
             && isCanSplitHere4LineCpl(pText + pLineLevelTmp->pContentList->iStrLen) )
            {
// printStrForDebug("CONT ELE of Line", pText, pLineLevelTmp->pContentList->iStrLen);  // debug
                if( isDebug4ThisLine )
                {
                    char cTmp = *(pText + pLineLevelTmp->pContentList->iStrLen); 
                    *(pText + pLineLevelTmp->pContentList->iStrLen) = '\0'; 
                    printf("%s __ELE__ : %s\n\n", pLineNode->pName, pText);
                    *(pText + pLineLevelTmp->pContentList->iStrLen) = cTmp; 
                }

                pstCompileInfoTail->mType[IDX_LEFT_PARM] = 'C';    // CONT ELE
                ((struct stCplInfo4Line *)(&(pstCompileInfoTail->pVal1)))->pLeftParm = pText;
                ((struct stCplInfo4Line *)(&(pstCompileInfoTail->pVal1)))->iLeftParmLen = pLineLevelTmp->pContentList->iStrLen;
                pstCompileInfoTail->pTranPartList4Line = pLineLevelTmp->pTranPartList;

                pstCompileInfoTail->next =
                newCompileInfo4Line(
                  'E'                  // char cObjType
                , pLineNode->pName     // char *pObjName
                , pLineNode->iNameLen  // unsigned int iObjNameLen
                );
                pstCompileInfoTail->next->pVal3 = (char *)pstCompileInfoTail;  // 当BEFORE用，形成双向链表
                pstCompileInfoTail = pstCompileInfoTail->next;

                pText += pLineLevelTmp->pContentList->iStrLen;
                isDone = true;

                // 保存表达式最后非空字符信息
                mLastTextInfo4Expr.pTextBf = pText;
                mLastTextInfo4Expr.pLineHeadBf = pLineHead;
                mLastTextInfo4Expr.iLineHeadKgfBf = iLineHeadKgf;
                mLastTextInfo4Expr.iLineNumBf = iLineNum;
                mLastTextInfo4Expr.cCmpIndentFlagBf = cCmpIndentFlag;

                break ;
            }
        }
    }
// printf("CONT ELE of Line isDone=[%d]\n", isDone);  // debug
// printStrForDebug("\npText", pText, 8);   // debug

    // Str node
    if( ! isDone )
    {
        passKgf_Comment();

        pLineLevelTmp = pLineNode->pstStrEleList;
        for( ; pLineLevelTmp; pLineLevelTmp=pLineLevelTmp->next )
        {
// printStrForDebug("Str ELE of Line", pLineLevelTmp->pContentList->pStr, pLineLevelTmp->pContentList->iStrLen);  // debug
            struct stStr *pStrTmp = findStrName(pLineLevelTmp->pContentList->pStr, pLineLevelTmp->pContentList->iStrLen);
            if( ! pStrTmp )
                continue ;

            unsigned int iLen = getStrObjLen(pStrTmp, pText);
            if( iLen )
            {
// printStrForDebug("STR ele of Line", pText, iLen);   // debug
                if( isDebug4ThisLine )
                {
                    char cTmp = *(pLineLevelTmp->pContentList->pStr + pLineLevelTmp->pContentList->iStrLen);
                    *(pLineLevelTmp->pContentList->pStr + pLineLevelTmp->pContentList->iStrLen) = '\0';

                    char cTmp2 = *(pText + iLen);
                    *(pText + iLen) = '\0';

                    printf("%s __ELE__ : %s : %s\n\n", pLineNode->pName, pLineLevelTmp->pContentList->pStr, pText);

                    *(pLineLevelTmp->pContentList->pStr + pLineLevelTmp->pContentList->iStrLen) = cTmp;
                    *(pText + iLen) = cTmp2;
                }

                pstCompileInfoTail->mType[IDX_LEFT_PARM] = 'S';
                pstCompileInfoTail->pStrType = pLineLevelTmp->pContentList->pStr;
                pstCompileInfoTail->iStrTypeLen = pLineLevelTmp->pContentList->iStrLen;
                pstCompileInfoTail->pTranPartList4Line = pLineLevelTmp->pTranPartList;

                ((struct stCplInfo4Line *)(&(pstCompileInfoTail->pVal1)))->pLeftParm = pText;
                ((struct stCplInfo4Line *)(&(pstCompileInfoTail->pVal1)))->iLeftParmLen = iLen;

                pstCompileInfoTail->next =
                newCompileInfo4Line(
                  'E'                  // char cObjType
                , pLineNode->pName     // char *pObjName
                , pLineNode->iNameLen  // unsigned int iObjNameLen
                );
                pstCompileInfoTail->next->pVal3 = (char *)pstCompileInfoTail;  // 当BEFORE用，形成双向链表
                pstCompileInfoTail = pstCompileInfoTail->next;

                pText += iLen;
                isDone = true;

                // 保存表达式最后非空字符信息
                mLastTextInfo4Expr.pTextBf = pText;
                mLastTextInfo4Expr.pLineHeadBf = pLineHead;
                mLastTextInfo4Expr.iLineHeadKgfBf = iLineHeadKgf;
                mLastTextInfo4Expr.iLineNumBf = iLineNum;
                mLastTextInfo4Expr.cCmpIndentFlagBf = cCmpIndentFlag;

                // 20231119  防止循环获得多个连续的 __ELE__
                break ;
            }
        }
    } // if( ! isDone )

// printf("STR ele of Line = [%d]\n", isDone);
// printStrForDebug("pText", pText, 8);   // debug

// 20230618
    // 之前得 __BEF__ , __ELE__ 先判断小括号是否是定义内容
    // 如果之前不是，再判断其为运算小括号
    if( ! isDone && *pText == '(' )
    {
        while( *pText == '(' )
        {
            if( ! doWithLRkh4Line(pLineNode) )
                return false;

            // 这里不能结束
            if( checkLineEnd(pLineEnd, iPathY) )
                return retErrInfo4CodeFile("Miss content for the expr object !");

            passKgf_Comment();
        }

        if( *pText == ')' )
            return retErrInfo4CodeFile("Miss content before ')' !");

        // 如果是运输小括号，返回继续运算
        continue ;
    }

    if( ! isDone )
    {
// printf("pstCompileInfoTail->pVal3 = %p\n", pstCompileInfoTail->pVal3);
        if( pstCompileInfoTail->pVal3 )
        {
            if( ! pstSubLineCountList->cFlag )
                return retErrInfo4CodeFile("Miss __ELE__ here !");

            // 回退到前1个节点的位置
            pstCompileInfoTail = (struct stCompileInfo *)(pstCompileInfoTail->pVal3);  // go before
            freeCompileInfoNode(&(pstCompileInfoTail->next));
            pText = (char *)(pstSubLineCountList->pp);    // 回退pText
            return true;
        }
        else
            return retWarnInfo4CodeFile("Miss content for the expr object !");
    }

    ////////////////////////////////////////////

// printf("11111111111111111111111111111 = [%d][%c]\n", pstSubLineCountList->iNum, *pText);
    // if line end ?
    // 里面处理了 右括号) 的情况 : pstSubLineCountList->iNum > 0 时，return false
    if( checkLineEnd(pLineEnd, iPathY) )
        return true;

    // 若 __ELE__ 后面直接跟 左括号是错误的
    if( *pText == '(' )
    {
        pText ++ ;
        return retErrInfo4CodeFile("Can not be '(' after __ELE__");
    }
    else if( *pText == ')' ) 
    {
        // 20230623，行结束
        if( pstSubLineCountList->iNum == 0 )
            return true;

        while( *pText == '(' || *pText == ')' )
        {
            if( ! doWithLRkh4Line(pLineNode) )
                return false;

            if( checkLineEnd(pLineEnd, iPathY) )
                return true;

            passKgf_Comment();
        }
    }
// printf("333333333333333333333333 = [%d]\n", pstSubLineCountList->iNum);

    //////////////////////////////////////////////////
    // __AFT__
    //////////////////////////////////////////////////
    isDone = false;
    passKgf_Comment();

    pLineLevelTmp = pLineNode->pstAftList;
    while( pLineLevelTmp )
    {
        struct stString * pContentTmp = pLineLevelTmp->pContentList;
        if( ! cmpStr(pText, pContentTmp->pStr, pContentTmp->iStrLen) )
        {
            pLineLevelTmp = pLineLevelTmp->next;
            continue ;
        }

        isDone = true;
// printStrForDebug("__AFT__", pText, pContentTmp->iStrLen);  // debug

        char *pTextSave = pText;

        pText += pContentTmp->iStrLen;

        pContentTmp = pContentTmp->next;
        for( ; pContentTmp; pContentTmp=pContentTmp->next )
        {
            if( ! isCanSplitHere4LineCpl(pText) )
            {
                isDone = false;
                break ;
            }

            passKgf_Comment();

            if( ! cmpStr(pText, pContentTmp->pStr, pContentTmp->iStrLen) )
            {
                isDone = false;
                break ;
            }
// printStrForDebug("__AFT__    ", pText, pContentTmp->iStrLen);  // debug

            pText += pContentTmp->iStrLen;

        } // for( ; pContentTmp; pContentTmp=pContentTmp->next )

        if( ! isCanSplitHere4LineCpl(pText) )
            isDone = false;

        if( isDone )
        {
            if( isDebug4ThisLine )
            {
                printf("%s __AFT__ :", pLineNode->pName);

                struct stString * pContentTmp = pLineLevelTmp->pContentList;
                for( ; pContentTmp; pContentTmp=pContentTmp->next )
                {
                    char cTmp = *(pContentTmp->pStr + pContentTmp->iStrLen);
                    *(pContentTmp->pStr+ pContentTmp->iStrLen) = '\0';
                    printf(" %s", pContentTmp->pStr);
                    *(pContentTmp->pStr + pContentTmp->iStrLen) = cTmp;
                }

                printf("\n\n");
            }

            pstCompileInfoTail->mType[IDX_LEFT_PARM] = 'A';    // __AFT__
            ((struct stCplInfo4Line *)(&(pstCompileInfoTail->pVal1)))->pOpr = pLineLevelTmp->pContentList;
            pstCompileInfoTail->pTranPartList4Line = pLineLevelTmp->pTranPartList;

            pstCompileInfoTail->next =
            newCompileInfo4Line(
             'E'                   // char cObjType
            , pLineNode->pName     // char *pObjName
            , pLineNode->iNameLen  // unsigned int iObjNameLen
            );  
            pstCompileInfoTail->next->pVal3 = (char *)pstCompileInfoTail;  // 当BEFORE用，形成双向链表
            pstCompileInfoTail = pstCompileInfoTail->next;

            // 保存表达式最后非空字符信息
            mLastTextInfo4Expr.pTextBf = pText;
            mLastTextInfo4Expr.pLineHeadBf = pLineHead;
            mLastTextInfo4Expr.iLineHeadKgfBf = iLineHeadKgf;
            mLastTextInfo4Expr.iLineNumBf = iLineNum;
            mLastTextInfo4Expr.cCmpIndentFlagBf = cCmpIndentFlag;

            // if line end ?
            if( checkLineEnd(pLineEnd, iPathY) )
                return true;

            ///////////////////////////////////

            // 处理左右括号
            while( *pText == ')' )
            {
                // 20230623，行结束
                if( pstSubLineCountList->iNum == 0 )
                    return true;

                if( ! doWithLRkh4Line(pLineNode) )
                    return false;

                if( checkLineEnd(pLineEnd, iPathY) )
                    return true;

                passKgf_Comment();
            }

            // Check : ( __AFT__ ...
            struct stCompileInfo * pCompileInfoBf = (struct stCompileInfo *)(pstCompileInfoTail->pVal3);  // __AFT__
            pCompileInfoBf = (struct stCompileInfo *)(pCompileInfoBf->pVal3);
            if( pCompileInfoBf->mType[IDX_LEFT_PARM] == '(' )
            {
                pText ++ ;
                return retErrInfo4CodeFile("Miss ')' after '__AFT__' !");
            }

            while( *pText == '(' )
            {
                if( ! doWithLRkh4Line(pLineNode) )
                    return false;

                if( checkLineEnd(pLineEnd, iPathY) )
                    return true;

                passKgf_Comment();
            }

            pLineLevelTmp = pLineNode->pstAftList;  // Go back the first node
            passKgf_Comment();

            continue ;
        }

        pText = pTextSave;
        pLineLevelTmp = pLineLevelTmp->next;

    } // while( pLineLevelTmp )

// printf("__AFT__ isDone = [%d]\n", isDone);  // debug
// printStrForDebug("pText", pText, 8);   // debug

    // if line end ?
    // 里面处理了 右括号) 的情况 : pstSubLineCountList->iNum > 0 时，return false
    if( checkLineEnd(pLineEnd, iPathY) )
        return true;

    //////////////////////////////////////////////////
    // __OPR__
    //////////////////////////////////////////////////

    while( true )
    {

    isDone = false;
    passKgf_Comment();

    pLineLevelTmp = pLineNode->pstOprList;
    for( ; pLineLevelTmp; pLineLevelTmp=pLineLevelTmp->next )
    {
        struct stString * pContentTmp = pLineLevelTmp->pContentList;
        if( ! cmpStr(pText, pContentTmp->pStr, pContentTmp->iStrLen) )
            continue ;

        isDone = true;
// printStrForDebug("__OPR__", pText, pContentTmp->iStrLen);  // debug

        char *pTextSave = pText;

        pText += pContentTmp->iStrLen;

        pContentTmp = pContentTmp->next;
        // for( ; pContentTmp && pContentTmp->next; pContentTmp=pContentTmp->next )  // 20230416
        for( ; pContentTmp; pContentTmp=pContentTmp->next )
        {
            if( *pText != ' ' && *pText != '\t' && *pText != '\r' && *pText != '\n' )
            {
                isDone = false;
                break ;
            }

            passKgf_Comment();

            if( ! cmpStr(pText, pContentTmp->pStr, pContentTmp->iStrLen) )
            {
                isDone = false;
                break ;
            }
// printStrForDebug("__OPR__    ", pText, pContentTmp->iStrLen);  // debug

            pText += pContentTmp->iStrLen;
        }

        if( ! isCanSplitHere4LineCpl(pText) )
            isDone = false;

        if( isDone )
        {
            if( isDebug4ThisLine )
            {
                printf("%s __OPR__ :", pLineNode->pName);

                struct stString * pContentTmp = pLineLevelTmp->pContentList;
                for( ; pContentTmp; pContentTmp=pContentTmp->next )
                {
                    char cTmp = *(pContentTmp->pStr + pContentTmp->iStrLen);
                    *(pContentTmp->pStr+ pContentTmp->iStrLen) = '\0';
                    printf(" %s", pContentTmp->pStr);
                    *(pContentTmp->pStr + pContentTmp->iStrLen) = cTmp;
                }

                printf("\n\n");
            }

            pstCompileInfoTail->mType[IDX_LEFT_PARM] = 'O';    // __OPR__
            ((struct stCplInfo4Line *)(&(pstCompileInfoTail->pVal1)))->pOpr = pLineLevelTmp->pContentList;
/******************************************
// 20230416
            *(pContentTmp->pStr + pContentTmp->iStrLen) = '\0';
            ((struct stCplInfo4Line *)(&(pstCompileInfoTail->pVal1)))->iOprPriority = atoi(pContentTmp->pStr);
******************************************/
            ((struct stCplInfo4Line *)(&(pstCompileInfoTail->pVal1)))->iOprPriority = pLineLevelTmp->iPriority;
            pstCompileInfoTail->pTranPartList4Line = pLineLevelTmp->pTranPartList;

            pstCompileInfoTail->next =
            newCompileInfo4Line(
             'E'                   // char cObjType
            , pLineNode->pName     // char *pObjName
            , pLineNode->iNameLen  // unsigned int iObjNameLen
            );  
            pstCompileInfoTail->next->pVal3 = (char *)pstCompileInfoTail;  // 当BEFORE用，形成双向链表
            pstCompileInfoTail = pstCompileInfoTail->next;

            // 保存表达式最后非空字符信息
            mLastTextInfo4Expr.pTextBf = pText;
            mLastTextInfo4Expr.pLineHeadBf = pLineHead;
            mLastTextInfo4Expr.iLineHeadKgfBf = iLineHeadKgf;
            mLastTextInfo4Expr.iLineNumBf = iLineNum;
            mLastTextInfo4Expr.cCmpIndentFlagBf = cCmpIndentFlag;

            break;
        }

        pText = pTextSave;

    } // for( ; pLineLevelTmp; pLineLevelTmp=pLineLevelTmp->next )

// printf("\n__OPR__ done = [%d]\n", isDone);  // debug
// printStrForDebug("pText", pText, 8);   // debug

    if( ! isDone )
    {
        if( pstSubLineCountList->iNum == 0 )
        {
            // 换行符
            if( pLineNode->pSplit && ! strncmp(pText, pLineNode->pSplit, pLineNode->iSplitLen) )
            {
                if( *(pText+pLineNode->iSplitLen) == '\r' || *(pText+pLineNode->iSplitLen) == '\n' )
                {
                    if( *(pText+pLineNode->iSplitLen) == '\r' )
                        pText += pLineNode->iSplitLen + 2; 
                    else  // *(pText+pLineNode->iSplitLen) == '\n' 
                        pText += pLineNode->iSplitLen + 1; 

                    iLineNum ++ ; 
                    pLineHead = pText;
                    iLineHeadKgf = 0; 
                    for(char *pTmp=pLineHead; *pTmp == ' ' || *pTmp == '\t'; pTmp ++ ) iLineHeadKgf ++ ; 

                    continue ;
                }
            }

            return true;
        }

        // 缺失括号
        if( *pText != ')' )
            return retErrInfo4CodeFile("Miss ')' for '(' here !");

        // 由于括号的原因，没有获得 OPR，先处理跳过括号，重新尝试去获得OPR
        while( *pText == ')' )
        {
            if( ! doWithLRkh4Line(pLineNode) )
                return false;

            // if( checkLineEnd(pLineEnd, iPathY) )
                // return retErrInfo4CodeFile("Miss content after __OPR__");

            passKgf_Comment();
        }

        continue ;   // while(true)  for __OPR__
    }

    ///////////////////////////////////////////////

    while( *pText == ')' )
    {
        if( ! doWithLRkh4Line(pLineNode) )
            return false;

        if( checkLineEnd(pLineEnd, iPathY) )
            return retErrInfo4CodeFile("Miss content after __OPR__");

        passKgf_Comment();
    }

    // Check : ( __OPR__ ...
    struct stCompileInfo * pCompileInfoBf = (struct stCompileInfo *)(pstCompileInfoTail->pVal3);  // __OPR__
    pCompileInfoBf = (struct stCompileInfo *)(pCompileInfoBf->pVal3);
    if( pCompileInfoBf->mType[IDX_LEFT_PARM] == '(' )
    {
        pText ++ ;
        return retErrInfo4CodeFile("Miss ')' after '__OPR__' !");
    }

    break ;  // while(true)  for __OPR__

    } // while(true)

} // while( true )

    return false;
}

struct stCompileInfo * CZGLanguage::newCompileInfo4Tree
(
  char cObjType
, char cTreeLevelType
, char *pObjName
, unsigned int iObjNameLen
, unsigned int iPathY
, char *pOtherName
, unsigned int iOtherNameLen
, unsigned int iPriority
, struct stExprInfo * pAttrExpr
, char *pValue
, unsigned int iValueLen
, unsigned int iLoopCount4ShortPath
)
{
    struct stCompileInfo * pNew = getCompileInfoNode();
    memset(pNew, 0x00, sizeof(struct stCompileInfo));

    pNew->iLineNum = iLineNum;
    pNew->pLineHead = pLineHead;
    pNew->iLineHeadKgf = iLineHeadKgf;

    pNew->mType[IDX_OBJ] = cObjType;
    pNew->mType[IDX_TREE_LV_TYPE] = cTreeLevelType;
    pNew->pObjName = pObjName;
    pNew->iObjNameLen = iObjNameLen;
    pNew->iPriority = iPriority;
    pNew->pAttrExpr = pAttrExpr;
    pNew->iLoopCount4ShortPath = iLoopCount4ShortPath;

    ((struct stCplInfo4Tree *)(&(pNew->pVal1)))->iPathY = iPathY;
    ((struct stCplInfo4Tree *)(&(pNew->pVal1)))->pOtherName = pOtherName;
    ((struct stCplInfo4Tree *)(&(pNew->pVal1)))->iOtherNameLen = iOtherNameLen;
    ((struct stCplInfo4Tree *)(&(pNew->pVal1)))->pValue = pValue;
    ((struct stCplInfo4Tree *)(&(pNew->pVal1)))->iValueLen = iValueLen;

// printf("newCompileInfo4Tree ------------\n");
// printf("iLineNum = %d\n", iLineNum);
// printf("iLineHeadKgf = %d\n", iLineHeadKgf);

    return pNew;
}

struct stCompileInfo * CZGLanguage::newCompileInfo4Line
(
  char cObjType
, char *pObjName
, unsigned int iObjNameLen
)
{
    struct stCompileInfo * pNew = getCompileInfoNode();
    memset(pNew, 0x00, sizeof(struct stCompileInfo));

    pNew->iLineNum = iLineNum;
    pNew->pLineHead = pLineHead;
    pNew->iLineHeadKgf = iLineHeadKgf;

    pNew->mType[IDX_OBJ] = cObjType;
    pNew->pObjName = pObjName;
    pNew->iObjNameLen = iObjNameLen;

    return pNew;
}

bool CZGLanguage::inDebugLimit(char *pName, unsigned int iNameLen, unsigned int iPathY)
{
    if( ! pstDebugLimit )
        return true;

    bool isInLineNum = true;
    bool isExistsPathLimit = false;

    // 检查是否会指定行号内
    struct stString * pDebugLimitTmp = pstDebugLimit;
    for( ; pDebugLimitTmp; pDebugLimitTmp=pDebugLimitTmp->next )
    {
        if( pDebugLimitTmp->pStr )
        {
            isExistsPathLimit = true;
            continue ;
        }

        if( iLineNum < pDebugLimitTmp->iStrLen || iLineNum > pDebugLimitTmp->iNum )
            isInLineNum = false;
        else
        {
            isInLineNum = true;
            break ;
        }
    }

    if( ! isInLineNum )
        return false;

    if( ! isExistsPathLimit )
        return true;

    // 检查是否在指定路径内
    pDebugLimitTmp = pstDebugLimit;
    for( ; pDebugLimitTmp; pDebugLimitTmp=pDebugLimitTmp->next )
    {
        if( pDebugLimitTmp->pStr
         && iNameLen == pDebugLimitTmp->iStrLen && ! strncmp(pName, pDebugLimitTmp->pStr, iNameLen) 
         && (iPathY == pDebugLimitTmp->iNum || pDebugLimitTmp->iNum == 0) )
            return true;
    }

    return false;
}

bool CZGLanguage::isComment()
{
// printf("isComment !!!!!!!!!!!!! %p | %p | %p | %c\n", pText4FuzzyStart, pText4FuzzyEnd, pText,*pText); // debug
// printStrForDebug("pText4FuzzyStart", pText4FuzzyStart, 20);
// printStrForDebug("pText4FuzzyEnd", pText4FuzzyEnd, 20);

    if( pLineComment && ! strncmp(pText, pLineComment, iLineCommentLen) )
    {
        // 转换时，需要保留注释
        // 若内容回退，释放掉原来记录的注释信息
        if( pText < pstCommentListTail->pStr && pstCommentList->next )
        {
            freeStringList( &(pstCommentList->next) );
            pstCommentList->next = NULL;
            pstCommentListTail = pstCommentList;
        }

        // 非模糊解析模式，或非PassCode内容内的注释可以记录
        // if( ! isFuzzy || pText4FuzzyStart == pText4FuzzyEnd )
        if( ! isFuzzy || pText > pText4FuzzyEnd )
        {
            pstCommentListTail->next = getStringNode();
            pstCommentListTail = pstCommentListTail->next;
            memset(pstCommentListTail, 0x00, sizeof(struct stString));

            // 记录注释内容
            if( pText == pLineHead + iLineHeadKgf )
                pstCommentListTail->cFlag = TYPE_COMMENT_1_LINE_START;
            else
                pstCommentListTail->cFlag = TYPE_COMMENT_1_LINE_END;

            pText += iLineCommentLen;
            pstCommentListTail->pStr = pText;

            // 跳过注释
            for( ; *pText != '\n' && *pText != '\0'; pText ++ );
            if( *pText == '\n')
            {
                doWithFh();
                pText ++ ;
            }

            if( *(pText-2) == '\r' )
                pstCommentListTail->iStrLen = pText - pstCommentListTail->pStr - 2;    // 剔除 \r\n
            else
                pstCommentListTail->iStrLen = pText - pstCommentListTail->pStr - 1;    // 剔除 \n
        }
        else
        {
            pText += iLineCommentLen;

            // 跳过注释
            for( ; *pText != '\n' && *pText != '\0'; pText ++ );
            if( *pText == '\n') {
                doWithFh();
                pText ++ ;
            }
        }

// printf("One line comment : pstCommentListTail->pStr=%p, pstCommentListTail->iStrLen=%d\n", pstCommentListTail->pStr, pstCommentListTail->iStrLen);
// printStrForDebug("One line comment", pstCommentListTail->pStr, pstCommentListTail->iStrLen);
// printf("pstCommentListTail->cFlag = %d\n", pstCommentListTail->cFlag);
        return true;
    }
    else if( pLinesCommentStart && ! strncmp(pText, pLinesCommentStart, iLinesCommentStartLen) )
    {
// printStrForDebug("pLineHead", pLineHead, iLineHeadKgf + 4);
        // 转换时，需要保留注释
        // 若内容回退，释放掉原来记录的注释信息
        if( pText < pstCommentListTail->pStr && pstCommentList->next )
        {
            freeStringList( &(pstCommentList->next) );
            pstCommentList->next = NULL;
            pstCommentListTail = pstCommentList;
        }

        // 非模糊解析模式，或非PassCode内容内的注释可以记录
        if( ! isFuzzy || pText > pText4FuzzyEnd )
        {
            pstCommentListTail->next = getStringNode();
            pstCommentListTail = pstCommentListTail->next;
            memset(pstCommentListTail, 0x00, sizeof(struct stString));

            // 记录注释内容
            if( pText == pLineHead + iLineHeadKgf )
                pstCommentListTail->cFlag = TYPE_COMMENT_N_LINE_START;
            else
                pstCommentListTail->cFlag = TYPE_COMMENT_N_LINE_END;

            pText += iLinesCommentStartLen;
            pstCommentListTail->pStr = pText;

            // 跳过注释
            // pText += iLinesCommentStartLen;     // 20240502
            for( ; *pText; pText ++ )
            {
                if( *pText == '\n' )
                    doWithFh();
                else if( ! strncmp(pText, pLinesCommentEnd, iLinesCommentEndLen) )
                    break ;
            }

            pstCommentListTail->iStrLen = pText - pstCommentListTail->pStr;
  
            if( *pText )
                pText += iLinesCommentEndLen;
        }
        else
        {
            // pText += iLinesCommentStartLen;  // 20240502

            // 跳过注释
            pText += iLinesCommentStartLen;
            for( ; *pText; pText ++ ) {
                if( *pText == '\n' )
                    doWithFh();
                else if( ! strncmp(pText, pLinesCommentEnd, iLinesCommentEndLen) )
                    break ;
            }

            if( *pText )
                pText += iLinesCommentEndLen;
        }

// printf("lines comment : pstCommentListTail->pStr=%p, pstCommentListTail->iStrLen=%d\n", pstCommentListTail->pStr, pstCommentListTail->iStrLen);
// printStrForDebug("lines comment", pstCommentListTail->pStr, pstCommentListTail->iStrLen);
// printf("pstCommentListTail->cFlag = %d\n", pstCommentListTail->cFlag);

        return true;
    }

    return false;
}

bool CZGLanguage::go2NodesOfOneShortPath
(
  struct stPath * pPathNextNode
, unsigned int iPathY
, bool *isNLoop
, unsigned int iLoopCount
, unsigned int * iSkipNodeCount
)
{
// printf("go2NodesOfOneShortPath function [%c] [%p] [%p] [%d] [%c] !!!!!!!!!!!\n", *pText, pstIndentHead, pstIndentTail, cTreeLevelType, pPathNextNode->pOneTreeCplLevel->cSplitFlag);  // debug
// printf("\ngo2NodesOfOneShortPath cCmpIndentFlag : [%d] | bef Indent : [%d] | aft Indent : [%d + %d] | iDoWithOneLineNodeCount=%d | pLineHead=%p | pText = %p | iLineHeadKgf=%d | iLineNum=%d | pstCompileInfoTail=%p | isNLoop=%d | cSplitFlag=[%c] | cTreeLevelType=%d | *pText=[%c]\n", cCmpIndentFlag, pstIndentTail->iEtcIdnNum, pstIndentSum4GoNextTree4Cpl->iNum, pPathNextNode->pOneTreeCplLevel->iIndent, iDoWithOneLineNodeCount, pLineHead, pText, iLineHeadKgf, iLineNum, pstCompileInfoTail, *isNLoop, cSplitFlag, cTreeLevelType, *pText);   // debug
    unsigned int iRightNodeCount4OneShortPath = 0;
    char cCmpIndentFlagSave = cCmpIndentFlag;
    bool isRightIndent = true;

    cTreeLevelType = pPathNextNode->pOneTreeCplLevel->cType;

    if( *pText == '\0' )
    {
        // 需要检查后续节点是否 可跳过CAN_SKIP
    }
    else if( cSplitFlag == '/' 
     && cTreeLevelType != TYPE_B && cTreeLevelType != TYPE_T && cTreeLevelType != TYPE_N 
     && cTreeLevelType != TYPE_BLANK && cTreeLevelType != TYPE_ANY )
    {
        char * pTextBf = pText;
        char * pLineHeadBf = pLineHead;
        unsigned int iLineHeadKgfBf = iLineHeadKgf;
        unsigned int iLineNumBf = iLineNum;
        char cCmpIndentFlagBf = cCmpIndentFlag;

        passKgf_Comment();

        // if( pLineHead + iLineHeadKgf == pText )
        if( iLineNumBf != iLineNum )
        {
            pText = pTextBf;
            pLineHead = pLineHeadBf;
            iLineHeadKgf = iLineHeadKgfBf;
            iLineNum = iLineNumBf;
            cCmpIndentFlag = cCmpIndentFlagBf;

            // 可跳过
            if( ATTR_CAN_SKIP & pPathNextNode->pOneTreeCplLevel->iAttrFlag ) {
                isRightIndent = false;
                // (*iSkipNodeCount) ++ ;
            } else if( pText > pTextBfGoBack ) {
                pTextBfGoBack = pText;
                return false;
            } else
                return false;
        }
    }
    else if( cSplitFlag == '\\'
     && cTreeLevelType != TYPE_B && cTreeLevelType != TYPE_T && cTreeLevelType != TYPE_N 
     && cTreeLevelType != TYPE_BLANK && cTreeLevelType != TYPE_ANY )
    {
        if( *pText == ' ' || *pText == '\t' || *pText == '\n' || *pText == '\r' )
        {
            // 可跳过
            if( ATTR_CAN_SKIP & pPathNextNode->pOneTreeCplLevel->iAttrFlag ) {
                isRightIndent = false;
                // (*iSkipNodeCount) ++ ;
            } else if( pText > pTextBfGoBack ) {
                pTextBfGoBack = pText;
                return false;
            } else
                return false;
        }
    }
    // 缩进敏感  cSplitFlag == |
    else if( (cIndentType == INDENT_COMPILER || cIndentType == INDENT_COMPILER_TRANSLATOR)
     && !(ATTR_SKIP_INDENT & pPathNextNode->pOneTreeCplLevel->iAttrFlag) 
     && ! iDoWithOneLineNodeCount && ! iCount4SkipIndentTree
     && passKgf_Comment()   // 20231112
     && (pLineHead == pText || pLineHead + iLineHeadKgf == pText) )  // 要刚刚分行完才需要做缩进是否正确的判断
    {
        unsigned int iPathNextNodeIndent = pPathNextNode->pOneTreeCplLevel->iIndent + pstIndentSum4GoNextTree4Cpl->iNum;
// printf("cSplitFlag == | : cCmpIndentFlag=%d, iEtcIdnNum=%d, iPathNextNodeIndent=%d\n", cCmpIndentFlag, pstIndentTail->iEtcIdnNum, iPathNextNodeIndent);

        if(  ( cCmpIndentFlag == CMP_INDENT_SAME && pstIndentTail->iEtcIdnNum != iPathNextNodeIndent )
          || ( cCmpIndentFlag == CMP_INDENT_ADD  && pstIndentTail->iEtcIdnNum >= iPathNextNodeIndent )
          || ( cCmpIndentFlag == CMP_INDENT_SUB  && pstIndentTail->iEtcIdnNum <= iPathNextNodeIndent )
          || ( cCmpIndentFlag == CMP_INDENT_ERROR ) )
        {
            if( pText > pTextBfGoBack )
                pTextBfGoBack = pText;

// printf("cCmpIndentFlag Bad !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n\n");
            return false;
        }
        else if( cCmpIndentFlag == CMP_INDENT_SUB )
        {
            // 走到这一步，说明分行缩减标识cCmpIndentFlag 和 etc缩进配置能匹配上
            // 但不代表实际缩减幅度能匹配上，有可能缩减跨了不只是1级，需要继续通过缩进空格长度继续匹配
// printf("======================================= CMP_INDENT_SUB pstIndentTail->iStrLen = %d\n", pstIndentTail->iStrLen);

/***********************************
char cTmp = *(pLineHead + iLineHeadKgf + 3);
*(pLineHead + iLineHeadKgf + 3) = '\0';
printf("pLineHead indent : [%s]\n", pLineHead);
*(pLineHead + iLineHeadKgf + 3) = cTmp;
***********************************/

            struct stIndent * pIndentBfCheck = pstIndentTail;
            
            // 只检查当前 Tree 维度下的缩进关系
            for( ; pIndentBfCheck; pIndentBfCheck=pIndentBfCheck->before )
            {
/***********************************
cTmp = *(pIndentBfCheck->pStr + pIndentBfCheck->iStrLen + 3);
*(pIndentBfCheck->pStr + pIndentBfCheck->iStrLen + 3) = '\0';
printf("\npIndentBfCheck indent : [%s]\n", pIndentBfCheck->pStr);
*(pIndentBfCheck->pStr + pIndentBfCheck->iStrLen + 3) = cTmp;

printf("pIndentBfCheck->iEtcIdnNum=[%d] | iPathNextNodeIndent=[%d] | pIndentBfCheck->iStrLen=[%d] | iLineHeadKgf=[%d]\n", pIndentBfCheck->iEtcIdnNum, iPathNextNodeIndent, pIndentBfCheck->iStrLen, iLineHeadKgf);  //  debug
***********************************/

                // Tree解析边界
                if( pIndentBfCheck->cLastNodeOfBeforeTree == 'Y' )
                {
                    // 缩进比它大的，跳过不检查
                    if( pIndentBfCheck->iEtcIdnNum > iPathNextNodeIndent )
                        continue ;

                    // 否则，退出该Tree路径解析
                    if( pText > pTextBfGoBack )
                        pTextBfGoBack = pText;

// printf("cCmpIndentFlag == CMP_INDENT_SUB 111 Bad !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n\n");
                    return false;
                }

                // 若配置缩进一致，其缩进空格内容必须一致
                if( pIndentBfCheck->iEtcIdnNum == iPathNextNodeIndent )
                {
// printf("pIndentBfCheck->iEtcIdnNum == iPathNextNodeIndent !!!!!!!!!!!!!!!!!!!!!!!!!!!\n");  // debug

                    // 若缩进一致，正常往下走
                    if( pIndentBfCheck->iStrLen == iLineHeadKgf && ! strncmp(pLineHead, pIndentBfCheck->pStr, iLineHeadKgf) )
                        break;
                    // 若缩进不一致，退出该Tree路径解析
                    else {
                        if( pText > pTextBfGoBack )
                            pTextBfGoBack = pText;

// printf("cCmpIndentFlag == CMP_INDENT_SUB 222 Bad !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n\n");
                        return false;
                    }
                }
                // 这个功能还需要进一步思考和测试补充 ！！！！！！！！！！！！！ ????????
                // 若之前配置缩进比它小，其缩进空格内容也需要比它短
                else if( pIndentBfCheck->iEtcIdnNum < iPathNextNodeIndent )
                {
// printf("pIndentBfCheck->iEtcIdnNum < iPathNextNodeIndent !!!!!!!!!!!!!!!!!!!!!!!!!!!\n");  // debug

                    if( pIndentBfCheck->iStrLen < iLineHeadKgf && ! strncmp(pLineHead, pIndentBfCheck->pStr, pIndentBfCheck->iStrLen) )
                        break;
                    else {
// printf("cCmpIndentFlag == CMP_INDENT_SUB 333 Bad !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n\n");
                        return false;
                    }
                }

            }  // for
        } // if
    } // if

    bool isFirstNode = true;
    bool isRightNode = true;

    struct stCompileInfo * pCompileInfoFather = pstCompileInfoTail;
    struct stCompileInfo * pCompileInfoTailBf = NULL;
    struct stCompileInfo * pCompileInfoNew = NULL;

    bool isInDebugLimit = inDebugLimit(pstCompileInfoTail->pObjName, pstCompileInfoTail->iObjNameLen, iPathY+1);

    bool isDebug4ThisShortPathBase = isDebug && isInDebugLimit && ! iCloseDebugTimes; 

    struct stPath * pPathNode4SplitFlagHead = NULL;

while( true )
{
// printf("while(true) : isRightNode : %d | cTreeLevelType : %d | *pText : [%c]\n", isRightNode, cTreeLevelType, *pText);  // debug

    char cTreeLevelTypeSave = cTreeLevelType;

    ///////////////////////////////////////////////////
    // LOG
    ///////////////////////////////////////////////////
    bool isDebug4ThisShortPath = isDebug4ThisShortPathBase ; 
    if( isDebug4ThisShortPath )
    {
        char cTmp = *(pstCompileInfoTail->pObjName + pstCompileInfoTail->iObjNameLen);
        *(pstCompileInfoTail->pObjName + pstCompileInfoTail->iObjNameLen) = '\0';
        printf("PATH : %s\n", pstCompileInfoTail->pObjName);
        *(pstCompileInfoTail->pObjName + pstCompileInfoTail->iObjNameLen) = cTmp;

        printf("ID   : %d\nX    : %d\n", iObjId, iPathY+1);

        if( pPathNextNode->pOneTreeCplLevel->pOtherName ) {
            cTmp = *(pPathNextNode->pOneTreeCplLevel->pOtherName + pPathNextNode->pOneTreeCplLevel->iOtherNameLen);
            *(pPathNextNode->pOneTreeCplLevel->pOtherName + pPathNextNode->pOneTreeCplLevel->iOtherNameLen) = '\0';
            printf("Y    : %s\n", pPathNextNode->pOneTreeCplLevel->pOtherName);
            *(pPathNextNode->pOneTreeCplLevel->pOtherName + pPathNextNode->pOneTreeCplLevel->iOtherNameLen) = cTmp;
        } else {
            printf("Y    : %d\n", pPathNextNode->pOneTreeCplLevel->iOtherNameLen);
        }

        cTmp = *(pPathNextNode->pOneTreeCplLevel->pKeyword + pPathNextNode->pOneTreeCplLevel->iKeywordLen);
        *(pPathNextNode->pOneTreeCplLevel->pKeyword + pPathNextNode->pOneTreeCplLevel->iKeywordLen) = '\0';
        printf("V    : %s\n", pPathNextNode->pOneTreeCplLevel->pKeyword);
        *(pPathNextNode->pOneTreeCplLevel->pKeyword + pPathNextNode->pOneTreeCplLevel->iKeywordLen) = cTmp;

        char *pTmp = pText;
        for( ; *pTmp != '\r' && *pTmp != '\n' && *pTmp != '\0'; pTmp ++ )
            if( pTmp - pText > 40 )
                break ;

        cTmp = *pTmp;
        *pTmp = '\0';
        printf("CODE : %s\n", pText);
        *pTmp = cTmp;

        printf("LINE : %d\n\n", iLineNum);
    }

    ///////////////////////////////////////////////////
    // 将当前节点的缩进保存起来，若当前节点解析正确，可以成为新的缩进参照
    char * pIndentNew = pLineHead;
    unsigned int iIndentNew = iLineHeadKgf;

    char *pTextSave = pText;
    if( isRightNode )
    {
        pCompileInfoTailBf = pstCompileInfoTail;

        // New one stCompileInfo to the end    for pFork
        pstCompileInfoTail->next =
        newCompileInfo4Tree(
          pCompileInfoTailBf->mType[IDX_OBJ]              // char cObjType
        , cTreeLevelType                                  // char cTreeLevelType
        , pCompileInfoTailBf->pObjName                    // char *pObjName
        , pCompileInfoTailBf->iObjNameLen                 // unsigned int iObjNameLen
        , iPathY + 1                                      // unsigned int iPathY
        , pPathNextNode->pOneTreeCplLevel->pOtherName     // char *pOtherName
        , pPathNextNode->pOneTreeCplLevel->iOtherNameLen  // unsigned int iOtherNameLen
        , pPathNextNode->pOneTreeCplLevel->iPriority      // unsigned int iPriority
        , pPathNextNode->pOneTreeCplLevel->pAttrExpr      // struct stExprInfo * pAttrExpr
        , NULL                                            // char *pValue
        , 0                                               // unsigned int iValueLen
        , iLoopCount                                      // unsigned int iLoopCount4ShortPath
        );

        pstCompileInfoTail = pstCompileInfoTail->next;
        pCompileInfoNew = pstCompileInfoTail;

        isRightNode = false;

        iStep4TypeCont ++ ;
    }

    ////////////////////////////////////////////
    // 保存注释信息，预先挂在 pCompileInfoNew 上，避免后续下钻后，挂载节点不对
    // 若无法解析通过，可以释放掉，回头重新解析注释
    if( pstCommentList->next )
    {
// printf("保存注释信息，预先挂在 pCompileInfoNew 上\n");

        pCompileInfoNew->pComments_PassCode = pstCommentList->next;
        pstCommentList->next = NULL;
        pstCommentListTail = pstCommentList;
    }
    // 保存挂载节点类型，为后续移动注释作为判断依据
    pCompileInfoNew->mType[IDX_TREE_LEVEL_TYPE] = cTreeLevelType;

    ////////////////////////////////////////////
    if( *pText == '\0' )
    {
// printf("*pText == '0' !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");

        if( *(pPathNextNode->pOneTreeCplLevel->pPathY + iPathY) == 'e' || *(pPathNextNode->pOneTreeCplLevel->pPathY + iPathY) == 'E' )
        {
            if( ! pPathNextNode->nextNode || pPathNextNode->nextNode->pOneTreeCplLevel->cSplitFlag != '+' )
            {
                *isNLoop = false;

                if( iRightNodeCount4OneShortPath )
                {
                    // 注释还原，为了后续挂载到正确节点
                    pstCommentList->next = pCompileInfoNew->pComments_PassCode;

                    freeCompileInfoNode( & (pCompileInfoTailBf->next) );
                    pCompileInfoTailBf->next = NULL;
                    pstCompileInfoTail = pCompileInfoTailBf;
                }

                break ;
            }
        }
        
        // 遇到分行节点
        if( cTreeLevelType == TYPE_N )
            isRightNode = true;
    }
    // 缩进不正确，下面的直接不用解析
    else if( ! isRightIndent )
    {
        // pass
    }
    else if( cTreeLevelType == TYPE_ANY )
    {
        // 遇到 ANY ，要么成功结束，要么所有内容被吃完，然后程序结束 ！！
        freeCompileInfoNode( &(pCompileInfoTailBf->next) );
        pstCompileInfoTail = pCompileInfoTailBf;

        struct stPath *pAnyOther = NULL;
        struct stPath *pAnyEnd = pPathNextNode->nextNode;

        if( pAnyEnd->pOneTreeCplLevel->cSplitFlag == '+' )
        {
            pAnyOther = pAnyEnd;
            for( ; pAnyEnd->pOneTreeCplLevel->cSplitFlag == '+'; pAnyEnd=pAnyEnd->nextNode);
        }

        char *pTextAny = pText;
        unsigned int iLen = 0;
        struct stPath *pPathTmp = NULL;
        while( *pText )
        {
            bool isDone = false;
            pPathTmp = pAnyOther;

            while( true )
            {
                // ANY 的分割内容，暂时只支持 自定义常量 和 分行符
                // 不支持关键字，例如 __NUMBER__ 等 ！！！
                if( pPathTmp && pPathTmp->pOneTreeCplLevel->cSplitFlag == '+' ) {
                    // 先循环完 pPathTmp
                    if( ! cmpStr(pText, pPathTmp->pOneTreeCplLevel->pKeyword, pPathTmp->pOneTreeCplLevel->iKeywordLen) )
                    {
                        pPathTmp = pPathTmp->nextNode;
                        continue ;
                    }
                } else if( *pText != '\r' && *pText != '\n' ) 
                    break ;

                if( iLen )
                {
// printStrForDebug("__ANY__ part", pTextAny, iLen);
                    pstCompileInfoTail->next =
                    newCompileInfo4Tree (
                      pCompileInfoTailBf->mType[IDX_OBJ]              // char cObjType
                    , cTreeLevelType                                  // char cTreeLevelType
                    , pCompileInfoTailBf->pObjName                    // char *pObjName
                    , pCompileInfoTailBf->iObjNameLen                 // unsigned int iObjNameLen
                    , iPathY + 1                                      // unsigned int iPathY
                    , pPathNextNode->pOneTreeCplLevel->pOtherName     // char *pOtherName
                    , pPathNextNode->pOneTreeCplLevel->iOtherNameLen  // unsigned int iOtherNameLen
                    , pPathNextNode->pOneTreeCplLevel->iPriority      // unsigned int iPriority
                    , pPathNextNode->pOneTreeCplLevel->pAttrExpr      // struct stExprInfo * pAttrExpr
                    , pTextAny                                        // char *pValue
                    , iLen                                            // unsigned int iValueLen
                    , iLoopCount                                      // unsigned int iLoopCount4ShortPath
                    );

                    pstCompileInfoTail = pstCompileInfoTail->next;
                }

                ////////////////////////////////////////////////////////////
/********************************************
if( *pText != '\r' && *pText != '\n' )
{
    printStrForDebug("__ANY__ other", pText, pPathTmp->pOneTreeCplLevel->iKeywordLen);
    printStrForDebug("__ANY__ other name", pPathTmp->pOneTreeCplLevel->pOtherName, pPathNextNode->pOneTreeCplLevel->iOtherNameLen);
}
else
    printf("__ANY__ other : \\n\n");
/*********************************************/

                if( *pText != '\r' && *pText != '\n' )
                pstCompileInfoTail->next = 
                newCompileInfo4Tree (
                  pCompileInfoTailBf->mType[IDX_OBJ]              // char cObjType
                , cTreeLevelType                                  // char cTreeLevelType
                , pCompileInfoTailBf->pObjName                    // char *pObjName
                , pCompileInfoTailBf->iObjNameLen                 // unsigned int iObjNameLen
                , iPathY + 1                                      // unsigned int iPathY
                , pPathTmp->pOneTreeCplLevel->pOtherName          // char *pOtherName
                , pPathTmp->pOneTreeCplLevel->iOtherNameLen       // unsigned int iOtherNameLen
                , pPathNextNode->pOneTreeCplLevel->iPriority      // unsigned int iPriority
                , pPathNextNode->pOneTreeCplLevel->pAttrExpr      // struct stExprInfo * pAttrExpr
                , pText                                           // char *pValue
                , (*pText=='\r'||*pText=='\n') ? 0 : pPathTmp->pOneTreeCplLevel->iKeywordLen    // unsigned int iValueLen
                , iLoopCount                                      // unsigned int iLoopCount4ShortPath
                );
                else  ///////////////////////////////////
                pstCompileInfoTail->next =
                newCompileInfo4Tree (
                  pCompileInfoTailBf->mType[IDX_OBJ]              // char cObjType
                , cTreeLevelType                                  // char cTreeLevelType
                , pCompileInfoTailBf->pObjName                    // char *pObjName
                , pCompileInfoTailBf->iObjNameLen                 // unsigned int iObjNameLen
                , iPathY + 1                                      // unsigned int iPathY
                , pPathNextNode->pOneTreeCplLevel->pOtherName     // char *pOtherName
                , pPathNextNode->pOneTreeCplLevel->iOtherNameLen  // unsigned int iOtherNameLen
                , pPathNextNode->pOneTreeCplLevel->iPriority      // unsigned int iPriority
                , pPathNextNode->pOneTreeCplLevel->pAttrExpr      // struct stExprInfo * pAttrExpr
                , pText                                           // char *pValue
                , (*pText=='\r'||*pText=='\n') ? 0 : pPathTmp->pOneTreeCplLevel->iKeywordLen    // unsigned int iValueLen
                , iLoopCount                                      // unsigned int iLoopCount4ShortPath
                );

                pstCompileInfoTail = pstCompileInfoTail->next;

                if( *pText == '\n' || *pText == '\r' ) {

                    if( *pText == '\r' )
                        pText += 2;
                    else
                        pText ++ ;

                    iLineNum ++ ;
                    pLineHead = pText;   // 20220109
                    iLineHeadKgf = 0;
                    for(char *pTmp = pLineHead; *pTmp == ' ' || *pTmp == '\t'; pTmp ++ ) iLineHeadKgf ++ ;

                } else
                    pText += pPathTmp->pOneTreeCplLevel->iKeywordLen;

                pTextAny = pText;
                iLen = 0;
                isDone = true;
            }

            if( isDone ) continue ;

            //////////////////////////////////////////////

            pPathTmp = pAnyEnd;
            while( pPathTmp )
            {
                if( cmpStr(pText, pPathTmp->pOneTreeCplLevel->pKeyword, pPathTmp->pOneTreeCplLevel->iKeywordLen) ) 
                {
                    isDone = true;
                    break;
                }

                if( pPathTmp->nextNode && pPathTmp->nextNode->pOneTreeCplLevel->cSplitFlag == '+' )
                    pPathTmp = pPathTmp->nextNode;
                else
                    break;
            }

            if( isDone )
            {
// printStrForDebug("__ANY__ end", pTextAny, iLen);

                if( iLen )
                {
                    pstCompileInfoTail->next =
                    newCompileInfo4Tree (
                      pCompileInfoTailBf->mType[IDX_OBJ]              // char cObjType
                    , cTreeLevelType                                  // char cTreeLevelType
                    , pCompileInfoTailBf->pObjName                    // char *pObjName
                    , pCompileInfoTailBf->iObjNameLen                 // unsigned int iObjNameLen
                    , iPathY + 1                                      // unsigned int iPathY
                    , pPathNextNode->pOneTreeCplLevel->pOtherName     // char *pOtherName
                    , pPathNextNode->pOneTreeCplLevel->iOtherNameLen  // unsigned int iOtherNameLen
                    , pPathNextNode->pOneTreeCplLevel->iPriority      // unsigned int iPriority
                    , pPathNextNode->pOneTreeCplLevel->pAttrExpr      // struct stExprInfo * pAttrExpr
                    , pTextAny                                        // char *pValue
                    , iLen                                            // unsigned int iValueLen
                    , iLoopCount                                      // unsigned int iLoopCount4ShortPath
                    );

                    pstCompileInfoTail = pstCompileInfoTail->next;
                }

                isRightNode = true;
                // *isNLoop = false;   // __ANY__ 只允许循环一次  ??????? 20231105
                break;
            }

            iLen ++ ;
            pText ++ ;

        } // while( *pText )
    }
    // else if( cTreeLevelType == TYPE_B && *pText == ' ')
    else if( cTreeLevelType == TYPE_B )
    {
// printf("TYPE_B\n");  // debug
        if( *pText == ' ' )
        {
            pText += 1;
            isRightNode = true;
        }
    }
    else if( cTreeLevelType == TYPE_T ) // && *pText == '\t' )
    {
// printf("TYPE_T\n");  // debug
        if( *pText == '\t' )
        {
            pText += 1;
            isRightNode = true;
        }
    }
    // TYPE_BLANK 调到 TYPE_N 之前，20231104
    else if( cTreeLevelType == TYPE_BLANK )   // && (*pText == ' ' || *pText == '\t' || *pText == '\r' || *pText == '\n') )
    {
// printf("TYPE_BLANK\n");  // debug
        if( *pText == ' ' || *pText == '\t' || *pText == '\r' || *pText == '\n' )
        {
            ((struct stCplInfo4Tree *)(&(pstCompileInfoTail->pVal1)))->pValue = pText;
            for( ; *pText == ' ' || *pText == '\t' || *pText == '\r' || *pText == '\n'; pText ++ )
            {
                ((struct stCplInfo4Tree *)(&(pstCompileInfoTail->pVal1)))->iValueLen ++ ;
                if( *pText == '\n')
                    doWithFh();
            }

            isRightNode = true;
        }
    }
    else if( cTreeLevelType == TYPE_N )
    {
        unsigned int iLineNumBf = iLineNum;
        passKgf_Comment();
        if( iLineNumBf != iLineNum ) // || pText == pLineHead + iLineHeadKgf )
        {
            // pText 回到新行头，为后续判断缩进作为依据
            pText = pLineHead;
            isRightNode = true;
        }
    }
    else if( cTreeLevelType == TYPE_CONT ) 
    {
		// 若配置了匹配规则
		if( ATTR_CONT_MATCH_RULE & pPathNextNode->pOneTreeCplLevel->iAttrFlag )
		{
			unsigned int iStrLen = getStrObjLen(pPathNextNode->pOneTreeCplLevel->pStr4MatchRule, pText);
// printStrForDebug("pStr4MatchRule name", pPathNextNode->pOneTreeCplLevel->pStr4MatchRule->pName, pPathNextNode->pOneTreeCplLevel->pStr4MatchRule->iNameLen);   // debug
// printStrForDebug("pStr4MatchRule info", pText, iStrLen);   // debug
// printStrForDebug("Keyword info", pPathNextNode->pOneTreeCplLevel->pKeyword, pPathNextNode->pOneTreeCplLevel->iKeywordLen);   // debug

			if( iStrLen == pPathNextNode->pOneTreeCplLevel->iKeywordLen
			 && cmpStr(pText, pPathNextNode->pOneTreeCplLevel->pKeyword, pPathNextNode->pOneTreeCplLevel->iKeywordLen) 
			)
			{
				((struct stCplInfo4Tree *)(&(pstCompileInfoTail->pVal1)))->pValue = pText;
                ((struct stCplInfo4Tree *)(&(pstCompileInfoTail->pVal1)))->iValueLen = pPathNextNode->pOneTreeCplLevel->iKeywordLen;

                pText += pPathNextNode->pOneTreeCplLevel->iKeywordLen;
                isRightNode = true;
			}
		}
        else if( cmpStr(pText, pPathNextNode->pOneTreeCplLevel->pKeyword, pPathNextNode->pOneTreeCplLevel->iKeywordLen) )
        {
// printStrForDebug("TYPE_CONT", pPathNextNode->pOneTreeCplLevel->pKeyword, pPathNextNode->pOneTreeCplLevel->iKeywordLen);

            ((struct stCplInfo4Tree *)(&(pstCompileInfoTail->pVal1)))->pValue = pText;
            ((struct stCplInfo4Tree *)(&(pstCompileInfoTail->pVal1)))->iValueLen = pPathNextNode->pOneTreeCplLevel->iKeywordLen;

            pText += pPathNextNode->pOneTreeCplLevel->iKeywordLen;
            isRightNode = true;
        }
        // 是否遇到注释
        else if( isComment() )
        {
            if( cTreeLevelType != TYPE_B && cTreeLevelType != TYPE_T && cTreeLevelType != TYPE_N && cTreeLevelType != TYPE_BLANK )
                passKgf_Comment();

            continue ;
        }
        else if( *(pPathNextNode->pOneTreeCplLevel->pPathY + iPathY) == 'e' || *(pPathNextNode->pOneTreeCplLevel->pPathY + iPathY) == 'E' )
        {
            if( ! pPathNextNode->nextNode || pPathNextNode->nextNode->pOneTreeCplLevel->cSplitFlag != '+' )
            {
                *isNLoop = false;

                if( iRightNodeCount4OneShortPath )
                {
                    // 注释还原，为了后续挂载到正确节点
                    pstCommentList->next = pCompileInfoNew->pComments_PassCode;

                    freeCompileInfoNode( & (pCompileInfoTailBf->next) );
                    pCompileInfoTailBf->next = NULL;
                    pstCompileInfoTail = pCompileInfoTailBf;
                }

                break ;
            }
        }
        else 
            addFailText4ObjPoint(pPathNextNode->pOneTreeCplLevel->pKeyword);
    }
    else if( cTreeLevelType == TYPE_PATH )
    {
// printStrForDebug("TYPE_PATH", pPathNextNode->pOneTreeCplLevel->pKeyword, pPathNextNode->pOneTreeCplLevel->iKeywordLen);  // debug
// printf("cTreeLevelType = [%d]\n", cTreeLevelType);  //debug
// printf("Tree Indent : [%d]\n", pPathNextNode->pOneTreeCplLevel->iIndent);   // debug

        // 20230820 将 TREE 对象的名字保持在下钻前对象节点的值上，没有什么作用，还会影响SKIP时的空值输出
        // ((struct stCplInfo4Tree *)(&(pstCompileInfoTail->pVal1)))->pValue = pPathNextNode->pOneTreeCplLevel->pKeyword;
        // ((struct stCplInfo4Tree *)(&(pstCompileInfoTail->pVal1)))->iValueLen = pPathNextNode->pOneTreeCplLevel->iKeywordLen;

        struct stTree * pOneTree = findTreeName(pPathNextNode->pOneTreeCplLevel->pKeyword, pPathNextNode->pOneTreeCplLevel->iKeywordLen);

        if( ! isFailText4ObjPoint(pOneTree) )
        {
            // pTextSave = pText;

            bool isSuccessNode = isSuccessText4ObjPoint(pOneTree);
            if( isSuccessNode )
                iCloseDebugTimes ++ ;
// printf("iCloseDebugTimes = %d\n", iCloseDebugTimes);

            // 新增 下钻时缩进空格数的累加 新节点 
            struct stString * pIndentSum4GoNextTree4CplNew = getStringNode();
            pIndentSum4GoNextTree4CplNew->iNum = pPathNextNode->pOneTreeCplLevel->iIndent + pstIndentSum4GoNextTree4Cpl->iNum;
            pIndentSum4GoNextTree4CplNew->next = pstIndentSum4GoNextTree4Cpl;
            pstIndentSum4GoNextTree4Cpl = pIndentSum4GoNextTree4CplNew;
            pstIndentSum4GoNextTree4Cpl->cFlag = cSplitFlag;   // 保存下钻前的分隔符
// printf("pstIndentSum4GoNextTree4CplNew->iNum = %d, iLineHeadKgf=%d, cSplitFlag=[%c]\n", pstIndentSum4GoNextTree4Cpl->iNum, iLineHeadKgf, pstIndentSum4GoNextTree4Cpl->cFlag);  // debug

            // 为了compileTextByTree失败后回退
            char cSplitFlagSave = cSplitFlag;

            // Tree下钻开始前，给上条路径最后的缩进节点打上标识，作为路径解析退出分割点
            if( pPathNextNode->pOneTreeCplLevel->iAttrFlag & ATTR_SKIP_INDENT )
                iCount4SkipIndentTree ++ ;

            // Tree下钻开始前，给上条路径最后的缩进节点打上标识，作为路径解析退出分割点
// printStrForDebug("before compileTextByTree pstIndentTail", pstIndentTail->pStr, pstIndentTail->iStrLen + 3); // debug
// printf("iDoWithOneLineNodeCount = %d\n", iDoWithOneLineNodeCount);
            if( pstIndentTail->iStrLen && ! iDoWithOneLineNodeCount && ! iCount4SkipIndentTree )
                pstIndentTail->cLastNodeOfBeforeTree = 'Y';

            if( compileTextByTree(pOneTree, pPathNextNode) ) {
                isRightNode = true;
                orderTreeNodeByPriority(pCompileInfoNew);

                ///////////////////////////////////

                if( isSuccessNode )
                    iCloseDebugTimes -- ;
                else
                    addSuccessText4ObjPoint(pTextSave, pOneTree);
            } else {
                if( pCompileInfoNew->pFork )
                    freeCompileInfoList( &(pCompileInfoNew->pFork) );

                addFailText4ObjPoint(pPathNextNode->pOneTreeCplLevel->pKeyword);
                addFailText4ObjPoint(pOneTree);

                pstIndentTail->cLastNodeOfBeforeTree = 'N';

                cSplitFlag = cSplitFlagSave;
            }

            pstCompileInfoTail = pCompileInfoNew;

            ///////////////////////////////////////////

            // Tree下钻完毕，标识取消
            pstIndentTail->cLastNodeOfBeforeTree = 'N';

            // 释放 下钻时缩进空格数的累加 新节点 
            pIndentSum4GoNextTree4CplNew = pstIndentSum4GoNextTree4Cpl;
            pstIndentSum4GoNextTree4Cpl = pstIndentSum4GoNextTree4Cpl->next;
            freeStringNode(& pIndentSum4GoNextTree4CplNew);

// printf("pIndentNew - pLineHead = %p - %p\n", pIndentNew, pLineHead);  // debug
// printf("iIndentNew - iLineHeadKgf = %d - %d\n", iIndentNew, iLineHeadKgf);  // debug

            if( pPathNextNode->pOneTreeCplLevel->iAttrFlag & ATTR_SKIP_INDENT )
                iCount4SkipIndentTree -- ;
        }

        // compileTextByTree 处理Tree下钻，有可能会使得 cTreeLevelType == 0，这里补回 cTreeLevelType
        cTreeLevelType = cTreeLevelTypeSave;
    }
    else if( cTreeLevelType == TYPE_EXPR )
    {
        struct stLine *pLineTmp = findLineName(pPathNextNode->pOneTreeCplLevel->pKeyword, pPathNextNode->pOneTreeCplLevel->iKeywordLen);

        if( pLineTmp && ! isFailText4ObjPoint(pLineTmp) )
        {
// printStrForDebug("TYPE_EXPR", pLineTmp->pName, pLineTmp->iNameLen);  // debug
            ((struct stCplInfo4Tree *)(&(pstCompileInfoTail->pVal1)))->pValue = pLineTmp->pName;
            ((struct stCplInfo4Tree *)(&(pstCompileInfoTail->pVal1)))->iValueLen = pLineTmp->iNameLen;

            // For go back
            // pTextSave = pText;
            char * pLineHeadSave = pLineHead;
            unsigned int iLineNumSave = iLineNum;

            bool isSuccessNode = isSuccessText4ObjPoint(pLineTmp);
            if( isSuccessNode )
                iCloseDebugTimes ++ ;
// printf("Line iCloseDebugTimes = %d\n", iCloseDebugTimes);

            char cTmp4LineName = *(pLineTmp->pName + pLineTmp->iNameLen);
            *(pLineTmp->pName + pLineTmp->iNameLen) = '\0';

            struct stString * pSubLineCountListNew = getStringNode();
            memset(pSubLineCountListNew, 0x00, sizeof(struct stString));
            pSubLineCountListNew->next = pstSubLineCountList;
            pstSubLineCountList = pSubLineCountListNew;

            iDoWithOneLineNodeCount ++ ;
            // char cCmpIndentFlagSave = cCmpIndentFlag;
            if( doWithOneLineNode(pLineTmp, pPathNextNode, iPathY) ) {
                isRightNode = true;
// printOneLineCompileInfo(pCompileInfoNew->pFork); // debug

                // Go back  Tree -> line -> ...
                pstCompileInfoTail = pCompileInfoNew;

                ///////////////////////////////////

                if( isSuccessNode )
                    iCloseDebugTimes -- ;
                else
                    addSuccessText4ObjPoint(pTextSave, pLineTmp);

                /////////////////////////////////
                // 表达式解析成功后，pText 回到expr最后一个非空节点
                pText = mLastTextInfo4Expr.pTextBf;
                pLineHead = mLastTextInfo4Expr.pLineHeadBf;
                iLineHeadKgf = mLastTextInfo4Expr.iLineHeadKgfBf;
                iLineNum = mLastTextInfo4Expr.iLineNumBf;
                cCmpIndentFlag = mLastTextInfo4Expr.cCmpIndentFlagBf;

            } else {
                pText = pTextSave;
                pLineHead  = pLineHeadSave;
                iLineNum = iLineNumSave;
 
                freeAllCompileInfo4OnePath(pCompileInfoNew->pFork);
                // 20231104
                // freeCompileInfoNode( &(pCompileInfoNew->pFork) );
                freeCompileInfoList( &(pCompileInfoNew->pFork) );
                pstCompileInfoTail = pCompileInfoNew;

                addFailText4ObjPoint(pPathNextNode->pOneTreeCplLevel->pKeyword);
                addFailText4ObjPoint(pLineTmp);
            }
            iDoWithOneLineNodeCount -- ;
            // cCmpIndentFlag = cCmpIndentFlagSave;

            *(pLineTmp->pName + pLineTmp->iNameLen) = cTmp4LineName;

            // 弹栈
            pSubLineCountListNew = pstSubLineCountList;
            pstSubLineCountList = pstSubLineCountList->next;
            freeStringNode( & pSubLineCountListNew);

            // doWithOneLineNode 处理Tree下钻，有可能会使得 cTreeLevelType == 0，这里补回 cTreeLevelType
            cTreeLevelType = cTreeLevelTypeSave;
        }
    }
    else if( cTreeLevelType == TYPE_STR )
    {
        struct stStr *pStrTmp = findStrName(pPathNextNode->pOneTreeCplLevel->pKeyword, pPathNextNode->pOneTreeCplLevel->iKeywordLen);
        unsigned int iLen = getStrObjLen(pStrTmp, pText);

        if( iLen )
        {
// printStrForDebug("TYPE_STR name", pStrTmp->pName, pStrTmp->iNameLen);   // debug
// printStrForDebug("TYPE_STR info", pText, iLen);   // debug
            ((struct stCplInfo4Tree *)(&(pstCompileInfoTail->pVal1)))->pValue = pText;
            ((struct stCplInfo4Tree *)(&(pstCompileInfoTail->pVal1)))->iValueLen = iLen;

            pText += iLen;
            isRightNode = true;

        } else
            addFailText4ObjPoint(pPathNextNode->pOneTreeCplLevel->pKeyword);

    } else {
        printf("Something error 2030 [%d]\n", cTreeLevelType);
        exit(0);
    }

    ////////////////////////////////////////////////////////////

    // 保留最近最近一个 | / \ 节点
    if( pPathNextNode->pOneTreeCplLevel->cSplitFlag == '|'
     || pPathNextNode->pOneTreeCplLevel->cSplitFlag == '/'
     || pPathNextNode->pOneTreeCplLevel->cSplitFlag == '\\' )
    {
        pPathNode4SplitFlagHead = pPathNextNode;
    }

    isRightNode = isRightNode && isRightIndent;

/********************************
printf("isRightNode=[%d][%d][%c]\n", isRightNode, cTreeLevelType, cSplitFlag); // pPathNextNode->pOneTreeCplLevel->cSplitFlag);
if( cTreeLevelType == TYPE_PATH )
    printStrForDebug("    RightNode TYPE_PATH", pPathNextNode->pOneTreeCplLevel->pKeyword, pPathNextNode->pOneTreeCplLevel->iKeywordLen);  // debug
printStrForDebug("pText", pText, 4);   // debug
********************************/

    // 解析不成功
    if( ! isRightNode ) 
    {
        if( cSplitFlag == '/' )
        {
// printf("cSplitFlag == '/'  !!!!!!!!!!!!!!\n");

            char * pTextBf = pText;
            char * pLineHeadBf = pLineHead;
            unsigned int iLineHeadKgfBf = iLineHeadKgf;
            unsigned int iLineNumBf = iLineNum;
            char cCmpIndentFlagBf = cCmpIndentFlag;

            passKgf_Comment();

            // 若出现分行，错误节点
            if( iLineNumBf != iLineNum ) {
                pText = pTextBf;
                pLineHead = pLineHeadBf;
                iLineHeadKgf = iLineHeadKgfBf;
                iLineNum = iLineNumBf;
                cCmpIndentFlag = cCmpIndentFlagBf;
            } else if( pTextBf != pText )
                continue ;
        }
        // 可能是注释 或 空格
        else if( (isComment() || *pText==' ' || *pText=='\t' || *pText=='\r' || *pText=='\n')
         && cTreeLevelType != TYPE_B && cTreeLevelType != TYPE_T && cTreeLevelType != TYPE_N && cTreeLevelType != TYPE_BLANK )
        {
            passKgf_Comment();
            cTreeLevelType = cTreeLevelTypeSave;

            continue ;
        }
        // 可能是 表达式换行符
        else if( iDoWithOneLineNodeCount && ! strncmp(pText, pstLineList->pSplit, pstLineList->iSplitLen)
              && (*(pText+pstLineList->iSplitLen) == '\r' || *(pText+pstLineList->iSplitLen) == '\n') )
        {
// printStrForDebug("Line pSplit", pstLineList->pSplit, pstLineList->iSplitLen);
            pText += pstLineList->iSplitLen ;   // 跳过分隔符
        }
    }

    // 当此节点为第一个节点，并且解析失败时，退出此路径
    // 第一个节点失败退出的目的，是为了确保解析按类型优先级来
    if( ! isRightNode && isFirstNode && !(ATTR_CAN_SKIP & pPathNextNode->pOneTreeCplLevel->iAttrFlag) ) {
        freeAllCompileInfo4OnePath( pCompileInfoFather->next );
        freeCompileInfoNode( & (pCompileInfoFather->next) );

        pstCompileInfoTail = pCompileInfoFather;
        pstCompileInfoTail->next = NULL;

        if( isDebug4ThisShortPath ) printf("Failed to go here !\n\n", iLineNum);

        return false;
    } else
        isFirstNode = false;

    /////////////////////////////////////////

/*******************************************
 * 20231112
    // 保留最近最近一个 | / \ 节点
    if( pPathNextNode->pOneTreeCplLevel->cSplitFlag == '|'
     || pPathNextNode->pOneTreeCplLevel->cSplitFlag == '/'
     || pPathNextNode->pOneTreeCplLevel->cSplitFlag == '\\' )
    {
        pPathNode4SplitFlagHead = pPathNextNode;
    }
*******************************************/
    // 保存上一个节点
    struct stPath * pPathBeforeNode = pPathNextNode;

// printf("ATTR_SKIP_INDENT=%d | iDoWithOneLineNodeCount=%d | iCount4SkipIndentTree=%d | cSplitFlag=[%c] | pIndentNew=%p | pstIndentTail->pStr=%p | pLineHead+iLineHeadKgf=%p | pText=%p\n", pPathBeforeNode->pOneTreeCplLevel->iAttrFlag & ATTR_SKIP_INDENT, iDoWithOneLineNodeCount, iCount4SkipIndentTree, pPathNextNode->pOneTreeCplLevel->cSplitFlag, pIndentNew, pstIndentTail->pStr, pLineHead + iLineHeadKgf, pText);

    // 走下一个节点
    pPathNextNode = pPathNextNode->nextNode;

    /////////////////////////////////////////  
	
    // 若节点正确，跳过与其并行的节点
    if( isRightNode )
    {
        iRightNodeCount4OneShortPath ++ ;

        // 若此节点属性为缩进 敏感，保存此节点缩进为最新缩进参考
        if( (cIndentType == INDENT_COMPILER || cIndentType == INDENT_COMPILER_TRANSLATOR)
         && ! (pPathBeforeNode->pOneTreeCplLevel->iAttrFlag & ATTR_SKIP_INDENT)
         && pIndentNew != pstIndentTail->pStr
         && cTreeLevelType != TYPE_N && cTreeLevelType != TYPE_BLANK && cTreeLevelType != TYPE_ANY
         // && (pLineHead + iLineHeadKgf == pTextSave || pLineHead + iLineHeadKgf == pText)   // 一行中的第一个节点
         && (pLineHead == pText || pLineHead + iLineHeadKgf == pText || pLineHead == pTextSave || pLineHead + iLineHeadKgf == pTextSave)   // 一行中的第一个节点
         && ! iDoWithOneLineNodeCount && ! iCount4SkipIndentTree
        )
        { 
// printf("FFFFFFFFFFFFFFFFFFFFFFFFF????????????????????????? [%c][%p | %p]\n", pPathBeforeNode->pOneTreeCplLevel->cSplitFlag, pLineHead + iLineHeadKgf, pTextSave);

// printStrForDebug("================= pIndentNew", pIndentNew, iIndentNew + 3);

                pstIndentTail->next = (struct stIndent *)getStringNode();
                memset(pstIndentTail->next, 0x00, sizeof(struct stIndent));

                pstIndentTail->next->pStr = pIndentNew;
                pstIndentTail->next->iStrLen = iIndentNew;
                pstIndentTail->next->iEtcIdnNum = pPathBeforeNode->pOneTreeCplLevel->iIndent + pstIndentSum4GoNextTree4Cpl->iNum;   // 保存配置文件的缩进

                pstIndentTail->next->before = pstIndentTail;

                pstIndentTail = pstIndentTail->next;

                ///////////////////////////////////////////////////////////////

                // 刷新 cCmpIndentFlag 的值
                if( *(pLineHead + iLineHeadKgf) == '\n' || *(pLineHead + iLineHeadKgf) == '\r' )
                {
                    // cCmpIndentFlag = CMP_INDENT_BLANK;
                }
                // 是否为注释
                else if(  (pLineComment && ! strncmp(pText, pLineComment, iLineCommentLen) )
                       || (pLinesCommentStart && ! strncmp(pText, pLinesCommentStart, iLinesCommentStartLen)) )
                {
                    // pass
                }
                // 是否缩进相同
                else if( iLineHeadKgf == iIndentNew && ! strncmp(pLineHead, pIndentNew, iIndentNew)  )
                    cCmpIndentFlag = CMP_INDENT_SAME;
                // 是否缩进增加
                else if( iLineHeadKgf > iIndentNew && ! strncmp(pLineHead, pIndentNew, iIndentNew)  )
                    cCmpIndentFlag = CMP_INDENT_ADD;
                // 是否缩进减少
                else if( iLineHeadKgf < iIndentNew && ! strncmp(pLineHead, pIndentNew, iLineHeadKgf)  )
                    cCmpIndentFlag = CMP_INDENT_SUB;
                else
                    cCmpIndentFlag = CMP_INDENT_ERROR;

// printf("pstIndentTail->iEtcIdnNum = %d, iDoWithOneLineNodeCount = %d\n", pstIndentTail->iEtcIdnNum, iDoWithOneLineNodeCount);  // debug
        }

        // 跳过与其并行的节点
        for( ; pPathNextNode && pPathNextNode->pOneTreeCplLevel->cSplitFlag == '+'; pPathNextNode=pPathNextNode->nextNode );

        // 若下一节点为空，或者是新路径，完成此路径解析
        if( pPathNextNode == NULL
         || (  *(pPathNextNode->pOneTreeCplLevel->pPathY + iPathY) != ' '
            && *(pPathNextNode->pOneTreeCplLevel->pPathY + iPathY) != 'e' 
            && *(pPathNextNode->pOneTreeCplLevel->pPathY + iPathY) != 'E' ) )
        {
// printf("break !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
            break ;
        }

        // 保存下个分割标记
        cSplitFlag = pPathNextNode->pOneTreeCplLevel->cSplitFlag;

    // 若非正确节点，但存在并行节点，可以继续
    } else if( pPathNextNode && pPathNextNode->pOneTreeCplLevel->cSplitFlag == '+' ) {
        // 更换新节点的信息 20230319
        pstCompileInfoTail->iPriority = pPathNextNode->pOneTreeCplLevel->iPriority;
        ((struct stCplInfo4Tree *)(&(pstCompileInfoTail->pVal1)))->pOtherName = pPathNextNode->pOneTreeCplLevel->pOtherName;
        ((struct stCplInfo4Tree *)(&(pstCompileInfoTail->pVal1)))->iOtherNameLen = pPathNextNode->pOneTreeCplLevel->iOtherNameLen;

    // 若非正确节点，且无并行节点，但为 可跳过 节点，当成 isRightNode 处理
    } else if( ATTR_CAN_SKIP & pPathNode4SplitFlagHead->pOneTreeCplLevel->iAttrFlag ) {
        isRightNode = true;
        (*iSkipNodeCount) ++ ;

        if( isDebug4ThisShortPath ) printf("Skip this node !!!\n\n");

        // 跳过节点，将挂载在此节点的注释还原回去，以便后续重新挂载非SKIP节点
        pstCommentList->next = pCompileInfoNew->pComments_PassCode;
        pCompileInfoNew->pComments_PassCode = NULL;

// printf("pPathNextNode ATTR_CAN_SKIP = %p\n", pPathNextNode);  // debug

        // 若下一节点为空，或者是新路径，完成此路径解析
        if( pPathNextNode == NULL
         || (  *(pPathNextNode->pOneTreeCplLevel->pPathY + iPathY) != ' '
            && *(pPathNextNode->pOneTreeCplLevel->pPathY + iPathY) != 'e'
            && *(pPathNextNode->pOneTreeCplLevel->pPathY + iPathY) != 'E' ) )
        {
            // 退出前，若之前解析过正确节点，要删除没加载数据的最后一个pstCompileInfoTail节点
            if( iRightNodeCount4OneShortPath )
            {
                pstCompileInfoTail = pCompileInfoTailBf;
                freeCompileInfoNode( &(pstCompileInfoTail->next) ); 
            }

            break ;
        }

    // 若非正确节点，且无并行节点，此路径错误，退出
    } else {  // if( pPathNextNode == NULL || pPathNextNode->pOneTreeCplLevel->cSplitFlag != '+' ) {
        // freeCompileInfoNode( &(pCompileInfoFather->next) ); 
// printf("111111111111111111111111111111111111111111111 pCompileInfoFather = %p\n", pCompileInfoFather);
        // 20231104
        // freeAllCompileInfo4OnePath( pCompileInfoFather );
        freeAllCompileInfo4OnePath( pCompileInfoFather->next );
        freeCompileInfoNode( & (pCompileInfoFather->next) );
        pstCompileInfoTail = pCompileInfoFather;

        if( pText > pTextBfGoBack )
            pTextBfGoBack = pText;

        // 释放注释节点
        if( pCompileInfoNew->pComments_PassCode )
            freeStringList( & (pCompileInfoNew->pComments_PassCode) );

        if( isDebug4ThisShortPath ) printf("Failed to go here ! [%c]\n\n", cSplitFlag);

        cCmpIndentFlag = cCmpIndentFlagSave;

        return false;
    }
	
    // 切换下一个节点类型
    cTreeLevelType = pPathNextNode->pOneTreeCplLevel->cType;

// printf("NNNNNNNNN pPathNextNode->pOneTreeCplLevel->cType = %d, cSplitFlag = %c\n", cTreeLevelType, cSplitFlag);  // debug
    // 下一个节点类型如果是 空格型, 直接循环
    if( cTreeLevelType == TYPE_B || cTreeLevelType == TYPE_T || cTreeLevelType == TYPE_N
     || cTreeLevelType == TYPE_BLANK || cTreeLevelType == TYPE_ANY )
    {
        continue;
    }

    // 若下一个节点类型不是上述空格型, 跳过空格符
    if( cSplitFlag == '/' ) {
        char * pTextBf = pText;
        char * pLineHeadBf = pLineHead;
        unsigned int iLineHeadKgfBf = iLineHeadKgf;
        unsigned int iLineNumBf = iLineNum;
        char cCmpIndentFlagBf = cCmpIndentFlag;

        passKgf_Comment();

        if( iLineNum > iLineNumBf )
        {
            pText = pTextBf;
            pLineHead = pLineHeadBf;
            iLineHeadKgf = iLineHeadKgfBf;
            iLineNum = iLineNumBf;
            cCmpIndentFlag = cCmpIndentFlagBf;

            if( (*(pPathNextNode->pOneTreeCplLevel->pPathY + iPathY) == 'e' || *(pPathNextNode->pOneTreeCplLevel->pPathY + iPathY) == 'E')
             && ! pPathNextNode->nextNode   // 是否走完路径
            )
            {
                *isNLoop = false;
                break ;
            }

            // 可跳过
            if( ATTR_CAN_SKIP & pPathNextNode->pOneTreeCplLevel->iAttrFlag )
            {
                isRightIndent = false;
                // (*iSkipNodeCount) ++ ;
                continue ;
            }

            if( pText > pTextBfGoBack )
                pTextBfGoBack = pText;

            // 释放注释节点
            if( pCompileInfoNew->pComments_PassCode )
                freeStringList( & (pCompileInfoNew->pComments_PassCode) );

            if( isDebug4ThisShortPath ) printf("Failed to go here 333 !\n\n");

            freeAllCompileInfo4OnePath( pCompileInfoFather->next );
            freeCompileInfoNode( & (pCompileInfoFather->next) );
            pstCompileInfoTail = pCompileInfoFather;

            cCmpIndentFlag = cCmpIndentFlagSave;
            return false;
        }
    } else if( cSplitFlag == '\\' ) {
        if( *pText == ' ' || *pText == '\t' || *pText == '\n' || *pText == '\r' )
        {
            if( (*(pPathNextNode->pOneTreeCplLevel->pPathY + iPathY) == 'e' || *(pPathNextNode->pOneTreeCplLevel->pPathY + iPathY) == 'E')
             && ! pPathNextNode->nextNode   // 是否走完路径
            )
            {
                *isNLoop = false;
                break ;
            }

            // 可跳过
            if( ATTR_CAN_SKIP & pPathNextNode->pOneTreeCplLevel->iAttrFlag )
            {
                isRightIndent = false;
                // (*iSkipNodeCount) ++ ;
                continue ;
            }

            if( pText > pTextBfGoBack )
                pTextBfGoBack = pText;

            // 释放注释节点
            if( pCompileInfoNew->pComments_PassCode )
                freeStringList( & (pCompileInfoNew->pComments_PassCode) );

            if( isDebug4ThisShortPath ) printf("Failed to go here !\n\n");

            freeAllCompileInfo4OnePath( pCompileInfoFather->next );
            freeCompileInfoNode( & (pCompileInfoFather->next) );
            pstCompileInfoTail = pCompileInfoFather;

            cCmpIndentFlag = cCmpIndentFlagSave;
            return false;
        }
    } else { // if( cSplitFlag == '|' )

        unsigned int iLineNumBf = iLineNum;
        passKgf_Comment();

        if( (ATTR_NEXT_LINE & pPathNextNode->pOneTreeCplLevel->iAttrFlag) && (iLineNum - iLineNumBf) != 1 )
        {
            if( pText > pTextBfGoBack )
                pTextBfGoBack = pText;

            // 释放注释节点
            if( pCompileInfoNew->pComments_PassCode )
                freeStringList( & (pCompileInfoNew->pComments_PassCode) );

            if( isDebug4ThisShortPath ) printf("Failed to go here !\n\n");

            freeAllCompileInfo4OnePath( pCompileInfoFather->next );
            freeCompileInfoNode( & (pCompileInfoFather->next) );
            pstCompileInfoTail = pCompileInfoFather;

            cCmpIndentFlag = cCmpIndentFlagSave;
            return false;
        }
        else if( (ATTR_NEXT_LINES & pPathNextNode->pOneTreeCplLevel->iAttrFlag) && (iLineNum == iLineNumBf) )
        {
            if( pText > pTextBfGoBack )
                pTextBfGoBack = pText;

            // 释放注释节点
            if( pCompileInfoNew->pComments_PassCode )
                freeStringList( & (pCompileInfoNew->pComments_PassCode) );

            if( isDebug4ThisShortPath ) printf("Failed to go here !\n\n");

            freeAllCompileInfo4OnePath( pCompileInfoFather->next );
            freeCompileInfoNode( & (pCompileInfoFather->next) );
            pstCompileInfoTail = pCompileInfoFather;

            cCmpIndentFlag = cCmpIndentFlagSave;
            return false;
        }

        /////////////////////////////////////////////////////////////////
        // 检查下一个节点的缩进情况
        /////////////////////////////////////////////////////////////////
        if( cIndentType != INDENT_COMPILER && cIndentType != INDENT_COMPILER_TRANSLATOR )
            continue ;

        // if( cSplitFlag != '|' ) // || cCmpIndentFlag == CMP_INDENT_BLANK )
            // continue ;

        // 节点是否忽略缩进
        if( ATTR_SKIP_INDENT & pPathNextNode->pOneTreeCplLevel->iAttrFlag )
            continue ;

        // 同一行，无需检查缩进 
        // if( iLineNum == iLineNumBf )
            // continue ;

        // 表达式里 或 忽略缩进属性里，无需检查缩进
        if( iDoWithOneLineNodeCount || iCount4SkipIndentTree )
            continue ;

        if( *pText == '\0' )
            continue ;

        ////////////////////////////////////////////////////////////////

        unsigned int iPathNextNodeIndent = pPathNextNode->pOneTreeCplLevel->iIndent + pstIndentSum4GoNextTree4Cpl->iNum;
        isRightIndent = true;

// printf("Check next indent : cCmpIndentFlag=[%d], pstIndentTail->iEtcIdnNum=[%d], iPathNextNodeIndent=[%d]\n", cCmpIndentFlag, pstIndentTail->iEtcIdnNum, iPathNextNodeIndent);  // debug
// printStrForDebug("Next indent", pLineHead, iLineHeadKgf + 3);   // debug

        // 若缩进错误
        if( pLineHead == pText    // 要刚刚分行才进行缩进正确的判断 
         && (  (cCmpIndentFlag == CMP_INDENT_SAME && pstIndentTail->iEtcIdnNum != iPathNextNodeIndent )
            || (cCmpIndentFlag == CMP_INDENT_ADD  && pstIndentTail->iEtcIdnNum >= iPathNextNodeIndent )
            || (cCmpIndentFlag == CMP_INDENT_SUB  && pstIndentTail->iEtcIdnNum <= iPathNextNodeIndent )
            || (cCmpIndentFlag == CMP_INDENT_ERROR ) )
        ) {
            if( ATTR_CAN_SKIP & pPathNextNode->pOneTreeCplLevel->iAttrFlag )
            {
                isRightIndent = false;
                // (*iSkipNodeCount) ++ ;
                continue ;
            }

            if( pText > pTextBfGoBack )
                pTextBfGoBack = pText;

            // 释放注释节点
            if( pCompileInfoNew->pComments_PassCode )
                freeStringList( & (pCompileInfoNew->pComments_PassCode) );

            if( isDebug4ThisShortPath ) printf("Failed to go here !\n\n");

            freeAllCompileInfo4OnePath( pCompileInfoFather->next );
            freeCompileInfoNode( & (pCompileInfoFather->next) );
            pstCompileInfoTail = pCompileInfoFather;

            cCmpIndentFlag = cCmpIndentFlagSave;
            return false;
        }

        // 检查缩进后退
        // 走到这一步，说明分行缩减标识cCmpIndentFlag 和 etc缩进配置能匹配上
        // 但不代表实际缩减幅度能匹配上，有可能缩减跨了不只是1级，需要继续通过缩进空格长度继续匹配
        if( cCmpIndentFlag == CMP_INDENT_SUB && pLineHead == pText )   // 要刚刚分行才进行缩进正确的判断
        {
            struct stIndent * pIndentBfCheck = pstIndentTail;
            unsigned int iPathNextNodeIndent = pPathNextNode->pOneTreeCplLevel->iIndent + pstIndentSum4GoNextTree4Cpl->iNum;

            // 只检查当前 Tree 维度下的缩进关系
            for( ; pIndentBfCheck; pIndentBfCheck=pIndentBfCheck->before )
            {
/*******************************
char cTmp = *(pIndentBfCheck->pStr + pIndentBfCheck->iStrLen + 3);
*(pIndentBfCheck->pStr + pIndentBfCheck->iStrLen + 3) = '\0';
printf("\npIndentBfCheck indent : [%s]\n", pIndentBfCheck->pStr);
*(pIndentBfCheck->pStr + pIndentBfCheck->iStrLen + 3) = cTmp;

printf("pIndentBfCheck->iEtcIdnNum=[%d] | iPathNextNodeIndent=[%d] | pIndentBfCheck->iStrLen=[%d] | iLineHeadKgf=[%d]\n", pIndentBfCheck->iEtcIdnNum, iPathNextNodeIndent, pIndentBfCheck->iStrLen, iLineHeadKgf);  //  debug
*******************************/

                // Tree解析边界
                if( pIndentBfCheck->cLastNodeOfBeforeTree == 'Y' )
                {
// printf("pIndentBfCheck->cLastNodeOfBeforeTree = YYYYYYYYYYYYYYYYYYYYYYYYYY !!!!!!!!!!!!!!!!!!!!1\n");
                    // 缩进比它大的，跳过不检查
                    if( pIndentBfCheck->iEtcIdnNum > iPathNextNodeIndent )
                        continue ;

// printf("pIndentBfCheck->cLastNodeOfBeforeTree = RRRRRRRRRRRRRRRRRRRRRRRRRRRRRR !!!!!!!!!!!!!!!!!!!!1\n");
                    // 否则，退出该Tree路径解析
                    if( pText > pTextBfGoBack )
                        pTextBfGoBack = pText;

                    ////////////////////////////
                    // 释放注释节点
                    if( pCompileInfoNew->pComments_PassCode )
                        freeStringList( & (pCompileInfoNew->pComments_PassCode) );

                    if( isDebug4ThisShortPath ) printf("Failed to go here !\n\n");

                    freeAllCompileInfo4OnePath( pCompileInfoFather->next );
                    freeCompileInfoNode( & (pCompileInfoFather->next) );
                    pstCompileInfoTail = pCompileInfoFather;
                    cCmpIndentFlag = cCmpIndentFlagSave;
                    return false;
                }

                // 若配置缩进一致，其缩进空格内容必须一致
                if( pIndentBfCheck->iEtcIdnNum == iPathNextNodeIndent )
                {
// printf("pIndentBfCheck->iEtcIdnNum == iPathNextNodeIndent !!!!!!!!!2222\n");  // debug

                    // 若缩进一致，正常往下走
                    if( pIndentBfCheck->iStrLen == iLineHeadKgf && ! strncmp(pLineHead, pIndentBfCheck->pStr, iLineHeadKgf) )
                        break;
                    else if( ATTR_CAN_SKIP & pPathNextNode->pOneTreeCplLevel->iAttrFlag ) {
                        isRightIndent = false;
                        // (*iSkipNodeCount) ++ ;
                        break ;
                    // 若缩进不一致，退出该Tree路径解析
                    } else {
                        if( pText > pTextBfGoBack )
                            pTextBfGoBack = pText;

                        //////////////////////////////////////////
                        // 释放注释节点
                        if( pCompileInfoNew->pComments_PassCode )
                            freeStringList( & (pCompileInfoNew->pComments_PassCode) );

                        if( isDebug4ThisShortPath ) printf("Failed to go here !\n\n");

                        freeAllCompileInfo4OnePath( pCompileInfoFather->next );
                        freeCompileInfoNode( & (pCompileInfoFather->next) );
                        pstCompileInfoTail = pCompileInfoFather;

                        cCmpIndentFlag = cCmpIndentFlagSave;
                        return false;
                    }
                }
                // 这个功能还需要进一步思考和测试补充 ！！！！！！！！！！！！！ ????????
                // 若之前配置缩进比它小，其缩进空格内容也需要比它短
                else if( pIndentBfCheck->iEtcIdnNum < iPathNextNodeIndent )
                {
// printf("pIndentBfCheck->iEtcIdnNum < iPathNextNodeIndent !!!!!!!!!!!!!!!2222\n");  // debug

                    if( pIndentBfCheck->iStrLen < iLineHeadKgf && ! strncmp(pLineHead, pIndentBfCheck->pStr, pIndentBfCheck->iStrLen) )
                        break;
                    else if( ATTR_CAN_SKIP & pPathNextNode->pOneTreeCplLevel->iAttrFlag ) {
                        isRightIndent = false;
                        // (*iSkipNodeCount) ++ ;
                        break ;
                    } else {
                        // 释放注释节点
                        if( pCompileInfoNew->pComments_PassCode )
                            freeStringList( & (pCompileInfoNew->pComments_PassCode) );

                        if( isDebug4ThisShortPath ) printf("Failed to go here !\n\n");

                        freeAllCompileInfo4OnePath( pCompileInfoFather->next );
                        freeCompileInfoNode( & (pCompileInfoFather->next) );
                        pstCompileInfoTail = pCompileInfoFather;

                        cCmpIndentFlag = cCmpIndentFlagSave;
                        return false;
                    }
                }
            }
        } // if( cCmpIndentFlag == CMP_INDENT_SUB )
    } // else { // if( cSplitFlag == '|' )
} // while(true)

    // 所有节点都跳过时，相当于首节点未通过，释放掉多余节点
    // 同时关闭循环
    if( iRightNodeCount4OneShortPath == 0 )
    {
        freeAllCompileInfo4OnePath( pCompileInfoFather->next );
        freeCompileInfoNode( & (pCompileInfoFather->next) );

        pstCompileInfoTail = pCompileInfoFather;
        pstCompileInfoTail->next = NULL;

        // 关闭循环
        *isNLoop = false;
    }

// printf("go2Node end iRightNodeCount4OneShortPath = %d | isNLoop = %d\n", iRightNodeCount4OneShortPath, *isNLoop);  // debug

    return true;
}

/*******************************************
 * findFisrtNodeOfOneShortPath 函数中，应该可以不用处理分割标记 | \ / 
 * 若是真正的第一个节点，不用处理
 * 若是下钻的节点，会在go2NodesOfOneShortPath函数中先处理
 // * 此函数里无需记录 cSplitFlag 值
*******************************************/
bool CZGLanguage::findFisrtNodeOfOneShortPath
(
  struct stPath *pPathList
, unsigned int iPathY
, bool *isNLoop
, struct stPath *pFatherPathNode
, unsigned int iLoopCount
)
{
// printf("findFisrtNodeOfOneShortPath [%p] cType:[%d] pstIndentTail:[%d] iLineNum:[%d] !!!!!!!!\n", pPathList, pPathList->pOneTreeCplLevel->cType, pstIndentTail->iEtcIdnNum, iLineNum);  // debug
// printStrForDebug("pText", pText, 5);
// printStrForDebug("keyword", pPathList->pOneTreeCplLevel->pKeyword, pPathList->pOneTreeCplLevel->iKeywordLen);

    struct stPath * pPathNext = pPathList;
    struct stPath * pPathNextNode = NULL;

    char *pTextSave = pText;

    unsigned int iLineNumSave = iLineNum;
    char * pLineHeadSave = pLineHead;
    unsigned int iLineHeadKgfSave = iLineHeadKgf;

    struct stIndent *pIndentSave = pstIndentTail;

    char cSplitFlagSave = cSplitFlag;

    //////////////////////////////////////////////
    // 并行路径时，根据类型的不同优先级进行解析 : BTN > TYPE_CONT > TREE > LINE > STR > __ANY__
    // 解析优先级不受并行路径自身结构顺序影响
    //////////////////////////////////////////////
while(true)
{
// printf("findFisrtNodeOfOneShortPath while(true) !!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");  // debug

    ////////////////////////////////////////////////
    // cType == BTN Blank

    pPathNext = pPathList;
    for( ; pPathNext; pPathNext=pPathNext->next )
    {
        // 20231209
        // if( pPathList->pOneTreeCplLevel->cType != TYPE_CONT )
            // break;

        pPathNextNode = pPathNext;

        for( ; pPathNextNode; pPathNextNode=pPathNextNode->nextNode )
        {
            // 解析位置归位
            pText = pTextSave;
            iLineNum = iLineNumSave;
            pLineHead = pLineHeadSave;
            iLineHeadKgf = iLineHeadKgfSave;

            pstIndentTail = pIndentSave;
            if( pstIndentTail->next )
                freeIndentList( &(pstIndentTail->next) );
            pstIndentTail->next = NULL;

            // do with kgf first
            unsigned int iSkipNodeCount = 0;
            if( pPathNextNode->pOneTreeCplLevel->cType == TYPE_B && (*pText == ' ' || ATTR_CAN_SKIP & pPathNextNode->pOneTreeCplLevel->iAttrFlag) )
            {
                cTreeLevelType = TYPE_B;
                if( go2NodesOfOneShortPath(pPathNextNode, iPathY, isNLoop, iLoopCount, &iSkipNodeCount) )
                    return true;
            }
            if( pPathNextNode->pOneTreeCplLevel->cType == TYPE_T && (*pText == '\t' || ATTR_CAN_SKIP & pPathNextNode->pOneTreeCplLevel->iAttrFlag) )
            {
                cTreeLevelType = TYPE_T;
                if( go2NodesOfOneShortPath(pPathNextNode, iPathY, isNLoop, iLoopCount, &iSkipNodeCount) )
                    return true;
            }
            // if( *pText == '\n' && pPathNextNode->pOneTreeCplLevel->cType == TYPE_N )
            if( pPathNextNode->pOneTreeCplLevel->cType == TYPE_N && (*pText == '\n' || ATTR_CAN_SKIP & pPathNextNode->pOneTreeCplLevel->iAttrFlag) )
            {
                cTreeLevelType = TYPE_N;
                if( go2NodesOfOneShortPath(pPathNextNode, iPathY, isNLoop, iLoopCount, &iSkipNodeCount) )
                    return true;
            }

            // passKgf();  // for ^^^^   ??????????????????? 和下面代码冲突 ??????? 20230715

            if( pPathNextNode->pOneTreeCplLevel->cType == TYPE_BLANK 
             && (  *pText == ' ' || *pText == '\t' || *pText == '\r' || *pText == '\n' 
                || ATTR_CAN_SKIP & pPathNextNode->pOneTreeCplLevel->iAttrFlag
                )
            )
            {
                cTreeLevelType = TYPE_BLANK;
                unsigned int iSkipNodeCount = 0;
                if( go2NodesOfOneShortPath(pPathNextNode, iPathY, isNLoop, iLoopCount, &iSkipNodeCount) )
                    return true;

                cSplitFlag = cSplitFlagSave;
            }

            if( pPathNextNode->nextNode && pPathNextNode->nextNode->pOneTreeCplLevel->cSplitFlag == '+' )
                continue ;
            else
                break ;

        } // for( ; pPathNextNode; pPathNextNode=pPathNextNode->nextNode )
    } // for( ; pPathNext; pPathNext=pPathNext->next )

    // 若缩进 不 敏感
    if( cIndentType != INDENT_COMPILER && cIndentType != INDENT_COMPILER_TRANSLATOR )
    {
        passKgf_Comment();

        // 解析初始位置调整为空格后
        pTextSave = pText;
        iLineNumSave = iLineNum;
        pLineHeadSave = pLineHead;
        iLineHeadKgfSave = iLineHeadKgf;
    }

    ///////////////////////////////////////////////////
    // cType == 'C'

    pPathNext = pPathList;
    for( ; pPathNext; pPathNext=pPathNext->next )
    {
        pPathNextNode = pPathNext;

        for( ; pPathNextNode; pPathNextNode=pPathNextNode->nextNode )
        {
            // 解析位置归位
            pText = pTextSave;
            iLineNum = iLineNumSave;
            pLineHead = pLineHeadSave;
            iLineHeadKgf = iLineHeadKgfSave;

            pstIndentTail = pIndentSave;
            if( pstIndentTail->next )
                freeIndentList( &(pstIndentTail->next) );
            pstIndentTail->next = NULL;

            ///////////////////////////////////////////

            if( pPathNextNode->pOneTreeCplLevel->cType == TYPE_CONT )
            {
                passKgf_Comment();  // for ^^

                if( cmpStr(pText, pPathNextNode->pOneTreeCplLevel->pKeyword, pPathNextNode->pOneTreeCplLevel->iKeywordLen)
                 || ATTR_CAN_SKIP & pPathNextNode->pOneTreeCplLevel->iAttrFlag
                )
                {
                    cTreeLevelType = TYPE_CONT;
                    unsigned int iSkipNodeCount = 0;
                    if( go2NodesOfOneShortPath(pPathNextNode, iPathY, isNLoop, iLoopCount, &iSkipNodeCount) )
                        return true;

                    cSplitFlag = cSplitFlagSave;
                }
            } else
                break;

            if( pPathNextNode->nextNode && pPathNextNode->nextNode->pOneTreeCplLevel->cSplitFlag == '+' )
                continue ;
            else
                break ;

        } // for( ; pPathNextNode; pPathNextNode=pPathNextNode->nextNode )
    } // for( ; pPathNext; pPathNext=pPathNext->next )

    ////////////////////////////////////////////////
    // cType == TYPE_PATH

    pPathNext = pPathList;
    for( ; pPathNext; pPathNext=pPathNext->next )
    {
        pPathNextNode = pPathNext;

        for( ; pPathNextNode; pPathNextNode=pPathNextNode->nextNode )
        {
            if( pPathNextNode->pOneTreeCplLevel->cType == TYPE_PATH )
            {
// printStrForDebug("findFisrtNodeOfOneShortPath >> TYPE_PATH", pPathNextNode->pOneTreeCplLevel->pKeyword, pPathNextNode->pOneTreeCplLevel->iKeywordLen);  // debug

                // 解析位置归位
                pText = pTextSave;
                iLineNum = iLineNumSave;
                pLineHead = pLineHeadSave;
                iLineHeadKgf = iLineHeadKgfSave;

                pstIndentTail = pIndentSave;
                if( pstIndentTail->next )
                    freeIndentList( &(pstIndentTail->next) );
                pstIndentTail->next = NULL;

                ///////////////////////////////////////

                cTreeLevelType = TYPE_PATH;

                unsigned int iSkipNodeCount = 0;
                if( go2NodesOfOneShortPath(pPathNextNode, iPathY, isNLoop, iLoopCount, &iSkipNodeCount) )
                    return true;

                if( iSkipNodeCount == 0 && (ATTR_CAN_SKIP & pPathNextNode->pOneTreeCplLevel->iAttrFlag) )
{
// printf("?????????????????????????????????????\n");
                    return true;
}

                cSplitFlag = cSplitFlagSave;
            }

            if( pPathNextNode->nextNode && pPathNextNode->nextNode->pOneTreeCplLevel->cSplitFlag == '+' )
                continue ;
            else
                break ;

        } // for( ; pPathNextNode; pPathNextNode=pPathNextNode->nextNode )
    } // for( ; pPathNext; pPathNext=pPathNext->next )

    ////////////////////////////////////////////////
    // cType == TYPE_EXPR

    pPathNext = pPathList;
    for( ; pPathNext; pPathNext=pPathNext->next )
    {
        pPathNextNode = pPathNext;

        for( ; pPathNextNode; pPathNextNode=pPathNextNode->nextNode )
        {
            if( pPathNextNode->pOneTreeCplLevel->cType == TYPE_EXPR )
            {
                // 解析位置归位
                pText = pTextSave;
                iLineNum = iLineNumSave;
                pLineHead = pLineHeadSave;
                iLineHeadKgf = iLineHeadKgfSave;

                pstIndentTail = pIndentSave;
                if( pstIndentTail->next )
                    freeIndentList( &(pstIndentTail->next) );
                pstIndentTail->next = NULL;

                ///////////////////////////////////////

                cTreeLevelType = TYPE_EXPR;

                unsigned int iSkipNodeCount  = 0;
                if( go2NodesOfOneShortPath(pPathNextNode, iPathY, isNLoop, iLoopCount, &iSkipNodeCount) )
                    return true;

                if( iSkipNodeCount == 0 && (ATTR_CAN_SKIP & pPathNextNode->pOneTreeCplLevel->iAttrFlag) )
                    return true;

                cSplitFlag = cSplitFlagSave;
            }

            if( pPathNextNode->nextNode && pPathNextNode->nextNode->pOneTreeCplLevel->cSplitFlag == '+' )
                continue ;
            else
                break ;

        } // for( ; pPathNextNode; pPathNextNode=pPathNextNode->nextNode )
    } // for( ; pPathNext; pPathNext=pPathNext->next )

    ////////////////////////////////////////////////
    // cType == TYPE_STR

    pPathNext = pPathList;
    for( ; pPathNext; pPathNext=pPathNext->next )
    {
        pPathNextNode = pPathNext;

        for( ; pPathNextNode; pPathNextNode=pPathNextNode->nextNode )
        {
            if( pPathNextNode->pOneTreeCplLevel->cType == TYPE_STR )
            {
                // 解析位置归位
                pText = pTextSave;
                iLineNum = iLineNumSave;
                pLineHead = pLineHeadSave;
                iLineHeadKgf = iLineHeadKgfSave;

                pstIndentTail = pIndentSave;
                if( pstIndentTail->next )
                    freeIndentList( &(pstIndentTail->next) );
                pstIndentTail->next = NULL;

                ////////////////////////////////////////

                cTreeLevelType = TYPE_STR;
                unsigned int iSkipNodeCount = 0;
                if( go2NodesOfOneShortPath(pPathNextNode, iPathY, isNLoop, iLoopCount, &iSkipNodeCount) )
                    return true;

                cSplitFlag = cSplitFlagSave;
            }

            if( pPathNextNode->nextNode && pPathNextNode->nextNode->pOneTreeCplLevel->cSplitFlag == '+' )
                continue ;
            else
                break ;

        } // for( ; pPathNextNode; pPathNextNode=pPathNextNode->nextNode )
    } // for( ; pPathNext; pPathNext=pPathNext->next )

    ////////////////////////////////////////////////
    // cType == TYPE_ANY

    pPathNext = pPathList;
    for( ; pPathNext; pPathNext=pPathNext->next )
    {
        pPathNextNode = pPathNext;

        for( ; pPathNextNode; pPathNextNode=pPathNextNode->nextNode )
        {
            if( pPathNextNode->pOneTreeCplLevel->cType == TYPE_ANY )
            {
                // 解析位置归位
                pText = pTextSave;
                iLineNum = iLineNumSave;
                pLineHead = pLineHeadSave;
                iLineHeadKgf = iLineHeadKgfSave;

                pstIndentTail = pIndentSave;
                if( pstIndentTail->next )
                    freeIndentList( &(pstIndentTail->next) );
                pstIndentTail->next = NULL;

                //////////////////////////////////

                cTreeLevelType = TYPE_ANY;

                unsigned int iSkipNodeCount = 0;
                if( go2NodesOfOneShortPath(pPathNextNode, iPathY, isNLoop, iLoopCount, &iSkipNodeCount) )
                    return true;

                cSplitFlag = cSplitFlagSave;
            }

            if( pPathNextNode->nextNode && pPathNextNode->nextNode->pOneTreeCplLevel->cSplitFlag == '+' )
                continue ;
            else
                break ;

        } // for( ; pPathNextNode; pPathNextNode=pPathNextNode->nextNode )
    } // for( ; pPathNext; pPathNext=pPathNext->next )

    ////////////////////////////////////////////

// printf("findFisrtNodeOfOneShortPath end before check passKgf !!!!!!!!!!!!!!!!\n");

    // 解析不成功，可能是注释
    if( cSplitFlag == '/' )
    {
        char * pTextBf = pText;
        char * pLineHeadBf = pLineHead;
        unsigned int iLineHeadKgfBf = iLineHeadKgf;
        unsigned int iLineNumBf = iLineNum;
        char cCmpIndentFlagBf = cCmpIndentFlag;

        passKgf_Comment();

        if( iLineNumBf != iLineNum )
        {
           pText = pTextBf;
           pLineHead = pLineHeadBf;
           iLineHeadKgf = iLineHeadKgfBf;
           iLineNum = iLineNumBf;
           cCmpIndentFlag = cCmpIndentFlagBf;
        }
        else if( pTextBf != pText )
        {
            pTextSave = pText;
            pPathNext = pPathList;

            // 跳过注释后
            iLineNumSave = iLineNum;
            pLineHeadSave = pLineHead;
            iLineHeadKgfSave = iLineHeadKgf;

            continue ;
        }
    }
    else
    {
        passKgf();
        if( isComment() )
        {
            passKgf_Comment();  // 20231111

            pTextSave = pText;
            pPathNext = pPathList;

            // 跳过注释后
            iLineNumSave = iLineNum;
            pLineHeadSave = pLineHead;
            iLineHeadKgfSave = iLineHeadKgf;

            continue ;
        }
    }

    break ;

} // while(true)

// printf("findFisrtNodeOfOneShortPath end !!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");

    // 20230924
    // 上面无法找到短路径的首节点匹配，看看首节点是否是 CAN_SKIP 节点，etc案例:
/**********************************************
__DEF_SUB_PATH__       __TABLE_NAME__
1        : x0     @           | __NAME__
+        : x1     @           | __VAR_NAME__
         : x2     @           + __NAME__
         : x3     @           | .
         : x4     @           | __NAME__
1        : x5     @ CAN_SKIP  | as               -- !!!!!!
         : x6     @ CAN_SKIP  | __NAME__
**********************************************/
    if( ATTR_CAN_SKIP & pPathList->pOneTreeCplLevel->iAttrFlag )
    {
        cTreeLevelType = pPathList->pOneTreeCplLevel->cType;
        unsigned int iSkipNodeCount = 0;
        if( go2NodesOfOneShortPath(pPathList, iPathY, isNLoop, iLoopCount, &iSkipNodeCount) )
            return true;
    }

    return false;
}

bool CZGLanguage::freeAllCompileInfo4OnePath(struct stCompileInfo *pCompileInfo4OnePath)
{
    if( ! pCompileInfo4OnePath )
        return true;

    if( pCompileInfo4OnePath->pFork )
    {
        freeAllCompileInfo4OnePath(pCompileInfo4OnePath->pFork);
// printf("%p = freeAllCompileInfo4OnePath pFork\n", pCompileInfo4OnePath->pFork);
        freeCompileInfoNode(&(pCompileInfo4OnePath->pFork));
    }

    if( pCompileInfo4OnePath->next )
    {
        freeAllCompileInfo4OnePath(pCompileInfo4OnePath->next);
// printf("%p = freeAllCompileInfo4OnePath next\n", pCompileInfo4OnePath->next);
        freeCompileInfoNode(&(pCompileInfo4OnePath->next));
    }

    return true;
}

bool CZGLanguage::compileOnePath(struct stPath *pPathList, unsigned int iPathY, struct stPath *pFatherPathNode)
{
// printf("compileOnePath cTreeLevelType=[%d], pPathList=[%p], iPathY=[%d], pText=[%p] pstIndentTail->iEtcIdnNum=[%d] iLineNum=%d pstIndentSum4GoNextTree4Cpl->cFlag=%c\n", cTreeLevelType, pPathList, iPathY, pText, pstIndentTail->iEtcIdnNum, iLineNum, pstIndentSum4GoNextTree4Cpl->cFlag);  // debug

    struct stPath *pPathNext = pPathList;
    struct stPath *pPathNextNode = NULL;

    char * pLineHead4NLoop = NULL;
    unsigned int iLineHeadKgf4NLoop = 0;

    // 表达式内：整条路径的开始，是否分行，和分隔符无关，只和行尾符有关，因此分隔符统一给'|'
    if( iDoWithOneLineNodeCount )
        cSplitFlag = '|';
    // 非表达式内：整条路径的开始，分割标识为树下钻前的割标识
    else
        cSplitFlag = pstIndentSum4GoNextTree4Cpl->cFlag;

    char cSplitFlag4NLoop = cSplitFlag;

while( pPathList )
{
// printf("compileOnePath 1/N path | cSplitFlag = %c pPathY:[%c]\n", cSplitFlag, *(pPathList->pOneTreeCplLevel->pPathY + iPathY));  // debug

    bool isNLoop = false;
    if( *(pPathList->pOneTreeCplLevel->pPathY + iPathY) == 'N'
     || *(pPathList->pOneTreeCplLevel->pPathY + iPathY) == 'M'
     || *(pPathList->pOneTreeCplLevel->pPathY + iPathY) == 'P' )
    {
        isNLoop = true;
    }

    // For loop go back
    pLineHead4NLoop = pLineHead;
    iLineHeadKgf4NLoop = iLineHeadKgf;
    cSplitFlag4NLoop = cSplitFlag;

// printStrForDebug("pLineHead4NLoop 111", pLineHead4NLoop, iLineHeadKgf4NLoop + 3);

    unsigned int iLoopCount = 1;
    if( ! findFisrtNodeOfOneShortPath(pPathList, iPathY, &isNLoop, pFatherPathNode, iLoopCount) )
        return false;

    while( isNLoop )
    {
        cSplitFlag = cSplitFlag4NLoop;
// printf("compileOnePath : while( isNLoop ) pPathList=[%p], iPathY=[%d], *pText=[%c], cSplitFlag=[%c]\n", pPathList, iPathY, *pText, cSplitFlag); // debug

        if( *pText == '\0' )
            return true;

// printStrForDebug("pLineHead4NLoop 222", pLineHead4NLoop, iLineHeadKgf4NLoop + 3);
// printf("iLineHeadKgf4NLoop - iLineHeadKgf : %d - %d\n", iLineHeadKgf4NLoop, iLineHeadKgf);

        ///////////////////////////////////////////
        // 若遇到 表达式的换行符，跳过重来
        if( iDoWithOneLineNodeCount && pstLineList->iSplitLen 
          && ! strncmp(pText, pstLineList->pSplit, pstLineList->iSplitLen) 
          && (*(pText+pstLineList->iSplitLen) == '\r' || *(pText+pstLineList->iSplitLen) == '\n') )
        {
            pText += pstLineList->iSplitLen ;   // 跳过分隔符
            continue ;
        }    

        ///////////////////////////////////////////

        char * pTextBf = pText;
        char * pLineHeadBf = pLineHead;
        unsigned int iLineHeadKgfBf = iLineHeadKgf;
        unsigned int iLineNumBf = iLineNum;
        char cCmpIndentFlagBf = cCmpIndentFlag;

        iLoopCount ++ ;
        if( ! findFisrtNodeOfOneShortPath(pPathList, iPathY, &isNLoop, pFatherPathNode, iLoopCount) )
        {
// printf("findFisrtNodeOfOneShortPath break !!!!!!!!!!!!!!!!!!!!!\n");

            pText = pTextBf;
            pLineHead = pLineHeadBf;
            iLineHeadKgf = iLineHeadKgfBf;
            iLineNum = iLineNumBf;
            cCmpIndentFlag = cCmpIndentFlagBf;

            break ;
        }

        // 兜底规则，防止CAN_SKIP造成的正确假象，然后进入死循环
        if( pTextBf == pText )
            break ;
    }

    if( *pText == '\0' )
        return true;

    ////////////////////////////////////////////////////

    // Go to next 1/N path
    pPathNextNode = pPathList->nextNode;
    for( ; pPathNextNode && pPathNextNode->pOneTreeCplLevel->cSplitFlag == '+'; pPathNextNode=pPathNextNode->nextNode );
    for( ; pPathNextNode; pPathNextNode=pPathNextNode->nextNode )
    {
        // 检查最后一个e节点是否被解析到，解析到则错误
        if( *(pPathNextNode->pOneTreeCplLevel->pPathY + iPathY) == 'e' )
        {
/********************************************
if( pstCompileInfoTail->pVal2 )
    printStrForDebug("CplOthername", pstCompileInfoTail->pVal2, pstCompileInfoTail->iValLen2);
else
    printf("CplOthername : %d\n", pstCompileInfoTail->iValLen2);

if( pPathNextNode->pOneTreeCplLevel->pOtherName )
    printStrForDebug("e__Othername", pPathNextNode->pOneTreeCplLevel->pOtherName, pPathNextNode->pOneTreeCplLevel->iOtherNameLen);
else
    printf("e__Othername : %d\n", pPathNextNode->pOneTreeCplLevel->iOtherNameLen);
********************************************/

            struct stPath *pPathTmp = pPathNextNode;
            while( true )
            {
                if( pPathTmp->pOneTreeCplLevel->pOtherName && pPathTmp->pOneTreeCplLevel->iOtherNameLen == pstCompileInfoTail->iValLen2
                 && ! strncmp(pPathTmp->pOneTreeCplLevel->pOtherName, pstCompileInfoTail->pVal2, pPathTmp->pOneTreeCplLevel->iOtherNameLen) )
                {
                    return retErrInfo4CodeFile("Last node must be NULL for 'e' path_node !");
                }
                else if( ! pPathTmp->pOneTreeCplLevel->pOtherName && pPathTmp->pOneTreeCplLevel->iOtherNameLen == pstCompileInfoTail->iValLen2 )
                {
                    return retErrInfo4CodeFile("Last node must be NULL for 'e' path_node !");
                }

                pPathTmp = pPathTmp->nextNode;
                if( ! pPathTmp || pPathTmp->pOneTreeCplLevel->cSplitFlag != '+' )
                    break ;

/**********************************************
if( pPathTmp->pOneTreeCplLevel->pOtherName )
printStrForDebug("e__Othername", pPathTmp->pOneTreeCplLevel->pOtherName, pPathTmp->pOneTreeCplLevel->iOtherNameLen);
else
printf("e__Othername : %d\n", pPathTmp->pOneTreeCplLevel->iOtherNameLen);
**********************************************/
            }
        }

        if( *(pPathNextNode->pOneTreeCplLevel->pPathY + iPathY) != ' ' 
         && *(pPathNextNode->pOneTreeCplLevel->pPathY + iPathY) != 'e'
         && *(pPathNextNode->pOneTreeCplLevel->pPathY + iPathY) != 'E' )
            break ;
    }

    if( pPathNextNode == NULL )
        return true;

    pPathList = pPathNextNode;
    cSplitFlag = pPathList->pOneTreeCplLevel->cSplitFlag;

} // while( pPathList )

    return true;
}

bool CZGLanguage::compileCodeFile(char cRunTypeParm, char *srcFile, char *outputFile)
{
// printf("compileCodeFile !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! [%p]\n", pstExprRetHead);  // debug

    cRunType = cRunTypeParm;
    if( cRunType == 'R' || cRunType == 'F' )
        isFuzzy = true;

    // iCplFileSize = getFileSize(srcFile) + 4;
	iCplFileSize = getFileSize(srcFile);
    if( iCplFileSize == 0 )
    {
        printf("The file %s is empty !\n", srcFile);
        return false;
    }
    if( iCplFileSize > 53687090 )
    {
        printf("The file %s is too large !\n", srcFile);
        return false;
    }
    /*************
    iCplFd = open(srcFile, O_RDONLY);
    if( iCplFd == -1 )
    {
        printf("!!! warning !!! : Open the file '%s' failed !\n", srcFile);
        return false;
    }
    ****************/
    
    pCplFd = fopen(srcFile, "rb");
    if( pCplFd == NULL )
    {
        printf("!!! warning !!! : Open the file '%s' failed !\n", srcFile);
        return false;
    }

    /*************************
    // pCplMmp = mmap(NULL, iCplFileSize, PROT_WRITE, MAP_PRIVATE, iCplFd, 0);
    pCplMmp = mmap(NULL, iCplFileSize, PROT_WRITE, MAP_PRIVATE, iCplFd, 0);
    if( pCplMmp == MAP_FAILED )
    {
        printf("!!! warning !!! : Mmap the file '%s' failed !\n", srcFile);
        return false;
    }
    *************************/
    pCplMmp = malloc(iCplFileSize+4);
    if( pCplMmp == NULL )
    {
        printf("!!! warning !!! : malloc failed !\n");
        return false;
    }
    memset(pCplMmp+iCplFileSize, 0x00, 4);
    // 将文件拷贝到内存中
    fread(pCplMmp, 1, iCplFileSize, pCplFd);
	
	/////////////////////////////////////////////// 20260227
	// 将分行符 \r\n \r 统一成 \n，避免输出显示问题
	pText = (char *)pCplMmp;
	pTextBfGoBack = pText;
	for( ; *pTextBfGoBack; )
	{
		if( *pTextBfGoBack == '\r' && *(pTextBfGoBack+1) == '\n' )
			pTextBfGoBack ++ ;
		else if( *pTextBfGoBack == '\r' )
			*pTextBfGoBack = '\n';
		
		*pText = *pTextBfGoBack;
			
		pText ++ ;
		pTextBfGoBack ++ ;
	}
	for( ; *pText; pText ++ ) *pText = '\0';
	
    //////////////////////////////////////////////////
    pfOpf = fopen(outputFile, "w+");
    if( ! pfOpf )
    {
        printf("Fail to open output file [%s] !\n", outputFile);
        return false;
    }
    ///////////////////////////////////////////////////////////////////

    pText = (char *)pCplMmp;
    pLineHead = pText;
    pTextBfGoBack = pText;
    pText4FuzzyStart = pText;
    pText4FuzzyEnd = pText;
    iLineNum4FuzzyStart = 1;
    iLineNum4FuzzyEnd = 1;

    if( *(pText + iCplFileSize-1) != '\n' )
        *(pText + iCplFileSize) = '\n'; // 为了防止换行边界BUG

    // 20221113
    iLineNum = 1;
    iLineHeadKgf = 0;
    for(char *pTmp=pLineHead; *pTmp == ' ' || *pTmp == '\t'; pTmp ++ ) iLineHeadKgf ++ ;

    // 缩进初始化处理
    // pstIndentHead = getStringNode();
    // memset(pstIndentHead, 0x00, sizeof(struct stString));
    pstIndentHead = (struct stIndent *)getStringNode();
    memset(pstIndentHead, 0x00, sizeof(struct stIndent));
    pstIndentHead->pStr = pText;
    pstIndentHead->iStrLen = 0;
    pstIndentTail = pstIndentHead;

    if( *(pLineHead + iLineHeadKgf) == '\n' || *(pLineHead + iLineHeadKgf) == '\r' ) {
        // cCmpIndentFlag = CMP_INDENT_BLANK;
    } else if( iLineHeadKgf > 0 )
        cCmpIndentFlag = CMP_INDENT_ADD;
    else
        cCmpIndentFlag = CMP_INDENT_SAME;

    makePathHeadListByType();

    ///////////////////////////////////////////////////////

    // 解析结果的开始节点
    pstCompileInfoHead = getCompileInfoNode();
    memset(pstCompileInfoHead, 0x00, sizeof(struct stCompileInfo));
    pstCompileInfoTail = pstCompileInfoHead;

    pstCompileInfoTail->pFork = getCompileInfoNode();
    memset(pstCompileInfoTail->pFork, 0x00, sizeof(struct stCompileInfo));
    pstCompileInfoTail = pstCompileInfoTail->pFork;

    if( ! compileTextByTree(NULL, NULL) )
    {
// printStrForDebug("pText", pText, pTextBfGoBack - pText);

        printf("========================== !!! COMPILE ERROR !!! ===============================\n");
        printf("|1| Line : %d\n", iLineNum);
        *pTextBfGoBack = '\0';
        printf("|2| %s<<< \n", pText);

        return false;
    }

    if( pText4FuzzyStart != pText4FuzzyEnd && cRunType != 'F' )
    {
        char cTmp = *pText4FuzzyEnd;
        *pText4FuzzyEnd = '\0';

        printf("============================ !!! Pass code start !!! ============================\n");
        printf("Lines : %d ~ %d\n", iLineNum4FuzzyStart, iLineNum4FuzzyEnd);
        printf("%s\n", pText4FuzzyStart);
        printf("----------------------------- !!! Pass code end !!! ----------------------------\n");
        *pText4FuzzyEnd = cTmp;
    }

    orderCplInfoHeadByPriority();
    outputCompileInfo();

    return true;
}

bool CZGLanguage::addCompileInfoHead()
{
    // 在生成新的CompileInfo头节点分支前，将模糊解析跳过的代码挂载到当前头节点上
    if( pText4FuzzyStart != pText4FuzzyEnd )
    {
        pstCompileInfoHead->pComments_PassCode = getStringNode();
        memset(pstCompileInfoHead->pComments_PassCode, 0x00, sizeof(struct stString));
        pstCompileInfoHead->pComments_PassCode->pStr = pText4FuzzyStart;
        pstCompileInfoHead->pComments_PassCode->iStrLen = pText4FuzzyEnd - pText4FuzzyStart;
    }

    ///////////////////////////////////////

    struct stCompileInfo *pCompileInfoNew = getCompileInfoNode();
    memset(pCompileInfoNew, 0x00, sizeof(struct stCompileInfo));
    pCompileInfoNew->next = pstCompileInfoHead;
    pstCompileInfoHead = pCompileInfoNew;
    pstCompileInfoTail = pstCompileInfoHead;

    pstCompileInfoTail->pFork = getCompileInfoNode();
    memset(pstCompileInfoTail->pFork, 0x00, sizeof(struct stCompileInfo));
    pstCompileInfoTail = pstCompileInfoTail->pFork;

    pstCompileInfoTail->mType[IDX_OBJ] = 'P';   // Tree

    return true;
}

bool CZGLanguage::compileTextByTree(struct stTree *pOneTree, struct stPath *pFatherPathNode)
{
// printf("compileTextByTree [%p][%p][%c]\n", pOneTree, pFatherPathNode, *pText);  // debug

    // For fork tree
    if( pOneTree )
    {
        pstCompileInfoTail->pFork = getCompileInfoNode();
// printf("compileTextByTree new pstCompileInfoTail->pFork = %p->%p\n", pstCompileInfoTail, pstCompileInfoTail->pFork);  // debug
        memset(pstCompileInfoTail->pFork, 0x00, sizeof(struct stCompileInfo));
        pstCompileInfoTail = pstCompileInfoTail->pFork;
    }

    // For first node
    pstCompileInfoTail->mType[IDX_OBJ] = 'P';   // Tree

    bool isCompileOnePath = false;
    char *pTextSave = pText;                    // 若有路径走通，则 pText 不在回头
    unsigned int iLineNumSave = iLineNum;       // 行数跟着 pText 变动
    char * pLineHeadSave = pLineHead;
    unsigned int iLineHeadKgfSave = iLineHeadKgf;   //

//  每一次循环成功，代表有一条路径成功走通
// while( *pText )
// 当下钻的时候，即使文本内容已经已经解析完毕，依然需要继续解析，要么报错，要么跳过SKIP正常退出
while( *pText || pOneTree )
{
// printf("\ncompileTextByTree : while( *pText ) = [%c], pOneTree=[%p], pstIndentHead:Tail=[%p:%p], iLineNum=%d\n", *pText, pOneTree, pstIndentHead, pstIndentTail, iLineNum); // debug

    if( isFuzzy && ! pOneTree && isCompileOnePath )
    {
        if( cRunType == 'F' )
        {
            char cTmp = *(pstCompileInfoHead->next->pFork->next->pObjName + pstCompileInfoHead->next->pFork->next->iObjNameLen);
            *(pstCompileInfoHead->next->pFork->next->pObjName + pstCompileInfoHead->next->pFork->next->iObjNameLen) = '\0';

            printf("\n--------------------------------------------------------------------\n");
            printf("### Found code by : %s | Lines : %d ~ %d :\n", pstCompileInfoHead->next->pFork->next->pObjName, iLineNum4FuzzyEnd, iLineNum);
            printf("--------------------------------------------------------------------\n");

            *(pstCompileInfoHead->next->pFork->next->pObjName + pstCompileInfoHead->next->pFork->next->iObjNameLen) = cTmp;

            //////////////////////////////////////////

            cTmp = *pText;
            *pText = '\0';

            printf("%s\n", pText4FuzzyEnd);

            *pText = cTmp;
        }
        else if( pText4FuzzyStart != pText4FuzzyEnd )
        {
            char cTmp = *pText4FuzzyEnd;
            *pText4FuzzyEnd = '\0';

            printf("============================ !!! Pass code start !!! ============================\n");
            printf("Lines : %d ~ %d\n", iLineNum4FuzzyStart, iLineNum4FuzzyEnd);
            printf("%s\n", pText4FuzzyStart);
            printf("----------------------------- !!! Pass code end !!! ----------------------------\n");

            *pText4FuzzyEnd = cTmp;
        }

        pText4FuzzyStart = pText;
        pText4FuzzyEnd = pText;

        iLineNum4FuzzyStart = iLineNum;
        iLineNum4FuzzyEnd = iLineNum;
    }

    isCompileOnePath = false;
    pTextSave = pText;                 // 若有路径走通，则 pText 不在回头
    iLineNumSave = iLineNum;           // 行数跟着 pText 变动
    pLineHeadSave = pLineHead;
    iLineHeadKgfSave = iLineHeadKgf;   // 

    struct stCompileInfo * pCompileInfoTailSave = pstCompileInfoTail;

    struct stIndent * pIndentSave = pstIndentTail;

    cTreeLevelType = 0;

    // 20231015
    if( ! pOneTree )
        cCmpIndentFlag = CMP_INDENT_SAME;
    char cCmpIndentFlagSave = cCmpIndentFlag;

    if( *pText == ' ' || *pText == '\t' || *pText == '\r' || *pText == '\n'  )
    {
        struct stString * pPathHeadListTmp = pPathHeadList4B;
        for( ; pPathHeadListTmp; pPathHeadListTmp=pPathHeadListTmp->next )
        {
            if( pOneTree && ((struct stPathHead *)(pPathHeadListTmp->pp))->pTree != pOneTree )
                continue ;

            struct stPathHead *pOnePathHead = (struct stPathHead *)(pPathHeadListTmp->pp);
// printStrForDebug("Tree", pOnePathHead->pTree->pName, pOnePathHead->pTree->iNameLen);  // debug
// printf("Path : %d\n", pOnePathHead->iPathY);  // debug

            if( isFailText4ObjPoint(pOnePathHead->pPathList) )
                continue ;

            // Pass sub tree for first tree
            if( ! pOneTree && pOnePathHead->pTree->cType == 'p' )
                continue ;

            if( *pText == ' ' )
                cTreeLevelType = TYPE_B;
            else
                continue;

            pstCompileInfoTail->pObjName = pOnePathHead->pTree->pName;
            pstCompileInfoTail->iObjNameLen = pOnePathHead->pTree->iNameLen;
            pstCompileInfoTail->iPriority = pOnePathHead->pTree->iPriority;

            if( compileOnePath(pOnePathHead->pPathList, pOnePathHead->iPathY - 1, pFatherPathNode) ) {
                isCompileOnePath = true;
                break ;
            } else {
                isCompileOnePath = false;
                pText = pTextSave;
                iLineNum = iLineNumSave;
                pLineHead = pLineHeadSave;
                iLineHeadKgf = iLineHeadKgfSave;

                pstCompileInfoTail = pCompileInfoTailSave;
                if( pstCompileInfoTail->next )   // 20220904
                    freeCompileInfoList( &(pstCompileInfoTail->next) );
                pstCompileInfoTail->next = NULL;

                pstIndentTail = pIndentSave;
                if( pstIndentTail->next )
                    freeIndentList( &(pstIndentTail->next) );
                pstIndentTail->next = NULL;
                cCmpIndentFlag = cCmpIndentFlagSave;

                addFailText4ObjPoint(pOnePathHead->pPathList);
            }
        }

        pstIndentTail = pIndentSave;
        if( pstIndentTail->next )
            freeIndentList( &(pstIndentTail->next) );
        pstIndentTail->next = NULL;

        if( isCompileOnePath ) 
        {
            if( pOneTree ) return true;

            orderTreeNodeByPriority(pstCompileInfoHead);
            addCompileInfoHead();

            continue;
        }

        /////////////////////////////////////////////////////////////////////

        pPathHeadListTmp = pPathHeadList4T;
        for( ; pPathHeadListTmp; pPathHeadListTmp=pPathHeadListTmp->next )
        {
            if( pOneTree && ((struct stPathHead *)(pPathHeadListTmp->pp))->pTree != pOneTree )
                continue ;

            struct stPathHead *pOnePathHead = (struct stPathHead *)(pPathHeadListTmp->pp);
// printStrForDebug("Tree", pOnePathHead->pTree->pName, pOnePathHead->pTree->iNameLen);  // debug
// printf("Path : %d\n", pOnePathHead->iPathY);  // debug

            if( isFailText4ObjPoint(pOnePathHead->pPathList) )
                continue ;

            // Pass sub tree for first tree
            if( ! pOneTree && pOnePathHead->pTree->cType == 'p' )
                continue ;

            if( *pText == '\t' ) 
                cTreeLevelType = TYPE_T;
            else
                continue;

            pstCompileInfoTail->pObjName = pOnePathHead->pTree->pName;
            pstCompileInfoTail->iObjNameLen = pOnePathHead->pTree->iNameLen;
            pstCompileInfoTail->iPriority = pOnePathHead->pTree->iPriority;

            if( compileOnePath(pOnePathHead->pPathList, pOnePathHead->iPathY - 1, pFatherPathNode) ) {
                isCompileOnePath = true;
                break ;
            } else {
                isCompileOnePath = false;
                pText = pTextSave;
                iLineNum = iLineNumSave;
                pLineHead = pLineHeadSave;
                iLineHeadKgf = iLineHeadKgfSave;

                pstCompileInfoTail = pCompileInfoTailSave;
                if( pstCompileInfoTail->next )   // 20220904
                    freeCompileInfoList( &(pstCompileInfoTail->next) );
                pstCompileInfoTail->next = NULL;

                pstIndentTail = pIndentSave;
                if( pstIndentTail->next )
                    freeIndentList( &(pstIndentTail->next) );
                pstIndentTail->next = NULL;
                cCmpIndentFlag = cCmpIndentFlagSave;

                addFailText4ObjPoint(pOnePathHead->pPathList);
            }
        }

        pstIndentTail = pIndentSave;
        if( pstIndentTail->next )
            freeIndentList( &(pstIndentTail->next) );
        pstIndentTail->next = NULL;

        if( isCompileOnePath )
        {
            if( pOneTree ) return true;

            orderTreeNodeByPriority(pstCompileInfoHead);
            addCompileInfoHead();

            continue;
        }

        /////////////////////////////////////////////////////////////////////

        pPathHeadListTmp = pPathHeadList4N;
        for( ; pPathHeadListTmp; pPathHeadListTmp=pPathHeadListTmp->next )
        {
            if( pOneTree && ((struct stPathHead *)(pPathHeadListTmp->pp))->pTree != pOneTree )
                continue ;

            struct stPathHead *pOnePathHead = (struct stPathHead *)(pPathHeadListTmp->pp);
// printStrForDebug("Tree", pOnePathHead->pTree->pName, pOnePathHead->pTree->iNameLen);  // debug
// printf("Path : %d\n", pOnePathHead->iPathY);  // debug

            if( isFailText4ObjPoint(pOnePathHead->pPathList) )
                continue ;

            // Pass sub tree for first tree
            if( ! pOneTree && pOnePathHead->pTree->cType == 'p' )
                continue ;

            if( *pText == '\r' || *pText == '\n' )
                cTreeLevelType = TYPE_N;
            else
                continue;

            pstCompileInfoTail->pObjName = pOnePathHead->pTree->pName;
            pstCompileInfoTail->iObjNameLen = pOnePathHead->pTree->iNameLen;
            pstCompileInfoTail->iPriority = pOnePathHead->pTree->iPriority;

            if( compileOnePath(pOnePathHead->pPathList, pOnePathHead->iPathY - 1, pFatherPathNode) ) {
                isCompileOnePath = true;
                break ;
            } else {
                isCompileOnePath = false;
                pText = pTextSave;
                iLineNum = iLineNumSave;
                pLineHead = pLineHeadSave;
                iLineHeadKgf = iLineHeadKgfSave;

                pstCompileInfoTail = pCompileInfoTailSave;
                if( pstCompileInfoTail->next )   // 20220904
                    freeCompileInfoList( &(pstCompileInfoTail->next) );
                pstCompileInfoTail->next = NULL;

                pstIndentTail = pIndentSave;
                if( pstIndentTail->next )
                    freeIndentList( &(pstIndentTail->next) );
                pstIndentTail->next = NULL;
                cCmpIndentFlag = cCmpIndentFlagSave;

                addFailText4ObjPoint(pOnePathHead->pPathList);
            }
        }

        pstIndentTail = pIndentSave;
        if( pstIndentTail->next )
            freeIndentList( &(pstIndentTail->next) );
        pstIndentTail->next = NULL;

        if( isCompileOnePath )
        {
            if( pOneTree ) return true;

            orderTreeNodeByPriority(pstCompileInfoHead);
            addCompileInfoHead();

            continue;
        }

        /////////////////////////////////////////////////////////////////////

        pPathHeadListTmp = pPathHeadList4Blank;
        for( ; pPathHeadListTmp; pPathHeadListTmp=pPathHeadListTmp->next )
        {
            if( pOneTree && ((struct stPathHead *)(pPathHeadListTmp->pp))->pTree != pOneTree )
                continue ;

            struct stPathHead *pOnePathHead = (struct stPathHead *)(pPathHeadListTmp->pp);
// printStrForDebug("Tree", pOnePathHead->pTree->pName, pOnePathHead->pTree->iNameLen);  // debug
// printf("Path : %d\n", pOnePathHead->iPathY);  // debug

            if( isFailText4ObjPoint(pOnePathHead->pPathList) )
                continue ;

            // Pass sub tree for first tree
            if( ! pOneTree && pOnePathHead->pTree->cType == 'p' )
                continue ;

            if( *pText == '\r' || *pText == '\n' )
                cTreeLevelType = TYPE_N;
            else
                continue;

            pstCompileInfoTail->pObjName = pOnePathHead->pTree->pName;
            pstCompileInfoTail->iObjNameLen = pOnePathHead->pTree->iNameLen;
            pstCompileInfoTail->iPriority = pOnePathHead->pTree->iPriority;

            if( compileOnePath(pOnePathHead->pPathList, pOnePathHead->iPathY - 1, pFatherPathNode) ) {
                isCompileOnePath = true;
                break ;
            } else {
                isCompileOnePath = false;
                pText = pTextSave;
                iLineNum = iLineNumSave;
                pLineHead = pLineHeadSave;
                iLineHeadKgf = iLineHeadKgfSave;

                pstCompileInfoTail = pCompileInfoTailSave;
                if( pstCompileInfoTail->next )   // 20220904
                    freeCompileInfoList( &(pstCompileInfoTail->next) );
                pstCompileInfoTail->next = NULL;

                pstIndentTail = pIndentSave;
                if( pstIndentTail->next )
                    freeIndentList( &(pstIndentTail->next) );
                pstIndentTail->next = NULL;
                cCmpIndentFlag = cCmpIndentFlagSave;

                addFailText4ObjPoint(pOnePathHead->pPathList);
            }
        }

        pstIndentTail = pIndentSave;
        if( pstIndentTail->next )
            freeIndentList( &(pstIndentTail->next) );
        pstIndentTail->next = NULL;

        if( isCompileOnePath )
        {
            if( pOneTree ) return true;

            orderTreeNodeByPriority(pstCompileInfoHead);
            addCompileInfoHead();

            continue;
        }

        /////////////////////////////////////////////////////////////////////

        pPathHeadListTmp = pPathHeadList4Blank;
        for( ; pPathHeadListTmp; pPathHeadListTmp=pPathHeadListTmp->next )
        {
            if( pOneTree && ((struct stPathHead *)(pPathHeadListTmp->pp))->pTree != pOneTree )
                continue ;

            struct stPathHead *pOnePathHead = (struct stPathHead *)(pPathHeadListTmp->pp);
// printStrForDebug("Tree", pOnePathHead->pTree->pName, pOnePathHead->pTree->iNameLen);  // debug
// printf("Path : %d\n", pOnePathHead->iPathY);  // debug

            if( isFailText4ObjPoint(pOnePathHead->pPathList) )
                continue ;

            // Pass sub tree for first tree
            if( ! pOneTree && pOnePathHead->pTree->cType == 'p' )
                continue ;

            cTreeLevelType = TYPE_BLANK;

            pstCompileInfoTail->pObjName = pOnePathHead->pTree->pName;
            pstCompileInfoTail->iObjNameLen = pOnePathHead->pTree->iNameLen;
            pstCompileInfoTail->iPriority = pOnePathHead->pTree->iPriority;

            if( compileOnePath(pOnePathHead->pPathList, pOnePathHead->iPathY - 1, pFatherPathNode) ) {
                isCompileOnePath = true;
                break ;
            } else {
                isCompileOnePath = false;
                pText = pTextSave;
                iLineNum = iLineNumSave;
                pLineHead = pLineHeadSave;
                iLineHeadKgf = iLineHeadKgfSave;

                pstCompileInfoTail = pCompileInfoTailSave;
                if( pstCompileInfoTail->next )  // 20220904
                    freeCompileInfoList( &(pstCompileInfoTail->next) );
                pstCompileInfoTail->next = NULL;

                pstIndentTail = pIndentSave;
                if( pstIndentTail->next )
                    freeIndentList( &(pstIndentTail->next) );
                pstIndentTail->next = NULL;
                cCmpIndentFlag = cCmpIndentFlagSave;

                addFailText4ObjPoint(pOnePathHead->pPathList);
            }
        }

        pstIndentTail = pIndentSave;
        if( pstIndentTail->next )
            freeIndentList( &(pstIndentTail->next) );
        pstIndentTail->next = NULL;

        if( isCompileOnePath )
        {
            if( pOneTree ) return true;

            orderTreeNodeByPriority(pstCompileInfoHead);
            addCompileInfoHead();

            continue;
        }

        // Pass kgf
        if( *pText == '\r' || *pText == '\n')
        {
            iLineNum ++ ;

            if( *pText == '\r' ) {
                pLineHead = pText + 2;
                pText ++ ;    // pass \r
            } else
                pLineHead = pText + 1;

            iLineHeadKgf = 0;
            for(char * pTmp = pLineHead; *pTmp == ' ' || *pTmp == '\t'; pTmp ++ ) iLineHeadKgf ++ ;

            //////////////////////////////////////
            // 比较上一行缩进
            // 是否为空行
            if( *(pLineHead + iLineHeadKgf + 1) == '\n' || *(pLineHead + iLineHeadKgf + 1) == '\r' ) {
                // cCmpIndentFlag = CMP_INDENT_BLANK;
            // 是否为注释
            } else if(  (pLineComment && ! strncmp(pText, pLineComment, iLineCommentLen) )
                   || (pLinesCommentStart && ! strncmp(pText, pLinesCommentStart, iLinesCommentStartLen)) ) {
                // pass

            // 是否缩进相同
            } else if( iLineHeadKgf == pstIndentTail->iStrLen && ! strncmp(pLineHead, pstIndentTail->pStr, pstIndentTail->iStrLen) )
                cCmpIndentFlag = CMP_INDENT_SAME;
            // 是否缩进增加
            else if( iLineHeadKgf > pstIndentTail->iStrLen && ! strncmp(pLineHead, pstIndentTail->pStr, pstIndentTail->iStrLen) )
                cCmpIndentFlag = CMP_INDENT_ADD;
            // 是否缩进减少
            else if( iLineHeadKgf < pstIndentTail->iStrLen && ! strncmp(pLineHead, pstIndentTail->pStr, iLineHeadKgf) )
                cCmpIndentFlag = CMP_INDENT_SUB;
            else
                cCmpIndentFlag = CMP_INDENT_ERROR;
        }

        pText ++ ;

        if( isFuzzy )
        {
            pText4FuzzyEnd = pText;
            iLineNum4FuzzyEnd = iLineNum;
        }
    }
    else
    {
        // TYPE_CONT
        struct stString * pPathHeadListTmp = pPathHeadList4Cont;
        for( ; pPathHeadListTmp; pPathHeadListTmp=pPathHeadListTmp->next )
        {
// printf("pPathHeadListTmp Path : %d\n", ((struct stPathHead *)(pPathHeadListTmp->pp))->iPathY);  // debug

            if( pOneTree && ((struct stPathHead *)(pPathHeadListTmp->pp))->pTree != pOneTree )
                continue ;

            if( ! cmpStr(pText, pPathHeadListTmp->pStr, pPathHeadListTmp->iStrLen) )
                continue;

            struct stPathHead *pOnePathHead = (struct stPathHead *)(pPathHeadListTmp->pp);
// printf("----------------------- [%c][%c]\n", cSplitFlag, pstIndentSum4GoNextTree4Cpl->cFlag);  // debug
// printStrForDebug("Tree 4 TYPE_CONT", pOnePathHead->pTree->pName, pOnePathHead->pTree->iNameLen);  // debug
// printf("cType : %c, Path : %d\n", pOnePathHead->pTree->cType, pOnePathHead->iPathY);  // debug

            if( isFailText4ObjPoint(pOnePathHead->pPathList) )
                continue ;

            // Pass sub tree for first tree  // why ???
            if( ! pOneTree && pOnePathHead->pTree->cType == 'p' )
                continue ;

            cTreeLevelType = TYPE_CONT;
            iStep4TypeCont = 0;
            
            pstCompileInfoTail->pObjName = pOnePathHead->pTree->pName;
            pstCompileInfoTail->iObjNameLen = pOnePathHead->pTree->iNameLen;
            pstCompileInfoTail->iPriority = pOnePathHead->pTree->iPriority;

            if( compileOnePath(pOnePathHead->pPathList, pOnePathHead->iPathY - 1, pFatherPathNode) ) {
                isCompileOnePath = true;
                break ;
            } else {
                isCompileOnePath = false;
                pText = pTextSave;
                iLineNum = iLineNumSave;
                pLineHead = pLineHeadSave;
                iLineHeadKgf = iLineHeadKgfSave;

                pstCompileInfoTail = pCompileInfoTailSave;
                freeAllCompileInfo4OnePath(pstCompileInfoTail->next);
                if( pstCompileInfoTail->next )   // 20220904
                    freeCompileInfoNode( &(pstCompileInfoTail->next) );
                pstCompileInfoTail->next = NULL;

                pstIndentTail = pIndentSave;
                if( pstIndentTail->next )
                    freeIndentList( &(pstIndentTail->next) );
                pstIndentTail->next = NULL;
                cCmpIndentFlag = cCmpIndentFlagSave;

                addFailText4ObjPoint(pOnePathHead->pPathList);
            }
        }

// printf("\n111111111111 isCompileOnePath pIndentTail = [%d] : Curr iLineHeadKgf = [%d]\n", pstIndentTail->iStrLen, iLineHeadKgf); // debug

        pstIndentTail = pIndentSave;
        if( pstIndentTail->next )
            freeIndentList( &(pstIndentTail->next) );
        pstIndentTail->next = NULL;

        if( isCompileOnePath )
        {
// printf("22222222222 isCompileOnePath pIndentSave = [%d] : Curr iLineHeadKgf = [%d]\n", pIndentSave->iStrLen, iLineHeadKgf); // debug

            if( pOneTree ) return true;

            orderTreeNodeByPriority(pstCompileInfoHead);
            addCompileInfoHead();

            continue;
        }

// printStrForDebug("pTextSave", pTextSave, 5);  // debug
// printStrForDebug("pTextBfGoBack", pTextBfGoBack, 5); // debug
// printf("iStep4TypeCont = [%d]\n", iStep4TypeCont - 1);

// 20260301 可能导致多个关键字开头相同的路径只能走其中一条
//         // 若能进入到常量路径，解析2步以上，但不完则报错
//         if( cTreeLevelType == TYPE_CONT && iStep4TypeCont - 1 > 1 )
//         {
// // printf("Error : Can not go on to compile here 111 !!!\n");  // debug
// 
//             if( ! isFuzzy || pOneTree )
//                 return false;
// 
//             pText ++ ;
//             pText4FuzzyEnd = pText;
//             iLineNum4FuzzyEnd = iLineNum;
// 
//             continue ;
//         }

        /////////////////////////////////////////////////
        // TYPE_STR
        if( pPathHeadList4Str )
        {
            pPathHeadListTmp = pPathHeadList4Str;

            for( ; pPathHeadListTmp; pPathHeadListTmp=pPathHeadListTmp->next )
            {
                if( pOneTree && ((struct stPathHead *)(pPathHeadListTmp->pp))->pTree != pOneTree )
                    continue ;

                struct stPathHead *pOnePathHead = (struct stPathHead *)(pPathHeadListTmp->pp);
// printf("-----------------------\n");  // debug
// printStrForDebug("Tree", pOnePathHead->pTree->pName, pOnePathHead->pTree->iNameLen);  // debug
// printf("cType : %c, Path : %d\n", pOnePathHead->pTree->cType, pOnePathHead->iPathY);  // debug

                if( isFailText4ObjPoint(pOnePathHead->pPathList) )
                    continue ;

                // Pass sub tree for first tree
                if( ! pOneTree && pOnePathHead->pTree->cType == 'p' )
                    continue ;

                cTreeLevelType = TYPE_STR;

                pstCompileInfoTail->pObjName = pOnePathHead->pTree->pName;
                pstCompileInfoTail->iObjNameLen = pOnePathHead->pTree->iNameLen;
                pstCompileInfoTail->iPriority = pOnePathHead->pTree->iPriority;

                if( compileOnePath(pOnePathHead->pPathList, pOnePathHead->iPathY - 1, pFatherPathNode) ) {
                    isCompileOnePath = true;
                    break ;
                } else {
                    isCompileOnePath = false;
                    pText = pTextSave;
                    iLineNum = iLineNumSave;
                    pLineHead = pLineHeadSave;
                    iLineHeadKgf = iLineHeadKgfSave;

                    pstCompileInfoTail = pCompileInfoTailSave;
                    freeAllCompileInfo4OnePath(pstCompileInfoTail->next);
                    if( pstCompileInfoTail->next )   // 20220904
                        freeCompileInfoNode( &(pstCompileInfoTail->next) );
                    pstCompileInfoTail->next = NULL;

                    pstIndentTail = pIndentSave;
                    if( pstIndentTail->next )
                        freeIndentList( &(pstIndentTail->next) );
                    pstIndentTail->next = NULL;
                    cCmpIndentFlag = cCmpIndentFlagSave;

                    addFailText4ObjPoint(pOnePathHead->pPathList);
                }
            }

            pstIndentTail = pIndentSave;
            if( pstIndentTail->next )
                freeIndentList( &(pstIndentTail->next) );
            pstIndentTail->next = NULL;
        }

        if( isCompileOnePath )
        {
            if( pOneTree ) return true;

            orderTreeNodeByPriority(pstCompileInfoHead);
            addCompileInfoHead();

            continue;
        }

        /////////////////////////////////////////////////
        // TYPE_EXPR
        if( pPathHeadList4Line )
        {
            pPathHeadListTmp = pPathHeadList4Line;
            for( ; pPathHeadListTmp; pPathHeadListTmp=pPathHeadListTmp->next )
            {
                if( pOneTree && ((struct stPathHead *)(pPathHeadListTmp->pp))->pTree != pOneTree )
                    continue ;

                struct stPathHead *pOnePathHead = (struct stPathHead *)(pPathHeadListTmp->pp);
// printStrForDebug("Tree", pOnePathHead->pTree->pName, pOnePathHead->pTree->iNameLen);  // debug
// printf("Path : %d\n", pOnePathHead->iPathY);  // debug

                if( isFailText4ObjPoint(pOnePathHead->pPathList) )
                    continue ;

                // Pass sub tree for first tree
                if( ! pOneTree && pOnePathHead->pTree->cType == 'p' )
                    continue ;

                cTreeLevelType = TYPE_EXPR;

                pstCompileInfoTail->pObjName = pOnePathHead->pTree->pName;
                pstCompileInfoTail->iObjNameLen = pOnePathHead->pTree->iNameLen;
                pstCompileInfoTail->iPriority = pOnePathHead->pTree->iPriority;

                if( compileOnePath(pOnePathHead->pPathList, pOnePathHead->iPathY - 1, pFatherPathNode) ) {
                    isCompileOnePath = true;
                    break ;
                } else {
                    isCompileOnePath = false;
                    pText = pTextSave;
                    iLineNum = iLineNumSave;
                    pLineHead = pLineHeadSave;
                    iLineHeadKgf = iLineHeadKgfSave;

                    pstCompileInfoTail = pCompileInfoTailSave;
                    freeAllCompileInfo4OnePath(pstCompileInfoTail->next);
                    if( pstCompileInfoTail->next )   // 20220904
                        freeCompileInfoNode( &(pstCompileInfoTail->next) );
                    pstCompileInfoTail->next = NULL;

                    pstIndentTail = pIndentSave;
                    if( pstIndentTail->next )
                        freeIndentList( &(pstIndentTail->next) );
                    pstIndentTail->next = NULL;
                    cCmpIndentFlag = cCmpIndentFlagSave;

                    addFailText4ObjPoint(pOnePathHead->pPathList);
                }
            }

            pstIndentTail = pIndentSave;
            if( pstIndentTail->next )
                freeIndentList( &(pstIndentTail->next) );
            pstIndentTail->next = NULL;
        }

        if( isCompileOnePath )
        {
            if( pOneTree ) return true;

            orderTreeNodeByPriority(pstCompileInfoHead);
            addCompileInfoHead();

            continue;
        }

        ////////////////////////////////////////////////////////////
        // TYPE_PATH  20230319
        if( pPathHeadList4Tree )
        {
// printf("pPathHeadList4Tree ??????????????????????????????? %p\n", pPathHeadList4Tree);
            pPathHeadListTmp = pPathHeadList4Tree;
            for( ; pPathHeadListTmp; pPathHeadListTmp=pPathHeadListTmp->next )
            {
                if( pOneTree && ((struct stPathHead *)(pPathHeadListTmp->pp))->pTree != pOneTree )
                    continue ;

                struct stPathHead *pOnePathHead = (struct stPathHead *)(pPathHeadListTmp->pp);
// printStrForDebug("Tree", pOnePathHead->pTree->pName, pOnePathHead->pTree->iNameLen);  // debug
// printf("Path : %d\n", pOnePathHead->iPathY);  // debug

                if( isFailText4ObjPoint(pOnePathHead->pPathList) )
                    continue ;

                // Pass sub tree for first tree
                if( ! pOneTree && pOnePathHead->pTree->cType == 'p' )
                    continue ;

                cTreeLevelType = TYPE_EXPR;

                pstCompileInfoTail->pObjName = pOnePathHead->pTree->pName;
                pstCompileInfoTail->iObjNameLen = pOnePathHead->pTree->iNameLen;
                pstCompileInfoTail->iPriority = pOnePathHead->pTree->iPriority;

                if( compileOnePath(pOnePathHead->pPathList, pOnePathHead->iPathY - 1, pFatherPathNode) ) {
                    isCompileOnePath = true;
                    break ;
                } else {
                    isCompileOnePath = false;
                    pText = pTextSave;
                    iLineNum = iLineNumSave;
                    pLineHead = pLineHeadSave;
                    iLineHeadKgf = iLineHeadKgfSave;

                    pstCompileInfoTail = pCompileInfoTailSave;
                    freeAllCompileInfo4OnePath(pstCompileInfoTail->next);
                    if( pstCompileInfoTail->next )   // 20220904
                        freeCompileInfoNode( &(pstCompileInfoTail->next) );
                    pstCompileInfoTail->next = NULL;

                    pstIndentTail = pIndentSave;
                    if( pstIndentTail->next )
                        freeIndentList( &(pstIndentTail->next) );
                    pstIndentTail->next = NULL;
                    cCmpIndentFlag = cCmpIndentFlagSave;

                    addFailText4ObjPoint(pOnePathHead->pPathList);
                }
            }

            pstIndentTail = pIndentSave;
            if( pstIndentTail->next )
                freeIndentList( &(pstIndentTail->next) );
            pstIndentTail->next = NULL;
        }

        if( isCompileOnePath )
        {
            if( pOneTree ) return true;

            orderTreeNodeByPriority(pstCompileInfoHead);
            addCompileInfoHead();

            continue;
        }

// printf("Error : Can not go on to compile here 222 !!!!\n");  // debug

        if( pOneTree )
            return false;

/*****************************
// 20230902
        // 非模糊解析
        if( ! isFuzzy )
        {
            // 看看是否为注释
            if( isComment() )
                continue ;
            else
                return false;
        }
        pText ++ ;
        pText4FuzzyEnd = pText;
        iLineNum4FuzzyEnd = iLineNum;
*****************************/
        // 看看是否为注释，模糊解析下也要解析注释
        if( ! isComment() )
        {
            if( ! isFuzzy )
                return false;

            pText ++ ;
        }

        if( isFuzzy ) {
            pText4FuzzyEnd = pText;
            iLineNum4FuzzyEnd = iLineNum;
        }

    } // if
} // while( *pText )

    return true;

} // compileTextByTree

bool CZGLanguage::orderTreeNodeByPriority(struct stCompileInfo *pTreeCompileInfo)
{
// printf("orderTreeNodeByPriority !!!!!!\n");  // debug

    struct stCompileInfo * pTreeCompileInfo4Order = pTreeCompileInfo->pFork;
    struct stCompileInfo * pTreeCompileInfoSrc = pTreeCompileInfo->pFork->next;
    pTreeCompileInfo4Order->next = NULL;

    while( true )
    {
        struct stCompileInfo * pOneCompileInfo = pTreeCompileInfoSrc;
        if( pOneCompileInfo == NULL )
            break;

        pTreeCompileInfoSrc = pTreeCompileInfoSrc->next;
        pOneCompileInfo->next = NULL;

        struct stCompileInfo *pCompileInfoTmp = pTreeCompileInfo4Order;
        for( ; pCompileInfoTmp; pCompileInfoTmp=pCompileInfoTmp->next )
        {
            if( pCompileInfoTmp->next == NULL )
            {
                pCompileInfoTmp->next = pOneCompileInfo;
                break;
            }

            if( pOneCompileInfo->iPriority > pCompileInfoTmp->next->iPriority )
            {
                pOneCompileInfo->next = pCompileInfoTmp->next;
                pCompileInfoTmp->next = pOneCompileInfo;
                break;
            }
        }
    } // while( true )

    pTreeCompileInfo->pFork = pTreeCompileInfo4Order;

/************************************************************
printf("orderTreeNodeByPriority !!!!!!\n");  // debug

for( pTreeCompileInfo = pTreeCompileInfo->pFork; pTreeCompileInfo; pTreeCompileInfo=pTreeCompileInfo->next )
{
    printf("addr = %p\n", pTreeCompileInfo);
    printf("pFork = %p\n", pTreeCompileInfo->pFork);
    printStrForDebug("Obj Name", pTreeCompileInfo->pObjName, pTreeCompileInfo->iObjNameLen);
    printf("iPriority = %d\n", pTreeCompileInfo->iPriority);
    printStrForDebug("other Name", pTreeCompileInfo->pVal2, pTreeCompileInfo->iValLen2);
    printStrForDebug("value", pTreeCompileInfo->pVal3, pTreeCompileInfo->iValLen3);
    printf("-----------\n");
}
************************************************************/

    return true;
}

bool CZGLanguage::orderCplInfoHeadByPriority()
{
// printf("orderCplInfoHeadByPriority !!!!!!!!!!!!!\n");

/********************************************************
for(struct stCompileInfo * pHeadTmp=pstCompileInfoHead->next; pHeadTmp ; pHeadTmp=pHeadTmp->next )
{
    printf("pFork = %p\n", pHeadTmp->pFork);
    printStrForDebug("obj name", pHeadTmp->pFork->pObjName, pHeadTmp->pFork->iObjNameLen);
    printf("iPriority = %d\n", pHeadTmp->pFork->iPriority);
    printf("-------------------------------\n");
}
printf("-------------------------------\n");
********************************************************/

    struct stCompileInfo * pHeadNew = pstCompileInfoHead;
    pstCompileInfoHead = pstCompileInfoHead->next;
    pHeadNew->next = NULL;

    struct stCompileInfo * pOneHead = pstCompileInfoHead;
    for( ; pOneHead; pOneHead=pstCompileInfoHead )
    {
        pstCompileInfoHead = pstCompileInfoHead->next;
        pOneHead->next = NULL;

        struct stCompileInfo * pHeadTmp = pHeadNew;
        for( ; pHeadTmp; pHeadTmp=pHeadTmp->next )
        {
            if( pHeadTmp->next == NULL ) {
                pHeadTmp->next = pOneHead;
                break;
            } else if( pOneHead->pFork->iPriority > pHeadTmp->next->pFork->iPriority ) {
                pOneHead->next = pHeadTmp->next;
                pHeadTmp->next = pOneHead;
                break;
            }
        }
    }

    pstCompileInfoHead = pHeadNew;

/********************************************************
for(struct stCompileInfo * pHeadTmp=pstCompileInfoHead->next; pHeadTmp ; pHeadTmp=pHeadTmp->next )
{
    printf("pFork = %p\n", pHeadTmp->pFork);
    printStrForDebug("obj name", pHeadTmp->pFork->pObjName, pHeadTmp->pFork->iObjNameLen);
    printf("iPriority = %d\n", pHeadTmp->pFork->iPriority);
    printf("-------------------------------\n");
}
********************************************************/

    return true;
}

bool CZGLanguage::printOneLineCompileInfo(struct stCompileInfo *pLineCompileInfo)
{
printf("printOneLineCompileInfo !!!!!!\n");  // debug

    struct stCompileInfo *pCompileInfoSrc = pLineCompileInfo->pFork;

for( ; pCompileInfoSrc; pCompileInfoSrc=pCompileInfoSrc->next )
{

if( pCompileInfoSrc->mType[IDX_LEFT_PARM] == 'O'
 || pCompileInfoSrc->mType[IDX_LEFT_PARM] == 'B'
 || pCompileInfoSrc->mType[IDX_LEFT_PARM] == 'A' )
{
    printf("addr = %p\n", pCompileInfoSrc);
    printf("pFork = %p\n", pCompileInfoSrc->pFork);
    // printf("iObjId = %d\n", iObjId);
    printStrForDebug("Obj Name", pCompileInfoSrc->pObjName, pCompileInfoSrc->iObjNameLen);
    printf("Type = %c\n", pCompileInfoSrc->mType[IDX_LEFT_PARM]);

    printf("iPriority = %d\n", pCompileInfoSrc->iValLen2);

    struct stString *pOpr = (struct stString *)(pCompileInfoSrc->pVal2);

    if( pCompileInfoSrc->mType[IDX_LEFT_PARM] == 'O' )
        for( ; pOpr->next; pOpr=pOpr->next )
            printStrForDebug("Opr", pOpr->pStr, pOpr->iStrLen);
    else if( pCompileInfoSrc->mType[IDX_LEFT_PARM] == 'B' || pCompileInfoSrc->mType[IDX_LEFT_PARM] == 'A' )
        for( ; pOpr; pOpr=pOpr->next )
            printStrForDebug("Opr", pOpr->pStr, pOpr->iStrLen);

    printf("-----------\n");
}
else
{
    printf("addr = %p\n", pCompileInfoSrc);
    printf("pFork = %p\n", pCompileInfoSrc->pFork);
    // printf("iObjId = %d\n", iObjId);
    printStrForDebug("Obj Name", pCompileInfoSrc->pObjName, pCompileInfoSrc->iObjNameLen);
    printf("Type = %c\n", pCompileInfoSrc->mType[IDX_LEFT_PARM]);

    printf("iPriority = %d\n", pCompileInfoSrc->iPriority);
    printStrForDebug("Val1", pCompileInfoSrc->pVal1, pCompileInfoSrc->iValLen1);
    printf("-----------\n");
}

}

    return true;
}

bool CZGLanguage::writeResultList4Tree
(
  unsigned int iSeq
, char cObjType
, unsigned int iLineNum
, char * pLineHead4This
, unsigned int iLineHeadKgf
, unsigned int iObjId
, char * pObjName
, unsigned int iObjNameLen

, unsigned int iPathY
, char * pOtherName
, unsigned int iOtherNameLen
, char * pValue
, unsigned int iValueLen
)
{

    // 10 split tab
    // + iSeq=10 + objType=2 + iLineNum=10 + iLineHeadKgf=10 + iObjId=10 + iPathY=10
    // + ?iLineHeadKgf? + ?iObjNameLen? + ?other name? + ?value?
    unsigned int iMemSize = 10 + 10+2+10+10+10+10 + iLineHeadKgf + iObjNameLen + iOtherNameLen + iValueLen;

    char cObjNameTmp = *(pObjName + iObjNameLen);
    *(pObjName + iObjNameLen) = '\0';

    char cOtherNameTmp = 0;
    if( pOtherName )
    {
        cOtherNameTmp = *(pOtherName + iOtherNameLen);
        *(pOtherName + iOtherNameLen) = '\0';
    }

    char cValueTmp = 0;
    if( pValue )
    {
        cValueTmp = *(pValue + iValueLen);
        *(pValue + iValueLen) = '\0';
    }

    if( iMemSize >= RES_NODE_SIZE )
    {
        pResultList->next = getStringNode();
        pResultList = pResultList->next;
        memset(pResultList, 0x00, sizeof(struct stString));
    
        pResultList->pStr = (char *)malloc(iMemSize + 8);
        pResultTail = pResultList->pStr;
        pResultList->iStrLen = 0;  // 直接算用完
    }
    else if( pResultList->iStrLen <= iMemSize )
    {
        pResultList->next = getStringNode();
        pResultList = pResultList->next;
        memset(pResultList, 0x00, sizeof(struct stString));

        pResultList->pStr = (char *)malloc(RES_NODE_SIZE);
        pResultList->iStrLen = RES_NODE_SIZE;
        pResultTail = pResultList->pStr;
    }

char * pResult4Print = pResultTail;

    sprintf(pResultTail, "%d\t%c\t%d\t\0", iSeq, cObjType, iLineNum);
    for( ; *pResultTail; pResultTail ++ );

    // Let ' ' to 'b' , '\t' to 't'
    char *pTmp = pLineHead4This;
    for(unsigned int iCount=iLineHeadKgf; iCount; iCount -- )
    {   
        if( *pTmp == ' ' ) 
            *pResultTail = 'b';
        else if( *pTmp == '\t' )
            *pResultTail = 't';

        pResultTail ++ ;
        pTmp ++ ;
    }   
    *pResultTail = '\t';
    pResultTail ++ ;
    *pResultTail = '\0';

    if( pOtherName )
    sprintf( pResultTail
           , "%d\t%s\t%d\t%s\t%s\n\0"
           , iObjId
           , pObjName
           , iPathY
           , pOtherName  // !!!
           , pValue                     // pValue == NULL ? "" : pValue
           );
    else
    sprintf( pResultTail
           , "%d\t%s\t%d\t%d\t%s\n\0"
           , iObjId
           , pObjName
           , iPathY
           , iOtherNameLen  // !!!
           , pValue                     // pValue == NULL ? "" : pValue
           );

// printf("%s", pResult4Print);   // debug
    fputs(pResult4Print, pfOpf);

    *(pObjName + iObjNameLen) = cObjNameTmp;
    if( pOtherName )
        *(pOtherName + iOtherNameLen) = cOtherNameTmp;
    if( pValue )
        *(pValue + iValueLen) = cValueTmp;

    if( pResultList->iStrLen )
    {
        pResultList->iStrLen -= iMemSize;

        for( ; *pResultTail; pResultTail ++ );
    }

    return true;
}

bool CZGLanguage::writeLastResult4Tree
(
  unsigned int iSeq
, unsigned int iObjId4This
, char * pObjName
, unsigned int iObjNameLen
, unsigned int iFirstLineNum4Tree
)
{
    // 10 split tab
    // + iSeq=10 + objType=2 + iLineNum=10 + iLineHeadKgf=10 + iObjId=10 + iPathY=10
    // + ?obj name? + value=10
    unsigned int iMemSize = 10 + 10+2+10+10+10+10 + iObjNameLen + 10;
    
    char cObjNameTmp = *(pObjName + iObjNameLen);
    *(pObjName + iObjNameLen) = '\0';
    
    if( iMemSize >= RES_NODE_SIZE )
    {
        pResultList->next = getStringNode();
        pResultList = pResultList->next;
        memset(pResultList, 0x00, sizeof(struct stString));
    
        pResultList->pStr = (char *)malloc(iMemSize + 8);
        pResultTail = pResultList->pStr;
        pResultList->iStrLen = 0;  // 直接算用完
    }
    else if( pResultList->iStrLen <= iMemSize )
    {
        pResultList->next = getStringNode();
        pResultList = pResultList->next;
        memset(pResultList, 0x00, sizeof(struct stString));
    
        pResultList->pStr = (char *)malloc(RES_NODE_SIZE);
        pResultList->iStrLen = RES_NODE_SIZE;
        pResultTail = pResultList->pStr;
    }
    
    // iSeq ++ ;
    
    sprintf( pResultTail
           , "%d\tP\t\t\t%d\t%s\t\t\t%d\n\0"
           , iSeq
           , iObjId4This
           , pObjName
           , iFirstLineNum4Tree
           );

// printf("%s", pResultTail);
    fputs(pResultTail, pfOpf);
    
    if( pResultList->iStrLen )
    {
        pResultList->iStrLen -= iMemSize;
        for( ; *pResultTail; pResultTail ++ );
    }
    
    *(pObjName + iObjNameLen) = cObjNameTmp;

    return true;
}

bool CZGLanguage::writeResultList4Line
(
  unsigned int iSeq
, char cObjType
, unsigned int iLineNum
, char * pLineHead4This 
, unsigned int iLineHeadKgf
, unsigned int iObjId
, char * pObjName
, unsigned int iObjNameLen

, char cLeftParmType
, char * pLeftParmTypeName
, unsigned int iLeftParmTypeNameLen

, char * pLeftParm
, unsigned int iLeftParmLen

, struct stString * pOpr
, char cOprType

, char cRightParmType
, char * pRightParmTypeName
, unsigned int iRightParmTypeNameLen

, char * pRightParm
, unsigned int iRightParmLen
)
{
    unsigned int iOprLen = 0;
    if( pOpr )
    {
        struct stString * pOprTmp = pOpr;
        if( cOprType == 'O' ) {
            for( ; pOprTmp->next; pOprTmp=pOprTmp->next )
                iOprLen += pOprTmp->iStrLen + 1;
        } else {
            for( ; pOprTmp; pOprTmp=pOprTmp->next )
                iOprLen += pOprTmp->iStrLen + 1;
        }
    }

    // 12 split tab
    // + iSeq=10 + cObjType=2 + iLineNum=10 + iLineHeadKgf=10 + iObjId=10
    // + cLeftParmType=10 + cRightParmType=10 + (iLeftParmLen=10 + iRightParmLen=10)
    // + ?iLineHeadKgf? + ?pLeftParm? + ?pOpr? + ?pRightParm?
    // unsigned int iMemSize = 12 + 10+2+10+10+10 + 4*10 + iLineHeadKgf + iLeftParmLen + iOprLen + iRightParmLen;
    unsigned int iMemSize = 12 + 10+2+10+10+10 + 4*10 + iLineHeadKgf + iOprLen;
    if( cLeftParmType != '?' )
        iMemSize += iLeftParmLen;
    if( cRightParmType != '?' )
        iMemSize += iRightParmLen;

    char cObjNameTmp = *(pObjName + iObjNameLen);
    *(pObjName + iObjNameLen) = '\0';

    char cLeftParmTmp = 0;
    if( pLeftParm && cLeftParmType != '?' )
    {
        cLeftParmTmp = *(pLeftParm + iLeftParmLen);
        *(pLeftParm + iLeftParmLen) = '\0';
    }

    char cRightParmTmp = 0;
    if( pRightParm && cRightParmType != '?' )
    {
        cRightParmTmp = *(pRightParm + iRightParmLen);
        *(pRightParm + iRightParmLen) = '\0';
    }
    
    if( iMemSize >= RES_NODE_SIZE )
    {
        pResultList->next = getStringNode();
        pResultList = pResultList->next;
        memset(pResultList, 0x00, sizeof(struct stString));
    
        pResultList->pStr = (char *)malloc(iMemSize + 8);
        pResultTail = pResultList->pStr;
        pResultList->iStrLen = 0;  // 直接算用完
    }
    else if( pResultList->iStrLen <= iMemSize )
    {
        pResultList->next = getStringNode();
        pResultList = pResultList->next;
        memset(pResultList, 0x00, sizeof(struct stString));

        pResultList->pStr = (char *)malloc(RES_NODE_SIZE);
        pResultList->iStrLen = RES_NODE_SIZE;
        pResultTail = pResultList->pStr;
    }

char *pResult4Print = pResultTail;   // debug

/*****************************************************
    // Let ' ' to 'b' , '\t' to 't'
    char cLineHeadTmp = *(pLineHead4This + iLineHeadKgf);
    *(pLineHead4This + iLineHeadKgf) = '\0';

    if( *pLineHead4This == ' ' || *pLineHead4This == '\t' )
    {
        char *pTmp = pLineHead4This;
        for(unsigned int iCount=iLineHeadKgf; iCount; iCount -- )
        {
            if( *pTmp == ' ' )
                *pTmp = 'b';
            else if( *pTmp == '\t' )
                *pTmp = 't';

            pTmp ++ ;
        }
    }
    sprintf(pResultTail, "%d\t%c\t%d\t%s\t\0", iSeq, cObjType, iLineNum, pLineHead4This);
    *(pLineHead4This+ iLineHeadKgf) = cLineHeadTmp;

    for( ; *pResultTail; pResultTail ++ );
*****************************************************/
    sprintf(pResultTail, "%d\t%c\t%d\t\0", iSeq, cObjType, iLineNum);
    for( ; *pResultTail; pResultTail ++ );

    // Let ' ' to 'b' , '\t' to 't'
    char *pTmp = pLineHead4This;
    for(unsigned int iCount=iLineHeadKgf; iCount; iCount -- )
    {
        if( *pTmp == ' ' )
            *pResultTail = 'b';
        else if( *pTmp == '\t' )
            *pResultTail = 't';

        pResultTail ++ ;
        pTmp ++ ;
    }
    *pResultTail = '\t';
    pResultTail ++ ;
    *pResultTail = '\0';

    char *pParmType = "";
    if( cLeftParmType == 'S' )
    {
        *(pLeftParmTypeName + iLeftParmTypeNameLen) = '\0';
        pParmType = pLeftParmTypeName;
    }
    else if( cLeftParmType == 'C' )
        pParmType = "CONT";
    else if( cLeftParmType == '?' )
        pParmType = "?";

    if( cLeftParmType != '?' )
    sprintf( pResultTail
           , "%d\t%s\t%s\t%s\t"
           , iObjId
           , pObjName
           , pParmType
           , cLeftParmType == '\0' ? "" : pLeftParm
           );
    else
    sprintf( pResultTail
           , "%d\t%s\t%s\t%d\t"
           , iObjId
           , pObjName
           , pParmType
           , iLeftParmLen
           );

    ///////////////////////////////////

    for( ; *pResultTail; pResultTail ++ );

    if( pOpr )
    {
        for( ; pOpr; pOpr=pOpr->next )
        {
            *(pOpr->pStr + pOpr->iStrLen) = '\0';
            sprintf(pResultTail, "%s \0", pOpr->pStr);
            pResultTail += (pOpr->iStrLen + 1);
        }
        *(pResultTail-1) = '\t';    // let last ' ' -> '\t'
    }

    for( ; *pResultTail; pResultTail ++ );

    /////////////////////////////////////////

    pParmType = "";

    if( cRightParmType == 'S' )
    {
        *(pRightParmTypeName + iRightParmTypeNameLen) = '\0';
        sprintf(pResultTail, "%s\t%s\n\0", pRightParmTypeName, pRightParm);
    }
    else if( cRightParmType == '?' )
        sprintf(pResultTail, "?\t%d\n\0", iRightParmLen);
    else
        sprintf(pResultTail, "\t\n\0");

// printf("44444444444444444444=[%s]\n", pResult4Print);  // debug
    fputs(pResult4Print, pfOpf);

    if( pResultList->iStrLen )
    {
        pResultList->iStrLen -= iMemSize;

        for( ; *pResultTail; pResultTail ++ );
    }

    ////////////////////////////

    *(pObjName + iObjNameLen) = cObjNameTmp;
    if( pLeftParm && cLeftParmType != '?') *(pLeftParm + iLeftParmLen) = cLeftParmTmp;
    if( pRightParm && cRightParmType != '?') *(pRightParm + iRightParmLen) = cRightParmTmp;

    return true;
}


/***************************************************
 * pstTranResult4OneLine :

  StrNode->pp->L->O->R
     |
  StrNode->pp->L->O->R
     |
  StrNode->pp->L->O->R
***************************************************/
bool CZGLanguage::makeTranResult4OneLine
(
    unsigned int iSeq

  , char cLeftParmType
  , char cOprType
  , char cRightParmType

  , char * pLeftParm
  , unsigned int iLeftParmLen
  , struct stString * pLeftParmTranList

  , struct stString * pOpr
  , struct stString * pOprTranList

  , char * pRightParm
  , unsigned int iRightParmLen
  , struct stString * pRightParmTranList
)
{
// printf("\nmakeTranResult4OneLine [%d][%c][%c][%c] !!!!!!!!!!!!!!!!!!!!!!!!!!!\n", iSeq, cLeftParmType, cOprType, cRightParmType);  // debug

    ///////////////////////////////////////////////
    // pstTranResult4OneLine
    ///////////////////////////////////////////////
    struct stString * pNewTranResultNode = getStringNode();
    memset(pNewTranResultNode, 0x00, sizeof(struct stString));
    pNewTranResultNode->next = pstTranResult4OneLine;
    pstTranResult4OneLine = pNewTranResultNode;

    pNewTranResultNode->iNum = iSeq;

    ///////////////////////////////////////////////
    // Left parm
    ///////////////////////////////////////////////
    struct stString * pLeftParmResult = NULL;

    if( cLeftParmType )
    {
        // 类型是结果
        if( cLeftParmType == '?' )
        {
            pLeftParmResult = getStringNode();
            memset(pLeftParmResult, 0x00, sizeof(struct stString));
            // pLeftParmResult->pStr = pLeftParm;
            // pLeftParmResult->iStrLen = iLeftParmLen;
            pLeftParmResult->cFlag = cLeftParmType;

            struct stString * pTranResult4OneLineTmp = pstTranResult4OneLine->next;
            for( ; pTranResult4OneLineTmp; pTranResult4OneLineTmp=pTranResult4OneLineTmp->next )
            {
                if( pTranResult4OneLineTmp->iNum == iLeftParmLen )
                    break ;
            }

            pLeftParmResult->pp = pTranResult4OneLineTmp->pp;
        }
        else if( cLeftParmType == 'P' )
        {
            pLeftParmResult = getStringNode();
            memset(pLeftParmResult, 0x00, sizeof(struct stString));
            pLeftParmResult->pStr = pLeftParm;
            pLeftParmResult->iStrLen = iLeftParmLen;
            pLeftParmResult->cFlag = cLeftParmType;

            pLeftParmResult->pp = pLeftParmTranList;    // Tree ComplileInfo->pFork
        }
        // 如果左参数有转换逻辑
        else if( pLeftParmTranList )
        {
            struct stString * pLeftParmTranListCopy = getStringNode();
            memcpy(pLeftParmTranListCopy, pLeftParmTranList, sizeof(struct stString));
            struct stString * pLeftParmTranListCopyTail = pLeftParmTranListCopy;

            struct stString * pTranPartTmp = pLeftParmTranList->next;
            for( ; pTranPartTmp; pTranPartTmp=pTranPartTmp->next )
            {
                pLeftParmTranListCopyTail->next = getStringNode();
                pLeftParmTranListCopyTail = pLeftParmTranListCopyTail->next;
                memcpy(pLeftParmTranListCopyTail, pTranPartTmp, sizeof(struct stString));
                pLeftParmTranListCopyTail->next = NULL;
            }

            pTranPartTmp = pLeftParmTranListCopy;
            for( ; pTranPartTmp; pTranPartTmp=pTranPartTmp->next )
            {
                if( pTranPartTmp->cFlag != 'E' )
                    continue ;

                pTranPartTmp->pStr = pLeftParm;
                pTranPartTmp->iStrLen = iLeftParmLen;
                pTranPartTmp->cFlag = cLeftParmType;
            }

            pLeftParmResult = pLeftParmTranListCopy;
        }
        else
        {
            pLeftParmResult = getStringNode();
            memset(pLeftParmResult, 0x00, sizeof(struct stString));
            pLeftParmResult->pStr = pLeftParm;
            pLeftParmResult->iStrLen = iLeftParmLen;
            pLeftParmResult->cFlag = cLeftParmType;
        }
    } // if( cLeftParmType )
/*************************************************
// debug
struct stString * pLeftParmResultTmp = pLeftParmResult;
for( ; pLeftParmResultTmp; pLeftParmResultTmp=pLeftParmResultTmp->next )
{
    printf("pLeftParmResult Type = [%c]\n", pLeftParmResultTmp->cFlag );
    if( pLeftParmResultTmp->cFlag == '?' )
        printf("    pLeftParmResult Value : [%d]\n", pLeftParmResultTmp->iStrLen);
    else
        printStrForDebug("    pLeftParmResult Value", pLeftParmResultTmp->pStr, pLeftParmResultTmp->iStrLen);
}
printf("----------------------------------------\n");
*************************************************/

    ///////////////////////////////////////////////
    // Right parm
    ///////////////////////////////////////////////
    struct stString * pRightParmResult = NULL;

    // 如果 右 参数有转换逻辑
    if( cRightParmType )
    {
        // 类型是 结果
        if( cRightParmType == '?' )
        {
            pRightParmResult = getStringNode();
            memset(pRightParmResult, 0x00, sizeof(struct stString));
            pRightParmResult->cFlag = cRightParmType;

            struct stString * pTranResult4OneLineTmp = pstTranResult4OneLine->next;
            for( ; pTranResult4OneLineTmp; pTranResult4OneLineTmp=pTranResult4OneLineTmp->next )
            {
                if( pTranResult4OneLineTmp->iNum == iRightParmLen )
                    break ;
            }

            pRightParmResult->pp = pTranResult4OneLineTmp->pp;
        }
        // 类型是 树
        else if( cRightParmType == 'P' )
        {
            pRightParmResult = getStringNode();
            memset(pRightParmResult, 0x00, sizeof(struct stString));
            pRightParmResult->pStr = pRightParm;
            pRightParmResult->iStrLen = iRightParmLen;
            pRightParmResult->cFlag = cRightParmType;

            pRightParmResult->pp = pRightParmTranList;    // Tree ComplileInfo->pFork
        }
        // 如果有转换逻辑
        else if( pRightParmTranList )
        {
            struct stString * pRightParmTranListCopy = getStringNode();
            memcpy(pRightParmTranListCopy, pRightParmTranList, sizeof(struct stString));
            struct stString * pRightParmTranListCopyTail = pRightParmTranListCopy;
    
            struct stString * pTranPartTmp = pRightParmTranList->next;
            for( ; pTranPartTmp; pTranPartTmp=pTranPartTmp->next )
            {
                pRightParmTranListCopyTail->next = getStringNode();
                pRightParmTranListCopyTail = pRightParmTranListCopyTail->next;
                memcpy(pRightParmTranListCopyTail, pTranPartTmp, sizeof(struct stString));
                pRightParmTranListCopyTail->next = NULL;
            }
    
            pTranPartTmp = pRightParmTranListCopy;
            for( ; pTranPartTmp; pTranPartTmp=pTranPartTmp->next )
            {
                if( pTranPartTmp->cFlag != 'E' )
                    continue ;
    
                pTranPartTmp->pStr = pRightParm;
                pTranPartTmp->iStrLen = iRightParmLen;
                pTranPartTmp->cFlag = cRightParmType;
            }
    
            pRightParmResult = pRightParmTranListCopy;
        }
        else 
        {
            pRightParmResult = getStringNode();
            memset(pRightParmResult, 0x00, sizeof(struct stString));
            pRightParmResult->pStr = pRightParm;
            pRightParmResult->iStrLen = iRightParmLen;
            pRightParmResult->cFlag = cRightParmType;
        }
    } // if( cRightParmType )

/*************************************************
// debug
struct stString * pRightParmResultTmp = pRightParmResult;
for( ; pRightParmResultTmp; pRightParmResultTmp=pRightParmResultTmp->next )
{
    printf("pRightParmResult Type = [%c]\n", pRightParmResultTmp->cFlag );
    if( pRightParmResultTmp->cFlag == '?' )
        printf("    pRightParmResult Value : [%d][%p]\n", iRightParmLen, pRightParmResult->pp);
    else
        printStrForDebug("    pRightParmResult Value", pRightParmResultTmp->pStr, pRightParmResultTmp->iStrLen);
}
*************************************************/

    ///////////////////////////////////////////////
    // Opr bef aft ........
    ///////////////////////////////////////////////
    if( pOprTranList )
    {
        struct stString * pOprTranListCopy = getStringNode();
        memcpy(pOprTranListCopy, pOprTranList, sizeof(struct stString));
        struct stString * pOprTranListCopyTail = pOprTranListCopy;

        struct stString * pTranPartTmp = pOprTranList->next;
        for( ; pTranPartTmp; pTranPartTmp=pTranPartTmp->next )
        {
            pOprTranListCopyTail->next = getStringNode();
            pOprTranListCopyTail = pOprTranListCopyTail->next;
            memcpy(pOprTranListCopyTail, pTranPartTmp, sizeof(struct stString));
            pOprTranListCopyTail->next = NULL;
        }

        pTranPartTmp = pOprTranListCopy;
        for( ; pTranPartTmp; pTranPartTmp=pTranPartTmp->next )
        {
            if( pTranPartTmp->cFlag == 'L' )
                pTranPartTmp->pp = pLeftParmResult;
            else if( pTranPartTmp->cFlag == 'R' )
                pTranPartTmp->pp = pRightParmResult;
        }

        pNewTranResultNode->pp = pOprTranListCopy;
    }
    else if( cOprType == 'O' )
    {
        // Left Parm
        struct stString * pTranResultTmp = getStringNode();
        pNewTranResultNode->pp = pTranResultTmp;
        memset(pTranResultTmp, 0x00, sizeof(struct stString));
        pTranResultTmp->cFlag = 'L';
        pTranResultTmp->pp = pLeftParmResult;

        // Opr
        pTranResultTmp->next = getStringNode();
        pTranResultTmp = pTranResultTmp->next;
        memset(pTranResultTmp, 0x00, sizeof(struct stString));
        pTranResultTmp->cFlag = 'O';   // OPR BEF AFT 都使用同一个标记
        pTranResultTmp->pp = pOpr;

        // Right Parm
        pTranResultTmp->next = getStringNode();
        pTranResultTmp = pTranResultTmp->next;
        memset(pTranResultTmp, 0x00, sizeof(struct stString));
        pTranResultTmp->cFlag = 'R';
        pTranResultTmp->pp = pRightParmResult;
    }
    else if( cOprType == 'A' )
    {
        // Left Parm
        struct stString * pTranResultTmp = getStringNode();
        pNewTranResultNode->pp = pTranResultTmp;
        memset(pTranResultTmp, 0x00, sizeof(struct stString));
        pTranResultTmp->cFlag = 'L';
        pTranResultTmp->pp = pLeftParmResult;

        // AFT
        pTranResultTmp->next = getStringNode();
        pTranResultTmp = pTranResultTmp->next;
        memset(pTranResultTmp, 0x00, sizeof(struct stString));
        pTranResultTmp->cFlag = 'O';   // OPR BEF AFT 都使用同一个标记
        pTranResultTmp->pp = pOpr;
    }
    else if( cOprType == 'B' )
    {
        // BEF
        struct stString * pTranResultTmp = getStringNode();
        pNewTranResultNode->pp = pTranResultTmp;
        memset(pTranResultTmp, 0x00, sizeof(struct stString));
        pTranResultTmp->cFlag = 'O';   // OPR BEF AFT 都使用同一个标记
        pTranResultTmp->pp = pOpr;

        // Right Parm
        pTranResultTmp->next = getStringNode();
        pTranResultTmp = pTranResultTmp->next;
        memset(pTranResultTmp, 0x00, sizeof(struct stString));
        pTranResultTmp->cFlag = 'R';
        pTranResultTmp->pp = pRightParmResult;
    }
    // 若行只有一个节点
    else if( cOprType == 0 )
    {
        // Left Parm
        struct stString * pTranResultTmp = getStringNode();
        pNewTranResultNode->pp = pTranResultTmp;
        memset(pTranResultTmp, 0x00, sizeof(struct stString));
        pTranResultTmp->cFlag = 'L';
        pTranResultTmp->pp = pLeftParmResult;
    }

    // 是否需要在最后添加右括号 )
    if( pNewTranResultNode->next 
     && pNewTranResultNode->next->pp
     && ((struct stString *)(pNewTranResultNode->next->pp))->cFlag == ')' )
    {
        struct stString *pTmp = (struct stString *)(pNewTranResultNode->pp);
        for( ; pTmp->next; pTmp=pTmp->next );
        pTmp->next = (struct stString *)(pNewTranResultNode->next->pp);
    }

/****************************************************
// debug
struct stString *pTmp = (struct stString *)(pNewTranResultNode->pp);
printf("\n=========== pNewTranResultNode [%d] ================\n", pNewTranResultNode->iNum);
for( ; pTmp; pTmp=pTmp->next)
{
    if( pTmp->cFlag )
        printf("pNewTranResultNode : [%c : %p]\n", pTmp->cFlag, pTmp->pp);
    else
        printStrForDebug("pNewTranResultNode", pTmp->pStr, pTmp->iStrLen);
}
printf("\n");
****************************************************/

    return true;
}

bool CZGLanguage::addSuccessText4ObjPoint(char * pTextSave, void * pSuccessObjPoint)
{
    struct stSuccessText4ObjPoint * pOneSuccessText4ObjPoint = pSuccessText4ObjPointHashTab + (unsigned long long)pTextSave % SUCCESS_TEXT_PATH_NUM;

    pOneSuccessText4ObjPoint->pTextAddr = pTextSave;
    pOneSuccessText4ObjPoint->pObjPoint = pSuccessObjPoint;

    return true;
}

bool CZGLanguage::isSuccessText4ObjPoint(void * pObjPoint)
{
    struct stSuccessText4ObjPoint * pOneSuccessText4ObjPoint = pSuccessText4ObjPointHashTab + (unsigned long long)pText % SUCCESS_TEXT_PATH_NUM;
    if( pOneSuccessText4ObjPoint->pTextAddr == pText && pOneSuccessText4ObjPoint->pObjPoint == pObjPoint )
        return true;

    return false;
}

bool CZGLanguage::addFailText4ObjPoint(void * pFailObjPoint)
{
    // 优化没有考虑缩进因素，后续需要添加 !!!!!!!!!!!!!!!!!!!!!!!!!!!!!
    // 优化没有考虑缩进因素，后续需要添加 !!!!!!!!!!!!!!!!!!!!!!!!!!!!!
    // 优化没有考虑缩进因素，后续需要添加 !!!!!!!!!!!!!!!!!!!!!!!!!!!!!
    if( cIndentType == INDENT_COMPILER || cIndentType == INDENT_COMPILER_TRANSLATOR )
    {
        return true;
    }

    struct stFailText4ObjPoint * pOneFailText4ObjPoint = NULL; // pFailText4ObjPointHashTab + (unsigned long)pText % FAIL_TEXT_PATH_NUM;

    /////////////////////////////////////////////
    // KEY 冲突，最多循环4次

    for(int i=0; i < 1001; i += 300 )
    {
        pOneFailText4ObjPoint = pFailText4ObjPointHashTab + (unsigned long long)(pText + i) % FAIL_TEXT_PATH_NUM;
// printf("pOneFailText4ObjPoint = [%p], pTextAddr=[%p], pText=[%p]\n", pOneFailText4ObjPoint, pOneFailText4ObjPoint->pTextAddr, pText);

        if( pOneFailText4ObjPoint->pTextAddr == NULL )
        {
            struct stString * pObjPointNew = getStringNode();
            memset(pObjPointNew, 0x00, sizeof(struct stString));
            pObjPointNew->pp = pFailObjPoint;

            pOneFailText4ObjPoint->pTextAddr = pText;
            pOneFailText4ObjPoint->pObjPoint = pObjPointNew;
            return true;
        }

        if( pOneFailText4ObjPoint->pTextAddr == pText )
        {
            struct stString *pObjPointExists = pOneFailText4ObjPoint->pObjPoint;
            for( ; pObjPointExists; pObjPointExists=pObjPointExists->next )
            {
                if( pObjPointExists->pp == pFailObjPoint )
                    return true;
            }

            struct stString * pObjPointNew = getStringNode();
            memset(pObjPointNew, 0x00, sizeof(struct stString));
            pObjPointNew->pp = pFailObjPoint;

            pObjPointNew->next = pOneFailText4ObjPoint->pObjPoint;
            pOneFailText4ObjPoint->pObjPoint = pObjPointNew;
            return true;
        } 
    }

    // 备用位置都已经沾满，替换key
    pOneFailText4ObjPoint->pTextAddr = pText;
    if( pOneFailText4ObjPoint->pObjPoint )
        freeStringList( &(pOneFailText4ObjPoint->pObjPoint));

    struct stString * pObjPointNew = getStringNode();
    memset(pObjPointNew, 0x00, sizeof(struct stString));
    pObjPointNew->pp = pFailObjPoint;
    pOneFailText4ObjPoint->pObjPoint = pObjPointNew;

    return true;
}

bool CZGLanguage::isFailText4ObjPoint(void * pObjPoint)
{
// printf("isFailText4ObjPoint !!!\n");

    struct stFailText4ObjPoint * pOneFailText4ObjPoint = NULL; // pFailText4ObjPointHashTab + (unsigned long)pText % FAIL_TEXT_PATH_NUM;

    for(int i=0; i < 1001; i += 300 )
    {
        pOneFailText4ObjPoint = pFailText4ObjPointHashTab + (unsigned long long)(pText + i) % FAIL_TEXT_PATH_NUM;

        if( pOneFailText4ObjPoint->pTextAddr == pText ) 
        {
            struct stString * pObjPointTmp = pOneFailText4ObjPoint->pObjPoint;
            for( ; pObjPointTmp; pObjPointTmp=pObjPointTmp->next )
            {
                if( pObjPointTmp->pp == pObjPoint )
                    return true;
            }
        }
    }

    return false;
}

bool CZGLanguage::writeCommentAtLineStart
(
     struct stCompileInfo * pOneCompileInfo
   , char * pIndent1
   , unsigned int iIndentLen1
   , char * pIndent2
   , unsigned int iIndentLen2
)
{
    if( ! isTryKeepComment )
        return true;

    // 行尾注释，写在行尾
    struct stString * pCommentTail = pOneCompileInfo->pComments_PassCode;
    if( ! pCommentTail )
        return true;

    // 独立行注释
    for( ; pCommentTail; pCommentTail=pCommentTail->next )
    {
        doWithMem4WriteTranResult(1 + iIndentLen1 + iIndentLen2);
    
        // 分行
        *pResultTail = '\n';
        pResultTail ++ ;
    
        // 缩进
        memcpy(pResultTail, pIndent1, iIndentLen1);
        pResultTail += iIndentLen1;
    
        memcpy(pResultTail, pIndent2, iIndentLen2);
        pResultTail += iIndentLen2;
    
        if( pCommentTail->cFlag == TYPE_COMMENT_1_LINE_START )
        {
            doWithMem4WriteTranResult(iLineCommentLen4Tran + pCommentTail->iStrLen);
            // 写注释符号
            memcpy(pResultTail, pLineComment4Tran, iLineCommentLen4Tran);
            pResultTail += iLineCommentLen4Tran;
            // 写注释内容
            memcpy(pResultTail, pCommentTail->pStr, pCommentTail->iStrLen);
            pResultTail += pCommentTail->iStrLen;
            *pResultTail = '\0';
        }
        else if( pCommentTail->cFlag == TYPE_COMMENT_N_LINE_START )
        {
            // 写注释 开始 符号
            doWithMem4WriteTranResult(iLinesCommentStartLen4Tran);
            memcpy(pResultTail, pLinesCommentStart4Tran, iLinesCommentStartLen4Tran);
            pResultTail += iLinesCommentStartLen4Tran;
    
            // 写注释内容
            char cEnd = *(pCommentTail->pStr + pCommentTail->iStrLen);
            *(pCommentTail->pStr + pCommentTail->iStrLen) = '\0';
            char * pTmp = pCommentTail->pStr;
    
            while( *pTmp )
            {
                char * pOneLineComment = NULL;
                unsigned int iOneLineCommentLen = 0;
    
                for( ; *pTmp == ' ' || *pTmp == '\t'; pTmp ++ );
                pOneLineComment = pTmp;
    
                for( ; *pTmp != '\r' && *pTmp != '\n' && *pTmp != '\0'; pTmp ++ )
                    iOneLineCommentLen ++ ;
    
                if( *pTmp == '\r' )
                    pTmp += 2;
                else if( *pTmp == '\n' )
                    pTmp ++ ;
    
                // 写一行注释
                doWithMem4WriteTranResult(iOneLineCommentLen);
                memcpy(pResultTail, pOneLineComment, iOneLineCommentLen);
                pResultTail += iOneLineCommentLen;
    
                if( *pTmp == '\0' )
                    break ;
    
                doWithMem4WriteTranResult(1 + iIndentLen1 + iIndentLen2);
    
                // 分行
                *pResultTail = '\n';
                pResultTail ++ ;
    
                // 缩进
                memcpy(pResultTail, pIndent1, iIndentLen1);
                pResultTail += iIndentLen1;
    
                memcpy(pResultTail, pIndent2, iIndentLen2);
                pResultTail += iIndentLen2;

            } // while( *pTmp )
    
            // 写注释 结束 符号
            doWithMem4WriteTranResult(iLinesCommentEndLen4Tran);
            memcpy(pResultTail, pLinesCommentEnd4Tran, iLinesCommentEndLen4Tran);
            pResultTail += iLinesCommentEndLen4Tran;

            *pResultTail = '\0';
    
        } else
            break ;
    }

    return true;
}

bool CZGLanguage::writeCommentAtLineEnd(struct stCompileInfo * pOneCompileInfo)
{
    if( ! isTryKeepComment )
        return true;

    // 行尾注释，写在行尾
    struct stString * pCommentTail = pOneCompileInfo->pComments_PassCode;
    if( ! pCommentTail )
        return true;

    for( ; pCommentTail; pCommentTail=pCommentTail->next )
    {
        // 写注释前4个空格
        doWithMem4WriteTranResult(4);
        memcpy(pResultTail, "    ", 4);
        pResultTail += 4;
    
        if( pCommentTail->cFlag == TYPE_COMMENT_1_LINE_END )
        {
            doWithMem4WriteTranResult(iLineCommentLen4Tran + pCommentTail->iStrLen);
            // 写注释符号
            memcpy(pResultTail, pLineComment4Tran, iLineCommentLen4Tran);
            pResultTail += iLineCommentLen4Tran;
            // 写注释内容
            memcpy(pResultTail, pCommentTail->pStr, pCommentTail->iStrLen);
            pResultTail += pCommentTail->iStrLen;
    
            pCommentTail = pCommentTail->next;
            break ;
        }
        else if( pCommentTail->cFlag == TYPE_COMMENT_N_LINE_END )
        {
            doWithMem4WriteTranResult(iLinesCommentStartLen4Tran + iLinesCommentEndLen4Tran + pCommentTail->iStrLen);
            // 写注释 开始 符号
            memcpy(pResultTail, pLinesCommentStart4Tran, iLinesCommentStartLen4Tran);
            pResultTail += iLinesCommentStartLen4Tran;
            // 写注释内容
            memcpy(pResultTail, pCommentTail->pStr, pCommentTail->iStrLen);
            pResultTail += pCommentTail->iStrLen;
            // 写注释 结束 符号
            memcpy(pResultTail, pLinesCommentEnd4Tran, iLinesCommentEndLen4Tran);
            pResultTail += iLinesCommentEndLen4Tran;
        }
        else
            break ;
    } 

    // 节点内存未释放，后续需要可以优化
    pOneCompileInfo->pComments_PassCode = pCommentTail;

    *pResultTail = '\0';
    return true;
}

bool CZGLanguage::writePassCode(char *pPassCode, unsigned int iPassCodeLen)
{
// printStrForDebug("writePassCode start =============================\n", pPassCode, iPassCodeLen);
// printf("writePassCode end ---------------------------\n");

    doWithMem4WriteTranResult(iPassCodeLen);

    memcpy(pResultTail, pPassCode, iPassCodeLen);
    pResultTail += iPassCodeLen;
    *pResultTail = '\0';

    return true;
}

bool CZGLanguage::doWithCompileInfo4Line4CT(struct stCompileInfo * pCompileInfoTmp, unsigned int iObjId4This)
{
// printf("doWithCompileInfo4Line4CT !!!!!!!!!!!!!!!!!!!!!!!!!!!! [%p][%c]\n", pCompileInfoTmp->pFork, pCompileInfoTmp->mType[IDX_LEFT_PARM]);

    struct stCompileInfo * pCompileInfoBefore = NULL;

    if( cRunType == 'C' 
     && pCompileInfoTmp->pFork && pCompileInfoTmp->mType[IDX_LEFT_PARM] == 'P' )
    {
        unsigned int iSeqForkFirst = iSeq + 1;
        unsigned int iObjId4TreeEnd = iObjId + 1;

        go2CompileInfoTree4Cpl(pCompileInfoTmp->pFork);

        iSeq ++ ;

        writeLastResult4Tree (
          iSeq                                 // unsigned int iSeq
        , iObjId4TreeEnd                       // unsigned int iObjId4This
        , pCompileInfoTmp->pFork->pObjName     // char * pObjName
        , pCompileInfoTmp->pFork->iObjNameLen  // unsigned int iObjNameLen
        , iSeqForkFirst                        // unsigned int iFirstLineNum4Tree
        );

        // new result
        pCompileInfoTmp->mType[IDX_LEFT_PARM] = '?';
        pCompileInfoTmp->iValLen1 = iSeq;
    }

    // 特殊处理 __BEF__ 漏算情况
    if( pCompileInfoTmp->pVal3 
     && ((struct stCompileInfo *)(pCompileInfoTmp->pVal3))->pVal3
     && ((struct stCompileInfo *)(((struct stCompileInfo *)(pCompileInfoTmp->pVal3))->pVal3))->mType[IDX_LEFT_PARM] == 'B' 
     && (  ((struct stCompileInfo *)(pCompileInfoTmp->pVal3))->mType[IDX_LEFT_PARM] == 'S'
        || ((struct stCompileInfo *)(pCompileInfoTmp->pVal3))->mType[IDX_LEFT_PARM] == 'C'
        || ((struct stCompileInfo *)(pCompileInfoTmp->pVal3))->mType[IDX_LEFT_PARM] == '?'
        || ((struct stCompileInfo *)(pCompileInfoTmp->pVal3))->mType[IDX_LEFT_PARM] == 'P'
        )
    )
    {
        // 回头继续计算，注意：循环时先 pCompileInfoTmp=pCompileInfoTmp->next
        pCompileInfoTmp = (struct stCompileInfo *)(((struct stCompileInfo *)(pCompileInfoTmp->pVal3))->pVal3);
    } 
    // 特殊处理 ( __BEF__ __BEF__ ... )
    else if( pCompileInfoTmp->mType[IDX_LEFT_PARM] == ')' && ((struct stCompileInfo *)(pCompileInfoTmp->pVal3))->mType[IDX_LEFT_PARM] == 'B' )
    {
        pCompileInfoBefore = (struct stCompileInfo *)(pCompileInfoTmp->pVal3);

        // Pass )
        if( pCompileInfoBefore->pVal3 ) {
            pCompileInfoBefore->next = pCompileInfoBefore->next->next;
            pCompileInfoBefore->next->pVal3 = (char *)pCompileInfoBefore;
        } else
            pCompileInfoBefore->next->pVal3 = NULL;

        //////////////////////////////////////////////////

        // do With: ( __BEF__ __BEF__ ... )
        while( pCompileInfoBefore->mType[IDX_LEFT_PARM] == 'B' )
        {
            pCompileInfoBefore = (struct stCompileInfo *)(pCompileInfoBefore->pVal3);
        }

        // if exists node before (
        if( pCompileInfoBefore->pVal3 ) {
            pCompileInfoBefore = (struct stCompileInfo *)(pCompileInfoBefore->pVal3);
            pCompileInfoBefore->next = pCompileInfoBefore->next->next;
            pCompileInfoBefore->next->pVal3 = (char *)pCompileInfoBefore;
        } else
            pCompileInfoBefore->next->pVal3 = NULL;
    }
    else if( pCompileInfoTmp->mType[IDX_LEFT_PARM] == 'S'    // Str
          || pCompileInfoTmp->mType[IDX_LEFT_PARM] == 'C'    // Cont
          || pCompileInfoTmp->mType[IDX_LEFT_PARM] == 'P'    // Tree
          || pCompileInfoTmp->mType[IDX_LEFT_PARM] == '?' )  // Result
    {
        pCompileInfoBefore = (struct stCompileInfo *)(pCompileInfoTmp->pVal3);
// printf("Line node : SC? [%c] !!!!!!!!!!!!!! \n", pCompileInfoBefore->mType[IDX_LEFT_PARM]);  // debug

        while( pCompileInfoBefore && pCompileInfoBefore->mType[IDX_LEFT_PARM] == 'B' )
        {
// printf("Line node : SC? [%c] !!!!!!!!!!!!!! \n", pCompileInfoBefore->mType[IDX_LEFT_PARM]);  // debug
            iSeq ++ ;

            if( cRunType == 'C' )
            writeResultList4Line (
              iSeq
            , pCompileInfoTmp->mType[IDX_OBJ] 
            , pCompileInfoTmp->iLineNum
            , pCompileInfoTmp->pLineHead
            , pCompileInfoTmp->iLineHeadKgf
            , iObjId4This
            , pCompileInfoTmp->pObjName
            , pCompileInfoTmp->iObjNameLen

            , '\0'        // char cLeftParmType
            , NULL        // char * pLeftParmTypeName;
            , 0           // unsigned int iLeftParmTypeNameLen;

            , NULL        // char * pLeftParm
            , 0           // unsigned int iLeftParmLen

            , (struct stString *)(pCompileInfoBefore->pVal2)  // struct stString * pOpr
            , 'B'                                             // char cOprType

            , pCompileInfoTmp->mType[IDX_LEFT_PARM]           // char cRightParmType
            , pCompileInfoTmp->pStrType                       // char * pRightParmTypeName;
            , pCompileInfoTmp->iStrTypeLen                    // unsigned int iRightParmTypeNameLen;

            , pCompileInfoTmp->pVal1                          // char * pRightParm
            , pCompileInfoTmp->iValLen1                       // unsigned iRightParmLen
            );
            /////////////////////////////////////////////
            else // if( cRunType == 'T' )
            makeTranResult4OneLine (
              iSeq                                                    // unsigned int iSeq

            , '\0'                                                    // char cLeftParmType
            , 'B'                                                     // char cOprType
            , pCompileInfoTmp->mType[IDX_LEFT_PARM]                   // char cRightParmType

            , NULL                                                    // char * pLeftParm
            , 0                                                       // unsigned int iLeftParmLen
            , NULL                                                    // struct stString * pLeftParmTranList

            , (struct stString *)(pCompileInfoBefore->pVal2)          // struct stString * pOpr
            , pCompileInfoBefore->pTranPartList4Line                  // struct stString * pOprTranList

            , pCompileInfoTmp->pVal1                                  // char * pRightParm
            , pCompileInfoTmp->iValLen1                               // unsigned int iRightParmLen
            // , pCompileInfoTmp->pTranPartList4Line                     // struct stString * pRightParmTranList
            , pCompileInfoTmp->mType[IDX_LEFT_PARM] == 'P' ?
              (struct stString *)(pCompileInfoTmp->pFork) : pCompileInfoTmp->pTranPartList4Line   // struct stString * pRightParmTranList
            );

            /////////////////////////////////////////////////
            // 剔除 __BEF__ 之后的节点 pCompileInfoTmp
            if( pCompileInfoTmp->next )
                pCompileInfoTmp->next->pVal3 = (char *)pCompileInfoBefore;
            pCompileInfoBefore->next = pCompileInfoTmp->next;

            // 将 __BEF__ 节点变成结果节点
            pCompileInfoBefore->mType[IDX_LEFT_PARM] = '?';
            pCompileInfoBefore->iValLen1 = iSeq;

            // 看看 __BEF__ 节点上面是否还是 __BEF__ 节点
            pCompileInfoTmp = pCompileInfoBefore;
            pCompileInfoBefore = (struct stCompileInfo *)(pCompileInfoBefore->pVal3);

        } // while( pCompileInfoBefore && pCompileInfoBefore->mType[IDX_LEFT_PARM] == 'B' )
    }
    else if( pCompileInfoTmp->mType[IDX_LEFT_PARM] == 'O' )    // __OPR__
    {
        unsigned int iCmpOprPriority = pCompileInfoTmp->iValLen2;   // iOprPriority

        // __ELE__
        pCompileInfoBefore = (struct stCompileInfo *)(pCompileInfoTmp->pVal3);
// printf("Line node : OPR [%c] !!!!!!!!!!!!!! \n", pCompileInfoBefore->mType[IDX_LEFT_PARM]);  // debug

        while( true )
        {
            if( pCompileInfoBefore->pVal3 == NULL
             || ((struct stCompileInfo *)(pCompileInfoBefore->pVal3))->mType[IDX_LEFT_PARM] == '(' )
                break ;

            // __OPR__
            pCompileInfoBefore = (struct stCompileInfo *)(pCompileInfoBefore->pVal3);
            if( pCompileInfoBefore->iValLen2 < iCmpOprPriority )
                break ;

            // __ELE__
            pCompileInfoBefore = (struct stCompileInfo *)(pCompileInfoBefore->pVal3);

            iSeq ++ ;

            struct stCompileInfo * pCompileInfoRight = pCompileInfoBefore->next->next;

            if( cRunType == 'C' )
            writeResultList4Line (
              iSeq
            , pCompileInfoTmp->mType[IDX_OBJ]
            , pCompileInfoTmp->iLineNum
            , pCompileInfoTmp->pLineHead
            , pCompileInfoTmp->iLineHeadKgf
            , iObjId4This
            , pCompileInfoTmp->pObjName
            , pCompileInfoTmp->iObjNameLen

            , pCompileInfoBefore->mType[IDX_LEFT_PARM]   // char cLeftParmType
            , pCompileInfoBefore->pStrType               // char * pLeftParmTypeName;
            , pCompileInfoBefore->iStrTypeLen            // unsigned int iLeftParmTypeNameLen;

            , pCompileInfoBefore->pVal1                  // char * pLeftParm
            , pCompileInfoBefore->iValLen1               // unsigned int iLeftParmLen

            , (struct stString *)(pCompileInfoBefore->next->pVal2)  // struct stString * pOpr
            , 'O'                                                   // char cOprType

            , pCompileInfoRight->mType[IDX_LEFT_PARM]    // char cRightParmType
            , pCompileInfoRight->pStrType                // char * pRightParmTypeName;
            , pCompileInfoRight->iStrTypeLen             // unsigned int iRightParmTypeNameLen;

            , pCompileInfoRight->pVal1                   // char * pRightParm
            , pCompileInfoRight->iValLen1                // unsigned iRightParmLen
            );
            /////////////////////////////////////////////
            else // if( cRunType == 'T' )
            makeTranResult4OneLine (
              iSeq                                                    // unsigned int iSeq

            , pCompileInfoBefore->mType[IDX_LEFT_PARM]                // char cLeftParmType
            , 'O'                                                     // char cOprType
            , pCompileInfoRight->mType[IDX_LEFT_PARM]                 // char cRightParmType

            , pCompileInfoBefore->pVal1                               // char * pLeftParm
            , pCompileInfoBefore->iValLen1                            // unsigned int iLeftParmLen
            // , pCompileInfoBefore->pTranPartList4Line                  // struct stString * pLeftParmTranList
            , pCompileInfoBefore->mType[IDX_LEFT_PARM] == 'P' ?
              (struct stString *)(pCompileInfoBefore->pFork) : pCompileInfoBefore->pTranPartList4Line

            , (struct stString *)(pCompileInfoBefore->next->pVal2)    // struct stString * pOpr
            , pCompileInfoBefore->next->pTranPartList4Line            // struct stString * pOprTranList

            , pCompileInfoRight->pVal1                                // char * pRightParm
            , pCompileInfoRight->iValLen1                             // unsigned int iRightParmLen
            // , pCompileInfoRight->pTranPartList4Line                   // struct stString * pRightParmTranList
            , pCompileInfoRight->mType[IDX_LEFT_PARM] == 'P' ?
              (struct stString *)(pCompileInfoRight->pFork) : pCompileInfoRight->pTranPartList4Line
            );

            /////////////////////////////////////////////////

            pCompileInfoRight->next->pVal3 = (char *)pCompileInfoBefore;
            pCompileInfoBefore->next = pCompileInfoRight->next;

            // new result
            pCompileInfoBefore->mType[IDX_LEFT_PARM] = '?';
            pCompileInfoBefore->iValLen1 = iSeq;

        } // while( true )
    }
    else if ( pCompileInfoTmp->mType[IDX_LEFT_PARM] == 'B' )   // __BEF__
    {
        // Pass
    }
    else if( pCompileInfoTmp->mType[IDX_LEFT_PARM] == 'A' )
    {
        pCompileInfoBefore = (struct stCompileInfo *)(pCompileInfoTmp->pVal3);
// printf("Line node __AFT__ [%c] !!!!!!!!!!!!!!!!!!!!!!!\n", pCompileInfoBefore->mType[IDX_LEFT_PARM]);

        iSeq ++ ;

        if( cRunType == 'C' )
        writeResultList4Line (
          iSeq
        , pCompileInfoTmp->mType[IDX_OBJ]
        , pCompileInfoTmp->iLineNum
        , pCompileInfoTmp->pLineHead
        , pCompileInfoTmp->iLineHeadKgf
        , iObjId4This
        , pCompileInfoTmp->pObjName
        , pCompileInfoTmp->iObjNameLen

        , pCompileInfoBefore->mType[IDX_LEFT_PARM]   // char cLeftParmType
        , pCompileInfoBefore->pStrType               // char * pLeftParmTypeName;
        , pCompileInfoBefore->iStrTypeLen            // unsigned int iLeftParmTypeNameLen;

        , pCompileInfoBefore->pVal1                  // char * pLeftParm
        , pCompileInfoBefore->iValLen1               // unsigned int iLeftParmLen

        , (struct stString *)(pCompileInfoBefore->next->pVal2)  // struct stString * pOpr
        , 'A'                                                   // char cOprType

        , '\0'    // char cRightParmType
        , NULL    // char * pRightParmTypeName;
        , 0       // unsigned int iRightParmTypeNameLen;

        , NULL    // char * pRightParm
        , 0       // unsigned iRightParmLen
        );
        /////////////////////////////////////////////
        else // if( cRunType == 'T' )
        makeTranResult4OneLine (
          iSeq                                                    // unsigned int iSeq

        , pCompileInfoBefore->mType[IDX_LEFT_PARM]                // char cLeftParmType
        , 'A'                                                     // char cOprType
        , '\0'                                                    // char cRightParmType

        , pCompileInfoBefore->pVal1                               // char * pLeftParm
        , pCompileInfoBefore->iValLen1                            // unsigned int iLeftParmLen
        // , pCompileInfoBefore->pTranPartList4Line                  // struct stString * pLeftParmTranList
        , pCompileInfoBefore->mType[IDX_LEFT_PARM] == 'P' ?
          (struct stString *)(pCompileInfoBefore->pFork) : pCompileInfoBefore->pTranPartList4Line

        , (struct stString *)(pCompileInfoBefore->next->pVal2)    // struct stString * pOpr
        , pCompileInfoBefore->next->pTranPartList4Line            // struct stString * pOprTranList

        , NULL                                                    // char * pRightParm
        , 0                                                       // unsigned int iRightParmLen
        , NULL                                                    // struct stString * pRightParmTranList
        );

        ///////////////////////////////////////////////////////
        
        if( pCompileInfoTmp->next )
            pCompileInfoTmp->next->pVal3 = (char *)pCompileInfoBefore;
        pCompileInfoBefore->next = pCompileInfoTmp->next;

        // new result
        pCompileInfoBefore->mType[IDX_LEFT_PARM] = '?';
        pCompileInfoBefore->iValLen1 = iSeq;
    }
    else if( pCompileInfoTmp->mType[IDX_LEFT_PARM] == '(' )   // (
    {
// printf("Line node : (((((((((((((((((((((((((((((((( \n");  // debug
        // Pass
    }
    else if( pCompileInfoTmp->mType[IDX_LEFT_PARM] == ')' )   // )
    {
// printf("Line node : )))))))))))))))))))))))))))))))\n");  // debug

        pCompileInfoBefore = (struct stCompileInfo *)(pCompileInfoTmp->pVal3);

// printf("111 pCompileInfoBefore->pVal3 = %p | [%c]\n", pCompileInfoBefore->pVal3, pCompileInfoBefore->mType[IDX_LEFT_PARM]);  // debug
        // Pass )
        if( pCompileInfoBefore->pVal3 ) {
            pCompileInfoBefore->next = pCompileInfoBefore->next->next;
            pCompileInfoBefore->next->pVal3 = (char *)pCompileInfoBefore;
        } else
            pCompileInfoBefore->next->pVal3 = NULL;

        struct stString * pNewTranResultNode = getStringNode();
        memset(pNewTranResultNode, 0x00, sizeof(struct stString));
        pNewTranResultNode->next = pstTranResult4OneLine;
        pstTranResult4OneLine = pNewTranResultNode;        

        pNewTranResultNode->pp = getStringNode();
        pNewTranResultNode = (struct stString *)(pNewTranResultNode->pp);
        memset(pNewTranResultNode, 0x00, sizeof(struct stString));
        pNewTranResultNode->cFlag = ')';
        pNewTranResultNode->pStr = ")";
        pNewTranResultNode->iStrLen = 1;

        //////////////////////////////////////////////////

        while( true )
        {
// printf("pCompileInfoBefore->pVal3 = %p\n", pCompileInfoBefore->pVal3);  // debug

            if( ((struct stCompileInfo *)(pCompileInfoBefore->pVal3))->mType[IDX_LEFT_PARM] == '(' )
            {
                // Pass (
                pCompileInfoBefore = (struct stCompileInfo *)(pCompileInfoBefore->pVal3);

                // if exists node before (
                if( pCompileInfoBefore->pVal3 ) {
                    pCompileInfoBefore = (struct stCompileInfo *)(pCompileInfoBefore->pVal3);
                    pCompileInfoBefore->next = pCompileInfoBefore->next->next;
                    pCompileInfoBefore->next->pVal3 = (char *)pCompileInfoBefore;
                } else
                    pCompileInfoBefore->next->pVal3 = NULL;

                pNewTranResultNode = getStringNode();
                memset(pNewTranResultNode, 0x00, sizeof(struct stString));
                pNewTranResultNode->pStr = "(";
                pNewTranResultNode->iStrLen = 1;
                pNewTranResultNode->cFlag = '(';

                pNewTranResultNode->next = (struct stString *)(pstTranResult4OneLine->pp);
                pstTranResult4OneLine->pp = pNewTranResultNode;

                break ;
            }

            ////////////////////////////////////////////

            // __OPR__
            pCompileInfoBefore = (struct stCompileInfo *)(pCompileInfoBefore->pVal3);

            // __ELE__
            pCompileInfoBefore = (struct stCompileInfo *)(pCompileInfoBefore->pVal3);

            iSeq ++ ;

            struct stCompileInfo * pCompileInfoRight = pCompileInfoBefore->next->next;

            if( cRunType == 'C' )
            writeResultList4Line (
              iSeq
            , pCompileInfoTmp->mType[IDX_OBJ]
            , pCompileInfoTmp->iLineNum
            , pCompileInfoTmp->pLineHead
            , pCompileInfoTmp->iLineHeadKgf
            , iObjId4This
            , pCompileInfoTmp->pObjName
            , pCompileInfoTmp->iObjNameLen

            , pCompileInfoBefore->mType[IDX_LEFT_PARM]   // char cLeftParmType
            , pCompileInfoBefore->pStrType               // char * pLeftParmTypeName;
            , pCompileInfoBefore->iStrTypeLen            // unsigned int iLeftParmTypeNameLen;

            , pCompileInfoBefore->pVal1                  // char * pLeftParm
            , pCompileInfoBefore->iValLen1               // unsigned int iLeftParmLen

            , (struct stString *)(pCompileInfoBefore->next->pVal2)  // struct stString * pOpr
            , 'O'                                                   // char cOprType

            , pCompileInfoRight->mType[IDX_LEFT_PARM]    // char cRightParmType
            , pCompileInfoRight->pStrType                // char * pRightParmTypeName;
            , pCompileInfoRight->iStrTypeLen             // unsigned int iRightParmTypeNameLen;

            , pCompileInfoRight->pVal1                   // char * pRightParm
            , pCompileInfoRight->iValLen1                // unsigned iRightParmLen
            );
            /////////////////////////////////////////////
            else // if( cRunType == 'T' )
            makeTranResult4OneLine (
              iSeq                                                    // unsigned int iSeq

            , pCompileInfoBefore->mType[IDX_LEFT_PARM]                // char cLeftParmType
            , 'O'                                                     // char cOprType
            , pCompileInfoRight->mType[IDX_LEFT_PARM]                 // char cRightParmType

            , pCompileInfoBefore->pVal1                               // char * pLeftParm
            , pCompileInfoBefore->iValLen1                            // unsigned int iLeftParmLen
            // , pCompileInfoBefore->pTranPartList4Line                  // struct stString * pLeftParmTranList
            , pCompileInfoBefore->mType[IDX_LEFT_PARM] == 'P' ?
              (struct stString *)(pCompileInfoBefore->pFork) : pCompileInfoBefore->pTranPartList4Line

            , (struct stString *)(pCompileInfoBefore->next->pVal2)    // struct stString * pOpr
            , pCompileInfoBefore->next->pTranPartList4Line            // struct stString * pOprTranList

            , pCompileInfoRight->pVal1                                // char * pRightParm
            , pCompileInfoRight->iValLen1                             // unsigned int iRightParmLen
            // , pCompileInfoRight->pTranPartList4Line                   // struct stString * pRightParmTranList
            , pCompileInfoRight->mType[IDX_LEFT_PARM] == 'P' ?
              (struct stString *)(pCompileInfoRight->pFork) : pCompileInfoRight->pTranPartList4Line
            );

            /////////////////////////////////////
        
            pCompileInfoRight->next->pVal3 = (char *)pCompileInfoBefore;
            pCompileInfoBefore->next = pCompileInfoRight->next;

            // new result
            pCompileInfoBefore->mType[IDX_LEFT_PARM] = '?';
            pCompileInfoBefore->iValLen1 = iSeq;

        } // while( true )
    }
    else  // The line end
    {
// printf("Line node : END !!!!!!!!!!!!!! [%c]\n", ((struct stCompileInfo *)(pCompileInfoTmp->pVal3))->mType[IDX_LEFT_PARM] );  // debug

        // __ELE__
        pCompileInfoBefore = (struct stCompileInfo *)(pCompileInfoTmp->pVal3);

        // 若只剩一个 __ELE__ 节点，退出
        if( pCompileInfoBefore->pVal3 == NULL )
        {
            // 若类型不是结果，则说明一行只有一个节点，需要写入结果
            if( pCompileInfoBefore->mType[IDX_LEFT_PARM] != '?' )
            {
                iSeq ++ ;
        
                if( cRunType == 'C' )
                writeResultList4Line (
                  iSeq
                , pCompileInfoBefore->mType[IDX_OBJ]
                , pCompileInfoBefore->iLineNum
                , pCompileInfoBefore->pLineHead
                , pCompileInfoBefore->iLineHeadKgf
                , iObjId4This
                , pCompileInfoBefore->pObjName
                , pCompileInfoBefore->iObjNameLen
        
                , pCompileInfoBefore->mType[IDX_LEFT_PARM]   // char cLeftParmType
                , pCompileInfoBefore->pStrType               // char * pLeftParmTypeName;
                , pCompileInfoBefore->iStrTypeLen            // unsigned int iLeftParmTypeNameLen;
        
                , pCompileInfoBefore->pVal1               // char * pLeftParm
                , pCompileInfoBefore->iValLen1            // unsigned int iLeftParmLen
        
                , NULL  // struct stString * pOpr
                , 0     // char cOprType
        
                , '\0'    // char cRightParmType
                , NULL    // char * pRightParmTypeName;
                , 0       // unsigned int iRightParmTypeNameLen;
        
                , NULL    // char * pRightParm
                , 0       // unsigned iRightParmLen
                );
                /////////////////////////////////////////////
                else // if( cRunType == 'T' )
                makeTranResult4OneLine (
                  iSeq                                                    // unsigned int iSeq
        
                , pCompileInfoBefore->mType[IDX_LEFT_PARM]                // char cLeftParmType
                , 0                                                       // char cOprType
                , '\0'                                                    // char cRightParmType
        
                , pCompileInfoBefore->pVal1                               // char * pLeftParm
                , pCompileInfoBefore->iValLen1                            // unsigned int iLeftParmLen
                // , pCompileInfoTmp->pTranPartList4Line                  // struct stString * pLeftParmTranList
                , pCompileInfoBefore->mType[IDX_LEFT_PARM] == 'P' ?
                  (struct stString *)(pCompileInfoBefore->pFork) : pCompileInfoBefore->pTranPartList4Line
        
                , NULL    // struct stString * pOpr
                , NULL    // struct stString * pOprTranList
        
                , NULL                                                    // char * pRightParm
                , 0                                                       // unsigned int iRightParmLen
                , NULL                                                    // struct stString * pRightParmTranList
                );

            } // if( pCompileInfoBefore->mType[IDX_LEFT_PARM] != '?' )

            return true;
        }

        // __OPR__
        pCompileInfoBefore = (struct stCompileInfo *)(pCompileInfoBefore->pVal3);

// printf("while( pCompileInfoBefore ) !!!!!!!![%p]\n", pCompileInfoBefore);
// printStrForDebug("pOpr",((struct stString *)(pCompileInfoBefore->pVal2))->pStr,((struct stString *)(pCompileInfoBefore->pVal2))->iStrLen);

        while( pCompileInfoBefore )
        {
            iSeq ++ ;

            // Left __ELE__
            pCompileInfoBefore = (struct stCompileInfo *)(pCompileInfoBefore->pVal3);

// printf("???????? pCompileInfoBefore=[%p]\n", pCompileInfoBefore);
// printf("????????? next=[%p]\n", pCompileInfoBefore->next);
// printf("????????? next->next=[%p]\n", pCompileInfoBefore->next->next);

            // Right __ELE__
            struct stCompileInfo * pCompileInfoRight = pCompileInfoBefore->next->next;

// printf("????????????????????? left=[%c] opr=[%c] right=[%c]\n", pCompileInfoBefore->mType[IDX_LEFT_PARM], pCompileInfoBefore->next->mType[IDX_LEFT_PARM], pCompileInfoRight->mType[IDX_LEFT_PARM]);

// printStrForDebug("pLeftParm", pCompileInfoBefore->pVal1, pCompileInfoBefore->iValLen1);
// printStrForDebug("pOpr",((struct stString *)(pCompileInfoBefore->next->pVal2))->pStr,((struct stString *)(pCompileInfoBefore->next->pVal2))->iStrLen);
// printStrForDebug("pRightParm", pCompileInfoRight->pVal1, pCompileInfoRight->iValLen1);
 
            if( cRunType == 'C' )
            writeResultList4Line (
              iSeq
            , pCompileInfoTmp->mType[IDX_OBJ]
            , pCompileInfoTmp->iLineNum
            , pCompileInfoTmp->pLineHead
            , pCompileInfoTmp->iLineHeadKgf
            , iObjId4This
            , pCompileInfoTmp->pObjName
            , pCompileInfoTmp->iObjNameLen

            , pCompileInfoBefore->mType[IDX_LEFT_PARM]   // char cLeftParmType
            , pCompileInfoBefore->pStrType               // char * pLeftParmTypeName;
            , pCompileInfoBefore->iStrTypeLen            // unsigned int iLeftParmTypeNameLen;

            , pCompileInfoBefore->pVal1                  // char * pLeftParm
            , pCompileInfoBefore->iValLen1               // unsigned int iLeftParmLen

            , (struct stString *)(pCompileInfoBefore->next->pVal2)  // struct stString * pOpr
            , 'O'                                                   // char cOprType

            , pCompileInfoRight->mType[IDX_LEFT_PARM]    // char cRightParmType
            , pCompileInfoRight->pStrType                // char * pRightParmTypeName;
            , pCompileInfoRight->iStrTypeLen             // unsigned int iRightParmTypeNameLen;

            , pCompileInfoRight->pVal1                   // char * pRightParm
            , pCompileInfoRight->iValLen1                // unsigned iRightParmLen
            );
            ////////////////////////////////////
            else // if( cRunType == 'T' )
            makeTranResult4OneLine (
              iSeq                                                    // unsigned int iSeq

            , pCompileInfoBefore->mType[IDX_LEFT_PARM]                // char cLeftParmType
            , 'O'                                                     // char cOprType
            , pCompileInfoRight->mType[IDX_LEFT_PARM]                 // char cRightParmType

            , pCompileInfoBefore->pVal1                               // char * pLeftParm
            , pCompileInfoBefore->iValLen1                            // unsigned int iLeftParmLen
            // , pCompileInfoBefore->pTranPartList4Line                  // struct stString * pLeftParmTranList
            , pCompileInfoBefore->mType[IDX_LEFT_PARM] == 'P' ?
              (struct stString *)(pCompileInfoBefore->pFork) : pCompileInfoBefore->pTranPartList4Line

            , (struct stString *)(pCompileInfoBefore->next->pVal2)    // struct stString * pOpr
            , pCompileInfoBefore->next->pTranPartList4Line            // struct stString * pOprTranList

            , pCompileInfoRight->pVal1                                // char * pRightParm
            , pCompileInfoRight->iValLen1                             // unsigned int iRightParmLen
            // , pCompileInfoRight->pTranPartList4Line                   // struct stString * pRightParmTranList
            , pCompileInfoRight->mType[IDX_LEFT_PARM] == 'P' ?
              (struct stString *)(pCompileInfoRight->pFork) : pCompileInfoRight->pTranPartList4Line
            );

            /////////////////////////////////////

            pCompileInfoRight->next->pVal3 = (char *)pCompileInfoBefore;
            pCompileInfoBefore->next = pCompileInfoRight->next;

            // new result
            pCompileInfoBefore->mType[IDX_LEFT_PARM] = '?';
            pCompileInfoBefore->iValLen1 = iSeq;

            // next __OPR__
            pCompileInfoBefore = (struct stCompileInfo *)(pCompileInfoBefore->pVal3);

        } // while( pCompileInfoBefore )

    } // if( pCompileInfoTmp->mType[IDX_LEFT_PARM] == ...... )

    return true;
}

bool CZGLanguage::go2CompileInfoTree4Cpl(struct stCompileInfo * pOneFork)
{
// printf("\ngo2CompileInfoTree4Cpl pOneFork->next = %p->%p\n", pOneFork, pOneFork->next);  // debug

    iObjId ++ ;
    unsigned int iObjId4This = iObjId;

    struct stCompileInfo * pCompileInfoTmp = pOneFork->next;
    unsigned int iMemSize = 0;

    for( ; pCompileInfoTmp; pCompileInfoTmp=pCompileInfoTmp->next )
    {
// printf("    Type=%c | pCompileInfoTmp = %p | pFork = %p\n", pOneFork->mType[IDX_OBJ], pCompileInfoTmp, pCompileInfoTmp->pFork);  // debug

        if( pOneFork->mType[IDX_OBJ] == 'P' )
        {
            // 20230916
            //////////////////////////////////////////////////////////
            // pCompileInfoTmp->pVal3 == NULL 代表 SKIP 节点
            // pCompileInfoTmp->iValLen3 == 0 代表 __ANY__ 分行
            /////////////////////////////////////////////////////////
            // 若是 SKIP 节点 或 __ANY__ 分行，都不输出
            if( pCompileInfoTmp->pVal3 && pCompileInfoTmp->iValLen3 )
            {
                iSeq ++ ;

                writeResultList4Tree (
                  iSeq 
                , pCompileInfoTmp->mType[IDX_OBJ]  // char cObjType
                , pCompileInfoTmp->iLineNum 
                , pCompileInfoTmp->pLineHead
                , pCompileInfoTmp->iLineHeadKgf
                , iObjId4This
                , pCompileInfoTmp->pObjName       // Tree name
                , pCompileInfoTmp->iObjNameLen    // Tree name length
                , pCompileInfoTmp->iValLen1       // unsigned int iPathY
                , pCompileInfoTmp->pVal2          // char * pOtherName
                , pCompileInfoTmp->iValLen2       // unsigned int iOtherNameLen
                , pCompileInfoTmp->pVal3          // char * pValue
                , pCompileInfoTmp->iValLen3       // unsigned int iValueLen
                );
            }

            if( pCompileInfoTmp->pFork )
            {
                unsigned int iSeqForkFirst = iSeq + 1;
                unsigned int iObjId4TreeEnd = iObjId + 1;

                go2CompileInfoTree4Cpl(pCompileInfoTmp->pFork);

                //////////////////////////////////////////////

                if( pCompileInfoTmp->pFork->mType[IDX_OBJ] == 'P')
                {
                    iSeq ++ ;

                    writeLastResult4Tree (
                      iSeq                                 // unsigned int iSeq
                    , iObjId4TreeEnd                       // unsigned int iObjId4This
                    , pCompileInfoTmp->pFork->pObjName     // char * pObjName
                    , pCompileInfoTmp->pFork->iObjNameLen  // unsigned int iObjNameLen
                    , iSeqForkFirst                        // unsigned int iFirstLineNum4Tree
                    );
                }
            } // if( pCompileInfoTmp->pFork )
        }
        else // if( pOneFork->mType[IDX_OBJ] == 'E' )
        {
// printf("111 pCompileInfoTmp->mType[IDX_LEFT_PARM] == %c, pFork = %p, pTranPartList4Line = %p\n", pCompileInfoTmp->mType[IDX_LEFT_PARM], pCompileInfoTmp->pFork, pCompileInfoTmp->pTranPartList4Line);

            doWithCompileInfo4Line4CT(pCompileInfoTmp, iObjId4This);
        }
    } // for( ; pCompileInfoTmp; pCompileInfoTmp=pCompileInfoTmp->next )

    return true;
}

bool CZGLanguage::doWithMem4WriteTranResult(unsigned int iNeedMemSize)
{
    // 内容长度 超 剩余缓存长度
    if( iNeedMemSize + 4 >= pResultList->iStrLen )
    {
        // 将已有内容输出
// printf("Result :::::::::::::::::::::::::::::::::::::\n %s", pResultList->pStr);
        fputs(pResultList->pStr, pfOpf);
    
        // 更新缓存
        if( iNeedMemSize >= RES_NODE_SIZE ) {
            pResultList->pStr = (char *)malloc(iNeedMemSize + 1024);
            pResultList->iStrLen = iNeedMemSize + 1024;
        } else
            pResultList->iStrLen = RES_NODE_SIZE;
    
        pResultTail = pResultList->pStr;
        *pResultTail = '\0';
    }

// printf("Use Mem : [%d]-[%d]\n", pResultList->iStrLen, iNeedMemSize); // debug

    pResultList->iStrLen -= iNeedMemSize;

    return true;
}

bool CZGLanguage::writeLineTranResult(struct stString * pOneTranResult4OneLine)
{
// printf("writeLineTranResult !!!!!!!!!!!!!!!!!!!!\n", pOneTranResult4OneLine->cFlag);  // debug

    for( ; pOneTranResult4OneLine; pOneTranResult4OneLine=pOneTranResult4OneLine->next )
    {
// printf("    cFlag = [%c][%p]\n", pOneTranResult4OneLine->cFlag, pOneTranResult4OneLine->pp);  // debug

        // 优先判断是否是树下钻
        if( pOneTranResult4OneLine->cFlag == 'P' )
        {
            ///////////////////////////////////////
            // 确定缩进
            if( cIndentType == INDENT_TRANSLATOR || cIndentType == INDENT_COMPILER_TRANSLATOR )
            {
                // 增加缩进节点
                pstIndentList4TranList->next = getStringNode();
                memset(pstIndentList4TranList->next, 0x00, sizeof(struct stString));
                pstIndentList4TranList->next->pp = pstIndentList4TranList;   // pp -> before
                pstIndentList4TranList = pstIndentList4TranList->next;

                unsigned int iLineLen = 0;
                for( pResultTail -- ; *pResultTail != '\n' && *pResultTail != '\0'; pResultTail -- )
                {
                    iLineLen ++ ;
                }

                // 使得 pResultTail 回到原来的位置
                // pResultTail += iLineLen + 1;

                // 新增缩进长度 = 行长度
                pstIndentList4TranList->iStrLen = iLineLen;
                pstIndentList4TranList->pStr = (char *)malloc(iLineLen + 4);

                // 根据拼接行的字符类型，生成新的缩进
                char * pTranIndentTail = pstIndentList4TranList->pStr;
                pResultTail ++ ;  // pass \n or \0
                for( ; iLineLen; iLineLen -- )
                {
                    if( *pResultTail == '\t' )
                        *pTranIndentTail = '\t';
                    else
                        *pTranIndentTail = ' ';

                    pTranIndentTail ++ ;
                    pResultTail ++ ;     // 执行完，pResultTail 回到原来位置
                }

                // 行里面的树下钻，首节点不分行
                *pTranIndentTail = ' ';
                pTranIndentTail ++ ;
                pstIndentList4TranList->iStrLen ++ ;

                // 缩进字符串加上结束符，方便后续使用
                *(pstIndentList4TranList->pStr + pstIndentList4TranList->iStrLen) = '\0';

            } // if( cIndentType == INDENT_TRANSLATOR || cIndentType == INDENT_COMPILER_TRANSLATOR )

// printf("Line 2 Tree !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");

            // 行里面的树下钻，首节点不分行
            cSplitFlag4Tran4BfGoDown = '\\';

            // 默认格式化
            if( *(pResultTail-1) != ' ' && *(pResultTail-1) != '\t' && *(pResultTail-1) != '\n'
             && *(pResultTail-1) != '.' && *(pResultTail-1) != '(' )
            {
                doWithMem4WriteTranResult(1);

                *pResultTail = ' ';
                pResultTail ++ ;
            }

            if( ! go2CompileInfoTree4Tran( (struct stCompileInfo *)(pOneTranResult4OneLine->pp)) )
                return false;

            // 缩进敏感，并且下钻对象是树，下钻返回后
            if( cIndentType == INDENT_TRANSLATOR || cIndentType == INDENT_COMPILER_TRANSLATOR )
            {
                // 删除最后一个缩进节点
                pstIndentList4TranList = (struct stString *)(pstIndentList4TranList->pp);
                freeStringNode( &(pstIndentList4TranList->next) );
                pstIndentList4TranList->next = NULL;
            }
        }
        else if( pOneTranResult4OneLine->pp )
        {
// printf("pOneTranResult4OneLine->pp !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
            writeLineTranResult((struct stString *)(pOneTranResult4OneLine->pp));
        }
        else
        {
// printStrForDebug("        Value", pOneTranResult4OneLine->pStr, pOneTranResult4OneLine->iStrLen);

            // 缓存处理
            doWithMem4WriteTranResult(1 + pOneTranResult4OneLine->iStrLen);

            // 默认格式化
            if( *(pResultTail-1) != ' ' && *(pResultTail-1) != '\t' && *(pResultTail-1) != '\n'
             && *(pResultTail-1) != '.' && *(pOneTranResult4OneLine->pStr) != '.'
             && *(pResultTail-1) != '('
             && *(pOneTranResult4OneLine->pStr) != ')'
            ) 
            {
                *pResultTail = ' ';
                pResultTail ++ ;
            }

            memcpy(pResultTail, pOneTranResult4OneLine->pStr, pOneTranResult4OneLine->iStrLen);
            pResultTail += pOneTranResult4OneLine->iStrLen;
        }
    }

    *pResultTail = '\0';
    return true;
}

bool CZGLanguage::writeTranRes4ShortPaths(struct stString * pTranShortPathHeadNodeList)
{
// printf("writeTranRes4ShortPaths !!!!!!!!!!!!!!!!!!!!!!!!! [%d][%d]\n", pstIndentList4TranList->iStrLen, pTranShortPathHeadNodeList->iNum);

    // 循环一次，处理一列
    while( true )
    {
        struct stPath * pOneTranShortPathHeadNode = (struct stPath *)(pTranShortPathHeadNodeList->pp);

        struct stPath * pOneTranShortPathHeadNode4Next = pOneTranShortPathHeadNode->next;
// printf("pOneTranShortPathHeadNode4Next = %p\n", pOneTranShortPathHeadNode4Next);
        if( ! pOneTranShortPathHeadNode4Next )
            break ;

        for( ; pOneTranShortPathHeadNode; pOneTranShortPathHeadNode=pOneTranShortPathHeadNode->nextNode )
        {
// printStrForDebug("    111 pTranShortPathHeadNodeList other name", pOneTranShortPathHeadNode->pOneTreeTranLevel->pOtherName, pOneTranShortPathHeadNode->pOneTreeTranLevel->iOtherNameLen);
// printStrForDebug("    111 pTranShortPathHeadNodeList value", pOneTranShortPathHeadNode->pOneTreeTranLevel->pKeyword, pOneTranShortPathHeadNode->pOneTreeTranLevel->iKeywordLen);

            pOneTranShortPathHeadNode4Next = pOneTranShortPathHeadNode->next;

            // 尝试获取下一个转换节点，为了提前处理注释位置问题
            struct stPath * pOneTranShortPathHeadNode4NextOfNextNode = NULL;
            struct stPath * pNextNode4Check = pOneTranShortPathHeadNode->nextNode;
            for( ; pNextNode4Check; pNextNode4Check=pNextNode4Check->nextNode )
            {
                if( pNextNode4Check->next && pNextNode4Check->next->pOneTreeCplLevel )
                {
                    pOneTranShortPathHeadNode4NextOfNextNode = pNextNode4Check->next;
                    break ;
                }
            }

            // 若找不到下一个节点，可能是循环路径，尝试从头开始查找
            if( ! pOneTranShortPathHeadNode4NextOfNextNode )
            {
                pNextNode4Check = (struct stPath *)(pTranShortPathHeadNodeList->pp);
                if( pNextNode4Check->next && pNextNode4Check->next->pOneTreeCplLevel )
                    pOneTranShortPathHeadNode4NextOfNextNode = pNextNode4Check->next;
            }

            // 若为占位节点，跳过不处理
            if( pOneTranShortPathHeadNode4Next->pOneTreeCplLevel )
            {
                struct stCompileInfo * pOneCompileInfo = (struct stCompileInfo *)(pOneTranShortPathHeadNode4Next->pOneTreeCplLevel);

/***********************************************************************/
if( IF_PRINT )
{
printf("<<<<<------------------------\n%s\n------------------------>>>>>>\n", pResultList->pStr);

printf("    pOneCompileInfo->pFork = [%p][%c]\n", pOneCompileInfo->pFork, pOneCompileInfo->pFork ? pOneCompileInfo->pFork->mType[IDX_OBJ] : '0');

printStrForDebug("    Cpl value", pOneCompileInfo->pVal3, pOneCompileInfo->iValLen3);
printf("    Cpl cTreeLevelType : %d\n", pOneCompileInfo->mType[IDX_TREE_LEVEL_TYPE]);
printf("        lineNum : %d\n", pOneCompileInfo->iLineNum);
if( pOneTranShortPathHeadNode->pOneTreeTranLevel->pValueExpr )
    printStrForDebug("        Tran value", pOneTranShortPathHeadNode->pOneTreeTranLevel->pValueExpr->pStr, pOneTranShortPathHeadNode->pOneTreeTranLevel->pValueExpr->iStrLen);
else
    printStrForDebug("        Tran value", pOneTranShortPathHeadNode->pOneTreeTranLevel->pKeyword, pOneTranShortPathHeadNode->pOneTreeTranLevel->iKeywordLen);
printf("        cSplitFlag4Tran4BfGoDown : [%c][%d]\n", cSplitFlag4Tran4BfGoDown, cSplitFlag4Tran4BfGoDown);
printf("        Tran cSplitFlag : %c\n", pOneTranShortPathHeadNode->pOneTreeTranLevel->cSplitFlag);
printf("        Tran Indent : %d\n", pOneTranShortPathHeadNode->pOneTreeTranLevel->iIndentLen); 
printf("        pstIndentList4TranList->iStrLen : %d\n", pstIndentList4TranList->iStrLen); 
printf("        pOneCompileInfo cTreeLevelType : %d\n", pOneCompileInfo->mType[IDX_TREE_LEVEL_TYPE]);

// 注释
if( pOneCompileInfo->pComments_PassCode )
    printStrForDebug("        pComments_PassCode", pOneCompileInfo->pComments_PassCode->pStr, pOneCompileInfo->pComments_PassCode->iStrLen);

// if( pOneCompileInfo->pAttrExpr )
    // printStrForDebug("        AttrExpr", pOneCompileInfo->pAttrExpr->pStr, pOneCompileInfo->pAttrExpr->iStrLen);

/////////////////////////////////////////////////

if( pOneTranShortPathHeadNode4NextOfNextNode )
{
    struct stCompileInfo * pOneCompileInfo2 = (struct stCompileInfo *)(pOneTranShortPathHeadNode4NextOfNextNode->pOneTreeCplLevel);

    printf("        NEXT Tran cSplitFlag : %c\n", pNextNode4Check->pOneTreeTranLevel->cSplitFlag);
    printf("        NEXT pOneCompileInfo cTreeLevelType : %d\n", pOneCompileInfo2->mType[IDX_TREE_LEVEL_TYPE]);

    if( pOneCompileInfo2->pComments_PassCode )
        printStrForDebug("        NEXT pComments_PassCode", pOneCompileInfo2->pComments_PassCode->pStr, pOneCompileInfo2->pComments_PassCode->iStrLen);
}

}
/***********************************************************************/

                // 判断注释挂载节点是否需要移动
                if( isTryKeepComment && pOneTranShortPathHeadNode4NextOfNextNode 
                 && (cIndentType == INDENT_TRANSLATOR || cIndentType == INDENT_COMPILER_TRANSLATOR ) )
                {
                    struct stCompileInfo * pOneCompileInfo4NextNode = (struct stCompileInfo *)(pOneTranShortPathHeadNode4NextOfNextNode->pOneTreeCplLevel);

                    // 当前 节点注释是否需要移动到 下一个 节点
                    if( pOneCompileInfo->pComments_PassCode
                     && pOneCompileInfo->mType[IDX_TREE_LEVEL_TYPE] == TYPE_CONT
                     && cSplitFlag4Tran4BfGoDown != '|'
                     && cSplitFlag4Tran4BfGoDown != '\0'
                     && pOneTranShortPathHeadNode->pOneTreeTranLevel->cSplitFlag != '|'
                     && pOneTranShortPathHeadNode->pOneTreeTranLevel->cSplitFlag != '\0' )
                    {
                        // 若下个节点注释为空，直接挂载
                        if( ! pOneCompileInfo4NextNode->pComments_PassCode )
                        {
                            pOneCompileInfo4NextNode->pComments_PassCode = pOneCompileInfo->pComments_PassCode;
                            pOneCompileInfo->pComments_PassCode = NULL;
                        }
                    }
                    // 下一个 节点注释是否需要移动到 当前 节点
                    else if( pOneCompileInfo4NextNode->pComments_PassCode 
                          && pOneCompileInfo->mType[IDX_TREE_LEVEL_TYPE] == TYPE_CONT
                          && pNextNode4Check->pOneTreeTranLevel->cSplitFlag != '|'
                          && pNextNode4Check->pOneTreeTranLevel->cSplitFlag != '\0' )
                    {
                        // 若下个节点注释为空，直接挂载
                        if( ! pOneCompileInfo->pComments_PassCode )
                        {
                            pOneCompileInfo->pComments_PassCode = pOneCompileInfo4NextNode->pComments_PassCode;
                            pOneCompileInfo4NextNode->pComments_PassCode = NULL;
                        }
                    }
                }

                // if( pOneCompileInfo->pFork )
                if( pOneCompileInfo->pFork && pOneTranShortPathHeadNode->pOneTreeTranLevel->iKeywordLen == 0 )
                {
if(IF_PRINT) printf("run here 111\n");

                    // 缩进敏感，并且下钻对象是树，下钻前
                    if( pOneCompileInfo->pFork->mType[IDX_OBJ] == 'P'
                     && (cIndentType == INDENT_TRANSLATOR || cIndentType == INDENT_COMPILER_TRANSLATOR ) )
                    {
                        struct stString * pIndentList4TranTailBf = pstIndentList4TranList;

                        // 添加缩进节点
                        pstIndentList4TranList->next = getStringNode();
                        memset(pstIndentList4TranList->next, 0x00, sizeof(struct stString));
                        pstIndentList4TranList->next->pp = pstIndentList4TranList;  // pp -> before
                        pstIndentList4TranList = pstIndentList4TranList->next;

// printf("OneTreeIndent len = %d\n", pOneTranShortPathHeadNode->pOneTreeTranLevel->iIndentLen);
// printStrForDebug("OneTreeIndent", pOneTranShortPathHeadNode->pOneTreeTranLevel->pIndentHead, pOneTranShortPathHeadNode->pOneTreeTranLevel->iIndentLen + 4);
// printf("pOneTranShortPathHeadNode->pOneTreeTranLevel->cSplitFlag = [%c]\n", pOneTranShortPathHeadNode->pOneTreeTranLevel->cSplitFlag);  // debug
                        // 生成完整 缩进 字符串
                        if( pOneTranShortPathHeadNode->pOneTreeTranLevel->cSplitFlag == '|' )
                        {
                            // 新缩进长度 = 上一个缩进长度 + 配置文件的缩进长度
                            pstIndentList4TranList->iStrLen = pIndentList4TranTailBf->iStrLen + pOneTranShortPathHeadNode->pOneTreeTranLevel->iIndentLen;
                            pstIndentList4TranList->pStr = (char *)malloc(pstIndentList4TranList->iStrLen + 4);

                            // 复制上一个缩进
                            memcpy(pstIndentList4TranList->pStr, pIndentList4TranTailBf->pStr, pIndentList4TranTailBf->iStrLen);
                            // 拼接新的缩进
                            memcpy( pstIndentList4TranList->pStr + pIndentList4TranTailBf->iStrLen
                                  , pOneTranShortPathHeadNode->pOneTreeTranLevel->pIndentHead
                                  , pOneTranShortPathHeadNode->pOneTreeTranLevel->iIndentLen );

                            // 加上结束符
                            *(pstIndentList4TranList->pStr + pstIndentList4TranList->iStrLen) = '\0';
                        }
                        else //// if( pOneTranShortPathHeadNode->pOneTreeTranLevel->cSplitFlag == '/' or '\\' )
                        {
                            // 计算被拼接行长度，为新缩进长度做参考
                            unsigned int iLineLen = 0;
                            for( pResultTail -- ; *pResultTail != '\n' && *pResultTail != '\0'; pResultTail -- )
                            {
                                iLineLen ++ ;
                            }

                            // 使得 pResultTail 回到原来位置
                            // pResultTail += iLineLen + 1;

                            // 新增缩进长度 = 行长度
                            pstIndentList4TranList->iStrLen = iLineLen;
                            pstIndentList4TranList->pStr = (char *)malloc(iLineLen + 4);

                            // 根据拼接行的字符类型，生成新的缩进
                            char * pTranIndentTail = pstIndentList4TranList->pStr;
                            pResultTail ++ ;  // pass \n or \0
                            for( ; iLineLen; iLineLen -- )
                            {
                                if( *pResultTail == '\t' )
                                    *pTranIndentTail = '\t';
                                else
                                    *pTranIndentTail = ' ';

                                pTranIndentTail ++ ;
                                pResultTail ++ ;     // 执行完，pResultTail 回到原来位置
                            }

                            if( pOneTranShortPathHeadNode->pOneTreeTranLevel->cSplitFlag == '/' )
                            {
                                *pTranIndentTail = ' ';
                                pTranIndentTail ++ ;

                                pstIndentList4TranList->iStrLen ++ ;
                            }

                            // 加上结束符
                            *(pstIndentList4TranList->pStr + pstIndentList4TranList->iStrLen) = '\0';

                        } // if( pOneTranShortPathHeadNode->pOneTreeTranLevel->cSplitFlag == '|' )
                    } // if( cIndentType == INDENT_TRANSLATOR || cIndentType == INDENT_COMPILER_TRANSLATOR )

                    /////////////////////////////////////////////
                    // 下钻前，将挂载 此CompileInfo 节点上注释，后移到pFork节点后的第一个节点，以便下钻后能输出
                    if( pOneCompileInfo->pComments_PassCode )
                    {
                        pOneCompileInfo->pFork->next->pComments_PassCode = pOneCompileInfo->pComments_PassCode;
                        pOneCompileInfo->pComments_PassCode = NULL;
                    }

                    /////////////////////////////////////////////
                    // 下钻
// printf("??????????????????????? pTranShortPathHeadNodeList->iNum = %d\n", pTranShortPathHeadNodeList->iNum);
                    // 20231210 若是 路径首节点 下钻，cSplitFlag4Tran4BfGoDown沿用上一层下钻的值
                    if( pTranShortPathHeadNodeList->iNum != 1 || cSplitFlag4Tran4BfGoDown == '\0' )  // 20231210 若不是首节点下钻，跳过连续下钻
                        cSplitFlag4Tran4BfGoDown = pOneTranShortPathHeadNode->pOneTreeTranLevel->cSplitFlag;
// printf("\n------------------------- Tree 2 Tree/Line [%d : %d] [%c] !!!!!!!!!!!!!!!!!!!\n", pOneCompileInfo->iLineNum, iLineNumBf4Tran, cSplitFlag4Tran4BfGoDown);
                    if( ! go2CompileInfoTree4Tran(pOneCompileInfo->pFork) )
                        return false;

                    /////////////////////////////////////////////
                    // 缩进敏感，并且下钻对象是树，下钻后
                    if( pOneCompileInfo->pFork->mType[IDX_OBJ] == 'P'
                     && (cIndentType == INDENT_TRANSLATOR || cIndentType == INDENT_COMPILER_TRANSLATOR) )
                    {
                        // 删除最后一个缩进节点
                        pstIndentList4TranList = (struct stString *)(pstIndentList4TranList->pp);
                        freeStringNode( & (pstIndentList4TranList->next) );
                        pstIndentList4TranList->next = NULL;
                    }
                } 
                else //// if( pOneCompileInfo->pFork == NULL )
                {
if(IF_PRINT) printf("run here 222\n");
// printf("        pOneCompileInfo->iLineNum = %d | iLineNumBf4Tran = %d\n", pOneCompileInfo->iLineNum, iLineNumBf4Tran);  // debug

                    // 将转换的 缩进/分行 写入内存
                    if( cSplitFlag4Tran4BfGoDown == '|' )
                    {
                        cSplitFlag4Tran4BfGoDown = '\0';

                        // 写行尾注释
                        writeCommentAtLineEnd(pOneCompileInfo);

                        // 缩进敏感
                        if( cIndentType == INDENT_TRANSLATOR || cIndentType == INDENT_COMPILER_TRANSLATOR )
                        {
// printf("pstIndentList4TranList->iStrLen = [%d]-[%d]\n", pstIndentList4TranList->iStrLen, pOneTranShortPathHeadNode->pOneTreeTranLevel->iIndentLen);   // debug

                            // 写独立行注释
                            writeCommentAtLineStart( pOneCompileInfo, pstIndentList4TranList->pStr, pstIndentList4TranList->iStrLen
                                                   , pOneTranShortPathHeadNode->pOneTreeTranLevel->pIndentHead
                                                   , pOneTranShortPathHeadNode->pOneTreeTranLevel->iIndentLen);

                            ///////////////////////////////////////////

                            // 缓存处理
                            doWithMem4WriteTranResult(1 + pstIndentList4TranList->iStrLen + pOneTranShortPathHeadNode->pOneTreeTranLevel->iIndentLen);

                            // 分行
                            *pResultTail = '\n';
                            pResultTail ++ ;

                            // 缩进
                            memcpy(pResultTail, pstIndentList4TranList->pStr, pstIndentList4TranList->iStrLen);
                            pResultTail += pstIndentList4TranList->iStrLen;

                            memcpy(pResultTail, pOneTranShortPathHeadNode->pOneTreeTranLevel->pIndentHead
                                              , pOneTranShortPathHeadNode->pOneTreeTranLevel->iIndentLen);
                            pResultTail += pOneTranShortPathHeadNode->pOneTreeTranLevel->iIndentLen;
                        }
                        else if( pOneCompileInfo->iLineNum != iLineNumBf4Tran )
                        {
// printf("pOneCompileInfo->iLineNum != iLineNumBf4Tran 222 !!!!!!!!!!!!!!!!!!!!!!!!!\n");

                            // 写独立行注释
                            writeCommentAtLineStart(pOneCompileInfo, pOneCompileInfo->pLineHead, pOneCompileInfo->iLineHeadKgf, NULL, 0);

                            ///////////////////////////////////////////////

                            // 缓存处理
                            doWithMem4WriteTranResult(1 + pOneCompileInfo->iLineHeadKgf);

                            // 分行
                            *pResultTail = '\n';
                            pResultTail ++ ;

                            // 缩进
                            memcpy(pResultTail, pOneCompileInfo->pLineHead, pOneCompileInfo->iLineHeadKgf);
                            pResultTail += pOneCompileInfo->iLineHeadKgf;
                            *pResultTail = '\0';

                            iLineNumBf4Tran = pOneCompileInfo->iLineNum;
                        }
                        else if( *(pResultTail-1) != ' ' && *(pResultTail-1) != '\t' && *(pResultTail-1) != '\n' )
                        {
                            // 缓存处理
                            doWithMem4WriteTranResult(1);

                            // 分行
                            *pResultTail = ' ';
                            pResultTail ++ ;
                        }
                    }
                    else if( cSplitFlag4Tran4BfGoDown == '/' || cSplitFlag4Tran4BfGoDown == '\\')
                    {
// if( pOneCompileInfo->pComments_PassCode )
    // printf("pOneCompileInfo->pComments_PassCode ////////////////////////////////////\n");

                        if( cSplitFlag4Tran4BfGoDown == '/' )
                        {
                            // 缓存处理
                            doWithMem4WriteTranResult(1);

                            *pResultTail = ' ';
                            pResultTail ++ ;
                        }

                        cSplitFlag4Tran4BfGoDown = '\0';

                        // 下钻缩进自适应
                        if( cIndentType == INDENT_TRANSLATOR || cIndentType == INDENT_COMPILER_TRANSLATOR )
                        {
// printf("pstIndentList4TranList->iStrLen = [%d]-[%d]\n", pstIndentList4TranList->iStrLen, pOneTranShortPathHeadNode->pOneTreeTranLevel->iIndentLen);   // debug

                            // 缩进自适应
                            unsigned int iCmp = pstIndentList4TranList->iStrLen > pOneTranShortPathHeadNode->pOneTreeTranLevel->iIndentLen
                                              ? pOneTranShortPathHeadNode->pOneTreeTranLevel->iIndentLen : pstIndentList4TranList->iStrLen;
// printf("Try it iCmp = [%d]\n", iCmp);  // debug

                            for( ; iCmp; iCmp -- ) {
                                if( ! strncmp(pstIndentList4TranList->pStr+pstIndentList4TranList->iStrLen-iCmp, pOneTranShortPathHeadNode->pOneTreeTranLevel->pIndentHead, iCmp) )
                                    break;
                            }

// printf("Got it iCmp = [%d]\n", iCmp);  // debug
                            pstIndentList4TranList->iStrLen -= iCmp;
                            // *(pstIndentList4TranList->pStr + pstIndentList4TranList->iStrLen) = '\0';   // 这里不用断掉

                            // 自适应之后，要调整一下当前下钻节点的缩进信息 
                            // pstIndentList4TranList->pStr = pstIndentList4TranList->pStr;
                            pstIndentList4TranList->iStrLen = pstIndentList4TranList->iStrLen;
                        }
                    }
                    //////////////////////////////////////
                    else if( pOneTranShortPathHeadNode->pOneTreeTranLevel->cSplitFlag == '|' )
                    {
if(IF_PRINT) printf("run here 333\n");
// printf("111111111111111111111111111111111111 [%d][%d]\n", pstIndentList4TranList->iStrLen, pOneTranShortPathHeadNode->pOneTreeTranLevel->iIndentLen);
// printStrForDebug("    Cpl value", pOneCompileInfo->pVal3, pOneCompileInfo->iValLen3);

                        writeCommentAtLineEnd(pOneCompileInfo);

                        if( cIndentType == INDENT_TRANSLATOR || cIndentType == INDENT_COMPILER_TRANSLATOR )
                        {
if(IF_PRINT) printf("run here 333 111\n");
                            writeCommentAtLineStart(pOneCompileInfo, pstIndentList4TranList->pStr, pstIndentList4TranList->iStrLen
                                                   ,pOneTranShortPathHeadNode->pOneTreeTranLevel->pIndentHead
                                                   ,pOneTranShortPathHeadNode->pOneTreeTranLevel->iIndentLen);

                            //////////////////////////////////////

                            // 为了避免 __ANT__ 转换出现过多的空行，__ANY__ 的分行不处理
                            if( pOneCompileInfo->iValLen3 )
                            {
                                // 缓存处理
                                doWithMem4WriteTranResult(1 + pstIndentList4TranList->iStrLen + pOneTranShortPathHeadNode->pOneTreeTranLevel->iIndentLen);

                                *pResultTail = '\n';
                                pResultTail ++ ;

                                memcpy(pResultTail, pstIndentList4TranList->pStr, pstIndentList4TranList->iStrLen);
                                pResultTail += pstIndentList4TranList->iStrLen;

                                memcpy(pResultTail, pOneTranShortPathHeadNode->pOneTreeTranLevel->pIndentHead
                                                  , pOneTranShortPathHeadNode->pOneTreeTranLevel->iIndentLen);
                                pResultTail += pOneTranShortPathHeadNode->pOneTreeTranLevel->iIndentLen;
                            }
                        }
                        else if( pOneCompileInfo->iLineNum != iLineNumBf4Tran
                              && pOneCompileInfo->iValLen3  // 若pOneCompileInfo->iValLen3为空，应该是Skip节点，不处理
                        )
                        {
if(IF_PRINT) printf("run here 333 222\n");
// printf("pOneCompileInfo->iLineNum != iLineNumBf4Tran  111 !!!!!!!!!!!!!!!!!!!!!\n");

                            writeCommentAtLineStart(pOneCompileInfo, pOneCompileInfo->pLineHead, pOneCompileInfo->iLineHeadKgf, NULL, 0);

                            ///////////////////////////////////////////

                            // 缓存处理
                            doWithMem4WriteTranResult(1 + pOneCompileInfo->iLineHeadKgf);

                            // 分行
                            *pResultTail = '\n';
                            pResultTail ++ ;

                            // 缩进
                            memcpy(pResultTail, pOneCompileInfo->pLineHead, pOneCompileInfo->iLineHeadKgf);
                            pResultTail += pOneCompileInfo->iLineHeadKgf;

                            iLineNumBf4Tran = pOneCompileInfo->iLineNum;
                        }
                        else if( *(pResultTail-1) != ' ' && *(pResultTail-1) != '\t' && *(pResultTail-1) != '\n' )
                        {
if(IF_PRINT) printf("run here 333 333\n");
                            // 缓存处理
                            doWithMem4WriteTranResult(1);
                            *pResultTail = ' ';
                            pResultTail ++ ;
                        }
                    }
                    else if( pOneTranShortPathHeadNode->pOneTreeTranLevel->cSplitFlag == '/' )
                    {
if(IF_PRINT) printf("run here 444\n");
                        // 缓存处理
                        doWithMem4WriteTranResult(1);
                        *pResultTail = ' ';
                        pResultTail ++ ;
                    }
                    else if( pOneTranShortPathHeadNode->pOneTreeTranLevel->cSplitFlag == '\\' )
                    {
if(IF_PRINT) printf("run here 555\n");
// printStrForDebug("111 pOneTranShortPathHeadNode->pOneTreeTranLevel->pKeyword", pOneTranShortPathHeadNode->pOneTreeTranLevel->pKeyword, pOneTranShortPathHeadNode->pOneTreeTranLevel->iKeywordLen);
// printStrForDebug("111 pOneCompileInfo->pVal3", pOneCompileInfo->pVal3, pOneCompileInfo->iValLen3);
// printf("pOneCompileInfo cTreeLevelType : %d\n", pOneCompileInfo->mType[IDX_TREE_LEVEL_TYPE]);

                        // __ANY__ 分行
                        if( pOneCompileInfo->mType[IDX_TREE_LEVEL_TYPE] == 0   // 20260301
						 && pOneTranShortPathHeadNode->pOneTreeTranLevel->iKeywordLen == 0   // 20231209
                         && pOneCompileInfo->iValLen3 == 0
						 )
                        {
// printf("___ANY___________________[%d][%d]\n", iLineNumBf4Tran, pOneCompileInfo->iLineNum);
                            // 缓存处理
                            doWithMem4WriteTranResult(1);
                            *pResultTail = '\n';
                            pResultTail ++ ;
                        }
                    }

                    *pResultTail = '\0';
					
// printf("pOneCompileInfo->pFork = [%p]\n", pOneCompileInfo->pFork);
// printStrForDebug("Cpl value", pOneCompileInfo->pVal3, pOneCompileInfo->iValLen3);
// printf("Cpl value addr : [%p]\n", pOneCompileInfo->pVal3);
// printf("Cpl cTreeLevelType : %d\n", pOneCompileInfo->mType[IDX_TREE_LEVEL_TYPE]);

/********************************************************************
                    //////////////////////////////////////////
                    // 转换 内容 写入内存
                    if( pOneTranShortPathHeadNode->pOneTreeTranLevel->iKeywordLen ) {
if(IF_PRINT) printf("run here 666\n");
// printStrForDebug("222 pOneTranShortPathHeadNode->pOneTreeTranLevel->pKeyword", pOneTranShortPathHeadNode->pOneTreeTranLevel->pKeyword, pOneTranShortPathHeadNode->pOneTreeTranLevel->iKeywordLen);

                        // 缓存处理
                        doWithMem4WriteTranResult(pOneTranShortPathHeadNode->pOneTreeTranLevel->iKeywordLen);

                        memcpy(pResultTail, pOneTranShortPathHeadNode->pOneTreeTranLevel->pKeyword
                                          , pOneTranShortPathHeadNode->pOneTreeTranLevel->iKeywordLen);
                        pResultTail += pOneTranShortPathHeadNode->pOneTreeTranLevel->iKeywordLen;
                    } else {
if(IF_PRINT) printf("run here 777\n");
                        // 非空
                        if( pOneCompileInfo->iValLen3 )
                        {
                            // 缓存处理
                            doWithMem4WriteTranResult(pOneCompileInfo->iValLen3);
                            memcpy(pResultTail, pOneCompileInfo->pVal3, pOneCompileInfo->iValLen3);
                            pResultTail += pOneCompileInfo->iValLen3;
							
							iLineNumBf4Tran = pOneCompileInfo->iLineNum;   // 20260301
                        }
                    }
**********************************************************************/
					// 判断是否SKIP空节点： pOneCompileInfo->iValLen3 代表CONT/STR, pOneCompileInfo->pFork代表PATH
					if( pOneCompileInfo->iValLen3 || pOneCompileInfo->pFork )
					{
						// 若有转换内容，写转换内容
						if( pOneTranShortPathHeadNode->pOneTreeTranLevel->iKeywordLen ) {
if(IF_PRINT) printf("run here 666\n");
// printStrForDebug("222 pOneTranShortPathHeadNode->pOneTreeTranLevel->pKeyword", pOneTranShortPathHeadNode->pOneTreeTranLevel->pKeyword, pOneTranShortPathHeadNode->pOneTreeTranLevel->iKeywordLen);

							// 缓存处理
							doWithMem4WriteTranResult(pOneTranShortPathHeadNode->pOneTreeTranLevel->iKeywordLen);

							memcpy(pResultTail, pOneTranShortPathHeadNode->pOneTreeTranLevel->pKeyword
											  , pOneTranShortPathHeadNode->pOneTreeTranLevel->iKeywordLen);
							pResultTail += pOneTranShortPathHeadNode->pOneTreeTranLevel->iKeywordLen;
						}
						else  // 无转换内容，写原文内容
						{
if(IF_PRINT) printf("run here 777\n");
                            // 缓存处理
                            doWithMem4WriteTranResult(pOneCompileInfo->iValLen3);
                            memcpy(pResultTail, pOneCompileInfo->pVal3, pOneCompileInfo->iValLen3);
                            pResultTail += pOneCompileInfo->iValLen3;
							
							iLineNumBf4Tran = pOneCompileInfo->iLineNum;   // 20260301
						}
					}

                    *pResultTail = '\0';

                } // if( pOneCompileInfo->pFork )
            } // if( pOneTranShortPathHeadNode4Next->pOneTreeCplLevel )

            // 若此非首节点为最后一个，但首节点不是最后一个，此节点不释放
            if( ! pOneTranShortPathHeadNode4Next->next      // 最后一个节点
             && pOneTranShortPathHeadNode != (struct stPath *)(pTranShortPathHeadNodeList->pp)  // 非首节点
             && ((struct stPath *)(pTranShortPathHeadNodeList->pp))->next )    // 首节点不是最后一个，注意到这一步，首节点已经释放掉一个了
            {
                continue ;
            }

            pOneTranShortPathHeadNode->next = pOneTranShortPathHeadNode4Next->next;
            freePathNode( & pOneTranShortPathHeadNode4Next);

        } // while( true )  循环一次，处理一列
// printf("-------------------------\n");

        /////////////////////////////////////////////////
        // 下钻处理
        if( pTranShortPathHeadNodeList->next && pTranShortPathHeadNodeList->next->cFlag == 'n' )
        {
            if( ! writeTreeTranResult4n(pTranShortPathHeadNodeList->next) )
                return false;
        }

    } // while( true )

    *pResultTail = '\0';
    return true;
}

bool CZGLanguage::writeTreeTranResult4n(struct stString * pTranShortPathHeadNodeList)
{
// printf("writeTreeTranResult4nnnnnnn !!!!!!!!!!!!!!!!!!!\n");

    struct stPath * pOneTranShortPathHeadNode = NULL;
    struct stPath * pOneTranShortPathHeadNode4Next = NULL;

    ////////////////////////////////////////////////////////
    // 下钻多次，不能直接free掉，这里复制一份
    struct stPath * pCopyTranShortPathHead = getPathNode();
    memset(pCopyTranShortPathHead, 0x00, sizeof(struct stPath));
    struct stPath * pCopyTranShortPathTail = pCopyTranShortPathHead;

    for( pOneTranShortPathHeadNode = (struct stPath *)(pTranShortPathHeadNodeList->pp)
       ; pOneTranShortPathHeadNode
       ; pOneTranShortPathHeadNode = pOneTranShortPathHeadNode->nextNode )
    {
        pCopyTranShortPathTail->nextNode = getPathNode();
        pCopyTranShortPathTail = pCopyTranShortPathTail->nextNode;
        memcpy(pCopyTranShortPathTail, pOneTranShortPathHeadNode, sizeof(struct stPath));

        struct stPath * pCopyTranShortPathTail4Next = pCopyTranShortPathTail;
        struct stPath * pOneTranShortPathHeadNode4Next = pOneTranShortPathHeadNode->next;
        for( ; pOneTranShortPathHeadNode4Next; pOneTranShortPathHeadNode4Next=pOneTranShortPathHeadNode4Next->next )
        {
            pCopyTranShortPathTail4Next->next = getPathNode();
            pCopyTranShortPathTail4Next = pCopyTranShortPathTail4Next->next;
            memcpy(pCopyTranShortPathTail4Next, pOneTranShortPathHeadNode4Next, sizeof(struct stPath));
        }
    }

    /////////////////////////////////////////////////////

    if( ! writeTranRes4ShortPaths(pTranShortPathHeadNodeList) )
        return false;

    ///////////////////////////////////////////////////

    // 释放掉上面为释放的头排节点
    for( pOneTranShortPathHeadNode = (struct stPath *)(pTranShortPathHeadNodeList->pp)
       ; pOneTranShortPathHeadNode->nextNode
       ; ) 
    {
        struct stPath *pPathFree = pOneTranShortPathHeadNode;
        pOneTranShortPathHeadNode = pOneTranShortPathHeadNode->nextNode;
        freePathNode( & pPathFree );
    }
    freePathNode( & pOneTranShortPathHeadNode );

    // 将复制的内容替换掉上面free的
    pTranShortPathHeadNodeList->pp = pCopyTranShortPathHead->nextNode;

    // 释放掉单个的头节点
    freePathNode( & pCopyTranShortPathHead );

    return true;
}

/**************************************************************

TranShortPathHeadNode_1 -> 1/N/n : OtherName_1 : Value_1, Value_2
                                 : OtherName_2 : NULL
                                 : OtherName_3 : Value_1
                                 : NULL
TranShortPathHeadNode_2 -> 1/N/n : OtherName_4 : NULL
                                 : OtherName_5 : Value_1, Value_2
                                 : OtherName_6 : Value_1, Value_2
                                 : NULL
.................................................................
**************************************************************/
bool CZGLanguage::writeTreeTranResult(struct stString * pTranShortPathHeadNodeList)
{
// printf("writeTreeTranResult writeTreeTranResult writeTreeTranResult !!!!!!!!!!!!!!!!!!! [%d][%d]\n", pstIndentList4TranList->iStrLen, pTranShortPathHeadNodeList->iNum);

    // 循环一次，处理一个短路径 （包含下钻）
    for( ; pTranShortPathHeadNodeList; pTranShortPathHeadNodeList=pTranShortPathHeadNodeList->next )
    {
        // 下钻部分释放
        if( pTranShortPathHeadNodeList->cFlag == 'n' )
        {
            // 释放
            struct stPath * pOneTranShortPathHeadNode = (struct stPath *)(pTranShortPathHeadNodeList->pp);
            while( pOneTranShortPathHeadNode->nextNode )
            {
                struct stPath * pPathList4Free = pOneTranShortPathHeadNode;
                pOneTranShortPathHeadNode = pOneTranShortPathHeadNode->nextNode;
                freePathList( & pPathList4Free );
            }

            freePathList( & pOneTranShortPathHeadNode );

            continue ;
        }

        ///////////////////////////////////////////////

        if( ! writeTranRes4ShortPaths(pTranShortPathHeadNodeList) )
            return false;

        ///////////////////////////////////////////////
        // 精益求精，释放掉多余的节点
        struct stPath * pOneTranShortPathHeadNode = (struct stPath *)(pTranShortPathHeadNodeList->pp);
        for( ; pOneTranShortPathHeadNode; pOneTranShortPathHeadNode=pOneTranShortPathHeadNode->nextNode )
        {
            if( pOneTranShortPathHeadNode->next )
                freePathList( & (pOneTranShortPathHeadNode->next) );
        }

    } // for( ; pTranShortPathHeadNodeList; pTranShortPathHeadNodeList=pTranShortPathHeadNodeList->next )

    return true;
}

// 解析属性部分的表达式列表，返回值就是列表本身
bool CZGLanguage::runAttrExpr(struct stCompileInfo *pOneCompileInfo)
{
    // 拷贝一份表达式解析链表，用于解析消耗 
    struct stExprInfo * pExprHead = (struct stExprInfo *)getStringNode();
    struct stExprInfo * pExprCopyTail = pExprHead;
    memcpy(pExprHead, pOneCompileInfo->pAttrExpr, sizeof(struct stExprInfo));

    struct stExprInfo * pExprInfoTmp = pOneCompileInfo->pAttrExpr->next;
    for( ; pExprInfoTmp; pExprInfoTmp=pExprInfoTmp->next )
    {    
        pExprCopyTail->next = (struct stExprInfo *)getStringNode();
        memcpy(pExprCopyTail->next, pExprInfoTmp, sizeof(struct stExprInfo));
        pExprCopyTail->next->before = pExprCopyTail;
        pExprCopyTail = pExprCopyTail->next;
        pExprCopyTail->next = NULL;
    }

    // 处理一套函数
    while( pExprCopyTail )
    {
        // 分离头节点
        pExprCopyTail = pExprHead->next;
        pExprHead->next = NULL;
        pExprCopyTail->before = NULL;
    
// printStrForDebug("Attr Expr", pExprHead->pStr, pExprHead->iStrLen);
// printf("     line  : %d\n", pExprHead->iLevel);
    
        // 处理一层函数
        while( pExprCopyTail->cType )
        {
            // 查找函数名
            for( ; pExprCopyTail->cType != 'F'; pExprCopyTail=pExprCopyTail->next );
// printStrForDebug("     Attr function", pExprCopyTail->pStr, pExprCopyTail->iStrLen);
    
            // 函数是否缺参数
            if( ! pExprCopyTail->before )
            {
                *(pExprCopyTail->pStr + pExprCopyTail->iStrLen) = '\0';
                printf("!!! Syntax file ERROR !!!\n|1| Line %d : \"%s\"<<<\n|2| Miss parameter for function '%s' !\n", pExprHead->iLevel, pExprCopyTail->pStr, pExprCopyTail->pStr);
                return false;
            }
    
            // 执行具体函数功能
            /***********************************************************************************
            结果结构：
            stExprRetHead -> stExprRet4KeyValue -> stExprRet4KeyValue -> ....
                  |
            stExprRetHead -> stExprRet4List(pHead,pTail) -> stExprRet4List -> stExprRet4List -> ....
                  |
            stExprRetHead -> stExprRet4List(pHead,pTail) -> stExprRet4List -> stExprRet4List -> ....
                  |
            ...............................................................
                  |
            stExprRetHead -> NULL
            ***********************************************************************************/
    
            if( (pExprCopyTail->iStrLen == 7 && ! strncmp(pExprCopyTail->pStr, "addhead", pExprCopyTail->iStrLen))
             || (pExprCopyTail->iStrLen == 7 && ! strncmp(pExprCopyTail->pStr, "addtail", pExprCopyTail->iStrLen)) )
            {
                // 遍历参数
                for( pExprInfoTmp=pExprCopyTail->before 
                   ; pExprInfoTmp && pExprInfoTmp->iLevel == pExprInfoTmp->next->iLevel
                   ; pExprInfoTmp=pExprInfoTmp->before )
                {
                    char * pListName = NULL;
                    unsigned int iListNameLen = 0;

                    // 处理 变量 名称(如: __NAME__)
                    if( pExprInfoTmp->iStrLen != TYPE_POINTER ) {
                        pListName = pExprInfoTmp->pStr;
                        iListNameLen = pExprInfoTmp->iStrLen;
                    // 处理 常量 名称(如: t2)
                    } else {
                        struct stCompileInfo * pCompileInfoTmp = (struct stCompileInfo *)(pExprInfoTmp->pStr);
                        pListName = pCompileInfoTmp->pVal3;
                        iListNameLen = pCompileInfoTmp->iValLen3;
                    }
printStrForDebug("     Parm111", pListName, iListNameLen);  // debug
    
                    struct stExprRet4List * pExprRet4ListNew = (struct stExprRet4List *)getStringNode();
                    memset(pExprRet4ListNew, 0x00, sizeof(struct stExprRet4List));
                    pExprRet4ListNew->pCompileInfo = pOneCompileInfo;
    
                    // 按名称查找列表
                    struct stExprRetHead * pExprRetHeadTmp = pstExprRetHead->next;  // pass Key-Value
                    for( ; pExprRetHeadTmp->next ; pExprRetHeadTmp=pExprRetHeadTmp->next ) {
                        if( pExprRetHeadTmp->iNameLen == iListNameLen /*pExprInfoTmp->iStrLen*/
                         && ! strncmp(pExprRetHeadTmp->pName, pListName/*pExprInfoTmp->pStr*/, iListNameLen/*pExprInfoTmp->iStrLen*/) )
                            break ;
                    }
    
                    // 走到最后一个占位空节点，说明未找到链表，直接使用该节点创建一个新链表
                    if( pExprRetHeadTmp->next == NULL ) {
                        // 链表名称
                        pExprRetHeadTmp->pName = pListName/*pExprInfoTmp->pStr*/;
                        pExprRetHeadTmp->iNameLen = iListNameLen/*pExprInfoTmp->iStrLen*/;
    
                        // 链表末尾节点
                        pExprRet4ListNew->pTail = pExprRet4ListNew;
    
                        // 此链表挂载到头节点
                        pExprRetHeadTmp->pExprRetList = pExprRet4ListNew;
    
                        // 创建一个新的占位空头节点 
                        pExprRetHeadTmp->next = (struct stExprRetHead *)getStringNode();
                        memset(pExprRetHeadTmp->next, 0x00, sizeof(struct stExprRetHead));
    
                    // 若链表中无节点
                    } else if( pExprRetHeadTmp->pExprRetList == NULL ) {
                        // 链表末尾节点
                        pExprRet4ListNew->pTail = pExprRet4ListNew;
    
                        // 此链表挂载到头节点
                        pExprRetHeadTmp->pExprRetList = pExprRet4ListNew;
    
                    // addhead() 
                    } else if( *(pExprCopyTail->pStr + 3) == 'h' ) {
                        pExprRet4ListNew->next = (struct stExprRet4List *)(pExprRetHeadTmp->pExprRetList);
                        pExprRet4ListNew->pTail = ((struct stExprRet4List *)(pExprRetHeadTmp->pExprRetList))->pTail;
                        pExprRetHeadTmp->pExprRetList = pExprRet4ListNew;
    
                    // addtail()
                    } else {
                        struct stExprRet4List * pTheExprRet4List = (struct stExprRet4List *)(pExprRetHeadTmp->pExprRetList);
                        pTheExprRet4List->pTail->next = pExprRet4ListNew;
                        pTheExprRet4List->pTail = pTheExprRet4List->pTail->next;
                        pTheExprRet4List->pTail->next = NULL;
                    }
    
                    // 保留最后一个节点指针，方便后续回收
                    if( ! pExprInfoTmp->before )
                        break ;
    
                } // for( pExprInfoTmp=pExprCopyTail->before; pExprInfoTmp; pExprInfoTmp=pExprInfoTmp->before )
    
                // 执行完函数
                // 回收参数节点
                if( pExprInfoTmp->iLevel != pExprInfoTmp->next->iLevel ) {
                    pExprCopyTail->before->next = NULL;
                    freeExprInfoList(& (pExprInfoTmp->next) );
                    pExprInfoTmp->next = pExprCopyTail;
                    pExprCopyTail->before = pExprInfoTmp;
// if( pExprInfoTmp->iStrLen != TYPE_POINTER )
// printStrForDebug("     Parm111 new", pExprInfoTmp->pStr, pExprInfoTmp->iStrLen);  // debug
                } else {
                    pExprCopyTail->before->next = NULL;
                    pExprCopyTail->before = NULL;
                    freeExprInfoList(& pExprInfoTmp);
                }
    
                // 返回值，若无，直接清理节点，而不是给空值
                if( pExprCopyTail->before ) {
                    // 理论上，有 ->before，肯定有->next->next
                    pExprCopyTail = pExprCopyTail->before;
                    pExprCopyTail->next = pExprCopyTail->next->next;
                    freeExprInfoNode(&(pExprCopyTail->next->before));
                    pExprCopyTail->next->before = pExprCopyTail;
                } else if( pExprCopyTail->next ) {
                    pExprCopyTail = pExprCopyTail->next;
                    freeExprInfoNode(&(pExprCopyTail->before));
                    pExprCopyTail->before = NULL;
                } else {
                    freeExprInfoNode(& pExprCopyTail );
                    break ;   // while( pExprCopyTail->cType )
                }
    
            } else if( (pExprCopyTail->iStrLen == 7 && ! strncmp(pExprCopyTail->pStr, "gethead", pExprCopyTail->iStrLen))
                    || (pExprCopyTail->iStrLen == 7 && ! strncmp(pExprCopyTail->pStr, "gettail", pExprCopyTail->iStrLen)) ) {
    
                // 参数只能有一个
                pExprInfoTmp = pExprCopyTail->before;
// // if( pExprInfoTmp->iStrLen != TYPE_POINTER )
// printStrForDebug("     Parm222", pExprInfoTmp->pStr, pExprInfoTmp->iStrLen);  // debug
                if( pExprInfoTmp->before && pExprInfoTmp->before->iLevel == pExprInfoTmp->iLevel )
                {
                    *(pExprCopyTail->pStr + pExprCopyTail->iStrLen) = '\0';
                    printf("!!! Syntax file ERROR !!!\n|1| Line %d : \"%s\"<<<\n|2| Too many parameters for function '%s' !\n", pExprHead->iLevel, pExprCopyTail->pStr, pExprCopyTail->pStr);
                    return false;
                }
    
                // 按名称查找列表
                struct stExprRetHead * pExprRetHeadTmp = pstExprRetHead->next;  // pass Key-Value
                for( ; pExprRetHeadTmp->next ; pExprRetHeadTmp=pExprRetHeadTmp->next ) {
                    if( pExprRetHeadTmp->iNameLen == pExprInfoTmp->iStrLen
                     && ! strncmp(pExprRetHeadTmp->pName, pExprInfoTmp->pStr, pExprInfoTmp->iStrLen) )
                        break ;
                }

                // 执行完函数
                // 回收参数节点
                if( pExprInfoTmp->before )
                    pExprInfoTmp = pExprInfoTmp->before;

                if( pExprInfoTmp->iLevel != pExprInfoTmp->next->iLevel ) {
                    pExprCopyTail->before->next = NULL;
                    freeExprInfoNode(& (pExprInfoTmp->next) );
                    pExprInfoTmp->next = pExprCopyTail;
                    pExprCopyTail->before = pExprInfoTmp;
// printStrForDebug("     Parm222 new", pExprInfoTmp->pStr, pExprInfoTmp->iStrLen);  // debug
                } else {
                    pExprCopyTail->before->next = NULL;
                    pExprCopyTail->before = NULL;
                    freeExprInfoNode(& pExprInfoTmp);
                }
    
                if( pExprRetHeadTmp->next && pExprRetHeadTmp->pExprRetList )
                {
/******************************************************
                    // 执行完函数
                    // 回收参数节点
                    if( pExprInfoTmp->iLevel != pExprInfoTmp->next->iLevel ) {
                        pExprCopyTail->before->next = NULL;
                        freeExprInfoNode(& (pExprInfoTmp->next) );
                        pExprInfoTmp->next = pExprCopyTail;
                        pExprCopyTail->before = pExprInfoTmp;
// printStrForDebug("     Parm222 new", pExprInfoTmp->pStr, pExprInfoTmp->iStrLen);  // debug
                    } else {
                        pExprCopyTail->before->next = NULL;
                        pExprCopyTail->before = NULL;
                        freeExprInfoNode(& pExprInfoTmp);
                    }
******************************************************/
    
                    // 返回值
                    // get得值
                    struct stExprRet4List * pOneExprRet = NULL;

                    // gethead() or Only one node
                    if( *(pExprCopyTail->pStr + 3) == 'h' || ((struct stExprRet4List *)(pExprRetHeadTmp->pExprRetList))->next == NULL ) {
                        pOneExprRet = (struct stExprRet4List *)(pExprRetHeadTmp->pExprRetList);
                        pExprRetHeadTmp->pExprRetList = ((struct stExprRet4List *)(pExprRetHeadTmp->pExprRetList))->next;

                    // gettail()
                    } else {
                        struct stExprRet4List * pOneExprRetTmp = (struct stExprRet4List *)(pExprRetHeadTmp->pExprRetList);
                        pOneExprRet = pOneExprRetTmp->pTail;

                        for( ; pOneExprRetTmp->next != pOneExprRet; pOneExprRetTmp=pOneExprRetTmp->next );
                        pOneExprRetTmp->next = NULL;
                        ((struct stExprRet4List *)(pExprRetHeadTmp->pExprRetList))->pTail = pOneExprRetTmp;
                    }
    
                    // 值放入运算节点
                    pExprCopyTail->cType = 'P';
                    pExprCopyTail->iLevel -- ;
                    if( pOneExprRet->pCompileInfo->pFork ) {
// printf("pOneExprRet pFork : %p\n", pOneExprRet->pCompileInfo);  // debug
                        pExprCopyTail->pStr = (char *)(pOneExprRet->pCompileInfo);
                        pExprCopyTail->iStrLen = TYPE_POINTER;
                    } else {
// printStrForDebug("pOneExprRet value", pOneExprRet->pCompileInfo->pVal3, pOneExprRet->pCompileInfo->iValLen3);  // debug
                        pExprCopyTail->pStr = pOneExprRet->pCompileInfo->pVal3;
                        pExprCopyTail->iStrLen = pOneExprRet->pCompileInfo->iValLen3;
                    }
    
                    // 返回值，若无，直接清理节点，而不是给空值
                    if( pExprCopyTail->next == NULL )
                    {
                        freeExprInfoNode(& pExprCopyTail );
                        break ;   // while( pExprCopyTail->cType )
                    }

                } // if( pExprRetHeadTmp->next && pExprRetHeadTmp->pExprRetList )

            } else if( pExprCopyTail->iStrLen == 6 && ! strncmp(pExprCopyTail->pStr, "setkey", pExprCopyTail->iStrLen) ) {
                // 遍历参数
                for( pExprInfoTmp=pExprCopyTail->before
                   ; pExprInfoTmp && pExprInfoTmp->iLevel == pExprInfoTmp->next->iLevel
                   ; pExprInfoTmp=pExprInfoTmp->before )
                {
// // if( pExprInfoTmp->iStrLen != TYPE_POINTER )
// printStrForDebug("     Parm333", pExprInfoTmp->pStr, pExprInfoTmp->iStrLen);  // debug
    
                    // 第1个链表就是 Key-Value
                    struct stExprRet4KeyValue * pExprRet4KeyValueTmp = (struct stExprRet4KeyValue *)(pstExprRetHead->pExprRetList);  // Key-Value
                    for( ; pExprRet4KeyValueTmp; pExprRet4KeyValueTmp=pExprRet4KeyValueTmp->next )
                    {
                        if( pExprInfoTmp->iStrLen != pExprRet4KeyValueTmp->iKeyLen
                         || strncmp(pExprRet4KeyValueTmp->pKey, pExprInfoTmp->pStr, pExprRet4KeyValueTmp->iKeyLen) )
                            continue ;
    
                        pExprRet4KeyValueTmp->pCompileInfo = pOneCompileInfo;
                    }
    
                    // 遍历Key为空，需要新建一个Key-Value
                    if( ! pExprRet4KeyValueTmp )
                    {
                        struct stExprRet4KeyValue * pExprRet4KeyValueNew = (struct stExprRet4KeyValue *)getStringNode();
                        memset(pExprRet4KeyValueNew, 0x00, sizeof(struct stExprRet4KeyValue));
                        pExprRet4KeyValueNew->pKey = pExprInfoTmp->pStr;
                        pExprRet4KeyValueNew->iKeyLen = pExprInfoTmp->iStrLen;
                        pExprRet4KeyValueNew->pCompileInfo = pOneCompileInfo;
    
                        pExprRet4KeyValueNew->next = (struct stExprRet4KeyValue *)(pstExprRetHead->pExprRetList);
                        pstExprRetHead->pExprRetList = pExprRet4KeyValueNew;
                    }
    
                    // 保留最后一个节点指针，方便后续回收
                    if( ! pExprInfoTmp->before )
                        break ;
    
                } // for( pExprInfoTmp=pExprCopyTail->before; pExprInfoTmp; pExprInfoTmp=pExprInfoTmp->before )
/*********************************************************************
struct stExprRet4KeyValue * pExprRet4KeyValueTmp = (struct stExprRet4KeyValue *)(pstExprRetHead->pExprRetList);  // Key-Value
for( ; pExprRet4KeyValueTmp; pExprRet4KeyValueTmp=pExprRet4KeyValueTmp->next )
{
    printStrForDebug("KKKKKKKKey", pExprRet4KeyValueTmp->pKey, pExprRet4KeyValueTmp->iKeyLen);
    printf("VVVVVValue pCompileInfo = %p\n", pExprRet4KeyValueTmp->pCompileInfo);
    printf("VVVVVValue pCompileInfo->pFork = %p\n", pExprRet4KeyValueTmp->pCompileInfo->pFork);
    printStrForDebug("VVVVVValue pCompileInfo->pVal3", pExprRet4KeyValueTmp->pCompileInfo->pVal3, pExprRet4KeyValueTmp->pCompileInfo->iValLen3);
    printf("--------------------------------\n");
}
/*********************************************************************/
    
                // 执行完函数
                // 回收参数节点
                if( pExprInfoTmp->iLevel != pExprInfoTmp->next->iLevel ) {
                    pExprCopyTail->before->next = NULL;
                    freeExprInfoList(& (pExprInfoTmp->next) );
                    pExprInfoTmp->next = pExprCopyTail;
                    pExprCopyTail->before = pExprInfoTmp;
// // if( pExprInfoTmp->iStrLen != TYPE_POINTER )
// printStrForDebug("     Parm333 new", pExprInfoTmp->pStr, pExprInfoTmp->iStrLen);  // debug
                } else {
                    pExprCopyTail->before->next = NULL;
                    pExprCopyTail->before = NULL;
                    freeExprInfoList(& pExprInfoTmp);
                }
    
                // 返回值，若无，直接清理节点，而不是给空值
                if( pExprCopyTail->before ) {
                    // 理论上，有 ->before，肯定有->next->next
                    pExprCopyTail = pExprCopyTail->before;
                    pExprCopyTail->next = pExprCopyTail->next->next;
                    freeExprInfoNode(&(pExprCopyTail->next->before));
                    pExprCopyTail->next->before = pExprCopyTail;
                } else if( pExprCopyTail->next ) {
                    pExprCopyTail = pExprCopyTail->next;
                    freeExprInfoNode(&(pExprCopyTail->before));
                    pExprCopyTail->before = NULL;
                } else {
                    freeExprInfoNode(& pExprCopyTail );
                    break ;   // while( pExprCopyTail->cType )
                }

            } else if( pExprCopyTail->iStrLen == 6 && ! strncmp(pExprCopyTail->pStr, "getkey", pExprCopyTail->iStrLen) ) {

                // 参数只能有一个
                pExprInfoTmp = pExprCopyTail->before;
// printStrForDebug("     Parm444", pExprInfoTmp->pStr, pExprInfoTmp->iStrLen);  // debug
                if( pExprInfoTmp->before && pExprInfoTmp->before->iLevel == pExprInfoTmp->iLevel )
                {
                    *(pExprCopyTail->pStr + pExprCopyTail->iStrLen) = '\0';
                    printf("!!! Syntax file ERROR !!!\n|1| Line %d : \"%s\"<<<\n|2| Too many parameters for function '%s' !\n", pExprHead->iLevel, pExprCopyTail->pStr, pExprCopyTail->pStr);
                    return false;
                }

// printStrForDebug("pCompileInfo->pVal3", pCompileInfo->pVal3, pCompileInfo->iValLen3);  // debug
                struct stExprRet4KeyValue * pExprRet4KeyValue = (struct stExprRet4KeyValue *)(pstExprRetHead->pExprRetList);   //  Key-Value
                for( ; pExprRet4KeyValue; pExprRet4KeyValue=pExprRet4KeyValue->next )
                {
// printStrForDebug("pExprRet4KeyValue->pKey", pExprRet4KeyValue->pKey, pExprRet4KeyValue->iKeyLen);  // debug

                    if( pExprRet4KeyValue->iKeyLen == pExprInfoTmp->iStrLen
                     && ! strncmp(pExprRet4KeyValue->pKey, pExprInfoTmp->pStr, pExprInfoTmp->iStrLen) )
                        break ;
                }

                // 执行完函数
                // 回收参数节点
                if( pExprInfoTmp->before )
                    pExprInfoTmp = pExprInfoTmp->before;

                if( pExprInfoTmp->iLevel != pExprInfoTmp->next->iLevel ) {
                    pExprCopyTail->before->next = NULL;
                    freeExprInfoNode(& (pExprInfoTmp->next) );
                    pExprInfoTmp->next = pExprCopyTail;
                    pExprCopyTail->before = pExprInfoTmp;
                } else {
                    pExprCopyTail->before->next = NULL;
                    pExprCopyTail->before = NULL;
                    freeExprInfoNode(& pExprInfoTmp);
                }

                // 若找到值
                if( pExprRet4KeyValue ) {
// printf("!!!!!! getkey pCompileInfo = %p\n", pExprRet4KeyValue->pCompileInfo);
// printStrForDebug("!!!!!! getkey pCompileInfo->pVal3", pExprRet4KeyValue->pCompileInfo->pVal3, pExprRet4KeyValue->pCompileInfo->iValLen3);  // debug
// printf("!!!!!! getkey pCompileInfo->pFork = %p\n", pExprRet4KeyValue->pCompileInfo->pFork);

                    // 若是最后一个节点，返回
                    if( pExprCopyTail->next == NULL ) {
                        freeExprInfoNode(& pExprCopyTail);
                        break ;    // while( pExprCopyTail->cType )
                    } else {
                        // 值放入运算节点
                        pExprCopyTail->cType = 'P';
                        pExprCopyTail->iLevel -- ;
                        pExprCopyTail->pStr = (char *)(pExprRet4KeyValue->pCompileInfo);
                        pExprCopyTail->iStrLen = TYPE_POINTER;
                    }
                // 若 get 不到值
                } else {
                    // 若是最后一个节点，返回
                    if( pExprCopyTail->next == NULL ) {
                        freeExprInfoNode(& pExprCopyTail);
                        break ;    // while( pExprCopyTail->cType )
                    } else {
                        // 值放入运算节点
                        pExprCopyTail->cType = 'P';
                        pExprCopyTail->iLevel -- ;
                        pExprCopyTail->pStr = NULL;
                        pExprCopyTail->iStrLen = 0;
                    }
                }
            } else {
                *(pExprCopyTail->pStr + pExprCopyTail->iStrLen) = '\0';
                printf("!!! Syntax file ERROR !!!\n|1| Line %d : \"%s\"<<<\n|2| Bad function '%s' here !\n", pExprHead->iLevel, pExprCopyTail->pStr, pExprCopyTail->pStr);
                return false;
            }
        } // while( pExprCopyTail->cType )
    } // while( pExprCopyTail )

    return true;
}

// 处理当前一排路径解析结果的表达式处理，不涉及下钻！！！
bool CZGLanguage::runAttrExpr4OnePathCplInfo(struct stCompileInfo * pCompileInfo)
{
// printf("runAttrExpr4OnePathCplInfo !!!!!!!!!!!!!!!!\n");

    struct stCompileInfo * pCompileInfoTmp = pCompileInfo;

    struct stExprInfo * pExprInfoTmp = NULL;
    for( ; pCompileInfoTmp; pCompileInfoTmp=pCompileInfoTmp->next )
    {
        if( ! pCompileInfoTmp->pAttrExpr )
            continue ;

/********************************************************/
if( IF_PRINT )
{
printStrForDebug("\nCompileInfo value", pCompileInfoTmp->pVal3, pCompileInfoTmp->iValLen3);
printf("CompileInfo cTreeLevelType : %d\n", pCompileInfoTmp->mType[IDX_TREE_LEVEL_TYPE]);
printf("CompileInfo pFork: %p\n", pCompileInfoTmp->pFork);
if( pCompileInfoTmp->pComments_PassCode )
    printStrForDebug("Comment", pCompileInfoTmp->pComments_PassCode->pStr, pCompileInfoTmp->pComments_PassCode->iStrLen);

pExprInfoTmp = pCompileInfoTmp->pAttrExpr;
for( ; pExprInfoTmp; pExprInfoTmp=pExprInfoTmp->next )
{
    if( ! pExprInfoTmp->cType ) {
        printStrForDebug("Attr Expr", pExprInfoTmp->pStr, pExprInfoTmp->iStrLen);
        printf("     line  : %d\n", pExprInfoTmp->iLevel);
    } else {
        printStrForDebug("     Value", pExprInfoTmp->pStr, pExprInfoTmp->iStrLen);
        printf("     Level : %d\n", pExprInfoTmp->iLevel);
        printf("     Type  : %c\n", pExprInfoTmp->cType);
        printf("---------------------------------\n");
    }
}
printf("\n");
}
/********************************************************/

        //////////////////////////////////////////
        // 开始解析执行表达式链表

        if( ! runAttrExpr(pCompileInfoTmp) )
            return false;

    } // for( ; pCompileInfoTmp; pCompileInfoTmp=pCompileInfoTmp->next )

    return true;
}

bool CZGLanguage::runValueExpr(struct stExprInfo * pValExpr, struct stCompileInfo * pCompileInfo)
{
// printf("runValueExpr !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");

    // 清空返回值
    memset(&mRet4runValueExpr, 0x00, sizeof(struct stString));

    // 拷贝一份表达式解析链表，用于解析消耗 
    struct stExprInfo * pExprHead = (struct stExprInfo *)getStringNode();
    struct stExprInfo * pExprCopyTail = pExprHead;
    memcpy(pExprHead, pValExpr, sizeof(struct stExprInfo));

    struct stExprInfo * pExprInfoTmp = pValExpr->next;
    for( ; pExprInfoTmp; pExprInfoTmp=pExprInfoTmp->next )
    {    
        pExprCopyTail->next = (struct stExprInfo *)getStringNode();
        memcpy(pExprCopyTail->next, pExprInfoTmp, sizeof(struct stExprInfo));
        pExprCopyTail->next->before = pExprCopyTail;
        pExprCopyTail = pExprCopyTail->next;
        pExprCopyTail->next = NULL;
    }

    // 处理一套函数，理论上ValueExpr只有一套函数
    while( pExprCopyTail )
    {
        // 分离头节点
        pExprCopyTail = pExprHead->next;
        pExprHead->next = NULL;
        pExprCopyTail->before = NULL;
    
// printStrForDebug("Value Expr", pExprHead->pStr, pExprHead->iStrLen);
// printf("     line  : %d\n", pExprHead->iLevel);
    
        // 处理一层函数
        while( pExprCopyTail->cType )
        {
            // 查找函数名
            for( ; pExprCopyTail->cType != 'F'; pExprCopyTail=pExprCopyTail->next );
// printStrForDebug("     Value function", pExprCopyTail->pStr, pExprCopyTail->iStrLen);
    
            // 函数是否缺参数
            if( ! pExprCopyTail->before )
            {
                *(pExprCopyTail->pStr + pExprCopyTail->iStrLen) = '\0';
                printf("!!! Syntax file ERROR !!!\n|1| Line %d : \"%s\"<<<\n|2| Miss parameter for function '%s' !\n", pExprHead->iLevel, pExprCopyTail->pStr, pExprCopyTail->pStr);
                return false;
            }
    
            // 执行具体函数功能
            /***********************************************************************************
            结果结构：
            stExprRetHead -> stExprRet4KeyValue -> stExprRet4KeyValue -> ....
                  |
            stExprRetHead -> stExprRet4List(pHead,pTail) -> stExprRet4List -> stExprRet4List -> ....
                  |
            stExprRetHead -> stExprRet4List(pHead,pTail) -> stExprRet4List -> stExprRet4List -> ....
                  |
            ...............................................................
                  |
            stExprRetHead -> NULL
            ***********************************************************************************/

            if( (pExprCopyTail->iStrLen == 7 && ! strncmp(pExprCopyTail->pStr, "gethead", pExprCopyTail->iStrLen))
             || (pExprCopyTail->iStrLen == 7 && ! strncmp(pExprCopyTail->pStr, "gettail", pExprCopyTail->iStrLen)) ) {
    
                // 参数只能有一个
                pExprInfoTmp = pExprCopyTail->before;
                // if( pExprInfoTmp->before )
                if( pExprInfoTmp->before && pExprInfoTmp->before->iLevel == pExprInfoTmp->iLevel )
                {
                    *(pExprCopyTail->pStr + pExprCopyTail->iStrLen) = '\0';
                    printf("!!! Syntax file ERROR !!!\n|1| Line %d : \"%s\"<<<\n|2| Too many parameters for function '%s' !\n", pExprHead->iLevel, pExprCopyTail->pStr, pExprCopyTail->pStr);
                    return false;
                }

                char * pListName = NULL;
                unsigned int iListNameLen = 0;

                if( *(pExprInfoTmp->pStr) == '?' ) {
                    pListName = pCompileInfo->pVal3;
                    iListNameLen = pCompileInfo->iValLen3;
                } else {
                    pListName = pExprInfoTmp->pStr;
                    iListNameLen = pExprInfoTmp->iStrLen;
                }
// printStrForDebug("     ParmAAA", pListName, iListNameLen);  // debug
    
                // 按名称查找列表
                struct stExprRetHead * pExprRetHeadTmp = pstExprRetHead->next;  // pass Key-Value
                for( ; pExprRetHeadTmp->next ; pExprRetHeadTmp=pExprRetHeadTmp->next ) {
                    if( pExprRetHeadTmp->iNameLen == iListNameLen /*pExprInfoTmp->iStrLen*/
                     && ! strncmp(pExprRetHeadTmp->pName, pListName/*pExprInfoTmp->pStr*/, iListNameLen/*pExprInfoTmp->iStrLen*/) )
                         break ;
                }

                // 执行完函数
                // 回收参数节点
                if( pExprInfoTmp->before )
                    pExprInfoTmp = pExprInfoTmp->before;

                if( pExprInfoTmp->iLevel != pExprInfoTmp->next->iLevel ) {
                    pExprCopyTail->before->next = NULL;
                    freeExprInfoNode(& (pExprInfoTmp->next) );
                    pExprInfoTmp->next = pExprCopyTail;
                    pExprCopyTail->before = pExprInfoTmp;
// printStrForDebug("     Parm222 new", pExprInfoTmp->pStr, pExprInfoTmp->iStrLen);  // debug
                } else {
                    pExprCopyTail->before->next = NULL;
                    pExprCopyTail->before = NULL;
                    freeExprInfoNode(& pExprInfoTmp);
                }

                // 若找到列表
                if( pExprRetHeadTmp->next && pExprRetHeadTmp->pExprRetList ) 
                {
/********************************************************
                    // 执行完函数
                    // 回收参数节点
                    if( pExprInfoTmp->iLevel != pExprInfoTmp->next->iLevel ) {
                        pExprCopyTail->before->next = NULL;
                        freeExprInfoNode(& (pExprInfoTmp->next) );
                        pExprInfoTmp->next = pExprCopyTail;
                        pExprCopyTail->before = pExprInfoTmp;
printStrForDebug("     Parm222 new", pExprInfoTmp->pStr, pExprInfoTmp->iStrLen);  // debug
                    } else {
                        pExprCopyTail->before->next = NULL;
                        pExprCopyTail->before = NULL;
                        freeExprInfoNode(& pExprInfoTmp);
                    }
********************************************************/
    
                    ///////////////////////////////////////
                    // 返回值处理
                    // get得值
                    struct stExprRet4List * pOneExprRet = NULL;

                    // gethead() or Only one node
                    if( *(pExprCopyTail->pStr + 3) == 'h' || ((struct stExprRet4List *)(pExprRetHeadTmp->pExprRetList))->next == NULL ) {
                        pOneExprRet = (struct stExprRet4List *)(pExprRetHeadTmp->pExprRetList);
                        pExprRetHeadTmp->pExprRetList = ((struct stExprRet4List *)(pExprRetHeadTmp->pExprRetList))->next;

                    // gettail()
                    } else {
                        struct stExprRet4List * pOneExprRetTmp = (struct stExprRet4List *)(pExprRetHeadTmp->pExprRetList);
                        pOneExprRet = pOneExprRetTmp->pTail;

                        for( ; pOneExprRetTmp->next != pOneExprRet; pOneExprRetTmp=pOneExprRetTmp->next );
                        pOneExprRetTmp->next = NULL;
                        ((struct stExprRet4List *)(pExprRetHeadTmp->pExprRetList))->pTail = pOneExprRetTmp;
                    }
    
                    // 值放入运算节点
                    pExprCopyTail->cType = 'P';
                    pExprCopyTail->iLevel -- ;
                    if( pOneExprRet->pCompileInfo->pFork ) {
// printf("pOneExprRet pFork : %p\n", pOneExprRet->pCompileInfo);  // debug
                        pExprCopyTail->pStr = (char *)(pOneExprRet->pCompileInfo);
                        pExprCopyTail->iStrLen = TYPE_POINTER;
                    } else {
// printStrForDebug("pOneExprRet value", pOneExprRet->pCompileInfo->pVal3, pOneExprRet->pCompileInfo->iValLen3);  // debug
                        pExprCopyTail->pStr = pOneExprRet->pCompileInfo->pVal3;
                        pExprCopyTail->iStrLen = pOneExprRet->pCompileInfo->iValLen3;
                    }
    
                    // 若是最后一个节点，返回
                    if( pExprCopyTail->next == NULL )
                    {
                        if( pExprCopyTail->iStrLen == TYPE_POINTER ) {
                            mRet4runValueExpr.cFlag = 'P';
                            mRet4runValueExpr.pp = pExprCopyTail->pStr;
                        } else {
                            mRet4runValueExpr.cFlag = 'S';
                            mRet4runValueExpr.pStr = pExprCopyTail->pStr;
                            mRet4runValueExpr.iStrLen = pExprCopyTail->iStrLen;
                        }

                        freeExprInfoNode(& pExprCopyTail );
                        return true;
                    }
                } 
                // 若 没 找到列表  20240107
                else
                {
// printf("???????????????? kkkkkkkkk = %d\n", pExprCopyTail->iStrLen);
                       // 若是最后一个节点，返回
                    if( pExprCopyTail->next == NULL ) {
                        mRet4runValueExpr.cFlag = 'S';
                        freeExprInfoNode(& pExprCopyTail);

                        return true;
                    } else {
                        // 值放入运算节点
                        pExprCopyTail->cType = 'P';
                        pExprCopyTail->iLevel -- ;
                        pExprCopyTail->pStr = NULL;
                        pExprCopyTail->iStrLen = 0;
                    }
                }

            } else if( pExprCopyTail->iStrLen == 6 && ! strncmp(pExprCopyTail->pStr, "getkey", pExprCopyTail->iStrLen) ) {

                // 参数只能有一个
                pExprInfoTmp = pExprCopyTail->before;
// printStrForDebug("     ParmBBB", pExprInfoTmp->pStr, pExprInfoTmp->iStrLen);  // debug
                if( pExprInfoTmp->before && pExprInfoTmp->before->iLevel == pExprInfoTmp->iLevel )
                {
                    *(pExprCopyTail->pStr + pExprCopyTail->iStrLen) = '\0';
                    printf("!!! Syntax file ERROR !!!\n|1| Line %d : \"%s\"<<<\n|2| Too many parameters for function '%s' !\n", pExprHead->iLevel, pExprCopyTail->pStr, pExprCopyTail->pStr);
                    return false;
                }

// printStrForDebug("pCompileInfo->pVal3", pCompileInfo->pVal3, pCompileInfo->iValLen3);  // debug
                struct stExprRet4KeyValue * pExprRet4KeyValue = (struct stExprRet4KeyValue *)(pstExprRetHead->pExprRetList);   //  Key-Value
                for( ; pExprRet4KeyValue; pExprRet4KeyValue=pExprRet4KeyValue->next )
                {
// printStrForDebug("pExprRet4KeyValue->pKey", pExprRet4KeyValue->pKey, pExprRet4KeyValue->iKeyLen);  // debug

                    if( pExprRet4KeyValue->iKeyLen == pExprInfoTmp->iStrLen
                     // && cmpStr(pExprRet4KeyValue->pKey, pExprInfoTmp->pStr, pExprInfoTmp->iStrLen) )
                     && ! strncmp(pExprRet4KeyValue->pKey, pExprInfoTmp->pStr, pExprInfoTmp->iStrLen) )
                        break ;

                    // 若是变量
                    if( *(pExprInfoTmp->pStr) == '?'
                     && pExprRet4KeyValue->iKeyLen == pCompileInfo->iValLen3
                     && cmpStr(pExprRet4KeyValue->pKey, pCompileInfo->pVal3, pCompileInfo->iValLen3) )  // 这里字符串比较，要考虑到大小写
                        break ;
                }

                // 执行完函数
                // 回收参数节点
                if( pExprInfoTmp->before )
                    pExprInfoTmp = pExprInfoTmp->before;

                if( pExprInfoTmp->iLevel != pExprInfoTmp->next->iLevel ) {
                    pExprCopyTail->before->next = NULL;
                    freeExprInfoNode(& (pExprInfoTmp->next) );
                    pExprInfoTmp->next = pExprCopyTail;
                    pExprCopyTail->before = pExprInfoTmp;
                } else {
                    pExprCopyTail->before->next = NULL;
                    pExprCopyTail->before = NULL;
                    freeExprInfoNode(& pExprInfoTmp);
                }

                // 若找到值
                if( pExprRet4KeyValue ) {
// printf("!!!!!! getkey pCompileInfo = %p\n", pExprRet4KeyValue->pCompileInfo);
// printStrForDebug("!!!!!! getkey pCompileInfo->pVal3", pExprRet4KeyValue->pCompileInfo->pVal3, pExprRet4KeyValue->pCompileInfo->iValLen3);  // debug
// printf("!!!!!! getkey pCompileInfo->pFork = %p\n", pExprRet4KeyValue->pCompileInfo->pFork);

                    // 若是最后一个节点，返回
                    if( pExprCopyTail->next == NULL ) {
                        mRet4runValueExpr.pp = pExprRet4KeyValue->pCompileInfo;
                        mRet4runValueExpr.cFlag = 'P';
                        freeExprInfoNode(& pExprCopyTail);

                        return true;
                    } else {
                        // 值放入运算节点
                        pExprCopyTail->cType = 'P';
                        pExprCopyTail->iLevel -- ;
                        pExprCopyTail->pStr = (char *)(pExprRet4KeyValue->pCompileInfo);
                        pExprCopyTail->iStrLen = TYPE_POINTER;
                    }
                // 若 get 不到值
                } else {
                    // 若是最后一个节点，返回
                    if( pExprCopyTail->next == NULL ) {
                        mRet4runValueExpr.cFlag = 'S';
                        freeExprInfoNode(& pExprCopyTail);

                        return true;                              
                    } else {
                        // 值放入运算节点
                        pExprCopyTail->cType = 'P';
                        pExprCopyTail->iLevel -- ;
                        pExprCopyTail->pStr = NULL;
                        pExprCopyTail->iStrLen = 0;
                    }
                }

            } else if( pExprCopyTail->iStrLen == 2 && ! strncmp(pExprCopyTail->pStr, "if", pExprCopyTail->iStrLen) ) {
/***********************************************************
pExprInfoTmp = pExprCopyTail->before;
for( ; pExprInfoTmp; pExprInfoTmp=pExprInfoTmp->before )
{
    printf("     ParmCCC->iLevel = %d\n", pExprInfoTmp->iLevel);  // debug

    if( pExprInfoTmp->iStrLen != TYPE_POINTER )
        printStrForDebug("     ParmCCC->pStr", pExprInfoTmp->pStr, pExprInfoTmp->iStrLen);  // debug
    else
        printf("     ParmCCC->pStr: %p\n", pExprInfoTmp->pStr);  // debug

    printf("------------------------------------\n");
}
***********************************************************/

                // 第 1 个参数，bool参数
                pExprInfoTmp = pExprCopyTail->before;
                if( ! pExprInfoTmp || pExprInfoTmp->iLevel != pExprInfoTmp->next->iLevel )
                {
                    *(pExprCopyTail->pStr + pExprCopyTail->iStrLen) = '\0';
                    printf("!!! Syntax file ERROR !!!\n|1| Line %d : \"%s\"<<<\n|2| Miss 3 parameters for function 'if' !\n", pExprHead->iLevel, pExprCopyTail->pStr);
                    return false;
                }

                // 第 2 个参数，真 值返回值
                pExprInfoTmp = pExprInfoTmp->before;
                if( ! pExprInfoTmp || pExprInfoTmp->iLevel != pExprInfoTmp->next->iLevel )
                {
                    *(pExprCopyTail->pStr + pExprCopyTail->iStrLen) = '\0';
                    printf("!!! Syntax file ERROR !!!\n|1| Line %d : \"%s\"<<<\n|2| Miss 2 parameters for function 'if' !\n", pExprHead->iLevel, pExprCopyTail->pStr);
                    return false;
                }

                // 第 3 个参数，假 值返回值
                pExprInfoTmp = pExprInfoTmp->before;
                if( ! pExprInfoTmp || pExprInfoTmp->iLevel != pExprInfoTmp->next->iLevel )
                {
                    *(pExprCopyTail->pStr + pExprCopyTail->iStrLen) = '\0';
                    printf("!!! Syntax file ERROR !!!\n|1| Line %d : \"%s\"<<<\n|2| Miss 1 parameters for function 'if' !\n", pExprHead->iLevel, pExprCopyTail->pStr);
                    return false;
                }

                // 第 4 个参数，报错
                if( pExprInfoTmp->before && pExprInfoTmp->before->iLevel == pExprInfoTmp->iLevel )
                {
                    *(pExprCopyTail->pStr + pExprCopyTail->iStrLen) = '\0';
                    printf("!!! Syntax file ERROR !!!\n|1| Line %d : \"%s\"<<<\n|2| Too many parameters for function 'if' !\n", pExprHead->iLevel, pExprCopyTail->pStr);
                    return false;
                }

                // 值放入运算节点
                pExprCopyTail->cType = 'P';
                pExprCopyTail->iLevel -- ;
                // 以 pExprInfoTmp->next->next->iStrLen 作为bool参数，判断真假
// printf("pExprInfoTmp->next->next->iStrLen = %d\n", pExprInfoTmp->next->next->iStrLen);  // debug
                // 若为真，返回第2个参数
                if( pExprInfoTmp->next->next->iStrLen ) {
                    pExprCopyTail->pStr = pExprInfoTmp->next->pStr;
                    pExprCopyTail->iStrLen = pExprInfoTmp->next->iStrLen;
                // 若为假，返回第3个参数
                } else {
                    pExprCopyTail->pStr = pExprInfoTmp->pStr;
                    pExprCopyTail->iStrLen = pExprInfoTmp->iStrLen;
                }

                // 执行完函数
                // 回收参数节点
                if( pExprInfoTmp->before ) {
                    pExprInfoTmp = pExprInfoTmp->before;

                    pExprCopyTail->before->next = NULL;
                    freeExprInfoList(& (pExprInfoTmp->next) );
                    pExprInfoTmp->next = pExprCopyTail;
                    pExprCopyTail->before = pExprInfoTmp;
                } else {
                    pExprCopyTail->before->next = NULL;
                    pExprCopyTail->before = NULL;
                    freeExprInfoList(& pExprInfoTmp);
                }

                // 若是最后一个节点，返回
                if( pExprCopyTail->next == NULL )
                {
                    if( pExprCopyTail->iStrLen == TYPE_POINTER ) {
                        mRet4runValueExpr.cFlag = 'P';
                        mRet4runValueExpr.pp = pExprCopyTail->pStr;
                    } else {
                        mRet4runValueExpr.cFlag = 'S';
                        mRet4runValueExpr.pStr = pExprCopyTail->pStr;
                        mRet4runValueExpr.iStrLen = pExprCopyTail->iStrLen;
                    }

                    freeExprInfoNode(& pExprCopyTail);
                    return true;
                }

            } else if( pExprCopyTail->iStrLen == 6 && ! strncmp(pExprCopyTail->pStr, "ifnull", pExprCopyTail->iStrLen) ) {
// printf("ifnull !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");

                // 遍历参数
                for( pExprInfoTmp=pExprCopyTail->before
                   ; pExprInfoTmp && pExprInfoTmp->iLevel == pExprInfoTmp->next->iLevel
                   ; pExprInfoTmp=pExprInfoTmp->before )
                {
/***************************************
if( pExprInfoTmp->iStrLen != TYPE_POINTER )
printStrForDebug("     ParmDDD->pStr", pExprInfoTmp->pStr, pExprInfoTmp->iStrLen);  // debug
else
printf("     ParmDDD->pStr : %p\n", pExprInfoTmp->pStr);  // debug
***************************************/

                    // 遇到不为空，返回
                    if( pExprInfoTmp->pStr )
                        break ;

                    // 保留最后一个节点指针，方便后续回收
                    if( ! pExprInfoTmp->before )
                        break ;
                }

                // 值放入运算节点
                pExprCopyTail->cType = 'P';
                pExprCopyTail->iLevel -- ;
                if( *(pExprInfoTmp->pStr) == '?' ) {
                    pExprCopyTail->pStr = pCompileInfo->pVal3;
                    pExprCopyTail->iStrLen = pCompileInfo->iValLen3;
                } else {
                    pExprCopyTail->pStr = pExprInfoTmp->pStr;
                    pExprCopyTail->iStrLen = pExprInfoTmp->iStrLen;
                }

                // 执行完函数
                // 回收参数节点
                for( ; pExprInfoTmp && pExprInfoTmp->before && pExprInfoTmp->iLevel == pExprInfoTmp->next->iLevel
                     ; pExprInfoTmp=pExprInfoTmp->before );

                if( pExprInfoTmp->before ) {
                    pExprInfoTmp = pExprInfoTmp->before;

                    pExprCopyTail->before->next = NULL;
                    freeExprInfoList(& (pExprInfoTmp->next) );
                    pExprInfoTmp->next = pExprCopyTail;
                    pExprCopyTail->before = pExprInfoTmp;
                } else {
                    pExprCopyTail->before->next = NULL;
                    pExprCopyTail->before = NULL;
                    freeExprInfoList(& pExprInfoTmp);
                }

                // 若是最后一个节点，返回
                if( pExprCopyTail->next == NULL )
                {
                    if( pExprCopyTail->iStrLen == TYPE_POINTER ) {
                        mRet4runValueExpr.cFlag = 'P';
                        mRet4runValueExpr.pp = pExprCopyTail->pStr;
                    } else {
                        mRet4runValueExpr.cFlag = 'S';
                        mRet4runValueExpr.pStr = pExprCopyTail->pStr;
                        mRet4runValueExpr.iStrLen = pExprCopyTail->iStrLen;
                    }

                    freeExprInfoNode(& pExprCopyTail);
                    return true;
                }

            } else {
                *(pExprCopyTail->pStr + pExprCopyTail->iStrLen) = '\0';
                printf("!!! Syntax file ERROR !!!\n|1| Line %d : \"%s\"<<<\n|2| Bad function '%s' here !\n", pExprHead->iLevel, pExprCopyTail->pStr, pExprCopyTail->pStr);
                return false;
            }
        } // while( pExprCopyTail->cType )
    } // while( pExprCopyTail )

    return true;
}

bool CZGLanguage::go2CompileInfoTree4Tran(struct stCompileInfo * pOneFork)
{
// printf("go2CompileInfoTree4Tran !!!!!!!!!!!!! [%c] [%p]\n", pOneFork->mType[IDX_OBJ], pstExprRetHead);

// printf("pOneFork->next = %p\n", pOneFork->next);

    struct stCompileInfo * pCompileInfoTmp = pOneFork->next;
    unsigned int iTreePath = pOneFork->next->iValLen1;

// printStrForDebug("Tree name", pCompileInfoTmp->pObjName, pCompileInfoTmp->iObjNameLen); // debug
// printf("Tree path : [%d]\n", pCompileInfoTmp->iValLen1); // debug

    ////////////////////////////////////////////////
    // 处理当前一排路径解析结果的表达式处理，不涉及下钻！！！
    if( ! runAttrExpr4OnePathCplInfo(pCompileInfoTmp) )
        return false;

    ////////////////////////////////////////////////
    // Find the tran path
    struct stPath *pTheTranPathList = NULL;

    struct stPathHead * pPathHeadTmp = pstPathHeadList;
    for( ; pPathHeadTmp; pPathHeadTmp=pPathHeadTmp->next )
    {
        if( pCompileInfoTmp->iValLen1 == pPathHeadTmp->iPathY
         && pCompileInfoTmp->iObjNameLen == pPathHeadTmp->pTree->iNameLen
         && ! strncmp(pPathHeadTmp->pTree->pName, pCompileInfoTmp->pObjName, pCompileInfoTmp->iObjNameLen) )
        {
            pTheTranPathList = pPathHeadTmp->pTranPathList;

            if( pPathHeadTmp->pTranPathList )
            {
                //////////////////////////////////////
                // Copy pPathHeadTmp->pTranPathList
                //////////////////////////////////////

                pTheTranPathList = getPathNode();
                memcpy(pTheTranPathList, pPathHeadTmp->pTranPathList, sizeof(struct stPath));
                struct stPath * pTheTranPathListTail = pTheTranPathList;
            
                for( struct stPath * pPathTmp=pPathHeadTmp->pTranPathList->nextNode
                   ; pPathTmp
                   ; pPathTmp=pPathTmp->nextNode )
                {
                    pTheTranPathListTail->nextNode = getPathNode();
                    pTheTranPathListTail = pTheTranPathListTail->nextNode;
                    memcpy(pTheTranPathListTail, pPathTmp, sizeof(struct stPath));
                }
            }

            break ;
        }
    }

    struct stTree *pTreeTmp = pstTreeList;
    for( ; pTreeTmp; pTreeTmp=pTreeTmp->next )
    {
// printStrForDebug("Tree name", pTreeTmp->pName, pTreeTmp->iNameLen);
// printf("iPathMaxX : %d\n", pTreeTmp->iPathMaxX);  // debug

        if( pTreeTmp->iNameLen == pCompileInfoTmp->iObjNameLen
         && ! strncmp(pTreeTmp->pName, pCompileInfoTmp->pObjName, pCompileInfoTmp->iObjNameLen) )
        {
            break ;
        }
    }

    // 如果 树 有转换逻辑
    if( pOneFork->mType[IDX_OBJ] == 'P' && pTheTranPathList ) 
    {
if(IF_PRINT) printf("run here aaa\n");

        struct stPath * pTranPathTmp = pTheTranPathList;

        // 转换部分，不需要考虑 + 分行情况
        for( ; pTranPathTmp; pTranPathTmp=pTranPathTmp->nextNode )
        {
/**************************
printf("Tran Path node : [%c]\n", *(pTranPathTmp->pOneTreeTranLevel->pPathY + iTreePath-1));
printStrForDebug("Tran Other name", pTranPathTmp->pOneTreeTranLevel->pOtherName, pTranPathTmp->pOneTreeTranLevel->iOtherNameLen);
printStrForDebug("Tran key word", pTranPathTmp->pOneTreeTranLevel->pKeyword, pTranPathTmp->pOneTreeTranLevel->iKeywordLen);
/***************************/

            ///////////////////////////////////////////////////////
            // 获得与当前Other name为+(或)相关的其他other name 
            // 用于空值占位
            ///////////////////////////////////////////////////////

            // 并行段路径头节点
            struct stTreeCplLevel * pTreeCplLevel4MP = NULL;
            // 并行段路径跳过头节点，目标节点在此次短路径
            struct stTreeCplLevel * pTreeCplLevel4MP4Skip = NULL;
            // 并行节点头节点
            struct stTreeCplLevel * pTreeCplLevel4SplitFlag = NULL;

            struct stTreeCplLevel * pTreeCplLevelTmp = pTreeTmp->pstTreeCplLevels;
            for( ; pTreeCplLevelTmp; pTreeCplLevelTmp=pTreeCplLevelTmp->next )
            {
                // Try to get pTreeCplLevel4MP
                char cPathY = *(pTreeCplLevelTmp->pPathY + iTreePath - 1);
// printf("cPathY cPathY cPathY ====== [%c]\n", cPathY);
                if( cPathY == 'M' || cPathY == 'P' ) {
                    pTreeCplLevel4MP4Skip = pTreeCplLevelTmp;
                    if( pTreeCplLevel4MP ) {
                         if( *(pTreeCplLevel4MP->pPathY + iTreePath - 1) != cPathY )
                            pTreeCplLevel4MP = pTreeCplLevelTmp;
                    } else
                        pTreeCplLevel4MP = pTreeCplLevelTmp;

                // } else if( cPathY == '1' || cPathY == 'N' )  // 20230806
                } else if( cPathY == '1' || cPathY == 'N' || cPathY == 'e' || cPathY == 'E' )
                    pTreeCplLevel4MP = NULL;

                // Try to get pTreeCplLevel4SplitFlag
                if( pTreeCplLevelTmp->cSplitFlag != '+'  // | \ /
                 && pTreeCplLevelTmp->next && pTreeCplLevelTmp->next->cSplitFlag == '+' )
                {
                    pTreeCplLevel4SplitFlag = pTreeCplLevelTmp;
                }
                else if( pTreeCplLevelTmp->cSplitFlag != '+'  // | \ /
                      && (pTreeCplLevelTmp->next == NULL || pTreeCplLevelTmp->next->cSplitFlag != '+') )
                {
                    pTreeCplLevel4SplitFlag = NULL;
                }

                // if some other name
                if( pTreeCplLevelTmp->pOtherName
                 && pTreeCplLevelTmp->iOtherNameLen == pTranPathTmp->pOneTreeTranLevel->iOtherNameLen
                 && ! strncmp(pTreeCplLevelTmp->pOtherName, pTranPathTmp->pOneTreeTranLevel->pOtherName, pTranPathTmp->pOneTreeTranLevel->iOtherNameLen) )
                {
                    break ;
                }
                else if( pTranPathTmp->pOneTreeTranLevel->pOtherName == NULL
                      && pTreeCplLevelTmp->iOtherNameLen == pTranPathTmp->pOneTreeTranLevel->iOtherNameLen )
                {
                    break ;
                }
// printStrForDebug("Keyword", pTreeCplLevelTmp->pKeyword, pTreeCplLevelTmp->iKeywordLen);

            } // for( ; pTreeCplLevelTmp; pTreeCplLevelTmp=pTreeCplLevelTmp->next )

            ////////////////////////////////////////////////////
            // 下面将解析结果挂到转换节点
            ////////////////////////////////////////////////////

            // 为了同一个别名，向后添加节点
            struct stPath * pTranPathTail = pTranPathTmp;
// printf("pTranPathTmp->pOneTreeTranLevel->cOtherNameType = %c\n", pTranPathTmp->pOneTreeTranLevel->cOtherNameType);  //debug

            // 此参数为了优化循环次数
            unsigned int iCurrLoopCount4ShortPath = 0;
            for( pCompileInfoTmp=pOneFork->next; pCompileInfoTmp; pCompileInfoTmp=pCompileInfoTmp->next )
            {
// 打印 other name 映射关系
// printStrForDebug("\npTranPathTmp otherName", pTranPathTmp->pOneTreeTranLevel->pOtherName, pTranPathTmp->pOneTreeTranLevel->iOtherNameLen);  // debug
// printStrForDebug("pCompileInfoTmp otherName", pCompileInfoTmp->pVal2, pCompileInfoTmp->iValLen2); // debug
// printStrForDebug("pCompileInfoTmp value", pCompileInfoTmp->pVal3, pCompileInfoTmp->iValLen3); // debug

                // 简单优化减少循环次数
                if( iCurrLoopCount4ShortPath > pCompileInfoTmp->iLoopCount4ShortPath ) // 情况1：循环次数由大变小
                    break ;

                // 若 other name 一样
                if( pTranPathTmp->pOneTreeTranLevel->iOtherNameLen == pCompileInfoTmp->iValLen2
                 && (  (  pTranPathTmp->pOneTreeTranLevel->pOtherName && pCompileInfoTmp->pVal2
                       && ! strncmp(pTranPathTmp->pOneTreeTranLevel->pOtherName, pCompileInfoTmp->pVal2, pCompileInfoTmp->iValLen2)
                       )
                    || ( pTranPathTmp->pOneTreeTranLevel->pOtherName == NULL && pCompileInfoTmp->pVal2 == NULL )
                    )
                )
                {
                    // 使得 iCurrLoopCount4ShortPath > 0
                    iCurrLoopCount4ShortPath = pCompileInfoTmp->iLoopCount4ShortPath;
// printf("pTranPathTmp->pOneTreeCplLevel=[%p], pTranPathTmp->pOneTreeTranLevel=[%p], pTranPathTmp->next=[%p]\n", pTranPathTmp->pOneTreeCplLevel, pTranPathTmp->pOneTreeTranLevel, pTranPathTmp->next);  // debug

                    // 将解析结果挂到此节点上
                    pTranPathTail->next = getPathNode();
                    pTranPathTail = pTranPathTail->next;
                    memset(pTranPathTail, 0x00, sizeof(struct stPath));

                    // 若是表达式
                    if( pTranPathTmp->pOneTreeTranLevel->pValueExpr ) {
                        if( ! runValueExpr(pTranPathTmp->pOneTreeTranLevel->pValueExpr, pCompileInfoTmp) )
                            return false;

                        if( mRet4runValueExpr.cFlag == 'S' ) {
// printStrForDebug("mRet4runValueExpr pStr", mRet4runValueExpr.pStr, mRet4runValueExpr.iStrLen); // debug
                            // 返回值是个字符串，需要创建一个新的CompileInfo节点去接受这个值
                            struct stCompileInfo * pCompileInfoNew = getCompileInfoNode();
                            memset(pCompileInfoNew, 0x00, sizeof(struct stCompileInfo));
                            pCompileInfoNew->pVal3 = mRet4runValueExpr.pStr;
                            pCompileInfoNew->iValLen3 = mRet4runValueExpr.iStrLen;
                            pCompileInfoNew->pLineHead = pCompileInfoTmp->pLineHead;
                            pCompileInfoNew->iLineHeadKgf = pCompileInfoTmp->iLineHeadKgf;
                            pTranPathTail->pOneTreeCplLevel = (struct stTreeCplLevel *)pCompileInfoNew;
                        } else {
// printf("mRet4runValueExpr : cFlag=%c | pp = %p\n", mRet4runValueExpr.cFlag, mRet4runValueExpr.pp);  // debug
                            // 将 pCompileInfo 强转挂在 pOneTreeCplLevel 上
                            struct stCompileInfo * pCompileInfoNew = getCompileInfoNode();
                            memcpy(pCompileInfoNew, mRet4runValueExpr.pp, sizeof(struct stCompileInfo));
                            pCompileInfoNew->pLineHead = pCompileInfoTmp->pLineHead;
                            pCompileInfoNew->iLineHeadKgf = pCompileInfoTmp->iLineHeadKgf;
                            pTranPathTail->pOneTreeCplLevel = (struct stTreeCplLevel *)pCompileInfoNew;
                        }
                    } else {
                        // 将 pCompileInfoTmp 强转挂在 pOneTreeCplLevel 上
                        pTranPathTail->pOneTreeCplLevel = (struct stTreeCplLevel *)pCompileInfoTmp;
                    }
                }
                // 若 other name 不一样，需要检查是否为并行 + 节点
                // 如果是 并行 + 节点，需要添加占位节点
                else if( pTreeCplLevel4MP || pTreeCplLevel4SplitFlag )
                {
                    bool isFind = false;

                    if( pTreeCplLevel4MP )
                    {
                        char cPathMP = *(pTreeCplLevel4MP->pPathY + iTreePath - 1);   // M or P

                        struct stTreeCplLevel * pTreeCplLevel4MPtmp = pTreeCplLevel4MP;
                        for( ; ! isFind && pTreeCplLevel4MPtmp; pTreeCplLevel4MPtmp=pTreeCplLevel4MPtmp->next )
                        {
                            char cPathTmp = *(pTreeCplLevel4MPtmp->pPathY + iTreePath - 1);
                            if( cPathMP != cPathTmp )
                            {
                                // 优化
                                if( cPathTmp == 'M' || cPathTmp == 'P' || cPathTmp == '1' || cPathTmp == 'N' )
                                    break ;

                                continue ;
                            }

                            if( pTreeCplLevel4MPtmp == pTreeCplLevel4MP4Skip )
                                continue ;

                            while( true )
                            {
// printStrForDebug("pTreeCplLevel4MP", pTreeCplLevel4MPtmp->pOtherName, pTreeCplLevel4MPtmp->iOtherNameLen);  // debug

                                // 若 other name 一样
                                if( pTreeCplLevel4MPtmp->iOtherNameLen == pCompileInfoTmp->iValLen2
                                  && (  (  pTreeCplLevel4MPtmp->pOtherName && pCompileInfoTmp->pVal2
                                        && ! strncmp(pTreeCplLevel4MPtmp->pOtherName, pCompileInfoTmp->pVal2, pTreeCplLevel4MPtmp->iOtherNameLen )
                                        )
                                     || ( pTreeCplLevel4MPtmp->pOtherName == NULL && pCompileInfoTmp->pVal2 == NULL )
                                     )
                                )
                                {
// printf("Got pTreeCplLevel4MP !!!!!!!!!!!!!!!!!!!!\n"); // debug
                                    // 新增一个占位空节点
                                    pTranPathTail->next = getPathNode();
                                    pTranPathTail = pTranPathTail->next;
                                    memset(pTranPathTail, 0x00, sizeof(struct stPath));
                                    // pTranPathTail->pOneTreeCplLevel = (struct stTreeCplLevel *)pCompileInfoTmp;

                                    isFind = true;
                                    break ;
                                }

                                if( pTreeCplLevel4MPtmp->next && pTreeCplLevel4MPtmp->next->cSplitFlag == '+' )
                                    pTreeCplLevel4MPtmp = pTreeCplLevel4MPtmp->next;
                                else
                                    break ;

                            } // while( true )
                        } // for( ; ! isFind && pTreeCplLevel4MPtmp; pTreeCplLevel4MPtmp=pTreeCplLevel4MPtmp->next )
                    } // if( pTreeCplLevel4MP )

                    if( ! isFind && pTreeCplLevel4SplitFlag )
                    {
                        struct stTreeCplLevel * pTreeCplLevel4SplitFlagTmp = pTreeCplLevel4SplitFlag;

                        while( true )
                        {
// printStrForDebug("pTreeCplLevel4SplitFlagTmp", pTreeCplLevel4SplitFlagTmp->pOtherName, pTreeCplLevel4SplitFlagTmp->iOtherNameLen);  // debug

                            // 若 other name 一样    
                            if( pTreeCplLevel4SplitFlagTmp->iOtherNameLen == pCompileInfoTmp->iValLen2
                              && (  (  pTreeCplLevel4SplitFlagTmp->pOtherName && pCompileInfoTmp->pVal2
                                    && ! strncmp(pTreeCplLevel4SplitFlagTmp->pOtherName, pCompileInfoTmp->pVal2, pTreeCplLevel4SplitFlagTmp->iOtherNameLen )
                                    )
                                 || ( pTreeCplLevel4SplitFlagTmp->pOtherName == NULL && pCompileInfoTmp->pVal2 == NULL )
                                 )
                            )
                            {
// printf("Got pTreeCplLevel4SplitFlag !!!!!!!!!!!!!!!!!!!!\n"); // debug
                                // 新增一个占位空节点    
                                pTranPathTail->next = getPathNode();
                                pTranPathTail = pTranPathTail->next;
                                memset(pTranPathTail, 0x00, sizeof(struct stPath));
                                // pTranPathTail->pOneTreeCplLevel = (struct stTreeCplLevel *)pCompileInfoTmp;

                                isFind = true;
                                break ;
                            }

                            if( pTreeCplLevel4SplitFlagTmp->next && pTreeCplLevel4SplitFlagTmp->next->cSplitFlag == '+' )
                                pTreeCplLevel4SplitFlagTmp = pTreeCplLevel4SplitFlagTmp->next;
                            else
                                break ;

                        } // while( true )
                    } // if( ! isFind && pTreeCplLevel4SplitFlag )
                } // else if( pTreeCplLevel4MP || pTreeCplLevel4SplitFlag )
// printf("--------------------------------\n");
            } // for( ; pCompileInfoTmp; pCompileInfoTmp=pCompileInfoTmp->next )
// printf("==========================================\n");
        } // for(struct stPath * pTranPathTmp=pTheTranPathList; pTranPathTmp; pTranPathTmp=pTranPathTmp->nextNode )

        //////////////////////////////////////////////////////////////////

        // 以上已完成转换CompileInfo节点挂载
        // 开始转换内容
        pTranPathTmp = pTheTranPathList; 

        // 获得短路径头节点列表，为了处理可能的笛卡尔积情况
        struct stString * pTranShortPathHeadNodeList = getStringNode();
        memset(pTranShortPathHeadNodeList, 0x00, sizeof(struct stString));
        pTranShortPathHeadNodeList->pp = pTranPathTmp;
        pTranShortPathHeadNodeList->cFlag = *(pTranPathTmp->pOneTreeTranLevel->pPathY + iTreePath-1);
        pTranShortPathHeadNodeList->iNum = 1;   // 首节点标识，为后续下钻判断作为依据  20231210

        struct stString * pTranShortPathHeadNodeListTail = pTranShortPathHeadNodeList;

        while( pTranPathTmp )
        {
            // if( pTranPathTmp->nextNode && *(pTranPathTmp->nextNode->pOneTreeTranLevel->pPathY + iTreePath-1) != ' ' )
            if( pTranPathTmp->nextNode 
             && (  *(pTranPathTmp->nextNode->pOneTreeTranLevel->pPathY + iTreePath-1) != ' ' 
                && *(pTranPathTmp->nextNode->pOneTreeTranLevel->pPathY + iTreePath-1) != 'e' ) )
            {
                struct stPath *pNextNodeTmp = pTranPathTmp->nextNode;
                pTranPathTmp->nextNode = NULL;
                pTranPathTmp = pNextNodeTmp;

                pTranShortPathHeadNodeListTail->next = getStringNode();
                pTranShortPathHeadNodeListTail = pTranShortPathHeadNodeListTail->next;
                memset(pTranShortPathHeadNodeListTail, 0x00, sizeof(struct stString));
                pTranShortPathHeadNodeListTail->pp = pTranPathTmp;

                pTranShortPathHeadNodeListTail->cFlag = *(pNextNodeTmp->pOneTreeTranLevel->pPathY + iTreePath-1);
            }
            else
                pTranPathTmp = pTranPathTmp->nextNode;
        }

        for( pTranShortPathHeadNodeListTail=pTranShortPathHeadNodeList; pTranShortPathHeadNodeListTail; )
        {
            if( ! pTranShortPathHeadNodeListTail->next )
                break ;

            if( '*' != *(((struct stPath *)(pTranShortPathHeadNodeListTail->next->pp))->pOneTreeTranLevel->pPathY + iTreePath-1) )
            {
                pTranShortPathHeadNodeListTail = pTranShortPathHeadNodeListTail->next;
                continue ;
            }

            ///////////////////////////////////////////////////////
            // 处理笛卡尔积

            struct stPath * pOneTranShortPath_1 = NULL;
            struct stPath * pOneTranShortPath_2 = NULL;
            struct stString * pTranShortPathHeadNodeListTail4Next = pTranShortPathHeadNodeListTail->next;
            
            for( ; pTranShortPathHeadNodeListTail4Next 
                   && '*' == *(((struct stPath *)(pTranShortPathHeadNodeListTail4Next->pp))->pOneTreeTranLevel->pPathY + iTreePath-1)
               ; pTranShortPathHeadNodeListTail4Next=pTranShortPathHeadNodeListTail4Next->next )
            {
                unsigned int iDkeCount_1 = 0;
                unsigned int iDkeCount_2 = 0;

                pOneTranShortPath_1 = (struct stPath *)(pTranShortPathHeadNodeListTail->pp);
                for( pOneTranShortPath_1 = pOneTranShortPath_1->next  // 直接跳过第一个空节点
                   ; pOneTranShortPath_1
                   ; pOneTranShortPath_1 = pOneTranShortPath_1->next )
                {
                    iDkeCount_1 ++ ;
                }

                pOneTranShortPath_2 = (struct stPath *)(pTranShortPathHeadNodeListTail4Next->pp);
                for( pOneTranShortPath_2 = pOneTranShortPath_2->next  // 直接跳过第一个空节点
                   ; pOneTranShortPath_2
                   ; pOneTranShortPath_2 = pOneTranShortPath_2->next )
                {   
                    iDkeCount_2 ++ ;
                }

// printf("iDkeCount_1 = %d\n", iDkeCount_1);  // debug
// printf("iDkeCount_2 = %d\n", iDkeCount_2);  // debug

                for( pOneTranShortPath_1 = (struct stPath *)(pTranShortPathHeadNodeListTail->pp)
                   ; pOneTranShortPath_1
                   ; pOneTranShortPath_1 = pOneTranShortPath_1->nextNode )
                {
                    struct stPath * pOneTranShortPath_1_next = pOneTranShortPath_1->next;  // 直接跳过第一个空节点
                    for( ; pOneTranShortPath_1_next; pOneTranShortPath_1_next=pOneTranShortPath_1_next->next )
                    {
                        // 乘以笛卡尔倍数
                        for(int i = iDkeCount_2 - 1; i; i -- )
                        {
                            struct stPath * pPathNew = getPathNode();
                            memset(pPathNew, 0x00, sizeof(struct stPath));
                            pPathNew->pOneTreeCplLevel = pOneTranShortPath_1_next->pOneTreeCplLevel;

                            pPathNew->next = pOneTranShortPath_1_next->next;
                            pOneTranShortPath_1_next->next = pPathNew;
                            pOneTranShortPath_1_next = pPathNew;
                        }
                    } // for
                } // for

                for( pOneTranShortPath_2 = (struct stPath *)(pTranShortPathHeadNodeListTail4Next->pp)
                   ; pOneTranShortPath_2
                   ; pOneTranShortPath_2 = pOneTranShortPath_2->nextNode )
                {
                    struct stPath * pSrcPathList = pOneTranShortPath_2->next;  // 直接跳过第一个空节点

                    // 乘以笛卡尔倍数
                    for(int i = iDkeCount_1 - 1; i; i -- )
                    {
                        // First node
                        struct stPath * pPathListHead = getPathNode();
                        memset(pPathListHead, 0x00, sizeof(struct stPath));
                        pPathListHead->pOneTreeCplLevel = pSrcPathList->pOneTreeCplLevel;
                        struct stPath * pPathListTail = pPathListHead;

                        // Other nodes
                        struct stPath * pOneTranShortPath_2_next = pSrcPathList->next;
                        for( ; pOneTranShortPath_2_next; pOneTranShortPath_2_next=pOneTranShortPath_2_next->next )
                        {
                            pPathListTail->next = getPathNode();
                            pPathListTail = pPathListTail->next;
                            memset(pPathListTail, 0x00, sizeof(struct stPath));

                            pPathListTail->pOneTreeCplLevel = pOneTranShortPath_2_next->pOneTreeCplLevel;
                        }

                        pPathListTail->next = pOneTranShortPath_2->next;
                        pOneTranShortPath_2->next = pPathListHead;
                        
                    } // for
                } // for

                // 笛卡尔积后，两个模块合并
                for( pOneTranShortPath_1 = (struct stPath *)(pTranShortPathHeadNodeListTail->pp)
                   ; pOneTranShortPath_1->nextNode
                   ; pOneTranShortPath_1 = pOneTranShortPath_1->nextNode );

                pOneTranShortPath_1->nextNode = (struct stPath *)(pTranShortPathHeadNodeListTail4Next->pp);

            } // for

            pTranShortPathHeadNodeListTail->next = pTranShortPathHeadNodeListTail4Next;

        } // for( pTranShortPathHeadNodeListTail=pTranShortPathHeadNodeList; pTranShortPathHeadNodeListTail; )

        ////////////////////////////////////////////////
        // 依次处理每段短路径的最后占位符
        // 算法是根据每段短路径的最大挂载深度
        char cN_1 = '\0';
        unsigned int iNodeMax = 0;  // 每一条转换短路径的最大挂载深度
        struct stPath * pOneTranShortPathHeadNode4Next = NULL;
        for( pTranShortPathHeadNodeListTail = pTranShortPathHeadNodeList
           ; pTranShortPathHeadNodeListTail
           ; pTranShortPathHeadNodeListTail = pTranShortPathHeadNodeListTail->next )
        {
            iNodeMax = 0;

            // 获得此短路径的最大挂载深度
            struct stPath * pOneTranShortPathHeadNode = (struct stPath *)(pTranShortPathHeadNodeListTail->pp);
            for( ; pOneTranShortPathHeadNode; pOneTranShortPathHeadNode=pOneTranShortPathHeadNode->nextNode )
            {
                struct stPath * pOneTranShortPathHeadNode4Next = pOneTranShortPathHeadNode;
                unsigned int iNodeCount = 0;
                for( ; pOneTranShortPathHeadNode4Next->next; pOneTranShortPathHeadNode4Next = pOneTranShortPathHeadNode4Next->next )
                    iNodeCount ++ ;

                if( iNodeCount > iNodeMax )
                    iNodeMax = iNodeCount;
            }

// printf("iNodeMax = %d\n", iNodeMax);   // debug

            // 根据上面获得的最大挂载深度判断是否需要填充占位空节点
            pOneTranShortPathHeadNode = (struct stPath *)(pTranShortPathHeadNodeListTail->pp);
            for( ; pOneTranShortPathHeadNode; pOneTranShortPathHeadNode=pOneTranShortPathHeadNode->nextNode )
            {
// printf("111111111111 pOneTranShortPathHeadNode  : [%c]\n", *(pOneTranShortPathHeadNode->pOneTreeTranLevel->pPathY + iTreePath-1));

                if( *(pOneTranShortPathHeadNode->pOneTreeTranLevel->pPathY + iTreePath-1) == '1'
                 || *(pOneTranShortPathHeadNode->pOneTreeTranLevel->pPathY + iTreePath-1) == 'N' )
                {
                    cN_1 = *(pOneTranShortPathHeadNode->pOneTreeTranLevel->pPathY + iTreePath-1);
                }
// printf("222222222222 cN_1 = [%c]\n", cN_1);

                // 走到最后一个节点
                unsigned int iNodeThis = 0;
                pOneTranShortPathHeadNode4Next = pOneTranShortPathHeadNode;
                for( ; pOneTranShortPathHeadNode4Next->next; pOneTranShortPathHeadNode4Next=pOneTranShortPathHeadNode4Next->next)
                {
                    iNodeThis ++ ;

                    // 若 N 对 1，只保留第一个映射节点
                    if( cN_1 == '1' && iNodeThis > 1 )
                        pOneTranShortPathHeadNode4Next->next->pOneTreeCplLevel = NULL;
                }
// printf("iNodeMax : iNodeThis = [%d : %d]\n", iNodeMax, iNodeThis);

                // 若此节点最大挂载深度，小于此短路径最大挂载深度，需要补充占位空节点
                if( iNodeThis < iNodeMax )
                {
/****************************************
                    for(int i=iNodeMax-iNodeThis; i; i -- )
                    {
                        pOneTranShortPathHeadNode4Next->next = getPathNode();
                        memcpy(pOneTranShortPathHeadNode4Next->next, pOneTranShortPathHeadNode4Next, sizeof(struct stPath));
                        pOneTranShortPathHeadNode4Next = pOneTranShortPathHeadNode4Next->next;
                        pOneTranShortPathHeadNode4Next->pOneTreeCplLevel = NULL;
                        pOneTranShortPathHeadNode4Next->next = NULL;
                    }
****************************************/
                    for(int i=iNodeMax-iNodeThis; i; i -- )
                    {
                        pOneTranShortPathHeadNode4Next->next = getPathNode();
                        memcpy(pOneTranShortPathHeadNode4Next->next, pOneTranShortPathHeadNode4Next, sizeof(struct stPath));

                        // 20240304 当某个other name对应的节点数只有1时，后面的节点都填充为此唯一节点的内容，而不是填充为空
                        // other name 对应的节点数不为1，后面默认填充为空，后续是否可以加个属性配置来填充空值内容？？？
                        if( iNodeThis == 1 && cN_1 == 'N' )
                            pOneTranShortPathHeadNode4Next->next->pOneTreeCplLevel = pOneTranShortPathHeadNode4Next->pOneTreeCplLevel;
                        else
                            pOneTranShortPathHeadNode4Next->next->pOneTreeCplLevel = NULL;

                        pOneTranShortPathHeadNode4Next = pOneTranShortPathHeadNode4Next->next;
                        // pOneTranShortPathHeadNode4Next->pOneTreeCplLevel = NULL;
                        pOneTranShortPathHeadNode4Next->next = NULL;
                    }

                } // if
            } // for
        } // for

        ///////////////////////////////////
        // 处理 e 最后节点
        for( pTranShortPathHeadNodeListTail = pTranShortPathHeadNodeList
           ; pTranShortPathHeadNodeListTail
           ; pTranShortPathHeadNodeListTail = pTranShortPathHeadNodeListTail->next )
        {
            struct stPath * pOneTranShortPathHeadNode = (struct stPath *)(pTranShortPathHeadNodeListTail->pp);
            for( ; pOneTranShortPathHeadNode; pOneTranShortPathHeadNode=pOneTranShortPathHeadNode->nextNode )
            {
// printf("pTranShortPathHeadNodeList : [%c]\n", *(pOneTranShortPathHeadNode->pOneTreeTranLevel->pPathY + iTreePath-1));

                if( *(pOneTranShortPathHeadNode->pOneTreeTranLevel->pPathY + iTreePath-1) != 'e' )
                    continue ;

                // 到最后一个节点
                for( pOneTranShortPathHeadNode4Next = pOneTranShortPathHeadNode
                   ; pOneTranShortPathHeadNode4Next->next
                   ; pOneTranShortPathHeadNode4Next=pOneTranShortPathHeadNode4Next->next );

                // 若最后一个Cpl节点非空，将其置成空，使得其后续不会被转换
                if( pOneTranShortPathHeadNode4Next->pOneTreeCplLevel )
                {
                    pOneTranShortPathHeadNode4Next->pOneTreeCplLevel = NULL;
                }
            }
        }

/********************************************/
// debug
if( IF_PRINT )
{
for( pTranShortPathHeadNodeListTail = pTranShortPathHeadNodeList
   ; pTranShortPathHeadNodeListTail
   ; pTranShortPathHeadNodeListTail = pTranShortPathHeadNodeListTail->next )
{
    struct stPath * pOneTranShortPathHeadNode = (struct stPath *)(pTranShortPathHeadNodeListTail->pp);
// printf("??? pOneTranShortPathHeadNode->next = %p\n", pOneTranShortPathHeadNode->next);

    for( ; pOneTranShortPathHeadNode; pOneTranShortPathHeadNode=pOneTranShortPathHeadNode->nextNode )
    {
        printf("pTranShortPathHeadNodeList : [%c]\n", *(pOneTranShortPathHeadNode->pOneTreeTranLevel->pPathY + iTreePath-1));
        printStrForDebug("    pTranShortPathHeadNodeList other name", pOneTranShortPathHeadNode->pOneTreeTranLevel->pOtherName, pOneTranShortPathHeadNode->pOneTreeTranLevel->iOtherNameLen);
        printStrForDebug("    pTranShortPathHeadNodeList value", pOneTranShortPathHeadNode->pOneTreeTranLevel->pKeyword, pOneTranShortPathHeadNode->pOneTreeTranLevel->iKeywordLen);
        printf("    pTranShortPathHeadNodeList cSplitFlag = [%c]\n", pOneTranShortPathHeadNode->pOneTreeTranLevel->cSplitFlag);

        struct stPath * pOneTranShortPathHeadNode4Next = pOneTranShortPathHeadNode->next;
        for( ; pOneTranShortPathHeadNode4Next; pOneTranShortPathHeadNode4Next=pOneTranShortPathHeadNode4Next->next )
        {
            if( pOneTranShortPathHeadNode4Next->pOneTreeCplLevel ) {
                struct stCompileInfo * pOneCompileInfo = (struct stCompileInfo *)(pOneTranShortPathHeadNode4Next->pOneTreeCplLevel);
                printStrForDebug("    Cpl value", pOneCompileInfo->pVal3, pOneCompileInfo->iValLen3);
                printf("    Cpl cTreeLevelType : %d\n", pOneCompileInfo->mType[IDX_TREE_LEVEL_TYPE]);
                if( pOneCompileInfo->pComments_PassCode )
                    printStrForDebug("    Comment", pOneCompileInfo->pComments_PassCode->pStr, pOneCompileInfo->pComments_PassCode->iStrLen);
            } else {
                printf("    Cpl value : []\n");
            }
        }
        
        if( pOneTranShortPathHeadNode->pOneTreeTranLevel->pValueExpr )
        {
            printStrForDebug("    Tran expr", pOneTranShortPathHeadNode->pOneTreeTranLevel->pValueExpr->pStr, pOneTranShortPathHeadNode->pOneTreeTranLevel->pValueExpr->iStrLen);
        }
    }
    printf("\n");
}
}
/********************************************/

        if( ! writeTreeTranResult(pTranShortPathHeadNodeList) )
            return false;

        freeStringList( & pTranShortPathHeadNodeList);
    }
    // 行 对象转换
    else if( pOneFork->mType[IDX_OBJ] == 'E' )
    {
if(IF_PRINT) printf("run here bbb\n");
// printf("Tran Line !!!!!!!!!!!!!!!! [%c][%c]\n", cRunType, cSplitFlag4Tran4BfGoDown);  // debug
// printf("pOneCompileInfo->iLineNum = %d | iLineNumBf4Tran = %d\n", pOneFork->iLineNum, iLineNumBf4Tran);  // debug

        if( cSplitFlag4Tran4BfGoDown == '|' )
        {
            writeCommentAtLineEnd(pOneFork->next);

            // 缩进敏感
            if( cIndentType == INDENT_TRANSLATOR || cIndentType == INDENT_COMPILER_TRANSLATOR ) {
                writeCommentAtLineStart(pOneFork->next, pstIndentList4TranList->pStr, pstIndentList4TranList->iStrLen, NULL, 0);

                // 行 下钻，不需要自适应

                // 缓存处理
                doWithMem4WriteTranResult(1);

                // 分行
                *pResultTail = '\n';
                pResultTail ++ ;

                // 缩进
                memcpy(pResultTail, pstIndentList4TranList->pStr, pstIndentList4TranList->iStrLen);
                pResultTail += pstIndentList4TranList->iStrLen;
            } else if( pOneFork->iLineNum != iLineNumBf4Tran ) {
                writeCommentAtLineStart(pOneFork->next, pOneFork->pLineHead, pOneFork->iLineHeadKgf, NULL, 0);

                // 缓存处理
                doWithMem4WriteTranResult(1 + pOneFork->iLineHeadKgf);

                // 分行
                *pResultTail = '\n';
                pResultTail ++ ;

                // 缩进
                memcpy(pResultTail, pOneFork->pLineHead, pOneFork->iLineHeadKgf);
                pResultTail += pOneFork->iLineHeadKgf;

                iLineNumBf4Tran = pOneFork->iLineNum;
            } else {
                // 缓存处理     
                doWithMem4WriteTranResult(1);

                // 分行
                *pResultTail = ' ';
                pResultTail ++ ;
            }
        }
        else if( cSplitFlag4Tran4BfGoDown == '/' )
        {
            // 缓存处理
            doWithMem4WriteTranResult(1);

            // 分行
            *pResultTail = ' ';
            pResultTail ++ ;
        }
        *pResultTail = '\0';

        cSplitFlag4Tran4BfGoDown = '\0';

        // 若此行第一次运算
        if( pOneFork->next->mType[IDX_LEFT_PARM] != '?' )
        {
            for( ; pCompileInfoTmp; pCompileInfoTmp=pCompileInfoTmp->next )
            {
// printf("222 pCompileInfoTmp->mType[IDX_LEFT_PARM] == %c, pFork = %p, pTranPartList4Line = %p\n", pCompileInfoTmp->mType[IDX_LEFT_PARM], pCompileInfoTmp->pFork, pCompileInfoTmp->pTranPartList4Line);

                doWithCompileInfo4Line4CT(pCompileInfoTmp, 0);
            }

            ///////////////////////////////////////////////////
            // 行运算是消耗节点的运算，只能使用一次
            // 保存此次结果，挂在 pFork 上，以备下次再用
            pOneFork->next->pFork= (struct stCompileInfo *)(pstTranResult4OneLine->pp);

            //////////////////////////////////////////
            // 将行转换结果写入
            writeLineTranResult( (struct stString *)(pstTranResult4OneLine->pp) );
        }
        // 若此行之前运算过，直接从之前的结果读取
        else // if( pOneFork->next->mType[IDX_LEFT_PARM] == '?' )
        {
            writeLineTranResult( (struct stString *)(pOneFork->next->pFork) );
        }
    }
    // 树 对象如果没有转换逻辑，直接按解析结果输出
    else  // if( pOneFork->mType[IDX_OBJ] == 'P' && pTheTranPathList == NULL ) 
    {
if(IF_PRINT) printf("run here ccc\n");
// printf("!!!!!!!!!!!!!! pOneFork->mType[IDX_OBJ] == %c && pTheTranPathList == %p\n", pOneFork->mType[IDX_OBJ], pTheTranPathList);  // debug

        while( pCompileInfoTmp )
        {
// printf("while( pCompileInfoTmp ) !!!!!!!!!!!!!!!!!!!\n");

            if( pCompileInfoTmp->iLineNum != iLineNumBf4Tran
             && (pCompileInfoTmp->pVal3 || pCompileInfoTmp->pFork) )
            {
if(IF_PRINT) printf("run here ddd [%d][%d]\n", iLineNumBf4Tran, pCompileInfoTmp->iLineNum);

                writeCommentAtLineEnd(pCompileInfoTmp);
                writeCommentAtLineStart(pCompileInfoTmp, pCompileInfoTmp->pLineHead, pCompileInfoTmp->iLineHeadKgf, NULL, 0);

                // 缓存处理
                doWithMem4WriteTranResult(1 + pCompileInfoTmp->iLineHeadKgf);

                // 分行 
                *pResultTail = '\n'; 
                pResultTail ++ ; 

                // 缩进
                memcpy(pResultTail, pCompileInfoTmp->pLineHead, pCompileInfoTmp->iLineHeadKgf);
                pResultTail += pCompileInfoTmp->iLineHeadKgf;

                iLineNumBf4Tran = pCompileInfoTmp->iLineNum;
				
if(IF_PRINT) printf("<<<<<------------------------\n%s\n------------------------>>>>>>\n", pResultList->pStr);
            }
            *pResultTail = '\0';

            if( pCompileInfoTmp->pFork )
            {
if(IF_PRINT) printf("run here eee\n");

                /////////////////////////////////////////////
                // 下钻
                if( *(pResultTail-1) == ' ' || *(pResultTail-1) == '\t' || *(pResultTail-1) == '\n' )
                    cSplitFlag4Tran4BfGoDown = '\\';
                else 
                    cSplitFlag4Tran4BfGoDown = '/';

                if( ! go2CompileInfoTree4Tran(pCompileInfoTmp->pFork) )
                    return false;

                pCompileInfoTmp = pCompileInfoTmp->next;

                continue ;
            }
// printf("cSplitFlag4Tran4BfGoDown : [%c]\n", cSplitFlag4Tran4BfGoDown); // debug
// printStrForDebug("pCompileInfoTmp->pVal3", pCompileInfoTmp->pVal3, pCompileInfoTmp->iValLen3);  // debug

            /////////////////////////////////////////////////////
            // 非下钻部分，集中处理，获得其原始值
            // 将后续几个非下钻节点的，源文本内容，直接拷贝
            /////////////////////////////////////////////////////
if(IF_PRINT) printf("run here fff\n");
            // Skip 节点 pCompileInfoTmp->pVal3 值为空，需要跳过
            if( ! pCompileInfoTmp->pVal3 )
            {
                pCompileInfoTmp = pCompileInfoTmp->next;
                continue ;
            }

            char * pTextStart = pCompileInfoTmp->pVal3;
            char * pTextEnd = pCompileInfoTmp->pVal3 + pCompileInfoTmp->iValLen3;
// printf("111 pResultTail=%p, pTextStart=%p, pTextEnd=%p, iTextSrcLen=%d\n");  // debug

            for( pCompileInfoTmp=pCompileInfoTmp->next; pCompileInfoTmp; pCompileInfoTmp=pCompileInfoTmp->next )
            {
// printStrForDebug("pCompileInfoTmp->pVal3", pCompileInfoTmp->pVal3, pCompileInfoTmp->iValLen3);  // debug

                if( pCompileInfoTmp->pFork )
                    break ;

                // 非 Skip 节点
                if( pCompileInfoTmp->pVal3 )
                    pTextEnd = pCompileInfoTmp->pVal3 + pCompileInfoTmp->iValLen3;
				
// printf("iLineNumBf4Tran=[%d] pCompileInfoTmp->iLineNum=[%d]\n", iLineNumBf4Tran, pCompileInfoTmp->iLineNum);

                iLineNumBf4Tran = pCompileInfoTmp->iLineNum;  // 20260227
            }
// printf("222 pResultTail=%p, pTextStart=%p, pTextEnd=%p, iTextSrcLen=%d\n");  // debug
// printStrForDebug("No tran text", pTextStart, pTextEnd - pTextStart);  // debug
// for(char *pTmp=pTextStart; pTmp <= pTextEnd; pTmp ++ )
// {
// printf("[%c][%d]\n", *pTmp, *pTmp);
// }

            // 是否加空格
            if( cSplitFlag4Tran4BfGoDown != '\\'   // 20260227
			 && *(pResultTail-1) != ' ' && *(pResultTail-1) != '\t' 
             && pTextStart > pCplMmp // 边界检查
             && ( *(pTextStart-1) == ' ' || *(pTextStart-1) == '\t' ) )
            {
                doWithMem4WriteTranResult(1);
                *pResultTail = *(pTextStart-1);
                pResultTail ++ ;
            }
			
			cSplitFlag4Tran4BfGoDown = '\0';   // 20260227
// printf("333 pResultTail=%p, pTextStart=%p, pTextEnd=%p, iTextSrcLen=%d\n");  // debug

            unsigned int iTextSrcLen = pTextEnd - pTextStart;

            // 缓存处理
            doWithMem4WriteTranResult(iTextSrcLen);
// printf("pResultTail=%p, pTextStart=%p, pTextEnd=%p, iTextSrcLen=%d\n");  // debug
// printStrForDebug("pTextStart", pTextStart, iTextSrcLen);  // debug
            memcpy(pResultTail, pTextStart, iTextSrcLen);
            pResultTail += iTextSrcLen;

            *pResultTail = '\0';
			
if(IF_PRINT) printf("<<<<<------------------------\n%s\n------------------------>>>>>>\n", pResultList->pStr);

        } // while( pCompileInfoTmp )
    } // if( pOneFork->mType[IDX_OBJ] == 'P' && pTheTranPathList )

    return true;
}

bool CZGLanguage::outputCompileInfo()
{
    // 初始化结果内存链表
    struct stString * pResultHead = getStringNode();
    pResultList = pResultHead;

    memset(pResultList, 0x00, sizeof(struct stString));
    pResultList->pStr = (char *)malloc(RES_NODE_SIZE);
    pResultList->iStrLen = RES_NODE_SIZE;
    pResultTail = pResultList->pStr;
    *pResultTail = '\0';

    /////////////////////////////////////////////

    // 分析结果链表需要倒过来
    struct stCompileInfo * pHeadTmp = pstCompileInfoHead->next;
    pstCompileInfoHead->next = NULL;
    while( pHeadTmp )
    {
        struct stCompileInfo * pFreeHeadTmp = pHeadTmp;
        pHeadTmp = pHeadTmp->next;

        pFreeHeadTmp->next = pstCompileInfoHead->next;
        pstCompileInfoHead->next = pFreeHeadTmp;
    }

    /////////////////////////////////////

    // 输出结果集
    pHeadTmp = pstCompileInfoHead->next;
    if( cRunType == 'C' )
    {
        for( ; pHeadTmp ; pHeadTmp=pHeadTmp->next )
        {
            unsigned int iSeqForkFirst = iSeq + 1;
            unsigned int iObjId4TreeEnd = iObjId + 1;

            if( pHeadTmp->pFork->next->pFork )
            {
                iSeq ++ ;

                writeResultList4Tree (
                  iSeq
                , pHeadTmp->pFork->next->pFork->next->mType[IDX_OBJ]  // char cObjType
                , pHeadTmp->pFork->next->pFork->next->iLineNum
                , pHeadTmp->pFork->next->pFork->next->pLineHead
                , pHeadTmp->pFork->next->pFork->next->iLineHeadKgf
                , iObjId4TreeEnd
                , pHeadTmp->pFork->pObjName                    // Tree name
                , pHeadTmp->pFork->iObjNameLen                 // Tree name length
                , pHeadTmp->pFork->next->iValLen1              // unsigned int iPathY
                , pHeadTmp->pFork->next->pVal2                 // char * pOtherName
                , pHeadTmp->pFork->next->iValLen2              // unsigned int iOtherNameLen
                , pHeadTmp->pFork->next->pFork->pObjName       // char * pValue
                , pHeadTmp->pFork->next->pFork->iObjNameLen    // unsigned int iValueLen
                );
            }

            go2CompileInfoTree4Cpl(pHeadTmp->pFork);

            //////////////////////////////////////////////////

            iSeq ++ ;

            writeLastResult4Tree (
              iSeq                          // unsigned int iSeq
            , iObjId4TreeEnd                // unsigned int iObjId4This
            , pHeadTmp->pFork->pObjName     // char * pObjName
            , pHeadTmp->pFork->iObjNameLen  // unsigned int iObjNameLen
            , iSeqForkFirst                 // unsigned int iFirstLineNum4Tree
            );
        }
    }
    else if( cRunType == 'T' )
    {
        for( ; pHeadTmp; pHeadTmp=pHeadTmp->next )
        {
            // 是否为空内容
            if( ! pHeadTmp->pFork->next )
                break ;

            if( ! go2CompileInfoTree4Tran(pHeadTmp->pFork) )
                return false;
        }

// printf("Result :::::::::::::::::::::::::::::::::::::\n %s", pResultList->pStr);
        fputs(pResultList->pStr, pfOpf);
    }
    else if( cRunType == 'R' )
    {
        for( ; pHeadTmp; pHeadTmp=pHeadTmp->next )
        {
            // 是否为空内容
            if( ! pHeadTmp->pFork->next )
                break ;

            if( pHeadTmp->pComments_PassCode )
            {
                writePassCode(pHeadTmp->pComments_PassCode->pStr, pHeadTmp->pComments_PassCode->iStrLen);
                iLineNumBf4Tran = pHeadTmp->pFork->next->iLineNum;
            }

            if( ! go2CompileInfoTree4Tran(pHeadTmp->pFork) )
                return false;
        }

        if( pText4FuzzyStart != pText4FuzzyEnd )
            writePassCode(pText4FuzzyStart, pText4FuzzyEnd-pText4FuzzyStart);

// printf("Result :::::::::::::::::::::::::::::::::::::\n %s", pResultList->pStr);
        fputs(pResultList->pStr, pfOpf);
    }
    else // if( cRunType == 'F' )
    {
        // pass
    }

    return true;
}

int main(int argc, char **argv)
{
    if( argc < 2 )
    {
        cout << "Miss parameter !" << endl;
        return -1;
    }

    char * pSynFile = NULL;
    char * pCodeFile = NULL;
    char * pOutputFile = NULL;

    char cRunType = 'C';  // C : Compiler, T : Translator

    for(int i=1; i < argc; i ++ )
    {
        // 指定 运行模式 : Compiler
        if( ! strcmp(argv[i], "-C") || ! strcmp(argv[i], "-c") )
        {
            cRunType = 'C';
        }
        // 指定 运行模式 : Translator
        else if( ! strcmp(argv[i], "-T") || ! strcmp(argv[i], "-t") )
        {
            cRunType = 'T';
        }
        // 指定 运行模式 : Replace
        else if( ! strcmp(argv[i], "-R") || ! strcmp(argv[i], "-r") )
        {
            cRunType = 'R';
        }
        // 指定 运行模式 : Find
        else if( ! strcmp(argv[i], "-F") || ! strcmp(argv[i], "-f") )
        {
            cRunType = 'F';
        }
        // 指定 语法文件
        else if( ! strcmp(argv[i], "-E") || ! strcmp(argv[i], "-e") )
        {
            i ++ ;
            if( i >= argc )
            {
                cout << "Miss parameter for '-E/-e' !" << endl;
                return -1;
            }
            pSynFile = argv[i];
        }
        // 指定 输出文件
        else if( ! strcmp(argv[i], "-O") || ! strcmp(argv[i], "-o") )
        {
            i ++ ;
            if( i >= argc )
            {
                cout << "Miss parameter for '-O/-o' !" << endl;
                return -1;
            }
            pOutputFile = argv[i];
        }
        // help info
        else if( ! strcmp(argv[i], "-H") || ! strcmp(argv[i], "-h") )
        {
            cout << "-E : Syntax file' !" << endl;
            cout << "-e : Syntax file' !" << endl;

            cout << "-O : output file' !" << endl;
            cout << "-o : output file' !" << endl;

            cout << "-H : help' !" << endl;
            cout << "-h : help' !" << endl;
        }
        // 被解析代码文件
        else
            pCodeFile = argv[i];
    }

    if( ! pCodeFile )
    {
        cout << "Miss code file !" << endl;
        return -1;
    }

    //////////////////////////////////////

    if( cRunType == 'C' )
        printf("Run type : Compiler\n");
    else if( cRunType == 'T' )
        printf("Run type : Translator\n");
    else if( cRunType == 'R' )
        printf("Run type : Replace\n");
    else if( cRunType == 'F' )
        printf("Run type : Find\n");

    if( ! pSynFile )
        pSynFile = "ZGL.syn";
    printf("Syntax file : %s\n", pSynFile);

    printf("code file : %s\n", pCodeFile);

    if( ! pOutputFile )
        pOutputFile = "out.zgl";
    printf("Output file : %s\n", pOutputFile);

    //////////////////////////////////////

    CZGLanguage *obj = new CZGLanguage();

// obj->askKxjs();
// return 0;
    

    obj->initStart();

    if( obj->readSynFile(pSynFile) )
        obj->compileCodeFile(cRunType, pCodeFile, pOutputFile);

    obj->initEnd();

    delete obj;

    return 0;

}

