/src/libucl/src/ucl_util.c

Source
/* Copyright (c) 2013, Vsevolod Stakhov
 * Copyright (c) 2015 Allan Jude <allanjude@freebsd.org>
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *       * Redistributions of source code must retain the above copyright
 *         notice, this list of conditions and the following disclaimer.
 *       * Redistributions in binary form must reproduce the above copyright
 *         notice, this list of conditions and the following disclaimer in the
 *         documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED ''AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL AUTHOR BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "ucl.h"
#include "ucl_internal.h"
#include "ucl_chartable.h"
#include "kvec.h"
#include <limits.h>
#include <stdarg.h>
#include <stdio.h> /* for snprintf */

#ifndef _WIN32
#include <glob.h>
#include <sys/param.h>
#else
#ifndef NBBY
#define NBBY 8
#endif
#endif

#ifdef HAVE_LIBGEN_H
#ifndef _WIN32
#include <libgen.h> /* For dirname */
#endif
#endif

typedef kvec_t(ucl_object_t *) ucl_array_t;

#define UCL_ARRAY_GET(ar, obj) ucl_array_t *ar = \
                   (ucl_array_t *) ((obj) != NULL ? (obj)->value.av : NULL)

#ifdef HAVE_OPENSSL
#include <openssl/err.h>
#include <openssl/sha.h>
#include <openssl/rsa.h>
#include <openssl/ssl.h>
#include <openssl/evp.h>
#endif

#ifdef CURL_FOUND
/* Seems to be broken */
#define CURL_DISABLE_TYPECHECK 1
#include <curl/curl.h>
#endif
#ifdef HAVE_FETCH_H
#include <fetch.h>
#endif

#if defined(_WIN32)
#include <windows.h>
#include <io.h>
#include <direct.h>

#ifndef PROT_READ
#define PROT_READ 1
#endif
#ifndef PROT_WRITE
#define PROT_WRITE 2
#endif
#ifndef PROT_READWRITE
#define PROT_READWRITE 3
#endif
#ifndef MAP_SHARED
#define MAP_SHARED 1
#endif
#ifndef MAP_PRIVATE
#define MAP_PRIVATE 2
#endif
#ifndef MAP_FAILED
#define MAP_FAILED ((void *) -1)
#endif

#define getcwd _getcwd
#define open _open
#define close _close

static void *ucl_mmap(char *addr, size_t length, int prot, int access, int fd, off_t offset)
{
  void *map = NULL;
  HANDLE handle = INVALID_HANDLE_VALUE;

  switch (prot) {
  default:
  case PROT_READ: {
    handle = CreateFileMapping((HANDLE) _get_osfhandle(fd), 0, PAGE_READONLY, 0, length, 0);
    if (!handle) break;
    map = (void *) MapViewOfFile(handle, FILE_MAP_READ, 0, 0, length);
    CloseHandle(handle);
    break;
  }
  case PROT_WRITE: {
    handle = CreateFileMapping((HANDLE) _get_osfhandle(fd), 0, PAGE_READWRITE, 0, length, 0);
    if (!handle) break;
    map = (void *) MapViewOfFile(handle, FILE_MAP_WRITE, 0, 0, length);
    CloseHandle(handle);
    break;
  }
  case PROT_READWRITE: {
    handle = CreateFileMapping((HANDLE) _get_osfhandle(fd), 0, PAGE_READWRITE, 0, length, 0);
    if (!handle) break;
    map = (void *) MapViewOfFile(handle, FILE_MAP_ALL_ACCESS, 0, 0, length);
    CloseHandle(handle);
    break;
  }
  }
  if (map == (void *) NULL) {
    return (void *) MAP_FAILED;
  }
  return (void *) ((char *) map + offset);
}

static int ucl_munmap(void *map, size_t length)
{
  if (!UnmapViewOfFile(map)) {
    return (-1);
  }
  return (0);
}

static char *ucl_realpath(const char *path, char *resolved_path)
{
  char *p;
  char tmp[MAX_PATH + 1];
  strncpy(tmp, path, sizeof(tmp) - 1);
  p = tmp;
  while (*p) {
    if (*p == '/') *p = '\\';
    p++;
  }
  return _fullpath(resolved_path, tmp, MAX_PATH);
}


char *dirname(char *path)
{
  static char path_buffer[_MAX_PATH];
  char drive[_MAX_DRIVE];
  char dir[_MAX_DIR];
  char fname[_MAX_FNAME];
  char ext[_MAX_EXT];

  _splitpath(path, drive, dir, fname, ext);
  _makepath(path_buffer, drive, dir, NULL, NULL);

  return path_buffer;
}

char *basename(char *path)
{
  static char path_buffer[_MAX_PATH];
  char drive[_MAX_DRIVE];
  char dir[_MAX_DIR];
  char fname[_MAX_FNAME];
  char ext[_MAX_EXT];

  _splitpath(path, drive, dir, fname, ext);
  _makepath(path_buffer, NULL, NULL, fname, ext);

  return path_buffer;
}
#else
#define ucl_mmap mmap
#define ucl_munmap munmap
#define ucl_realpath realpath
#endif

typedef void (*ucl_object_dtor)(ucl_object_t *obj);
static void ucl_object_free_internal(ucl_object_t *obj, bool allow_rec,
                   ucl_object_dtor dtor);
static void ucl_object_dtor_unref(ucl_object_t *obj);

static void
ucl_object_dtor_free(ucl_object_t *obj)
{
  if (obj->trash_stack[UCL_TRASH_KEY] != NULL) {
    UCL_FREE(obj->hh.keylen, obj->trash_stack[UCL_TRASH_KEY]);
  }
  if (obj->trash_stack[UCL_TRASH_VALUE] != NULL) {
    UCL_FREE(obj->len, obj->trash_stack[UCL_TRASH_VALUE]);
  }
  /* Do not free ephemeral objects */
  if ((obj->flags & UCL_OBJECT_EPHEMERAL) == 0) {
    if (obj->type != UCL_USERDATA) {
      UCL_FREE(sizeof(ucl_object_t), obj);
    }
    else {
      struct ucl_object_userdata *ud = (struct ucl_object_userdata *) obj;
      if (ud->dtor) {
        ud->dtor(obj->value.ud);
      }
      UCL_FREE(sizeof(*ud), obj);
    }
  }
}

/*
 * This is a helper function that performs exactly the same as
 * `ucl_object_unref` but it doesn't iterate over elements allowing
 * to use it for individual elements of arrays and multiple values
 */
static void
ucl_object_dtor_unref_single(ucl_object_t *obj)
{
  if (obj != NULL) {
#ifdef HAVE_ATOMIC_BUILTINS
    unsigned int rc = __sync_sub_and_fetch(&obj->ref, 1);
    if (rc == 0) {
#else
    if (--obj->ref == 0) {
#endif
      ucl_object_free_internal(obj, false, ucl_object_dtor_unref);
    }
  }
}

static void
ucl_object_dtor_unref(ucl_object_t *obj)
{
  if (obj->ref == 0) {
    ucl_object_dtor_free(obj);
  }
  else {
    /* This may cause dtor unref being called one more time */
    ucl_object_dtor_unref_single(obj);
  }
}

static void
ucl_object_free_internal(ucl_object_t *obj, bool allow_rec, ucl_object_dtor dtor)
{
  ucl_object_t *tmp, *sub;

  while (obj != NULL) {
    if (obj->type == UCL_ARRAY) {
      UCL_ARRAY_GET(vec, obj);
      unsigned int i;

      if (vec != NULL) {
        for (i = 0; i < vec->n; i++) {
          sub = kv_A(*vec, i);
          if (sub != NULL) {
            tmp = sub;
            while (sub) {
              tmp = sub->next;
              dtor(sub);
              sub = tmp;
            }
          }
        }
        kv_destroy(*vec);
        UCL_FREE(sizeof(*vec), vec);
      }
      obj->value.av = NULL;
    }
    else if (obj->type == UCL_OBJECT) {
      if (obj->value.ov != NULL) {
        ucl_hash_destroy(obj->value.ov, (ucl_hash_free_func) dtor);
      }
      obj->value.ov = NULL;
    }
    tmp = obj->next;
    dtor(obj);
    obj = tmp;

    if (!allow_rec) {
      break;
    }
  }
}

void ucl_object_free(ucl_object_t *obj)
{
  ucl_object_free_internal(obj, true, ucl_object_dtor_free);
}

size_t
ucl_unescape_json_string(char *str, size_t len)
{
  char *t = str, *h = str;
  int i, uval;

  if (len <= 1) {
    return len;
  }
  /* t is target (tortoise), h is source (hare) */

  while (len) {
    if (*h == '\\') {
      h++;

      if (len == 1) {
        /*
         * If \ is last, then do not try to go further
         * Issue: #74
         */
        len--;
        *t++ = '\\';
        continue;
      }

      switch (*h) {
      case 'n':
        *t++ = '\n';
        break;
      case 'r':
        *t++ = '\r';
        break;
      case 'b':
        *t++ = '\b';
        break;
      case 't':
        *t++ = '\t';
        break;
      case 'f':
        *t++ = '\f';
        break;
      case '\\':
        *t++ = '\\';
        break;
      case '"':
        *t++ = '"';
        break;
      case 'u':
        /* Unicode escape */
        uval = 0;
        h++; /* u character */
        len--;

        if (len > 3) {
          for (i = 0; i < 4; i++) {
            uval <<= 4;
            if (isdigit(h[i])) {
              uval += h[i] - '0';
            }
            else if (h[i] >= 'a' && h[i] <= 'f') {
              uval += h[i] - 'a' + 10;
            }
            else if (h[i] >= 'A' && h[i] <= 'F') {
              uval += h[i] - 'A' + 10;
            }
            else {
              break;
            }
          }

          /* Encode */
          if (uval < 0x80) {
            t[0] = (char) uval;
            t++;
          }
          else if (uval < 0x800) {
            t[0] = 0xC0 + ((uval & 0x7C0) >> 6);
            t[1] = 0x80 + ((uval & 0x03F));
            t += 2;
          }
          else if (uval < 0x10000) {
            t[0] = 0xE0 + ((uval & 0xF000) >> 12);
            t[1] = 0x80 + ((uval & 0x0FC0) >> 6);
            t[2] = 0x80 + ((uval & 0x003F));
            t += 3;
          }
#if 0
          /* It's not actually supported now */
          else if(uval <= 0x10FFFF) {
            t[0] = 0xF0 + ((uval & 0x1C0000) >> 18);
            t[1] = 0x80 + ((uval & 0x03F000) >> 12);
            t[2] = 0x80 + ((uval & 0x000FC0) >> 6);
            t[3] = 0x80 + ((uval & 0x00003F));
            t += 4;
          }
#endif
          else {
            *t++ = '?';
          }

          /* Consume 4 characters of source */
          h += 4;
          len -= 4;

          if (len > 0) {
            len--; /* for '\' character */
          }
          continue;
        }
        else {
          *t++ = 'u';
        }
        break;
      default:
        *t++ = *h;
        break;
      }
      h++;
      len--;
    }
    else {
      *t++ = *h++;
    }

    if (len > 0) {
      len--;
    }
  }
  *t = '\0';

  return (t - str);
}

size_t
ucl_unescape_squoted_string(char *str, size_t len)
{
  char *t = str, *h = str;

  if (len <= 1) {
    return len;
  }

  /* t is target (tortoise), h is source (hare) */

  while (len) {
    if (*h == '\\') {
      h++;

      if (len == 1) {
        /*
         * If \ is last, then do not try to go further
         * Issue: #74
         */
        len--;
        *t++ = '\\';
        continue;
      }

      switch (*h) {
      case '\'':
        *t++ = '\'';
        break;
      case '\n':
        /* Ignore \<newline> style stuff */
        break;
      case '\r':
        /* Ignore \r and the following \n if needed */
        if (len > 1 && h[1] == '\n') {
          h++;
          len--;
        }
        break;
      default:
        /* Ignore \ */
        *t++ = '\\';
        *t++ = *h;
        break;
      }

      h++;
      len--;
    }
    else {
      *t++ = *h++;
    }

    if (len > 0) {
      len--;
    }
  }

  *t = '\0';

  return (t - str);
}

char *
ucl_copy_key_trash(const ucl_object_t *obj)
{
  ucl_object_t *deconst;

  if (obj == NULL) {
    return NULL;
  }
  if (obj->trash_stack[UCL_TRASH_KEY] == NULL && obj->key != NULL) {
    deconst = __DECONST(ucl_object_t *, obj);
    deconst->trash_stack[UCL_TRASH_KEY] = malloc(obj->keylen + 1);
    if (deconst->trash_stack[UCL_TRASH_KEY] != NULL) {
      memcpy(deconst->trash_stack[UCL_TRASH_KEY], obj->key, obj->keylen);
      deconst->trash_stack[UCL_TRASH_KEY][obj->keylen] = '\0';
    }
    deconst->key = obj->trash_stack[UCL_TRASH_KEY];
    deconst->flags |= UCL_OBJECT_ALLOCATED_KEY;
  }

  return obj->trash_stack[UCL_TRASH_KEY];
}

void ucl_chunk_free(struct ucl_chunk *chunk)
{
  if (chunk) {
    struct ucl_parser_special_handler_chain *chain, *tmp;

    LL_FOREACH_SAFE(chunk->special_handlers, chain, tmp)
    {
      if (chain->special_handler->free_function) {
        chain->special_handler->free_function(
          chain->begin,
          chain->len,
          chain->special_handler->user_data);
      }
      else {
        UCL_FREE(chain->len, chain->begin);
      }

      UCL_FREE(sizeof(*chain), chain);
    }

    chunk->special_handlers = NULL;

    if (chunk->fname) {
      free(chunk->fname);
    }

    UCL_FREE(sizeof(*chunk), chunk);
  }
}

char *
ucl_copy_value_trash(const ucl_object_t *obj)
{
  ucl_object_t *deconst;

  if (obj == NULL) {
    return NULL;
  }
  if (obj->trash_stack[UCL_TRASH_VALUE] == NULL) {
    deconst = __DECONST(ucl_object_t *, obj);
    if (obj->type == UCL_STRING) {

      /* Special case for strings */
      if (obj->flags & UCL_OBJECT_BINARY) {
        deconst->trash_stack[UCL_TRASH_VALUE] = malloc(obj->len);
        if (deconst->trash_stack[UCL_TRASH_VALUE] != NULL) {
          memcpy(deconst->trash_stack[UCL_TRASH_VALUE],
               obj->value.sv,
               obj->len);
          deconst->value.sv = obj->trash_stack[UCL_TRASH_VALUE];
        }
      }
      else {
        deconst->trash_stack[UCL_TRASH_VALUE] = malloc(obj->len + 1);
        if (deconst->trash_stack[UCL_TRASH_VALUE] != NULL) {
          memcpy(deconst->trash_stack[UCL_TRASH_VALUE],
               obj->value.sv,
               obj->len);
          deconst->trash_stack[UCL_TRASH_VALUE][obj->len] = '\0';
          deconst->value.sv = obj->trash_stack[UCL_TRASH_VALUE];
        }
      }
    }
    else {
      /* Just emit value in json notation */
      deconst->trash_stack[UCL_TRASH_VALUE] = ucl_object_emit_single_json(obj);
      deconst->len = strlen(obj->trash_stack[UCL_TRASH_VALUE]);
    }
    deconst->flags |= UCL_OBJECT_ALLOCATED_VALUE;
  }

  return obj->trash_stack[UCL_TRASH_VALUE];
}

ucl_object_t *
ucl_parser_get_object(struct ucl_parser *parser)
{
  if (parser->state != UCL_STATE_ERROR && parser->top_obj != NULL) {
    return ucl_object_ref(parser->top_obj);
  }

  return NULL;
}

void ucl_parser_free(struct ucl_parser *parser)
{
  struct ucl_stack *stack, *stmp;
  struct ucl_macro *macro, *mtmp;
  struct ucl_chunk *chunk, *ctmp;
  struct ucl_pubkey *key, *ktmp;
  struct ucl_variable *var, *vtmp;
  ucl_object_t *tr, *trtmp;

  if (parser == NULL) {
    return;
  }

  if (parser->top_obj != NULL) {
    ucl_object_unref(parser->top_obj);
  }

  if (parser->includepaths != NULL) {
    ucl_object_unref(parser->includepaths);
  }

  LL_FOREACH_SAFE(parser->stack, stack, stmp)
  {
    free(stack);
  }
  HASH_ITER(hh, parser->macroes, macro, mtmp)
  {
    free(macro->name);
    HASH_DEL(parser->macroes, macro);
    UCL_FREE(sizeof(struct ucl_macro), macro);
  }
  LL_FOREACH_SAFE(parser->chunks, chunk, ctmp)
  {
    ucl_chunk_free(chunk);
  }
  LL_FOREACH_SAFE(parser->keys, key, ktmp)
  {
    UCL_FREE(sizeof(struct ucl_pubkey), key);
  }
  LL_FOREACH_SAFE(parser->variables, var, vtmp)
  {
    free(var->value);
    free(var->var);
    UCL_FREE(sizeof(struct ucl_variable), var);
  }
  LL_FOREACH_SAFE(parser->trash_objs, tr, trtmp)
  {
    ucl_object_free_internal(tr, false, ucl_object_dtor_free);
  }

  if (parser->err != NULL) {
    utstring_free(parser->err);
  }

  if (parser->cur_file) {
    UCL_FREE(strlen(parser->cur_file) + 1, parser->cur_file);
  }

  if (parser->comments) {
    ucl_object_unref(parser->comments);
  }

  UCL_FREE(sizeof(struct ucl_parser), parser);
}

const char *
ucl_parser_get_error(struct ucl_parser *parser)
{
  if (parser == NULL) {
    return NULL;
  }

  if (parser->err == NULL) {
    return NULL;
  }

  return utstring_body(parser->err);
}

int ucl_parser_get_error_code(struct ucl_parser *parser)
{
  if (parser == NULL) {
    return 0;
  }

  return parser->err_code;
}

unsigned
ucl_parser_get_column(struct ucl_parser *parser)
{
  if (parser == NULL || parser->chunks == NULL) {
    return 0;
  }

  return parser->chunks->column;
}

unsigned
ucl_parser_get_linenum(struct ucl_parser *parser)
{
  if (parser == NULL || parser->chunks == NULL) {
    return 0;
  }

  return parser->chunks->line;
}

void ucl_parser_clear_error(struct ucl_parser *parser)
{
  if (parser != NULL && parser->err != NULL) {
    utstring_free(parser->err);
    parser->err = NULL;
    parser->err_code = 0;
  }
}

bool ucl_pubkey_add(struct ucl_parser *parser, const unsigned char *key, size_t len)
{
#ifndef HAVE_OPENSSL
  ucl_create_err(&parser->err, "cannot check signatures without openssl");
  return false;
#else
#if (OPENSSL_VERSION_NUMBER < 0x10000000L)
  ucl_create_err(&parser->err, "cannot check signatures, openssl version is unsupported");
  return EXIT_FAILURE;
#else
  struct ucl_pubkey *nkey;
  BIO *mem;

  mem = BIO_new_mem_buf((void *) key, len);
  nkey = UCL_ALLOC(sizeof(struct ucl_pubkey));
  if (nkey == NULL) {
    ucl_create_err(&parser->err, "cannot allocate memory for key");
    return false;
  }
  nkey->key = PEM_read_bio_PUBKEY(mem, &nkey->key, NULL, NULL);
  BIO_free(mem);
  if (nkey->key == NULL) {
    UCL_FREE(sizeof(struct ucl_pubkey), nkey);
    ucl_create_err(&parser->err, "%s",
             ERR_error_string(ERR_get_error(), NULL));
    return false;
  }
  LL_PREPEND(parser->keys, nkey);
#endif
#endif
  return true;
}

void ucl_parser_add_special_handler(struct ucl_parser *parser,
                  struct ucl_parser_special_handler *handler)
{
  LL_APPEND(parser->special_handlers, handler);
}

#ifdef CURL_FOUND
struct ucl_curl_cbdata {
  unsigned char *buf;
  size_t buflen;
};

static size_t
ucl_curl_write_callback(void *contents, size_t size, size_t nmemb, void *ud)
{
  struct ucl_curl_cbdata *cbdata = ud;
  size_t realsize = size * nmemb;

  cbdata->buf = realloc(cbdata->buf, cbdata->buflen + realsize + 1);
  if (cbdata->buf == NULL) {
    return 0;
  }

  memcpy(&(cbdata->buf[cbdata->buflen]), contents, realsize);
  cbdata->buflen += realsize;
  cbdata->buf[cbdata->buflen] = 0;

  return realsize;
}
#endif

/**
 * Fetch a url and save results to the memory buffer
 * @param url url to fetch
 * @param len length of url
 * @param buf target buffer
 * @param buflen target length
 * @return
 */
bool ucl_fetch_url(const unsigned char *url, unsigned char **buf, size_t *buflen,
           UT_string **err, bool must_exist)
{

#ifdef HAVE_FETCH_H
  struct url *fetch_url;
  struct url_stat us;
  FILE *in;

  fetch_url = fetchParseURL(url);
  if (fetch_url == NULL) {
    ucl_create_err(err, "invalid URL %s: %s",
             url, strerror(errno));
    return false;
  }
  if ((in = fetchXGet(fetch_url, &us, "")) == NULL) {
    if (!must_exist) {
      ucl_create_err(err, "cannot fetch URL %s: %s",
               url, strerror(errno));
    }
    fetchFreeURL(fetch_url);
    return false;
  }

  *buflen = us.size;
  *buf = malloc(*buflen);
  if (*buf == NULL) {
    ucl_create_err(err, "cannot allocate buffer for URL %s: %s",
             url, strerror(errno));
    fclose(in);
    fetchFreeURL(fetch_url);
    return false;
  }

  if (fread(*buf, *buflen, 1, in) != 1) {
    ucl_create_err(err, "cannot read URL %s: %s",
             url, strerror(errno));
    fclose(in);
    fetchFreeURL(fetch_url);
    return false;
  }

  fetchFreeURL(fetch_url);
  return true;
#elif defined(CURL_FOUND)
  CURL *curl;
  int r;
  struct ucl_curl_cbdata cbdata;

  curl = curl_easy_init();
  if (curl == NULL) {
    ucl_create_err(err, "CURL interface is broken");
    return false;
  }
  if ((r = curl_easy_setopt(curl, CURLOPT_URL, url)) != CURLE_OK) {
    ucl_create_err(err, "invalid URL %s: %s",
             url, curl_easy_strerror(r));
    curl_easy_cleanup(curl);
    return false;
  }
  curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, ucl_curl_write_callback);
  cbdata.buf = NULL;
  cbdata.buflen = 0;
  curl_easy_setopt(curl, CURLOPT_WRITEDATA, &cbdata);

  if ((r = curl_easy_perform(curl)) != CURLE_OK) {
    if (!must_exist) {
      ucl_create_err(err, "error fetching URL %s: %s",
               url, curl_easy_strerror(r));
    }
    curl_easy_cleanup(curl);
    if (cbdata.buf) {
      free(cbdata.buf);
    }
    return false;
  }
  *buf = cbdata.buf;
  *buflen = cbdata.buflen;

  curl_easy_cleanup(curl);

  return true;
#else
  ucl_create_err(err, "URL support is disabled");
  return false;
#endif
}

/**
 * Fetch a file and save results to the memory buffer
 * @param filename filename to fetch
 * @param len length of filename
 * @param buf target buffer
 * @param buflen target length
 * @return
 */
bool ucl_fetch_file(const unsigned char *filename, unsigned char **buf, size_t *buflen,
          UT_string **err, bool must_exist)
{
  int fd;
  struct stat st;
  if ((fd = open(filename, O_RDONLY)) == -1) {
    ucl_create_err(err, "cannot open file %s: %s",
             filename, strerror(errno));
    return false;
  }

  if (fstat(fd, &st) == -1) {
    if (must_exist || errno == EPERM) {
      ucl_create_err(err, "cannot stat file %s: %s",
               filename, strerror(errno));
    }
    close(fd);

    return false;
  }
  if (!S_ISREG(st.st_mode)) {
    if (must_exist) {
      ucl_create_err(err, "file %s is not a regular file", filename);
    }
    close(fd);

    return false;
  }

  if (st.st_size == 0) {
    /* Do not map empty files */
    *buf = NULL;
    *buflen = 0;
  }
  else {
    if ((*buf = ucl_mmap(NULL, st.st_size, PROT_READ, MAP_SHARED, fd, 0)) == MAP_FAILED) {
      close(fd);
      ucl_create_err(err, "cannot mmap file %s: %s",
               filename, strerror(errno));
      *buf = NULL;

      return false;
    }
    *buflen = st.st_size;
  }

  close(fd);

  return true;
}


#if (defined(HAVE_OPENSSL) && OPENSSL_VERSION_NUMBER >= 0x10000000L)
static inline bool
ucl_sig_check(const unsigned char *data, size_t datalen,
        const unsigned char *sig, size_t siglen, struct ucl_parser *parser)
{
  struct ucl_pubkey *key;
  char dig[EVP_MAX_MD_SIZE];
  unsigned int diglen;
  EVP_PKEY_CTX *key_ctx;
  EVP_MD_CTX *sign_ctx = NULL;

  sign_ctx = EVP_MD_CTX_create();

  LL_FOREACH(parser->keys, key)
  {
    key_ctx = EVP_PKEY_CTX_new(key->key, NULL);
    if (key_ctx != NULL) {
      if (EVP_PKEY_verify_init(key_ctx) <= 0) {
        EVP_PKEY_CTX_free(key_ctx);
        continue;
      }
      if (EVP_PKEY_CTX_set_rsa_padding(key_ctx, RSA_PKCS1_PADDING) <= 0) {
        EVP_PKEY_CTX_free(key_ctx);
        continue;
      }
      if (EVP_PKEY_CTX_set_signature_md(key_ctx, EVP_sha256()) <= 0) {
        EVP_PKEY_CTX_free(key_ctx);
        continue;
      }
      EVP_DigestInit(sign_ctx, EVP_sha256());
      EVP_DigestUpdate(sign_ctx, data, datalen);
      EVP_DigestFinal(sign_ctx, dig, &diglen);

      if (EVP_PKEY_verify(key_ctx, sig, siglen, dig, diglen) == 1) {
        EVP_MD_CTX_destroy(sign_ctx);
        EVP_PKEY_CTX_free(key_ctx);
        return true;
      }

      EVP_PKEY_CTX_free(key_ctx);
    }
  }

  EVP_MD_CTX_destroy(sign_ctx);

  return false;
}
#endif

struct ucl_include_params {
  bool check_signature;
  bool must_exist;
  bool use_glob;
  bool use_prefix;
  bool soft_fail;
  bool allow_glob;
  unsigned priority;
  enum ucl_duplicate_strategy strat;
  enum ucl_parse_type parse_type;
  const char *prefix;
  const char *target;
};

/**
 * Include an url to configuration
 * @param data
 * @param len
 * @param parser
 * @param err
 * @return
 */
static bool
ucl_include_url(const unsigned char *data, size_t len,
        struct ucl_parser *parser,
        struct ucl_include_params *params)
{

  bool res;
  unsigned char *buf = NULL;
  size_t buflen = 0;
  struct ucl_chunk *chunk;
  char urlbuf[PATH_MAX];
  int prev_state;

  snprintf(urlbuf, sizeof(urlbuf), "%.*s", (int) len, data);

  if (!ucl_fetch_url(urlbuf, &buf, &buflen, &parser->err, params->must_exist)) {
    if (!params->must_exist) {
      ucl_parser_clear_error(parser);
    }
    return !params->must_exist;
  }

  if (params->check_signature) {
#if (defined(HAVE_OPENSSL) && OPENSSL_VERSION_NUMBER >= 0x10000000L)
    unsigned char *sigbuf = NULL;
    size_t siglen = 0;
    /* We need to check signature first */
    snprintf(urlbuf, sizeof(urlbuf), "%.*s.sig", (int) len, data);
    if (!ucl_fetch_url(urlbuf, &sigbuf, &siglen, &parser->err, true)) {
      return false;
    }
    if (!ucl_sig_check(buf, buflen, sigbuf, siglen, parser)) {
      ucl_create_err(&parser->err, "cannot verify url %s: %s",
               urlbuf,
               ERR_error_string(ERR_get_error(), NULL));
      if (siglen > 0) {
        free(sigbuf);
      }
      return false;
    }
    if (siglen > 0) {
      free(sigbuf);
    }
#endif
  }

  prev_state = parser->state;
  parser->state = UCL_STATE_INIT;

  res = ucl_parser_add_chunk_full(parser, buf, buflen, params->priority,
                  params->strat, params->parse_type);
  if (res == true) {
    /* Remove chunk from the stack */
    chunk = parser->chunks;
    if (chunk != NULL) {
      parser->chunks = chunk->next;
      ucl_chunk_free(chunk);
    }
  }

  parser->state = prev_state;
  free(buf);

  return res;
}

/**
 * Include a single file to the parser
 * @param data
 * @param len
 * @param parser
 * @param check_signature
 * @param must_exist
 * @param allow_glob
 * @param priority
 * @return
 */
static bool
ucl_include_file_single(const unsigned char *data, size_t len,
            struct ucl_parser *parser, struct ucl_include_params *params)
{
  bool res;
  struct ucl_chunk *chunk;
  unsigned char *buf = NULL;
  char *old_curfile, *ext;
  size_t buflen = 0;
  char filebuf[PATH_MAX], realbuf[PATH_MAX];
  int prev_state;
  struct ucl_variable *cur_var, *tmp_var, *old_curdir = NULL,
                      *old_filename = NULL;
  ucl_object_t *nest_obj = NULL, *old_obj = NULL, *new_obj = NULL;
  ucl_hash_t *container = NULL;
  struct ucl_stack *st = NULL;

  if (parser->state == UCL_STATE_ERROR) {
    /* Return immediately if we are in the error state... */
    return false;
  }

  snprintf(filebuf, sizeof(filebuf), "%.*s", (int) len, data);
  if (ucl_realpath(filebuf, realbuf) == NULL) {
    if (params->soft_fail) {
      return false;
    }
    if (!params->must_exist && errno != EPERM) {
      return true;
    }

    ucl_create_err(&parser->err, "cannot open file %s: %s",
             filebuf,
             strerror(errno));
    return false;
  }

  if (parser->cur_file && strcmp(realbuf, parser->cur_file) == 0) {
    /* We are likely including the file itself */
    if (params->soft_fail) {
      return false;
    }

    ucl_create_err(&parser->err, "trying to include the file %s from itself",
             realbuf);
    return false;
  }

  if (!ucl_fetch_file(realbuf, &buf, &buflen, &parser->err, params->must_exist)) {
    if (params->soft_fail) {
      return false;
    }

    if (params->must_exist || parser->err != NULL) {
      /* The case of fatal errors */
      return false;
    }

    ucl_parser_clear_error(parser);

    return true;
  }

  if (params->check_signature) {
#if (defined(HAVE_OPENSSL) && OPENSSL_VERSION_NUMBER >= 0x10000000L)
    unsigned char *sigbuf = NULL;
    size_t siglen = 0;
    /* We need to check signature first */
    snprintf(filebuf, sizeof(filebuf), "%s.sig", realbuf);
    if (!ucl_fetch_file(filebuf, &sigbuf, &siglen, &parser->err, true)) {
      if (buf) {
        ucl_munmap(buf, buflen);
      }

      return false;
    }
    if (!ucl_sig_check(buf, buflen, sigbuf, siglen, parser)) {
      ucl_create_err(&parser->err, "cannot verify file %s: %s",
               filebuf,
               ERR_error_string(ERR_get_error(), NULL));
      if (sigbuf) {
        ucl_munmap(sigbuf, siglen);
      }
      if (buf) {
        ucl_munmap(buf, buflen);
      }

      return false;
    }

    if (sigbuf) {
      ucl_munmap(sigbuf, siglen);
    }
#endif
  }

  old_curfile = parser->cur_file;
  parser->cur_file = NULL;

  /* Store old file vars */
  DL_FOREACH_SAFE(parser->variables, cur_var, tmp_var)
  {
    if (strcmp(cur_var->var, "CURDIR") == 0) {
      old_curdir = cur_var;
      DL_DELETE(parser->variables, cur_var);
    }
    else if (strcmp(cur_var->var, "FILENAME") == 0) {
      old_filename = cur_var;
      DL_DELETE(parser->variables, cur_var);
    }
  }

  ucl_parser_set_filevars(parser, realbuf, false);

  prev_state = parser->state;
  parser->state = UCL_STATE_INIT;

  if (params->use_prefix && params->prefix == NULL) {
    /* Auto generate a key name based on the included filename */
    params->prefix = basename(realbuf);
    ext = strrchr(params->prefix, '.');
    if (ext != NULL && (strcmp(ext, ".conf") == 0 || strcmp(ext, ".ucl") == 0)) {
      /* Strip off .conf or .ucl */
      *ext = '\0';
    }
  }
  if (params->prefix != NULL) {
    /* This is a prefixed include */
    container = parser->stack->obj->value.ov;

    old_obj = __DECONST(ucl_object_t *, ucl_hash_search(container,
                              params->prefix, strlen(params->prefix)));

    if (strcasecmp(params->target, "array") == 0) {
      if (old_obj == NULL) {
        /* Create an array with key: prefix */
        old_obj = ucl_object_new_full(UCL_ARRAY, params->priority);
        old_obj->key = params->prefix;
        old_obj->keylen = strlen(params->prefix);
        ucl_copy_key_trash(old_obj);
        old_obj->prev = old_obj;
        old_obj->next = NULL;

        container = ucl_hash_insert_object(container, old_obj,
                           parser->flags & UCL_PARSER_KEY_LOWERCASE);
        parser->stack->obj->len++;

        nest_obj = ucl_object_new_full(UCL_OBJECT, params->priority);
        nest_obj->prev = nest_obj;
        nest_obj->next = NULL;

        ucl_array_append(old_obj, nest_obj);
      }
      else {
        if (ucl_object_type(old_obj) == UCL_ARRAY) {
          /* Append to the existing array */
          nest_obj = ucl_object_new_full(UCL_OBJECT,
                           params->priority);
          if (nest_obj == NULL) {
            ucl_create_err(&parser->err,
                     "cannot allocate memory for an object");
            if (buf) {
              ucl_munmap(buf, buflen);
            }

            return false;
          }
          nest_obj->prev = nest_obj;
          nest_obj->next = NULL;

          ucl_array_append(old_obj, nest_obj);
        }
        else {
          /* Convert the object to an array */
          new_obj = ucl_object_typed_new(UCL_ARRAY);
          if (new_obj == NULL) {
            ucl_create_err(&parser->err,
                     "cannot allocate memory for an object");
            if (buf) {
              ucl_munmap(buf, buflen);
            }

            return false;
          }
          new_obj->key = old_obj->key;
          new_obj->keylen = old_obj->keylen;
          new_obj->flags |= UCL_OBJECT_MULTIVALUE;
          new_obj->prev = new_obj;
          new_obj->next = NULL;

          nest_obj = ucl_object_new_full(UCL_OBJECT,
                           params->priority);
          if (nest_obj == NULL) {
            ucl_create_err(&parser->err,
                     "cannot allocate memory for an object");
            if (buf) {
              ucl_munmap(buf, buflen);
            }

            ucl_object_unref(new_obj);

            return false;
          }
          nest_obj->prev = nest_obj;
          nest_obj->next = NULL;

          ucl_array_append(new_obj, old_obj);
          ucl_array_append(new_obj, nest_obj);
          ucl_hash_replace(container, old_obj, new_obj);
        }
      }
    }
    else {
      /* Case of object */
      if (old_obj == NULL) {
        /* Create an object with key: prefix */
        nest_obj = ucl_object_new_full(UCL_OBJECT, params->priority);

        if (nest_obj == NULL) {
          ucl_create_err(&parser->err, "cannot allocate memory for an object");
          if (buf) {
            ucl_munmap(buf, buflen);
          }

          return false;
        }

        nest_obj->key = params->prefix;
        nest_obj->keylen = strlen(params->prefix);
        ucl_copy_key_trash(nest_obj);
        nest_obj->prev = nest_obj;
        nest_obj->next = NULL;

        container = ucl_hash_insert_object(container, nest_obj,
                           parser->flags & UCL_PARSER_KEY_LOWERCASE);
        parser->stack->obj->len++;
      }
      else {
        if (ucl_object_type(old_obj) == UCL_OBJECT) {
          /* Append to existing Object*/
          nest_obj = old_obj;
        }
        else {
          /* The key is not an object */
          ucl_create_err(&parser->err,
                   "Conflicting type for key: %s, asked %s, has %s",
                   params->prefix, params->target,
                   ucl_object_type_to_string(ucl_object_type(old_obj)));
          if (buf) {
            ucl_munmap(buf, buflen);
          }

          return false;
        }
      }
    }


    /* Put all of the content of the include inside that object */
    parser->stack->obj->value.ov = container;

    st = UCL_ALLOC(sizeof(struct ucl_stack));
    if (st == NULL) {
      ucl_create_err(&parser->err, "cannot allocate memory for an object");
      ucl_object_unref(nest_obj);

      if (buf) {
        ucl_munmap(buf, buflen);
      }

      return false;
    }
    st->obj = nest_obj;
    st->e.params.level = parser->stack->e.params.level;
    st->e.params.flags = parser->stack->e.params.flags;
    st->e.params.line = parser->stack->e.params.line;
    st->chunk = parser->chunks;
    LL_PREPEND(parser->stack, st);
    parser->cur_obj = nest_obj;
  }

  res = ucl_parser_add_chunk_full(parser, buf, buflen, params->priority,
                  params->strat, params->parse_type);

  if (res) {
    /* Stop nesting the include, take 1 level off the stack */
    if (params->prefix != NULL && nest_obj != NULL) {
      parser->stack = st->next;
      UCL_FREE(sizeof(struct ucl_stack), st);
    }

    /* Remove chunk from the stack */
    chunk = parser->chunks;
    if (chunk != NULL) {
      parser->chunks = chunk->next;
      ucl_chunk_free(chunk);
      parser->recursion--;
    }

    /* Restore old file vars */
    if (parser->cur_file) {
      UCL_FREE(strlen(parser->cur_file) + 1, parser->cur_file);
    }

    parser->cur_file = old_curfile;
    DL_FOREACH_SAFE(parser->variables, cur_var, tmp_var)
    {
      if (strcmp(cur_var->var, "CURDIR") == 0 && old_curdir) {
        DL_DELETE(parser->variables, cur_var);
        free(cur_var->var);
        free(cur_var->value);
        UCL_FREE(sizeof(struct ucl_variable), cur_var);
      }
      else if (strcmp(cur_var->var, "FILENAME") == 0 && old_filename) {
        DL_DELETE(parser->variables, cur_var);
        free(cur_var->var);
        free(cur_var->value);
        UCL_FREE(sizeof(struct ucl_variable), cur_var);
      }
    }
    if (old_filename) {
      DL_APPEND(parser->variables, old_filename);
    }
    if (old_curdir) {
      DL_APPEND(parser->variables, old_curdir);
    }

    parser->state = prev_state;
  }

  if (buflen > 0) {
    ucl_munmap(buf, buflen);
  }

  return res;
}

/**
 * Include a file to configuration
 * @param data
 * @param len
 * @param parser
 * @param err
 * @return
 */
static bool
ucl_include_file(const unsigned char *data, size_t len,
         struct ucl_parser *parser,
         struct ucl_include_params *params,
         const ucl_object_t *args)
{
  const unsigned char *p = data, *end = data + len;
  bool need_glob = false;
  int cnt = 0;
  char glob_pattern[PATH_MAX];
  size_t i;

#ifndef _WIN32
  if (!params->allow_glob) {
    return ucl_include_file_single(data, len, parser, params);
  }
  else {
    /* Check for special symbols in a filename */
    while (p != end) {
      if (*p == '*' || *p == '?') {
        need_glob = true;
        break;
      }
      p++;
    }
    if (need_glob) {
      glob_t globbuf;
      memset(&globbuf, 0, sizeof(globbuf));
      ucl_strlcpy(glob_pattern, (const char *) data,
            (len + 1 < sizeof(glob_pattern) ? len + 1 : sizeof(glob_pattern)));
      if (glob(glob_pattern, 0, NULL, &globbuf) != 0) {
        return (!params->must_exist || false);
      }
      for (i = 0; i < globbuf.gl_pathc; i++) {

        if (parser->include_trace_func) {
          const ucl_object_t *parent = NULL;

          if (parser->stack) {
            parent = parser->stack->obj;
          }

          parser->include_trace_func(parser, parent, NULL,
                         globbuf.gl_pathv[i],
                         strlen(globbuf.gl_pathv[i]),
                         parser->include_trace_ud);
        }

        if (!ucl_include_file_single((unsigned char *) globbuf.gl_pathv[i],
                       strlen(globbuf.gl_pathv[i]), parser, params)) {
          if (params->soft_fail) {
            continue;
          }
          globfree(&globbuf);
          return false;
        }
        cnt++;
      }
      globfree(&globbuf);

      if (cnt == 0 && params->must_exist) {
        ucl_create_err(&parser->err, "cannot match any files for pattern %s",
                 glob_pattern);
        return false;
      }
    }
    else {
      return ucl_include_file_single(data, len, parser, params);
    }
  }
#else
  /* Win32 compilers do not support globbing. Therefore, for Win32,
     treat allow_glob/need_glob as a NOOP and just return */
  return ucl_include_file_single(data, len, parser, params);
#endif

  return true;
}

/**
 * Common function to handle .*include* macros
 * @param data
 * @param len
 * @param args
 * @param parser
 * @param default_try
 * @param default_sign
 * @return
 */
static bool
ucl_include_common(const unsigned char *data, size_t len,
           const ucl_object_t *args, struct ucl_parser *parser,
           bool default_try,
           bool default_sign)
{
  bool allow_url = false, search = false;
  const char *duplicate;
  const ucl_object_t *param;
  ucl_object_iter_t it = NULL, ip = NULL;
  char ipath[PATH_MAX];
  struct ucl_include_params params;

  /* Default values */
  params.soft_fail = default_try;
  params.allow_glob = false;
  params.check_signature = default_sign;
  params.use_prefix = false;
  params.target = "object";
  params.prefix = NULL;
  params.priority = 0;
  params.parse_type = UCL_PARSE_UCL;
  params.strat = UCL_DUPLICATE_APPEND;
  params.must_exist = !default_try;

  if (parser->include_trace_func) {
    const ucl_object_t *parent = NULL;

    if (parser->stack) {
      parent = parser->stack->obj;
    }

    parser->include_trace_func(parser, parent, args,
                   data, len, parser->include_trace_ud);
  }

  /* Process arguments */
  if (args != NULL && args->type == UCL_OBJECT) {
    while ((param = ucl_object_iterate(args, &it, true)) != NULL) {
      if (param->type == UCL_BOOLEAN) {
        if (strncmp(param->key, "try", param->keylen) == 0) {
          params.must_exist = !ucl_object_toboolean(param);
        }
        else if (strncmp(param->key, "sign", param->keylen) == 0) {
          params.check_signature = ucl_object_toboolean(param);
        }
        else if (strncmp(param->key, "glob", param->keylen) == 0) {
          params.allow_glob = ucl_object_toboolean(param);
        }
        else if (strncmp(param->key, "url", param->keylen) == 0) {
          allow_url = ucl_object_toboolean(param);
        }
        else if (strncmp(param->key, "prefix", param->keylen) == 0) {
          params.use_prefix = ucl_object_toboolean(param);
        }
      }
      else if (param->type == UCL_STRING) {
        if (strncmp(param->key, "key", param->keylen) == 0) {
          params.prefix = ucl_object_tostring(param);
        }
        else if (strncmp(param->key, "target", param->keylen) == 0) {
          params.target = ucl_object_tostring(param);
        }
        else if (strncmp(param->key, "duplicate", param->keylen) == 0) {
          duplicate = ucl_object_tostring(param);

          if (strcmp(duplicate, "append") == 0) {
            params.strat = UCL_DUPLICATE_APPEND;
          }
          else if (strcmp(duplicate, "merge") == 0) {
            params.strat = UCL_DUPLICATE_MERGE;
          }
          else if (strcmp(duplicate, "rewrite") == 0) {
            params.strat = UCL_DUPLICATE_REWRITE;
          }
          else if (strcmp(duplicate, "error") == 0) {
            params.strat = UCL_DUPLICATE_ERROR;
          }
        }
      }
      else if (param->type == UCL_ARRAY) {
        if (strncmp(param->key, "path", param->keylen) == 0) {
          ucl_set_include_path(parser, __DECONST(ucl_object_t *, param));
        }
      }
      else if (param->type == UCL_INT) {
        if (strncmp(param->key, "priority", param->keylen) == 0) {
          params.priority = ucl_object_toint(param);
        }
      }
    }
  }

  if (parser->includepaths == NULL) {
    if (allow_url && ucl_strnstr(data, "://", len) != NULL) {
      /* Globbing is not used for URL's */
      return ucl_include_url(data, len, parser, &params);
    }
    else if (data != NULL) {
      /* Try to load a file */
      return ucl_include_file(data, len, parser, &params, args);
    }
  }
  else {
    if (allow_url && ucl_strnstr(data, "://", len) != NULL) {
      /* Globbing is not used for URL's */
      return ucl_include_url(data, len, parser, &params);
    }

    ip = ucl_object_iterate_new(parser->includepaths);
    while ((param = ucl_object_iterate_safe(ip, true)) != NULL) {
      if (ucl_object_type(param) == UCL_STRING) {
        snprintf(ipath, sizeof(ipath), "%s/%.*s", ucl_object_tostring(param),
             (int) len, data);
        if ((search = ucl_include_file(ipath, strlen(ipath),
                         parser, &params, args))) {
          if (!params.allow_glob) {
            break;
          }
        }
      }
    }
    ucl_object_iterate_free(ip);
    if (search == true) {
      return true;
    }
    else {
      ucl_create_err(&parser->err,
               "cannot find file: %.*s in search path",
               (int) len, data);
      return false;
    }
  }

  return false;
}

/**
 * Handle include macro
 * @param data include data
 * @param len length of data
 * @param args UCL object representing arguments to the macro
 * @param ud user data
 * @return
 */
bool ucl_include_handler(const unsigned char *data, size_t len,
             const ucl_object_t *args, void *ud)
{
  struct ucl_parser *parser = ud;

  return ucl_include_common(data, len, args, parser, false, false);
}

/**
 * Handle includes macro
 * @param data include data
 * @param len length of data
 * @param args UCL object representing arguments to the macro
 * @param ud user data
 * @return
 */
bool ucl_includes_handler(const unsigned char *data, size_t len,
              const ucl_object_t *args, void *ud)
{
  struct ucl_parser *parser = ud;

  return ucl_include_common(data, len, args, parser, false, true);
}

/**
 * Handle tryinclude macro
 * @param data include data
 * @param len length of data
 * @param args UCL object representing arguments to the macro
 * @param ud user data
 * @return
 */
bool ucl_try_include_handler(const unsigned char *data, size_t len,
               const ucl_object_t *args, void *ud)
{
  struct ucl_parser *parser = ud;

  return ucl_include_common(data, len, args, parser, true, false);
}

/**
 * Handle priority macro
 * @param data include data
 * @param len length of data
 * @param args UCL object representing arguments to the macro
 * @param ud user data
 * @return
 */
bool ucl_priority_handler(const unsigned char *data, size_t len,
              const ucl_object_t *args, void *ud)
{
  struct ucl_parser *parser = ud;
  unsigned priority = 255;
  const ucl_object_t *param;
  bool found = false;
  char *value = NULL, *leftover = NULL;
  ucl_object_iter_t it = NULL;

  if (parser == NULL) {
    return false;
  }

  /* Process arguments */
  if (args != NULL && args->type == UCL_OBJECT) {
    while ((param = ucl_object_iterate(args, &it, true)) != NULL) {
      if (param->type == UCL_INT) {
        if (strncmp(param->key, "priority", param->keylen) == 0) {
          priority = ucl_object_toint(param);
          found = true;
        }
      }
    }
  }

  if (len > 0) {
    value = malloc(len + 1);
    ucl_strlcpy(value, (const char *) data, len + 1);
    priority = strtol(value, &leftover, 10);
    if (*leftover != '\0') {
      ucl_create_err(&parser->err, "Invalid priority value in macro: %s",
               value);
      free(value);
      return false;
    }
    free(value);
    found = true;
  }

  if (found == true) {
    parser->chunks->priority = priority;
    return true;
  }

  ucl_create_err(&parser->err, "Unable to parse priority macro");
  return false;
}

/**
 * Handle load macro
 * @param data include data
 * @param len length of data
 * @param args UCL object representing arguments to the macro
 * @param ud user data
 * @return
 */
bool ucl_load_handler(const unsigned char *data, size_t len,
            const ucl_object_t *args, void *ud)
{
  struct ucl_parser *parser = ud;
  const ucl_object_t *param;
  ucl_object_t *obj, *old_obj;
  ucl_object_iter_t it = NULL;
  bool try_load, multiline, test;
  const char *target, *prefix;
  char *load_file, *tmp;
  unsigned char *buf;
  size_t buflen;
  unsigned priority;
  int64_t iv;
  ucl_object_t *container = NULL;
  enum ucl_string_flags flags;

  /* Default values */
  try_load = false;
  multiline = false;
  test = false;
  target = "string";
  prefix = NULL;
  load_file = NULL;
  buf = NULL;
  buflen = 0;
  priority = 0;
  obj = NULL;
  old_obj = NULL;
  flags = 0;

  if (parser == NULL) {
    return false;
  }

  /* Process arguments */
  if (args != NULL && args->type == UCL_OBJECT) {
    while ((param = ucl_object_iterate(args, &it, true)) != NULL) {
      if (param->type == UCL_BOOLEAN) {
        if (strncmp(param->key, "try", param->keylen) == 0) {
          try_load = ucl_object_toboolean(param);
        }
        else if (strncmp(param->key, "multiline", param->keylen) == 0) {
          multiline = ucl_object_toboolean(param);
        }
        else if (strncmp(param->key, "escape", param->keylen) == 0) {
          test = ucl_object_toboolean(param);
          if (test) {
            flags |= UCL_STRING_ESCAPE;
          }
        }
        else if (strncmp(param->key, "trim", param->keylen) == 0) {
          test = ucl_object_toboolean(param);
          if (test) {
            flags |= UCL_STRING_TRIM;
          }
        }
      }
      else if (param->type == UCL_STRING) {
        if (strncmp(param->key, "key", param->keylen) == 0) {
          prefix = ucl_object_tostring(param);
        }
        else if (strncmp(param->key, "target", param->keylen) == 0) {
          target = ucl_object_tostring(param);
        }
      }
      else if (param->type == UCL_INT) {
        if (strncmp(param->key, "priority", param->keylen) == 0) {
          priority = ucl_object_toint(param);
        }
      }
    }
  }

  if (prefix == NULL || strlen(prefix) == 0) {
    ucl_create_err(&parser->err, "No Key specified in load macro");
    return false;
  }

  if (len > 0) {
    load_file = malloc(len + 1);
    if (!load_file) {
      ucl_create_err(&parser->err, "cannot allocate memory for suffix");

      return false;
    }

    snprintf(load_file, len + 1, "%.*s", (int) len, data);

    if (!ucl_fetch_file(load_file, &buf, &buflen, &parser->err,
              !try_load)) {
      free(load_file);

      if (try_load) {
        ucl_parser_clear_error(parser);
      }

      return (try_load || false);
    }

    free(load_file);
    container = parser->stack->obj;
    old_obj = __DECONST(ucl_object_t *, ucl_object_lookup(container,
                                prefix));

    if (old_obj != NULL) {
      ucl_create_err(&parser->err, "Key %s already exists", prefix);
      if (buf) {
        ucl_munmap(buf, buflen);
      }

      return false;
    }

    if (strcasecmp(target, "string") == 0) {
      obj = ucl_object_fromstring_common(buf, buflen, flags);
      ucl_copy_value_trash(obj);
      if (multiline) {
        obj->flags |= UCL_OBJECT_MULTILINE;
      }
    }
    else if (strcasecmp(target, "int") == 0) {
      tmp = malloc(buflen + 1);

      if (tmp == NULL) {
        ucl_create_err(&parser->err, "Memory allocation failed");
        if (buf) {
          ucl_munmap(buf, buflen);
        }

        return false;
      }

      snprintf(tmp, buflen + 1, "%.*s", (int) buflen, buf);
      iv = strtoll(tmp, NULL, 10);
      obj = ucl_object_fromint(iv);
      free(tmp);
    }

    if (buf) {
      ucl_munmap(buf, buflen);
    }

    if (obj != NULL) {
      obj->key = prefix;
      obj->keylen = strlen(prefix);
      ucl_copy_key_trash(obj);
      obj->prev = obj;
      obj->next = NULL;
      ucl_object_set_priority(obj, priority);
      ucl_object_insert_key(container, obj, obj->key, obj->keylen, false);
    }

    return true;
  }

  ucl_create_err(&parser->err, "Unable to parse load macro");
  return false;
}

bool ucl_inherit_handler(const unsigned char *data, size_t len,
             const ucl_object_t *args, const ucl_object_t *ctx, void *ud)
{
  const ucl_object_t *parent, *cur;
  ucl_object_t *target, *copy;
  ucl_object_iter_t it = NULL;
  bool replace = false;
  struct ucl_parser *parser = ud;

  parent = ucl_object_lookup_len(ctx, data, len);

  /* Some sanity checks */
  if (parent == NULL || ucl_object_type(parent) != UCL_OBJECT) {
    ucl_create_err(&parser->err, "Unable to find inherited object %.*s",
             (int) len, data);
    return false;
  }

  if (parser->stack == NULL || parser->stack->obj == NULL ||
    ucl_object_type(parser->stack->obj) != UCL_OBJECT) {
    ucl_create_err(&parser->err, "Invalid inherit context");
    return false;
  }

  target = parser->stack->obj;

  if (args && (cur = ucl_object_lookup(args, "replace")) != NULL) {
    replace = ucl_object_toboolean(cur);
  }

  while ((cur = ucl_object_iterate(parent, &it, true))) {
    /* We do not replace existing keys */
    if (!replace && ucl_object_lookup_len(target, cur->key, cur->keylen)) {
      continue;
    }

    copy = ucl_object_copy(cur);

    if (!replace) {
      copy->flags |= UCL_OBJECT_INHERITED;
    }

    ucl_object_insert_key(target, copy, copy->key,
                copy->keylen, false);
  }

  return true;
}

bool ucl_parser_set_filevars(struct ucl_parser *parser, const char *filename, bool need_expand)
{
  char realbuf[PATH_MAX], *curdir;

  if (filename != NULL) {
    if (need_expand) {
      if (ucl_realpath(filename, realbuf) == NULL) {
        return false;
      }
    }
    else {
      ucl_strlcpy(realbuf, filename, sizeof(realbuf));
    }

    if (parser->cur_file) {
      UCL_FREE(strlen(parser->cur_file) + 1, parser->cur_file);
    }

    parser->cur_file = UCL_STRDUP(realbuf);

    /* Define variables */
    ucl_parser_register_variable(parser, "FILENAME", realbuf);
    curdir = dirname(realbuf);
    ucl_parser_register_variable(parser, "CURDIR", curdir);
  }
  else {
    /* Set everything from the current dir */
    curdir = getcwd(realbuf, sizeof(realbuf));
    ucl_parser_register_variable(parser, "FILENAME", "undef");
    ucl_parser_register_variable(parser, "CURDIR", curdir);
  }

  return true;
}

bool ucl_parser_add_file_full(struct ucl_parser *parser, const char *filename,
                unsigned priority, enum ucl_duplicate_strategy strat,
                enum ucl_parse_type parse_type)
{
  unsigned char *buf;
  size_t len;
  bool ret;
  char realbuf[PATH_MAX];

  if (ucl_realpath(filename, realbuf) == NULL) {
    ucl_create_err(&parser->err, "cannot open file %s: %s",
             filename,
             strerror(errno));
    return false;
  }

  if (!ucl_fetch_file(realbuf, &buf, &len, &parser->err, true)) {
    return false;
  }

  ucl_parser_set_filevars(parser, realbuf, false);
  ret = ucl_parser_add_chunk_full(parser, buf, len, priority, strat,
                  parse_type);

  if (len > 0) {
    ucl_munmap(buf, len);
  }

  return ret;
}

bool ucl_parser_add_file_priority(struct ucl_parser *parser, const char *filename,
                  unsigned priority)
{
  if (parser == NULL) {
    return false;
  }

  return ucl_parser_add_file_full(parser, filename, priority,
                  UCL_DUPLICATE_APPEND, UCL_PARSE_UCL);
}

bool ucl_parser_add_file(struct ucl_parser *parser, const char *filename)
{
  if (parser == NULL) {
    return false;
  }

  return ucl_parser_add_file_full(parser, filename,
                  parser->default_priority, UCL_DUPLICATE_APPEND,
                  UCL_PARSE_UCL);
}


bool ucl_parser_add_fd_full(struct ucl_parser *parser, int fd,
              unsigned priority, enum ucl_duplicate_strategy strat,
              enum ucl_parse_type parse_type)
{
  unsigned char *buf;
  size_t len;
  bool ret;
  struct stat st;

  if (fstat(fd, &st) == -1) {
    ucl_create_err(&parser->err, "cannot stat fd %d: %s",
             fd, strerror(errno));
    return false;
  }
  if (st.st_size == 0) {
    return true;
  }
  if ((buf = ucl_mmap(NULL, st.st_size, PROT_READ, MAP_SHARED, fd, 0)) == MAP_FAILED) {
    ucl_create_err(&parser->err, "cannot mmap fd %d: %s",
             fd, strerror(errno));
    return false;
  }

  if (parser->cur_file) {
    UCL_FREE(strlen(parser->cur_file) + 1, parser->cur_file);
  }
  parser->cur_file = NULL;
  len = st.st_size;
  ret = ucl_parser_add_chunk_full(parser, buf, len, priority, strat,
                  parse_type);

  if (len > 0) {
    ucl_munmap(buf, len);
  }

  return ret;
}

bool ucl_parser_add_fd_priority(struct ucl_parser *parser, int fd,
                unsigned priority)
{
  if (parser == NULL) {
    return false;
  }

  return ucl_parser_add_fd_full(parser, fd, parser->default_priority,
                  UCL_DUPLICATE_APPEND, UCL_PARSE_UCL);
}

bool ucl_parser_add_fd(struct ucl_parser *parser, int fd)
{
  if (parser == NULL) {
    return false;
  }

  return ucl_parser_add_fd_priority(parser, fd, parser->default_priority);
}

size_t
ucl_strlcpy(char *dst, const char *src, size_t siz)
{
  char *d = dst;
  const char *s = src;
  size_t n = siz;

  /* Copy as many bytes as will fit */
  if (n != 0) {
    while (--n != 0) {
      if ((*d++ = *s++) == '\0') {
        break;
      }
    }
  }

  if (n == 0 && siz != 0) {
    *d = '\0';
  }

  return (s - src - 1); /* count does not include NUL */
}

size_t
ucl_strlcpy_unsafe(char *dst, const char *src, size_t siz)
{
  memcpy(dst, src, siz - 1);
  dst[siz - 1] = '\0';

  return siz - 1;
}

size_t
ucl_strlcpy_tolower(char *dst, const char *src, size_t siz)
{
  char *d = dst;
  const char *s = src;
  size_t n = siz;

  /* Copy as many bytes as will fit */
  if (n != 0) {
    while (--n != 0) {
      if ((*d++ = tolower(*s++)) == '\0') {
        break;
      }
    }
  }

  if (n == 0 && siz != 0) {
    *d = '\0';
  }

  return (s - src); /* count does not include NUL */
}

/*
 * Find the first occurrence of find in s
 */
char *
ucl_strnstr(const char *s, const char *find, int len)
{
  char c, sc;
  int mlen;

  if ((c = *find++) != 0) {
    mlen = strlen(find);
    do {
      do {
        if ((sc = *s++) == 0 || len-- < mlen)
          return (NULL);
      } while (sc != c);
    } while (strncmp(s, find, mlen) != 0);
    s--;
  }
  return ((char *) s);
}

/*
 * Find the first occurrence of find in s, ignore case.
 */
char *
ucl_strncasestr(const char *s, const char *find, int len)
{
  char c, sc;
  int mlen;

  if ((c = *find++) != 0) {
    c = tolower(c);
    mlen = strlen(find);
    do {
      do {
        if ((sc = *s++) == 0 || len-- == 0)
          return (NULL);
      } while (tolower(sc) != c);
    } while (strncasecmp(s, find, mlen) != 0);
    s--;
  }
  return ((char *) s);
}

ucl_object_t *
ucl_object_fromstring_common(const char *str, size_t len, enum ucl_string_flags flags)
{
  ucl_object_t *obj;
  const char *start, *end, *p, *pos;
  char *dst, *d;
  size_t escaped_len;

  if (str == NULL) {
    return NULL;
  }

  obj = ucl_object_new();
  if (obj) {
    if (len == 0) {
      len = strlen(str);
    }
    if (flags & UCL_STRING_TRIM) {
      /* Skip leading spaces */
      for (start = str; (size_t) (start - str) < len; start++) {
        if (!ucl_test_character(*start, UCL_CHARACTER_WHITESPACE_UNSAFE)) {
          break;
        }
      }
      /* Skip trailing spaces */
      for (end = str + len - 1; end > start; end--) {
        if (!ucl_test_character(*end, UCL_CHARACTER_WHITESPACE_UNSAFE)) {
          break;
        }
      }
      end++;
    }
    else {
      start = str;
      end = str + len;
    }

    obj->type = UCL_STRING;
    if (flags & UCL_STRING_ESCAPE) {
      for (p = start, escaped_len = 0; p < end; p++, escaped_len++) {
        if (ucl_test_character(*p, UCL_CHARACTER_JSON_UNSAFE | UCL_CHARACTER_WHITESPACE_UNSAFE)) {
          switch (*p) {
          case '\v':
          case '\0':
            escaped_len += 5;
            break;
          case ' ':
            break;
          default:
            escaped_len++;
            break;
          }
        }
      }
      dst = malloc(escaped_len + 1);
      if (dst != NULL) {
        for (p = start, d = dst; p < end; p++, d++) {
          if (ucl_test_character(*p, UCL_CHARACTER_JSON_UNSAFE | UCL_CHARACTER_WHITESPACE_UNSAFE)) {
            switch (*p) {
            case '\n':
              *d++ = '\\';
              *d = 'n';
              break;
            case '\r':
              *d++ = '\\';
              *d = 'r';
              break;
            case '\b':
              *d++ = '\\';
              *d = 'b';
              break;
            case '\t':
              *d++ = '\\';
              *d = 't';
              break;
            case '\f':
              *d++ = '\\';
              *d = 'f';
              break;
            case '\0':
              *d++ = '\\';
              *d++ = 'u';
              *d++ = '0';
              *d++ = '0';
              *d++ = '0';
              *d = '0';
              break;
            case '\v':
              *d++ = '\\';
              *d++ = 'u';
              *d++ = '0';
              *d++ = '0';
              *d++ = '0';
              *d = 'B';
              break;
            case '\\':
              *d++ = '\\';
              *d = '\\';
              break;
            case ' ':
              *d = ' ';
              break;
            case '"':
              *d++ = '\\';
              *d = '"';
              break;
            }
          }
          else {
            *d = *p;
          }
        }
        *d = '\0';
        obj->value.sv = dst;
        obj->trash_stack[UCL_TRASH_VALUE] = dst;
        obj->len = escaped_len;
      }
    }
    else {
      dst = malloc(end - start + 1);
      if (dst != NULL) {
        ucl_strlcpy_unsafe(dst, start, end - start + 1);
        obj->value.sv = dst;
        obj->trash_stack[UCL_TRASH_VALUE] = dst;
        obj->len = end - start;
      }
    }
    if ((flags & UCL_STRING_PARSE) && dst != NULL) {
      /* Parse what we have */
      if (flags & UCL_STRING_PARSE_BOOLEAN) {
        if (!ucl_maybe_parse_boolean(obj, dst, obj->len) && (flags & UCL_STRING_PARSE_NUMBER)) {
          ucl_maybe_parse_number(obj, dst, dst + obj->len, &pos,
                       flags & UCL_STRING_PARSE_DOUBLE,
                       flags & UCL_STRING_PARSE_BYTES,
                       flags & UCL_STRING_PARSE_TIME);
        }
      }
      else {
        ucl_maybe_parse_number(obj, dst, dst + obj->len, &pos,
                     flags & UCL_STRING_PARSE_DOUBLE,
                     flags & UCL_STRING_PARSE_BYTES,
                     flags & UCL_STRING_PARSE_TIME);
      }
    }
  }

  return obj;
}

static bool
ucl_object_insert_key_common(ucl_object_t *top, ucl_object_t *elt,
               const char *key, size_t keylen, bool copy_key, bool merge, bool replace)
{
  ucl_object_t *found, *tmp;
  const ucl_object_t *cur;
  ucl_object_iter_t it = NULL;
  const char *p;
  int ret = true;

  if (elt == NULL || key == NULL) {
    return false;
  }

  if (top == NULL) {
    return false;
  }

  if (top->type != UCL_OBJECT) {
    /* It is possible to convert NULL type to an object */
    if (top->type == UCL_NULL) {
      top->type = UCL_OBJECT;
    }
    else {
      /* Refuse converting of other object types */
      return false;
    }
  }

  if (top->value.ov == NULL) {
    top->value.ov = ucl_hash_create(false);
  }

  if (keylen == 0) {
    keylen = strlen(key);
  }

  for (p = key; p < key + keylen; p++) {
    if (ucl_test_character(*p, UCL_CHARACTER_UCL_UNSAFE)) {
      elt->flags |= UCL_OBJECT_NEED_KEY_ESCAPE;
      break;
    }
  }

  /* workaround for some use cases */
  if (elt->trash_stack[UCL_TRASH_KEY] != NULL &&
    key != (const char *) elt->trash_stack[UCL_TRASH_KEY]) {
    /* Remove copied key */
    free(elt->trash_stack[UCL_TRASH_KEY]);
    elt->trash_stack[UCL_TRASH_KEY] = NULL;
    elt->flags &= ~UCL_OBJECT_ALLOCATED_KEY;
  }

  elt->key = key;
  elt->keylen = keylen;

  if (copy_key) {
    ucl_copy_key_trash(elt);
  }

  found = __DECONST(ucl_object_t *, ucl_hash_search_obj(top->value.ov, elt));

  if (found == NULL) {
    top->value.ov = ucl_hash_insert_object(top->value.ov, elt, false);
    top->len++;
    /* Key was inserted - return true regardless of replace flag */
  }
  else {
    if (replace) {
      ucl_hash_replace(top->value.ov, found, elt);
      ucl_object_unref(found);
    }
    else if (merge) {
      if (found->type != UCL_OBJECT && elt->type == UCL_OBJECT) {
        /* Insert old elt to new one */
        ucl_object_insert_key_common(elt, found, found->key,
                       found->keylen, copy_key, false, false);
        ucl_hash_delete(top->value.ov, found);
        top->value.ov = ucl_hash_insert_object(top->value.ov, elt, false);
      }
      else if (found->type == UCL_OBJECT && elt->type != UCL_OBJECT) {
        /* Insert new to old */
        ucl_object_insert_key_common(found, elt, elt->key,
                       elt->keylen, copy_key, false, false);
      }
      else if (found->type == UCL_OBJECT && elt->type == UCL_OBJECT) {
        /* Mix two hashes */
        while ((cur = ucl_object_iterate(elt, &it, true)) != NULL) {
          tmp = ucl_object_ref(cur);
          ucl_object_insert_key_common(found, tmp, cur->key,
                         cur->keylen, copy_key, true, false);
        }
        ucl_object_unref(elt);
      }
      else {
        /* Just make a list of scalars */
        DL_CONCAT(found, elt);
      }
    }
    else {
      DL_CONCAT(found, elt);
    }
  }

  return ret;
}

bool ucl_object_delete_keyl(ucl_object_t *top, const char *key, size_t keylen)
{
  ucl_object_t *found;

  if (top == NULL || key == NULL) {
    return false;
  }

  found = __DECONST(ucl_object_t *, ucl_object_lookup_len(top, key, keylen));

  if (found == NULL) {
    return false;
  }

  ucl_hash_delete(top->value.ov, found);
  ucl_object_unref(found);
  top->len--;

  return true;
}

bool ucl_object_delete_key(ucl_object_t *top, const char *key)
{
  return ucl_object_delete_keyl(top, key, strlen(key));
}

ucl_object_t *
ucl_object_pop_keyl(ucl_object_t *top, const char *key, size_t keylen)
{
  const ucl_object_t *found;

  if (top == NULL || key == NULL) {
    return false;
  }
  found = ucl_object_lookup_len(top, key, keylen);

  if (found == NULL) {
    return NULL;
  }
  ucl_hash_delete(top->value.ov, found);
  top->len--;

  return __DECONST(ucl_object_t *, found);
}

ucl_object_t *
ucl_object_pop_key(ucl_object_t *top, const char *key)
{
  return ucl_object_pop_keyl(top, key, strlen(key));
}

bool ucl_object_insert_key(ucl_object_t *top, ucl_object_t *elt,
               const char *key, size_t keylen, bool copy_key)
{
  return ucl_object_insert_key_common(top, elt, key, keylen, copy_key, false, false);
}

bool ucl_object_insert_key_merged(ucl_object_t *top, ucl_object_t *elt,
                  const char *key, size_t keylen, bool copy_key)
{
  return ucl_object_insert_key_common(top, elt, key, keylen, copy_key, true, false);
}

bool ucl_object_replace_key(ucl_object_t *top, ucl_object_t *elt,
              const char *key, size_t keylen, bool copy_key)
{
  return ucl_object_insert_key_common(top, elt, key, keylen, copy_key, false, true);
}

bool ucl_object_merge(ucl_object_t *top, ucl_object_t *elt, bool copy)
{
  ucl_object_t *cur = NULL, *cp = NULL, *found = NULL;
  ucl_object_iter_t iter = NULL;

  if (top == NULL || elt == NULL) {
    return false;
  }

  if (top->type == UCL_ARRAY) {
    if (elt->type == UCL_ARRAY) {
      /* Merge two arrays */
      return ucl_array_merge(top, elt, copy);
    }
    else {
      if (copy) {
        ucl_array_append(top, ucl_object_copy(elt));

        return true;
      }
      else {
        ucl_array_append(top, ucl_object_ref(elt));

        return true;
      }
    }
  }
  else if (top->type == UCL_OBJECT) {
    if (elt->type == UCL_OBJECT) {
      /* Mix two hashes */
      while ((cur = (ucl_object_t *) ucl_hash_iterate(elt->value.ov,
                              &iter))) {

        if (copy) {
          cp = ucl_object_copy(cur);
        }
        else {
          cp = ucl_object_ref(cur);
        }

        found = __DECONST(ucl_object_t *,
                  ucl_hash_search(top->value.ov, cp->key, cp->keylen));

        if (found == NULL) {
          /* The key does not exist */
          top->value.ov = ucl_hash_insert_object(top->value.ov, cp,
                               false);
          top->len++;
        }
        else {
          /* The key already exists, merge it recursively */
          if (found->type == UCL_OBJECT || found->type == UCL_ARRAY) {
            if (!ucl_object_merge(found, cp, copy)) {
              return false;
            }
            ucl_object_unref(cp);
          }
          else {
            ucl_hash_replace(top->value.ov, found, cp);
            ucl_object_unref(found);
          }
        }
      }
    }
    else {
      if (copy) {
        cp = ucl_object_copy(elt);
      }
      else {
        cp = ucl_object_ref(elt);
      }

      found = __DECONST(ucl_object_t *,
                ucl_hash_search(top->value.ov, cp->key, cp->keylen));

      if (found == NULL) {
        /* The key does not exist */
        top->value.ov = ucl_hash_insert_object(top->value.ov, cp,
                             false);
        top->len++;
      }
      else {
        /* The key already exists, merge it recursively */
        if (found->type == UCL_OBJECT || found->type == UCL_ARRAY) {
          if (!ucl_object_merge(found, cp, copy)) {
            return false;
          }
          ucl_object_unref(cp);
        }
        else {
          ucl_hash_replace(top->value.ov, found, cp);
          ucl_object_unref(found);
        }
      }
    }
  }
  else {
    /* Cannot merge trivial objects */
    return false;
  }

  return true;
}

const ucl_object_t *
ucl_object_lookup_len(const ucl_object_t *obj, const char *key, size_t klen)
{
  const ucl_object_t *ret;
  ucl_object_t srch;

  if (obj == NULL || obj->type != UCL_OBJECT || key == NULL) {
    return NULL;
  }

  srch.key = key;
  srch.keylen = klen;
  ret = ucl_hash_search_obj(obj->value.ov, &srch);

  return ret;
}

const ucl_object_t *
ucl_object_lookup(const ucl_object_t *obj, const char *key)
{
  if (key == NULL) {
    return NULL;
  }

  return ucl_object_lookup_len(obj, key, strlen(key));
}

const ucl_object_t *
ucl_object_lookup_any(const ucl_object_t *obj,
            const char *key, ...)
{
  va_list ap;
  const ucl_object_t *ret = NULL;
  const char *nk = NULL;

  if (obj == NULL || key == NULL) {
    return NULL;
  }

  ret = ucl_object_lookup_len(obj, key, strlen(key));

  if (ret == NULL) {
    va_start(ap, key);

    while (ret == NULL) {
      nk = va_arg(ap, const char *);

      if (nk == NULL) {
        break;
      }
      else {
        ret = ucl_object_lookup_len(obj, nk, strlen(nk));
      }
    }

    va_end(ap);
  }

  return ret;
}

const ucl_object_t *
ucl_object_iterate_with_error(const ucl_object_t *obj, ucl_object_iter_t *iter, bool expand_values,
                int *ep)
{
  const ucl_object_t *elt = NULL;

  if (obj == NULL || iter == NULL) {
    return NULL;
  }

  if (expand_values) {
    switch (obj->type) {
    case UCL_OBJECT:
      return (const ucl_object_t *) ucl_hash_iterate2(obj->value.ov, iter, ep);
      break;
    case UCL_ARRAY: {
      unsigned int idx;
      UCL_ARRAY_GET(vec, obj);
      idx = (unsigned int) (uintptr_t) (*iter);

      if (vec != NULL) {
        while (idx < kv_size(*vec)) {
          if ((elt = kv_A(*vec, idx)) != NULL) {
            idx++;
            break;
          }
          idx++;
        }
        *iter = (void *) (uintptr_t) idx;
      }

      return elt;
      break;
    }
    default:
      /* Go to linear iteration */
      break;
    }
  }
  /* Treat everything as a linear list */
  elt = *iter;
  if (elt == NULL) {
    elt = obj;
  }
  else if (elt == obj) {
    return NULL;
  }
  *iter = __DECONST(void *, elt->next ? elt->next : obj);
  return elt;

  /* Not reached */
  return NULL;
}

void
ucl_object_iterate_end(const ucl_object_t *obj, ucl_object_iter_t *iter)
{
  if (iter == NULL || *iter == NULL) {
    return;
  }

  if (obj != NULL && obj->type == UCL_OBJECT) {
    ucl_hash_iterate_free(*iter);
  }

  *iter = NULL;
}

enum ucl_safe_iter_flags {
  UCL_ITERATE_FLAG_UNDEFINED = 0,
  UCL_ITERATE_FLAG_INSIDE_ARRAY,
  UCL_ITERATE_FLAG_INSIDE_OBJECT,
  UCL_ITERATE_FLAG_IMPLICIT,
  UCL_ITERATE_FLAG_EXCEPTION
};

static const char safe_iter_magic[4] = {'u', 'i', 't', 'e'};
struct ucl_object_safe_iter {
  char magic[4]; /* safety check */
  uint32_t flags;
  const ucl_object_t *impl_it; /* implicit object iteration */
  ucl_object_iter_t expl_it;   /* explicit iteration */
};

#define UCL_SAFE_ITER(ptr) (struct ucl_object_safe_iter *) (ptr)
#define UCL_SAFE_ITER_CHECK(it)                                             \
  do {                                                                    \
    assert(it != NULL);                                                 \
    assert(memcmp(it->magic, safe_iter_magic, sizeof(it->magic)) == 0); \
  } while (0)

ucl_object_iter_t
ucl_object_iterate_new(const ucl_object_t *obj)
{
  struct ucl_object_safe_iter *it;

  it = UCL_ALLOC(sizeof(*it));
  if (it != NULL) {
    memcpy(it->magic, safe_iter_magic, sizeof(it->magic));
    it->flags = UCL_ITERATE_FLAG_UNDEFINED;
    it->expl_it = NULL;
    it->impl_it = obj;
  }

  return (ucl_object_iter_t) it;
}

bool ucl_object_iter_chk_excpn(ucl_object_iter_t *it)
{
  struct ucl_object_safe_iter *rit = UCL_SAFE_ITER(it);

  UCL_SAFE_ITER_CHECK(rit);

  return (rit->flags == UCL_ITERATE_FLAG_EXCEPTION);
}

ucl_object_iter_t
ucl_object_iterate_reset(ucl_object_iter_t it, const ucl_object_t *obj)
{
  struct ucl_object_safe_iter *rit = UCL_SAFE_ITER(it);

  UCL_SAFE_ITER_CHECK(rit);

  if (rit->expl_it != NULL) {
    if (rit->flags == UCL_ITERATE_FLAG_INSIDE_OBJECT) {
      UCL_FREE(sizeof(*rit->expl_it), rit->expl_it);
    }
  }

  rit->impl_it = obj;
  rit->expl_it = NULL;
  rit->flags = UCL_ITERATE_FLAG_UNDEFINED;

  return it;
}

const ucl_object_t *
ucl_object_iterate_safe(ucl_object_iter_t it, bool expand_values)
{
  return ucl_object_iterate_full(it, expand_values ? UCL_ITERATE_BOTH : UCL_ITERATE_IMPLICIT);
}

const ucl_object_t *
ucl_object_iterate_full(ucl_object_iter_t it, enum ucl_iterate_type type)
{
  struct ucl_object_safe_iter *rit = UCL_SAFE_ITER(it);
  const ucl_object_t *ret = NULL;
  int ern;

  UCL_SAFE_ITER_CHECK(rit);

  if (rit->impl_it == NULL) {
    return NULL;
  }

  if (rit->impl_it->type == UCL_OBJECT) {
    rit->flags = UCL_ITERATE_FLAG_INSIDE_OBJECT;
    ret = ucl_object_iterate_with_error(rit->impl_it, &rit->expl_it, true, &ern);

    if (ret == NULL && ern != 0) {
      rit->flags = UCL_ITERATE_FLAG_EXCEPTION;
      return NULL;
    }

    if (ret == NULL && (type & UCL_ITERATE_IMPLICIT)) {
      /* Need to switch to another implicit object in chain */
      rit->impl_it = rit->impl_it->next;
      rit->expl_it = NULL;

      return ucl_object_iterate_safe(it, type);
    }
  }
  else if (rit->impl_it->type == UCL_ARRAY) {
    rit->flags = UCL_ITERATE_FLAG_INSIDE_ARRAY;
    ret = ucl_object_iterate(rit->impl_it, &rit->expl_it, true);

    if (ret == NULL && (type & UCL_ITERATE_IMPLICIT)) {
      /* Need to switch to another implicit object in chain */
      rit->impl_it = rit->impl_it->next;
      rit->expl_it = NULL;

      return ucl_object_iterate_safe(it, type);
    }
  }
  else {
    /* Just iterate over the implicit array */
    rit->flags = UCL_ITERATE_FLAG_IMPLICIT;
    ret = rit->impl_it;
    rit->impl_it = rit->impl_it->next;

    if (type & UCL_ITERATE_EXPLICIT) {
      /* We flatten objects if need to expand values */
      if (ret->type == UCL_OBJECT || ret->type == UCL_ARRAY) {
        return ucl_object_iterate_safe(it, type);
      }
    }
  }

  return ret;
}

void ucl_object_iterate_free(ucl_object_iter_t it)
{
  struct ucl_object_safe_iter *rit = UCL_SAFE_ITER(it);

  UCL_SAFE_ITER_CHECK(rit);

  if (rit->expl_it != NULL) {
    if (rit->flags == UCL_ITERATE_FLAG_INSIDE_OBJECT) {
      UCL_FREE(sizeof(*rit->expl_it), rit->expl_it);
    }
  }

  UCL_FREE(sizeof(*rit), it);
}

const ucl_object_t *
ucl_object_lookup_path(const ucl_object_t *top, const char *path_in)
{
  return ucl_object_lookup_path_char(top, path_in, '.');
}


const ucl_object_t *
ucl_object_lookup_path_char(const ucl_object_t *top, const char *path_in, const char sep)
{
  const ucl_object_t *o = NULL, *found;
  const char *p, *c;
  char *err_str;
  unsigned index;

  if (path_in == NULL || top == NULL) {
    return NULL;
  }

  found = NULL;
  p = path_in;

  /* Skip leading dots */
  while (*p == sep) {
    p++;
  }

  c = p;
  while (*p != '\0') {
    p++;
    if (*p == sep || *p == '\0') {
      if (p > c) {
        switch (top->type) {
        case UCL_ARRAY:
          /* Key should be an int */
          index = strtoul(c, &err_str, 10);
          if (err_str != NULL && (*err_str != sep && *err_str != '\0')) {
            return NULL;
          }
          o = ucl_array_find_index(top, index);
          break;
        default:
          o = ucl_object_lookup_len(top, c, p - c);
          break;
        }
        if (o == NULL) {
          return NULL;
        }
        top = o;
      }
      if (*p != '\0') {
        c = p + 1;
      }
    }
  }
  found = o;

  return found;
}


ucl_object_t *
ucl_object_new(void)
{
  return ucl_object_typed_new(UCL_NULL);
}

ucl_object_t *
ucl_object_typed_new(ucl_type_t type)
{
  return ucl_object_new_full(type, 0);
}

ucl_object_t *
ucl_object_new_full(ucl_type_t type, unsigned priority)
{
  ucl_object_t *new;

  if (type != UCL_USERDATA) {
    new = UCL_ALLOC(sizeof(ucl_object_t));
    if (new != NULL) {
      memset(new, 0, sizeof(ucl_object_t));
      new->ref = 1;
      new->type = (type <= UCL_NULL ? type : UCL_NULL);
      new->next = NULL;
      new->prev = new;
      ucl_object_set_priority(new, priority);

      if (type == UCL_ARRAY) {
        new->value.av = UCL_ALLOC(sizeof(ucl_array_t));
        if (new->value.av) {
          memset(new->value.av, 0, sizeof(ucl_array_t));
          UCL_ARRAY_GET(vec, new);

          /* Preallocate some space for arrays */
          kv_resize_safe(ucl_object_t *, *vec, 8, enomem);
        }
      }
    }
  }
  else {
    new = ucl_object_new_userdata(NULL, NULL, NULL);
    ucl_object_set_priority(new, priority);
  }
enomem:
  return new;
}

bool ucl_object_reserve(ucl_object_t *obj, size_t reserved)
{
  if (obj->type == UCL_ARRAY) {
    UCL_ARRAY_GET(vec, obj);

    if (vec == NULL) {
      /* Allocate array storage if not present (e.g., copied empty array) */
      vec = UCL_ALLOC(sizeof(*vec));
      if (vec == NULL) {
        return false;
      }
      kv_init(*vec);
      obj->value.av = (void *)vec;
    }

    if (vec->m < reserved) {
      /* Preallocate some space for arrays */
      kv_resize_safe(ucl_object_t *, *vec, reserved, e0);
    }
  }
  else if (obj->type == UCL_OBJECT) {
    ucl_hash_reserve(obj->value.ov, reserved);
  }
  return true;
e0:
  return false;
}

ucl_object_t *
ucl_object_new_userdata(ucl_userdata_dtor dtor,
            ucl_userdata_emitter emitter,
            void *ptr)
{
  struct ucl_object_userdata *new;
  size_t nsize = sizeof(*new);

  new = UCL_ALLOC(nsize);
  if (new != NULL) {
    memset(new, 0, nsize);
    new->obj.ref = 1;
    new->obj.type = UCL_USERDATA;
    new->obj.next = NULL;
    new->obj.prev = (ucl_object_t *) new;
    new->dtor = dtor;
    new->emitter = emitter;
    new->obj.value.ud = ptr;
  }

  return (ucl_object_t *) new;
}

ucl_type_t
ucl_object_type(const ucl_object_t *obj)
{
  if (obj == NULL) {
    return UCL_NULL;
  }

  return obj->type;
}

ucl_object_t *
ucl_object_fromstring(const char *str)
{
  return ucl_object_fromstring_common(str, 0, UCL_STRING_RAW);
}

ucl_object_t *
ucl_object_fromlstring(const char *str, size_t len)
{
  return ucl_object_fromstring_common(str, len, UCL_STRING_RAW);
}

ucl_object_t *
ucl_object_fromint(int64_t iv)
{
  ucl_object_t *obj;

  obj = ucl_object_new();
  if (obj != NULL) {
    obj->type = UCL_INT;
    obj->value.iv = iv;
  }

  return obj;
}

ucl_object_t *
ucl_object_fromdouble(double dv)
{
  ucl_object_t *obj;

  obj = ucl_object_new();
  if (obj != NULL) {
    obj->type = UCL_FLOAT;
    obj->value.dv = dv;
  }

  return obj;
}

ucl_object_t *
ucl_object_frombool(bool bv)
{
  ucl_object_t *obj;

  obj = ucl_object_new();
  if (obj != NULL) {
    obj->type = UCL_BOOLEAN;
    obj->value.iv = bv;
  }

  return obj;
}

bool ucl_array_append(ucl_object_t *top, ucl_object_t *elt)
{
  if (top->type != UCL_ARRAY) {
    return false;
  }

  UCL_ARRAY_GET(vec, top);

  if (elt == NULL || top == NULL) {
    return false;
  }

  if (vec == NULL) {
    vec = UCL_ALLOC(sizeof(*vec));

    if (vec == NULL) {
      return false;
    }

    kv_init(*vec);
    top->value.av = (void *) vec;
  }

  kv_push_safe(ucl_object_t *, *vec, elt, e0);

  top->len++;

  return true;
e0:
  return false;
}

bool ucl_array_prepend(ucl_object_t *top, ucl_object_t *elt)
{
  if (top->type != UCL_ARRAY) {
    return false;
  }

  UCL_ARRAY_GET(vec, top);

  if (elt == NULL || top == NULL) {
    return false;
  }

  if (vec == NULL) {
    vec = UCL_ALLOC(sizeof(*vec));
    kv_init(*vec);
    top->value.av = (void *) vec;
    kv_push_safe(ucl_object_t *, *vec, elt, e0);
  }
  else {
    /* Slow O(n) algorithm */
    kv_prepend_safe(ucl_object_t *, *vec, elt, e0);
  }

  top->len++;

  return true;
e0:
  return false;
}

bool ucl_array_merge(ucl_object_t *top, ucl_object_t *elt, bool copy)
{
  unsigned i;
  ucl_object_t *cp = NULL;
  ucl_object_t **obj;

  if (elt == NULL || top == NULL || top->type != UCL_ARRAY || elt->type != UCL_ARRAY) {
    return false;
  }

  if (copy) {
    cp = ucl_object_copy(elt);
  }
  else {
    cp = ucl_object_ref(elt);
  }

  UCL_ARRAY_GET(v1, top);
  UCL_ARRAY_GET(v2, cp);

  if (v1 && v2) {
    kv_concat_safe(ucl_object_t *, *v1, *v2, e0);

    for (i = v2->n; i < v1->n; i++) {
      obj = &kv_A(*v1, i);
      if (*obj == NULL) {
        continue;
      }
      top->len++;
    }
  }

  return true;
e0:
  return false;
}

ucl_object_t *
ucl_array_delete(ucl_object_t *top, ucl_object_t *elt)
{
  if (top->type != UCL_ARRAY) {
    return NULL;
  }

  UCL_ARRAY_GET(vec, top);
  ucl_object_t *ret = NULL;
  unsigned i;

  if (vec == NULL) {
    return NULL;
  }

  for (i = 0; i < vec->n; i++) {
    if (kv_A(*vec, i) == elt) {
      kv_del(ucl_object_t *, *vec, i);
      ret = elt;
      top->len--;
      break;
    }
  }

  return ret;
}

const ucl_object_t *
ucl_array_head(const ucl_object_t *top)
{
  UCL_ARRAY_GET(vec, top);

  if (vec == NULL || top == NULL || top->type != UCL_ARRAY ||
    top->value.av == NULL) {
    return NULL;
  }

  return (vec->n > 0 ? vec->a[0] : NULL);
}

const ucl_object_t *
ucl_array_tail(const ucl_object_t *top)
{
  UCL_ARRAY_GET(vec, top);

  if (top == NULL || top->type != UCL_ARRAY || top->value.av == NULL) {
    return NULL;
  }

  return (vec->n > 0 ? vec->a[vec->n - 1] : NULL);
}

ucl_object_t *
ucl_array_pop_last(ucl_object_t *top)
{
  if (top->type != UCL_ARRAY) {
    return NULL;
  }

  UCL_ARRAY_GET(vec, top);
  ucl_object_t **obj, *ret = NULL;

  if (vec != NULL && vec->n > 0) {
    obj = &kv_A(*vec, vec->n - 1);
    ret = *obj;
    kv_del(ucl_object_t *, *vec, vec->n - 1);
    top->len--;
  }

  return ret;
}

ucl_object_t *
ucl_array_pop_first(ucl_object_t *top)
{
  if (top->type != UCL_ARRAY) {
    return NULL;
  }

  UCL_ARRAY_GET(vec, top);
  ucl_object_t **obj, *ret = NULL;

  if (vec != NULL && vec->n > 0) {
    obj = &kv_A(*vec, 0);
    ret = *obj;
    kv_del(ucl_object_t *, *vec, 0);
    top->len--;
  }

  return ret;
}

unsigned int
ucl_array_size(const ucl_object_t *top)
{
  if (top == NULL || top->type != UCL_ARRAY) {
    return 0;
  }

  UCL_ARRAY_GET(vec, top);

  if (vec != NULL) {
    return kv_size(*vec);
  }

  return 0;
}

const ucl_object_t *
ucl_array_find_index(const ucl_object_t *top, unsigned int index)
{
  if (top->type != UCL_ARRAY) {
    return NULL;
  }

  UCL_ARRAY_GET(vec, top);

  if (vec != NULL && vec->n > 0 && index < vec->n) {
    return kv_A(*vec, index);
  }

  return NULL;
}

unsigned int
ucl_array_index_of(ucl_object_t *top, ucl_object_t *elt)
{
  if (top->type != UCL_ARRAY) {
    return (unsigned int) (-1);
  }

  UCL_ARRAY_GET(vec, top);
  unsigned i;

  if (vec == NULL) {
    return (unsigned int) (-1);
  }

  for (i = 0; i < vec->n; i++) {
    if (kv_A(*vec, i) == elt) {
      return i;
    }
  }

  return (unsigned int) (-1);
}

ucl_object_t *
ucl_array_replace_index(ucl_object_t *top, ucl_object_t *elt,
            unsigned int index)
{
  if (top->type != UCL_ARRAY) {
    return NULL;
  }

  UCL_ARRAY_GET(vec, top);
  ucl_object_t *ret = NULL;

  if (vec != NULL && vec->n > 0 && index < vec->n) {
    ret = kv_A(*vec, index);
    kv_A(*vec, index) = elt;
  }

  return ret;
}

ucl_object_t *
ucl_elt_append(ucl_object_t *head, ucl_object_t *elt)
{

  if (head == NULL) {
    elt->next = NULL;
    elt->prev = elt;
    head = elt;
  }
  else {
    if (head->type == UCL_USERDATA) {
      /* Userdata objects are VERY special! */
      struct ucl_object_userdata *ud = (struct ucl_object_userdata *) head;
      elt->prev = ud->obj.prev;
      ud->obj.prev->next = elt;
      ud->obj.prev = elt;
      elt->next = NULL;
    }
    else {
      elt->prev = head->prev;
      head->prev->next = elt;
      head->prev = elt;
      elt->next = NULL;
    }
  }

  return head;
}

bool ucl_object_todouble_safe(const ucl_object_t *obj, double *target)
{
  if (obj == NULL || target == NULL) {
    return false;
  }
  switch (obj->type) {
  case UCL_INT:
    *target = obj->value.iv; /* Probably could cause overflow */
    break;
  case UCL_FLOAT:
  case UCL_TIME:
    *target = obj->value.dv;
    break;
  default:
    return false;
  }

  return true;
}

double
ucl_object_todouble(const ucl_object_t *obj)
{
  double result = 0.;

  ucl_object_todouble_safe(obj, &result);
  return result;
}

bool ucl_object_toint_safe(const ucl_object_t *obj, int64_t *target)
{
  if (obj == NULL || target == NULL) {
    return false;
  }
  switch (obj->type) {
  case UCL_INT:
    *target = obj->value.iv;
    break;
  case UCL_FLOAT:
  case UCL_TIME:
    *target = obj->value.dv; /* Losing of decimal points */
    break;
  default:
    return false;
  }

  return true;
}

int64_t
ucl_object_toint(const ucl_object_t *obj)
{
  int64_t result = 0;

  ucl_object_toint_safe(obj, &result);
  return result;
}

bool ucl_object_toboolean_safe(const ucl_object_t *obj, bool *target)
{
  if (obj == NULL || target == NULL) {
    return false;
  }
  switch (obj->type) {
  case UCL_BOOLEAN:
    *target = (obj->value.iv == true);
    break;
  default:
    return false;
  }

  return true;
}

bool ucl_object_toboolean(const ucl_object_t *obj)
{
  bool result = false;

  ucl_object_toboolean_safe(obj, &result);
  return result;
}

bool ucl_object_tostring_safe(const ucl_object_t *obj, const char **target)
{
  if (obj == NULL || target == NULL) {
    return false;
  }

  switch (obj->type) {
  case UCL_STRING:
    if (!(obj->flags & UCL_OBJECT_BINARY)) {
      *target = ucl_copy_value_trash(obj);
    }
    break;
  default:
    return false;
  }

  return true;
}

const char *
ucl_object_tostring(const ucl_object_t *obj)
{
  const char *result = NULL;

  ucl_object_tostring_safe(obj, &result);
  return result;
}

const char *
ucl_object_tostring_forced(const ucl_object_t *obj)
{
  /* TODO: For binary strings we might encode string here */
  if (!(obj->flags & UCL_OBJECT_BINARY)) {
    return ucl_copy_value_trash(obj);
  }

  return NULL;
}

bool ucl_object_tolstring_safe(const ucl_object_t *obj, const char **target, size_t *tlen)
{
  if (obj == NULL || target == NULL) {
    return false;
  }
  switch (obj->type) {
  case UCL_STRING:
    *target = obj->value.sv;
    if (tlen != NULL) {
      *tlen = obj->len;
    }
    break;
  default:
    return false;
  }

  return true;
}

const char *
ucl_object_tolstring(const ucl_object_t *obj, size_t *tlen)
{
  const char *result = NULL;

  ucl_object_tolstring_safe(obj, &result, tlen);
  return result;
}

const char *
ucl_object_key(const ucl_object_t *obj)
{
  return ucl_copy_key_trash(obj);
}

const char *
ucl_object_keyl(const ucl_object_t *obj, size_t *len)
{
  if (len == NULL || obj == NULL) {
    return NULL;
  }
  *len = obj->keylen;
  return obj->key;
}

ucl_object_t *
ucl_object_ref(const ucl_object_t *obj)
{
  ucl_object_t *res = NULL;

  if (obj != NULL) {
    if (obj->flags & UCL_OBJECT_EPHEMERAL) {
      /*
       * Use deep copy for ephemeral objects, note that its refcount
       * is NOT increased, since ephemeral objects does not need refcount
       * at all
       */
      res = ucl_object_copy(obj);
    }
    else {
      res = __DECONST(ucl_object_t *, obj);
#ifdef HAVE_ATOMIC_BUILTINS
      (void) __sync_add_and_fetch(&res->ref, 1);
#else
      res->ref++;
#endif
    }
  }
  return res;
}

static ucl_object_t *
ucl_object_copy_internal(const ucl_object_t *other, bool allow_array)
{

  ucl_object_t *new;
  ucl_object_iter_t it = NULL;
  const ucl_object_t *cur;
  size_t sz = sizeof(*new);

  if (other->type == UCL_USERDATA) {
    sz = sizeof(struct ucl_object_userdata);
  }
  new = UCL_ALLOC(sz);

  if (new != NULL) {
    memcpy(new, other, sz);
    if (other->flags & UCL_OBJECT_EPHEMERAL) {
      /* Copied object is always non ephemeral */
      new->flags &= ~UCL_OBJECT_EPHEMERAL;
    }
    new->ref = 1;
    /* Unlink from others */
    new->next = NULL;
    new->prev = new;

    /* deep copy of values stored */
    if (other->trash_stack[UCL_TRASH_KEY] != NULL) {
      new->trash_stack[UCL_TRASH_KEY] = NULL;
      if (other->key == (const char *) other->trash_stack[UCL_TRASH_KEY]) {
        new->trash_stack[UCL_TRASH_KEY] = UCL_ALLOC(other->keylen + 1);
        memcpy(new->trash_stack[UCL_TRASH_KEY], other->trash_stack[UCL_TRASH_KEY], other->keylen);
        new->trash_stack[UCL_TRASH_KEY][other->keylen] = '\0';
        new->key = new->trash_stack[UCL_TRASH_KEY];
      }
    }
    if (other->trash_stack[UCL_TRASH_VALUE] != NULL) {
      new->trash_stack[UCL_TRASH_VALUE] =
        UCL_STRDUP(other->trash_stack[UCL_TRASH_VALUE]);
      if (new->type == UCL_STRING) {
        new->value.sv = new->trash_stack[UCL_TRASH_VALUE];
      }
    }

    if (other->type == UCL_ARRAY || other->type == UCL_OBJECT) {
      /* reset old value and length since we will re-add elements below */
      memset(&new->value, 0, sizeof(new->value));
      new->len = 0;

      while ((cur = ucl_object_iterate(other, &it, true)) != NULL) {
        if (other->type == UCL_ARRAY) {
          ucl_array_append(new, ucl_object_copy_internal(cur, false));
        }
        else {
          ucl_object_t *cp = ucl_object_copy_internal(cur, true);
          if (cp != NULL) {
            ucl_object_insert_key(new, cp, cp->key, cp->keylen,
                        false);
          }
        }
      }
    }
    else if (allow_array && other->next != NULL) {
      LL_FOREACH(other->next, cur)
      {
        ucl_object_t *cp = ucl_object_copy_internal(cur, false);
        if (cp != NULL) {
          DL_APPEND(new, cp);
        }
      }
    }
  }

  return new;
}

ucl_object_t *
ucl_object_copy(const ucl_object_t *other)
{
  return ucl_object_copy_internal(other, true);
}

void ucl_object_unref(ucl_object_t *obj)
{
  if (obj != NULL) {
#ifdef HAVE_ATOMIC_BUILTINS
    unsigned int rc = __sync_sub_and_fetch(&obj->ref, 1);
    if (rc == 0) {
#else
    if (--obj->ref == 0) {
#endif
      ucl_object_free_internal(obj, true, ucl_object_dtor_unref);
    }
  }
}

int ucl_object_compare(const ucl_object_t *o1, const ucl_object_t *o2)
{
  const ucl_object_t *it1, *it2;
  ucl_object_iter_t iter = NULL;
  int ret = 0;

  if (o1->type != o2->type) {
    return (o1->type) - (o2->type);
  }

  switch (o1->type) {
  case UCL_STRING:
    if (o1->len == o2->len && o1->len > 0) {
      ret = strcmp(ucl_object_tostring(o1), ucl_object_tostring(o2));
    }
    else {
      ret = o1->len - o2->len;
    }
    break;
  case UCL_FLOAT:
  case UCL_INT:
  case UCL_TIME:
    ret = ucl_object_todouble(o1) - ucl_object_todouble(o2);
    break;
  case UCL_BOOLEAN:
    ret = ucl_object_toboolean(o1) - ucl_object_toboolean(o2);
    break;
  case UCL_ARRAY:
    if (o1->len == o2->len && o1->len > 0) {
      UCL_ARRAY_GET(vec1, o1);
      UCL_ARRAY_GET(vec2, o2);
      unsigned i;

      /* Compare all elements in both arrays */
      for (i = 0; i < vec1->n; i++) {
        it1 = kv_A(*vec1, i);
        it2 = kv_A(*vec2, i);

        if (it1 == NULL && it2 != NULL) {
          return -1;
        }
        else if (it2 == NULL && it1 != NULL) {
          return 1;
        }
        else if (it1 != NULL && it2 != NULL) {
          ret = ucl_object_compare(it1, it2);
          if (ret != 0) {
            break;
          }
        }
      }
    }
    else {
      ret = o1->len - o2->len;
    }
    break;
  case UCL_OBJECT:
    if (o1->len == o2->len && o1->len > 0) {
      while ((it1 = ucl_object_iterate(o1, &iter, true)) != NULL) {
        it2 = ucl_object_lookup(o2, ucl_object_key(it1));
        if (it2 == NULL) {
          ret = 1;
          break;
        }
        ret = ucl_object_compare(it1, it2);
        if (ret != 0) {
          break;
        }
      }
    }
    else {
      ret = o1->len - o2->len;
    }
    break;
  default:
    ret = 0;
    break;
  }

  return ret;
}

int ucl_object_compare_qsort(const ucl_object_t **o1,
               const ucl_object_t **o2)
{
  return ucl_object_compare(*o1, *o2);
}

void ucl_object_array_sort(ucl_object_t *ar,
               int (*cmp)(const ucl_object_t **o1, const ucl_object_t **o2))
{
  UCL_ARRAY_GET(vec, ar);

  if (cmp == NULL || ar == NULL || ar->type != UCL_ARRAY) {
    return;
  }

  qsort(vec->a, vec->n, sizeof(ucl_object_t *),
      (int (*)(const void *, const void *)) cmp);
}

void ucl_object_sort_keys(ucl_object_t *obj,
              enum ucl_object_keys_sort_flags how)
{
  if (obj != NULL && obj->type == UCL_OBJECT) {
    ucl_hash_sort(obj->value.ov, how);
  }
}

#define PRIOBITS 4

unsigned int
ucl_object_get_priority(const ucl_object_t *obj)
{
  if (obj == NULL) {
    return 0;
  }

  return (obj->flags >> ((sizeof(obj->flags) * NBBY) - PRIOBITS));
}

void ucl_object_set_priority(ucl_object_t *obj,
               unsigned int priority)
{
  if (obj != NULL) {
    priority &= (0x1 << PRIOBITS) - 1;
    priority <<= ((sizeof(obj->flags) * NBBY) - PRIOBITS);
    priority |= obj->flags & ((1 << ((sizeof(obj->flags) * NBBY) -
                     PRIOBITS)) -
                  1);
    obj->flags = priority;
  }
}

bool ucl_object_string_to_type(const char *input, ucl_type_t *res)
{
  if (strcasecmp(input, "object") == 0) {
    *res = UCL_OBJECT;
  }
  else if (strcasecmp(input, "array") == 0) {
    *res = UCL_ARRAY;
  }
  else if (strcasecmp(input, "integer") == 0) {
    *res = UCL_INT;
  }
  else if (strcasecmp(input, "number") == 0) {
    *res = UCL_FLOAT;
  }
  else if (strcasecmp(input, "string") == 0) {
    *res = UCL_STRING;
  }
  else if (strcasecmp(input, "boolean") == 0) {
    *res = UCL_BOOLEAN;
  }
  else if (strcasecmp(input, "null") == 0) {
    *res = UCL_NULL;
  }
  else if (strcasecmp(input, "userdata") == 0) {
    *res = UCL_USERDATA;
  }
  else {
    return false;
  }

  return true;
}

const char *
ucl_object_type_to_string(ucl_type_t type)
{
  const char *res = "unknown";

  switch (type) {
  case UCL_OBJECT:
    res = "object";
    break;
  case UCL_ARRAY:
    res = "array";
    break;
  case UCL_INT:
    res = "integer";
    break;
  case UCL_FLOAT:
  case UCL_TIME:
    res = "number";
    break;
  case UCL_STRING:
    res = "string";
    break;
  case UCL_BOOLEAN:
    res = "boolean";
    break;
  case UCL_USERDATA:
    res = "userdata";
    break;
  case UCL_NULL:
    res = "null";
    break;
  }

  return res;
}

const ucl_object_t *
ucl_parser_get_comments(struct ucl_parser *parser)
{
  if (parser && parser->comments) {
    return parser->comments;
  }

  return NULL;
}

const ucl_object_t *
ucl_comments_find(const ucl_object_t *comments,
          const ucl_object_t *srch)
{
  if (comments && srch) {
    return ucl_object_lookup_len(comments, (const char *) &srch,
                   sizeof(void *));
  }

  return NULL;
}

bool ucl_comments_move(ucl_object_t *comments,
             const ucl_object_t *from, const ucl_object_t *to)
{
  const ucl_object_t *found;
  ucl_object_t *obj;

  if (comments && from && to) {
    found = ucl_object_lookup_len(comments,
                    (const char *) &from, sizeof(void *));

    if (found) {
      /* Replace key */
      obj = ucl_object_ref(found);
      ucl_object_delete_keyl(comments, (const char *) &from,
                   sizeof(void *));
      ucl_object_insert_key(comments, obj, (const char *) &to,
                  sizeof(void *), true);

      return true;
    }
  }

  return false;
}

void ucl_comments_add(ucl_object_t *comments, const ucl_object_t *obj,
            const char *comment)
{
  if (comments && obj && comment) {
    ucl_object_insert_key(comments, ucl_object_fromstring(comment),
                (const char *) &obj, sizeof(void *), true);
  }
}

void ucl_parser_set_include_tracer(struct ucl_parser *parser,
                   ucl_include_trace_func_t func,
                   void *user_data)
{
  parser->include_trace_func = func;
  parser->include_trace_ud = user_data;
}

const char *
ucl_parser_get_cur_file(struct ucl_parser *parser)
{
  return parser->cur_file;
}

Coverage Report

Created: 2026-05-16 06:28