Cleanups

libcomps/src/comps_parse.c

@@ -130,7 +130,7 @@ void comps_parse_start_doctype(void *userData,
                                const XML_Char *doctypeName,
                                const XML_Char *sysid,
                                const XML_Char *pubid,
-                               int standalone) {
+                               int standalone __attribute__((unused))) {
     #define parsed ((COMPS_Parsed*)userData)
     parsed->doctype_name = comps_str(doctypeName);
     parsed->doctype_sysid = comps_str(sysid);
@@ -143,7 +143,7 @@ int comps_parse_validate_dtd(char *filename, char *dtd_file) {
     xmlDtdPtr dtd_ptr;
     xmlValidCtxtPtr vctxt;
     int ret;
-    xmlErrorPtr err;
+    const xmlError *err;
 
     fptr = xmlReadFile(filename, NULL, 0);
     if (fptr == NULL) {

libcomps/src/python/src/pycomps.c

@@ -198,7 +198,7 @@ void pycomps_clear(PyObject *self) {
     COMPS_OBJECT_DESTROY(((PyCOMPS*)self)->comps_doc);
 }
 
-PyObject* PyCOMPS_clear(PyObject *self) {
+PyObject* PyCOMPS_clear(PyObject *self, PyObject *args __attribute__((unused))) {
 
     COMPS_Str *enc;
     enc = (COMPS_Str*)
@@ -772,27 +772,27 @@ PyDoc_STRVAR(PyCOMPS_arch_filter__doc__,
              ":return: new :py:class:`libcomps.Comps` instace");
 
 static PyMethodDef PyCOMPS_methods[] = {
-    {"groups_match", (PyCFunction)PyCOMPS_groups_match, METH_VARARGS | METH_KEYWORDS,
+    {"groups_match", _PyCFunction_CAST(PyCOMPS_groups_match), METH_VARARGS | METH_KEYWORDS,
     PyCOMPS_validate__doc__},
-    {"categories_match", (PyCFunction)PyCOMPS_categories_match, METH_VARARGS | METH_KEYWORDS,
+    {"categories_match", _PyCFunction_CAST(PyCOMPS_categories_match), METH_VARARGS | METH_KEYWORDS,
     PyCOMPS_validate__doc__},
-    {"environments_match", (PyCFunction)PyCOMPS_envs_match, METH_VARARGS | METH_KEYWORDS,
+    {"environments_match", _PyCFunction_CAST(PyCOMPS_envs_match), METH_VARARGS | METH_KEYWORDS,
     PyCOMPS_validate__doc__},
-    {"validate", (PyCFunction)PyCOMPS_validate, METH_NOARGS,
+    {"validate", _PyCFunction_CAST(PyCOMPS_validate), METH_NOARGS,
     PyCOMPS_validate__doc__},
-    {"validate_nf", (PyCFunction)PyCOMPS_validate_nf, METH_NOARGS,
+    {"validate_nf", _PyCFunction_CAST(PyCOMPS_validate_nf), METH_NOARGS,
     PyCOMPS_validate_nf__doc__},
-    {"xml_f", (PyCFunction)PyCOMPS_toxml_f, METH_VARARGS | METH_KEYWORDS,
+    {"xml_f", _PyCFunction_CAST(PyCOMPS_toxml_f), METH_VARARGS | METH_KEYWORDS,
     PyCOMPS_xml_f__doc__},
-    {"xml_str", (PyCFunction)PyCOMPS_toxml_str, METH_VARARGS | METH_KEYWORDS,
+    {"xml_str", _PyCFunction_CAST(PyCOMPS_toxml_str), METH_VARARGS | METH_KEYWORDS,
     PyCOMPS_xml_str__doc__},
-    {"toxml_f", (PyCFunction)PyCOMPS_toxml_f, METH_VARARGS | METH_KEYWORDS,
+    {"toxml_f", _PyCFunction_CAST(PyCOMPS_toxml_f), METH_VARARGS | METH_KEYWORDS,
     PyCOMPS_toxml_f__doc__},
-    {"toxml_str", (PyCFunction)PyCOMPS_toxml_str, METH_VARARGS | METH_KEYWORDS,
+    {"toxml_str", _PyCFunction_CAST(PyCOMPS_toxml_str), METH_VARARGS | METH_KEYWORDS,
     PyCOMPS_toxml_str__doc__},
-    {"fromxml_f", (PyCFunction)PyCOMPS_fromxml_f, METH_VARARGS | METH_KEYWORDS,
+    {"fromxml_f", _PyCFunction_CAST(PyCOMPS_fromxml_f), METH_VARARGS | METH_KEYWORDS,
     PyCOMPS_fromxml_f__doc__},
-    {"fromxml_str", (PyCFunction)PyCOMPS_fromxml_str, METH_VARARGS | METH_KEYWORDS,
+    {"fromxml_str", _PyCFunction_CAST(PyCOMPS_fromxml_str), METH_VARARGS | METH_KEYWORDS,
     PyCOMPS_fromxml_str__doc__},
     {"clear", (PyCFunction)PyCOMPS_clear, METH_NOARGS,
     "Clear Comps"},
@@ -928,7 +928,7 @@ PyTypeObject PyCOMPS_Type = {
     0,                         /* tp_alloc */
     PyCOMPS_new,                /* tp_new */};
 
-PyObject* Libcomps_xml_default(PyObject *self) {
+PyObject* Libcomps_xml_default(PyObject *self, PyObject *args __attribute__((unused))) {
     const char *keys[] = {"empty_groups", "empty_categories",
                           "empty_environments", "empty_langpacks",
                           "empty_blacklist", "empty_whiteout",

libcomps/src/python/src/pycomps_categories.c

@@ -199,7 +199,7 @@ PyMemberDef PyCOMPSCat_members[] = {
     {NULL}};
 
 PyMethodDef PyCOMPSCat_methods[] = {
-    {"validate", (PyCFunction)PyCOMPSCat_validate, METH_NOARGS,
+    {"validate", _PyCFunction_CAST(PyCOMPSCat_validate), METH_NOARGS,
     "validate inner category structure"},
     {NULL}  /* Sentinel */
 };

libcomps/src/python/src/pycomps_dict.c

@@ -391,15 +391,15 @@ PyMethodDef PyCOMPSDict_methods[] = {
      {"get", (PyCFunction)PyCOMPSDict_get_, METH_O, PyCOMPSDict_get__doc__},
      {"has_key", (PyCFunction)PyCOMPSDict_has_key, METH_O,
        PyCOMPSDict_has_key__doc__},
-     {"items", (PyCFunction)PyCOMPSDict_getiteritems, METH_NOARGS,
+     {"items", _PyCFunction_CAST(PyCOMPSDict_getiteritems), METH_NOARGS,
      "return iterator returning (key, value) tuple"},
-     {"values", (PyCFunction)PyCOMPSDict_getitervalues, METH_NOARGS,
+     {"values", _PyCFunction_CAST(PyCOMPSDict_getitervalues), METH_NOARGS,
      "return iterator returning item's value"},
-     {"keys", (PyCFunction)PyCOMPSDict_getiter, METH_NOARGS,
+     {"keys", _PyCFunction_CAST(PyCOMPSDict_getiter), METH_NOARGS,
      "return iterator returning item's key"},
-     {"clear", (PyCFunction)PyCOMPSDict_clear, METH_NOARGS,
+     {"clear", _PyCFunction_CAST(PyCOMPSDict_clear), METH_NOARGS,
      "clear the dict"},
-     {"copy", (PyCFunction)PyCOMPSDict_copy, METH_NOARGS,
+     {"copy", _PyCFunction_CAST(PyCOMPSDict_copy), METH_NOARGS,
      "return shallow copy of dict"},
      {"update", (PyCFunction)PyCOMPSDict_update, METH_O,
       PyCOMPSDict_update__doc__},

libcomps/src/python/src/pycomps_envs.c

@@ -165,7 +165,7 @@ PyMemberDef PyCOMPSEnv_members[] = {
     {NULL}};
 
 PyMethodDef PyCOMPSEnv_methods[] = {
-    {"validate", (PyCFunction)PyCOMPSEnv_validate, METH_NOARGS,
+    {"validate", _PyCFunction_CAST(PyCOMPSEnv_validate), METH_NOARGS,
     PyCOMPS_env_validate__doc__},
     {NULL}  /* Sentinel */
 };

libcomps/src/python/src/pycomps_gids.c

@@ -196,7 +196,7 @@ PyMemberDef PyCOMPSGID_members[] = {
     {NULL}};
 
 PyMethodDef PyCOMPSGID_methods[] = {
-    {"validate", (PyCFunction)PyCOMPSGID_validate, METH_NOARGS,
+    {"validate", _PyCFunction_CAST(PyCOMPSGID_validate), METH_NOARGS,
     "validate inner Group ID structure"},
     {NULL}  /* Sentinel */
 };

libcomps/src/python/src/pycomps_groups.c

@@ -210,9 +210,9 @@ PyDoc_STRVAR(PyCOMPS_group_packages_match__doc__,
              ":return: List of packages\n\n");
 
 PyMethodDef PyCOMPSGroup_methods[] = {
-    {"validate", (PyCFunction)PyCOMPSGroup_validate, METH_NOARGS,
+    {"validate", _PyCFunction_CAST(PyCOMPSGroup_validate), METH_NOARGS,
      PyCOMPS_group_validate__doc__},
-    {"packages_match", (PyCFunction)PyCOMPSGroup_packages_match,
+    {"packages_match", _PyCFunction_CAST(PyCOMPSGroup_packages_match),
      METH_VARARGS | METH_KEYWORDS,
      PyCOMPS_group_packages_match__doc__},
     {NULL}  /* Sentinel */
@@ -842,7 +842,7 @@ PyDoc_STRVAR(PyCOMPS_package_validate__doc__,
              ":raises ValueError: on first occured error");
 
 PyMethodDef PyCOMPSPack_methods[] = {
-    {"validate", (PyCFunction)PyCOMPSPackage_validate, METH_NOARGS,
+    {"validate", _PyCFunction_CAST(PyCOMPSPackage_validate), METH_NOARGS,
     PyCOMPS_package_validate__doc__},
     {NULL}  /* Sentinel */
 };

libcomps/src/python/src/pycomps_mdict.c

@@ -166,11 +166,11 @@ PyObject* PyCOMPSMDict_cmp(PyObject *self, PyObject *other, int op) {
 Py_ssize_t PyCOMPSMDict_len(PyObject *self) {
     return ((PyCOMPS_MDict*)self)->dict->len;
 }
-PyObject* PyCOMPSMDict_clear(PyObject *self) {
+PyObject* PyCOMPSMDict_clear(PyObject *self, PyObject *args __attribute__((unused))) {
     comps_objmrtree_clear(((PyCOMPS_MDict*)self)->dict);
     Py_RETURN_NONE;
 }
-PyObject* PyCOMPSMDict_copy(PyObject *self) {
+PyObject* PyCOMPSMDict_copy(PyObject *self, PyObject *args __attribute__((unused))) {
     PyObject *ret;
     ret = PyCOMPSDict_new(Py_TYPE(self), NULL, NULL);
     Py_TYPE(self)->tp_init(ret, NULL, NULL);
@@ -411,15 +411,15 @@ PyMethodDef PyCOMPSMDict_methods[] = {
      {"get", (PyCFunction)PyCOMPSMDict_get, METH_O, PyCOMPSMDict_get__doc__},
      {"has_key", (PyCFunction)PyCOMPSMDict_has_key, METH_O,
      PyCOMPSMDict_has_key__doc__},
-     {"items", (PyCFunction)PyCOMPSMDict_getiteritems, METH_NOARGS,
+     {"items", _PyCFunction_CAST(PyCOMPSMDict_getiteritems), METH_NOARGS,
      "return iterator returning (key, value) tuple"},
-     {"values", (PyCFunction)PyCOMPSMDict_getitervalues, METH_NOARGS,
+     {"values", _PyCFunction_CAST(PyCOMPSMDict_getitervalues), METH_NOARGS,
      "return iterator returning item's value"},
-     {"keys", (PyCFunction)PyCOMPSMDict_getiter, METH_NOARGS,
+     {"keys", _PyCFunction_CAST(PyCOMPSMDict_getiter), METH_NOARGS,
      "return iterator returning item's key"},
-     {"clear", (PyCFunction)PyCOMPSMDict_clear, METH_NOARGS,
+     {"clear", _PyCFunction_CAST(PyCOMPSMDict_clear), METH_NOARGS,
      "clear the dict"},
-     {"copy", (PyCFunction)PyCOMPSMDict_copy, METH_NOARGS,
+     {"copy", _PyCFunction_CAST(PyCOMPSMDict_copy), METH_NOARGS,
      "return shallow copy of dict"},
      {"update", (PyCFunction)PyCOMPSMDict_update, METH_O,
       PyCOMPSMDict_update__doc__},

libcomps/src/python/src/pycomps_sequence.c

@@ -90,7 +90,7 @@ inline PyObject* list_getitem_byid(PyObject *self, PyObject *id) {
     #undef _seq_
 }
 
-inline COMPS_Object *list_setitem_convert(PyObject *self, PyObject *item) {
+static inline COMPS_Object *list_setitem_convert(PyObject *self, PyObject *item) {
     #define _seq_ ((PyCOMPS_Sequence*)self)
     COMPS_Object *ret = NULL;
     if (!item)
@@ -643,7 +643,7 @@ PyMethodDef PyCOMPSSeq_methods[] = {
      "Append item to new of the list"},
      {"remove", (PyCFunction)PyCOMPSSeq_remove, METH_O,
      PyCOMPSSeq_remove__doc__},
-     {"clear", (PyCFunction)PyCOMPSSeq_clear, METH_NOARGS,
+     {"clear", _PyCFunction_CAST(PyCOMPSSeq_clear), METH_NOARGS,
      "Clear the list"},
      {"insert", (PyCFunction)PyCOMPSSeq_insert, METH_VARARGS,
      PyCOMPSSeq_insert__doc__},

libcomps/tests/check_comps.c

@@ -87,23 +87,20 @@ START_TEST(test_comps_doc_basic)
         comps_doc_add_category(doc, c);
     }
     tmplist = comps_doc_groups(doc);
-    fail_if(tmplist->len == 0, "No groups found");
+    ck_assert_msg(tmplist->len != 0, "No groups found");
     g = (COMPS_DocGroup*)tmplist->first->comps_obj;
     COMPS_OBJECT_DESTROY(tmplist);
 
     tmplist = comps_doc_get_groups(doc, "g1", NULL, NULL, NULL, 0);
-    fail_if(tmplist->len == 0, "Group with id 'g1' should be in groups, but"
-                               "cant get it");
+    ck_assert_msg(tmplist->len != 0, "Group with id 'g1' should be in groups, but cant get it");
     g = (COMPS_DocGroup*)tmplist->first->comps_obj;
     COMPS_OBJECT_DESTROY(tmplist);
 
     tmplist = comps_docgroup_get_packages(g, NULL, COMPS_PACKAGE_OPTIONAL);
-    fail_if(tmplist->len != 4, "Group with id 'g1' should have 4 optional "
-                               "packages. But have %d.", tmplist->len);
+    ck_assert_msg(tmplist->len == 4, "Group with id 'g1' should have 4 optional packages. But have %lu.", tmplist->len);
     COMPS_OBJECT_DESTROY(tmplist);
     tmplist = comps_docgroup_get_packages(g, NULL, COMPS_PACKAGE_MANDATORY);
-    fail_if(tmplist->len != 4, "Group with id 'g1' should have 4 optional "
-                               "packages. But have %d.", tmplist->len);
+    ck_assert_msg(tmplist->len == 4, "Group with id 'g1' should have 4 optional packages. But have %lu.", tmplist->len);
     COMPS_OBJECT_DESTROY(tmplist);
     COMPS_OBJECT_DESTROY(doc);
 }END_TEST
@@ -276,22 +273,18 @@ START_TEST(test_comps_doc_setfeats)
     g1 = (COMPS_DocGroup*)list->first->comps_obj;
     g2 = (COMPS_DocGroup*)list->first->next->comps_obj;
     g = comps_docgroup_union(g1, g2);
-    fail_if(g->packages->len != 14, "Union of (g1 v g2) should have 14 packages"
-            " have %d", g->packages->len);
+    ck_assert_msg(g->packages->len == 14, "Union of (g1 v g2) should have 14 packages have %lu", g->packages->len);
     COMPS_OBJECT_DESTROY(g);
     g = comps_docgroup_intersect(g1, g2);
-    fail_if(g->packages->len != 2, "Intersect of (g1 ^ g2) should have 2"
-            "packages, have %d", g->packages->len);
+    ck_assert_msg(g->packages->len == 2, "Intersect of (g1 ^ g2) should have 2 packages, have %lu", g->packages->len);
     COMPS_OBJECT_DESTROY(g);
     g1 = (COMPS_DocGroup*)list->first->next->comps_obj;
     g2 = (COMPS_DocGroup*)list->first->next->next->comps_obj;
     g = comps_docgroup_union(g1, g2);
-    fail_if(g->packages->len != 16, "Union of (g2 v g3) should have 16 packages"
-            " have %d", g->packages->len);
+    ck_assert_msg(g->packages->len == 16, "Union of (g2 v g3) should have 16 packages have %lu", g->packages->len);
     COMPS_OBJECT_DESTROY(g);
     g = comps_docgroup_intersect(g1, g2);
-    fail_if(g->packages->len != 0, "Intersect of (g2 ^ g3) should have 0"
-            "packages, have %d", g->packages->len);
+    ck_assert_msg(g->packages->len == 0, "Intersect of (g2 ^ g3) should have 0 packages, have %lu", g->packages->len);
     COMPS_OBJECT_DESTROY(g);
     COMPS_OBJECT_DESTROY(list);
     list = comps_doc_categories(doc);
@@ -300,85 +293,67 @@ START_TEST(test_comps_doc_setfeats)
 
     c = comps_doccategory_union(c1, c2);
     //print_category(c);
-    fail_if(c->group_ids->len != 4, "Union of (c1 v c2) should have 4 "
-            "group ids, have %d", c->group_ids->len);
+    ck_assert_msg(c->group_ids->len == 4, "Union of (c1 v c2) should have 4 group ids, have %lu", c->group_ids->len);
     COMPS_OBJECT_DESTROY(c);
 
     c = comps_doccategory_intersect(c1, c2);
-    fail_if(c->group_ids->len != 2, "Intersect of (c1 ^ c2) should have 2"
-            "group ids, have %d", c->group_ids->len);
+    ck_assert_msg(c->group_ids->len == 2, "Intersect of (c1 ^ c2) should have 2 group ids, have %lu", c->group_ids->len);
     COMPS_OBJECT_DESTROY(c);
 
     c1 = (COMPS_DocCategory*)list->first->next->comps_obj;
     c2 = (COMPS_DocCategory*)list->first->next->next->comps_obj;
     c = comps_doccategory_union(c1, c2);
-    fail_if(c->group_ids->len != 4, "Union of (c2 v c3) should have 4 "
-            "group ids, have %d", c->group_ids->len);
+    ck_assert_msg(c->group_ids->len == 4, "Union of (c2 v c3) should have 4 group ids, have %lu", c->group_ids->len);
     COMPS_OBJECT_DESTROY(c);
     c = comps_doccategory_intersect(c1, c2);
-    fail_if(c->group_ids->len != 2, "Intersect of (c2 ^ c3) should have 2"
-            "group ids, have %d", c->group_ids->len);
+    ck_assert_msg(c->group_ids->len == 2, "Intersect of (c2 ^ c3) should have 2 group ids, have %lu", c->group_ids->len);
     COMPS_OBJECT_DESTROY(c);
     COMPS_OBJECT_DESTROY(list);
 
     list = comps_doc_environments(doc);
     e1 = (COMPS_DocEnv*)list->first->comps_obj;
     e2 = (COMPS_DocEnv*)list->first->next->comps_obj;
     e = comps_docenv_union(e1, e2);
-    fail_if(e->group_list->len != 4, "Union of (e1 v e2) should have 4 "
-            "groud ids have %d", e->group_list->len);
-    fail_if(e->option_list->len != 7, "Union of (e1 v e2) should have 7 "
-            "option ids have %d", e->option_list->len);
+    ck_assert_msg(e->group_list->len == 4, "Union of (e1 v e2) should have 4 groud ids have %lu", e->group_list->len);
+    ck_assert_msg(e->option_list->len == 7, "Union of (e1 v e2) should have 7 option ids have %lu", e->option_list->len);
     COMPS_OBJECT_DESTROY(e);
     e = comps_docenv_intersect(e1, e2);
-    fail_if(e->group_list->len != 2, "Intersect of (e1 ^ e2) should have 2"
-            "group ids have %d", e->group_list->len);
-    fail_if(e->option_list->len != 1, "Union of (e1 v e2) should have 1 "
-            "option ids have %d", e->option_list->len);
+    ck_assert_msg(e->group_list->len == 2, "Intersect of (e1 ^ e2) should have 2 group ids have %lu", e->group_list->len);
+    ck_assert_msg(e->option_list->len == 1, "Union of (e1 v e2) should have 1 option ids have %lu", e->option_list->len);
     COMPS_OBJECT_DESTROY(e);
 
     e1 = (COMPS_DocEnv*)list->first->next->comps_obj;
     e2 = (COMPS_DocEnv*)list->first->next->next->comps_obj;
     e = comps_docenv_union(e1, e2);
-    fail_if(e->group_list->len != 4, "Union of (e2 v e3) should have 4 "
-            "groud ids have %d", e->group_list->len);
-    fail_if(e->option_list->len != 6, "Union of (e2 v e3) should have 7 "
-            "option ids have %d", e->option_list->len);
+    ck_assert_msg(e->group_list->len == 4, "Union of (e2 v e3) should have 4 groud ids have %lu", e->group_list->len);
+    ck_assert_msg(e->option_list->len == 6, "Union of (e2 v e3) should have 7 option ids have %lu", e->option_list->len);
     COMPS_OBJECT_DESTROY(e);
     e = comps_docenv_intersect(e1, e2);
-    fail_if(e->group_list->len != 2, "Intersect of (e2 ^ e3) should have 2 "
-            "groupids  have %d", e->group_list->len);
-    fail_if(e->option_list->len != 2, "Intersect of (e2 v e3) should have 2 "
-            "option ids have %d", e->option_list->len);
+    ck_assert_msg(e->group_list->len == 2, "Intersect of (e2 ^ e3) should have 2 groupids have %lu", e->group_list->len);
+    ck_assert_msg(e->option_list->len == 2, "Intersect of (e2 v e3) should have 2 option ids have %lu", e->option_list->len);
     COMPS_OBJECT_DESTROY(e);
     COMPS_OBJECT_DESTROY(list);
 
     tmpdoc = comps_doc_union(doc, doc2);
     list = comps_doc_groups(tmpdoc);
-    fail_if(list->len != 6, "Union of (doc ^ doc2) should have 6 "
-            "groups  have %d", list->len);
+    ck_assert_msg(list->len == 6, "Union of (doc ^ doc2) should have 6 groups have %lu", list->len);
     COMPS_OBJECT_DESTROY(list);
     list = comps_doc_categories(tmpdoc);
-    fail_if(list->len != 4, "Union of (doc ^ doc2) "
-            "should have 4 categories  have %d", list->len);
+    ck_assert_msg(list->len == 4, "Union of (doc ^ doc2) should have 4 categories have %lu", list->len);
     COMPS_OBJECT_DESTROY(list);
     list = comps_doc_environments(tmpdoc);
-    fail_if(list->len != 4, "Union of (doc ^ doc2) "
-            "should have 4 environments  have %d", list->len);
+    ck_assert_msg(list->len == 4, "Union of (doc ^ doc2) should have 4 environments have %lu", list->len);
     COMPS_OBJECT_DESTROY(list);
     COMPS_OBJECT_DESTROY(tmpdoc);
     tmpdoc = comps_doc_intersect(doc, doc2);
     list = comps_doc_groups(tmpdoc);
-    fail_if(list->len != 2, "Intersect of (doc ^ doc2) "
-            "should have 2 groups  have %d", list->len);
+    ck_assert_msg(list->len == 2, "Intersect of (doc ^ doc2) should have 2 groups have %lu", list->len);
     COMPS_OBJECT_DESTROY(list);
     list = comps_doc_categories(tmpdoc);
-    fail_if(list->len != 2, "Intersect of (doc ^ doc2)"
-            " should have 2 categories  have %d", list->len);
+    ck_assert_msg(list->len == 2, "Intersect of (doc ^ doc2) should have 2 categories have %lu", list->len);
     COMPS_OBJECT_DESTROY(list);
     list = comps_doc_environments(tmpdoc);
-    fail_if(list->len != 2, "Intersect of "
-            "(doc ^ doc2) should have 2 environments  have %d", list->len);
+    ck_assert_msg(list->len == 2, "Intersect of (doc ^ doc2) should have 2 environments have %lu", list->len);
     COMPS_OBJECT_DESTROY(list);
     COMPS_OBJECT_DESTROY(tmpdoc);
     COMPS_OBJECT_DESTROY(doc2);