/*

 * Copyright (c) 2015, Vsevolod Stakhov

 * 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 BY AUTHOR ''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.

 */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include <ucl.h>

#include "ucl.h"

#include "ucl_internal.h"

#include "utlist.h"

#define NEXT_STATE                            \

  do {                                      \

    if (p >= end) {                       \

      if (state != read_ebrace) {       \

        ucl_create_err(&parser->err,  \

                 "extra data"); \

        state = parse_err;            \

      }                                 \

    }                                     \

    else {                                \

      switch (*p) {                     \

      case '(':                         \

        state = read_obrace;          \

        break;                        \

      case ')':                         \

        state = read_ebrace;          \

        break;                        \

      default:                          \

        len = 0;                      \

        mult = 1;                     \

        state = read_length;          \

        break;                        \

      }                                 \

    }                                     \

  } while (0)

bool ucl_parse_csexp(struct ucl_parser *parser)

{

  const unsigned char *p, *end;

  ucl_object_t *obj;

  struct ucl_stack *st;

  uint64_t len = 0, mult = 1;

  enum {

    start_parse,

    read_obrace,

    read_length,

    read_value,

    read_ebrace,

    parse_err

  } state = start_parse;

  assert(parser != NULL);

  assert(parser->chunks != NULL);

  assert(parser->chunks->begin != NULL);

  assert(parser->chunks->remain != 0);

  p = parser->chunks->begin;

  end = p + parser->chunks->remain;

  while (p < end) {

    switch (state) {

    case start_parse:

      /* At this point we expect open brace */

      if (*p == '(') {

        state = read_obrace;

      }

      else {

        ucl_create_err(&parser->err, "bad starting character for "

                       "sexp block: %x",

                 (int) *p);

        state = parse_err;

      }

      break;

    case read_obrace:

      st = calloc(1, sizeof(*st));

      if (st == NULL) {

        ucl_create_err(&parser->err, "no memory");

        state = parse_err;

        continue;

      }

      st->obj = ucl_object_typed_new(UCL_ARRAY);

      if (st->obj == NULL) {

        ucl_create_err(&parser->err, "no memory");

        state = parse_err;

        free(st);

        continue;

      }

      if (parser->stack == NULL) {

        /* We have no stack */

        parser->stack = st;

        if (parser->top_obj == NULL) {

          parser->top_obj = st->obj;

        }

      }

      else {

        /* Prepend new element to the stack */

        LL_PREPEND(parser->stack, st);

      }

      p++;

      NEXT_STATE;

      break;

    case read_length:

      if (*p == ':') {

        if (len == 0) {

          ucl_create_err(&parser->err, "zero length element");

          state = parse_err;

          continue;

        }

        state = read_value;

      }

      else if (*p >= '0' && *p <= '9') {

        len += (*p - '0') * mult;

        mult *= 10;

        if (len > UINT32_MAX) {

          ucl_create_err(&parser->err, "too big length of an "

                         "element");

          state = parse_err;

          continue;

        }

      }

      else {

        ucl_create_err(&parser->err, "bad length character: %x",

                 (int) *p);

        state = parse_err;

        continue;

      }

      p++;

      break;

    case read_value:

      if ((uint64_t) (end - p) > len || len == 0) {

        ucl_create_err(&parser->err, "invalid length: %llu, %ld "

                       "remain",

                 (long long unsigned) len, (long) (end - p));

        state = parse_err;

        continue;

      }

      obj = ucl_object_typed_new(UCL_STRING);

      obj->value.sv = (const char *) p;

      obj->len = len;

      obj->flags |= UCL_OBJECT_BINARY;

      if (!(parser->flags & UCL_PARSER_ZEROCOPY)) {

        ucl_copy_value_trash(obj);

      }

      ucl_array_append(parser->stack->obj, obj);

      p += len;

      NEXT_STATE;

      break;

    case read_ebrace:

      if (parser->stack == NULL) {

        /* We have an extra end brace */

        ucl_create_err(&parser->err, "invalid length: %llu, %ld "

                       "remain",

                 (long long unsigned) len, (long) (end - p));

        state = parse_err;

        continue;

      }

      /* Pop the container */

      st = parser->stack;

      parser->stack = st->next;

      if (parser->stack->obj->type == UCL_ARRAY) {

        ucl_array_append(parser->stack->obj, st->obj);

      }

      else {

        ucl_create_err(&parser->err, "bad container object, array "

                       "expected");

        state = parse_err;

        continue;

      }

      free(st);

      st = NULL;

      p++;

      NEXT_STATE;

      break;

    case parse_err:

    default:

      return false;

    }

  }

  if (state != read_ebrace) {

    ucl_create_err(&parser->err, "invalid finishing state: %d", state);

    return false;

  }

  return true;

}