/* -*- Mode: C; indent-tabs-mode: nil; c-basic-offset: 8 -*- */

/*
 * This file is part of The Croco Library
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of version 2.1 of the GNU Lesser General Public
 * License as published by the Free Software Foundation.
 *
 * This program 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 Lesser General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
 * USA
 *
 * Author: Dodji Seketeli.
 * See COPYRIGHTS files for copyrights information.
 */

#include <string.h>
#include "cr-statement.h"
#include "cr-parser.h"

/**
 *@file
 *Definition of the #CRStatement class.
 */

#define DECLARATION_INDENT_NB 2

static void cr_statement_clear (CRStatement * a_this);

static void  
parse_font_face_start_font_face_cb (CRDocHandler * a_this,
                                    CRParsingLocation *a_location)
{
        CRStatement *stmt = NULL;
        enum CRStatus status = CR_OK;

        (void) a_location;

        stmt = cr_statement_new_at_font_face_rule (NULL, NULL);
        g_return_if_fail (stmt);

        status = cr_doc_handler_set_ctxt (a_this, stmt);
        g_return_if_fail (status == CR_OK);
}

static void
parse_font_face_unrecoverable_error_cb (CRDocHandler * a_this)
{
        CRStatement *stmt = NULL;
	CRStatement **stmtptr = NULL;
        enum CRStatus status = CR_OK;

        g_return_if_fail (a_this);

	stmtptr = &stmt;
        status = cr_doc_handler_get_ctxt (a_this, (gpointer *) stmtptr);
        if (status != CR_OK) {
                cr_utils_trace_info ("Couldn't get parsing context. "
                                     "This may lead to some memory leaks.");
                return;
        }
        if (stmt) {
                cr_statement_destroy (stmt);
                cr_doc_handler_set_ctxt (a_this, NULL);
                return;
        }
}

static void
parse_font_face_property_cb (CRDocHandler * a_this,
                             CRString * a_name,
                             CRTerm * a_value, gboolean a_important)
{
        enum CRStatus status = CR_OK;
        CRString *name = NULL;
        CRDeclaration *decl = NULL;
        CRStatement *stmt = NULL;
        CRStatement **stmtptr = NULL;

        (void) a_important;

        g_return_if_fail (a_this && a_name);

	stmtptr = &stmt;
        status = cr_doc_handler_get_ctxt (a_this, (gpointer *) stmtptr);
        g_return_if_fail (status == CR_OK && stmt);
        g_return_if_fail (stmt->type == AT_FONT_FACE_RULE_STMT);

        name = cr_string_dup (a_name) ;
        g_return_if_fail (name);
        decl = cr_declaration_new (stmt, name, a_value);
        if (!decl) {
                cr_utils_trace_info ("cr_declaration_new () failed.");
                goto error;
        }
        name = NULL;

        stmt->kind.font_face_rule->decl_list =
                cr_declaration_append (stmt->kind.font_face_rule->decl_list,
                                       decl);
        if (!stmt->kind.font_face_rule->decl_list)
                goto error;
        decl = NULL;

      error:
        if (decl) {
                cr_declaration_unref (decl);
                decl = NULL;
        }
        if (name) {
                cr_string_destroy (name);
                name = NULL;
        }
}

static void
parse_font_face_end_font_face_cb (CRDocHandler * a_this)
{
        CRStatement *result = NULL;
        CRStatement **resultptr = NULL;
        enum CRStatus status = CR_OK;

        g_return_if_fail (a_this);

	resultptr = &result;
        status = cr_doc_handler_get_ctxt (a_this, (gpointer *) resultptr);
        g_return_if_fail (status == CR_OK && result);
        g_return_if_fail (result->type == AT_FONT_FACE_RULE_STMT);

        status = cr_doc_handler_set_result (a_this, result);
        g_return_if_fail (status == CR_OK);
}

static void
parse_page_start_page_cb (CRDocHandler * a_this,
                          CRString * a_name, 
                          CRString * a_pseudo_page,
                          CRParsingLocation *a_location)
{
        CRStatement *stmt = NULL;
        enum CRStatus status = CR_OK;
        CRString *page_name = NULL, *pseudo_name = NULL ;

        (void) a_location;

        if (a_name)
                page_name = cr_string_dup (a_name) ;
        if (a_pseudo_page)
                pseudo_name = cr_string_dup (a_pseudo_page) ;

        stmt = cr_statement_new_at_page_rule (NULL, NULL, 
                                              page_name,
                                              pseudo_name);
        page_name = NULL ;
        pseudo_name = NULL ;
        g_return_if_fail (stmt);
        status = cr_doc_handler_set_ctxt (a_this, stmt);
        g_return_if_fail (status == CR_OK);
}

static void
parse_page_unrecoverable_error_cb (CRDocHandler * a_this)
{
        CRStatement *stmt = NULL;
        CRStatement **stmtptr = NULL;
        enum CRStatus status = CR_OK;

        g_return_if_fail (a_this);

	stmtptr = &stmt;
        status = cr_doc_handler_get_ctxt (a_this, (gpointer *) stmtptr);
        if (status != CR_OK) {
                cr_utils_trace_info ("Couldn't get parsing context. "
                                     "This may lead to some memory leaks.");
                return;
        }
        if (stmt) {
                cr_statement_destroy (stmt);
                stmt = NULL;
                cr_doc_handler_set_ctxt (a_this, NULL);
        }
}

static void
parse_page_property_cb (CRDocHandler * a_this,
                        CRString * a_name,
                        CRTerm * a_expression, gboolean a_important)
{
        CRString *name = NULL;
        CRStatement *stmt = NULL;
        CRStatement **stmtptr = NULL;
        CRDeclaration *decl = NULL;
        enum CRStatus status = CR_OK;

	stmtptr = &stmt;
        status = cr_doc_handler_get_ctxt (a_this, (gpointer *) stmtptr);
        g_return_if_fail (status == CR_OK && stmt->type == AT_PAGE_RULE_STMT);

        name = cr_string_dup (a_name);
        g_return_if_fail (name);

        decl = cr_declaration_new (stmt, name, a_expression);
        g_return_if_fail (decl);
        decl->important = a_important;
        stmt->kind.page_rule->decl_list =
                cr_declaration_append (stmt->kind.page_rule->decl_list, decl);
        g_return_if_fail (stmt->kind.page_rule->decl_list);
}

static void
parse_page_end_page_cb (CRDocHandler * a_this,
                        CRString * a_name, 
                        CRString * a_pseudo_page)
{
        enum CRStatus status = CR_OK;
        CRStatement *stmt = NULL;
        CRStatement **stmtptr = NULL;

        (void) a_name;
        (void) a_pseudo_page;

	stmtptr = &stmt;
        status = cr_doc_handler_get_ctxt (a_this, (gpointer *) stmtptr);
        g_return_if_fail (status == CR_OK && stmt);
        g_return_if_fail (stmt->type == AT_PAGE_RULE_STMT);

        status = cr_doc_handler_set_result (a_this, stmt);
        g_return_if_fail (status == CR_OK);
}

static void
parse_at_media_start_media_cb (CRDocHandler * a_this, 
                               GList * a_media_list,
                               CRParsingLocation *a_location)
{
        enum CRStatus status = CR_OK;
        CRStatement *at_media = NULL;
        GList *media_list = NULL;

        (void) a_location;

        g_return_if_fail (a_this && a_this->priv);

        if (a_media_list) {
                /*duplicate media list */
                media_list = cr_utils_dup_glist_of_cr_string 
                        (a_media_list);
        }

        g_return_if_fail (media_list);

        /*make sure cr_statement_new_at_media_rule works in this case. */
        at_media = cr_statement_new_at_media_rule (NULL, NULL, media_list);

        status = cr_doc_handler_set_ctxt (a_this, at_media);
        g_return_if_fail (status == CR_OK);
        status = cr_doc_handler_set_result (a_this, at_media);
        g_return_if_fail (status == CR_OK);
}

static void
parse_at_media_unrecoverable_error_cb (CRDocHandler * a_this)
{
        enum CRStatus status = CR_OK;
        CRStatement *stmt = NULL;
        CRStatement **stmtptr = NULL;

        g_return_if_fail (a_this);

	stmtptr = &stmt;
        status = cr_doc_handler_get_result (a_this, (gpointer *) stmtptr);
        if (status != CR_OK) {
                cr_utils_trace_info ("Couldn't get parsing context. "
                                     "This may lead to some memory leaks.");
                return;
        }
        if (stmt) {
                cr_statement_destroy (stmt);
                stmt = NULL;
                cr_doc_handler_set_ctxt (a_this, NULL);
                cr_doc_handler_set_result (a_this, NULL);
        }
}

static void
parse_at_media_start_selector_cb (CRDocHandler * a_this,
                                  CRSelector * a_sellist)
{
        enum CRStatus status = CR_OK;
        CRStatement *at_media = NULL;
        CRStatement **at_media_ptr = NULL;
	CRStatement *ruleset = NULL;

        g_return_if_fail (a_this && a_this->priv && a_sellist);

	at_media_ptr = &at_media;
        status = cr_doc_handler_get_ctxt (a_this, (gpointer *) at_media_ptr);
        g_return_if_fail (status == CR_OK && at_media);
        g_return_if_fail (at_media->type == AT_MEDIA_RULE_STMT);
        ruleset = cr_statement_new_ruleset (NULL, a_sellist, NULL, at_media);
        g_return_if_fail (ruleset);
        status = cr_doc_handler_set_ctxt (a_this, ruleset);
        g_return_if_fail (status == CR_OK);
}

static void
parse_at_media_property_cb (CRDocHandler * a_this,
                            CRString * a_name, CRTerm * a_value,
                            gboolean a_important)
{
        enum CRStatus status = CR_OK;

        /*
         *the current ruleset stmt, child of the 
         *current at-media being parsed.
         */
        CRStatement *stmt = NULL;
        CRStatement **stmtptr = NULL;
        CRDeclaration *decl = NULL;
        CRString *name = NULL;

        g_return_if_fail (a_this && a_name);

        name = cr_string_dup (a_name) ;
        g_return_if_fail (name);

	stmtptr = &stmt;
        status = cr_doc_handler_get_ctxt (a_this, 
                                          (gpointer *) stmtptr);
        g_return_if_fail (status == CR_OK && stmt);
        g_return_if_fail (stmt->type == RULESET_STMT);

        decl = cr_declaration_new (stmt, name, a_value);
        g_return_if_fail (decl);
        decl->important = a_important;
        status = cr_statement_ruleset_append_decl (stmt, decl);
        g_return_if_fail (status == CR_OK);
}

static void
parse_at_media_end_selector_cb (CRDocHandler * a_this, 
                                CRSelector * a_sellist)
{
        enum CRStatus status = CR_OK;

        /*
         *the current ruleset stmt, child of the 
         *current at-media being parsed.
         */
        CRStatement *stmt = NULL;
        CRStatement **stmtptr = NULL;

        g_return_if_fail (a_this && a_sellist);

	stmtptr = &stmt;
        status = cr_doc_handler_get_ctxt (a_this, (gpointer *) stmtptr);
        g_return_if_fail (status == CR_OK && stmt
                          && stmt->type == RULESET_STMT);
        g_return_if_fail (stmt->kind.ruleset->parent_media_rule);

        status = cr_doc_handler_set_ctxt
                (a_this, stmt->kind.ruleset->parent_media_rule);
        g_return_if_fail (status == CR_OK);
}

static void
parse_at_media_end_media_cb (CRDocHandler * a_this, 
                             GList * a_media_list)
{
        enum CRStatus status = CR_OK;
        CRStatement *at_media = NULL;
        CRStatement **at_media_ptr = NULL;

        (void) a_media_list;

        g_return_if_fail (a_this && a_this->priv);

	at_media_ptr = &at_media;
        status = cr_doc_handler_get_ctxt (a_this, 
                                          (gpointer *) at_media_ptr);
        g_return_if_fail (status == CR_OK && at_media);
        status = cr_doc_handler_set_result (a_this, at_media);
}

static void
parse_ruleset_start_selector_cb (CRDocHandler * a_this,
                                 CRSelector * a_sellist)
{
        CRStatement *ruleset = NULL;

        g_return_if_fail (a_this && a_this->priv && a_sellist);

        ruleset = cr_statement_new_ruleset (NULL, a_sellist, NULL, NULL);
        g_return_if_fail (ruleset);

        cr_doc_handler_set_result (a_this, ruleset);
}

static void
parse_ruleset_unrecoverable_error_cb (CRDocHandler * a_this)
{
        CRStatement *stmt = NULL;
        CRStatement **stmtptr = NULL;
        enum CRStatus status = CR_OK;

	stmtptr = &stmt;
        status = cr_doc_handler_get_result (a_this, (gpointer *) stmtptr);
        if (status != CR_OK) {
                cr_utils_trace_info ("Couldn't get parsing context. "
                                     "This may lead to some memory leaks.");
                return;
        }
        if (stmt) {
                cr_statement_destroy (stmt);
                stmt = NULL;
                cr_doc_handler_set_result (a_this, NULL);
        }
}

static void
parse_ruleset_property_cb (CRDocHandler * a_this,
                           CRString * a_name,
                           CRTerm * a_value, gboolean a_important)
{
        enum CRStatus status = CR_OK;
        CRStatement *ruleset = NULL;
        CRStatement **rulesetptr = NULL;
        CRDeclaration *decl = NULL;
        CRString *stringue = NULL;

        g_return_if_fail (a_this && a_this->priv && a_name);

        stringue = cr_string_dup (a_name);
        g_return_if_fail (stringue);

	rulesetptr = &ruleset;
        status = cr_doc_handler_get_result (a_this, (gpointer *) rulesetptr);
        g_return_if_fail (status == CR_OK
                          && ruleset 
                          && ruleset->type == RULESET_STMT);

        decl = cr_declaration_new (ruleset, stringue, a_value);
        g_return_if_fail (decl);
        decl->important = a_important;
        status = cr_statement_ruleset_append_decl (ruleset, decl);
        g_return_if_fail (status == CR_OK);
}

static void
parse_ruleset_end_selector_cb (CRDocHandler * a_this, 
                               CRSelector * a_sellist)
{
        CRStatement *result = NULL;
        CRStatement **resultptr = NULL;
        enum CRStatus status = CR_OK;

        g_return_if_fail (a_this && a_sellist);

	resultptr = &result;
        status = cr_doc_handler_get_result (a_this, (gpointer *) resultptr);

        g_return_if_fail (status == CR_OK
                          && result 
                          && result->type == RULESET_STMT);
}

static void
cr_statement_clear (CRStatement * a_this)
{
        g_return_if_fail (a_this);

        switch (a_this->type) {
        case AT_RULE_STMT:
                break;
        case RULESET_STMT:
                if (!a_this->kind.ruleset)
                        return;
                if (a_this->kind.ruleset->sel_list) {
                        cr_selector_unref (a_this->kind.ruleset->sel_list);
                        a_this->kind.ruleset->sel_list = NULL;
                }
                if (a_this->kind.ruleset->decl_list) {
                        cr_declaration_destroy
                                (a_this->kind.ruleset->decl_list);
                        a_this->kind.ruleset->decl_list = NULL;
                }
                g_free (a_this->kind.ruleset);
                a_this->kind.ruleset = NULL;
                break;

        case AT_IMPORT_RULE_STMT:
                if (!a_this->kind.import_rule)
                        return;
                if (a_this->kind.import_rule->url) {
                        cr_string_destroy 
                                (a_this->kind.import_rule->url) ;
                        a_this->kind.import_rule->url = NULL;
                }
                g_free (a_this->kind.import_rule);
                a_this->kind.import_rule = NULL;
                break;

        case AT_MEDIA_RULE_STMT:
                if (!a_this->kind.media_rule)
                        return;
                if (a_this->kind.media_rule->rulesets) {
                        cr_statement_destroy
                                (a_this->kind.media_rule->rulesets);
                        a_this->kind.media_rule->rulesets = NULL;
                }
                if (a_this->kind.media_rule->media_list) {
                        GList *cur = NULL;

                        for (cur = a_this->kind.media_rule->media_list;
                             cur; cur = cur->next) {
                                if (cur->data) {
                                        cr_string_destroy ((CRString *) cur->data);
                                        cur->data = NULL;
                                }

                        }
                        g_list_free (a_this->kind.media_rule->media_list);
                        a_this->kind.media_rule->media_list = NULL;
                }
                g_free (a_this->kind.media_rule);
                a_this->kind.media_rule = NULL;
                break;

        case AT_PAGE_RULE_STMT:
                if (!a_this->kind.page_rule)
                        return;

                if (a_this->kind.page_rule->decl_list) {
                        cr_declaration_destroy
                                (a_this->kind.page_rule->decl_list);
                        a_this->kind.page_rule->decl_list = NULL;
                }
                if (a_this->kind.page_rule->name) {
                        cr_string_destroy 
                                (a_this->kind.page_rule->name);
                        a_this->kind.page_rule->name = NULL;
                }
                if (a_this->kind.page_rule->pseudo) {
                        cr_string_destroy
                                (a_this->kind.page_rule->pseudo);
                        a_this->kind.page_rule->pseudo = NULL;
                }
                g_free (a_this->kind.page_rule);
                a_this->kind.page_rule = NULL;
                break;

        case AT_CHARSET_RULE_STMT:
                if (!a_this->kind.charset_rule)
                        return;

                if (a_this->kind.charset_rule->charset) {
                        cr_string_destroy
                                (a_this->kind.charset_rule->charset);
                        a_this->kind.charset_rule->charset = NULL;
                }
                g_free (a_this->kind.charset_rule);
                a_this->kind.charset_rule = NULL;
                break;

        case AT_FONT_FACE_RULE_STMT:
                if (!a_this->kind.font_face_rule)
                        return;

                if (a_this->kind.font_face_rule->decl_list) {
                        cr_declaration_unref
                                (a_this->kind.font_face_rule->decl_list);
                        a_this->kind.font_face_rule->decl_list = NULL;
                }
                g_free (a_this->kind.font_face_rule);
                a_this->kind.font_face_rule = NULL;
                break;

        default:
                break;
        }
}

/**
 * cr_statement_ruleset_to_string:
 *
 *@a_this: the current instance of #CRStatement
 *@a_indent: the number of whitespace to use for indentation
 *
 *Serializes the ruleset statement into a string
 *
 *Returns the newly allocated serialised string. Must be freed
 *by the caller, using g_free().
 */
static gchar *
cr_statement_ruleset_to_string (CRStatement const * a_this, glong a_indent)
{
        GString *stringue = NULL;
        gchar *tmp_str = NULL,
                *result = NULL;

        g_return_val_if_fail (a_this && a_this->type == RULESET_STMT, NULL);

        stringue = (GString *) g_string_new (NULL);
        if (!stringue) {
            return result;
        }

        if (a_this->kind.ruleset->sel_list) {
                if (a_indent)
                        cr_utils_dump_n_chars2 (' ', stringue, a_indent);

                tmp_str =
                        (gchar *) cr_selector_to_string (a_this->kind.ruleset->
                                               sel_list);
                if (tmp_str) {
                        g_string_append (stringue, tmp_str);
                        g_free (tmp_str);
                        tmp_str = NULL;
                }
        }
        g_string_append (stringue, " {\n");
        if (a_this->kind.ruleset->decl_list) {
                tmp_str = (gchar *) cr_declaration_list_to_string2
                        (a_this->kind.ruleset->decl_list,
                         a_indent + DECLARATION_INDENT_NB, TRUE);
                if (tmp_str) {
                        g_string_append (stringue, tmp_str);
                        g_free (tmp_str);
                        tmp_str = NULL;
                }
                g_string_append (stringue, "\n");
                cr_utils_dump_n_chars2 (' ', stringue, a_indent);
        }
        g_string_append (stringue, "}");
        result = stringue->str;

        g_string_free (stringue, FALSE);
        stringue = NULL;

        if (tmp_str) {
                g_free (tmp_str);
                tmp_str = NULL;
        }
        return result;
}


/**
 * cr_statement_font_face_rule_to_string:
 *
 *@a_this: the current instance of #CRStatement to consider
 *It must be a font face rule statement.
 *@a_indent: the number of white spaces of indentation.
 *
 *Serializes a font face rule statement into a string.
 *
 *Returns the serialized string. Must be deallocated by the caller
 *using g_free().
 */
static gchar *
cr_statement_font_face_rule_to_string (CRStatement const * a_this,
                                       glong a_indent)
{
        gchar *result = NULL, *tmp_str = NULL ;
        GString *stringue = NULL ;

        g_return_val_if_fail (a_this 
                              && a_this->type == AT_FONT_FACE_RULE_STMT,
                              NULL);

        if (a_this->kind.font_face_rule->decl_list) {
                stringue = (GString *) g_string_new (NULL) ;
                g_return_val_if_fail (stringue, NULL) ;
                if (a_indent)
                        cr_utils_dump_n_chars2 (' ', stringue, 
                                        a_indent);
                g_string_append (stringue, "@font-face {\n");
                tmp_str = (gchar *) cr_declaration_list_to_string2 
                        (a_this->kind.font_face_rule->decl_list,
                         a_indent + DECLARATION_INDENT_NB, TRUE) ;
                if (tmp_str) {
                        g_string_append (stringue,
                                         tmp_str) ;
                        g_free (tmp_str) ;
                        tmp_str = NULL ;
                }
                g_string_append (stringue, "\n}");
        }
        if (stringue) {
                result = stringue->str ;
                g_string_free (stringue, FALSE) ;
                stringue = NULL ;
        }
        return result ;
}


/**
 * cr_statement_charset_to_string:
 *
 *Serialises an \@charset statement into a string.
 *@a_this: the statement to serialize.
 *@a_indent: the number of indentation spaces
 *
 *Returns the serialized charset statement. Must be
 *freed by the caller using g_free().
 */
static gchar *
cr_statement_charset_to_string (CRStatement const *a_this,
                                gulong a_indent)
{
        gchar *str = NULL ;
        GString *stringue = NULL ;

        g_return_val_if_fail (a_this
                              && a_this->type == AT_CHARSET_RULE_STMT,
                              NULL) ;

        if (a_this->kind.charset_rule
            && a_this->kind.charset_rule->charset
            && a_this->kind.charset_rule->charset->stryng
            && a_this->kind.charset_rule->charset->stryng->str) {
                str = g_strndup (a_this->kind.charset_rule->charset->stryng->str,
                                 a_this->kind.charset_rule->charset->stryng->len);
                g_return_val_if_fail (str, NULL);
                stringue = g_string_new (NULL) ;
                g_return_val_if_fail (stringue, NULL) ;
                cr_utils_dump_n_chars2 (' ', stringue, a_indent);
                g_string_append_printf (stringue, 
                                        "@charset \"%s\" ;", str);
                if (str) {
                        g_free (str);
                        str = NULL;
                }
        }
        if (stringue) {
                str = stringue->str ;
                g_string_free (stringue, FALSE) ;
        }
        return str ;
}


/**
 * cr_statement_at_page_rule_to_string:
 *
 *Serialises the at page rule statement into a string
 *@a_this: the current instance of #CRStatement. Must
 *be an "\@page" rule statement.
 *
 *Returns the serialized string. Must be freed by the caller
 */
static gchar *
cr_statement_at_page_rule_to_string (CRStatement const *a_this,
                                     gulong a_indent)
{
        GString *stringue = NULL;
        gchar *result = NULL ;

        stringue = (GString *) g_string_new (NULL) ;

        cr_utils_dump_n_chars2 (' ', stringue, a_indent) ;
        g_string_append (stringue, "@page");
	if (a_this->kind.page_rule->name
	    && a_this->kind.page_rule->name->stryng) {
		g_string_append_printf 
		  (stringue, " %s",
		   a_this->kind.page_rule->name->stryng->str) ;
        } else {
                g_string_append (stringue, " ");
        }
	if (a_this->kind.page_rule->pseudo
	    && a_this->kind.page_rule->pseudo->stryng) {
		g_string_append_printf 
		  (stringue,  " :%s",
		   a_this->kind.page_rule->pseudo->stryng->str) ;
        }
        if (a_this->kind.page_rule->decl_list) {
                gchar *str = NULL ;
                g_string_append (stringue, " {\n");
                str = (gchar *) cr_declaration_list_to_string2
                        (a_this->kind.page_rule->decl_list,
                         a_indent + DECLARATION_INDENT_NB, TRUE) ;
                if (str) {
                        g_string_append (stringue, str) ;
                        g_free (str) ;
                        str = NULL ;
                }
                g_string_append (stringue, "\n}\n");
        }
        result = stringue->str ;
        g_string_free (stringue, FALSE) ;
        stringue = NULL ;
        return result ;
}


/**
 *Serializes an \@media statement.
 *@param a_this the current instance of #CRStatement
 *@param a_indent the number of spaces of indentation.
 *@return the serialized \@media statement. Must be freed
 *by the caller using g_free().
 */
static gchar *
cr_statement_media_rule_to_string (CRStatement const *a_this,
                                   gulong a_indent)
{
        gchar *str = NULL ;
        GString *stringue = NULL ;
        GList const *cur = NULL;

        g_return_val_if_fail (a_this->type == AT_MEDIA_RULE_STMT,
                              NULL);

        if (a_this->kind.media_rule) {
                stringue = (GString *) g_string_new (NULL) ;
                cr_utils_dump_n_chars2 (' ', stringue, a_indent);
                g_string_append (stringue, "@media");

                for (cur = a_this->kind.media_rule->media_list; cur;
                     cur = cur->next) {
                        if (cur->data) {
                                gchar *str2 = cr_string_dup2
                                        ((CRString const *) cur->data);

                                if (str2) {
                                        if (cur->prev) {
                                                g_string_append
                                                        (stringue, 
                                                         ",");
                                        }
                                        g_string_append_printf 
                                                (stringue, 
                                                 " %s", str2);
                                        g_free (str2);
                                        str2 = NULL;
                                }
                        }
                }
                g_string_append (stringue, " {\n");
                str = cr_statement_list_to_string
                        (a_this->kind.media_rule->rulesets,
                         a_indent + DECLARATION_INDENT_NB) ;
                if (str) {
                        g_string_append (stringue, str) ;
                        g_free (str) ;
                        str = NULL ;
                }
                g_string_append (stringue, "\n}");
        }
        if (stringue) {
                str = stringue->str ;
                g_string_free (stringue, FALSE) ;
        }
        return str ;
}


static gchar *
cr_statement_import_rule_to_string (CRStatement const *a_this,
                                    gulong a_indent)
{
        GString *stringue = NULL ;
        gchar *str = NULL;

        g_return_val_if_fail (a_this
                              && a_this->type == AT_IMPORT_RULE_STMT
                              && a_this->kind.import_rule,
                              NULL) ;

        if (a_this->kind.import_rule->url
            && a_this->kind.import_rule->url->stryng) { 
                stringue = (GString *) g_string_new (NULL) ;
                g_return_val_if_fail (stringue, NULL) ;
                str = g_strndup (a_this->kind.import_rule->url->stryng->str,
                                 a_this->kind.import_rule->url->stryng->len);
                cr_utils_dump_n_chars2 (' ', stringue, a_indent);
                if (str) {
                        g_string_append_printf (stringue,
                                                "@import url(\"%s\")", 
                                                str);
                        g_free (str);
                        str = NULL ;
                } else          /*there is no url, so no import rule, get out! */
                        return NULL;

                if (a_this->kind.import_rule->media_list) {
                        GList const *cur = NULL;

                        for (cur = a_this->kind.import_rule->media_list;
                             cur; cur = cur->next) {
                                if (cur->data) {
                                        CRString const *crstr = cur->data;

                                        if (cur->prev) {
                                                g_string_append 
                                                        (stringue, ", ");
                                        }
                                        if (crstr 
                                            && crstr->stryng
                                            && crstr->stryng->str) {
                                                g_string_append_len 
                                                        (stringue,
                                                         crstr->stryng->str,
                                                         crstr->stryng->len) ;
                                        }
                                }
                        }
                }
                g_string_append (stringue, " ;");
        }
        if (stringue) {
                str = stringue->str ;
                g_string_free (stringue, FALSE) ;
                stringue = NULL ;
        }
        return str ;
}


/*******************
 *public functions
 ******************/

/**
 * cr_statement_does_buf_parses_against_core:
 *
 *@a_buf: the buffer to parse.
 *@a_encoding: the character encoding of a_buf.
 *
 *Tries to parse a buffer and says whether if the content of the buffer
 *is a css statement as defined by the "Core CSS Grammar" (chapter 4 of the
 *css spec) or not.
 *
 *Returns TRUE if the buffer parses against the core grammar, false otherwise.
 */
gboolean
cr_statement_does_buf_parses_against_core (const guchar * a_buf,
                                           enum CREncoding a_encoding)
{
        CRParser *parser = NULL;
        enum CRStatus status = CR_OK;
        gboolean result = FALSE;

        parser = cr_parser_new_from_buf ((guchar*)a_buf, strlen ((const char *) a_buf),
                                         a_encoding, FALSE);
        g_return_val_if_fail (parser, FALSE);

        status = cr_parser_set_use_core_grammar (parser, TRUE);
        if (status != CR_OK) {
                goto cleanup;
        }

        status = cr_parser_parse_statement_core (parser);
        if (status == CR_OK) {
                result = TRUE;
        }

      cleanup:
        if (parser) {
                cr_parser_destroy (parser);
        }

        return result;
}

/**
 * cr_statement_parse_from_buf:
 *
 *@a_buf: the buffer to parse.
 *@a_encoding: the character encoding of a_buf.
 *
 *Parses a buffer that contains a css statement and returns 
 *an instance of #CRStatement in case of successful parsing.
 *TODO: at support of "\@import" rules.
 *
 *Returns the newly built instance of #CRStatement in case
 *of successful parsing, NULL otherwise.
 */
CRStatement *
cr_statement_parse_from_buf (const guchar * a_buf, enum CREncoding a_encoding)
{
        CRStatement *result = NULL;

        /*
         *The strategy of this function is "brute force".
         *It tries to parse all the types of CRStatement it knows about.
         *I could do this a smarter way but I don't have the time now.
         *I think I will revisit this when time of performances and
         *pull based incremental parsing comes.
         */

        result = cr_statement_ruleset_parse_from_buf (a_buf, a_encoding);
        if (!result) {
                result = cr_statement_at_charset_rule_parse_from_buf
                        (a_buf, a_encoding);
        } else {
                goto out;
        }

        if (!result) {
                result = cr_statement_at_media_rule_parse_from_buf
                        (a_buf, a_encoding);
        } else {
                goto out;
        }

        if (!result) {
                result = cr_statement_at_charset_rule_parse_from_buf
                        (a_buf, a_encoding);
        } else {
                goto out;
        }

        if (!result) {
                result = cr_statement_font_face_rule_parse_from_buf
                        (a_buf, a_encoding);

        } else {
                goto out;
        }

        if (!result) {
                result = cr_statement_at_page_rule_parse_from_buf
                        (a_buf, a_encoding);
        } else {
                goto out;
        }

        if (!result) {
                result = cr_statement_at_import_rule_parse_from_buf
                        (a_buf, a_encoding);
        } else {
                goto out;
        }

      out:
        return result;
}

/**
 * cr_statement_ruleset_parse_from_buf:
 *
 *@a_buf: the buffer to parse.
 *@a_enc: the character encoding of a_buf.
 *
 *Parses a buffer that contains a ruleset statement and instanciates
 *a #CRStatement of type RULESET_STMT.
 *
 *Returns the newly built instance of #CRStatement in case of successful parsing,
 *NULL otherwise.
 */
CRStatement *
cr_statement_ruleset_parse_from_buf (const guchar * a_buf,
                                     enum CREncoding a_enc)
{
        enum CRStatus status = CR_OK;
        CRStatement *result = NULL;
        CRStatement **resultptr = NULL;
        CRParser *parser = NULL;
        CRDocHandler *sac_handler = NULL;

        g_return_val_if_fail (a_buf, NULL);

        parser = cr_parser_new_from_buf ((guchar*)a_buf, strlen ((const char *) a_buf), 
                                         a_enc, FALSE);

        g_return_val_if_fail (parser, NULL);

        sac_handler = cr_doc_handler_new ();
        g_return_val_if_fail (sac_handler, NULL);

        sac_handler->start_selector = parse_ruleset_start_selector_cb;
        sac_handler->end_selector = parse_ruleset_end_selector_cb;
        sac_handler->property = parse_ruleset_property_cb;
        sac_handler->unrecoverable_error =
                parse_ruleset_unrecoverable_error_cb;

        cr_parser_set_sac_handler (parser, sac_handler);
        cr_parser_try_to_skip_spaces_and_comments (parser);
        status = cr_parser_parse_ruleset (parser);
        if (status != CR_OK) {
                goto cleanup;
        }

	resultptr = &result;
        status = cr_doc_handler_get_result (sac_handler,
                                            (gpointer *) resultptr);
        if (!((status == CR_OK) && result)) {
                if (result) {
                        cr_statement_destroy (result);
                        result = NULL;
                }
        }

      cleanup:
        if (parser) {
                cr_parser_destroy (parser);
                parser = NULL;
                sac_handler = NULL ;
        }
        if (sac_handler) {
                cr_doc_handler_unref (sac_handler);
                sac_handler = NULL;
        }
        return result;
}

/**
 * cr_statement_new_ruleset:
 *
 *@a_sel_list: the list of #CRSimpleSel (selectors)
 *the rule applies to.
 *@a_decl_list: the list of instances of #CRDeclaration
 *that composes the ruleset.
 *@a_media_types: a list of instances of GString that
 *describe the media list this ruleset applies to.
 *
 *Creates a new instance of #CRStatement of type
 *#CRRulSet.
 *
 *Returns the new instance of #CRStatement or NULL if something
 *went wrong.
 */
CRStatement *
cr_statement_new_ruleset (CRStyleSheet * a_sheet,
                          CRSelector * a_sel_list,
                          CRDeclaration * a_decl_list,
                          CRStatement * a_parent_media_rule)
{
        CRStatement *result = NULL;

        g_return_val_if_fail (a_sel_list, NULL);

        if (a_parent_media_rule) {
                g_return_val_if_fail
                        (a_parent_media_rule->type == AT_MEDIA_RULE_STMT,
                         NULL);
                g_return_val_if_fail (a_parent_media_rule->kind.media_rule,
                                      NULL);
        }

        result = (CRStatement *) g_try_malloc (sizeof (CRStatement));

        if (!result) {
                cr_utils_trace_info ("Out of memory");
                return NULL;
        }

        memset (result, 0, sizeof (CRStatement));
        result->type = RULESET_STMT;
        result->kind.ruleset = (CRRuleSet *) g_try_malloc (sizeof (CRRuleSet));

        if (!result->kind.ruleset) {
                cr_utils_trace_info ("Out of memory");
                if (result)
                        g_free (result);
                return NULL;
        }

        memset (result->kind.ruleset, 0, sizeof (CRRuleSet));
        result->kind.ruleset->sel_list = a_sel_list;
        if (a_sel_list)
                cr_selector_ref (a_sel_list);
        result->kind.ruleset->decl_list = a_decl_list;

        if (a_parent_media_rule) {
                result->kind.ruleset->parent_media_rule = a_parent_media_rule;
                a_parent_media_rule->kind.media_rule->rulesets =
                        cr_statement_append
                        (a_parent_media_rule->kind.media_rule->rulesets,
                         result);
        }

        cr_statement_set_parent_sheet (result, a_sheet);

        return result;
}

/**
 * cr_statement_at_media_rule_parse_from_buf:
 *
 *@a_buf: the input to parse.
 *@a_enc: the encoding of the buffer.
 *
 *Parses a buffer that contains an "\@media" declaration
 *and builds an \@media css statement.
 *
 *Returns the \@media statement, or NULL if the buffer could not
 *be successfully parsed.
 */
CRStatement *
cr_statement_at_media_rule_parse_from_buf (const guchar * a_buf,
                                           enum CREncoding a_enc)
{
        CRParser *parser = NULL;
        CRStatement *result = NULL;
        CRStatement **resultptr = NULL;
        CRDocHandler *sac_handler = NULL;
        enum CRStatus status = CR_OK;

        parser = cr_parser_new_from_buf ((guchar*)a_buf, strlen ((const char *) a_buf), 
                                         a_enc, FALSE);
        if (!parser) {
                cr_utils_trace_info ("Instanciation of the parser failed");
                goto cleanup;
        }

        sac_handler = cr_doc_handler_new ();
        if (!sac_handler) {
                cr_utils_trace_info
                        ("Instanciation of the sac handler failed");
                goto cleanup;
        }

        sac_handler->start_media = parse_at_media_start_media_cb;
        sac_handler->start_selector = parse_at_media_start_selector_cb;
        sac_handler->property = parse_at_media_property_cb;
        sac_handler->end_selector = parse_at_media_end_selector_cb;
        sac_handler->end_media = parse_at_media_end_media_cb;
        sac_handler->unrecoverable_error =
                parse_at_media_unrecoverable_error_cb;

        status = cr_parser_set_sac_handler (parser, sac_handler);
        if (status != CR_OK)
                goto cleanup;

        status = cr_parser_try_to_skip_spaces_and_comments (parser);
        if (status != CR_OK)
                goto cleanup;

        status = cr_parser_parse_media (parser);
        if (status != CR_OK)
                goto cleanup;

	resultptr = &result;
        status = cr_doc_handler_get_result (sac_handler,
                                            (gpointer *) resultptr);
        if (status != CR_OK)
                goto cleanup;

      cleanup:

        if (parser) {
                cr_parser_destroy (parser);
                parser = NULL;
                sac_handler = NULL ;
        }
        if (sac_handler) {
                cr_doc_handler_unref (sac_handler);
                sac_handler = NULL;
        }

        return result;
}

/**
 * cr_statement_new_at_media_rule:
 *
 *@a_ruleset: the ruleset statements contained
 *in the \@media rule.
 *@a_media: the media string list. A list of GString pointers.
 *
 *Instanciates an instance of #CRStatement of type
 *AT_MEDIA_RULE_STMT (\@media ruleset).
 *
 */
CRStatement *
cr_statement_new_at_media_rule (CRStyleSheet * a_sheet,
                                CRStatement * a_rulesets, GList * a_media)
{
        CRStatement *result = NULL,
                *cur = NULL;

        if (a_rulesets)
                g_return_val_if_fail (a_rulesets->type == RULESET_STMT, NULL);

        result = (CRStatement *) g_try_malloc (sizeof (CRStatement));

        if (!result) {
                cr_utils_trace_info ("Out of memory");
                return NULL;
        }

        memset (result, 0, sizeof (CRStatement));
        result->type = AT_MEDIA_RULE_STMT;

        result->kind.media_rule = (CRAtMediaRule *) g_try_malloc (sizeof (CRAtMediaRule));
        if (!result->kind.media_rule) {
                cr_utils_trace_info ("Out of memory");
                g_free (result);
                return NULL;
        }
        memset (result->kind.media_rule, 0, sizeof (CRAtMediaRule));
        result->kind.media_rule->rulesets = a_rulesets;
        for (cur = a_rulesets; cur; cur = cur->next) {
                if (cur->type != RULESET_STMT || !cur->kind.ruleset) {
                        cr_utils_trace_info ("Bad parameter a_rulesets. "
                                             "It should be a list of "
                                             "correct ruleset statement only !");
                        goto error;
                }
                cur->kind.ruleset->parent_media_rule = result;
        }

        result->kind.media_rule->media_list = a_media;
        if (a_sheet) {
                cr_statement_set_parent_sheet (result, a_sheet);
        }

        return result;

      error:
        return NULL;
}

/**
 * cr_statement_new_at_import_rule:
 *
 *@a_url: the url to connect to the get the file
 *to be imported.
 *@a_sheet: the imported parsed stylesheet.
 *
 *Creates a new instance of #CRStatment of type
 *#CRAtImportRule.
 *
 *Returns the newly built instance of #CRStatement.
 */
CRStatement *
cr_statement_new_at_import_rule (CRStyleSheet * a_container_sheet,
                                 CRString * a_url,
                                 GList * a_media_list,
                                 CRStyleSheet * a_imported_sheet)
{
        CRStatement *result = NULL;

        result = (CRStatement *) g_try_malloc (sizeof (CRStatement));

        if (!result) {
                cr_utils_trace_info ("Out of memory");
                return NULL;
        }

        memset (result, 0, sizeof (CRStatement));
        result->type = AT_IMPORT_RULE_STMT;

        result->kind.import_rule = (CRAtImportRule *) g_try_malloc (sizeof (CRAtImportRule));

        if (!result->kind.import_rule) {
                cr_utils_trace_info ("Out of memory");
                g_free (result);
                return NULL;
        }

        memset (result->kind.import_rule, 0, sizeof (CRAtImportRule));
        result->kind.import_rule->url = a_url;
        result->kind.import_rule->media_list = a_media_list;
        result->kind.import_rule->sheet = a_imported_sheet;
        if (a_container_sheet)
                cr_statement_set_parent_sheet (result, a_container_sheet);

        return result;
}

/**
 * cr_statement_at_import_rule_parse_from_buf:
 *
 *@a_buf: the buffer to parse.
 *@a_encoding: the encoding of a_buf.
 *
 *Parses a buffer that contains an "\@import" rule and
 *instanciate a #CRStatement of type AT_IMPORT_RULE_STMT
 *
 *Returns the newly built instance of #CRStatement in case of 
 *a successful parsing, NULL otherwise.
 */
CRStatement *
cr_statement_at_import_rule_parse_from_buf (const guchar * a_buf,
                                            enum CREncoding a_encoding)
{
        enum CRStatus status = CR_OK;
        CRParser *parser = NULL;
        CRStatement *result = NULL;
        GList *media_list = NULL;
        CRString *import_string = NULL;
        CRParsingLocation location = {0,0,0} ;

        parser = cr_parser_new_from_buf ((guchar*)a_buf, strlen ((const char *) a_buf),
                                         a_encoding, FALSE);
        if (!parser) {
                cr_utils_trace_info ("Instanciation of parser failed.");
                goto cleanup;
        }

        status = cr_parser_try_to_skip_spaces_and_comments (parser);
        if (status != CR_OK)
                goto cleanup;

        status = cr_parser_parse_import (parser,
                                         &media_list, 
                                         &import_string,
                                         &location);
        if (status != CR_OK || !import_string)
                goto cleanup;

        result = cr_statement_new_at_import_rule (NULL, import_string,
                                                  media_list, NULL);
        if (result) {
                cr_parsing_location_copy (&result->location,
                                          &location) ;
                import_string = NULL;
                media_list = NULL;
        }

 cleanup:
        if (parser) {
                cr_parser_destroy (parser);
                parser = NULL;
        }
        if (media_list) {
                for (; media_list;
                     media_list = g_list_next (media_list)) {
                        if (media_list->data) {
                                cr_string_destroy ((CRString*)media_list->data);
                                media_list->data = NULL;
                        }
                }
                g_list_free (media_list);
                media_list = NULL;
        }
        if (import_string) {
                cr_string_destroy (import_string);
                import_string = NULL;
        }

        return result;
}

/**
 * cr_statement_new_at_page_rule:
 *
 *@a_decl_list: a list of instances of #CRDeclarations
 *which is actually the list of declarations that applies to
 *this page rule.
 *@a_selector: the page rule selector.
 *
 *Creates a new instance of #CRStatement of type
 *#CRAtPageRule.
 *
 *Returns the newly built instance of #CRStatement or NULL
 *in case of error.
 */
CRStatement *
cr_statement_new_at_page_rule (CRStyleSheet * a_sheet,
                               CRDeclaration * a_decl_list,
                               CRString * a_name, CRString * a_pseudo)
{
        CRStatement *result = NULL;

        result = (CRStatement *) g_try_malloc (sizeof (CRStatement));

        if (!result) {
                cr_utils_trace_info ("Out of memory");
                return NULL;
        }

        memset (result, 0, sizeof (CRStatement));
        result->type = AT_PAGE_RULE_STMT;

        result->kind.page_rule = (CRAtPageRule *) g_try_malloc (sizeof (CRAtPageRule));

        if (!result->kind.page_rule) {
                cr_utils_trace_info ("Out of memory");
                g_free (result);
                return NULL;
        }

        memset (result->kind.page_rule, 0, sizeof (CRAtPageRule));
        if (a_decl_list) {
                result->kind.page_rule->decl_list = a_decl_list;
                cr_declaration_ref (a_decl_list);
        }
        result->kind.page_rule->name = a_name;
        result->kind.page_rule->pseudo = a_pseudo;
        if (a_sheet)
                cr_statement_set_parent_sheet (result, a_sheet);

        return result;
}

/**
 * cr_statement_at_page_rule_parse_from_buf:
 *
 *@a_buf: the character buffer to parse.
 *@a_encoding: the character encoding of a_buf.
 *
 *Parses a buffer that contains an "\@page" production and,
 *if the parsing succeeds, builds the page statement.
 *
 *Returns the newly built at page statement in case of successful parsing,
 *NULL otherwise.
 */
CRStatement *
cr_statement_at_page_rule_parse_from_buf (const guchar * a_buf,
                                          enum CREncoding a_encoding)
{
        enum CRStatus status = CR_OK;
        CRParser *parser = NULL;
        CRDocHandler *sac_handler = NULL;
        CRStatement *result = NULL;
        CRStatement **resultptr = NULL;

        g_return_val_if_fail (a_buf, NULL);

        parser = cr_parser_new_from_buf ((guchar*)a_buf, strlen ((const char *) a_buf),
                                         a_encoding, FALSE);
        if (!parser) {
                cr_utils_trace_info ("Instanciation of the parser failed.");
                goto cleanup;
        }

        sac_handler = cr_doc_handler_new ();
        if (!sac_handler) {
                cr_utils_trace_info
                        ("Instanciation of the sac handler failed.");
                goto cleanup;
        }

        sac_handler->start_page = parse_page_start_page_cb;
        sac_handler->property = parse_page_property_cb;
        sac_handler->end_page = parse_page_end_page_cb;
        sac_handler->unrecoverable_error = parse_page_unrecoverable_error_cb;

        status = cr_parser_set_sac_handler (parser, sac_handler);
        if (status != CR_OK)
                goto cleanup;

        /*Now, invoke the parser to parse the "@page production" */
        cr_parser_try_to_skip_spaces_and_comments (parser);
        if (status != CR_OK)
                goto cleanup;
        status = cr_parser_parse_page (parser);
        if (status != CR_OK)
                goto cleanup;

	resultptr = &result;
        status = cr_doc_handler_get_result (sac_handler,
                                            (gpointer *) resultptr);

      cleanup:

        if (parser) {
                cr_parser_destroy (parser);
                parser = NULL;
                sac_handler = NULL ;
        }
        if (sac_handler) {
                cr_doc_handler_unref (sac_handler);
                sac_handler = NULL;
        }
        return result;
}

/**
 * cr_statement_new_at_charset_rule:
 *
 *@a_charset: the string representing the charset.
 *Note that the newly built instance of #CRStatement becomes
 *the owner of a_charset. The caller must not free a_charset !!!.
 *
 *Creates a new instance of #CRStatement of type
 *#CRAtCharsetRule.
 *
 *Returns the newly built instance of #CRStatement or NULL
 *if an error arises.
 */
CRStatement *
cr_statement_new_at_charset_rule (CRStyleSheet * a_sheet, 
                                  CRString * a_charset)
{
        CRStatement *result = NULL;

        g_return_val_if_fail (a_charset, NULL);

        result = (CRStatement *) g_try_malloc (sizeof (CRStatement));

        if (!result) {
                cr_utils_trace_info ("Out of memory");
                return NULL;
        }

        memset (result, 0, sizeof (CRStatement));
        result->type = AT_CHARSET_RULE_STMT;

        result->kind.charset_rule = (CRAtCharsetRule *) g_try_malloc (sizeof (CRAtCharsetRule));

        if (!result->kind.charset_rule) {
                cr_utils_trace_info ("Out of memory");
                g_free (result);
                return NULL;
        }
        memset (result->kind.charset_rule, 0, sizeof (CRAtCharsetRule));
        result->kind.charset_rule->charset = a_charset;
        cr_statement_set_parent_sheet (result, a_sheet);

        return result;
}

/**
 * cr_statement_at_charset_rule_parse_from_buf:
 *
 *@a_buf: the buffer to parse.
 *@a_encoding: the character encoding of the buffer.
 *
 *Parses a buffer that contains an '\@charset' rule and
 *creates an instance of #CRStatement of type AT_CHARSET_RULE_STMT.
 *
 *Returns the newly built instance of #CRStatement.
 */
CRStatement *
cr_statement_at_charset_rule_parse_from_buf (const guchar * a_buf,
                                             enum CREncoding a_encoding)
{
        enum CRStatus status = CR_OK;
        CRParser *parser = NULL;
        CRStatement *result = NULL;
        CRString *charset = NULL;

        g_return_val_if_fail (a_buf, NULL);

        parser = cr_parser_new_from_buf ((guchar*)a_buf, strlen ((const char *) a_buf),
                                         a_encoding, FALSE);
        if (!parser) {
                cr_utils_trace_info ("Instanciation of the parser failed.");
                goto cleanup;
        }

        /*Now, invoke the parser to parse the "@charset production" */
        cr_parser_try_to_skip_spaces_and_comments (parser);
        if (status != CR_OK)
                goto cleanup;
        status = cr_parser_parse_charset (parser, &charset, NULL);
        if (status != CR_OK || !charset)
                goto cleanup;

        result = cr_statement_new_at_charset_rule (NULL, charset);
        if (result)
                charset = NULL;

      cleanup:

        if (parser) {
                cr_parser_destroy (parser);
                parser = NULL;
        }
        if (charset) {
                cr_string_destroy (charset);
        }

        return result;
}

/**
 * cr_statement_new_at_font_face_rule:
 *
 *@a_font_decls: a list of instances of #CRDeclaration. Each declaration
 *is actually a font declaration.
 *
 *Creates an instance of #CRStatement of type #CRAtFontFaceRule.
 *
 *Returns the newly built instance of #CRStatement.
 */
CRStatement *
cr_statement_new_at_font_face_rule (CRStyleSheet * a_sheet,
                                    CRDeclaration * a_font_decls)
{
        CRStatement *result = NULL;

        result = (CRStatement *) g_try_malloc (sizeof (CRStatement));

        if (!result) {
                cr_utils_trace_info ("Out of memory");
                return NULL;
        }
        memset (result, 0, sizeof (CRStatement));
        result->type = AT_FONT_FACE_RULE_STMT;

        result->kind.font_face_rule = (CRAtFontFaceRule *) g_try_malloc
                (sizeof (CRAtFontFaceRule));

        if (!result->kind.font_face_rule) {
                cr_utils_trace_info ("Out of memory");
                g_free (result);
                return NULL;
        }
        memset (result->kind.font_face_rule, 0, sizeof (CRAtFontFaceRule));

        result->kind.font_face_rule->decl_list = a_font_decls;
        if (a_sheet)
                cr_statement_set_parent_sheet (result, a_sheet);

        return result;
}

/**
 * cr_statement_font_face_rule_parse_from_buf:
 *
 *
 *@a_buf: the buffer to parse.
 *@a_encoding: the character encoding of a_buf.
 *
 *Parses a buffer that contains an "\@font-face" rule and builds
 *an instance of #CRStatement of type AT_FONT_FACE_RULE_STMT out of it.
 *
 *Returns the newly built instance of #CRStatement in case of successufull
 *parsing, NULL otherwise.
 */
CRStatement *
cr_statement_font_face_rule_parse_from_buf (const guchar * a_buf,
                                            enum CREncoding a_encoding)
{
        CRStatement *result = NULL;
        CRStatement **resultptr = NULL;
        CRParser *parser = NULL;
        CRDocHandler *sac_handler = NULL;
        enum CRStatus status = CR_OK;

        parser = cr_parser_new_from_buf ((guchar*)a_buf, strlen ((const char *) a_buf),
                                         a_encoding, FALSE);
        if (!parser)
                goto cleanup;

        sac_handler = cr_doc_handler_new ();
        if (!sac_handler)
                goto cleanup;

        /*
         *set sac callbacks here
         */
        sac_handler->start_font_face = parse_font_face_start_font_face_cb;
        sac_handler->property = parse_font_face_property_cb;
        sac_handler->end_font_face = parse_font_face_end_font_face_cb;
        sac_handler->unrecoverable_error =
                parse_font_face_unrecoverable_error_cb;

        status = cr_parser_set_sac_handler (parser, sac_handler);
        if (status != CR_OK)
                goto cleanup;

        /*
         *cleanup spaces of comment that may be there before the real
         *"@font-face" thing.
         */
        status = cr_parser_try_to_skip_spaces_and_comments (parser);
        if (status != CR_OK)
                goto cleanup;

        status = cr_parser_parse_font_face (parser);
        if (status != CR_OK)
                goto cleanup;

	resultptr = &result;
        status = cr_doc_handler_get_result (sac_handler,
                                            (gpointer *) resultptr);
        if (status != CR_OK || !result)
                goto cleanup;

      cleanup:
        if (parser) {
                cr_parser_destroy (parser);
                parser = NULL;
                sac_handler = NULL ;
        }
        if (sac_handler) {
                cr_doc_handler_unref (sac_handler);
                sac_handler = NULL;
        }
        return result;
}

/**
 * cr_statement_set_parent_sheet:
 *
 *@a_this: the current instance of #CRStatement.
 *@a_sheet: the sheet that contains the current statement.
 *
 *Sets the container stylesheet.
 *
 *Returns CR_OK upon successful completion, an error code otherwise.
 */
enum CRStatus
cr_statement_set_parent_sheet (CRStatement * a_this, CRStyleSheet * a_sheet)
{
        g_return_val_if_fail (a_this, CR_BAD_PARAM_ERROR);
        a_this->parent_sheet = a_sheet;
        return CR_OK;
}

/**
 * cr_statement_get_parent_sheet:
 *
 *@a_this: the current #CRStatement.
 *@a_sheet: out parameter. A pointer to the sheets that
 *
 *Gets the sheets that contains the current statement.
 *
 *Returns CR_OK upon successful completion, an error code otherwise.
 */
enum CRStatus
cr_statement_get_parent_sheet (CRStatement * a_this, CRStyleSheet ** a_sheet)
{
        g_return_val_if_fail (a_this && a_sheet, CR_BAD_PARAM_ERROR);
        *a_sheet = a_this->parent_sheet;
        return CR_OK;
}

/**
 * cr_statement_append:
 *
 *@a_this: the current instance of the statement list.
 *@a_new: a_new the new instance of #CRStatement to append.
 *
 *Appends a new statement to the statement list.
 *
 *Returns the new list statement list, or NULL in cas of failure.
 */
CRStatement *
cr_statement_append (CRStatement * a_this, CRStatement * a_new)
{
        CRStatement *cur = NULL;

        g_return_val_if_fail (a_new, NULL);

        if (!a_this) {
                return a_new;
        }

        /*walk forward in the current list to find the tail list element */
        for (cur = a_this; cur && cur->next; cur = cur->next) ;

        cur->next = a_new;
        a_new->prev = cur;

        return a_this;
}

/**
 * cr_statement_prepend:
 *
 *@a_this: the current instance of #CRStatement.
 *@a_new: the new statement to prepend.
 *
 *Prepends the an instance of #CRStatement to
 *the current statement list.
 *
 *Returns the new list with the new statement prepended,
 *or NULL in case of an error.
 */
CRStatement *
cr_statement_prepend (CRStatement * a_this, CRStatement * a_new)
{
        CRStatement *cur = NULL;

        g_return_val_if_fail (a_new, NULL);

        if (!a_this)
                return a_new;

        a_new->next = a_this;
        a_this->prev = a_new;

        /*walk backward in the prepended list to find the head list element */
        for (cur = a_new; cur && cur->prev; cur = cur->prev) ;

        return cur;
}

/**
 * cr_statement_unlink:
 *
 *@a_this: the current statements list.
 *@a_to_unlink: the statement to unlink from the list.
 *
 *Unlinks a statement from the statements list.
 *
 *Returns the new list where a_to_unlink has been unlinked
 *from, or NULL in case of error.
 */
CRStatement *
cr_statement_unlink (CRStatement * a_stmt)
{
        CRStatement *result = a_stmt;

        g_return_val_if_fail (result, NULL);

        /**
         *Some sanity checks first
         */
        if (a_stmt->next) {
                g_return_val_if_fail (a_stmt->next->prev == a_stmt, NULL);
        }
        if (a_stmt->prev) {
                g_return_val_if_fail (a_stmt->prev->next == a_stmt, NULL);
        }

        /**
         *Now, the real unlinking job.
         */
        if (a_stmt->next) {
                a_stmt->next->prev = a_stmt->prev;
        }
        if (a_stmt->prev) {
                a_stmt->prev->next = a_stmt->next;
        }

        if (a_stmt->parent_sheet
            && a_stmt->parent_sheet->statements == a_stmt) {
                a_stmt->parent_sheet->statements =
                        a_stmt->parent_sheet->statements->next;
        }

        a_stmt->next = NULL;
        a_stmt->prev = NULL;
        a_stmt->parent_sheet = NULL;

        return result;
}

/**
 * cr_statement_nr_rules:
 *
 *@a_this: the current instance of #CRStatement.
 *
 *Gets the number of rules in the statement list;
 *
 *Returns number of rules in the statement list.
 */
gint
cr_statement_nr_rules (CRStatement const * a_this)
{
        CRStatement const *cur = NULL;
        int nr = 0;

        g_return_val_if_fail (a_this, -1);

        for (cur = a_this; cur; cur = cur->next)
                nr++;
        return nr;
}

/**
 * cr_statement_get_from_list:
 *
 *@a_this: the current instance of #CRStatement.
 *@itemnr: the index into the statement list.
 *
 *Use an index to get a CRStatement from the statement list.
 *
 *Returns CRStatement at position itemnr, if itemnr > number of statements - 1,
 *it will return NULL.
 */
CRStatement *
cr_statement_get_from_list (CRStatement * a_this, int itemnr)
{
        CRStatement *cur = NULL;
        int nr = 0;

        g_return_val_if_fail (a_this, NULL);

        for (cur = a_this; cur; cur = cur->next)
                if (nr++ == itemnr)
                        return cur;
        return NULL;
}

/**
 * cr_statement_ruleset_set_sel_list:
 *
 *@a_this: the current ruleset statement.
 *@a_sel_list: the selector list to set. Note
 *that this function increments the ref count of a_sel_list.
 *The sel list will be destroyed at the destruction of the
 *current instance of #CRStatement.
 *
 *Sets a selector list to a ruleset statement.
 *
 *Returns CR_OK upon successful completion, an error code otherwise.
 */
enum CRStatus
cr_statement_ruleset_set_sel_list (CRStatement * a_this,
                                   CRSelector * a_sel_list)
{
        g_return_val_if_fail (a_this && a_this->type == RULESET_STMT,
                              CR_BAD_PARAM_ERROR);

        if (a_this->kind.ruleset->sel_list)
                cr_selector_unref (a_this->kind.ruleset->sel_list);

        a_this->kind.ruleset->sel_list = a_sel_list;

        if (a_sel_list)
                cr_selector_ref (a_sel_list);

        return CR_OK;
}

/**
 * cr_statement_ruleset_get_declarations:
 *
 *@a_this: the current instance of #CRStatement.
 *@a_decl_list: out parameter. A pointer to the returned
 *list of declaration. Must not be NULL.
 *
 *Gets a pointer to the list of declaration contained
 *in the ruleset statement.
 *
 *Returns CR_OK upon successful completion, an error code if something
 *bad happened.
 */
enum CRStatus
cr_statement_ruleset_get_declarations (CRStatement * a_this,
                                       CRDeclaration ** a_decl_list)
{
        g_return_val_if_fail (a_this
                              && a_this->type == RULESET_STMT
                              && a_this->kind.ruleset
                              && a_decl_list, CR_BAD_PARAM_ERROR);

        *a_decl_list = a_this->kind.ruleset->decl_list;

        return CR_OK;
}

/**
 * cr_statement_ruleset_get_sel_list:
 *
 *@a_this: the current ruleset statement.
 *@a_list: out parameter. The returned selector list,
 *if and only if the function returned CR_OK.
 *
 *Gets a pointer to the selector list contained in
 *the current ruleset statement.
 *
 *Returns CR_OK upon successful completion, an error code otherwise.
 */
enum CRStatus
cr_statement_ruleset_get_sel_list (CRStatement const * a_this, CRSelector ** a_list)
{
        g_return_val_if_fail (a_this && a_this->type == RULESET_STMT
                              && a_this->kind.ruleset, CR_BAD_PARAM_ERROR);

        *a_list = a_this->kind.ruleset->sel_list;

        return CR_OK;
}

/**
 * cr_statement_ruleset_set_decl_list:
 *
 *@a_this: the current ruleset statement.
 *@a_list: the declaration list to be added to the current
 *ruleset statement.
 *
 *Sets a declaration list to the current ruleset statement.
 *
 *Returns CR_OK upon successful completion, an error code otherwise.
 */
enum CRStatus
cr_statement_ruleset_set_decl_list (CRStatement * a_this,
                                    CRDeclaration * a_list)
{
        g_return_val_if_fail (a_this && a_this->type == RULESET_STMT
                              && a_this->kind.ruleset, CR_BAD_PARAM_ERROR);

        if (a_this->kind.ruleset->decl_list == a_list)
                return CR_OK;

        if (a_this->kind.ruleset->sel_list) {
                cr_declaration_destroy (a_this->kind.ruleset->decl_list);
        }

        a_this->kind.ruleset->sel_list = NULL;

        return CR_OK;
}

/**
 * cr_statement_ruleset_append_decl2:
 *
 *@a_this: the current statement.
 *@a_prop: the property of the declaration.
 *@a_value: the value of the declaration.
 *
 *Appends a declaration to the current ruleset statement.
 *
 *Returns CR_OK upon successful completion, an error code
 *otherwise.
 */
enum CRStatus
cr_statement_ruleset_append_decl2 (CRStatement * a_this,
                                   CRString * a_prop, 
                                   CRTerm * a_value)
{
        CRDeclaration *new_decls = NULL;

        g_return_val_if_fail (a_this && a_this->type == RULESET_STMT
                              && a_this->kind.ruleset, CR_BAD_PARAM_ERROR);

        new_decls = cr_declaration_append2
                (a_this->kind.ruleset->decl_list, 
                 a_prop, a_value);
        g_return_val_if_fail (new_decls, CR_ERROR);
        a_this->kind.ruleset->decl_list = new_decls;

        return CR_OK;
}

/**
 * cr_statement_ruleset_append_decl:
 *
 *Appends a declaration to the current statement.
 *
 *@a_this: the current statement.
 *@a_declaration: the declaration to append.
 *
 *Returns CR_OK upon sucessful completion, an error code
 *otherwise.
 */
enum CRStatus
cr_statement_ruleset_append_decl (CRStatement * a_this,
                                  CRDeclaration * a_decl)
{
        CRDeclaration *new_decls = NULL;

        g_return_val_if_fail (a_this && a_this->type == RULESET_STMT
                              && a_this->kind.ruleset, CR_BAD_PARAM_ERROR);

        new_decls = cr_declaration_append
                (a_this->kind.ruleset->decl_list, a_decl);
        g_return_val_if_fail (new_decls, CR_ERROR);
        a_this->kind.ruleset->decl_list = new_decls;

        return CR_OK;
}

/**
 * cr_statement_at_import_rule_set_imported_sheet:
 *
 *Sets a stylesheet to the current \@import rule.
 *@a_this: the current \@import rule.
 *@a_sheet: the stylesheet. The stylesheet is owned
 *by the current instance of #CRStatement, that is, the 
 *stylesheet will be destroyed when the current instance
 *of #CRStatement is destroyed.
 *
 *Returns CR_OK upon successful completion, an error code otherwise.
 */
enum CRStatus
cr_statement_at_import_rule_set_imported_sheet (CRStatement * a_this,
                                                CRStyleSheet * a_sheet)
{
        g_return_val_if_fail (a_this
                              && a_this->type == AT_IMPORT_RULE_STMT
                              && a_this->kind.import_rule,
                              CR_BAD_PARAM_ERROR);

        a_this->kind.import_rule->sheet = a_sheet;

        return CR_OK;
}

/**
 * cr_statement_at_import_rule_get_imported_sheet:
 *
 *@a_this: the current \@import rule statement.
 *@a_sheet: out parameter. The returned stylesheet if and
 *only if the function returns CR_OK.
 *
 *Gets the stylesheet contained by the \@import rule statement.
 *Returns CR_OK upon sucessful completion, an error code otherwise.
 */
enum CRStatus
cr_statement_at_import_rule_get_imported_sheet (CRStatement * a_this,
                                                CRStyleSheet ** a_sheet)
{
        g_return_val_if_fail (a_this
                              && a_this->type == AT_IMPORT_RULE_STMT
                              && a_this->kind.import_rule,
                              CR_BAD_PARAM_ERROR);
        *a_sheet = a_this->kind.import_rule->sheet;
        return CR_OK;

}

/**
 * cr_statement_at_import_rule_set_url:
 *
 *@a_this: the current \@import rule statement.
 *@a_url: the url to set.
 *
 *Sets an url to the current \@import rule statement.
 *
 *Returns CR_OK upon successful completion, an error code otherwise.
 */
enum CRStatus
cr_statement_at_import_rule_set_url (CRStatement * a_this, 
                                     CRString * a_url)
{
        g_return_val_if_fail (a_this
                              && a_this->type == AT_IMPORT_RULE_STMT
                              && a_this->kind.import_rule,
                              CR_BAD_PARAM_ERROR);

        if (a_this->kind.import_rule->url) {
                cr_string_destroy (a_this->kind.import_rule->url);
        }

        a_this->kind.import_rule->url = a_url;

        return CR_OK;
}

/**
 * cr_statement_at_import_rule_get_url:
 *
 *@a_this: the current \@import rule statement.
 *@a_url: out parameter. The returned url if
 *and only if the function returned CR_OK.
 *
 *Gets the url of the \@import rule statement.
 *Returns CR_OK upon successful completion, an error code otherwise.
 */
enum CRStatus
cr_statement_at_import_rule_get_url (CRStatement const * a_this,
                                     CRString ** a_url)
{
        g_return_val_if_fail (a_this
                              && a_this->type == AT_IMPORT_RULE_STMT
                              && a_this->kind.import_rule,
                              CR_BAD_PARAM_ERROR);

        *a_url = a_this->kind.import_rule->url;

        return CR_OK;
}

/**
 * cr_statement_at_media_nr_rules:
 *
 *@a_this: the current instance of #CRStatement.
 *
 *Returns the number of rules in the media rule;
 */
int
cr_statement_at_media_nr_rules (CRStatement const * a_this)
{
        g_return_val_if_fail (a_this
                              && a_this->type == AT_MEDIA_RULE_STMT
                              && a_this->kind.media_rule, CR_BAD_PARAM_ERROR);

        return cr_statement_nr_rules (a_this->kind.media_rule->rulesets);
}

/**
 * cr_statement_at_media_get_from_list:
 *
 *@a_this: the current instance of #CRStatement.
 *@itemnr: the index into the media rule list of rules.
 *
 *Use an index to get a CRStatement from the media rule list of rules.
 *
 *Returns CRStatement at position itemnr, if itemnr > number of rules - 1,
 *it will return NULL.
 */
CRStatement *
cr_statement_at_media_get_from_list (CRStatement * a_this, int itemnr)
{
        g_return_val_if_fail (a_this
                              && a_this->type == AT_MEDIA_RULE_STMT
                              && a_this->kind.media_rule, NULL);

        return cr_statement_get_from_list (a_this->kind.media_rule->rulesets,
                                           itemnr);
}

/**
 * cr_statement_at_page_rule_set_declarations:
 *
 *@a_this: the current \@page rule statement.
 *@a_decl_list: the declaration list to add. Will be freed
 *by the current instance of #CRStatement when it is destroyed.
 *
 *Sets a declaration list to the current \@page rule statement.
 *
 *Returns CR_OK upon successful completion, an error code otherwise.
 */
enum CRStatus
cr_statement_at_page_rule_set_declarations (CRStatement * a_this,
                                            CRDeclaration * a_decl_list)
{
        g_return_val_if_fail (a_this
                              && a_this->type == AT_PAGE_RULE_STMT
                              && a_this->kind.page_rule, CR_BAD_PARAM_ERROR);

        if (a_this->kind.page_rule->decl_list) {
                cr_declaration_unref (a_this->kind.page_rule->decl_list);
        }

        a_this->kind.page_rule->decl_list = a_decl_list;

        if (a_decl_list) {
                cr_declaration_ref (a_decl_list);
        }

        return CR_OK;
}

/**
 * cr_statement_at_page_rule_get_declarations:
 *
 *@a_this: the current \@page rule statement.
 *@a_decl_list: out parameter. The returned declaration list.
 *
 *Gets the declaration list associated to the current \@page rule
 *statement.
 *
 *Returns CR_OK upon successful completion, an error code otherwise.
 */
enum CRStatus
cr_statement_at_page_rule_get_declarations (CRStatement * a_this,
                                            CRDeclaration ** a_decl_list)
{
        g_return_val_if_fail (a_this
                              && a_this->type == AT_PAGE_RULE_STMT
                              && a_this->kind.page_rule, CR_BAD_PARAM_ERROR);

        *a_decl_list = a_this->kind.page_rule->decl_list;

        return CR_OK;
}

/**
 * cr_statement_at_charset_rule_set_charset:
 *
 *
 *@a_this: the current \@charset rule statement.
 *@a_charset: the charset to set.
 *
 *Sets the charset of the current \@charset rule statement.
 *
 *Returns CR_OK upon successful completion, an error code otherwise.
 */
enum CRStatus
cr_statement_at_charset_rule_set_charset (CRStatement * a_this,
                                          CRString * a_charset)
{
        g_return_val_if_fail (a_this
                              && a_this->type == AT_CHARSET_RULE_STMT
                              && a_this->kind.charset_rule,
                              CR_BAD_PARAM_ERROR);

        if (a_this->kind.charset_rule->charset) {
                cr_string_destroy (a_this->kind.charset_rule->charset);
        }
        a_this->kind.charset_rule->charset = a_charset;
        return CR_OK;
}

/**
 * cr_statement_at_charset_rule_get_charset:
 *@a_this: the current \@charset rule statement.
 *@a_charset: out parameter. The returned charset string if
 *and only if the function returned CR_OK.
 *
 *Gets the charset string associated to the current
 *\@charset rule statement.
 *
 * Returns CR_OK upon successful completion, an error code otherwise.
 */
enum CRStatus
cr_statement_at_charset_rule_get_charset (CRStatement const * a_this,
                                          CRString ** a_charset)
{
        g_return_val_if_fail (a_this
                              && a_this->type == AT_CHARSET_RULE_STMT
                              && a_this->kind.charset_rule,
                              CR_BAD_PARAM_ERROR);

        *a_charset = a_this->kind.charset_rule->charset;

        return CR_OK;
}

/**
 * cr_statement_at_font_face_rule_set_decls:
 *
 *@a_this: the current \@font-face rule statement.
 *@a_decls: the declarations list to set.
 *
 *Sets a declaration list to the current \@font-face rule statement.
 *
 *Returns CR_OK upon successful completion, an error code otherwise.
 */
enum CRStatus
cr_statement_at_font_face_rule_set_decls (CRStatement * a_this,
                                          CRDeclaration * a_decls)
{
        g_return_val_if_fail (a_this
                              && a_this->type == AT_FONT_FACE_RULE_STMT
                              && a_this->kind.font_face_rule,
                              CR_BAD_PARAM_ERROR);

        if (a_this->kind.font_face_rule->decl_list) {
                cr_declaration_unref (a_this->kind.font_face_rule->decl_list);
        }

        a_this->kind.font_face_rule->decl_list = a_decls;
        cr_declaration_ref (a_decls);

        return CR_OK;
}

/**
 * cr_statement_at_font_face_rule_get_decls:
 *
 *@a_this: the current \@font-face rule statement.
 *@a_decls: out parameter. The returned declaration list if
 *and only if this function returns CR_OK.
 *
 *Gets the declaration list associated to the current instance
 *of \@font-face rule statement.
 *
 *Returns CR_OK upon successful completion, an error code otherwise.
 */
enum CRStatus
cr_statement_at_font_face_rule_get_decls (CRStatement * a_this,
                                          CRDeclaration ** a_decls)
{
        g_return_val_if_fail (a_this
                              && a_this->type == AT_FONT_FACE_RULE_STMT
                              && a_this->kind.font_face_rule,
                              CR_BAD_PARAM_ERROR);

        *a_decls = a_this->kind.font_face_rule->decl_list;

        return CR_OK;
}

/**
 * cr_statement_at_font_face_rule_add_decl:
 *
 *@a_this: the current \@font-face rule statement.
 *@a_prop: the property of the declaration.
 *@a_value: the value of the declaration.
 *
 *Adds a declaration to the current \@font-face rule
 *statement.
 *
 *Returns CR_OK upon successful completion, an error code otherwise.
 */
enum CRStatus
cr_statement_at_font_face_rule_add_decl (CRStatement * a_this,
                                         CRString * a_prop, CRTerm * a_value)
{
        CRDeclaration *decls = NULL;

        g_return_val_if_fail (a_this
                              && a_this->type == AT_FONT_FACE_RULE_STMT
                              && a_this->kind.font_face_rule,
                              CR_BAD_PARAM_ERROR);

        decls = cr_declaration_append2
                (a_this->kind.font_face_rule->decl_list, 
                 a_prop, a_value);

        g_return_val_if_fail (decls, CR_ERROR);

        if (a_this->kind.font_face_rule->decl_list == NULL)
                cr_declaration_ref (decls);

        a_this->kind.font_face_rule->decl_list = decls;

        return CR_OK;
}


/**
 * cr_statement_to_string:
 *
 *@a_this: the current statement to serialize
 *@a_indent: the number of white space of indentation.
 *
 *Serializes a css statement into a string
 *
 *Returns the serialized statement. Must be freed by the caller
 *using g_free().
 */
gchar *
cr_statement_to_string (CRStatement const * a_this, gulong a_indent)
{
        gchar *str = NULL ;

        if (!a_this)
                return NULL;

        switch (a_this->type) {
        case RULESET_STMT:
                str = cr_statement_ruleset_to_string 
                        (a_this, a_indent);
                break;

        case AT_FONT_FACE_RULE_STMT:
                str = cr_statement_font_face_rule_to_string 
                        (a_this, a_indent) ;
                break;

        case AT_CHARSET_RULE_STMT:
                str = cr_statement_charset_to_string
                        (a_this, a_indent);                
                break;

        case AT_PAGE_RULE_STMT:
                str = cr_statement_at_page_rule_to_string
                        (a_this, a_indent);
                break;

        case AT_MEDIA_RULE_STMT:
                str = cr_statement_media_rule_to_string
                        (a_this, a_indent);
                break;

        case AT_IMPORT_RULE_STMT:
                str = cr_statement_import_rule_to_string
                        (a_this, a_indent);
                break;

        default:
                cr_utils_trace_info ("Statement unrecognized");
                break;
        }
        return str ;
}

gchar*
cr_statement_list_to_string (CRStatement const *a_this, gulong a_indent)
{
        CRStatement const *cur_stmt = NULL ;
        GString *stringue = NULL ;
        gchar *str = NULL ;

        g_return_val_if_fail (a_this, NULL) ;

        stringue = g_string_new (NULL) ;
        if (!stringue) {
                cr_utils_trace_info ("Out of memory") ;
                return NULL ;
        }
        for (cur_stmt = a_this ; cur_stmt;
             cur_stmt = cur_stmt->next) {
                str = cr_statement_to_string (cur_stmt, a_indent) ;
                if (str) {
                        if (!cur_stmt->prev) {
                                g_string_append (stringue, str) ;
                        } else {
                                g_string_append_printf 
                                        (stringue, "\n%s", str) ;
                        }
                        g_free (str) ;
                        str = NULL ;
                }                
        }
        str = stringue->str ;
        g_string_free (stringue, FALSE) ;
        return str ;
}

/**
 * cr_statement_dump:
 *
 *@a_this: the current css2 statement.
 *@a_fp: the destination file pointer.
 *@a_indent: the number of white space indentation characters.
 *
 *Dumps the css2 statement to a file.
 */
void
cr_statement_dump (CRStatement const * a_this, FILE * a_fp, gulong a_indent)
{
        gchar *str = NULL ;

        if (!a_this)
                return;

        str = cr_statement_to_string (a_this, a_indent) ;
        if (str) {
                fprintf (a_fp, "%s",str) ;
                g_free (str) ;
                str = NULL ;
        }
}

/**
 * cr_statement_dump_ruleset:
 *
 *@a_this: the current instance of #CRStatement.
 *@a_fp: the destination file pointer.
 *@a_indent: the number of indentation white spaces to add.
 *
 *Dumps a ruleset statement to a file.
 */
void
cr_statement_dump_ruleset (CRStatement const * a_this, FILE * a_fp, glong a_indent)
{
        gchar *str = NULL;

        g_return_if_fail (a_fp && a_this);
        str = cr_statement_ruleset_to_string (a_this, a_indent);
        if (str) {
                fprintf (a_fp, "%s", str);
                g_free (str);
                str = NULL;
        }
}

/**
 * cr_statement_dump_font_face_rule:
 *
 *@a_this: the current instance of font face rule statement.
 *@a_fp: the destination file pointer.
 *@a_indent: the number of white space indentation.
 *
 *Dumps a font face rule statement to a file.
 */
void
cr_statement_dump_font_face_rule (CRStatement const * a_this, FILE * a_fp,
                                  glong a_indent)
{
        gchar *str = NULL ;
        g_return_if_fail (a_this 
                          && a_this->type == AT_FONT_FACE_RULE_STMT);

        str = cr_statement_font_face_rule_to_string (a_this,
                                                     a_indent) ;
        if (str) {
                fprintf (a_fp, "%s", str) ;
                g_free (str) ;
                str = NULL ;
        }
}

/**
 * cr_statement_dump_charset:
 *
 *@a_this: the current instance of the \@charset rule statement.
 *@a_fp: the destination file pointer.
 *@a_indent: the number of indentation white spaces.
 *
 *Dumps an \@charset rule statement to a file.
 */
void
cr_statement_dump_charset (CRStatement const * a_this, FILE * a_fp, gulong a_indent)
{
        gchar *str = NULL;

        g_return_if_fail (a_this && a_this->type == AT_CHARSET_RULE_STMT);

        str = cr_statement_charset_to_string (a_this,
                                              a_indent) ;
        if (str) {
                fprintf (a_fp, "%s", str) ;
                g_free (str) ;
                str = NULL ;
        }
}


/**
 * cr_statement_dump_page:
 *
 *@a_this: the statement to dump on stdout.
 *@a_fp: the destination file pointer.
 *@a_indent: the number of indentation white spaces.
 *
 *Dumps an \@page rule statement on stdout.
 */
void
cr_statement_dump_page (CRStatement const * a_this, FILE * a_fp, gulong a_indent)
{
        gchar *str = NULL;

        g_return_if_fail (a_this
                          && a_this->type == AT_PAGE_RULE_STMT
                          && a_this->kind.page_rule);

        str = cr_statement_at_page_rule_to_string (a_this, a_indent) ;
        if (str) {
                fprintf (a_fp, "%s", str);
                g_free (str) ;
                str = NULL ; 
        }
}


/**
 * cr_statement_dump_media_rule:
 *
 *@a_this: the statement to dump.
 *@a_fp: the destination file pointer
 *@a_indent: the number of white spaces indentation.
 *
 *Dumps an \@media rule statement to a file.
 */
void
cr_statement_dump_media_rule (CRStatement const * a_this,
                              FILE * a_fp,
                              gulong a_indent)
{
        gchar *str = NULL ;
        g_return_if_fail (a_this->type == AT_MEDIA_RULE_STMT);

        str = cr_statement_media_rule_to_string (a_this, a_indent) ;
        if (str) {
                fprintf (a_fp, "%s", str) ;
                g_free (str) ;
                str = NULL ;
        }
}

/**
 * cr_statement_dump_import_rule:
 *
 *@a_fp: the destination file pointer.
 *@a_indent: the number of white space indentations.
 *
 *Dumps an \@import rule statement to a file.
 */
void
cr_statement_dump_import_rule (CRStatement const * a_this, FILE * a_fp,
                               gulong a_indent)
{
        gchar *str = NULL ;
        g_return_if_fail (a_this
                          && a_this->type == AT_IMPORT_RULE_STMT
                          && a_fp
                          && a_this->kind.import_rule);

        str = cr_statement_import_rule_to_string (a_this, a_indent) ;
        if (str) {
                fprintf (a_fp, "%s", str) ;
                g_free (str) ;
                str = NULL ;
        }
}

/**
 * cr_statement_destroy:
 *
 * @a_this: the current instance of #CRStatement.
 *
 *Destructor of #CRStatement.
 */
void
cr_statement_destroy (CRStatement * a_this)
{
        CRStatement *cur = NULL;

        g_return_if_fail (a_this);

        /*go get the tail of the list */
        for (cur = a_this; cur && cur->next; cur = cur->next) {
                cr_statement_clear (cur);
        }

        if (cur)
                cr_statement_clear (cur);

        if (cur->prev == NULL) {
                g_free (a_this);
                return;
        }

        /*walk backward and free next element */
        for (cur = cur->prev; cur && cur->prev; cur = cur->prev) {
                if (cur->next) {
                        g_free (cur->next);
                        cur->next = NULL;
                }
        }

        if (!cur)
                return;

        /*free the one remaining list */
        if (cur->next) {
                g_free (cur->next);
                cur->next = NULL;
        }

        g_free (cur);
        cur = NULL;
}
