/* ----------------------------------------------------------------------------

   libconfig - A library for processing structured configuration files

   Copyright (C) 2005-2010  Mark A Lindner

   This file is part of libconfig.

   This 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.

   This 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 Library General Public

   License along with this library; if not, see

   <http://www.gnu.org/licenses/>.

   ----------------------------------------------------------------------------

*/

#ifdef HAVE_CONFIG_H

#include "ac_config.h"

#endif

#include "libconfig.h"

#include "grammar.h"

#include "scanner.h"

#include "scanctx.h"

#include "parsectx.h"

#include "wincompat.h"

#include <locale.h>

#ifdef HAVE_XLOCALE_H

#include <xlocale.h>

#endif

#include <stdlib.h>

#include <string.h>

#include <ctype.h>

#define PATH_TOKENS ":./"

#define CHUNK_SIZE 16

#define FLOAT_PRECISION 10

#define _new(T) (T *)calloc(sizeof(T), 1) /* zeroed */

#define _delete(P) free((void *)(P))

/* ------------------------------------------------------------------------- */

#ifndef LIBCONFIG_STATIC

#if (defined(WIN32) || defined(_WIN32) || defined(__WIN32__))

BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)

{

  return(TRUE);

}

#endif /* WIN32 */

#endif /* LIBCONFIG_STATIC */

/* ------------------------------------------------------------------------- */

static const char *__io_error = "file I/O error";

static void __config_list_destroy(config_list_t *list);

static void __config_write_setting(const config_setting_t *setting,

                                   FILE *stream, int depth,

                                   unsigned short tab_width);

extern int libconfig_yyparse(void *scanner, struct parse_context *ctx,

                             struct scan_context *scan_ctx);

extern int libconfig_yylex_init_extra(struct scan_context *scan_ctx,

                                      yyscan_t *scanner);

/* ------------------------------------------------------------------------- */

static void __config_locale_override(void)

{

#if (defined(WIN32) || defined(_WIN32) || defined(__WIN32__)) \

  && ! defined(__MINGW32__)

  _configthreadlocale(_ENABLE_PER_THREAD_LOCALE);

  setlocale(LC_NUMERIC, "C");

#elif defined(__APPLE__)

  locale_t loc = newlocale(LC_NUMERIC_MASK, "C", NULL);

  uselocale(loc);

#elif ((defined HAVE_NEWLOCALE) && (defined HAVE_USELOCALE))

  locale_t loc = newlocale(LC_NUMERIC, "C", NULL);

  uselocale(loc);

#else

#warning "No way to modify calling thread's locale!"

#endif

}

/* ------------------------------------------------------------------------- */

static void __config_locale_restore(void)

{

#if (defined(WIN32) || defined(_WIN32) || defined(__WIN32__)) \

  && ! defined(__MINGW32__)

    _configthreadlocale(_DISABLE_PER_THREAD_LOCALE);

#elif ((defined HAVE_USELOCALE) && (defined HAVE_FREELOCALE))

  locale_t loc = uselocale(LC_GLOBAL_LOCALE);

  freelocale(loc);

#else

#warning "No way to modify calling thread's locale!"

#endif

}

/* ------------------------------------------------------------------------- */

static int __config_name_compare(const char *a, const char *b)

{

  const char *p, *q;

  for(p = a, q = b; ; p++, q++)

  {

    int pd = ((! *p) || strchr(PATH_TOKENS, *p));

    int qd = ((! *q) || strchr(PATH_TOKENS, *q));

    if(pd && qd)

      break;

    else if(pd)

      return(-1);

    else if(qd)

      return(1);

    else if(*p < *q)

      return(-1);

    else if(*p > *q)

      return(1);

  }

  return(0);

}

/* ------------------------------------------------------------------------- */

static void __config_indent(FILE *stream, int depth, unsigned short w)

{

  if(w)

    fprintf(stream, "%*s", (depth - 1) * w, " ");

  else

  {

    int i;

    for(i = 0; i < (depth - 1); ++i)

      fputc('\t', stream);

  }

}

/* ------------------------------------------------------------------------- */

static void __config_write_value(const config_value_t *value, int type,

                                 int format, int depth,

                                 unsigned short tab_width, FILE *stream)

{

  char fbuf[64];

  switch(type)

  {

    /* boolean */

    case CONFIG_TYPE_BOOL:

      fputs(value->ival ? "true" : "false", stream);

      break;

    /* int */

    case CONFIG_TYPE_INT:

      switch(format)

      {

        case CONFIG_FORMAT_HEX:

          fprintf(stream, "0x%X", value->ival);

          break;

        case CONFIG_FORMAT_DEFAULT:

        default:

          fprintf(stream, "%d", value->ival);

          break;

      }

      break;

    /* 64-bit int */

    case CONFIG_TYPE_INT64:

      switch(format)

      {

        case CONFIG_FORMAT_HEX:

          fprintf(stream, "0x" INT64_HEX_FMT "L", value->llval);

          break;

        case CONFIG_FORMAT_DEFAULT:

        default:

          fprintf(stream, INT64_FMT "L", value->llval);

          break;

      }

      break;

    /* float */

    case CONFIG_TYPE_FLOAT:

    {

      char *q;

      snprintf(fbuf, sizeof(fbuf) - 3, "%.*g", FLOAT_PRECISION, value->fval);

      /* check for exponent */

      q = strchr(fbuf, 'e');

      if(! q)

      {

        /* no exponent */

        if(! strchr(fbuf, '.')) /* no decimal point */

          strcat(fbuf, ".0");

        else

        {

          /* has decimal point */

          char *p;

          for(p = fbuf + strlen(fbuf) - 1; p > fbuf; --p)

          {

            if(*p != '0')

            {

              *(++p) = '\0';

              break;

            }

          }

        }

      }

      fputs(fbuf, stream);

      break;

    }

    /* string */

    case CONFIG_TYPE_STRING:

    {

      char *p;

      fputc('\"', stream);

      if(value->sval)

      {

        for(p = value->sval; *p; p++)

        {

          int c = (int)*p & 0xFF;

          switch(c)

          {

            case '\"':

            case '\\':

              fputc('\\', stream);

              fputc(c, stream);

              break;

            case '\n':

              fputs("\\n", stream);

              break;

            case '\r':

              fputs("\\r", stream);

              break;

            case '\f':

              fputs("\\f", stream);

              break;

            case '\t':

              fputs("\\t", stream);

              break;

            default:

              if(c >= ' ')

                fputc(c, stream);

              else

                fprintf(stream, "\\x%02X", c);

          }

        }

      }

      fputc('\"', stream);

      break;

    }

    /* list */

    case CONFIG_TYPE_LIST:

    {

      config_list_t *list = value->list;

      fprintf(stream, "( ");

      if(list)

      {

        int len = list->length;

        config_setting_t **s;

        for(s = list->elements; len--; s++)

        {

          __config_write_value(&((*s)->value), (*s)->type,

                               config_setting_get_format(*s),

                               depth + 1, tab_width, stream);

          if(len)

            fputc(',', stream);

          fputc(' ', stream);

        }

      }

      fputc(')', stream);

      break;

    }

    /* array */

    case CONFIG_TYPE_ARRAY:

    {

      config_list_t *list = value->list;

      fprintf(stream, "[ ");

      if(list)

      {

        int len = list->length;

        config_setting_t **s;

        for(s = list->elements; len--; s++)

        {

          __config_write_value(&((*s)->value), (*s)->type,

                               config_setting_get_format(*s),

                               depth + 1, tab_width, stream);

          if(len)

            fputc(',', stream);

          fputc(' ', stream);

        }

      }

      fputc(']', stream);

      break;

    }

    /* group */

    case CONFIG_TYPE_GROUP:

    {

      config_list_t *list = value->list;

      if(depth > 0)

      {

#ifdef K_AND_R_STYLE /* Horrendous, but many people like it. */

        fputc(' ', stream);

#else

        fputc('\n', stream);

        if(depth > 1)

          __config_indent(stream, depth, tab_width);

#endif

        fprintf(stream, "{\n");

      }

      if(list)

      {

        int len = list->length;

        config_setting_t **s;

        for(s = list->elements; len--; s++)

          __config_write_setting(*s, stream, depth + 1, tab_width);

      }

      if(depth > 1)

        __config_indent(stream, depth, tab_width);

      if(depth > 0)

        fputc('}', stream);

      break;

    }

    default:

      /* this shouldn't happen, but handle it gracefully... */

      fputs("???", stream);

      break;

  }

}

/* ------------------------------------------------------------------------- */

static void __config_list_add(config_list_t *list, config_setting_t *setting)

{

  if((list->length % CHUNK_SIZE) == 0)

  {

    list->elements = (config_setting_t **)realloc(

      list->elements,

      (list->length + CHUNK_SIZE) * sizeof(config_setting_t *));

  }

  list->elements[list->length] = setting;

  list->length++;

}

/* ------------------------------------------------------------------------- */

static config_setting_t *__config_list_search(config_list_t *list,

                                              const char *name,

                                              unsigned int *idx)

{

  config_setting_t **found = NULL;

  unsigned int i;

  if(! list)

    return(NULL);

  for(i = 0, found = list->elements; i < list->length; i++, found++)

  {

    if(! (*found)->name)

      continue;

    if(! __config_name_compare(name, (*found)->name))

    {

      if(idx)

        *idx = i;

      return(*found);

    }

  }

  return(NULL);

}

/* ------------------------------------------------------------------------- */

static config_setting_t *__config_list_remove(config_list_t *list, int idx)

{

  config_setting_t *removed = *(list->elements + idx);

  int offset = (idx * sizeof(config_setting_t *));

  int len = list->length - 1 - idx;

  char *base = (char *)list->elements + offset;

  memmove(base, base + sizeof(config_setting_t *),

          len * sizeof(config_setting_t *));

  list->length--;

  /* possibly realloc smaller? */

  return(removed);

}

/* ------------------------------------------------------------------------- */

static void __config_setting_destroy(config_setting_t *setting)

{

  if(setting)

  {

    if(setting->name)

      _delete(setting->name);

    if(setting->type == CONFIG_TYPE_STRING)

      _delete(setting->value.sval);

    else if((setting->type == CONFIG_TYPE_GROUP)

            || (setting->type == CONFIG_TYPE_ARRAY)

            || (setting->type == CONFIG_TYPE_LIST))

    {

      if(setting->value.list)

        __config_list_destroy(setting->value.list);

    }

    if(setting->hook && setting->config->destructor)

      setting->config->destructor(setting->hook);

    _delete(setting);

  }

}

/* ------------------------------------------------------------------------- */

static void __config_list_destroy(config_list_t *list)

{

  config_setting_t **p;

  unsigned int i;

  if(! list)

    return;

  if(list->elements)

  {

    for(p = list->elements, i = 0; i < list->length; p++, i++)

      __config_setting_destroy(*p);

    _delete(list->elements);

  }

  _delete(list);

}

/* ------------------------------------------------------------------------- */

static int __config_vector_checktype(const config_setting_t *vector, int type)

{

  /* if the array is empty, then it has no type yet */

  if(! vector->value.list)

    return(CONFIG_TRUE);

  if(vector->value.list->length == 0)

    return(CONFIG_TRUE);

  /* if it's a list, any type is allowed */

  if(vector->type == CONFIG_TYPE_LIST)

    return(CONFIG_TRUE);

  /* otherwise the first element added determines the type of the array */

  return((vector->value.list->elements[0]->type == type)

         ? CONFIG_TRUE : CONFIG_FALSE);

}

/* ------------------------------------------------------------------------- */

static int __config_validate_name(const char *name)

{

  const char *p = name;

  if(*p == '\0')

    return(CONFIG_FALSE);

  if(! isalpha((int)*p) && (*p != '*'))

    return(CONFIG_FALSE);

  for(++p; *p; ++p)

  {

    if(! (isalpha((int)*p) || isdigit((int)*p) || strchr("*_-", (int)*p)))

      return(CONFIG_FALSE);

  }

  return(CONFIG_TRUE);

}

/* ------------------------------------------------------------------------- */

static int __config_read(config_t *config, FILE *stream, const char *filename,

                         const char *str)

{

  yyscan_t scanner;

  struct scan_context scan_ctx;

  struct parse_context parse_ctx;

  YY_BUFFER_STATE buffer = NULL;

  int r;

  /* Reinitialize the config */

  void (*destructor)(void *) = config->destructor;

  const char *include_dir = config->include_dir;

  unsigned short tab_width = config->tab_width;

  unsigned short flags = config->flags;

  config->include_dir = NULL;

  config_destroy(config);

  config_init(config);

  config->destructor = destructor;

  config->include_dir = include_dir;

  config->tab_width = tab_width;

  config->flags = flags;

  parsectx_init(&parse_ctx);

  parse_ctx.config = config;

  parse_ctx.parent = config->root;

  parse_ctx.setting = config->root;

  __config_locale_override();

  scanctx_init(&scan_ctx, filename);

  scan_ctx.config = config;

  libconfig_yylex_init_extra(&scan_ctx, &scanner);

  if(stream)

    libconfig_yyrestart(stream, scanner);

  else /* read from string */

    buffer = libconfig_yy_scan_string(str, scanner);

  libconfig_yyset_lineno(1, scanner);

  r = libconfig_yyparse(scanner, &parse_ctx, &scan_ctx);

  if(r != 0)

  {

    YY_BUFFER_STATE buf;

    config->error_file = scanctx_current_filename(&scan_ctx);

    config->error_type = CONFIG_ERR_PARSE;

    /* Unwind the include stack, freeing the buffers and closing the files. */

    while((buf = (YY_BUFFER_STATE)scanctx_pop_include(&scan_ctx)) != NULL)

      libconfig_yy_delete_buffer(buf, scanner);

  }

  libconfig_yylex_destroy(scanner);

  config->filenames = scanctx_cleanup(&scan_ctx, &(config->num_filenames));

  parsectx_cleanup(&parse_ctx);

  __config_locale_restore();

  return(r == 0 ? CONFIG_TRUE : CONFIG_FALSE);

}

/* ------------------------------------------------------------------------- */

int config_read(config_t *config, FILE *stream)

{

  return(__config_read(config, stream, NULL, NULL));

}

/* ------------------------------------------------------------------------- */

int config_read_string(config_t *config, const char *str)

{

  return(__config_read(config, NULL, NULL, str));

}

/* ------------------------------------------------------------------------- */

static void __config_write_setting(const config_setting_t *setting,

                                   FILE *stream, int depth,

                                   unsigned short tab_width)

{

  if(depth > 1)

    __config_indent(stream, depth, tab_width);

  if(setting->name)

  {

    fputs(setting->name, stream);

    fprintf(stream, " %c ", (setting->type == CONFIG_TYPE_GROUP ? ':' : '='));

  }

  __config_write_value(&(setting->value), setting->type,

                       config_setting_get_format(setting),

                       depth, tab_width, stream);

  if(depth > 0)

  {

    fputc(';', stream);

    fputc('\n', stream);

  }

}

/* ------------------------------------------------------------------------- */

void config_write(const config_t *config, FILE *stream)

{

  __config_locale_override();

  __config_write_setting(config->root, stream, 0, config->tab_width);

  __config_locale_restore();

}

/* ------------------------------------------------------------------------- */

int config_read_file(config_t *config, const char *filename)

{

  int ret;

  FILE *stream = fopen(filename, "rt");

  if(! stream)

  {

    config->error_text = __io_error;

    config->error_type = CONFIG_ERR_FILE_IO;

    return(CONFIG_FALSE);

  }

  ret = __config_read(config, stream, filename, NULL);

  fclose(stream);

  return(ret);

}

/* ------------------------------------------------------------------------- */

int config_write_file(config_t *config, const char *filename)

{

  FILE *f = fopen(filename, "wt");

  if(! f)

  {

    config->error_text = __io_error;

    config->error_type = CONFIG_ERR_FILE_IO;

    return(CONFIG_FALSE);

  }

  config_write(config, f);

  fclose(f);

  config->error_type = CONFIG_ERR_NONE;

  return(CONFIG_TRUE);

}

/* ------------------------------------------------------------------------- */

void config_destroy(config_t *config)

{

  unsigned int count = config->num_filenames;

  const char **f;

  __config_setting_destroy(config->root);

  for(f = config->filenames; count > 0; ++f, --count)

    _delete(*f);

  _delete(config->filenames);

  _delete(config->include_dir);

  memset((void *)config, 0, sizeof(config_t));

}

/* ------------------------------------------------------------------------- */

void config_init(config_t *config)

{

  memset((void *)config, 0, sizeof(config_t));

  config->root = _new(config_setting_t);

  config->root->type = CONFIG_TYPE_GROUP;

  config->root->config = config;

  config->tab_width = 2;

}

/* ------------------------------------------------------------------------- */

void config_set_auto_convert(config_t *config, int flag)

{

  if(flag)

    config->flags |= CONFIG_OPTION_AUTOCONVERT;

  else

    config->flags &= ~CONFIG_OPTION_AUTOCONVERT;

}

/* ------------------------------------------------------------------------- */

int config_get_auto_convert(const config_t *config)

{

  return((config->flags & CONFIG_OPTION_AUTOCONVERT) != 0);

}

/* ------------------------------------------------------------------------- */

static config_setting_t *config_setting_create(config_setting_t *parent,

                                               const char *name, int type)

{

  config_setting_t *setting;

  config_list_t *list;

  if((parent->type != CONFIG_TYPE_GROUP)

     && (parent->type != CONFIG_TYPE_ARRAY)

     && (parent->type != CONFIG_TYPE_LIST))

    return(NULL);

  setting = _new(config_setting_t);

  setting->parent = parent;

  setting->name = (name == NULL) ? NULL : strdup(name);

  setting->type = type;

  setting->config = parent->config;

  setting->hook = NULL;

  setting->line = 0;

  list = parent->value.list;

  if(! list)

    list = parent->value.list = _new(config_list_t);

  __config_list_add(list, setting);

  return(setting);

}

/* ------------------------------------------------------------------------- */

static int __config_setting_get_int(const config_setting_t *setting,

                                    int *value)

{

  switch(setting->type)

  {

    case CONFIG_TYPE_INT:

      *value = setting->value.ival;

      return(CONFIG_TRUE);

    case CONFIG_TYPE_INT64:

      if((setting->value.llval > INT32_MAX)

         || (setting->value.llval < INT32_MIN))

        *value = 0;

      else

        *value = (int)(setting->value.llval);

      return(CONFIG_TRUE);

    case CONFIG_TYPE_FLOAT:

      if((setting->config->flags & CONFIG_OPTION_AUTOCONVERT) != 0)

      {

        *value = (int)(setting->value.fval);

        return(CONFIG_TRUE);

      }

      else

      { /* fall through */ }

    default:

      return(CONFIG_FALSE);

  }

}

/* ------------------------------------------------------------------------- */

int config_setting_get_int(const config_setting_t *setting)

{

  int value = 0;

  __config_setting_get_int(setting, &value);

  return(value);

}

/* ------------------------------------------------------------------------- */

static int __config_setting_get_int64(const config_setting_t *setting,

                                      long long *value)

{

  switch(setting->type)

  {

    case CONFIG_TYPE_INT64:

      *value = setting->value.llval;

      return(CONFIG_TRUE);

    case CONFIG_TYPE_INT:

      *value = (long long)(setting->value.ival);

      return(CONFIG_TRUE);

    case CONFIG_TYPE_FLOAT:

      if((setting->config->flags & CONFIG_OPTION_AUTOCONVERT) != 0)

      {

        *value = (long long)(setting->value.fval);

        return(CONFIG_TRUE);

      }

      else

      { /* fall through */ }

    default:

      return(CONFIG_FALSE);

  }

}

/* ------------------------------------------------------------------------- */

long long config_setting_get_int64(const config_setting_t *setting)

{

  long long value = 0;

  __config_setting_get_int64(setting, &value);

  return(value);

}

/* ------------------------------------------------------------------------- */

int config_setting_lookup_int(const config_setting_t *setting,

                              const char *name, int *value)

{

  config_setting_t *member = config_setting_get_member(setting, name);

  if(! member)

    return(CONFIG_FALSE);

  return(__config_setting_get_int(member, value));

}

/* ------------------------------------------------------------------------- */

int config_setting_lookup_int64(const config_setting_t *setting,

                                const char *name, long long *value)

{

  config_setting_t *member = config_setting_get_member(setting, name);

  if(! member)

    return(CONFIG_FALSE);

  return(__config_setting_get_int64(member, value));

}