/*  
 *  string_t.c - dynamic string handling module
 *  
 *  Copyright (C) 2005 Free Software Foundation, Inc.
 *  
 *  This file is part of GNU Wget.
 *  
 *  GNU Wget is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  GNU Wget 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
 *  In addition, as a special exception, the Free Software Foundation
 *  gives permission to link the code of its release of Wget with the
 *  OpenSSL project's "OpenSSL" library (or with modified versions of it
 *  that use the same license as the "OpenSSL" library), and distribute
 *  the linked executables.  You must obey the GNU General Public License
 *  in all respects for all of the code used other than "OpenSSL".  If you
 *  modify this file, you may extend this exception to your version of the
 *  file, but you are not obligated to do so.  If you do not wish to do
 *  so, delete this exception statement from your version.
 */  

#include "config.h"

#include <assert.h>
#include <stdlib.h>
#include <wchar.h>

#include "wget.h"

#ifdef STANDALONE
#undef xmalloc
#undef xrealloc
#undef xfree_null
#define xmalloc malloc
#define xrealloc realloc
#define xfree_null(p) if (!(p)) ; else free (p)
#else
#include "xmalloc.h"
#endif

#ifdef WINDOWS
static const wchar_t w_line_delim[] = L"\r\n";
static const char line_delim[] = "\r\n";
static const unsigned int line_delim_len = 2;
#else
static const wchar_t w_line_delim[] = L"\n";
static const char line_delim[] = "\n";
static const unsigned int line_delim_len = 2;
#endif

typedef struct string_t {
  char *sz;           /* standard null-terminated string */
  unsigned int len;   /* number of chars in the allocated buffer */
  unsigned int used;  /* number of used chars */
} *string;

#ifdef STRING_MODULE_DEBUG

#define assert_valid_string(str) \
  assert (((str) != NULL) \
          && ((str)->sz != NULL) \
          && ((str)->used + 1 <= (str)->len));

static void
string_dump (struct string_t *str, FILE *out)
{  
  assert_valid_string (str);
  assert (out);
  
  fprintf (out, "string_dump: str->sz = %s (%p)\n", str->sz, str->sz);
  fprintf (out, "string_dump: *(str->sz) = %d\n", *(str->sz));
  fprintf (out, "string_dump: str->len = %u\n", str->len);
  fprintf (out, "string_dump: str->used = %u\n", str->used);
}

#define DEBUG_PRINTF(x) printf x

#else /* not defined STRING_MODULE_DEBUG */

#define assert_valid_string(str) do {} while (0);
#define string_dump(str, out) do {} while (0);
#define DEBUG_PRINTF(x) do {} while (0);

#endif


void
string_init (struct string_t *s, unsigned int len)
{
  size_t to_alloc;
  
  /* no need to check that len > 0, since the len == 0 case is ok */
  assert (s != NULL);

  /* 
   * for the moment we try to perform a reasonable allocation by rounding up
   * the number of requested chars (including the trailing zero) to the 
   * closest multiple of 256, but we should probably find a better allocation
   * policy or completely leave the optimization of memory allocation to malloc
   */
  to_alloc = ((len + 1 + 256) & (~0xFF));
  
  s->sz = (char *) xmalloc (to_alloc * sizeof (char));
  *(s->sz) = '\0';
  s->len = to_alloc;
  s->used = 0;

  string_dump (s, stdout);
}

void
string_copy (struct string_t *dst, const void *src, unsigned int len)
{
  assert_valid_string (dst);
  assert (src != NULL);
  
  /* no need to do anything */
  if (len == 0) return;
  
  if (dst->sz == NULL) {
    string_init (dst, len); 
  }

  strncpy (dst->sz, (const char *) src, len);
  dst->sz[len] = '\0';

  dst->used = len;
}

void
string_cat (struct string_t *dst, const void *src, unsigned int len)
{
  assert_valid_string (dst);
  assert (src != NULL);

  /* no need to do anything */
  if (len == 0) return;
  
  if (dst->sz == NULL) {
    string_init (dst, len);    
  }

  strncpy (dst->sz + dst->used, (const char *) src, len);
  dst->sz[dst->used + len] = '\0';
  
  dst->used += len;
}

void
string_ready (struct string_t *str, unsigned int len)
{
  assert_valid_string (str);
  
  /* no need to do anything */
  if (len == 0) return;

  if (str->len - str->used < len)
    {
      DEBUG_PRINTF (("calling xrealloc"));
      str->sz = xrealloc (str->sz, str->len + len);
    }

  str->len += len;
}

void
string_destroy (struct string_t *str)
{
  assert_valid_string (str);
  
  xfree_null (str->sz);
  memset (str, 0, sizeof (*str));
}

static void
string_append_delim (struct string_t *dst)
{
  assert_valid_string (dst);
  string_cat (dst, line_delim, line_delim_len);
}

static int 
is_line_delim (const wchar_t *wsz)
{
  assert (wsz != NULL);
 
  if (*wsz == L'\r' && *(wsz + 1) == L'\n') {
    return 2;
  } else if (*wsz == L'\r' || *wsz == L'\n') {
    return 1;
  }
  
  return 0;
}

/*
 * DEST is the string to which the multibyte stuff will be added
 * TO_ESC is the null wide char string to add
 */
static void
string_append_multibyte (struct string_t *dest, const wchar_t *wstr, unsigned int len, mbstate_t *state)
{
  int i;

  assert_valid_string (dest);
  assert (wstr != NULL);
  assert (state != NULL);
  
  /* nothing to do */
  if (len == 0) return;

  string_ready (dest, 4 * MB_CUR_MAX * (len + 1));

  DEBUG_PRINTF (("string_append_multibyte: len = %u\n", len));
  string_dump (dest, stdout);
  
  for (i = 0; len > 0; ++i, --len) {    
    size_t copied = wcrtomb (dest->sz + dest->used, *(wstr + i), state);

    DEBUG_PRINTF (("string_append_multibyte (loop): i = %d\n", i));
    DEBUG_PRINTF (("string_append_multibyte (loop): copied = %u\n", copied));
    string_dump (dest, stdout);
    
    if (copied == (size_t)(-1)) {
      perror ("wcrtomb");
      exit (EXIT_FAILURE);
    }    
    dest->used += copied;
    *(dest->sz + dest->used) = '\0';

    DEBUG_PRINTF (("string_append_multibyte (loop): processed %s\n", dest->sz + dest->used - copied));
  }
}

static void
string_append_multibyte_newline (struct string_t *dest, mbstate_t *state)
{
  assert_valid_string (dest);
  string_append_multibyte(dest, w_line_delim, line_delim_len, state);
}

static void
string_append_multibyte_terminator (struct string_t *dest, mbstate_t *state)
{
  const wchar_t terminator = L'\0';

  assert_valid_string (dest);
  string_append_multibyte(dest, &terminator, 1, state);
}

/* 
 * DEST is the string to which the escape code will be added
 * TO_ESC is the (not necessarily null terminated) string to escape
 * LEN is the length of the string to escape
 */
static void
do_escape (struct string_t *dest, const char *to_esc, unsigned int len, mbstate_t *state)
{
  /* we only need to allocate 5 chars for byte: 
   * - one for the leading backslash
   * - three for the octal representation
   * - one for the trailing zero */
  wchar_t buf[8] = L"";
  size_t buf_elems = sizeof(buf)/sizeof(buf[0]);
  int i;

  assert_valid_string (dest);
  assert (to_esc != NULL);
  assert (state != NULL);

  /* nothing to do */
  if (len == 0) return;
  
  DEBUG_PRINTF (("do_escape: len = %d\n", len));
  string_dump (dest, stdout);
  
  for (i = 0; len > 0; ++i, --len) {
    int j = (unsigned char)*(to_esc + i);
    int cc = swprintf (buf, buf_elems, L"\\%03o", j);
    assert(cc > 0 && cc < buf_elems);
    DEBUG_PRINTF (("do_escape (loop): escaping \\%03o\n", j));
    buf[buf_elems - 1] = L'\0';
    assert (wcslen(buf) == 4);
    string_append_multibyte (dest, buf, 4, state);
  }
}

static void
string_escape (struct string_t *str)
{
  wchar_t c;
  int i;
  mbstate_t state1, state2;  
  size_t ret;
  unsigned int to_read;
  struct string_t src;
  int delim_size;
  
  assert_valid_string (str);

  memset (&state1, '\0', sizeof (state1));
  memset (&state2, '\0', sizeof (state2));
  
  src = *str;
  to_read = src.used + 1;
  
  /* this value is completely arbitrary */
  string_init (str, 4 * to_read);

  DEBUG_PRINTF (("string_escape: dumping string src"));
  string_dump (&src, stdout);
  DEBUG_PRINTF (("string_escape: dumping string str"));
  string_dump (str, stdout);

  i = 0;
  while ((ret = mbrtowc (&c, src.sz + i, to_read, &state1)) != 0) {
    DEBUG_PRINTF (("string_escape (loop): ret = %d\n", ret));
    if (ret == (size_t)(-2)) {
      DEBUG_PRINTF (("string_escape (loop): handling ret == -2"));
      /* mauro: should we just return the portion of the string already 
       * processed and print an error message? */
      perror ("mbrtowc");
      exit (EXIT_FAILURE);
    } else if (ret == (size_t)(-1)) {
      DEBUG_PRINTF (("string_escape (loop): handling ret == -1"));
      do_escape (str, src.sz + i, 1, &state2);
      i++;
    } else if ((delim_size = is_line_delim(&c))) {
      DEBUG_PRINTF (("string_escape (loop): handling ret == line_delim"));
      i += delim_size;
      string_append_multibyte_newline (str, &state2);
    } else if (iswprint(c) || iswblank(c)) {
      DEBUG_PRINTF (("string_escape (loop): handling ret == blank | printable"));
      string_append_multibyte (str, &c, 1, &state2);
      if (c == L'\\') {
        /* since the backslash character is used to escape unprintable data, 
         * in order to avoid ambiguities in the escaped string we have to 
         * escape backslashes as well */
        string_append_multibyte (str, &c, 1, &state2);
      }
      i += ret;
    } else { 
      DEBUG_PRINTF (("string_escape (loop): handling ret == toescape"));
      do_escape (str, src.sz + i, ret, &state2);
      i += ret;
    }
  }
  
  string_append_multibyte_terminator (str, &state2);
  
  string_destroy (&src);
}

/*
 * BUF must be a null-terminated dynamically allocated string
 * LEN is the size of the string BUF
 */
void
escape_buffer (char **buf, size_t len)
{
  struct string_t s;

  assert (buf != NULL && *buf != NULL);

  /* nothing to do */
  if (len == 0) return;
  
  DEBUG_PRINTF (("escape_buffer processing: %s (len %u)\n", *buf, len));
  
  s.sz = *buf; 
  s.used = len;
  s.len = len + 1;
  
  string_escape (&s);
  
  *buf = s.sz;
}

#ifdef STANDALONE
int main(void)
{
  char *buf;
  const size_t buflen = 512;
  buf = (char *) xmalloc(buflen);
  assert (buf != NULL);
  
  puts ("--------------------------------------------------------------------------------");
  
  while (fgets (buf, buflen - 1, stdin) != NULL)
    {
      /* just in case... */
      buf[buflen - 1] = '\0';
      printf ("before escape: %s", buf);
      escape_buffer (&buf, strlen(buf));
      printf ("after escape: %s", buf);
    }

  puts ("--------------------------------------------------------------------------------");

  return 0;
}
#endif

/*
 * vim: et ts=2 sw=2
 */