Changeset 83 for trunk/src/helpers/xml.c

Timestamp:

Jun 28, 2001, 7:13:56 PM (24 years ago)

Author:

umoeller

Message:

Many misc updates.

File:

• trunk/src/helpers/xml.c (modified) (24 diffs)

trunk/src/helpers/xml.c

@@ -276 +276 @@
 
 /*
- *@@ CompareNodeBaseNodes:
+ *@@ CompareXStrings:
  *      tree comparison func for NodeBases.
  *      This works for all trees which contain structures
@@ -293 +293 @@
  */
 
-int TREEENTRY CompareNodeBaseNodes(TREE *t1,
-                                  TREE *t2)
-{
-    PNODEBASE   p1 = (PNODEBASE)t1,
-                p2 = (PNODEBASE)t2;
-    return (strhcmp(p1->strNodeName.psz, p2->strNodeName.psz));
-}
-
-/*
- *@@ CompareNodeBaseNodes:
- *      tree comparison func for element declarations.
- *      Used to find nodes in _DOMDOCTYPENODE.ElementDeclsTree.
- *
- *@@added V0.9.9 (2001-02-16) [umoeller]
- */
-
-int TREEENTRY CompareNodeBaseData(TREE *t1,
-                                 void *pData)
-{
-    PNODEBASE     p1 = (PNODEBASE)t1;
-    return (strhcmp(p1->strNodeName.psz, (const char*)pData));
+int TREEENTRY CompareXStrings(ULONG ul1,
+                              ULONG ul2)
+{
+    return (strhcmp(((PXSTRING)ul1)->psz,
+                    ((PXSTRING)ul1)->psz));
 }
 
@@ -343 +327 @@
         pNewNode->ulNodeType = ulNodeType;
 
+        pNewNode->Tree.ulKey = (ULONG)&pNewNode->strNodeName;
+
         xstrInit(&pNewNode->strNodeName, 0);
         if (pcszNodeName)
+        {
             xstrcpy(&pNewNode->strNodeName,
                     pcszNodeName,
-                    ulNodeNameLength);  // if 0, xstrcpy will do strlen()
-
+                    ulNodeNameLength);
+        }
 
         *ppNew = pNewNode;
@@ -514 +501 @@
         lstClear(&llDeleteNodes);
 
-        xstrClear(&pNode->strNodeName);
+        xstrFree(((PXSTRING*)&pNode->Tree.ulKey));
         free(pNode);
     }
@@ -587 +574 @@
                 // attribute:
                 // add to parent's attributes list
-                if (treeInsertNode(&pParentNode->AttributesMap,
-                                   &pNewNode->NodeBase.Tree,
-                                   CompareNodeBaseNodes,
-                                   FALSE)      // no duplicates
-                        == TREE_DUPLICATE)
+                if (treeInsert(&pParentNode->AttributesMap,
+                               &pNewNode->NodeBase.Tree,
+                               CompareXStrings))
                     arc = ERROR_DOM_DUPLICATE_ATTRIBUTE;
                                 // shouldn't happen, because expat takes care of this
@@ -837 +822 @@
         PDOMDOCTYPENODE pNew = NULL;
         arc = xmlCreateDomNode((PDOMNODE)pDocumentNode,
-                            DOMNODE_DOCUMENT_TYPE,
-                            NULL,
-                            0,
-                            (PDOMNODE*)&pNew);
+                               DOMNODE_DOCUMENT_TYPE,
+                               pcszDoctypeName,
+                               0,
+                               (PDOMNODE*)&pNew);
 
         if (!arc)
@@ -854 +839 @@
             pNew->fHasInternalSubset = fHasInternalSubset;
 
-            if (pcszDoctypeName)
-            {
-                ULONG ul = strlen(pcszDoctypeName);
-                if (ul)
-                {
-                    xstrcpy(&pDocumentNode->DomNode.NodeBase.strNodeName,
-                            pcszDoctypeName,
-                            ul);
-                }
-            }
-
             treeInit(&pNew->ElementDeclsTree);
             treeInit(&pNew->AttribDeclBasesTree);
@@ -909 +883 @@
         case XML_CTYPE_NAME:   // that's easy
             pParticle->NodeBase.ulNodeType = ELEMENTPARTICLE_NAME;
-            xstrInitCopy(&pParticle->NodeBase.strNodeName, pModel->name, 0);
-            treeInsertNode(ppElementNamesTree,
-                           &pParticle->NodeBase.Tree,
-                           CompareNodeBaseNodes,
-                           TRUE);       // allow duplicates here
+            xstrcpy(&pParticle->NodeBase.strNodeName, pModel->name, 0);
+            treeInsert(ppElementNamesTree,
+                       &pParticle->NodeBase.Tree,
+                       CompareXStrings);
         break;
 
@@ -1097 +1070 @@
                 case ELEMENTPARTICLE_SEQ:
                 {
-                    const char *pcszNewElementName
-                        = pNewElement->NodeBase.strNodeName.psz;
+                    PXSTRING pstrNewElementName
+                        = &pNewElement->NodeBase.strNodeName;
 
                     // for all these, we first need to check if
                     // the element is allowed at all
                     PCMELEMENTPARTICLE pParticle
-                        = (PCMELEMENTPARTICLE)treeFindEQData(
-                                         &pParentElementDecl->ParticleNamesTree,
-                                         (void*)pcszNewElementName,
-                                         CompareNodeBaseData);
+                        = (PCMELEMENTPARTICLE)treeFind(
+                                         pParentElementDecl->ParticleNamesTree,
+                                         (ULONG)pstrNewElementName,
+                                         CompareXStrings);
                     if (!pParticle)
                         // not found: then this element is not allowed within this
@@ -1112 +1085 @@
                         xmlSetError(pDom,
                                     ERROR_DOM_INVALID_SUBELEMENT,
-                                    pcszNewElementName,
+                                    pstrNewElementName->psz,
                                     TRUE);
                     else
@@ -1249 +1222 @@
                 // enumeration: then check if it has one of the
                 // allowed values
-                PNODEBASE pValue = (PNODEBASE)treeFindEQData(
-                                                &pAttribDecl->ValuesTree,
-                                                (void*)pAttrib->pstrNodeValue->psz,
-                                                CompareNodeBaseData);
+                PNODEBASE pValue = (PNODEBASE)treeFind(
+                                                pAttribDecl->ValuesTree,
+                                                (ULONG)pAttrib->pstrNodeValue,
+                                                CompareXStrings);
                 if (!pValue)
                     xmlSetError(pDom,
@@ -1297 +1270 @@
         {
             // for all others , we need to find the attribute
-            PSZ pszAttrNameThis = pDeclThis->NodeBase.strNodeName.psz;
-            PDOMNODE pAttrNode = (PDOMNODE)treeFindEQData(
-                                            &pNewElement->AttributesMap,
-                                            (void*)pszAttrNameThis,
-                                            CompareNodeBaseData);
+            PXSTRING pstrAttrNameThis = &pDeclThis->NodeBase.strNodeName;
+            PDOMNODE pAttrNode = (PDOMNODE)treeFind(
+                                            pNewElement->AttributesMap,
+                                            (ULONG)pstrAttrNameThis,
+                                            CompareXStrings);
 
             // now switch again
@@ -1311 +1284 @@
                         xmlSetError(pDom,
                                     ERROR_DOM_REQUIRED_ATTRIBUTE_MISSING,
-                                    pszAttrNameThis,
+                                    pstrAttrNameThis->psz,
                                     TRUE);
                 break;
@@ -1871 +1844 @@
             {
                 // add this to the doctype's declarations tree
-                if (treeInsertNode(&pDocType->ElementDeclsTree,
-                                   (TREE*)pNew,
-                                   CompareNodeBaseNodes,
-                                   FALSE)
-                        == TREE_DUPLICATE)
+                if (treeInsert(&pDocType->ElementDeclsTree,
+                               (TREE*)pNew,
+                               CompareXStrings))
                     // element already declared:
                     // according to the XML specs, this is a validity
@@ -1906 +1877 @@
                                    &pNew);
     if (!arc)
-        treeInsertNode(&pDecl->ValuesTree,
-                       (TREE*)pNew,
-                       CompareNodeBaseNodes,
-                       FALSE);
+        treeInsert(&pDecl->ValuesTree,
+                   (TREE*)pNew,
+                   CompareXStrings);
 
     return (arc);
@@ -1978 +1948 @@
             if (!pThis)
             {
-                // cache didn't match: look up attributes tree then
-                pThis = (PCMATTRIBUTEDECLBASE)treeFindEQData(
-                                    &pDocType->AttribDeclBasesTree,
-                                    (void*)pcszElementName,
-                                    CompareNodeBaseData);
+                // cache didn't match: look up attributes tree then...
+                // note: cheap trick, we need an XSTRING for treeFind
+                // but don't want malloc, so we use xstrInitSet
+                XSTRING strElementName;
+                xstrInitSet(&strElementName, (PSZ)pcszElementName);
+                pThis = (PCMATTRIBUTEDECLBASE)treeFind(
+                                    pDocType->AttribDeclBasesTree,
+                                    (ULONG)&strElementName,
+                                    CompareXStrings);
 
                 if (!pThis)
@@ -1990 +1964 @@
                     pDom->arcDOM = xmlCreateNodeBase(ATTRIBUTE_DECLARATION_BASE,
                                                      sizeof(CMATTRIBUTEDECLBASE),
-                                                     pcszElementName,
-                                                     0,
+                                                     strElementName.psz,
+                                                     strElementName.ulLength,
                                                      (PNODEBASE*)&pThis);
                     if (!pDom->arcDOM)
@@ -1998 +1972 @@
                         treeInit(&pThis->AttribDeclsTree);
 
-                        treeInsertNode(&pDocType->AttribDeclBasesTree,
-                                       (TREE*)pThis,
-                                       CompareNodeBaseNodes,
-                                       FALSE);
+                        treeInsert(&pDocType->AttribDeclBasesTree,
+                                   (TREE*)pThis,
+                                   CompareXStrings);
                     }
                 }
@@ -2085 +2058 @@
                                 pNew->ulConstraint = CMAT_IMPLIED;
 
-                        if (treeInsertNode(&pThis->AttribDeclsTree,
-                                           (TREE*)pNew,
-                                           CompareNodeBaseNodes,
-                                           FALSE)
-                                == TREE_DUPLICATE)
+                        if (treeInsert(&pThis->AttribDeclsTree,
+                                       (TREE*)pNew,
+                                       CompareXStrings))
                             xmlSetError(pDom,
                                         ERROR_DOM_DUPLICATE_ATTRIBUTE_DECL,
@@ -2431 +2402 @@
 
 PCMELEMENTDECLNODE xmlFindElementDecl(PXMLDOM pDom,
-                                      const XSTRING *pstrElementName)
+                                      const XSTRING *pcstrElementName)
 {
     PCMELEMENTDECLNODE pElementDecl = NULL;
 
+    PDOMDOCTYPENODE pDocTypeNode = pDom->pDocTypeNode;
+    if (    (pDocTypeNode)
+         && (pcstrElementName)
+         && (pcstrElementName->ulLength)
+       )
+    {
+        pElementDecl = (PCMELEMENTDECLNODE)treeFind(
+                                      pDocTypeNode->ElementDeclsTree,
+                                      (ULONG)pcstrElementName,
+                                      CompareXStrings);
+    }
+
+    return (pElementDecl);
+}
+
+/*
+ *@@ xmlFindAttribDeclBase:
+ *      returns the _CMATTRIBUTEDECLBASE for the specified
+ *      element name, or NULL if none exists.
+ *
+ *      To find a specific attribute declaration from both
+ *      an element and an attribute name, use xmlFindAttribDecl
+ *      instead.
+ *
+ *@@added V0.9.9 (2001-02-16) [umoeller]
+ */
+
+PCMATTRIBUTEDECLBASE xmlFindAttribDeclBase(PXMLDOM pDom,
+                                           const XSTRING *pstrElementName)
+{
     PDOMDOCTYPENODE pDocTypeNode = pDom->pDocTypeNode;
     if (    (pDocTypeNode)
@@ -2441 +2442 @@
        )
     {
-        pElementDecl = (PCMELEMENTDECLNODE)treeFindEQData(
-                                      &pDocTypeNode->ElementDeclsTree,
-                                      (void*)pstrElementName->psz,
-                                      CompareNodeBaseData);
-    }
-
-    return (pElementDecl);
-}
-
-/*
- *@@ xmlFindAttribDeclBase:
- *      returns the _CMATTRIBUTEDECLBASE for the specified
- *      element name, or NULL if none exists.
- *
- *      To find a specific attribute declaration from both
- *      an element and an attribute name, use xmlFindAttribDecl
- *      instead.
- *
- *@@added V0.9.9 (2001-02-16) [umoeller]
- */
-
-PCMATTRIBUTEDECLBASE xmlFindAttribDeclBase(PXMLDOM pDom,
-                                           const XSTRING *pstrElementName)
-{
-    PCMATTRIBUTEDECLBASE pAttribDeclBase = NULL;
-
-    PDOMDOCTYPENODE pDocTypeNode = pDom->pDocTypeNode;
-    if (    (pDocTypeNode)
-         && (pstrElementName)
-         && (pstrElementName->ulLength)
-       )
-    {
-        pAttribDeclBase = (PCMATTRIBUTEDECLBASE)treeFindEQData(
-                                        &pDocTypeNode->AttribDeclBasesTree,
-                                        (void*)pstrElementName->psz,
-                                        CompareNodeBaseData);
-    }
-
-    return (pAttribDeclBase);
+        return ((PCMATTRIBUTEDECLBASE)treeFind(
+                                        pDocTypeNode->AttribDeclBasesTree,
+                                        (ULONG)pstrElementName,
+                                        CompareXStrings));
+    }
+
+    return (NULL);
 }
 
@@ -2498 +2467 @@
                                             // must be NULL on the first call
 {
-    PCMATTRIBUTEDECL pAttribDecl = NULL;
     if (pstrElementName && pstrAttribName)
     {
@@ -2507 +2475 @@
         if (*ppAttribDeclBase)
         {
-            pAttribDecl = (PCMATTRIBUTEDECL)treeFindEQData(
-                                         &((**ppAttribDeclBase).AttribDeclsTree),
-                                         (void*)pstrAttribName->psz,
-                                         CompareNodeBaseData);
-        }
-    }
-
-    return (pAttribDecl);
+            return ((PCMATTRIBUTEDECL)treeFind(
+                                         ((**ppAttribDeclBase).AttribDeclsTree),
+                                         (ULONG)pstrAttribName,
+                                         CompareXStrings));
+        }
+    }
+
+    return (NULL);
 }
 
@@ -2671 +2639 @@
                                const char *pcszAttribName)
 {
-    PDOMNODE pAttrNode = (PDOMNODE)treeFindEQData(&pElement->AttributesMap,
-                                                  (void*)pcszAttribName,
-                                                  CompareNodeBaseData);
+    XSTRING str;
+    PDOMNODE pAttrNode;
+    xstrInitSet(&str, (PSZ)pcszAttribName);
+    // note, cheap trick: no malloc here, but we need
+    // an XSTRING for treeFind
+    pAttrNode = (PDOMNODE)treeFind(pElement->AttributesMap,
+                                   (ULONG)&str,
+                                   CompareXStrings);
     if (pAttrNode)
         return (pAttrNode->pstrNodeValue);