[XML] pvApiCtx should be forwarded outside gateways. 07/5207/2
Bruno JOFRET [Tue, 11 Oct 2011 17:05:08 +0000 (19:05 +0200)]
Change-Id: I08f52f14673e979be55c4ccaf8790d44a2157614

35 files changed:
scilab/modules/xml/includes/xml_mlist.h
scilab/modules/xml/sci_gateway/cpp/sci_extraction.cpp
scilab/modules/xml/sci_gateway/cpp/sci_insertion.cpp
scilab/modules/xml/sci_gateway/cpp/sci_percent_XMLAttr_e.cpp
scilab/modules/xml/sci_gateway/cpp/sci_percent_XMLAttr_length.cpp
scilab/modules/xml/sci_gateway/cpp/sci_percent_XMLAttr_size.cpp
scilab/modules/xml/sci_gateway/cpp/sci_percent_XMLList_e.cpp
scilab/modules/xml/sci_gateway/cpp/sci_percent_XMLList_length.cpp
scilab/modules/xml/sci_gateway/cpp/sci_percent_XMLList_size.cpp
scilab/modules/xml/sci_gateway/cpp/sci_percent_c_i_XMLAttr.cpp
scilab/modules/xml/sci_gateway/cpp/sci_percent_foo_i_XMLList.cpp
scilab/modules/xml/sci_gateway/cpp/sci_percent_s_i_XMLList.cpp
scilab/modules/xml/sci_gateway/cpp/sci_print.cpp
scilab/modules/xml/sci_gateway/cpp/sci_xmlAddNs.cpp
scilab/modules/xml/sci_gateway/cpp/sci_xmlClose.cpp
scilab/modules/xml/sci_gateway/cpp/sci_xmlDocument.cpp
scilab/modules/xml/sci_gateway/cpp/sci_xmlDump.cpp
scilab/modules/xml/sci_gateway/cpp/sci_xmlElement.cpp
scilab/modules/xml/sci_gateway/cpp/sci_xmlGetNsByHref.cpp
scilab/modules/xml/sci_gateway/cpp/sci_xmlGetNsByPrefix.cpp
scilab/modules/xml/sci_gateway/cpp/sci_xmlGetOpenStreams.cpp
scilab/modules/xml/sci_gateway/cpp/sci_xmlNs.cpp
scilab/modules/xml/sci_gateway/cpp/sci_xmlRead.cpp
scilab/modules/xml/sci_gateway/cpp/sci_xmlReadStr.cpp
scilab/modules/xml/sci_gateway/cpp/sci_xmlValidate.cpp
scilab/modules/xml/sci_gateway/cpp/sci_xmlValidationFile.cpp
scilab/modules/xml/sci_gateway/cpp/sci_xmlWrite.cpp
scilab/modules/xml/sci_gateway/cpp/sci_xmlXPath.cpp
scilab/modules/xml/src/c/XMLMlistsManagement.c
scilab/modules/xml/src/cpp/XMLList_insertion.hpp
scilab/modules/xml/src/cpp/XMLObject.cpp
scilab/modules/xml/src/cpp/XMLObject.hxx
scilab/modules/xml/src/cpp/XMLRhsValue.hxx
scilab/modules/xml/src/cpp/extraction.hpp
scilab/modules/xml/src/cpp/insertion.hpp

index 1863826..7c23afb 100644 (file)
@@ -29,7 +29,7 @@
  * @param id the object id
  * @return 1 if all is ok else 0
  */
-int createXMLObjectAtPos(int type, int pos, int id);
+int createXMLObjectAtPos(int type, int pos, int id, void *pvApiCtx);
 
 /**
  * Creates an XML object at a given position in a list
@@ -40,76 +40,76 @@ int createXMLObjectAtPos(int type, int pos, int id);
  * @param id the object id
  * @return 1 if all is ok else 0
  */
-int createXMLObjectAtPosInList(int * list, int stackPos, int type, int pos, int id);
+int createXMLObjectAtPosInList(int * list, int stackPos, int type, int pos, int id, void *pvApiCtx);
 
 /**
  * Checks if a mlist has the good type
  * @param mlist the mlist address
  * @return 1 if the mlist has the good type, else 0.
  */
-int isXMLDoc(int * mlist);
+int isXMLDoc(int * mlist, void *pvApiCtx);
 
 /**
  * Checks if a mlist has the good type
  * @param mlist the mlist address
  * @return 1 if the mlist has the good type, else 0.
  */
-int isXMLElem(int * mlist);
+int isXMLElem(int * mlist, void *pvApiCtx);
 
 /**
  * Checks if a mlist has the good type
  * @param mlist the mlist address
  * @return 1 if the mlist has the good type, else 0.
  */
-int isXMLAttr(int * mlist);
+int isXMLAttr(int * mlist, void *pvApiCtx);
 
 /**
  * Checks if a mlist has the good type
  * @param mlist the mlist address
  * @return 1 if the mlist has the good type, else 0.
  */
-int isXMLNs(int * mlist);
+int isXMLNs(int * mlist, void *pvApiCtx);
 
 /**
  * Checks if a mlist has the good type
  * @param mlist the mlist address
  * @return 1 if the mlist has the good type, else 0.
  */
-int isXMLList(int * mlist);
+int isXMLList(int * mlist, void *pvApiCtx);
 
 /**
  * Checks if a mlist has the good type
  * @param mlist the mlist address
  * @return 1 if the mlist has the good type, else 0.
  */
-int isXMLObject(int * mlist);
+int isXMLObject(int * mlist, void *pvApiCtx);
 
 /**
  * Checks if a mlist has the good type
  * @param mlist the mlist address
  * @return 1 if the mlist has the good type, else 0.
  */
-int isXMLNotHandled(int * mlist);
+int isXMLNotHandled(int * mlist, void *pvApiCtx);
 
 /**
  * Checks if a mlist has the good type
  * @param mlist the mlist address
  * @return 1 if the mlist has the good type, else 0.
  */
-int isXMLSet(int * mlist);
+int isXMLSet(int * mlist, void *pvApiCtx);
 
 /**
  * Checks if a mlist has the good type
  * @param mlist the mlist address
  * @return 1 if the mlist has the good type, else 0.
  */
-int isXMLValid(int * mlist);
+int isXMLValid(int * mlist, void *pvApiCtx);
 
 /**
  * Get the XMLObject field _id
  * @param mlist the mlist address
  * @return the object id.
  */
-int getXMLObjectId(int * mlist);
+int getXMLObjectId(int * mlist, void *pvApiCtx);
 
 #endif /* __XML_MLIST_H__ */
index 6b0f90a..7c0296e 100644 (file)
@@ -16,16 +16,16 @@ using namespace org_modules_xml;
 
 int sci_percent_XMLDoc_e(char *fname, unsigned long fname_len)
 {
-    return sci_extraction<org_modules_xml::XMLDocument>(fname, fname_len);
+    return sci_extraction<org_modules_xml::XMLDocument>(fname, pvApiCtx);
 }
 /*--------------------------------------------------------------------------*/
 int sci_percent_XMLElem_e(char *fname, unsigned long fname_len)
 {
-    return sci_extraction<XMLElement>(fname, fname_len);
+    return sci_extraction<XMLElement>(fname, pvApiCtx);
 }
 /*--------------------------------------------------------------------------*/
 int sci_percent_XMLNs_e(char *fname, unsigned long fname_len)
 {
-    return sci_extraction<XMLNs>(fname, fname_len);
+    return sci_extraction<XMLNs>(fname, pvApiCtx);
 }
 /*--------------------------------------------------------------------------*/
index edd3c25..60e7811 100644 (file)
 
 int sci_percent_c_i_XMLDoc(char *fname, unsigned long fname_len)
 {
-    return sci_insertion<org_modules_xml::XMLDocument, std::string>(fname, fname_len);
+    return sci_insertion<org_modules_xml::XMLDocument, std::string>(fname, pvApiCtx);
 }
 /*--------------------------------------------------------------------------*/
 int sci_percent_XMLElem_i_XMLDoc(char *fname, unsigned long fname_len)
 {
-    return sci_insertion<org_modules_xml::XMLDocument, XMLElement>(fname, fname_len);
+    return sci_insertion<org_modules_xml::XMLDocument, XMLElement>(fname, pvApiCtx);
 }
 /*--------------------------------------------------------------------------*/
 int sci_percent_c_i_XMLElem(char *fname, unsigned long fname_len)
 {
-    return sci_insertion<XMLElement, std::string>(fname, fname_len);
+    return sci_insertion<XMLElement, std::string>(fname, pvApiCtx);
 }
 /*--------------------------------------------------------------------------*/
 int sci_percent_XMLElem_i_XMLElem(char *fname, unsigned long fname_len)
 {
-    return sci_insertion<XMLElement, XMLElement>(fname, fname_len);
+    return sci_insertion<XMLElement, XMLElement>(fname, pvApiCtx);
 }
 /*--------------------------------------------------------------------------*/
 int sci_percent_XMLAttr_i_XMLElem(char *fname, unsigned long fname_len)
 {
-    return sci_insertion<XMLElement, XMLAttr>(fname, fname_len);
+    return sci_insertion<XMLElement, XMLAttr>(fname, pvApiCtx);
 }
 /*--------------------------------------------------------------------------*/
 int sci_percent_XMLList_i_XMLElem(char *fname, unsigned long fname_len)
 {
-    return sci_insertion<XMLElement, XMLNodeList>(fname, fname_len);
+    return sci_insertion<XMLElement, XMLNodeList>(fname, pvApiCtx);
 }
 /*--------------------------------------------------------------------------*/
 int sci_percent_XMLNs_i_XMLElem(char *fname, unsigned long fname_len)
 {
-    return sci_insertion<XMLElement, XMLNs>(fname, fname_len);
+    return sci_insertion<XMLElement, XMLNs>(fname, pvApiCtx);
 }
 /*--------------------------------------------------------------------------*/
 int sci_percent_XMLElem_i_XMLList(char *fname, unsigned long fname_len)
 {
-    return sci_XMLList_insertion<XMLElement>(fname, fname_len);
+    return sci_XMLList_insertion<XMLElement>(fname, pvApiCtx);
 }
 /*--------------------------------------------------------------------------*/
 int sci_percent_XMLDoc_i_XMLList(char *fname, unsigned long fname_len)
 {
-    return sci_XMLList_insertion<org_modules_xml::XMLDocument>(fname, fname_len);
+    return sci_XMLList_insertion<org_modules_xml::XMLDocument>(fname, pvApiCtx);
 }
 /*--------------------------------------------------------------------------*/
 int sci_percent_c_i_XMLList(char *fname, unsigned long fname_len)
 {
-    return sci_XMLList_insertion<std::string>(fname, fname_len);
+    return sci_XMLList_insertion<std::string>(fname, pvApiCtx);
 }
 /*--------------------------------------------------------------------------*/
 int sci_percent_XMLList_i_XMLList(char *fname, unsigned long fname_len)
 {
-    return sci_XMLList_insertion<XMLNodeList>(fname, fname_len);
+    return sci_XMLList_insertion<XMLNodeList>(fname, pvApiCtx);
 }
 /*--------------------------------------------------------------------------*/
index 7670db6..3c6661d 100644 (file)
@@ -91,7 +91,7 @@ int sci_percent_XMLAttr_e(char * fname, unsigned long fname_len)
         return 0;
     }
 
-    id = getXMLObjectId(mlistaddr);
+    id = getXMLObjectId(mlistaddr, pvApiCtx);
     attr = XMLObject::getFromId<XMLAttr>(id);
 
     if (!attr)
index 1805fe9..7ab1b78 100644 (file)
@@ -44,14 +44,14 @@ int sci_percent_XMLAttr_length(char * fname, unsigned long fname_len)
         return 0;
     }
 
-    if (!isXMLAttr(addr))
+    if (!isXMLAttr(addr, pvApiCtx))
     {
         Scierror(999, gettext("%s: Wrong type for input argument #%i: A %s expected.\n"), fname, 1, "XMLAttr");
         return 0;
 
     }
 
-    id = getXMLObjectId(addr);
+    id = getXMLObjectId(addr, pvApiCtx);
     attrs = XMLObject::getFromId<XMLAttr>(id);
     if (!attrs)
     {
index f70348f..403fa2e 100644 (file)
@@ -44,14 +44,14 @@ int sci_percent_XMLAttr_size(char * fname, unsigned long fname_len)
         return 0;
     }
 
-    if (!isXMLAttr(addr))
+    if (!isXMLAttr(addr, pvApiCtx))
     {
         Scierror(999, gettext("%s: Wrong type for input argument #%i: A %s expected.\n"), fname, 1, "XMLAttr");
         return 0;
 
     }
 
-    id = getXMLObjectId(addr);
+    id = getXMLObjectId(addr, pvApiCtx);
     attrs = XMLObject::getFromId<XMLAttr>(id);
     if (!attrs)
     {
index 0908e8e..f1b0b99 100644 (file)
@@ -85,7 +85,7 @@ int sci_percent_XMLList_e(char * fname, unsigned long fname_len)
                 return 0;
             }
 
-            id = getXMLObjectId(mlistaddr);
+            id = getXMLObjectId(mlistaddr, pvApiCtx);
             list = XMLObject::getFromId<XMLList>(id);
             if (!list)
             {
@@ -135,7 +135,7 @@ int sci_percent_XMLList_e(char * fname, unsigned long fname_len)
         return 0;
     }
 
-    id = getXMLObjectId(mlistaddr);
+    id = getXMLObjectId(mlistaddr, pvApiCtx);
     list = XMLObject::getFromId<XMLList>(id);
     if (!list)
     {
@@ -151,7 +151,7 @@ int sci_percent_XMLList_e(char * fname, unsigned long fname_len)
         return 0;
     }
 
-    if (!elem->createOnStack(Rhs + 1))
+    if (!elem->createOnStack(Rhs + 1, pvApiCtx))
     {
         return 0;
     }
index 0680b1a..4f1cd10 100644 (file)
@@ -44,14 +44,14 @@ int sci_percent_XMLList_length(char * fname, unsigned long fname_len)
         return 0;
     }
 
-    if (!isXMLList(addr) && !isXMLSet(addr))
+    if (!isXMLList(addr, pvApiCtx) && !isXMLSet(addr, pvApiCtx))
     {
         Scierror(999, gettext("%s: Wrong type for input argument #%i: XMLList or XMLSet expected.\n"), fname, 1);
         return 0;
 
     }
 
-    id = getXMLObjectId(addr);
+    id = getXMLObjectId(addr, pvApiCtx);
     list = XMLObject::getFromId<XMLList>(id);
     if (!list)
     {
index cb5ce83..517caa5 100644 (file)
@@ -44,14 +44,14 @@ int sci_percent_XMLList_size(char * fname, unsigned long fname_len)
         return 0;
     }
 
-    if (!isXMLList(addr) && !isXMLSet(addr))
+    if (!isXMLList(addr, pvApiCtx) && !isXMLSet(addr, pvApiCtx))
     {
         Scierror(999, gettext("%s: Wrong type for input argument #%i: XMLList or XMLSet expected.\n"), fname, 1);
         return 0;
 
     }
 
-    id = getXMLObjectId(addr);
+    id = getXMLObjectId(addr, pvApiCtx);
     list = XMLObject::getFromId<XMLList>(id);
     if (!list)
     {
index 7d371fa..c3cc6f8 100644 (file)
@@ -104,7 +104,7 @@ int sci_percent_c_i_XMLAttr(char * fname, unsigned long fname_len)
         return 0;
     }
 
-    lhsid = getXMLObjectId(lhsaddr);
+    lhsid = getXMLObjectId(lhsaddr, pvApiCtx);
     a = XMLObject::getFromId<XMLAttr>(lhsid);
     if (!a)
     {
@@ -147,7 +147,7 @@ int sci_percent_c_i_XMLAttr(char * fname, unsigned long fname_len)
     }
     freeAllocatedSingleString(value);
 
-    a->createOnStack(Rhs + 1);
+    a->createOnStack(Rhs + 1, pvApiCtx);
     LhsVar(1) = Rhs + 1;
     PutLhsVar();
 
index 8027aab..6123234 100644 (file)
@@ -84,7 +84,7 @@ int sci_percent_foo_i_XMLList(char * fname, unsigned long fname_len)
         return 0;
     }
 
-    lhsid = getXMLObjectId(lhsaddr);
+    lhsid = getXMLObjectId(lhsaddr, pvApiCtx);
     a = XMLObject::getFromId<XMLNodeList>(lhsid);
     if (!a)
     {
@@ -121,7 +121,7 @@ int sci_percent_foo_i_XMLList(char * fname, unsigned long fname_len)
         {
             a->setElementAtPosition(index, std::string(retstr));
             freeAllocatedSingleString(retstr);
-            a->createOnStack(Rhs + 1);
+            a->createOnStack(Rhs + 1, pvApiCtx);
             LhsVar(1) = Rhs + 1;
         }
     }
index 2549054..ecb797b 100644 (file)
@@ -76,7 +76,7 @@ int sci_percent_s_i_XMLList(char * fname, unsigned long fname_len)
         return 0;
     }
 
-    lhsid = getXMLObjectId(lhsaddr);
+    lhsid = getXMLObjectId(lhsaddr, pvApiCtx);
     a = XMLObject::getFromId<XMLNodeList>(lhsid);
     if (!a)
     {
@@ -94,7 +94,7 @@ int sci_percent_s_i_XMLList(char * fname, unsigned long fname_len)
     if (row == 0 && col == 0)
     {
         a->removeElementAtPosition((int)index);
-        a->createOnStack(Rhs + 1);
+        a->createOnStack(Rhs + 1, pvApiCtx);
         LhsVar(1) = Rhs + 1;
     }
     else if (isNamedVarExist(pvApiCtx, "%s_xmlFormat"))
@@ -121,7 +121,7 @@ int sci_percent_s_i_XMLList(char * fname, unsigned long fname_len)
         {
             a->setElementAtPosition(index, std::string(retstr));
             freeAllocatedSingleString(retstr);
-            a->createOnStack(Rhs + 1);
+            a->createOnStack(Rhs + 1, pvApiCtx);
             LhsVar(1) = Rhs + 1;
         }
     }
index adffc5b..72a58af 100644 (file)
@@ -31,7 +31,7 @@ extern "C"
 using namespace org_modules_xml;
 
 /*--------------------------------------------------------------------------*/
-int sci_print(char * fname, unsigned long fname_len)
+int sci_print(char * fname, void* pvApiCtx)
 {
     XMLObject * obj;
     int id;
@@ -47,7 +47,7 @@ int sci_print(char * fname, unsigned long fname_len)
         return 0;
     }
 
-    id = getXMLObjectId(mlistaddr);
+    id = getXMLObjectId(mlistaddr, pvApiCtx);
     obj = XMLObject::getFromId<XMLObject>(id);
     if (!obj)
     {
@@ -63,36 +63,36 @@ int sci_print(char * fname, unsigned long fname_len)
 /*--------------------------------------------------------------------------*/
 int sci_percent_XMLDoc_p(char *fname, unsigned long fname_len)
 {
-    return sci_print(fname, fname_len);
+    return sci_print(fname, pvApiCtx);
 }
 /*--------------------------------------------------------------------------*/
 int sci_percent_XMLElem_p(char *fname, unsigned long fname_len)
 {
-    return sci_print(fname, fname_len);
+    return sci_print(fname, pvApiCtx);
 }
 /*--------------------------------------------------------------------------*/
 int sci_percent_XMLNs_p(char *fname, unsigned long fname_len)
 {
-    return sci_print(fname, fname_len);
+    return sci_print(fname, pvApiCtx);
 }
 /*--------------------------------------------------------------------------*/
 int sci_percent_XMLList_p(char *fname, unsigned long fname_len)
 {
-    return sci_print(fname, fname_len);
+    return sci_print(fname, pvApiCtx);
 }
 /*--------------------------------------------------------------------------*/
 int sci_percent_XMLAttr_p(char *fname, unsigned long fname_len)
 {
-    return sci_print(fname, fname_len);
+    return sci_print(fname, pvApiCtx);
 }
 /*--------------------------------------------------------------------------*/
 int sci_percent_XMLSet_p(char *fname, unsigned long fname_len)
 {
-    return sci_print(fname, fname_len);
+    return sci_print(fname, pvApiCtx);
 }
 /*--------------------------------------------------------------------------*/
 int sci_percent_XMLValid_p(char *fname, unsigned long fname_len)
 {
-    return sci_print(fname, fname_len);
+    return sci_print(fname, pvApiCtx);
 }
 /*--------------------------------------------------------------------------*/
index 4c0b96d..8d5083a 100644 (file)
@@ -49,13 +49,13 @@ int sci_xmlAddNs(char * fname, unsigned long fname_len)
         return 0;
     }
 
-    if (!isXMLElem(addr))
+    if (!isXMLElem(addr, pvApiCtx))
     {
         Scierror(999, gettext("%s: Wrong type for input argument #%i: A %s expected.\n"), fname, 1, "XMLElem");
         return 0;
     }
 
-    elem = XMLObject::getFromId<XMLElement>(getXMLObjectId(addr));
+    elem = XMLObject::getFromId<XMLElement>(getXMLObjectId(addr, pvApiCtx));
     if (!elem)
     {
         Scierror(999, gettext("%s: XML Element does not exist.\n"), fname);
@@ -71,13 +71,13 @@ int sci_xmlAddNs(char * fname, unsigned long fname_len)
             return 0;
         }
 
-        if (!isXMLNs(addr))
+        if (!isXMLNs(addr, pvApiCtx))
         {
             Scierror(999, gettext("%s: Wrong type for input argument #%i: A %s expected.\n"), fname, i, "XMLNs");
             return 0;
         }
 
-        ns = XMLObject::getFromId<XMLNs>(getXMLObjectId(addr));
+        ns = XMLObject::getFromId<XMLNs>(getXMLObjectId(addr, pvApiCtx));
         if (!ns)
         {
             Scierror(999, gettext("%s: XML Namespace does not exist.\n"), fname);
index b9fd795..6dbf5ed 100644 (file)
@@ -72,9 +72,9 @@ int sci_xmlClose(char * fname, unsigned long fname_len)
                 return 0;
             }
 
-            if (isXMLDoc(addr))
+            if (isXMLDoc(addr, pvApiCtx))
             {
-                id = getXMLObjectId(addr);
+                id = getXMLObjectId(addr, pvApiCtx);
                 doc = XMLObject::getFromId<org_modules_xml::XMLDocument>(id);
                 if (!doc)
                 {
@@ -83,9 +83,9 @@ int sci_xmlClose(char * fname, unsigned long fname_len)
                 }
                 delete doc;
             }
-            else if (isXMLValid(addr))
+            else if (isXMLValid(addr, pvApiCtx))
             {
-                id = getXMLObjectId(addr);
+                id = getXMLObjectId(addr, pvApiCtx);
                 vf = XMLObject::getFromId<XMLValidation>(id);
                 if (!vf)
                 {
index e9e4190..fe35e79 100644 (file)
@@ -64,7 +64,7 @@ int sci_xmlDocument(char * fname, unsigned long fname_len)
         freeAllocatedSingleString(*(vars[i]));
     }
 
-    if (!doc->createOnStack(Rhs + 1))
+    if (!doc->createOnStack(Rhs + 1, pvApiCtx))
     {
         return 0;
     }
index a94a7bf..5a6de48 100644 (file)
@@ -53,14 +53,14 @@ int sci_xmlDump(char *fname, unsigned long fname_len)
         return 0;
     }
 
-    type = isXMLObject(addr);
+    type = isXMLObject(addr, pvApiCtx);
     if (!type)
     {
         Scierror(999, gettext("%s: Wrong type for input argument #%i: A %s expected.\n"), fname, 1, "XML object");
         return 0;
     }
 
-    id = getXMLObjectId(addr);
+    id = getXMLObjectId(addr, pvApiCtx);
     obj = XMLObject::getFromId<XMLObject>(id);
     if (!obj)
     {
index 89d7f2a..bf62666 100644 (file)
@@ -46,13 +46,13 @@ int sci_xmlElement(char * fname, unsigned long fname_len)
         return 0;
     }
 
-    if (!isXMLDoc(addr))
+    if (!isXMLDoc(addr, pvApiCtx))
     {
         Scierror(999, gettext("%s: Wrong type for input argument #%i: A %s expected.\n"), fname, 1, "XMLDoc");
         return 0;
     }
 
-    doc = XMLObject::getFromId<org_modules_xml::XMLDocument>(getXMLObjectId(addr));
+    doc = XMLObject::getFromId<org_modules_xml::XMLDocument>(getXMLObjectId(addr, pvApiCtx));
     if (!doc)
     {
         Scierror(999, gettext("%s: XML Document does not exist.\n"), fname);
@@ -83,7 +83,7 @@ int sci_xmlElement(char * fname, unsigned long fname_len)
 
     elem = new XMLElement(*doc, name);
     freeAllocatedSingleString(name);
-    if (!elem->createOnStack(Rhs + 1))
+    if (!elem->createOnStack(Rhs + 1, pvApiCtx))
     {
         return 0;
     }
index 6943f59..b7be977 100644 (file)
@@ -45,13 +45,13 @@ int sci_xmlGetNsByHref(char * fname, unsigned long fname_len)
         return 0;
     }
 
-    if (!isXMLElem(addr))
+    if (!isXMLElem(addr, pvApiCtx))
     {
         Scierror(999, gettext("%s: Wrong type for input argument #%i: A %s expected.\n"), fname, 1, "XMLElem");
         return 0;
     }
 
-    elem = XMLObject::getFromId<XMLElement>(getXMLObjectId(addr));
+    elem = XMLObject::getFromId<XMLElement>(getXMLObjectId(addr, pvApiCtx));
     if (!elem)
     {
         Scierror(999, gettext("%s: XML Element does not exist.\n"), fname);
@@ -83,7 +83,7 @@ int sci_xmlGetNsByHref(char * fname, unsigned long fname_len)
     ns = elem->getNamespaceByHref((const char *)href);
     freeAllocatedSingleString(href);
 
-    if (!ns->createOnStack(Rhs + 1))
+    if (!ns->createOnStack(Rhs + 1, pvApiCtx))
     {
         return 0;
     }
index 37c4ade..b9ef16c 100644 (file)
@@ -45,13 +45,13 @@ int sci_xmlGetNsByPrefix(char * fname, unsigned long fname_len)
         return 0;
     }
 
-    if (!isXMLElem(addr))
+    if (!isXMLElem(addr, pvApiCtx))
     {
         Scierror(999, gettext("%s: Wrong type for input argument #%i: A %s expected.\n"), fname, 1, "XMLElem");
         return 0;
     }
 
-    elem = XMLObject::getFromId<XMLElement>(getXMLObjectId(addr));
+    elem = XMLObject::getFromId<XMLElement>(getXMLObjectId(addr, pvApiCtx));
     if (!elem)
     {
         Scierror(999, gettext("%s: XML Element does not exist.\n"), fname);
@@ -82,7 +82,7 @@ int sci_xmlGetNsByPrefix(char * fname, unsigned long fname_len)
     ns = elem->getNamespaceByPrefix((const char *)href);
     freeAllocatedSingleString(href);
 
-    if (!ns->createOnStack(Rhs + 1))
+    if (!ns->createOnStack(Rhs + 1, pvApiCtx))
     {
         return 0;
     }
index 5ac9635..03cbe73 100644 (file)
@@ -47,12 +47,12 @@ int sci_xmlGetOpenStreams(char *fname, unsigned long fname_len)
 
     for (std::list<org_modules_xml::XMLDocument *>::const_iterator i = openDocs.begin(); i != openDocs.end(); i++, j++)
     {
-        createXMLObjectAtPosInList(addr, Rhs + 1, XMLDOCUMENT, j, (*i)->getId());
+        createXMLObjectAtPosInList(addr, Rhs + 1, XMLDOCUMENT, j, (*i)->getId(), pvApiCtx);
     }
 
     for (std::list<org_modules_xml::XMLValidation *>::const_iterator i = openValidationFiles.begin(); i != openValidationFiles.end(); i++, j++)
     {
-        createXMLObjectAtPosInList(addr, Rhs + 1, XMLVALID, j, (*i)->getId());
+        createXMLObjectAtPosInList(addr, Rhs + 1, XMLVALID, j, (*i)->getId(), pvApiCtx);
     }
 
     LhsVar(1) = Rhs + 1;
index ffbf859..f87367a 100644 (file)
@@ -48,13 +48,13 @@ int sci_xmlNs(char * fname, unsigned long fname_len)
         return 0;
     }
 
-    if (!isXMLElem(addr))
+    if (!isXMLElem(addr, pvApiCtx))
     {
         Scierror(999, gettext("%s: Wrong type for input argument #%i: A %s expected.\n"), fname, 1, "XMLElem");
         return 0;
     }
 
-    elem = XMLObject::getFromId<XMLElement>(getXMLObjectId(addr));
+    elem = XMLObject::getFromId<XMLElement>(getXMLObjectId(addr, pvApiCtx));
     if (!elem)
     {
         Scierror(999, gettext("%s: XML Element does not exist.\n"), fname);
@@ -86,7 +86,7 @@ int sci_xmlNs(char * fname, unsigned long fname_len)
         freeAllocatedSingleString(*(vars[i]));
     }
 
-    if (!ns->createOnStack(Rhs + 1))
+    if (!ns->createOnStack(Rhs + 1, pvApiCtx))
     {
         return 0;
     }
index 290d947..1409148 100644 (file)
@@ -88,7 +88,7 @@ int sci_xmlRead(char * fname, unsigned long fname_len)
         return 0;
     }
 
-    if (!doc->createOnStack(Rhs + 1))
+    if (!doc->createOnStack(Rhs + 1, pvApiCtx))
     {
         return 0;
     }
index d1b0f5c..6eabed7 100644 (file)
@@ -53,7 +53,7 @@ int sci_xmlReadStr(char * fname, unsigned long fname_len)
         return 0;
     }
 
-    if (!XMLRhsValue::get(fname, addr, &code))
+    if (!XMLRhsValue::get(fname, addr, &code, pvApiCtx))
     {
         return 0;
     }
@@ -89,7 +89,7 @@ int sci_xmlReadStr(char * fname, unsigned long fname_len)
         return 0;
     }
 
-    if (!doc->createOnStack(Rhs + 1))
+    if (!doc->createOnStack(Rhs + 1, pvApiCtx))
     {
         return 0;
     }
index 0f9b18e..7f65d34 100644 (file)
@@ -58,9 +58,9 @@ int sci_xmlValidate(char * fname, unsigned long fname_len)
     {
         getAllocatedMatrixOfString(pvApiCtx, addr, &row, &col, &path);
     }
-    else if (isXMLDoc(addr))
+    else if (isXMLDoc(addr, pvApiCtx))
     {
-        id = getXMLObjectId(addr);
+        id = getXMLObjectId(addr, pvApiCtx);
         doc = XMLObject::getFromId<org_modules_xml::XMLDocument>(id);
         if (!doc)
         {
@@ -83,13 +83,13 @@ int sci_xmlValidate(char * fname, unsigned long fname_len)
             return 0;
         }
 
-        if (!isXMLValid(addr))
+        if (!isXMLValid(addr, pvApiCtx))
         {
             Scierror(999, gettext("%s: Wrong type for input argument #%i: A %s expected.\n"), fname, 1, "XMLValid");
             return 0;
         }
 
-        id = getXMLObjectId(addr);
+        id = getXMLObjectId(addr, pvApiCtx);
         validation = XMLObject::getFromId<XMLValidation>(id);
         if (!validation)
         {
index e1fb605..0704d01 100644 (file)
@@ -34,7 +34,7 @@ using namespace org_modules_xml;
 
 /*--------------------------------------------------------------------------*/
 template <class T>
-int sci_xmlValidationFile(char * fname, unsigned long fname_len)
+int sci_xmlValidationFile(char * fname, void* pvApiCtx)
 {
     T * validation = 0;
     SciErr err;
@@ -69,7 +69,7 @@ int sci_xmlValidationFile(char * fname, unsigned long fname_len)
         return 0;
     }
 
-    if (!validation->createOnStack(Rhs + 1))
+    if (!validation->createOnStack(Rhs + 1, pvApiCtx))
     {
         return 0;
     }
@@ -81,16 +81,16 @@ int sci_xmlValidationFile(char * fname, unsigned long fname_len)
 /*--------------------------------------------------------------------------*/
 int sci_xmlDTD(char * fname, unsigned long fname_len)
 {
-    return sci_xmlValidationFile<XMLValidationDTD>(fname, fname_len);
+    return sci_xmlValidationFile<XMLValidationDTD>(fname, pvApiCtx);
 }
 /*--------------------------------------------------------------------------*/
 int sci_xmlRelaxNG(char * fname, unsigned long fname_len)
 {
-    return sci_xmlValidationFile<XMLValidationRelaxNG>(fname, fname_len);
+    return sci_xmlValidationFile<XMLValidationRelaxNG>(fname, pvApiCtx);
 }
 /*--------------------------------------------------------------------------*/
 int sci_xmlSchema(char * fname, unsigned long fname_len)
 {
-    return sci_xmlValidationFile<XMLValidationSchema>(fname, fname_len);
+    return sci_xmlValidationFile<XMLValidationSchema>(fname, pvApiCtx);
 }
 /*--------------------------------------------------------------------------*/
index 0bda94b..df1825c 100644 (file)
@@ -54,13 +54,13 @@ int sci_xmlWrite(char * fname, unsigned long fname_len)
         return 0;
     }
 
-    if (!isXMLDoc(addr))
+    if (!isXMLDoc(addr, pvApiCtx))
     {
         Scierror(999, gettext("%s: Wrong type for input argument %i: A %s expected.\n"), fname, 1, "XMLDoc");
         return 0;
     }
 
-    doc = XMLObject::getFromId<org_modules_xml::XMLDocument>(getXMLObjectId(addr));
+    doc = XMLObject::getFromId<org_modules_xml::XMLDocument>(getXMLObjectId(addr, pvApiCtx));
     if (!doc)
     {
         Scierror(999, gettext("%s: XML Document does not exist.\n"), fname);
index 94f1097..0b55686 100644 (file)
@@ -53,13 +53,13 @@ int sci_xmlXPath(char * fname, unsigned long fname_len)
         return 0;
     }
 
-    if (!isXMLDoc(addr))
+    if (!isXMLDoc(addr, pvApiCtx))
     {
         Scierror(999, gettext("%s: Wrong type for input argument #%i: A %s expected.\n"), fname, 1, "XMLDoc");
         return 0;
     }
 
-    id = getXMLObjectId(addr);
+    id = getXMLObjectId(addr, pvApiCtx);
     doc = XMLObject::getFromId<org_modules_xml::XMLDocument>(id);
     if (!doc)
     {
@@ -138,7 +138,7 @@ int sci_xmlXPath(char * fname, unsigned long fname_len)
         {
             createMatrixOfDouble(pvApiCtx, Rhs + 1, 0, 0, 0);
         }
-        set->createOnStack(Rhs + 1);
+        set->createOnStack(Rhs + 1, pvApiCtx);
         break;
     }
     case XPATH_BOOLEAN :
index 47f5338..7069f1f 100644 (file)
@@ -28,10 +28,10 @@ static const char * _XMLNotHandled[] = { "XMLNH", "_id" };
 static const char * _XMLSet[] = { "XMLSet", "_id" };
 static const char * _XMLValid[] = { "XMLValid", "_id" };
 
-static int compareStrToMlistType(const char ** str, int nb, int * mlist);
+static int compareStrToMlistType(const char ** str, int nb, int * mlist, void* pvApiCtx);
 
 /*--------------------------------------------------------------------------*/
-int createXMLObjectAtPos(int type, int pos, int id)
+int createXMLObjectAtPos(int type, int pos, int id, void *pvApiCtx)
 {
     const char ** fields = NULL;
     int * mlistaddr = NULL;
@@ -90,7 +90,7 @@ int createXMLObjectAtPos(int type, int pos, int id)
 }
 
 /*--------------------------------------------------------------------------*/
-int createXMLObjectAtPosInList(int * list, int stackPos, int type, int pos, int id)
+int createXMLObjectAtPosInList(int * list, int stackPos, int type, int pos, int id, void *pvApiCtx)
 {
     const char ** fields = NULL;
     int * mlistaddr = NULL;
@@ -148,51 +148,51 @@ int createXMLObjectAtPosInList(int * list, int stackPos, int type, int pos, int
     return 1;
 }
 /*--------------------------------------------------------------------------*/
-int isXMLDoc(int * mlist)
+int isXMLDoc(int * mlist, void *pvApiCtx)
 {
-    return compareStrToMlistType(XMLObjects, 1, mlist);
+    return compareStrToMlistType(XMLObjects, 1, mlist, pvApiCtx);
 }
 /*--------------------------------------------------------------------------*/
-int isXMLElem(int * mlist)
+int isXMLElem(int * mlist, void *pvApiCtx)
 {
-    return compareStrToMlistType(XMLObjects + 1, 1, mlist);
+    return compareStrToMlistType(XMLObjects + 1, 1, mlist, pvApiCtx);
 }
 /*--------------------------------------------------------------------------*/
-int isXMLAttr(int * mlist)
+int isXMLAttr(int * mlist, void *pvApiCtx)
 {
-    return compareStrToMlistType(XMLObjects + 2, 1, mlist);
+    return compareStrToMlistType(XMLObjects + 2, 1, mlist, pvApiCtx);
 }
 /*--------------------------------------------------------------------------*/
-int isXMLNs(int * mlist)
+int isXMLNs(int * mlist, void *pvApiCtx)
 {
-    return compareStrToMlistType(XMLObjects + 3, 1, mlist);
+    return compareStrToMlistType(XMLObjects + 3, 1, mlist, pvApiCtx);
 }
 /*--------------------------------------------------------------------------*/
-int isXMLList(int * mlist)
+int isXMLList(int * mlist, void *pvApiCtx)
 {
-    return compareStrToMlistType(XMLObjects + 4, 1, mlist);
+    return compareStrToMlistType(XMLObjects + 4, 1, mlist, pvApiCtx);
 }
 /*--------------------------------------------------------------------------*/
-int isXMLNotHandled(int * mlist)
+int isXMLNotHandled(int * mlist, void *pvApiCtx)
 {
-    return compareStrToMlistType(XMLObjects + 5, 1, mlist);
+    return compareStrToMlistType(XMLObjects + 5, 1, mlist, pvApiCtx);
 }
 /*--------------------------------------------------------------------------*/
-int isXMLSet(int * mlist)
+int isXMLSet(int * mlist, void *pvApiCtx)
 {
-    return compareStrToMlistType(XMLObjects + 6, 1, mlist);
+    return compareStrToMlistType(XMLObjects + 6, 1, mlist, pvApiCtx);
 }
 /*--------------------------------------------------------------------------*/
-int isXMLValid(int * mlist)
+int isXMLValid(int * mlist, void *pvApiCtx)
 {
-    return compareStrToMlistType(XMLObjects + 7, 1, mlist);
+    return compareStrToMlistType(XMLObjects + 7, 1, mlist, pvApiCtx);
 }/*--------------------------------------------------------------------------*/
-int isXMLObject(int * mlist)
+int isXMLObject(int * mlist, void *pvApiCtx)
 {
-    return compareStrToMlistType(XMLObjects, NB_XMLOBJECTS, mlist);
+    return compareStrToMlistType(XMLObjects, NB_XMLOBJECTS, mlist, pvApiCtx);
 }
 /*--------------------------------------------------------------------------*/
-int getXMLObjectId(int * mlist)
+int getXMLObjectId(int * mlist, void *pvApiCtx)
 {
     int *id = NULL;
     int row, col;
@@ -215,7 +215,7 @@ int getXMLObjectId(int * mlist)
  * @param mlist the mlist address
  * @return 0 if one of the strings is not the mlist type
  */
-static int compareStrToMlistType(const char ** str, int nb, int * mlist)
+static int compareStrToMlistType(const char ** str, int nb, int * mlist, void *pvApiCtx)
 {
     char ** mlist_type = NULL;
     int i = 0, type;
index 857ed9f..c46001b 100644 (file)
@@ -36,7 +36,7 @@ using namespace org_modules_xml;
  * @param fname_len the function name length
  */
 template <class T>
-int sci_XMLList_insertion(char * fname, unsigned long fname_len)
+int sci_XMLList_insertion(char * fname, void* pvApiCtx)
 {
     XMLNodeList * a;
     T * b;
@@ -80,7 +80,7 @@ int sci_XMLList_insertion(char * fname, unsigned long fname_len)
         return 0;
     }
 
-    lhsid = getXMLObjectId(lhsaddr);
+    lhsid = getXMLObjectId(lhsaddr, pvApiCtx);
     a = XMLObject::getFromId<XMLNodeList>(lhsid);
     if (!a)
     {
@@ -88,7 +88,7 @@ int sci_XMLList_insertion(char * fname, unsigned long fname_len)
         return 0;
     }
 
-    success = XMLRhsValue::get(fname, rhsaddr, &b);
+    success = XMLRhsValue::get(fname, rhsaddr, &b, pvApiCtx);
     if (!success)
     {
         Scierror(999, gettext("%s: Error in getting rhs argument.\n"), fname);
@@ -102,7 +102,7 @@ int sci_XMLList_insertion(char * fname, unsigned long fname_len)
         delete b;
     }
 
-    if (a->createOnStack(Rhs + 1))
+    if (a->createOnStack(Rhs + 1, pvApiCtx))
     {
         LhsVar(1) = Rhs + 1;
     }
index 633fb04..1a02cfa 100644 (file)
@@ -38,11 +38,11 @@ namespace org_modules_xml
         return scope->getVariableFromId(id);
     }
 
-    int XMLObject::createOnStack(int pos) const
+    int XMLObject::createOnStack(int pos, void* pvApiCtx) const
     {
         if (scilabType != -1)
         {
-            return createXMLObjectAtPos(scilabType, pos, id);
+            return createXMLObjectAtPos(scilabType, pos, id, pvApiCtx);
         }
 
         return 0;
index c583074..af08b7e 100644 (file)
@@ -74,7 +74,7 @@ namespace org_modules_xml
          * @param pos the stack position
          * @return 1 if all is ok, else 0
          */
-        int createOnStack(int pos) const;
+        int createOnStack(int pos, void* pvApiCtx) const;
 
         /**
          * @param id the object id
index f22795d..2ff6c6b 100644 (file)
@@ -44,32 +44,32 @@ namespace org_modules_xml
          * @param obj a pointer to the object to retrieve
          * @return true if all is ok
          */
-        static bool get(char * fname, int * addr, XMLDocument ** obj) { return get<XMLDocument>(fname, addr, obj); }
+        static bool get(char * fname, int * addr, XMLDocument ** obj, void* pvApiCtx) { return get<XMLDocument>(fname, addr, obj, pvApiCtx); }
 
         /**
          * @ref get
          */
-        static bool get(char * fname, int * addr, XMLElement ** obj) { return get<XMLElement>(fname, addr, obj); }
+        static bool get(char * fname, int * addr, XMLElement ** obj, void* pvApiCtx) { return get<XMLElement>(fname, addr, obj, pvApiCtx); }
 
         /**
          * @ref get
          */
-        static bool get(char * fname, int * addr, XMLAttr ** obj) { return get<XMLAttr>(fname, addr, obj); }
+        static bool get(char * fname, int * addr, XMLAttr ** obj, void* pvApiCtx) { return get<XMLAttr>(fname, addr, obj, pvApiCtx); }
 
         /**
          * @ref get
          */
-        static bool get(char * fname, int * addr, XMLNs ** obj) { return get<XMLNs>(fname, addr, obj); }
+        static bool get(char * fname, int * addr, XMLNs ** obj, void* pvApiCtx) { return get<XMLNs>(fname, addr, obj, pvApiCtx); }
 
         /**
          * @ref get
          */
-        static bool get(char * fname, int * addr, XMLNodeList ** obj) { return get<XMLNodeList>(fname, addr, obj); }
+        static bool get(char * fname, int * addr, XMLNodeList ** obj, void* pvApiCtx) { return get<XMLNodeList>(fname, addr, obj, pvApiCtx); }
 
         /**
          * @ref get
          */
-        static bool get(char * fname, int * addr, std::string ** obj)
+        static bool get(char * fname, int * addr, std::string ** obj, void* pvApiCtx)
             {
                 char ** str = 0;
                 int row = 0;
@@ -105,9 +105,9 @@ namespace org_modules_xml
          * @ref get
          */
         template <class T>
-        static bool get(char * fname, int * addr, T ** obj)
+        static bool get(char * fname, int * addr, T ** obj, void* pvApiCtx)
             {
-                int id = getXMLObjectId(addr);
+                int id = getXMLObjectId(addr, pvApiCtx);
                 *obj = XMLObject::getFromId<T>(id);
                 if (!*obj)
                 {
index e7c3bc9..4b0c392 100644 (file)
@@ -46,7 +46,7 @@ using namespace org_modules_xml;
  * @param pos the stack position
  * @return 1 if all is ok, else 0
  */
-int createStringOnStack(char * fname, const char * str, int pos)
+int createStringOnStack(char * fname, const char * str, int pos, void* pvApiCtx)
 {
     SciErr err;
 
@@ -101,15 +101,15 @@ int createStringOnStack(char * fname, const char * str, int pos)
  * @param pos the stack position
  * @return 1 if all is ok, else 0
  */
-int createVariableOnStack(char * fname, org_modules_xml::XMLDocument & doc, const char * field, int pos)
+int createVariableOnStack(char * fname, org_modules_xml::XMLDocument & doc, const char * field, int pos, void* pvApiCtx)
 {
     if (!strcmp("root", field))
     {
-        return doc.getRoot()->createOnStack(pos);
+        return doc.getRoot()->createOnStack(pos, pvApiCtx);
     }
     else if (!strcmp("url", field))
     {
-        return createStringOnStack(fname, doc.getDocumentURL(), pos);
+        return createStringOnStack(fname, doc.getDocumentURL(), pos, pvApiCtx);
     }
     else
     {
@@ -127,18 +127,18 @@ int createVariableOnStack(char * fname, org_modules_xml::XMLDocument & doc, cons
  * @param pos the stack position
  * @return 1 if all is ok, else 0
  */
-int createVariableOnStack(char * fname, XMLElement & elem, const char * field, int pos)
+int createVariableOnStack(char * fname, XMLElement & elem, const char * field, int pos, void* pvApiCtx)
 {
     if (!strcmp("name", field))
     {
-        return createStringOnStack(fname, elem.getNodeName(), pos);
+        return createStringOnStack(fname, elem.getNodeName(), pos, pvApiCtx);
     }
     else if (!strcmp("namespace", field))
     {
         const XMLNs * ns = elem.getNodeNameSpace();
         if (ns)
         {
-            return ns->createOnStack(pos);
+            return ns->createOnStack(pos, pvApiCtx);
         }
         else
         {
@@ -149,20 +149,20 @@ int createVariableOnStack(char * fname, XMLElement & elem, const char * field, i
     else if (!strcmp("content", field))
     {
         const char * content = elem.getNodeContent();
-        int ret = createStringOnStack(fname, content, pos);
+        int ret = createStringOnStack(fname, content, pos, pvApiCtx);
         xmlFree(const_cast<char *>(content));
         return ret;
     }
     else if (!strcmp("type", field))
     {
-        return createStringOnStack(fname, nodes_type[elem.getNodeType() - 1], pos);
+        return createStringOnStack(fname, nodes_type[elem.getNodeType() - 1], pos, pvApiCtx);
     }
     else if (!strcmp("parent", field))
     {
         const XMLElement * parent = elem.getParentElement();
         if (parent)
         {
-            return parent->createOnStack(pos);
+            return parent->createOnStack(pos, pvApiCtx);
         }
         else
         {
@@ -172,11 +172,11 @@ int createVariableOnStack(char * fname, XMLElement & elem, const char * field, i
     }
     else if (!strcmp("attributes", field))
     {
-        return elem.getAttributes()->createOnStack(pos);
+        return elem.getAttributes()->createOnStack(pos, pvApiCtx);
     }
     else if (!strcmp("children", field))
     {
-        return elem.getChildren()->createOnStack(pos);
+        return elem.getChildren()->createOnStack(pos, pvApiCtx);
     }
     else
     {
@@ -194,15 +194,15 @@ int createVariableOnStack(char * fname, XMLElement & elem, const char * field, i
  * @param pos the stack position
  * @return 1 if all is ok, else 0
  */
-int createVariableOnStack(char * fname, XMLNs & ns, const char * field, int pos)
+int createVariableOnStack(char * fname, XMLNs & ns, const char * field, int pos, void* pvApiCtx)
 {
     if (!strcmp("href", field))
     {
-        return createStringOnStack(fname, ns.getHref(), pos);
+        return createStringOnStack(fname, ns.getHref(), pos, pvApiCtx);
     }
     else if (!strcmp("prefix", field))
     {
-        return createStringOnStack(fname, ns.getPrefix(), pos);
+        return createStringOnStack(fname, ns.getPrefix(), pos, pvApiCtx);
     }
     else
     {
@@ -218,7 +218,7 @@ int createVariableOnStack(char * fname, XMLNs & ns, const char * field, int pos)
  * @param fname_len the function name length
  */
 template<class T>
-int sci_extraction(char * fname, unsigned long fname_len)
+int sci_extraction(char * fname, void *pvApiCtx)
 {
     T * t;
     int id;
@@ -252,7 +252,7 @@ int sci_extraction(char * fname, unsigned long fname_len)
     }
 
     getAllocatedSingleString(pvApiCtx, fieldaddr, &field);
-    id = getXMLObjectId(mlistaddr);
+    id = getXMLObjectId(mlistaddr, pvApiCtx);
 
     t = XMLObject::getFromId<T>(id);
     if (!t)
@@ -262,7 +262,7 @@ int sci_extraction(char * fname, unsigned long fname_len)
         return 0;
     }
 
-    ret = createVariableOnStack(fname, *t, const_cast<char *>(field), Rhs + 1);
+    ret = createVariableOnStack(fname, *t, const_cast<char *>(field), Rhs + 1, pvApiCtx);
     freeAllocatedSingleString(field);
     if (ret)
     {
index 9ed65a4..1b5697d 100644 (file)
@@ -161,7 +161,7 @@ bool setProperty(char * fname, XMLElement & elem, const char * field, T & value)
  * @param fname_len the function name length
  */
 template<class T, class U>
-int sci_insertion(char * fname, unsigned long fname_len)
+int sci_insertion(char * fname, void* pvApiCtx)
 {
     T * a;
     U * b;
@@ -204,7 +204,7 @@ int sci_insertion(char * fname, unsigned long fname_len)
     }
 
     getAllocatedSingleString(pvApiCtx, fieldaddr, &field);
-    lhsid = getXMLObjectId(lhsaddr);
+    lhsid = getXMLObjectId(lhsaddr, pvApiCtx);
 
     a = XMLObject::getFromId<T>(lhsid);
     if (!a)
@@ -214,7 +214,7 @@ int sci_insertion(char * fname, unsigned long fname_len)
         return 0;
     }
 
-    success = XMLRhsValue::get(fname, rhsaddr, &b);
+    success = XMLRhsValue::get(fname, rhsaddr, &b, pvApiCtx);
     if (!success)
     {
         freeAllocatedSingleString(field);
@@ -230,7 +230,7 @@ int sci_insertion(char * fname, unsigned long fname_len)
         delete b;
     }
 
-    if (a->createOnStack(Rhs + 1))
+    if (a->createOnStack(Rhs + 1, pvApiCtx))
     {
         LhsVar(1) = Rhs + 1;
     }