---

utils.c

Go to the documentation of this file.

/*
*This file is part of GNU MlView
*
*GNU MlView 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.
*
*GNU MlView 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 MlView; 
*see the file COPYING. If not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*
*
*Copyright 2001 dodji seketeli
*/


#include <stdio.h>
#include <locale.h>
#include <ctype.h>
#include "utils.h"
#include <gnome.h>
#include "config.h"
#include <libxml/valid.h>

typedef struct _ErrorMessage ErrorMessage ;

struct _ErrorMessage{
  gchar * error_type ;
  gchar *error_string ;
};

static ErrorMessage p_error_messages_tab[]={
  {"error","OK"}, /*0*/
  {"error","parser internal error"},
  {"error","no more memory"},
  {"error","error at document start"}, /*3*/
  {"error","document empty"},
  {"error","document end reached unexpectedly"},
  {"error","invalid hexadecimal character reference"}, /*6*/
  {"error","invalid decimal character reference"},
  {"error","invalid chararacter reference"},
  {"error","invalid character"},
  {"error","character reference at end of file"}, /*10*/
  {"error","character reference in prolog"},
  {"error","character reference in epilog"}, /*12*/
  {"error","character reference in DTD"},
  {"error","entity reference at end of file"}, /*14*/
  {"error","entity reference in prolog"},
  {"error","entity reference in epilog"}, /*16*/
  {"error","entity reference in DTD"},
  {"error","pe reference at end of file"}, /*18*/
  {"error","pe reference in prolog"},
  {"error","pe reference in epilog"}, /*20*/
  {"error","pe reference in int subset"},
  {"error","entity reference with no name"}, /*22*/
  {"error","entity reference with semicolon missing"},
  {"error","pe reference with no name"}, /*24*/
  {"error","pe reference semicolon missing"},
  {"error","undeclared entity"}, /*26*/
  {"warning","undeclared entity"},
  {"error","unparsed entity"}, /*28*/
  {"error","entity is external"},
  {"error","entity is parameter"},/*30*/
  {"error","unknown encoding"},
  {"error","unsupported encoding"}, /*32*/
  {"error","string not started"},
  {"error","string not closed"}, /*34*/
  {"error","namespace declaration error"},
  {"error","entity not started"} , /*36*/
  {"error","entity not finished"},

  {"error","\'<\' character in attribute"}, /*38*/
  {"error","attribute not started"},
  {"error","entity not finished"}, /*40*/
  {"error","attribute without value"}, 
  {"error","attribute redefined"},/*42*/
  {"error","literal not started"},
  {"error","literal not finished"}, /*44*/
  {"error","comment not finished"},
  {"error","processing instruction not started"}, /*46*/
  {"error","processing instruction not finished"},
  {"error","notation not started"}, /*48*/
  {"error","notation not finished"},
  {"error","attribute list not star*ted"}, /*50*/
  {"error","attribute list not finished"},
  {"error","mixed content not started"}, /*52*/
  {"error","mixed content not finished"},
  {"error","element content not started"}, /*54*/
  {"error","element content not finished"},
  {"error","xml declaration not started"},/*56*/
  {"error","xml declaration not finished"},
  {"error","condition section not started"},/*58*/
  {"error","condition section not finished"},
  {"error","external subset not finished"},/*60*/
  {"error","doctype not finished"},
  {"error","misplaced CDATA end"},/*62*/
  {"error","CDATA not finished"},
  {"error","reserved xml name"},/*64*/
  {"error","space required"},
  {"error","separator required"}, /*66*/
  {"error","NM token required"},
  {"error","name token required"}, /*68*/
  {"error","PCDATA required"},
  {"error","URI required"},/*70*/
  {"error","public id required"},
  {"error","\'<\' required"}, /*72*/
  {"error","\'>\' required"},
  {"error","\'</\' required"},/*74*/
  {"error","\'=\' required"},
  {"error","tag name mismatch"}, /*76*/
  {"error","tag not finished"},
  {"error","standalone value"},/*78*/
  {"error","encoding name"},
  {"error","hyphen in comment"},/*80*/
  {"error","invalid encoding"},
  {"error","entity standalone"},/*82*/
  {"error","condition section invalid"},
  {"error","value required"},/*84*/
  {"error","not well balanced"},
  {"error","extra content"},/*86*/
  {"error","entity character error"},
  {"error","PE internal"},/*88*/
  {"error","entity loop"},
  {"error","entity boundary"},/*90*/
  {"error","invalid uri"},
  {"error","uri fragment"},/*92*/  
  {NULL}
} ;

/*
 *xmlParserErrors messages retrieval routines.
 */

void get_xml_parser_error_as_string1(xmlParserCtxtPtr a_xml_parser_context, gchar * a_error_string){
  ErrorMessage error_message ;
  g_return_if_fail(a_xml_parser_context!=NULL) ;

  a_error_string=NULL ;    
  
  if(a_xml_parser_context->errNo >= sizeof(p_error_messages_tab)-1)
    return ;
  error_message=p_error_messages_tab[a_xml_parser_context->errNo] ;
  
  a_error_string=g_malloc(strlen(error_message.error_type) + 
                         strlen(error_message.error_string) + 2) ;
  sprintf(a_error_string, "%s:%s",error_message.error_type,error_message.error_string) ;
}

void get_xml_parser_error_as_string2(xmlParserErrors a_xml_error, gchar * a_error_string){
  ErrorMessage error_message ;
  a_error_string=NULL ;  
  
  if(a_xml_error >= sizeof(p_error_messages_tab) -1)
    return ;
  error_message=error_message=p_error_messages_tab[a_xml_error] ;
  a_error_string=g_malloc(strlen(error_message.error_type) + 
                         strlen(error_message.error_string) + 2) ;
  sprintf(a_error_string, "%s:%s",error_message.error_type,error_message.error_string) ;
}

gboolean
utils_is_white_string(const gchar *a_str)
{
        gchar * tmp_str= (gchar *) a_str ;
        if(tmp_str == NULL)
                return FALSE ;  

        while(*tmp_str){
                if(!isspace(*tmp_str)) return FALSE ;                   
                tmp_str ++ ;
        }
        return TRUE ;
}

void
init_i18n (void) 
{
        setlocale (LC_ALL, "") ;
        bindtextdomain (PACKAGE, PACKAGE_LOCALE_DIR) ;
        textdomain (PACKAGE) ;
}

/*=============================================
  some usefull patches to libxml:

  xmlUnlinkNs (xmlNode * node, xmlNs * ns)
  xmlUnlinkNsDef (xmlNode * node, xmlNs * ns)
 *============================================*/
xmlNs *
xmlUnlinkNs (xmlNode * node, xmlNs * ns)
{
        xmlNs * cur ;
        
        if(node == NULL  ||  ns == NULL) {
                return NULL;
        }

        cur = node->ns ;
        if(cur == NULL)
                return NULL ;

        /*Check if the namespace to unlink is the first ns in the xml node nsDef list. If yes, unlink it*/
        if(ns == cur){
                node->nsDef = node->nsDef->next ;
                ns->next = NULL ;
                return ns ;
        }

        /*the namespace to unlink may be further in the ns list. Walk to the namespace just before it...*/
        while(cur != NULL  &&  cur->next != ns) {
                cur = cur->next ;
        }
        if(cur == NULL)
                return NULL ;

        /*at this stage, cur points to the namespace that is just before the namespace to unlink. Let's now unlink ns*/
        if(ns->next == NULL)
                cur->next = NULL ;
        else{
                cur->next = ns->next ;
                ns->next = NULL ;
        }
        return ns ;
        
}

xmlNs *
xmlUnlinkNsDef (xmlNode * node, xmlNs * ns)
{
        xmlNs * cur ;

        if(node == NULL  ||  ns == NULL) {
                return NULL;
        }
        
        cur = node->nsDef ;
        if(cur == NULL)
                return NULL ;

        /*Check if the namespace to unlink is the first ns in the xml node nsDef list. If yes, unlink it*/
        if(ns == cur){
                node->nsDef = node->nsDef->next ;
                ns->next = NULL ;
                return ns ;
        }

        /*the namespace to unlink may be further in the ns list. Walk to the namespace just before it...*/
        while(cur != NULL  &&  cur->next != ns) {
                cur = cur->next ;
        }
        if(cur == NULL)
                return NULL ;

        /*at this stage, cur points to the namespace that is just before the namespace to unlink. Let's now unlink ns*/
        if(ns->next == NULL)
                cur->next = NULL ;
        else{
                cur->next = ns->next ;
                ns->next = NULL ;
        }
        return ns ;
}

int
xmlValidGetValidElementsChildren (xmlNode *a_node, 
                                  const xmlChar **a_list,
                                  int a_max)
{
        xmlElement * element_desc = NULL ;
        gint nb_valid_elements = 0 ;

        /*some sanity checks...*/
        if (a_node == NULL) return -2 ;
        if (a_list == NULL) return -2 ;
        if (a_list == NULL)  return -2 ;
        if (a_max == 0) return -2 ;
        if (a_node->type != XML_ELEMENT_NODE) return -2 ;
        if (a_node->parent == NULL) return -2 ;

        if (a_node->children) {
                /*the node is the root node 
                 *and it has children. We can it valid children
                 *with the function
                 */
                return xmlValidGetValidElements (a_node->last, NULL, 
                                                 a_list, a_max) ;
        
        } else {
                gint nb_elements = 0, i = 0 ;
                const xmlChar * elements[256] ;
                xmlNode * test_node = NULL ;
                xmlValidCtxt vctxt ;
                
                memset(&vctxt, 0, sizeof (xmlValidCtxt));

                element_desc = xmlGetDtdElementDesc(a_node->parent->doc->intSubset,
                                                    a_node->name);
                if ((element_desc == NULL) && (a_node->parent->doc->extSubset != NULL))
                        element_desc = xmlGetDtdElementDesc(a_node->parent->doc->extSubset,
                                                            a_node->name) ;
                if (element_desc == NULL) return (-1) ;
                
                /*
                 *Create a dummy child element
                 */
                test_node = 
                        xmlNewChild (a_node, NULL, "<!dummy?>", NULL) ;

                /*
                 *Insert each potential child node and check if the current node is still valid.
                 */
                nb_elements = 
                        xmlValidGetPotentialChildren (element_desc->content,
                                                      elements, &nb_elements, 256) ;
                
                for (i = 0 ; i < nb_elements ; i++) {
                        test_node->name = elements[i] ;
                        if (xmlStrEqual(test_node->name, "#PCDATA"))
                                test_node->type = XML_TEXT_NODE ;
                        else
                                test_node->type = XML_ELEMENT_NODE ;

                        if (xmlValidateOneElement (&vctxt, a_node->parent->doc, a_node)) {
                                int j ;
                                for (j = 0 ; j < nb_valid_elements ; j++)
                                        if (xmlStrEqual (elements[i], a_list[j])) break ;
                                a_list[nb_valid_elements++] = elements[i] ;
                                
                                if (nb_valid_elements >= a_max) break ;
                        }
                }

                /*
                 *Restore the tree structure
                 */
                xmlUnlinkNode (test_node) ;
                
                return nb_valid_elements ;
        }
}

void
utils_parse_full_name (xmlNode *a_node, gchar *a_full_name, xmlNs ** a_ns, gchar **a_local_name)
{
        gchar *colon_ptr, *prefix, *local_name ;
        gchar **full_name_array ;
        xmlNs * ns ;

        g_return_if_fail(a_node != NULL) ;
        g_return_if_fail(a_full_name != NULL) ;

        *a_ns = NULL ;
        *a_local_name = NULL ;

        colon_ptr = index(a_full_name, ':') ;

        if(colon_ptr != NULL){
                full_name_array = g_strsplit(a_full_name,":", 2) ;
                prefix = full_name_array[0] ;
                local_name = full_name_array[1] ;
                ns = xmlSearchNs(a_node->doc,
                                 a_node,
                                 prefix) ;
                if(ns != NULL)
                        *a_ns = ns ;
                else
                        *a_ns = NULL ;
                if(local_name != NULL && !utils_is_white_string(local_name))
                        *a_local_name = g_strstrip(local_name) ;
                
        }else{
                *a_local_name = g_strdup(g_strstrip(a_full_name)) ;
        }
}

/*=============================================
  some usefull patches i wrote for the files gtkclist.c and gtkctree.c:

  gtk_clist_absolute_row_top_ypixel(GtkCList *a_clist, gint a_row)
  gtk_ctree_node_absolute_top_ypixel(GtkCTree * a_tree, GtkCTreeNode *a_node)
 *============================================*/

#define CELL_SPACING 1

gint
gtk_clist_absolute_row_top_ypixel(GtkCList *a_clist, gint a_row)
{
        g_return_val_if_fail(a_clist != NULL,-1) ;
        g_return_val_if_fail(GTK_IS_CLIST(a_clist), -1) ;

        return (a_clist->row_height * a_row  +
                (a_row + 1) * CELL_SPACING) ;
}

gint
gtk_ctree_node_absolute_top_ypixel(GtkCTree * a_tree, GtkCTreeNode *a_node)
{
        gint pos ;
        g_return_val_if_fail(a_tree != NULL, -1) ;
        g_return_val_if_fail(GTK_IS_CTREE(a_tree), -1) ;
        g_return_val_if_fail(a_node != NULL, -1) ;

        pos = g_list_position(a_tree->clist.row_list,&a_node->list) ;
        return gtk_clist_absolute_row_top_ypixel(&a_tree->clist, pos) ;
}

---