pvaltree.c

基于h323协议的软phone

    /* Print the line we parsed */
    ptr[0] = '\n';
    ptr[1] = '\0';
    vt->pFunc(vt->pFuncParam, string);

    return param;
}


#if (RV_LOGMASK_COMPILEMASK & RV_LOGLEVEL_DEBUG)
/************************************************************************
 * vtRootPrint
 * purpose: Callback function used to print a single root for debugging
 *          purposes only
 * input  : rtH     - RTree handle used
 *          nodeId  - Node to print
 *          param   - vtStruct of the node
 * output : none
 * return : vtStruct of the node (i.e. - param)
 ************************************************************************/
static void* vtRootPrint(IN HRTREE rtH, IN int nodeId, IN void* param)
{
    vtStruct*   vt = (vtStruct *)param;

    if (vt->printOnlyRoots)
        return vtNodePrint(rtH, nodeId, 0, param);
    else
    {
        rtPrint(vt->vTree, nodeId, 0, -1, param, vt->pFuncParam);
        return param;
    }
}
#endif




/************************************************************************
 * vtSearchPath
 * purpose: Searches for a specified path, value or both in a specified tree
 *          This function is called by pvtSearchPath. It does less sanity
 *          checks and has no locking mechanisms in it
 * input  : vtDest      - PVT handle of the search tree
 *          rootNodeId  - Root ID of the search tree
 *          vtSrc       - PVT handle of path to be searched in
 *          srcNodeId   - Node ID of the beginning of the path to be searched in
 *          checkLeaves - If RV_TRUE, Compare the values in the lowest level nodes (leaves)
 *                        Use RV_FALSE if the tree syntax contains choices.
 * output : none
 * return : RV_TRUE if found, RV_FALSE if not
 *          Negative value on failure
 ************************************************************************/
static int
vtSearchPath(
    IN  vtStruct*   vtDest,
    IN  RvPvtNodeId rootNodeId,
    IN  vtStruct*   vtSrc,
    IN  RvPvtNodeId srcNodeId,
    IN  RvBool      checkLeaves)
{
    vtNode *vtNodeDest, *vtNodeSrc;
    RvPvtNodeId destCur, srcCur;
    RvPstNodeId destSynNodeId, srcSynNodeId;
    HPST hSyn;
    /*  RvPstFieldId destFieldId, srcFieldId;
    char *destString, *srcString;
    = pvtGetSynTree(destH, rootNodeId); */

    /*vtPrint(destH, rootNodeId, ErrVt); */
    vtNodeDest = GET_NODE(vtDest, rootNodeId);
    vtNodeSrc  = GET_NODE(vtSrc,  srcNodeId);
    hSyn       = vtNodeDest->hSyn;

    /*  vtGet(srcH, srcNodeId, &srcFieldId, &srcSynNodeId, &srcValue, &srcString);
    vtGet(destH, rootNodeId, &destFieldId, &destSynNodeId, &destValue, &destString);
    */
    destSynNodeId = VTN_SYN_NODE(vtNodeDest);
    srcSynNodeId  = VTN_SYN_NODE(vtNodeSrc);

    if (!pstAreNodesCongruent(
        hSyn,             destSynNodeId,
        vtNodeSrc->hSyn,  srcSynNodeId))
    {
        return RV_ERROR_UNKNOWN;
    }

    for (destCur = rootNodeId, srcCur = srcNodeId;
         destCur >=0 && srcCur >=0; )
    {
        destSynNodeId = VTN_SYN_NODE(vtNodeDest);
        srcSynNodeId  = VTN_SYN_NODE(vtNodeSrc);

        if (destSynNodeId != srcSynNodeId)
        {
            RvLogError(&vtSrc->log,
                (&vtSrc->log, "vtSearchPath: %s Different synNodeId [%d <> %d].",
                     getSafeFieldName(vtNodeSrc), destSynNodeId, srcSynNodeId));
            return RV_FALSE;
        }

        switch (pstGetNodeType(vtNodeDest->hSyn, destSynNodeId))
        {
            case pstSet:
            case pstSequence:  /* investigate all children */
                if (pvtNumChilds((HPVT)vtSrc, srcCur) >1)
                {
                    int i;
                    RvPstFieldId fieldId = (RvPstFieldId)-1;
                    RvPvtNodeId srcChild = pvtChild((HPVT)vtSrc, srcCur);
                    RvPvtNodeId destChild;
                    int children = pvtNumChilds((HPVT)vtSrc, srcCur);

                    for (i = 0; i < children; i++)
                    {
                        pvtGet((HPVT)vtSrc, srcChild, &fieldId, NULL, NULL, NULL);
                        destChild = pvtGetChild((HPVT)vtDest, destCur, fieldId, NULL);

                        if (destChild <0)
                        {
                            RvLogError(&vtSrc->log,
                                (&vtSrc->log, "vtSearchPath:Sequence: %s not in destination.",
                                     pstGetFieldNamePtr(hSyn, fieldId)));
                            return RV_FALSE;
                        }
                        if (pvtSearchPath((HPVT)vtDest, destChild, (HPVT)vtSrc, srcChild, checkLeaves) != RV_TRUE)
                            return RV_FALSE;
                        srcChild = pvtBrother((HPVT)vtSrc, srcChild);
                    }
                    return RV_TRUE;
                }
                break;

            case pstChoice:
                break;

            case pstSetOf:
            case pstSequenceOf:
                {
                    int j;
                    int children = pvtNumChilds((HPVT)vtDest, destCur);
                    RvPvtNodeId child    = pvtChild((HPVT)vtDest, destCur);
                    RvPvtNodeId srcChild = pvtChild((HPVT)vtSrc, srcCur);

                    pvtSetSyn((HPVT)vtSrc, hSyn, srcCur, -1, -1, NULL);

                    for (j = 0; j < children; j++)
                    {
                        if (pvtSearchPath((HPVT)vtDest, child, (HPVT)vtSrc, srcChild, checkLeaves) == RV_TRUE)
                        {
                            RvLogDebug(&vtSrc->log,
                                (&vtSrc->log, "vtSearchPath:SetOf: [%d] %s found.",
                                     j + 1, getSafeFieldName(vtNodeSrc)));
                            return pvtSetSyn((HPVT)vtSrc, hSyn, srcCur, -1, j + 1, NULL);
                        }
                        child = pvtBrother((HPVT)vtDest, child);
                    }
                    RvLogError(&vtSrc->log,
                        (&vtSrc->log, "vtSearchPath:SetOf: subtree of %s not found.",
                             getSafeFieldName(vtNodeSrc)));
                    return RV_FALSE;
                }
                break;

            default:
            {
                /* leaf holds value */

                if (!checkLeaves)
                {
                    /* not checking leaves - no need for comparison */
                    return RV_TRUE;
                }

                RvLogDebug(&vtSrc->log,
                    (&vtSrc->log, "pvtSearchPath:Leaf:%s: %d <-> %d.",
                         getSafeFieldName(vtNodeSrc), vtNodeDest->value, vtNodeSrc->value));

                /* compare values: */
                if (vtNodeDest->value != vtNodeSrc->value)
                    return RV_FALSE;

                /* see if both had/don't have strings: */
                if ((vtNodeDest->string && !vtNodeSrc->string) ||
                    (!vtNodeDest->string && vtNodeSrc->string))
                    return RV_FALSE;

                /* compare strings */
                if (vtNodeDest->string)
                {
                    if (rpoolCompareInternal(vtDest->sPool, vtNodeDest->string,
                        vtNodeSrc->string, (int)vtNodeDest->value))
                    {
                        return RV_FALSE;
                    }
                }

                /* matched */
                return RV_TRUE;
            }
        }

        {
            int synField;
            srcCur = pvtChild((HPVT)vtSrc, srcCur);
            vtNodeSrc = GET_NODE(vtSrc,  srcCur);
            synField = VTN_SYN_FIELD(vtNodeSrc);
            destCur = pvtGetChild((HPVT)vtDest, destCur, synField, NULL);
            vtNodeDest = GET_NODE(vtDest, destCur);
        }
    }

    return (srcCur < 0)? RV_TRUE : RV_FALSE;
}




RvBool pvtNodeCompare(RTElement e1, void *param)
{
    return ( (RvPstFieldId)VTN_SYN_FIELD((vtNode *)e1) == (RvPstFieldId)param );
}


static RvBool /* RV_TRUE -if node is a bit string /RV_FALSE - not a bit string */
pvtIsBitString(

          IN HPST hSyn,
          IN RvPstNodeId nodeId)
{
    return (pstGetNodeType(hSyn, nodeId) == pstBitString)?RV_TRUE:RV_FALSE;
}






/*____________________________interface_______________________________________*/

static RvPstNodeId /* syntax node id or negative value on failure */
pvtResolveSynNodeId(
           IN  HPVT hVal,
           IN  HPST hSyn,
           IN  RvPvtNodeId valParentId,
           IN  RvPstFieldId fieldEnum,
           OUT int *index /* of child in parent */
           )
{
    int objectId;
    RvPstNodeId parentSynNodeId = RV_PST_INVALID_NODEID;
    RvPvtNodeId parentId, childNodeId;
    pstChildExt child,field;
    pstTypeFromConstraint specialType;
    pstConstrainingField constrainingField;
    pstFieldOfObjectReference fieldOfObject;



    RvPstFieldId parentFieldId;
    int _index,i;
    pstNodeType type;
    if (index) *index = RV_ERROR_UNKNOWN;

    /* -- resolve syntax node id */
    if (pvtGet(hVal, valParentId, &parentFieldId, &parentSynNodeId, NULL, NULL) <0)
        return RV_PST_ERROR_UNKNOWN;

    /* -- SEQUENCE OF */
    if ((type=pstGetNodeType(hSyn, parentSynNodeId)) != RV_ERROR_UNKNOWN)
        if (type == pstSequenceOf || type == pstSetOf)
            return pstGetNodeOfId(hSyn,parentSynNodeId);

    if ( (_index = pstGetFieldExt(hSyn, parentSynNodeId, (int)fieldEnum, &child)) <0)
    {
        RvLogWarning(&((vtStruct *)hVal)->log,
            (&((vtStruct *)hVal)->log, "pvtResolveSynNodeId: child '%s' does not exist under '%s'.",
                pstGetFieldNamePtr(hSyn, fieldEnum), pstGetFieldNamePtr(hSyn, parentFieldId)));
        return RV_PST_ERROR_UNKNOWN;
    }
    if (index) *index = _index;

    if (child.speciality!=pstDependingDependent &&
        child.speciality!=pstDependent)
        return child.nodeId;


    /* getting special type */
    pstGetTypeFromConstraint(hSyn, child.nodeId, &specialType);

    /* getting constraining field */
    pstGetConstrainingField(hSyn, child.nodeId, &constrainingField);

    /* getting field itself(node) */
    /* here very intimate knowledge of the internal database is used*/
    /* it is known that fields are placed at nodeId+fieldIndex position */

    pstGetChildExt(hSyn, constrainingField.fieldId, 0, &field);

    for(i=0,parentId=valParentId;i<constrainingField.parentDepth;i++) /* going to parent */
        parentId=pvtParent(hVal,parentId);

    if((childNodeId=pvtGetChild(hVal,parentId,field.fieldId,&childNodeId))<0) /* going to depending field */
        return RV_PST_ERROR_UNKNOWN;

    if(pvtFindObject(hVal,childNodeId,hSyn,specialType.objectSetId,&objectId)==RV_ERROR_UNKNOWN) /* finding object */
        return RV_PST_ERROR_UNDEFINED_TYPE;

    for(i=1;;i++)                                                           /* finding field of object */
    {
        if (pstGetFieldOfObjectReference(hSyn, objectId, i, &fieldOfObject) < 0)
            return RV_PST_ERROR_UNKNOWN;
        if (fieldOfObject.fieldInClassNumber == specialType.fieldInClassNumber)
            break;
    }

    return fieldOfObject.settingId;
}


/*________________________________________add_________________________________*/


/************************************************************************
 * pvtSetNode
 * purpose: Set a node's value
 * input  : hVal        - PVT handle to use
 *          hSyn        - Syntax tree to use
 *                        Can be set to -1 if it will be supplied later (by pvtSetTree)
 *          nodePath    - Node Id to set
 *          nodeSynId   - Syntax node Id of the node or negative value on failure if unknown
 *          parentId    - Parent's node Id or negative value on failure if a root node
 *          fieldEnum   - Syntax tree field inside a type, or negative value on failure if a root node
 *          value       - Value of the root node, or length of the value if
 *                        value is a string
 *          string      - String value of the node, or NULL if not a string
 * output : index       - Index of the new node (1-based)
 * return : Node id of the added root on success
 *          Negative value on failure
 ************************************************************************/
static RvPvtNodeId
pvtSetNode(
      IN  HPVT          hVal,
      IN  HPST          hSyn,
      IN  RvPvtNodeId   nodePath,
      IN  RvPstNodeId   nodeSynId,
      IN  RvPvtNodeId   parentId,
      IN  RvPstFieldId  fieldEnum,
      IN  RvInt32       value,
      IN  const char*   string,
      OUT int*          index)
{
    vtStruct *vt = (vtStruct *)hVal;
    vtNode *node;
    RvBool isBitStr;
    char bitsNotInUse;
    RvPstNodeId synField;
    RvInt32 copiedValue = value; /* Number of bytes to copy from the user - used for bit strings */

    if (!vt)
        return RV_PVT_ERROR_UNKNOWN;

    if ( (node = (vtNode *)rtGetByPath(vt->vTree, (int)nodePath)) == NULL)
        return RV_PVT_ERROR_UNKNOWN;

    node->hSyn = hSyn;
    if (!RV_PST_NODEID_IS_VALID(nodeSynId))
        nodeSynId = pvtResolveSynNodeId(hVal, hSyn, parentId, fieldEnum, NULL);
    VTN_SET_SYN_INFO(node, nodeSynId, fieldEnum);

    if (index != NULL)
    {
        if (RV_PVT_NODEID_IS_VALID(parentId))
            *index = rtIndex(vt->vTree, (int)parentId, (int)nodePath);
        else
            *index = 1;
    }

    synField = VTN_SYN_NODE(node);

    /* See if it's a bit string */
    if ((isBitStr = pvtIsBitString(hSyn, synField)))