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

/*

 * This file is part of The Croco Library

 *

 * Copyright (C) 2002-2003 Dodji Seketeli <dodji@seketeli.org>

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of version 3 of the GNU 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 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

 */

/*

 *$Id: cr-enc-handler.c,v 1.8 2005/05/10 19:48:56 dodji Exp $

 */

/**

 *@file

 *The definition of the #CREncHandler class.

 */

#include <config.h>

#include "cr-enc-handler.h"

#include "cr-utils.h"

#include <string.h>

struct CREncAlias {

        const gchar *name;

        enum CREncoding encoding;

};

static struct CREncAlias gv_default_aliases[] = {

        {"UTF-8", CR_UTF_8},

        {"UTF_8", CR_UTF_8},

        {"UTF8", CR_UTF_8},

        {"UTF-16", CR_UTF_16},

        {"UTF_16", CR_UTF_16},

        {"UTF16", CR_UTF_16},

        {"UCS1", CR_UCS_1},

        {"UCS-1", CR_UCS_1},

        {"UCS_1", CR_UCS_1},

        {"ISO-8859-1", CR_UCS_1},

        {"ISO_8859-1", CR_UCS_1},

        {"UCS-1", CR_UCS_1},

        {"UCS_1", CR_UCS_1},

        {"UCS4", CR_UCS_4},

        {"UCS-4", CR_UCS_4},

        {"UCS_4", CR_UCS_4},

        {"ASCII", CR_ASCII},

        {0, 0}

};

static CREncHandler gv_default_enc_handlers[] = {

        {CR_UCS_1, cr_utils_ucs1_to_utf8, cr_utils_utf8_to_ucs1,

         cr_utils_ucs1_str_len_as_utf8, cr_utils_utf8_str_len_as_ucs1},

        {CR_ISO_8859_1, cr_utils_ucs1_to_utf8, cr_utils_utf8_to_ucs1,

         cr_utils_ucs1_str_len_as_utf8, cr_utils_utf8_str_len_as_ucs1},

        {CR_ASCII, cr_utils_ucs1_to_utf8, cr_utils_utf8_to_ucs1,

         cr_utils_ucs1_str_len_as_utf8, cr_utils_utf8_str_len_as_ucs1},

        {0, NULL, NULL, NULL, NULL}

};

/**

 * cr_enc_handler_get_instance:

 *@a_enc: the encoding of the Handler.

 *

 *Gets the instance of encoding handler.

 *This function implements a singleton pattern.

 *

 *Returns the instance of #CREncHandler.

 */

CREncHandler *

cr_enc_handler_get_instance (enum CREncoding a_enc)

{

        gulong i = 0;

        for (i = 0; gv_default_enc_handlers[i].encoding; i++) {

                if (gv_default_enc_handlers[i].encoding == a_enc) {

                        return (CREncHandler *)

                                & gv_default_enc_handlers[i].encoding;

                }

        }

        return NULL;

}

/**

 * cr_enc_handler_resolve_enc_alias:

 *@a_alias_name: the encoding name.

 *@a_enc: output param. The returned encoding type

 *or 0 if the alias is not supported.

 *

 *Given an encoding name (called an alias name)

 *the function returns the matching encoding type.

 *

 *Returns CR_OK upon successfull completion, an error code otherwise.

 */

enum CRStatus

cr_enc_handler_resolve_enc_alias (const guchar * a_alias_name,

                                  enum CREncoding *a_enc)

{

        gulong i = 0;

        guchar *alias_name_up = NULL;

        enum CRStatus status = CR_ENCODING_NOT_FOUND_ERROR;

        g_return_val_if_fail (a_alias_name != NULL, CR_BAD_PARAM_ERROR);

        alias_name_up = g_strdup (a_alias_name);

        g_ascii_strup (alias_name_up, -1);

        for (i = 0; gv_default_aliases[i].name; i++) {

                if (!strcmp (gv_default_aliases[i].name, alias_name_up)) {

                        *a_enc = gv_default_aliases[i].encoding;

                        status = CR_OK;

                        break;

                }

        }

        return status;

}

/**

 * cr_enc_handler_convert_input:

 *@a_this: the current instance of #CREncHandler.

 *@a_in: the input buffer to convert.

 *@a_in_len: in/out parameter. The len of the input

 *buffer to convert. After return, contains the number of

 *bytes actually consumed.

 *@a_out: output parameter. The converted output buffer.

 *Must be freed by the buffer.

 *@a_out_len: output parameter. The length of the output buffer.

 *

 *Converts a raw input buffer into an utf8 buffer.

 *

 *Returns CR_OK upon successfull completion, an error code otherwise.

 */

enum CRStatus

cr_enc_handler_convert_input (CREncHandler * a_this,

                              const guchar * a_in,

                              gulong * a_in_len,

                              guchar ** a_out, gulong * a_out_len)

{

        enum CRStatus status = CR_OK;

        g_return_val_if_fail (a_this && a_in && a_in_len && a_out,

                              CR_BAD_PARAM_ERROR);

        if (a_this->decode_input == NULL)

                return CR_OK;

        if (a_this->enc_str_len_as_utf8) {

                status = a_this->enc_str_len_as_utf8 (a_in,

                                                      &a_in[*a_in_len - 1],

                                                      a_out_len);

                g_return_val_if_fail (status == CR_OK, status);

        } else {

                *a_out_len = *a_in_len;

        }

        *a_out = g_malloc0 (*a_out_len);

        status = a_this->decode_input (a_in, a_in_len, *a_out, a_out_len);

        if (status != CR_OK) {

                g_free (*a_out);

                *a_out = NULL;

        }

        g_return_val_if_fail (status == CR_OK, status);

        return CR_OK;

}