indenting entire file according to the rules stated in the very end of
authorMarc Cromme <marc@indexdata.dk>
Wed, 14 Feb 2007 16:31:37 +0000 (16:31 +0000)
committerMarc Cromme <marc@indexdata.dk>
Wed, 14 Feb 2007 16:31:37 +0000 (16:31 +0000)
the file, using emacs M-x indent-region, and manual line breaking afterwards

index/mod_dom.c

index 0d7a99d..5805efb 100644 (file)
@@ -1,22 +1,22 @@
-/* $Id: mod_dom.c,v 1.8 2007-02-14 16:16:15 marc Exp $
+/* $Id: mod_dom.c,v 1.9 2007-02-14 16:31:37 marc Exp $
    Copyright (C) 1995-2007
    Index Data ApS
 
-This file is part of the Zebra server.
+   This file is part of the Zebra server.
 
-Zebra is free software; you can redistribute it and/or modify it under
-the terms of the GNU General Public License as published by the Free
-Software Foundation; either version 2, or (at your option) any later
-version.
+   Zebra is free software; you can redistribute it and/or modify it under
+   the terms of the GNU General Public License as published by the Free
+   Software Foundation; either version 2, or (at your option) any later
+   version.
 
-Zebra is distributed in the hope that it will be useful, but WITHOUT ANY
-WARRANTY; without even the implied warranty of MERCHANTABILITY or
-FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-for more details.
+   Zebra is distributed in the hope that it will be useful, but WITHOUT ANY
+   WARRANTY; without even the implied warranty of MERCHANTABILITY or
+   FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+   for more details.
 
-You should have received a copy of the GNU General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
 */
 
@@ -154,68 +154,68 @@ static int attr_content(struct _xmlAttr *attr, const char *name,
 {
     if (!XML_STRCMP(attr->name, name) && attr->children 
         && attr->children->type == XML_TEXT_NODE)
-    {
-       *dst_content = (const char *)(attr->children->content);
-       return 1;
-    }
+        {
+            *dst_content = (const char *)(attr->children->content);
+            return 1;
+        }
     return 0;
 }
 
 static void destroy_xsp(struct convert_s *c)
 {
     while(c)
-    {
-        if (c->stylesheet_xsp)
-            xsltFreeStylesheet(c->stylesheet_xsp);
-        c = c->next;
-    }
+        {
+            if (c->stylesheet_xsp)
+                xsltFreeStylesheet(c->stylesheet_xsp);
+            c = c->next;
+        }
 }
 
 static void destroy_dom(struct filter_info *tinfo)
 {
     if (tinfo->extract)
-    {
-        destroy_xsp(tinfo->extract->convert);
-        tinfo->extract = 0;
-    }
+        {
+            destroy_xsp(tinfo->extract->convert);
+            tinfo->extract = 0;
+        }
     if (tinfo->store)
-    {
-        destroy_xsp(tinfo->store->convert);
-        tinfo->store = 0;
-    }
+        {
+            destroy_xsp(tinfo->store->convert);
+            tinfo->store = 0;
+        }
     if (tinfo->input_list)
-    {
-        struct filter_input *i_ptr;
-        for (i_ptr = tinfo->input_list; i_ptr; i_ptr = i_ptr->next)
         {
-            switch(i_ptr->type)
-            {
-            case DOM_INPUT_XMLREADER:
-                if (i_ptr->u.xmlreader.reader)
-                    xmlFreeTextReader(i_ptr->u.xmlreader.reader);
-                break;
-            case DOM_INPUT_MARC:
-                yaz_iconv_close(i_ptr->u.marc.iconv);
-                yaz_marc_destroy(i_ptr->u.marc.handle);
-                break;
-            }
-            destroy_xsp(i_ptr->convert);
+            struct filter_input *i_ptr;
+            for (i_ptr = tinfo->input_list; i_ptr; i_ptr = i_ptr->next)
+                {
+                    switch(i_ptr->type)
+                        {
+                        case DOM_INPUT_XMLREADER:
+                            if (i_ptr->u.xmlreader.reader)
+                                xmlFreeTextReader(i_ptr->u.xmlreader.reader);
+                            break;
+                        case DOM_INPUT_MARC:
+                            yaz_iconv_close(i_ptr->u.marc.iconv);
+                            yaz_marc_destroy(i_ptr->u.marc.handle);
+                            break;
+                        }
+                    destroy_xsp(i_ptr->convert);
+                }
+            tinfo->input_list = 0;
         }
-        tinfo->input_list = 0;
-    }
     if (tinfo->retrieve_list)
-    {
-        struct filter_retrieve *r_ptr;
-        for (r_ptr = tinfo->retrieve_list; r_ptr; r_ptr = r_ptr->next)
-            destroy_xsp(r_ptr->convert);
-        tinfo->retrieve_list = 0;
-    }
+        {
+            struct filter_retrieve *r_ptr;
+            for (r_ptr = tinfo->retrieve_list; r_ptr; r_ptr = r_ptr->next)
+                destroy_xsp(r_ptr->convert);
+            tinfo->retrieve_list = 0;
+        }
 
     if (tinfo->doc_config)
-    {
-        xmlFreeDoc(tinfo->doc_config);
-        tinfo->doc_config = 0;
-    }
+        {
+            xmlFreeDoc(tinfo->doc_config);
+            tinfo->doc_config = 0;
+        }
     odr_reset(tinfo->odr_config);
 }
 
@@ -224,68 +224,78 @@ static ZEBRA_RES parse_convert(struct filter_info *tinfo, xmlNodePtr ptr,
 {
     *l = 0;
     for(; ptr; ptr = ptr->next)
-    {
-        if (ptr->type != XML_ELEMENT_NODE)
-            continue;
-        if (!XML_STRCMP(ptr->name, "xslt"))
         {
-            struct _xmlAttr *attr;
-            struct convert_s *p = odr_malloc(tinfo->odr_config, sizeof(*p));
-
-            p->next = 0;
-            p->stylesheet = 0;
-            p->stylesheet_xsp = 0;
-
-            for (attr = ptr->properties; attr; attr = attr->next)
-                if (attr_content(attr, "stylesheet", &p->stylesheet))
-                    ;
-                else
-                    yaz_log(YLOG_WARN, "%s: dom filter: bad attribute %s"
-                            " for <xslt>",
-                            tinfo->fname, attr->name);
-            if (p->stylesheet)
-            {
-                char tmp_xslt_full_name[1024];
-                if (!yaz_filepath_resolve(p->stylesheet, tinfo->profile_path,
-                                          NULL, tmp_xslt_full_name))
+            if (ptr->type != XML_ELEMENT_NODE)
+                continue;
+            if (!XML_STRCMP(ptr->name, "xslt"))
                 {
-                    yaz_log(YLOG_WARN,
-                            "%s: dom filter: stylesheet %s not found in "
-                            "path %s",
-                            tinfo->fname,
-                            p->stylesheet, tinfo->profile_path);
-                    return ZEBRA_FAIL;
-                }
+                    struct _xmlAttr *attr;
+                    struct convert_s *p 
+                        = odr_malloc(tinfo->odr_config, sizeof(*p));
+
+                    p->next = 0;
+                    p->stylesheet = 0;
+                    p->stylesheet_xsp = 0;
+
+                    for (attr = ptr->properties; attr; attr = attr->next)
+                        if (attr_content(attr, "stylesheet", &p->stylesheet))
+                            ;
+                        else
+                            yaz_log(YLOG_WARN, "%s: dom filter: "
+                                    "bad attribute %s"
+                                    " for <xslt>",
+                                    tinfo->fname, attr->name);
+                    if (p->stylesheet)
+                        {
+                            char tmp_xslt_full_name[1024];
+                            if (!yaz_filepath_resolve(p->stylesheet, 
+                                                      tinfo->profile_path,
+                                                      NULL, 
+                                                      tmp_xslt_full_name))
+                                {
+                                    yaz_log(YLOG_WARN,
+                                            "%s: dom filter: "
+                                            "stylesheet %s not found in "
+                                            "path %s",
+                                            tinfo->fname,
+                                            p->stylesheet, 
+                                            tinfo->profile_path);
+                                    return ZEBRA_FAIL;
+                                }
                 
-                p->stylesheet_xsp
-                    = xsltParseStylesheetFile((const xmlChar*) tmp_xslt_full_name);
-                if (!p->stylesheet_xsp)
+                            p->stylesheet_xsp
+                                = xsltParseStylesheetFile((const xmlChar*) 
+                                                          tmp_xslt_full_name);
+                            if (!p->stylesheet_xsp)
+                                {
+                                    yaz_log(YLOG_WARN,
+                                            "%s: dom filter: "
+                                            "could not parse xslt "
+                                            "stylesheet %s",
+                                            tinfo->fname, tmp_xslt_full_name);
+                                    return ZEBRA_FAIL;
+                                }
+                        }
+                    else
+                        {
+                            yaz_log(YLOG_WARN,
+                                    "%s: dom filter: "
+                                    "missing attribute 'stylesheet' "
+                                    "for element 'xslt'", tinfo->fname);
+                            return ZEBRA_FAIL;
+                        }
+                    *l = p;
+                    l = &p->next;
+                }
+            else
                 {
-                    yaz_log(YLOG_WARN,
-                            "%s: dom filter: could not parse xslt "
-                            "stylesheet %s",
-                            tinfo->fname, tmp_xslt_full_name);
+                    yaz_log(YLOG_LOG, 
+                            "%s: dom filter: bad node '%s' for <conv>",
+                            tinfo->fname, ptr->name);
                     return ZEBRA_FAIL;
                 }
-            }
-            else
-            {
-                yaz_log(YLOG_WARN,
-                        "%s: dom filter: missing attribute 'stylesheet' "
-                        "for element 'xslt'", tinfo->fname);
-                return ZEBRA_FAIL;
-            }
-            *l = p;
-            l = &p->next;
-        }
-        else
-        {
-            yaz_log(YLOG_LOG, "%s: dom filter: bad node '%s' for <conv>",
-                    tinfo->fname, ptr->name);
-            return ZEBRA_FAIL;
-        }
         
-    }
+        }
     return ZEBRA_OK;
 }
 
@@ -296,14 +306,14 @@ static ZEBRA_RES perform_convert(struct filter_info *tinfo,
                                  xsltStylesheetPtr *last_xsp)
 {
     for (; convert; convert = convert->next)
-    {
-        xmlDocPtr res_doc = xsltApplyStylesheet(convert->stylesheet_xsp,
-                                               *doc, params);
-        if (last_xsp)
-            *last_xsp = convert->stylesheet_xsp;
-        xmlFreeDoc(*doc);
-        *doc = res_doc;
-    }
+        {
+            xmlDocPtr res_doc = xsltApplyStylesheet(convert->stylesheet_xsp,
+                                                    *doc, params);
+            if (last_xsp)
+                *last_xsp = convert->stylesheet_xsp;
+            xmlFreeDoc(*doc);
+            *doc = res_doc;
+        }
     return ZEBRA_OK;
 }
 
@@ -327,80 +337,85 @@ static ZEBRA_RES parse_input(struct filter_info *tinfo, xmlNodePtr ptr,
                              const char *name)
 {
     for (; ptr; ptr = ptr->next)
-    {
-        if (ptr->type != XML_ELEMENT_NODE)
-            continue;
-        if (!XML_STRCMP(ptr->name, "marc"))
         {
-            yaz_iconv_t iconv = 0;
-            const char *input_charset = "marc-8";
-           struct _xmlAttr *attr;
+            if (ptr->type != XML_ELEMENT_NODE)
+                continue;
+            if (!XML_STRCMP(ptr->name, "marc"))
+                {
+                    yaz_iconv_t iconv = 0;
+                    const char *input_charset = "marc-8";
+                    struct _xmlAttr *attr;
             
-           for (attr = ptr->properties; attr; attr = attr->next)
-           {
-               if (attr_content(attr, "charset", &input_charset))
-                    ;
-                else
-                    yaz_log(YLOG_WARN, "%s: dom filter: bad attribute %s"
-                            " for <marc>",
-                            tinfo->fname, attr->name);
-           }
-            iconv = yaz_iconv_open("utf-8", input_charset);
-            if (!iconv)
-            {
-                yaz_log(YLOG_WARN, "%s: dom filter: unsupported charset "
-                        "'%s' for <marc>", 
-                        tinfo->fname,  input_charset);
-                return ZEBRA_FAIL;
-            }
-            else
-            {
-                struct filter_input *p = new_input(tinfo, DOM_INPUT_MARC);
-                p->u.marc.handle = yaz_marc_create();
-                p->u.marc.iconv = iconv;
+                    for (attr = ptr->properties; attr; attr = attr->next)
+                        {
+                            if (attr_content(attr, "charset", &input_charset))
+                                ;
+                            else
+                                yaz_log(YLOG_WARN, 
+                                        "%s: dom filter: bad attribute %s"
+                                        " for <marc>",
+                                        tinfo->fname, attr->name);
+                        }
+                    iconv = yaz_iconv_open("utf-8", input_charset);
+                    if (!iconv)
+                        {
+                            yaz_log(YLOG_WARN, 
+                                    "%s: dom filter: unsupported charset "
+                                    "'%s' for <marc>", 
+                                    tinfo->fname,  input_charset);
+                            return ZEBRA_FAIL;
+                        }
+                    else
+                        {
+                            struct filter_input *p 
+                                = new_input(tinfo, DOM_INPUT_MARC);
+                            p->u.marc.handle = yaz_marc_create();
+                            p->u.marc.iconv = iconv;
                 
-                yaz_marc_iconv(p->u.marc.handle, p->u.marc.iconv);
+                            yaz_marc_iconv(p->u.marc.handle, p->u.marc.iconv);
                 
-                ptr = ptr->next;
+                            ptr = ptr->next;
                 
-                parse_convert(tinfo, ptr, &p->convert);
-            }
-            break;
-
-        }
-        else if (!XML_STRCMP(ptr->name, "xmlreader"))
-        {
-            struct filter_input *p = new_input(tinfo, DOM_INPUT_XMLREADER);
-           struct _xmlAttr *attr;
-            const char *level_str = 0;
+                            parse_convert(tinfo, ptr, &p->convert);
+                        }
+                    break;
 
-            p->u.xmlreader.split_level = 0;
-            p->u.xmlreader.reader = 0;
-
-           for (attr = ptr->properties; attr; attr = attr->next)
-           {
-               if (attr_content(attr, "level", &level_str))
-                    ;
-                else
-                    yaz_log(YLOG_WARN, "%s: dom filter: bad attribute %s"
-                            " for <xmlreader>",
-                            tinfo->fname, attr->name);
-           }
-            if (level_str)
-                p->u.xmlreader.split_level = atoi(level_str);
+                }
+            else if (!XML_STRCMP(ptr->name, "xmlreader"))
+                {
+                    struct filter_input *p 
+                        = new_input(tinfo, DOM_INPUT_XMLREADER);
+                    struct _xmlAttr *attr;
+                    const char *level_str = 0;
+
+                    p->u.xmlreader.split_level = 0;
+                    p->u.xmlreader.reader = 0;
+
+                    for (attr = ptr->properties; attr; attr = attr->next)
+                        {
+                            if (attr_content(attr, "level", &level_str))
+                                ;
+                            else
+                                yaz_log(YLOG_WARN, 
+                                        "%s: dom filter: bad attribute %s"
+                                        " for <xmlreader>",
+                                        tinfo->fname, attr->name);
+                        }
+                    if (level_str)
+                        p->u.xmlreader.split_level = atoi(level_str);
                 
-            ptr = ptr->next;
+                    ptr = ptr->next;
 
-            parse_convert(tinfo, ptr, &p->convert);
-            break;
-        }
-        else
-        {
-            yaz_log(YLOG_WARN, "%s: dom filter: bad input type %s",
-                    tinfo->fname, ptr->name);
-            return ZEBRA_FAIL;
+                    parse_convert(tinfo, ptr, &p->convert);
+                    break;
+                }
+            else
+                {
+                    yaz_log(YLOG_WARN, "%s: dom filter: bad input type %s",
+                            tinfo->fname, ptr->name);
+                    return ZEBRA_FAIL;
+                }
         }
-    }
     return ZEBRA_OK;
 }
 
@@ -422,138 +437,143 @@ static ZEBRA_RES parse_dom(struct filter_info *tinfo, const char *fname)
     
     doc = xmlParseFile(tinfo->full_name);
     if (!doc)
-    {
-        yaz_log(YLOG_WARN, "%s: dom filter: failed to parse config file %s",
-                tinfo->fname, tinfo->full_name);
-       return ZEBRA_FAIL;
-    }
+        {
+            yaz_log(YLOG_WARN, 
+                    "%s: dom filter: failed to parse config file %s",
+                    tinfo->fname, tinfo->full_name);
+            return ZEBRA_FAIL;
+        }
     /* save because we store ptrs to the content */ 
     tinfo->doc_config = doc;
     
     ptr = xmlDocGetRootElement(doc);
     if (!ptr || ptr->type != XML_ELEMENT_NODE 
         || XML_STRCMP(ptr->name, "dom"))
-    {
-        yaz_log(YLOG_WARN, 
-                "%s: dom filter: expected root element <dom>", 
-                tinfo->fname);  
-        return ZEBRA_FAIL;
-    }
+        {
+            yaz_log(YLOG_WARN, 
+                    "%s: dom filter: expected root element <dom>", 
+                    tinfo->fname);  
+            return ZEBRA_FAIL;
+        }
 
     for (ptr = ptr->children; ptr; ptr = ptr->next)
-    {
-       if (ptr->type != XML_ELEMENT_NODE)
-           continue;
-        if (!XML_STRCMP(ptr->name, "extract"))
         {
-            /*
-              <extract name="index">
-              <xslt stylesheet="first.xsl"/>
-              <xslt stylesheet="second.xsl"/>
-              </extract>
-            */
-           struct _xmlAttr *attr;
-            struct filter_extract *f =
-                odr_malloc(tinfo->odr_config, sizeof(*f));
+            if (ptr->type != XML_ELEMENT_NODE)
+                continue;
+            if (!XML_STRCMP(ptr->name, "extract"))
+                {
+                    /*
+                      <extract name="index">
+                      <xslt stylesheet="first.xsl"/>
+                      <xslt stylesheet="second.xsl"/>
+                      </extract>
+                    */
+                    struct _xmlAttr *attr;
+                    struct filter_extract *f =
+                        odr_malloc(tinfo->odr_config, sizeof(*f));
             
-            tinfo->extract = f;
-            f->name = 0;
-            f->convert = 0;
-           for (attr = ptr->properties; attr; attr = attr->next)
-           {
-               if (attr_content(attr, "name", &f->name))
-                    ;
-                else
-                    yaz_log(YLOG_WARN, "%s: dom filter: bad attribute %s"
-                            " for <extract>",
-                            tinfo->fname, attr->name);
-
-           }
-            parse_convert(tinfo, ptr->children, &f->convert);
-        }
-       else if (!XML_STRCMP(ptr->name, "retrieve"))
-       {  
-            /* 
-               <retrieve name="F">
-               <xslt stylesheet="some.xsl"/>
-               <xslt stylesheet="some.xsl"/>
-               </retrieve>
-            */
-           struct _xmlAttr *attr;
-            struct filter_retrieve **fp = &tinfo->retrieve_list;
-            struct filter_retrieve *f =
-                odr_malloc(tinfo->odr_config, sizeof(*f));
+                    tinfo->extract = f;
+                    f->name = 0;
+                    f->convert = 0;
+                    for (attr = ptr->properties; attr; attr = attr->next)
+                        {
+                            if (attr_content(attr, "name", &f->name))
+                                ;
+                            else
+                                yaz_log(YLOG_WARN, 
+                                        "%s: dom filter: bad attribute %s"
+                                        " for <extract>",
+                                        tinfo->fname, attr->name);
+
+                        }
+                    parse_convert(tinfo, ptr->children, &f->convert);
+                }
+            else if (!XML_STRCMP(ptr->name, "retrieve"))
+                {  
+                    /* 
+                       <retrieve name="F">
+                       <xslt stylesheet="some.xsl"/>
+                       <xslt stylesheet="some.xsl"/>
+                       </retrieve>
+                    */
+                    struct _xmlAttr *attr;
+                    struct filter_retrieve **fp = &tinfo->retrieve_list;
+                    struct filter_retrieve *f =
+                        odr_malloc(tinfo->odr_config, sizeof(*f));
             
-            while (*fp)
-                fp = &(*fp)->next;
-
-            *fp = f;
-            f->name = 0;
-            f->identifier = 0;
-            f->convert = 0;
-            f->next = 0;
-
-           for (attr = ptr->properties; attr; attr = attr->next)
-           {
-               if (attr_content(attr, "identifier", &f->identifier))
-                    ;
-                else if (attr_content(attr, "name", &f->name))
-                    ;
-                else
-                    yaz_log(YLOG_WARN, "%s: dom filter: bad attribute %s"
-                            " for <retrieve>",
-                            tinfo->fname, attr->name);
-           }
-            parse_convert(tinfo, ptr->children, &f->convert);
-       }
-       else if (!XML_STRCMP(ptr->name, "store"))
-       {
-            /*
-               <retrieve name="F">
-               <xslt stylesheet="some.xsl"/>
-               <xslt stylesheet="some.xsl"/>
-               </retrieve>
-            */
-            struct filter_store *f =
-                odr_malloc(tinfo->odr_config, sizeof(*f));
+                    while (*fp)
+                        fp = &(*fp)->next;
+
+                    *fp = f;
+                    f->name = 0;
+                    f->identifier = 0;
+                    f->convert = 0;
+                    f->next = 0;
+
+                    for (attr = ptr->properties; attr; attr = attr->next)
+                        {
+                            if (attr_content(attr, "identifier", 
+                                             &f->identifier))
+                                ;
+                            else if (attr_content(attr, "name", &f->name))
+                                ;
+                            else
+                                yaz_log(YLOG_WARN, 
+                                        "%s: dom filter: bad attribute %s"
+                                        " for <retrieve>",
+                                        tinfo->fname, attr->name);
+                        }
+                    parse_convert(tinfo, ptr->children, &f->convert);
+                }
+            else if (!XML_STRCMP(ptr->name, "store"))
+                {
+                    /*
+                      <retrieve name="F">
+                      <xslt stylesheet="some.xsl"/>
+                      <xslt stylesheet="some.xsl"/>
+                      </retrieve>
+                    */
+                    struct filter_store *f =
+                        odr_malloc(tinfo->odr_config, sizeof(*f));
             
-            tinfo->store = f;
-            f->convert = 0;
-            parse_convert(tinfo, ptr->children, &f->convert);
+                    tinfo->store = f;
+                    f->convert = 0;
+                    parse_convert(tinfo, ptr->children, &f->convert);
+                }
+            else if (!XML_STRCMP(ptr->name, "input"))
+                {
+                    /*
+                      <input syntax="xml">
+                      <xmlreader level="1"/>
+                      </input>
+                      <input syntax="usmarc">
+                      <marc inputcharset="marc-8"/>
+                      </input>
+                    */
+                    struct _xmlAttr *attr;
+                    const char  *syntax = 0;
+                    const char *name = 0;
+                    for (attr = ptr->properties; attr; attr = attr->next)
+                        {
+                            if (attr_content(attr, "syntax", &syntax))
+                                ;
+                            else if (attr_content(attr, "name", &name))
+                                ;
+                            else
+                                yaz_log(YLOG_WARN, 
+                                        "%s: dom filter: bad attribute %s"
+                                        " for <input>",
+                                        tinfo->fname, attr->name);
+                        }
+                    parse_input(tinfo, ptr->children, syntax, name);
+                }
+            else
+                {
+                    yaz_log(YLOG_WARN, "%s: dom filter: bad element %s",
+                            tinfo->fname, ptr->name);
+                    return ZEBRA_FAIL;
+                }
         }
-       else if (!XML_STRCMP(ptr->name, "input"))
-       {
-            /*
-              <input syntax="xml">
-              <xmlreader level="1"/>
-              </input>
-              <input syntax="usmarc">
-              <marc inputcharset="marc-8"/>
-              </input>
-            */
-           struct _xmlAttr *attr;
-            const char  *syntax = 0;
-            const char *name = 0;
-           for (attr = ptr->properties; attr; attr = attr->next)
-           {
-               if (attr_content(attr, "syntax", &syntax))
-                    ;
-                else if (attr_content(attr, "name", &name))
-                    ;
-                else
-                    yaz_log(YLOG_WARN, "%s: dom filter: bad attribute %s"
-                            " for <input>",
-                            tinfo->fname, attr->name);
-           }
-            parse_input(tinfo, ptr->children, syntax, name);
-       }
-       else
-       {
-           yaz_log(YLOG_WARN, "%s: dom filter: bad element %s",
-                    tinfo->fname, ptr->name);
-           return ZEBRA_FAIL;
-       }
-    }
     return ZEBRA_OK;
 }
 
@@ -566,16 +586,16 @@ static struct filter_retrieve *lookup_retrieve(struct filter_info *tinfo,
     if (!est)
         return f;
     for (; f; f = f->next)
-    { 
-        /* find requested schema */
-       if (est) 
-       {    
-           if (f->identifier && !strcmp(f->identifier, est))
-                return f;
-           if (f->name && !strcmp(f->name, est))
-                return f;
-       } 
-    }
+        { 
+            /* find requested schema */
+            if (est) 
+                {    
+                    if (f->identifier && !strcmp(f->identifier, est))
+                        return f;
+                    if (f->name && !strcmp(f->name, est))
+                        return f;
+                } 
+        }
     return 0;
 }
 
@@ -583,10 +603,10 @@ static ZEBRA_RES filter_config(void *clientData, Res res, const char *args)
 {
     struct filter_info *tinfo = clientData;
     if (!args || !*args)
-    {
-        yaz_log(YLOG_WARN, "dom filter: need config file");
-        return ZEBRA_FAIL;
-    }
+        {
+            yaz_log(YLOG_WARN, "dom filter: need config file");
+            return ZEBRA_FAIL;
+        }
 
     if (tinfo->fname && !strcmp(args, tinfo->fname))
        return ZEBRA_OK;
@@ -627,14 +647,14 @@ static void index_cdata(struct filter_info *tinfo, struct recExtractCtrl *ctrl,
                        xmlNodePtr ptr, RecWord *recWord)
 {
     for(; ptr; ptr = ptr->next)
-    {
-       index_cdata(tinfo, ctrl, ptr->children, recWord);
-       if (ptr->type != XML_TEXT_NODE)
-           continue;
-       recWord->term_buf = (const char *)ptr->content;
-       recWord->term_len = XML_STRLEN(ptr->content);
-       (*ctrl->tokenAdd)(recWord);
-    }
+        {
+            index_cdata(tinfo, ctrl, ptr->children, recWord);
+            if (ptr->type != XML_TEXT_NODE)
+                continue;
+            recWord->term_buf = (const char *)ptr->content;
+            recWord->term_len = XML_STRLEN(ptr->content);
+            (*ctrl->tokenAdd)(recWord);
+        }
 }
 
 /* Alvis style indexing */
@@ -642,43 +662,48 @@ static void index_node(struct filter_info *tinfo,  struct recExtractCtrl *ctrl,
                       xmlNodePtr ptr, RecWord *recWord)
 {
     for(; ptr; ptr = ptr->next)
-    {
-       index_node(tinfo, ctrl, ptr->children, recWord);
-       if (ptr->type != XML_ELEMENT_NODE || !ptr->ns ||
-           XML_STRCMP(ptr->ns->href, zebra_xslt_ns))
-           continue;
-       if (!XML_STRCMP(ptr->name, "index"))
-       {
-           const char *name_str = 0;
-           const char *type_str = 0;
-           const char *xpath_str = 0;
-           struct _xmlAttr *attr;
-           for (attr = ptr->properties; attr; attr = attr->next)
-           {
-               if (attr_content(attr, "name", &name_str))
-                    ;
-               else if (attr_content(attr, "xpath", &xpath_str))
-                    ;
-                else if (attr_content(attr, "type", &type_str))
-                    ;
-                else
-                    yaz_log(YLOG_WARN, "%s: dom filter: bad attribute %s"
-                            " for <index>",
-                            tinfo->fname, attr->name);
-           }
-           if (name_str)
-           {
-               int prev_type = recWord->index_type; /* save default type */
-
-               if (type_str && *type_str)
-                   recWord->index_type = *type_str; /* type was given */
-               recWord->index_name = name_str;
-               index_cdata(tinfo, ctrl, ptr->children, recWord);
-
-               recWord->index_type = prev_type;     /* restore it again */
-           }
-       }
-    }
+        {
+            index_node(tinfo, ctrl, ptr->children, recWord);
+            if (ptr->type != XML_ELEMENT_NODE || !ptr->ns ||
+                XML_STRCMP(ptr->ns->href, zebra_xslt_ns))
+                continue;
+            if (!XML_STRCMP(ptr->name, "index"))
+                {
+                    const char *name_str = 0;
+                    const char *type_str = 0;
+                    const char *xpath_str = 0;
+                    struct _xmlAttr *attr;
+                    for (attr = ptr->properties; attr; attr = attr->next)
+                        {
+                            if (attr_content(attr, "name", &name_str))
+                                ;
+                            else if (attr_content(attr, "xpath", &xpath_str))
+                                ;
+                            else if (attr_content(attr, "type", &type_str))
+                                ;
+                            else
+                                yaz_log(YLOG_WARN, 
+                                        "%s: dom filter: bad attribute %s"
+                                        " for <index>",
+                                        tinfo->fname, attr->name);
+                        }
+                    if (name_str)
+                        {
+                            /* save default type */
+                            int prev_type = recWord->index_type; 
+
+                            /* type was given */
+                            if (type_str && *type_str)
+                                recWord->index_type = *type_str; 
+
+                            recWord->index_name = name_str;
+                            index_cdata(tinfo, ctrl, ptr->children, recWord);
+
+                            /* restore it again */
+                            recWord->index_type = prev_type;     
+                        }
+                }
+        }
 }
 
 /* Alvis style indexing */
@@ -690,38 +715,38 @@ static void index_record(struct filter_info *tinfo,struct recExtractCtrl *ctrl,
     if (ptr && ptr->type == XML_ELEMENT_NODE && ptr->ns &&
        !XML_STRCMP(ptr->ns->href, zebra_xslt_ns)
        && !XML_STRCMP(ptr->name, "record"))
-    {
-       const char *id_str = 0;
-       const char *rank_str = 0;
-       struct _xmlAttr *attr;
-       for (attr = ptr->properties; attr; attr = attr->next)
-       {
-           if (attr_content(attr, "type", &type_str))
-                ;
-           else if (attr_content(attr, "id", &id_str))
-                ;
-           else if (attr_content(attr, "rank", &rank_str))
-                ;
-            else
-                yaz_log(YLOG_WARN, "%s: dom filter: bad attribute %s"
-                        " for <record>",
-                        tinfo->fname, attr->name);
-       }
-       if (id_str)
-           sscanf(id_str, "%255s", ctrl->match_criteria);
+        {
+            const char *id_str = 0;
+            const char *rank_str = 0;
+            struct _xmlAttr *attr;
+            for (attr = ptr->properties; attr; attr = attr->next)
+                {
+                    if (attr_content(attr, "type", &type_str))
+                        ;
+                    else if (attr_content(attr, "id", &id_str))
+                        ;
+                    else if (attr_content(attr, "rank", &rank_str))
+                        ;
+                    else
+                        yaz_log(YLOG_WARN, "%s: dom filter: bad attribute %s"
+                                " for <record>",
+                                tinfo->fname, attr->name);
+                }
+            if (id_str)
+                sscanf(id_str, "%255s", ctrl->match_criteria);
 
-       if (rank_str)
-           ctrl->staticrank = atozint(rank_str);
-       ptr = ptr->children;
-    }
+            if (rank_str)
+                ctrl->staticrank = atozint(rank_str);
+            ptr = ptr->children;
+        }
 
     if (!strcmp("update", type_str))
         index_node(tinfo, ctrl, ptr, recWord);
     else if (!strcmp("delete", type_str))
-         yaz_log(YLOG_WARN, "dom filter delete: to be implemented");
+        yaz_log(YLOG_WARN, "dom filter delete: to be implemented");
     else
-         yaz_log(YLOG_WARN, "dom filter: unknown record type '%s'", 
-                 type_str);
+        yaz_log(YLOG_WARN, "dom filter: unknown record type '%s'", 
+                type_str);
 }
 
 
@@ -747,21 +772,21 @@ static void extract_doc_alvis(struct filter_info *tinfo,
        if (root_ptr)
            index_record(tinfo, recctr, root_ptr, &recWord);
         else
-                yaz_log(YLOG_WARN, "No root for index XML record");
+            yaz_log(YLOG_WARN, "No root for index XML record");
     }
 }
 
 
 /* DOM filter style indexing */
 static int attr_content_xml(struct _xmlAttr *attr, const char *name,
-                        xmlChar **dst_content)
+                            xmlChar **dst_content)
 {
     if (0 == XML_STRCMP(attr->name, name) && attr->children 
         && attr->children->type == XML_TEXT_NODE)
-    {
-        *dst_content = (attr->children->content);
-        return 1;
-    }
+        {
+            *dst_content = (attr->children->content);
+            return 1;
+        }
     return 0;
 }
 
@@ -782,58 +807,58 @@ void index_value_of(struct filter_info *tinfo,
 {
     xmlChar *text = xmlNodeGetContent(node);
 
-  xmlChar *look = index_p;
-  xmlChar *bval;
-  xmlChar *eval;
+    xmlChar *look = index_p;
+    xmlChar *bval;
+    xmlChar *eval;
 
-  xmlChar index[256];
-  xmlChar type[256];
+    xmlChar index[256];
+    xmlChar type[256];
 
-  /* parsing all index name/type pairs - may not start with ' ' or ':' */
-  while (*look && ' ' != *look && ':' != *look){
+    /* parsing all index name/type pairs - may not start with ' ' or ':' */
+    while (*look && ' ' != *look && ':' != *look){
     
-    /* setting name and type to zero */
-    *index = '\0';
-    *type = '\0';
+        /* setting name and type to zero */
+        *index = '\0';
+        *type = '\0';
     
-    /* parsing one index name */
-    bval = look;
-    while (*look && ':' != *look && ' ' != *look){
-      look++;
-    }
-    eval = look;
-    strncpy((char *)index, (const char *)bval, eval - bval);
-    index[eval - bval] = '\0';
+        /* parsing one index name */
+        bval = look;
+        while (*look && ':' != *look && ' ' != *look){
+            look++;
+        }
+        eval = look;
+        strncpy((char *)index, (const char *)bval, eval - bval);
+        index[eval - bval] = '\0';
     
     
-    /* parsing one index type, if existing */
-    if (':' == *look){
-      look++;
+        /* parsing one index type, if existing */
+        if (':' == *look){
+            look++;
       
-      bval = look;
-      while (*look && ' ' != *look){
-        look++;
-      }
-      eval = look;
-      strncpy((char *)type, (const char *)bval, eval - bval);
-      type[eval - bval] = '\0';
-    }
+            bval = look;
+            while (*look && ' ' != *look){
+                look++;
+            }
+            eval = look;
+            strncpy((char *)type, (const char *)bval, eval - bval);
+            type[eval - bval] = '\0';
+        }
 
-    printf("INDEX  '%s:%s' '%s'\n", index, type, text);
+        printf("INDEX  '%s:%s' '%s'\n", index, type, text);
     
-    if (*look && ' ' == *look && *(look+1)){
-      look++;
-    } 
-  }
-
-  xmlFree(text);
-
-/*   //recWord->term_buf = (const char *)ptr->content; */
-/*   //recWord->term_len = XML_STRLEN(ptr->content); */
-/*   //  if (type_str && *type_str) */
-/*   //  recWord->index_type = *type_str; /\* type was given *\/ */
-/*   //  recWord->index_name = name_str; */
-/*   // recWord->index_type = prev_type;     /\* restore it again *\/ */
+        if (*look && ' ' == *look && *(look+1)){
+            look++;
+        } 
+    }
+
+    xmlFree(text);
+
+    /*   //recWord->term_buf = (const char *)ptr->content; */
+    /*   //recWord->term_len = XML_STRLEN(ptr->content); */
+    /*   //  if (type_str && *type_str) */
+    /*   //  recWord->index_type = *type_str; /\* type was given *\/ */
+    /*   //  recWord->index_name = name_str; */
+    /*   // recWord->index_type = prev_type;     /\* restore it again *\/ */
 }
 
 
@@ -844,7 +869,7 @@ void set_record_info(struct filter_info *tinfo,
                      xmlChar * rank_p, 
                      xmlChar * action_p)
 {
-  printf("RECORD id=%s rank=%s action=%s\n", id_p, rank_p, action_p);
+    printf("RECORD id=%s rank=%s action=%s\n", id_p, rank_p, action_p);
 }
 
 
@@ -853,61 +878,62 @@ void process_xml_element_zebra_node(struct filter_info *tinfo,
                                     struct recExtractCtrl *recctr, 
                                     xmlNodePtr node)
 {
-  if (node->type == XML_ELEMENT_NODE 
-      && node->ns && 0 == XML_STRCMP(node->ns->href, zebra_xslt_ns)){
+    if (node->type == XML_ELEMENT_NODE 
+        && node->ns && 0 == XML_STRCMP(node->ns->href, zebra_xslt_ns)){
     
-    if (0 == XML_STRCMP(node->name, "index")){
-      xmlChar *index_p = 0;
+        if (0 == XML_STRCMP(node->name, "index")){
+            xmlChar *index_p = 0;
+
+            struct _xmlAttr *attr;      
+            for (attr = node->properties; attr; attr = attr->next){
+                if (attr_content_xml(attr, "name", &index_p)){
+                    index_value_of(tinfo, recctr, node, index_p);        
+                }  
+                else
+                    // printf("%s: dom filter: s% bad attribute %s",
+                    // tinfo->fname, xmlGetNodePath(node)), nodeattr->name);
+                    printf("dom filter: %s bad attribute @%s, "
+                           "expected @name\n",
+                           xmlGetNodePath(node), attr->name);
+            }
+        }
+        else if (0 == XML_STRCMP(node->name, "record")){
+            xmlChar *id_p = 0;
+            xmlChar *rank_p = 0;
+            xmlChar *action_p = 0;
 
-      struct _xmlAttr *attr;      
-      for (attr = node->properties; attr; attr = attr->next){
-        if (attr_content_xml(attr, "name", &index_p)){
-          index_value_of(tinfo, recctr, node, index_p);        
-        }  
-        else
-          //   printf("%s: dom filter: s% bad attribute %s",
-          //        tinfo->fname, xmlGetNodePath(node)), nodeattr->name);
-          printf("dom filter: %s bad attribute @%s, expected @name\n",
-                  xmlGetNodePath(node), attr->name);
-      }
-    }
-    else if (0 == XML_STRCMP(node->name, "record")){
-      xmlChar *id_p = 0;
-      xmlChar *rank_p = 0;
-      xmlChar *action_p = 0;
-
-      struct _xmlAttr *attr;
-      for (attr = node->properties; attr; attr = attr->next){
-        if (attr_content_xml(attr, "id", &id_p))
-          ;
-        else if (attr_content_xml(attr, "rank", &rank_p))
-          ;
-        else if (attr_content_xml(attr, "acton", &action_p))
-          ;
-        else
-          //   printf("%s: dom filter: s% bad attribute %s",
-          //        tinfo->fname, xmlGetNodePath(node)), nodeattr->name);
-          printf("dom filter: %s bad attribute @%s,"
-                 " expected @id|@rank|@action\n",
-                 xmlGetNodePath(node), attr->name);
-
-        if (action_p && 0 != strcmp("update", (const char *)action_p))
-          printf("dom filter: %s attribute @%s,"
-                 " only implemented '@action=\"update\"\n",
-                 xmlGetNodePath(node), attr->name);
+            struct _xmlAttr *attr;
+            for (attr = node->properties; attr; attr = attr->next){
+                if (attr_content_xml(attr, "id", &id_p))
+                    ;
+                else if (attr_content_xml(attr, "rank", &rank_p))
+                    ;
+                else if (attr_content_xml(attr, "acton", &action_p))
+                    ;
+                else
+                    // printf("%s: dom filter: s% bad attribute %s",
+                    // tinfo->fname, xmlGetNodePath(node)), nodeattr->name);
+                    printf("dom filter: %s bad attribute @%s,"
+                           " expected @id|@rank|@action\n",
+                           xmlGetNodePath(node), attr->name);
+
+                if (action_p && 0 != strcmp("update", (const char *)action_p))
+                    printf("dom filter: %s attribute @%s,"
+                           " only implemented '@action=\"update\"\n",
+                           xmlGetNodePath(node), attr->name);
           
 
-      }
-      set_record_info(tinfo, recctr, id_p, rank_p, action_p);
-    } else {
-      //   printf("%s: dom filter: s% bad attribute %s",
-      //        tinfo->fname, xmlGetNodePath(node)), nodeattr->name);
-      printf("dom filter: %s bad element <%s>,"
-             " expected <record>|<index> in namespace '%s'\n",
-             xmlGetNodePath(node), node->name, zebra_xslt_ns);
+            }
+            set_record_info(tinfo, recctr, id_p, rank_p, action_p);
+        } else {
+            //  printf("%s: dom filter: s% bad attribute %s",
+            //  tinfo->fname, xmlGetNodePath(node)), nodeattr->name);
+            printf("dom filter: %s bad element <%s>,"
+                   " expected <record>|<index> in namespace '%s'\n",
+                   xmlGetNodePath(node), node->name, zebra_xslt_ns);
       
+        }
     }
-  }
 }
 
 
@@ -920,88 +946,88 @@ void process_xml_pi_node(struct filter_info *tinfo,
 
     /* printf("PI     %s\n", xmlGetNodePath(node)); */
 
-  /* if right PI name, continue parsing PI */
-  if (0 == strcmp(zebra_pi_name, (const char *)node->name)){
-    xmlChar *pi_p =  node->content;
-    xmlChar *look = pi_p;
+    /* if right PI name, continue parsing PI */
+    if (0 == strcmp(zebra_pi_name, (const char *)node->name)){
+        xmlChar *pi_p =  node->content;
+        xmlChar *look = pi_p;
     
-    xmlChar *bval;
-    xmlChar *eval;
-
-    /* parsing PI record instructions */
-    if (0 == strncmp((const char *)look, "record", 6)){
-      xmlChar id[256];
-      xmlChar rank[256];
-      xmlChar action[256];
-
-      *id = '\0';
-      *rank = '\0';
-      *action = '\0';
+        xmlChar *bval;
+        xmlChar *eval;
+
+        /* parsing PI record instructions */
+        if (0 == strncmp((const char *)look, "record", 6)){
+            xmlChar id[256];
+            xmlChar rank[256];
+            xmlChar action[256];
+
+            *id = '\0';
+            *rank = '\0';
+            *action = '\0';
       
-      look += 6;
+            look += 6;
       
-      /* eat whitespace */
-      while (*look && ' ' == *look && *(look+1))
-        look++;
-
-      /* parse possible id */
-      if (*look && 0 == strncmp((const char *)look, "id=", 3)){
-        look += 3;
-        bval = look;
-        while (*look && ' ' != *look)
-          look++;
-        eval = look;
-        strncpy((char *)id, (const char *)bval, eval - bval);
-        id[eval - bval] = '\0';
-      }
+            /* eat whitespace */
+            while (*look && ' ' == *look && *(look+1))
+                look++;
+
+            /* parse possible id */
+            if (*look && 0 == strncmp((const char *)look, "id=", 3)){
+                look += 3;
+                bval = look;
+                while (*look && ' ' != *look)
+                    look++;
+                eval = look;
+                strncpy((char *)id, (const char *)bval, eval - bval);
+                id[eval - bval] = '\0';
+            }
       
-      /* eat whitespace */
-      while (*look && ' ' == *look && *(look+1))
-        look++;
+            /* eat whitespace */
+            while (*look && ' ' == *look && *(look+1))
+                look++;
       
-      /* parse possible rank */
-      if (*look && 0 == strncmp((const char *)look, "rank=", 5)){
-        look += 6;
-        bval = look;
-        while (*look && ' ' != *look)
-          look++;
-        eval = look;
-        strncpy((char *)rank, (const char *)bval, eval - bval);
-        rank[eval - bval] = '\0';
-      }
-
-      /* eat whitespace */
-      while (*look && ' ' == *look && *(look+1))
-        look++;
-
-      if (look && '\0' != *look){
-        printf ("ERROR %s: content '%s'; can not parse '%s'\n", 
-                xmlGetNodePath(node), pi_p, look);
-      } else {
-        /* set_record_info(id, rank, action); */
-        set_record_info(tinfo, recctr, id, rank, 0);
-      }
-
-    } 
+            /* parse possible rank */
+            if (*look && 0 == strncmp((const char *)look, "rank=", 5)){
+                look += 6;
+                bval = look;
+                while (*look && ' ' != *look)
+                    look++;
+                eval = look;
+                strncpy((char *)rank, (const char *)bval, eval - bval);
+                rank[eval - bval] = '\0';
+            }
+
+            /* eat whitespace */
+            while (*look && ' ' == *look && *(look+1))
+                look++;
+
+            if (look && '\0' != *look){
+                printf ("ERROR %s: content '%s'; can not parse '%s'\n", 
+                        xmlGetNodePath(node), pi_p, look);
+            } else {
+                /* set_record_info(id, rank, action); */
+                set_record_info(tinfo, recctr, id, rank, 0);
+            }
+
+        } 
    
-    /* parsing index instruction */
-    else   if (0 == strncmp((const char *)look, "index", 5)){
-      look += 5;
+        /* parsing index instruction */
+        else   if (0 == strncmp((const char *)look, "index", 5)){
+            look += 5;
       
-      /* eat whitespace */
-      while (*look && ' ' == *look && *(look+1))
-        look++;
+            /* eat whitespace */
+            while (*look && ' ' == *look && *(look+1))
+                look++;
 
-      /* export index instructions to outside */
-      *index_pp = look;
+            /* export index instructions to outside */
+            *index_pp = look;
 
-      /* nor record, neither index */ 
-    } else {
+            /* nor record, neither index */ 
+        } else {
     
-      printf ("ERROR %s: content '%s'; can not parse '%s'\n", 
-              xmlGetNodePath(node), pi_p, look);
-    }  
-  }
+            printf ("ERROR %s: content '%s'; can not parse '%s'\n", 
+                    xmlGetNodePath(node), pi_p, look);
+        }  
+    }
 }
 
 /* DOM filter style indexing */
@@ -1009,45 +1035,42 @@ void process_xml_element_node(struct filter_info *tinfo,
                               struct recExtractCtrl *recctr, 
                               xmlNodePtr node)
 {
-  /* remember indexing instruction from PI to next element node */
-  xmlChar *index_p = 0;
+    /* remember indexing instruction from PI to next element node */
+    xmlChar *index_p = 0;
 
-  /* printf("ELEM   %s\n", xmlGetNodePath(node)); */
+    /* printf("ELEM   %s\n", xmlGetNodePath(node)); */
 
-  /* check if we are an element node in the special zebra namespace 
-     and either set record data or index value-of node content*/
-  process_xml_element_zebra_node(tinfo, recctr, node);
+    /* check if we are an element node in the special zebra namespace 
+       and either set record data or index value-of node content*/
+    process_xml_element_zebra_node(tinfo, recctr, node);
   
-  /* loop through kid nodes */
-  for (node = node->children; node; node = node->next)
-    {
-      /* check and set PI record and index index instructions */
-      if (node->type == XML_PI_NODE){
-        process_xml_pi_node(tinfo, recctr, node, &index_p);
-      }
-      else if (node->type == XML_ELEMENT_NODE){
-        /* if there was a PI index instruction before this element node */
-        if (index_p){
-          index_value_of(tinfo, recctr, node, index_p);            
-          index_p = 0;
+    /* loop through kid nodes */
+    for (node = node->children; node; node = node->next)
+        {
+            /* check and set PI record and index index instructions */
+            if (node->type == XML_PI_NODE){
+                process_xml_pi_node(tinfo, recctr, node, &index_p);
+            }
+            else if (node->type == XML_ELEMENT_NODE){
+                /* if there was a PI index instruction before this element */
+                if (index_p){
+                    index_value_of(tinfo, recctr, node, index_p);            
+                    index_p = 0;
+                }
+                process_xml_element_node(tinfo, recctr, node);
+            }
+            else
+                continue;
         }
-        process_xml_element_node(tinfo, recctr, node);
-      }
-      else
-        continue;
-    }
 }
 
 
-
-
-
 /* DOM filter style indexing */
 void extract_dom_doc_node(struct filter_info *tinfo, 
                           struct recExtractCtrl *recctr, 
                           xmlDocPtr doc)
 {
-    printf("DOC    %s\n", xmlGetNodePath((xmlNodePtr)doc));
+    /* printf("DOC    %s\n", xmlGetNodePath((xmlNodePtr)doc)); */
 
     process_xml_element_node(tinfo, recctr, (xmlNodePtr)doc);
 }
@@ -1075,12 +1098,12 @@ static int convert_extract_doc(struct filter_info *tinfo,
     perform_convert(tinfo, input->convert, params, &doc, 0);
 
     if (tinfo->store)
-    {
-        /* store conversion */
-        store_doc = xmlCopyDoc(doc, 1);
-        perform_convert(tinfo, tinfo->store->convert,
-                        params, &store_doc, &last_xsp);
-    }
+        {
+            /* store conversion */
+            store_doc = xmlCopyDoc(doc, 1);
+            perform_convert(tinfo, tinfo->store->convert,
+                            params, &store_doc, &last_xsp);
+        }
     
     if (last_xsp)
         xsltSaveResultToString(&buf_out, &len_out, 
@@ -1115,46 +1138,47 @@ static int extract_xml_split(struct filter_info *tinfo,
     int ret;
 
     if (p->first_record)
-    {
-       if (input->u.xmlreader.reader)
-           xmlFreeTextReader(input->u.xmlreader.reader);
-       input->u.xmlreader.reader = xmlReaderForIO(ioread_ex, ioclose_ex,
-                                                   p /* I/O handler */,
-                                                   0 /* URL */, 
-                                                   0 /* encoding */,
-                                                   XML_PARSE_XINCLUDE|
-                                                   XML_PARSE_NOENT);
-    }
+        {
+            if (input->u.xmlreader.reader)
+                xmlFreeTextReader(input->u.xmlreader.reader);
+            input->u.xmlreader.reader = xmlReaderForIO(ioread_ex, ioclose_ex,
+                                                       p /* I/O handler */,
+                                                       0 /* URL */, 
+                                                       0 /* encoding */,
+                                                       XML_PARSE_XINCLUDE|
+                                                       XML_PARSE_NOENT);
+        }
     if (!input->u.xmlreader.reader)
        return RECCTRL_EXTRACT_ERROR_GENERIC;
 
     ret = xmlTextReaderRead(input->u.xmlreader.reader);
     while (ret == 1)
-    {
-       int type = xmlTextReaderNodeType(input->u.xmlreader.reader);
-       int depth = xmlTextReaderDepth(input->u.xmlreader.reader);
-       if (type == XML_READER_TYPE_ELEMENT && 
-            input->u.xmlreader.split_level == depth)
-       {
-           xmlNodePtr ptr = xmlTextReaderExpand(input->u.xmlreader.reader);
-            if (ptr)
-            {
-                xmlNodePtr ptr2 = xmlCopyNode(ptr, 1);
-                xmlDocPtr doc = xmlNewDoc((const xmlChar*) "1.0");
+        {
+            int type = xmlTextReaderNodeType(input->u.xmlreader.reader);
+            int depth = xmlTextReaderDepth(input->u.xmlreader.reader);
+            if (type == XML_READER_TYPE_ELEMENT && 
+                input->u.xmlreader.split_level == depth)
+                {
+                    xmlNodePtr ptr
+                        = xmlTextReaderExpand(input->u.xmlreader.reader);
+                    if (ptr)
+                        {
+                            xmlNodePtr ptr2 = xmlCopyNode(ptr, 1);
+                            xmlDocPtr doc = xmlNewDoc((const xmlChar*) "1.0");
                 
-                xmlDocSetRootElement(doc, ptr2);
+                            xmlDocSetRootElement(doc, ptr2);
                 
-                return convert_extract_doc(tinfo, input, p, doc);
-            }
-            else
-            {
-                xmlFreeTextReader(input->u.xmlreader.reader);
-                input->u.xmlreader.reader = 0;
-                return RECCTRL_EXTRACT_ERROR_GENERIC;
-            }
-       }
-       ret = xmlTextReaderRead(input->u.xmlreader.reader);
-    }
+                            return convert_extract_doc(tinfo, input, p, doc);
+                        }
+                    else
+                        {
+                            xmlFreeTextReader(input->u.xmlreader.reader);
+                            input->u.xmlreader.reader = 0;
+                            return RECCTRL_EXTRACT_ERROR_GENERIC;
+                        }
+                }
+            ret = xmlTextReaderRead(input->u.xmlreader.reader);
+        }
     xmlFreeTextReader(input->u.xmlreader.reader);
     input->u.xmlreader.reader = 0;
     return RECCTRL_EXTRACT_EOF;
@@ -1165,17 +1189,18 @@ static int extract_xml_full(struct filter_info *tinfo,
                             struct recExtractCtrl *p)
 {
     if (p->first_record) /* only one record per stream */
-    {
-        xmlDocPtr doc = xmlReadIO(ioread_ex, ioclose_ex, p /* I/O handler */,
-                                  0 /* URL */,
-                                  0 /* encoding */,
-                                  XML_PARSE_XINCLUDE|XML_PARSE_NOENT);
-        if (!doc)
         {
-            return RECCTRL_EXTRACT_ERROR_GENERIC;
+            xmlDocPtr doc = xmlReadIO(ioread_ex, ioclose_ex, 
+                                      p /* I/O handler */,
+                                      0 /* URL */,
+                                      0 /* encoding */,
+                                      XML_PARSE_XINCLUDE|XML_PARSE_NOENT);
+            if (!doc)
+                {
+                    return RECCTRL_EXTRACT_ERROR_GENERIC;
+                }
+            return convert_extract_doc(tinfo, input, p, doc);
         }
-        return convert_extract_doc(tinfo, input, p, doc);
-    }
     else
         return RECCTRL_EXTRACT_EOF;
 }
@@ -1191,45 +1216,46 @@ static int extract_iso2709(struct filter_info *tinfo,
     if (p->stream->readf(p->stream, buf, 5) != 5)
         return RECCTRL_EXTRACT_EOF;
     while (*buf < '0' || *buf > '9')
-    {
-        int i;
+        {
+            int i;
 
-        yaz_log(YLOG_WARN, "MARC: Skipping bad byte %d (0x%02X)",
-                *buf & 0xff, *buf & 0xff);
-        for (i = 0; i<4; i++)
-            buf[i] = buf[i+1];
+            yaz_log(YLOG_WARN, "MARC: Skipping bad byte %d (0x%02X)",
+                    *buf & 0xff, *buf & 0xff);
+            for (i = 0; i<4; i++)
+                buf[i] = buf[i+1];
 
-        if (p->stream->readf(p->stream, buf+4, 1) != 1)
-            return RECCTRL_EXTRACT_EOF;
-    }
+            if (p->stream->readf(p->stream, buf+4, 1) != 1)
+                return RECCTRL_EXTRACT_EOF;
+        }
     record_length = atoi_n (buf, 5);
     if (record_length < 25)
-    {
-        yaz_log (YLOG_WARN, "MARC record length < 25, is %d", record_length);
-        return RECCTRL_EXTRACT_ERROR_GENERIC;
-    }
+        {
+            yaz_log (YLOG_WARN, "MARC record length < 25, is %d", 
+                     record_length);
+            return RECCTRL_EXTRACT_ERROR_GENERIC;
+        }
     read_bytes = p->stream->readf(p->stream, buf+5, record_length-5);
     if (read_bytes < record_length-5)
-    {
-        yaz_log (YLOG_WARN, "Couldn't read whole MARC record");
-        return RECCTRL_EXTRACT_ERROR_GENERIC;
-    }
+        {
+            yaz_log (YLOG_WARN, "Couldn't read whole MARC record");
+            return RECCTRL_EXTRACT_ERROR_GENERIC;
+        }
     r = yaz_marc_read_iso2709(input->u.marc.handle,  buf, record_length);
     if (r < record_length)
-    {
-        yaz_log (YLOG_WARN, "Parsing of MARC record failed r=%d length=%d",
-                 r, record_length);
-        return RECCTRL_EXTRACT_ERROR_GENERIC;
-    }
+        {
+            yaz_log (YLOG_WARN, "Parsing of MARC record failed r=%d length=%d",
+                     r, record_length);
+            return RECCTRL_EXTRACT_ERROR_GENERIC;
+        }
     else
-    {
-        xmlDocPtr rdoc;
-        xmlNode *root_ptr;
-        yaz_marc_write_xml(input->u.marc.handle, &root_ptr, 0, 0, 0);
-        rdoc = xmlNewDoc((const xmlChar*) "1.0");
-        xmlDocSetRootElement(rdoc, root_ptr);
-        return convert_extract_doc(tinfo, input, p, rdoc);        
-    }
+        {
+            xmlDocPtr rdoc;
+            xmlNode *root_ptr;
+            yaz_marc_write_xml(input->u.marc.handle, &root_ptr, 0, 0, 0);
+            rdoc = xmlNewDoc((const xmlChar*) "1.0");
+            xmlDocSetRootElement(rdoc, root_ptr);
+            return convert_extract_doc(tinfo, input, p, rdoc);        
+        }
     return RECCTRL_EXTRACT_OK;
 }
 
@@ -1243,16 +1269,16 @@ static int filter_extract(void *clientData, struct recExtractCtrl *p)
 
     odr_reset(tinfo->odr_record);
     switch(input->type)
-    {
-    case DOM_INPUT_XMLREADER:
-        if (input->u.xmlreader.split_level == 0)
-            return extract_xml_full(tinfo, input, p);
-        else
-            return extract_xml_split(tinfo, input, p);
-        break;
-    case DOM_INPUT_MARC:
-        return extract_iso2709(tinfo, input, p);
-    }
+        {
+        case DOM_INPUT_XMLREADER:
+            if (input->u.xmlreader.split_level == 0)
+                return extract_xml_full(tinfo, input, p);
+            else
+                return extract_xml_split(tinfo, input, p);
+            break;
+        case DOM_INPUT_MARC:
+            return extract_iso2709(tinfo, input, p);
+        }
     return RECCTRL_EXTRACT_ERROR_GENERIC;
 }
 
@@ -1278,27 +1304,27 @@ static int filter_retrieve (void *clientData, struct recRetrieveCtrl *p)
     xsltStylesheetPtr last_xsp = 0;
 
     if (p->comp)
-    {
-       if (p->comp->which == Z_RecordComp_simple
-           && p->comp->u.simple->which == Z_ElementSetNames_generic)
-       {
-           esn = p->comp->u.simple->u.generic;
-       }
-       else if (p->comp->which == Z_RecordComp_complex 
-                && p->comp->u.complex->generic->elementSpec
-                && p->comp->u.complex->generic->elementSpec->which ==
-                Z_ElementSpec_elementSetName)
-       {
-           esn = p->comp->u.complex->generic->elementSpec->u.elementSetName;
-       }
-    }
+        {
+            if (p->comp->which == Z_RecordComp_simple
+                && p->comp->u.simple->which == Z_ElementSetNames_generic)
+                {
+                    esn = p->comp->u.simple->u.generic;
+                }
+            else if (p->comp->which == Z_RecordComp_complex 
+                     && p->comp->u.complex->generic->elementSpec
+                     && p->comp->u.complex->generic->elementSpec->which ==
+                     Z_ElementSpec_elementSetName)
+                {
+                    esn = p->comp->u.complex->generic->elementSpec->u.elementSetName;
+                }
+        }
     retrieve = lookup_retrieve(tinfo, esn);
     if (!retrieve)
-    {
-       p->diagnostic =
-           YAZ_BIB1_SPECIFIED_ELEMENT_SET_NAME_NOT_VALID_FOR_SPECIFIED_;
-       return 0;
-    }
+        {
+            p->diagnostic =
+                YAZ_BIB1_SPECIFIED_ELEMENT_SET_NAME_NOT_VALID_FOR_SPECIFIED_;
+            return 0;
+        }
 
     params[0] = 0;
     set_param_int(params, "id", p->localno, p->odr);
@@ -1326,54 +1352,54 @@ static int filter_retrieve (void *clientData, struct recRetrieveCtrl *p)
                    0 /* encoding */,
                    XML_PARSE_XINCLUDE|XML_PARSE_NOENT);
     if (!doc)
-    {
-       p->diagnostic = YAZ_BIB1_SYSTEM_ERROR_IN_PRESENTING_RECORDS;
-       return 0;
-    }
+        {
+            p->diagnostic = YAZ_BIB1_SYSTEM_ERROR_IN_PRESENTING_RECORDS;
+            return 0;
+        }
 
     /* retrieve conversion */
     perform_convert(tinfo, retrieve->convert, params, &doc, &last_xsp);
     if (!doc)
-    {
-       p->diagnostic = YAZ_BIB1_SYSTEM_ERROR_IN_PRESENTING_RECORDS;
-    }
+        {
+            p->diagnostic = YAZ_BIB1_SYSTEM_ERROR_IN_PRESENTING_RECORDS;
+        }
     else if (p->input_format == VAL_NONE || p->input_format == VAL_TEXT_XML)
-    {
-       xmlChar *buf_out;
-       int len_out;
+        {
+            xmlChar *buf_out;
+            int len_out;
 
-        if (last_xsp)
-            xsltSaveResultToString(&buf_out, &len_out, doc, last_xsp);
-        else
-           xmlDocDumpMemory(doc, &buf_out, &len_out);            
+            if (last_xsp)
+                xsltSaveResultToString(&buf_out, &len_out, doc, last_xsp);
+            else
+                xmlDocDumpMemory(doc, &buf_out, &len_out);            
 
-       p->output_format = VAL_TEXT_XML;
-       p->rec_len = len_out;
-       p->rec_buf = odr_malloc(p->odr, p->rec_len);
-       memcpy(p->rec_buf, buf_out, p->rec_len);
-       xmlFree(buf_out);
-    }
+            p->output_format = VAL_TEXT_XML;
+            p->rec_len = len_out;
+            p->rec_buf = odr_malloc(p->odr, p->rec_len);
+            memcpy(p->rec_buf, buf_out, p->rec_len);
+            xmlFree(buf_out);
+        }
     else if (p->output_format == VAL_SUTRS)
-    {
-       xmlChar *buf_out;
-       int len_out;
+        {
+            xmlChar *buf_out;
+            int len_out;
 
-        if (last_xsp)
-            xsltSaveResultToString(&buf_out, &len_out, doc, last_xsp);
-        else
-           xmlDocDumpMemory(doc, &buf_out, &len_out);            
+            if (last_xsp)
+                xsltSaveResultToString(&buf_out, &len_out, doc, last_xsp);
+            else
+                xmlDocDumpMemory(doc, &buf_out, &len_out);            
         
-       p->output_format = VAL_SUTRS;
-       p->rec_len = len_out;
-       p->rec_buf = odr_malloc(p->odr, p->rec_len);
-       memcpy(p->rec_buf, buf_out, p->rec_len);
+            p->output_format = VAL_SUTRS;
+            p->rec_len = len_out;
+            p->rec_buf = odr_malloc(p->odr, p->rec_len);
+            memcpy(p->rec_buf, buf_out, p->rec_len);
        
-       xmlFree(buf_out);
-    }
+            xmlFree(buf_out);
+        }
     else
-    {
-       p->diagnostic = YAZ_BIB1_RECORD_SYNTAX_UNSUPP;
-    }
+        {
+            p->diagnostic = YAZ_BIB1_RECORD_SYNTAX_UNSUPP;
+        }
     xmlFreeDoc(doc);
     return 0;
 }