/* plist.c -- plist module.

   Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012

     National Institute of Advanced Industrial Science and Technology (AIST)

     Registration Number H15PRO112

   This file is part of the m17n library.

   The m17n library is free software; you can redistribute it and/or

   modify it under the terms of the GNU Lesser General Public License

   as published by the Free Software Foundation; either version 2.1 of

   the License, or (at your option) any later version.

   The m17n library 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

   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public

   License along with the m17n library; if not, write to the Free

   Software Foundation, Inc., 51 Franklin Street, Fifth Floor,

   Boston, MA 02110-1301 USA.  */

/***en

    @addtogroup m17nPlist

    @brief Property List objects and API for them.

    A @e property @e list (or @e plist for short) is a list of zero or

    more properties.  A property consists of a @e key and a @e value,

    where key is a symbol and value is anything that can be cast to

    <tt>(void *)</tt>.

    If the key of a property is a @e managing @e key, its @e value is

    a @e managed @e object.  A property list itself is a managed

    objects.

    If each key of a plist is one of #Msymbol, #Mtext, #Minteger, and

    #Mplist, the plist is called as @e well-formed and represented by

    the following notation in the documentation.

@verbatim

      PLIST ::= '(' ELEMENT * ')'

      ELEMENT ::= INTEGER | SYMBOL | M-TEXT | PLIST

      M-TEXT ::= '"' text data ... '"'

@endverbatim

    For instance, if a plist has four elements; integer -20, symbol of

    name "sym", M-text of contents "abc", and plist of integer 10 and

    symbol of name "another-symbol", it is represented as this:

      (-20 sym "abc" (10 another-symbol))

  */

/***ja

    @addtogroup m17nPlist

    @brief プロパティリストオブジェクトとそれに関する API.

    @e プロパティリスト (または @e plist) は 0 

    個以上のプロパティのリストである。プロパティは @e キー と @e 値 

    からなる。キーはシンボルであり、値は <tt>(void *)</tt> 

    にキャストできるものならば何でも良い。

    あるプロパティのキーが @e 管理キー ならば、その @e 値 は @e 管理下

    @e オブジェクト 

    である。プロパティリスト自体も管理下オブジェクトである。  */

/*=*/

#if !defined (FOR_DOXYGEN) || defined (DOXYGEN_INTERNAL_MODULE)

/*** @addtogroup m17nInternal

     @{ */

#include <stdio.h>

#include <string.h>

#include <ctype.h>

#include "config.h"

#include "m17n.h"

#include "m17n-misc.h"

#include "internal.h"

#include "character.h"

#include "mtext.h"

#include "symbol.h"

#include "plist.h"

static M17NObjectArray plist_table;

/** Set PLIST to a newly allocated plist object.  */

#define MPLIST_NEW(plist)				\

  do {							\

    M17N_OBJECT (plist, free_plist, MERROR_PLIST);	\

    M17N_OBJECT_REGISTER (plist_table, plist);		\

  } while (0)

/** Set the element of PLIST to KEY and VAL.  If PLIST is an anchor,

    append a new anchor.  */

#define MPLIST_SET(plist, key, val)	\

  do {					\

    MPLIST_KEY (plist) = (key);		\

    MPLIST_VAL (plist) = (val);		\

    if (! (plist)->next)		\

      MPLIST_NEW ((plist)->next);	\

  } while (0)

/** Set the element of PLIST to KEY and VAL.  PLIST must be an anchor.

    Append a new anchor and set PLIST to that anchor.  */

#define MPLIST_SET_ADVANCE(plist, key, val)	\

  do {						\

    MPLIST_KEY (plist) = (key);			\

    MPLIST_VAL (plist) = (val);			\

    MPLIST_NEW ((plist)->next);			\

    plist = (plist)->next;			\

  } while (0)

static void

free_plist (void *object)

{

  MPlist *plist = (MPlist *) object;

  do {

    MPlist *next = plist->next;

    if (MPLIST_KEY (plist) != Mnil

	&& MPLIST_KEY (plist)->managing_key)

      M17N_OBJECT_UNREF (MPLIST_VAL (plist));

    M17N_OBJECT_UNREGISTER (plist_table, plist);

    free (plist);

    plist = next;

  } while (plist && plist->control.ref_count == 1);

  M17N_OBJECT_UNREF (plist);

}

/* Load a plist from a string.  */

#define READ_CHUNK 0x10000

typedef struct

{

  /* File pointer if the stream is associated with a file.  Otherwise

     NULL.  */

  FILE *fp;

  int eof;

  unsigned char buffer[READ_CHUNK];

  unsigned char *p, *pend;

} MStream;

static int

get_byte (MStream *st)

{

  int n;

  if (! st->fp || st->eof)

    return EOF;

  n = fread (st->buffer, 1, READ_CHUNK, st->fp);

  if (n <= 0)

    {

      st->eof = 1;

      return EOF;

    }

  st->p = st->buffer + 1;

  st->pend = st->buffer + n;

  return st->buffer[0];

}

#define GETC(st) ((st)->p < (st)->pend ? *(st)->p++ : get_byte (st))

#define UNGETC(c, st) (--((st)->p))

/** Mapping table for reading a number.  Hexadecimal chars

    (0..9,A..F,a..F) are mapped to the corresponding numbers.

    Apostrophe (code 39) is mapped to 254.  All the other bytes are

    mapped to 255.  */

unsigned char hex_mnemonic[256];

/** Mapping table for escaped characters.  Mnemonic characters (e, b,

    f, n, r, or t) that follows '\' are mapped to the corresponding

    character code.  All the other bytes are mapped to themselves.  */

unsigned char escape_mnemonic[256];

/** Read an integer from the stream ST.  It is assumed that we have

    already read one character C.  */

static int

read_decimal (MStream *st, int c)

{

  int num = 0;

  while (c >= '0' && c <= '9')

    {

      num = (num * 10) + (c - '0');

      c = GETC (st);

    }

  if (c != EOF)

    UNGETC (c, st);

  return num;

}

/** Read an unsigned from the stream ST.  */

static unsigned

read_hexadesimal (MStream *st)

{

  int c;

  unsigned num = 0, n;

  while ((c = GETC (st)) != EOF

	 && (n = hex_mnemonic[c]) < 16)

    num = (num << 4) | n;

  if (c != EOF)

    UNGETC (c, st);

  return num;

}

/** Read an M-text element from ST, and add it to LIST.  Return a list

    for the next element.  */

#define READ_MTEXT_BUF_SIZE 256

static MPlist *

read_mtext_element (MPlist *plist, MStream *st, int skip)

{

  unsigned char buffer[READ_MTEXT_BUF_SIZE], *buf = buffer;

  int nbytes = READ_MTEXT_BUF_SIZE;

  int c, i;

  i = 0;

  while ((c = GETC (st)) != EOF && c != '"')

    {

      int is_char = 0;

      if (c == '\\')

	{

	  c = GETC (st);

	  if (c == EOF)

	    break;

	  if (c == '\n')

	    continue;

	  if (c == 'x' || c == 'u')

	    {

	      int next_c;

	      c = read_hexadesimal (st);

	      next_c = GETC (st);

	      if (next_c != ' ')

		UNGETC (next_c, st);

	      if (c >= 0x80)

		is_char = 1;

	    }

	  else

	    c = escape_mnemonic[c];

	}

      if (! skip)

	{

	  if (i + MAX_UTF8_CHAR_BYTES + 1 >= nbytes)

	    {

	      if (buf == buffer)

		{

		  nbytes *= 2;

		  buf = malloc (nbytes);

		  memcpy (buf, buffer, i);

		}

	      else

		{

		  nbytes += READ_MTEXT_BUF_SIZE;

		  buf = realloc (buf, nbytes);

		}

	    }

	  if (is_char)

	    i += CHAR_STRING_UTF8 (c, buf);

	  else

	    buf[i++] = c;

	}

    }

  if (! skip)

    {

      MText *mt;

      buf[i] = 0;

      mt = mtext__from_data (buf, i, MTEXT_FORMAT_UTF_8, (buf == buffer));

      if (buf != buffer)

	mt->allocated = nbytes;

      MPLIST_SET_ADVANCE (plist, Mtext, mt);

    }

  return plist;

}

static int

read_character (MStream *st, int c)

{

  unsigned char buf[MAX_UTF8_CHAR_BYTES + 1];

  int len = CHAR_BYTES_BY_HEAD (c);

  int i;

  buf[0] = c;

  for (i = 1; i < len; i++)

    {

      c = GETC (st);

      if (c == EOF

	  || (c & 0xC0) != 0x80)

	break;

      buf[i] = c;

    }

  if (i == len)

    c = STRING_CHAR_UTF8 (buf);

  else

    c = buf[0];

  return c;

}

/** Read a symbol element from ST, and add it to LIST.  Return a list

    for the next element.  */

static MPlist *

read_symbol_element (MPlist *plist, MStream *st, int c, int skip)

{

  unsigned char buffer[1024];

  int bufsize = 1024;

  unsigned char *buf = buffer;

  int i;

  i = 0;

  while (c != EOF

	 && c > ' '

	 && c != ')' && c != '(' && c != '"')

    {

      if (i >= bufsize)

	{

	  bufsize *= 2;

	  if (buf == buffer)

	    {

	      MTABLE_MALLOC (buf, bufsize, MERROR_PLIST);

	      memcpy (buf, buffer, i);

	    }

	  else

	    MTABLE_REALLOC (buf, bufsize, MERROR_PLIST);

	}

      if (c == '\\')

	{

	  c = GETC (st);

	  if (c == EOF)

	    break;

	  c = escape_mnemonic[c];

	}

      if (! skip)

	buf[i++] = c;

      c = GETC (st);

    }

  if (c > ' ')

    UNGETC (c, st);

  if (! skip)

    {

      buf[i] = 0;

      MPLIST_SET_ADVANCE (plist, Msymbol, msymbol ((char *) buf));

      if (buf != buffer)

	free (buf);

    }

  return plist;

}

/** Read an integer element from ST, and add it to LIST.  Return a

    list for the next element.  It is assumed that we have already

    read the character C. */

static MPlist *

read_integer_element (MPlist *plist, MStream *st, int c, int skip)

{

  int num;

  if (c == '#')

    {

      c = GETC (st);

      if (c != 'x')

	{

	  UNGETC (c, st);

	  return read_symbol_element (plist, st, '#', skip);

	}

      num = read_hexadesimal (st);

    }

  else if (c == '0')

    {

      c = GETC (st);

      num = (c == 'x' ? read_hexadesimal (st) : read_decimal (st, c));

    }

  else if (c == '?')

    {

      c = GETC (st);

      if (c == EOF)

	num = 0;

      else if (c != '\\')

	{

	  if (c < 128 || ! CHAR_UNITS_BY_HEAD_UTF8 (c))

	    num = c;

	  else

	    num = read_character (st, c);

	}

      else

	{

	  c = GETC (st);

	  if (c == EOF)

	    num = '\\';

	  else if (c < 128 || ! CHAR_UNITS_BY_HEAD_UTF8 (c))

	    num = escape_mnemonic[c];

	  else

	    num = read_character (st, c);

	}

    }

  else if (c == '-')

    {

      c = GETC (st);

      if (c < '0' || c > '9')

	{

	  UNGETC (c, st);

	  return read_symbol_element (plist, st, '-', skip);

	}

      num = - read_decimal (st, c);

    }

  else

    num = read_decimal (st, c);

  if (! skip)

    MPLIST_SET_ADVANCE (plist, Minteger, (void *) num);

  return plist;

}

/* Read an element of various type from stream ST, and add it to LIST.

   Return a list for the next element.  The element type is decided by

   the first token character found as below:

	'(': plist

	'"': mtext

	'0'..'9', '-': integer

	'?': integer representing character code

	the other ASCII letters: symbol

   If KEYS is not NULL, it is a plist contains target keys and stop

   keys.  In this caes, read only a plist whose key has value 1 in

   KEYS, and return NULL when we encounter a plist whose key has value

   0 in KEYS while skipping any other elements.  */

static MPlist *

read_element (MPlist *plist, MStream *st, MPlist *keys)

{

  int c;

  /* Skip separators and comments.  */

  while (1)

    {

      while ((c = GETC (st)) != EOF && c <= ' ');

      if (c != ';')

	break;

      while ((c = GETC (st)) != EOF && c != '\n');

      if (c == EOF)

	break;

    }

  if (c == '(')

    {

      MPlist *pl, *p;

      MPLIST_NEW (pl);

      p = pl;

      p = read_element (p, st, NULL);

      if (keys && p && MPLIST_SYMBOL_P (pl))

	{

	  if (MPLIST_TAIL_P (keys))

	    {

	      while ((p = read_element (p, st, NULL)));

	      MPLIST_SET_ADVANCE (plist, Mplist, pl);

	      return NULL;

	    }

	  else

	    {

	      MPlist *p0 = keys;

	      MPLIST_FIND (p0, MPLIST_SYMBOL (pl));

	      if (! MPLIST_TAIL_P (p0) && ! MPLIST_VAL (p0))

		{

		  M17N_OBJECT_UNREF (pl);

		  return NULL;

		}

	      while ((p = read_element (p, st, NULL)));

	      if (! MPLIST_TAIL_P (p0))

		{

		  MPLIST_SET_ADVANCE (plist, Mplist, pl);

		  return NULL;

		}

	      else

		M17N_OBJECT_UNREF (pl);

	    }

	}

      else

	{

	  if (p)

	    while ((p = read_element (p, st, NULL)));

	  MPLIST_SET_ADVANCE (plist, Mplist, pl);

	}

      return plist;

    }

  if (c == '"')

    return (read_mtext_element (plist, st, keys ? 1 : 0));

  if ((c >= '0' && c <= '9') || c == '-' || c == '?' || c == '#')

    return (read_integer_element (plist, st, c, keys ? 1 : 0));

  if (c == EOF || c == ')')

    return NULL;

  return (read_symbol_element (plist, st, c, keys ? 1 : 0));

}

#define PUTC(MT, C)			\

  do {					\

    if (MT)				\

      mtext_cat_char ((MT), (C));	\

    else				\

      putc ((C), mdebug__output);	\

  } while (0);

#define PUTS(MT, STR)			\

  do {					\

    if (MT)				\

      MTEXT_CAT_ASCII ((MT), (STR));	\

    else				\

      fputs ((STR), mdebug__output);	\

  } while (0)

static void 

write_symbol (MText *mt, MSymbol sym)

{

  if (sym == Mnil)

    {

      PUTS (mt, "nil");

    }

  else

    {

      char *name = MSYMBOL_NAME (sym);

      if (isdigit (*name))

	PUTC (mt, '\\');

      while (*name)

	{

	  if (*name <= ' ' || *name == '\\' || *name == '"'

	      || *name == '(' || *name == ')')

	    PUTC (mt, '\\');

	  PUTC (mt, *name); 

	  name++;

	}

    }

}

static void

write_element (MText *mt, MPlist *plist, int indent)

{

  if (MPLIST_SYMBOL_P (plist))

    {

      write_symbol (mt, MPLIST_SYMBOL (plist));

    }

  else if (MPLIST_INTEGER_P (plist))

    {

      int num = MPLIST_INTEGER (plist);

      char buf[128];

      sprintf (buf, "%d", num);

      PUTS (mt, buf);

    }

  else if (MPLIST_PLIST_P (plist)

	   || MPLIST_NESTED_P (plist))

    {

      MPlist *pl;

      int newline = 0;

      if (MPLIST_NESTED_P (plist))

	{

	  write_symbol (mt, MPLIST_KEY (plist));

	  PUTC (mt, ':');

	}

      plist = MPLIST_PLIST (plist);

      PUTC (mt, '(');

      if (indent >= 0)

	indent++;

      MPLIST_DO (pl, plist)

	{

	  if (pl != plist)

	    {

	      if (indent > 0 && (MPLIST_PLIST_P (pl) || MPLIST_MTEXT_P (pl)))

		newline = 1;

	      if (newline)

		{

		  int i;

		  PUTC (mt, '\n');

		  for (i = 1; i < indent; i++)

		    PUTC (mt, ' ');

		}

	      PUTC (mt, ' ');

	    }

	  write_element (mt, pl, indent);

	  if (indent >= 0)

	    newline = (MPLIST_PLIST_P (pl) || MPLIST_MTEXT_P (pl));

	}

      PUTC (mt, ')');

    }

  else if (MPLIST_MTEXT_P (plist))

    {

      MText *this_mt = MPLIST_MTEXT (plist);

      int from = 0, to = mtext_nchars (this_mt);

      int stop1 = 0, stop2 = 0;

      if (! mt && this_mt->format > MTEXT_FORMAT_UTF_8)

	{

	  this_mt = mtext_dup (this_mt);

	  mtext__adjust_format (this_mt, MTEXT_FORMAT_UTF_8);

	}

      PUTC (mt, '"');

      while (1)

	{

	  int stop, escaped;

	  if (from == stop1)

	    {

	      if ((stop1 = mtext_character (this_mt, from, to, '"')) < 0)

		stop1 = to;

	    }

	  if (from == stop2)

	    {

	      if ((stop2 = mtext_character (this_mt, from, to, '\\')) < 0)

		stop2 = to;

	    }

	  if (stop1 < stop2)

	    stop = stop1++, escaped = '"';

	  else

	    stop = stop2++, escaped = '\\';

	  if (mt)

	    mtext_copy (mt, mtext_nchars (mt), this_mt, from, stop);

	  else

	    {

	      unsigned char *data = MTEXT_DATA (this_mt);

	      unsigned char *beg = data + mtext__char_to_byte (this_mt, from);

	      unsigned char *end = data + mtext__char_to_byte (this_mt, stop);

	      while (beg < end)

		putc (*beg, mdebug__output), beg++;

	    }

	  if (stop == to)

	    break;

	  PUTC (mt, '\\');

	  PUTC (mt, escaped);

	  from = stop + 1;

	}

      PUTC (mt, '"');

      if (this_mt != MPLIST_MTEXT (plist))

	M17N_OBJECT_UNREF (this_mt);

    }

  else if (MPLIST_STRING_P (plist))

    {

      char *str = MPLIST_STRING (plist);

      if (mt)

	{

	  MText *this_mt = mtext__from_data (str, strlen (str),

					     MTEXT_FORMAT_UTF_8, 0);

	  mtext_copy (mt, mtext_nchars (mt),

		      this_mt, 0, mtext_nchars (this_mt));

	  M17N_OBJECT_UNREF (this_mt);

	}

      else

	fprintf (mdebug__output, "%s", str);

    }

  else 

    {

      char buf[128];

      write_symbol (mt, MPLIST_KEY (plist));

      PUTC (mt, ':');

      sprintf (buf, "%04X", (unsigned) MPLIST_VAL (plist));

      PUTS (mt, buf);

    }

}

/* Internal API */

int

mplist__init ()

{

  int i;

  M17N_OBJECT_ADD_ARRAY (plist_table, "Plist");

  Minteger = msymbol ("integer");

  Mplist = msymbol_as_managing_key ("plist");

  Mtext = msymbol_as_managing_key ("mtext");

  for (i = 0; i < 256; i++)

    hex_mnemonic[i] = 255;

  for (i = '0'; i <= '9'; i++)

    hex_mnemonic[i] = i - '0';

  for (i = 'A'; i <= 'F'; i++)

    hex_mnemonic[i] = i - 'A' + 10;

  for (i = 'a'; i <= 'f'; i++)

    hex_mnemonic[i] = i - 'a' + 10;

  for (i = 0; i < 256; i++)

    escape_mnemonic[i] = i;

  escape_mnemonic['e'] = 27;

  escape_mnemonic['b'] = '\b';

  escape_mnemonic['f'] = '\f';

  escape_mnemonic['n'] = '\n';

  escape_mnemonic['r'] = '\r';

  escape_mnemonic['t'] = '\t';

  escape_mnemonic['\\'] = '\\';

  return 0;

}

void

mplist__fini (void)

{

}

/* Parse this form of PLIST:

      (symbol:KEY1 TYPE1:VAL1 symbol:KEY2 TYPE2:VAL2 ...)

   and return a newly created plist of this form:

      (KEY1:VAL1 KEY2:VAL2 ...)  */

MPlist *

mplist__from_plist (MPlist *plist)

{

  MPlist *pl, *p;

  MPLIST_NEW (pl);

  p = pl;

  while (! MPLIST_TAIL_P (plist))

    {

      MSymbol key, type;

      if (! MPLIST_SYMBOL_P (plist))

	MERROR (MERROR_PLIST, NULL);

      key = MPLIST_SYMBOL (plist);

      plist = MPLIST_NEXT (plist);

      type = MPLIST_KEY (plist);

      if (type->managing_key && MPLIST_VAL (plist))

	M17N_OBJECT_REF (MPLIST_VAL (plist));

      if (type == Mplist)

	MPLIST_SET_NESTED_P (p);

      MPLIST_SET_ADVANCE (p, key, MPLIST_VAL (plist));

      plist = MPLIST_NEXT (plist);

    }

  return pl;

}

/** Parse this form of PLIST:

      ((symbol:KEY1 ANY:VAL1 ... ) (symbol:KEY2 ANY:VAL2 ...) ...)

    and return a newly created plist of this form:

      (KEY1:(ANY:VAL1 ...) KEY2:(ANY:VAL2 ...) ...)

    ANY can be any type.  */

MPlist *

mplist__from_alist (MPlist *plist)

{

  MPlist *pl, *p;

  MPLIST_NEW (pl);

  p = pl;

  MPLIST_DO (plist, plist)

    {

      MPlist *elt;

      if (! MPLIST_PLIST_P (plist))

	MERROR (MERROR_PLIST, NULL);

      elt = MPLIST_PLIST (plist);

      if (! MPLIST_SYMBOL_P (elt))

	MERROR (MERROR_PLIST, NULL);

      MPLIST_SET_NESTED_P (p);

      MPLIST_SET_ADVANCE (p, MPLIST_SYMBOL (elt), MPLIST_NEXT (elt));

      M17N_OBJECT_REF (MPLIST_NEXT (elt));

    }

  return pl;

}

MPlist *

mplist__from_file (FILE *fp, MPlist *keys)

{

  MPlist *plist, *pl;

  MStream st;

  st.fp = fp;

  st.eof = 0;

  st.p = st.pend = st.buffer;

  MPLIST_NEW (plist);

  pl = plist;

  while ((pl = read_element (pl, &st, keys)));

  return plist;

}

/** Parse $STR of $N bytes and return a property list object.  $FORMAT

    must be either @c MTEXT_FORMAT_US_ASCII or @c MTEXT_FORMAT_UTF_8,

    and controls how to produce @c STRING or @c M-TEXT in the

    following definition.

    The syntax of $STR is as follows.

    PLIST ::= '(' ELEMENT * ')'

    ELEMENT ::= SYMBOL | INTEGER | UNSIGNED | STRING | M-TEXT | PLIST

    SYMBOL ::= ascii-character-sequence

    INTEGER ::= '-' ? [ '0' | .. | '9' ]+

    UNSIGNED ::= '0x' [ '0' | .. | '9' | 'A' | .. | 'F' | 'a' | .. | 'f' ]+

    M-TEXT ::= '"' byte-sequence '"'

    Each kind of @c ELEMENT is assigned one of these keys:

	@c Msymbol, @c Mint, @c Munsigned, @c Mtext, @c Mplist

    In an ascii-character-sequence, a backslush (\) is used as the escape

    character, which means that, for instance, <tt>"abc\ def"</tt>

    produces a symbol whose name is of length seven with the fourth

    character being a space.

    In a byte-sequence, "\r", "\n", "\e", and "\t" are replaced by CR,

    NL, ESC, and TAB character respectively, "\xXX" are replaced by

    byte 0xXX.  After this replacement, the byte-sequence is decoded

    into M-TEXT by $CODING.  */

MPlist *

mplist__from_string (unsigned char *str, int n)

{

  MPlist *plist, *pl;

  MStream st;

  st.fp = NULL;

  st.eof = 0;

  st.p = str;

  st.pend = str + n;

  MPLIST_NEW (plist);

  pl = plist;

  while ((pl = read_element (pl, &st, NULL)));

  return plist;

}

int

mplist__serialize (MText *mt, MPlist *plist, int pretty)

{

  MPlist *pl;

  int separator = pretty ? '\n' : ' ';

  MPLIST_DO (pl, plist)

    {

      if (pl != plist)

	mtext_cat_char (mt, separator);

      write_element (mt, pl, pretty ? 0 : -1);

    }

  if (pretty)

    mtext_cat_char (mt, separator);

  return 0;

}

/**en