module.pmod.in

/* Parser.YAML
 */

#pike __REAL_VERSION__

#require constant(@module@)

//! @ignore
inherit @module@;
//! @endignore

// #define YAML_DEBUG

#ifdef YAML_DEBUG
# define TRACE(X...)werror("%s:%d: %s",basename(__FILE__),__LINE__,sprintf(X))
#else
# define TRACE(X...)0
#endif


//! @decl typedef mapping(string:mixed) EventData
typedef mapping(string:mixed) EventData;

//! @decl typedef mapping(string:mixed) TokenData
typedef mapping(string:mixed) TokenData;

#define SCALAR_TAG_IS(event, what) (event->tag == what)

#define IS_NOT_IMPLICIT(event)                     \
  (!event->quoted_implicit && !event->plain_implicit)

#define IS_NOT_IMPLICIT_AND_TAG_IS(event, tag)     \
  (IS_NOT_IMPLICIT(event) && SCALAR_TAG_IS(event, tag))

#define IS_NOT_QUOTED(event)                       \
  (event->style == PLAIN_SCALAR_STYLE ||           \
   event->style == ANY_SCALAR_STYLE)

#define SCALAR_IS_QUOTED(event)                    \
  (event->style == SINGLE_QUOTED_SCALAR_STYLE ||   \
   event->style == DOUBLE_QUOTED_SCALAR_STYLE)


//! Decode the YAML data in @[input] into an internal Pike structure.
//!
//! This is the same as:
//!
//! @code
//! Parser.YAML.Parser p = Parser.YAML.Parser();
//! p->set_input_string(my_yaml_data);
//! mixed res = p->deconstruct();
//! @endcode
//!
//! @seealso
//!  @[Parser.deconstruct()]
//!
//! @param input
//! @param cb
//!  A mapping of tag callbacks where the index is a tag and the value the
//!  the function to call when the tag is found.
//!  See @[Parser.add_tag_callback()]
public mixed decode(string(8bit) input, void|mapping(string:function) cb)
{
  Parser p = Parser();
  p->set_input_string(input);

  if (cb) {
    p->set_tag_callbacks(cb);
  }

  return p->deconstruct();
}


//! Decode the YAML data in the @[file] into an internal Pike structure.
//!
//! This is the same as:
//!
//! @code
//! Parser.YAML.Parser p = Parser.YAML.Parser();
//! p->set_input_file(my_yaml_file);
//! mixed res = p->deconstruct();
//! @endcode
//!
//! @seealso
//!  @[Parser.deconstruct()]
//!
//! @param file
//! @param cb
//!  A mapping of tag callbacks where the index is a tag and the value the
//!  the function to call when the tag is found.
//!  See @[Parser.add_tag_callback()]
public mixed decode_file(string(8bit) file, void|mapping(string:function) cb)
{
  Parser p = Parser();
  p->set_input_file(file);

  if (cb) {
    p->set_tag_callbacks(cb);
  }

  return p->deconstruct();
}


//! Returns the string representation of the event type in @[e] which can
//! either be an event from @[Parser.get_event()] or the result from
//! @[Parser.parse()].
//!
//! This is the same as
//!
//! @code
//! Parser.YAML.EVENT_TYPE_TO_STR[event_type]
//! @endcode
public string describe_event(EventData|int e)
{
  int c = mappingp(e) ? e->type : e;
  return EVENT_TYPE_TO_STR[c];
}


//! Returns the string representation of the token type in @[t] wich can
//! either be a token from @[Scanner.get_token()] or the result from
//! @[Scanner.scan()].
//!
//! This is the same as
//!
//! @code
//! Parser.YAML.TOKEN_TYPE_TO_STR[token_type]
//! @endcode
public string describe_token(TokenData|int t)
{
  int c = mappingp(t) ? t->type : t;
  return TOKEN_TYPE_TO_STR[c];
}


//! YAML parser class
//!
//! In principle you don't need to use this class explicitly unless you want to
//! do some special parsing of your own. In most common use cases @[decode()]
//! or @[decode_file()] will be sufficient.
class Parser
{
  inherit _Parser;

  private ADT.Queue parse_queue = ADT.Queue();
  private ADT.Queue event_queue = ADT.Queue();
  private mapping anchors = ([]);
  private mapping(string:function) tag_callbacks = ([]);

  //! Add a tag callback
  //!
  //! If @[tag] is set in a scalar value then function @[f] will be called
  //! with the @[EventData] as first argument and the actual @[Parser()] object
  //! as second. If @[f] returns @[UNDEFINED] then the function call will be
  //! skipped and the default conversion, if such exist, will take place. If
  //! anything other than @[UNDEFINED] is returned that will be set as the
  //! scalar value.
  //!
  //! If @[f] is falsy the callback will be removed if it exist.
  //!
  //! @seealso
  //!  @[set_tag_callbacks()]
  //!
  //! @example
  //! @code
  //! import Parser.YAML;
  //!
  //! string yml = #"
  //!   my-data: !to-upper |
  //!     Some application specific
  //!     string that will be converted
  //!     to upper case...
  //!   ";
  //!
  //! Parser p = Parser();
  //! p->set_input_string(yml);
  //! p->add_tag_callback("!to-upper",
  //!   lambda (EventData e) {
  //!     return upper_case(e->value);
  //!   });
  //!
  //! mapping res = p->deconstruct();
  //!
  //! ([ /* 1 element */
  //!   "my-data": "SOME APPLICATION SPECIFIC\n"
  //!     "STRING THAT WILL BE CONVERTED\n"
  //!     "TO UPPER CASE...\n"
  //! ])
  //! @endcode
  public void add_tag_callback(string tag, function(EventData : mixed) f)
  {
    if (f) {
      tag_callbacks[tag] = f;
    }
    else {
      m_delete(tag_callbacks, tag);
    }
  }

  //! Set all tag callbacks in one go.
  //!
  //! @seealso
  //!  @[add_tag_callback()]
  //!
  //! @param callbacks
  public void set_tag_callbacks(mapping(string:function) callbacks)
  {
    tag_callbacks = callbacks;
  }

  //! Move the parser to the next event. If @[peek_event()] has been called
  //! that event type will be returned.
  //!
  //! @seealso
  //!  @[get_event()], @[peek_event()]
  //!
  //! @returns
  //!  The current event type. This is any of the @[ALIAS_EVENT],
  //!  @[DOCUMENT_END_EVENT], @[DOCUMENT_START_EVENT], @[MAPPING_END_EVENT],
  //!  @[MAPPING_START_EVENT], @[NO_EVENT], @[SCALAR_EVENT],
  //!  @[SEQUENCE_END_EVENT], @[SEQUENCE_START_EVENT], @[STREAM_END_EVENT]
  //!  or @[STREAM_START_EVENT] constants.
  //!
  //!  To get a string representation of the event use the @[describe_event()]
  //!  mapping.
  public int parse()
  {
    if (sizeof(parse_queue)) {
      int t = parse_queue->get();

      if (sizeof(event_queue)) {
        event_queue->get();
      }

      return t;
    }

    return ::parse();
  }

  //! Returns the current event data structure. If @[peek_event()] has been
  //! called the event from that call will be returned.
  //!
  //! @seealso
  //!  @[peek_event()], @[parse()]
  //!
  //! @returns
  //!  A mapping of some sort. It has different members depending on what type
  //!  of event it is.
  public EventData get_event()
  {
    if (sizeof(event_queue)) {
      parse_queue->get();
      return event_queue->get();
    }

    EventData e = ::get_event();
    convert_scalar_type(e);

    return e;
  }

  //! Peek at the next event. This will move the parser one step, but the result
  //! of a call to this function will be cached and returned from the next call
  //! to @[parse()]. So beware that multiple consecutive calls to this method
  //! will move the cursor beyond what @[parse()] or @[get_event()] will return.
  public EventData peek_event()
  {
    parse_queue->put(::parse());
    EventData d = ::get_event();
    convert_scalar_type(d);
    event_queue->put(d);
    return d;
  }

  private bool is_deconstructed = false;

  //! Converts the entire document into a Pike data structure.
  //!
  //! @note
  //!  If the YAML stream being parsed contains multiple YAML documents an
  //!  array will be returned with each doucument per array index.
  //!
  //! @seealso
  //!  @[decode()], @[decode_file()]
  public mixed deconstruct()
  {
    if (is_deconstructed) {
      error("deconstruct() can not be called twice.\n");
    }

    EventData e, n;
    mixed out;
    mixed curr;
    array docs;

    is_deconstructed = true;

    while (int t = parse()) {
      switch (t)
      {
        case DOCUMENT_END_EVENT:
          if (!out) {
            out = copy_value(curr);
          }
          else {
            if (!docs) {
              docs = ({ out });
            }
            docs += ({ curr });
          }

          break;

        case MAPPING_START_EVENT:
          curr = deconstruct_mapping();
          break;

        case SEQUENCE_START_EVENT:
          curr = deconstruct_sequence();
          break;

        case SCALAR_EVENT:
          e = get_event();

          if (!curr) {
            curr = e->value;
          }
          else if (arrayp(curr)) {
            curr += ({ e->value });
          }
          else if (mappingp(curr)) {
            n = peek_event();
            // Skip the peeked event
            parse();

            switch (n->type)
            {
              case SCALAR_EVENT:
                curr[e->value] = n->value;
                break;

              case SEQUENCE_START_EVENT:
                curr[e->value] = deconstruct_sequence();
                break;

              case MAPPING_START_EVENT:
                curr[e->value] = deconstruct_mapping();
                break;
            }
          }

          break;
      }
    }

    return docs || out;
  }


  public array deconstruct_sequence()
  {
    EventData e;
    array out = ({});

    while (parse()) {
      e = get_event();

      if (e->type == SEQUENCE_END_EVENT) {
        break;
      }

      mixed val = UNDEFINED;

      if (e->tag && tag_callbacks) {
        if (function f = tag_callbacks[e->tag]) {
          val = f(e, this);
        }
      }

      if (undefinedp(val)) {
        switch (e->type)
        {
          case MAPPING_START_EVENT:
            val = deconstruct_mapping();
            break;

          case SEQUENCE_START_EVENT:
            val = deconstruct_sequence();
            break;

          case ALIAS_EVENT:
            out += ({ anchors[e->anchor] });
            break;

          default:
            val = e->value;
            break;
        }
      }

      if (!undefinedp(val)) {
        out += ({ val });
      }

      if (e->anchor) {
        anchors[e->anchor] = val;
      }
    }

    return out;
  }

  public mapping deconstruct_mapping()
  {
    EventData e, n;
    mapping out = ([]);

    while (parse()) {
      e = get_event();

      if (e->type == MAPPING_END_EVENT) {
        break;
      }

      if (e->type == SEQUENCE_START_EVENT) {
        e->value = deconstruct_sequence();
      }
      else {
        // Dunno about this, but it makes no sense to have a property name
        // { y: 12 } be converted to { Val.true: 12 }
        if (e->value == Val.true || e->value == Val.false) {
          e->value = e->_raw_value;
        }
      }

      n = peek_event();
      parse();

      switch (n->type)
      {
        case SEQUENCE_START_EVENT:
          out[e->value] = deconstruct_sequence();
          break;

        case MAPPING_START_EVENT:
          out[e->value] = deconstruct_mapping();
          break;

        case ALIAS_EVENT:
          out[e->value] = anchors[n->anchor];
          break;

        default:
          out[e->value] = n->value;
          break;
      }

      if (n->anchor) {
        anchors[n->anchor] = out[e->value];
      }
    }

    return out;
  }

  protected void maybe_add_default_anchor(EventData e)
  {
    if (e->anchor) {
      anchors[e->anchor] = e->value;
    }
  }
  //! @ignore


  //! Convert @tt{value@} in @[e] to it's proper data type
  //!
  //! NOTE: This method has side effects, it changes the value property in @[e].
  //! It also adds the member @tt{_raw_value@} which contain the original
  //! value if type conversion occurs.
  protected void convert_scalar_type(EventData e)
  {
    if (e->type != SCALAR_EVENT) {
      return;
    }

    string d = e->value;
    string lcd = lower_case(d);
    mixed val;
    e->_raw_value = d;

    if (IS_NOT_IMPLICIT(e) && e->tag && tag_callbacks) {
      if (function f = tag_callbacks[e->tag]) {
        if (!zero_type(val = f(e))) {
          e->value = val;
          maybe_add_default_anchor(e);
          return;
        }
      }
    }

    if (SCALAR_IS_QUOTED(e)) {
      // Do nothing, explicit string
    }
    else if (IS_NOT_IMPLICIT_AND_TAG_IS(e, STR_TAG)) {
      // Do nothing, explicit string
    }
    else if (IS_NOT_IMPLICIT_AND_TAG_IS(e, NULL_TAG)) {
      e->value = Val.null;
    }
    else if (IS_NOT_IMPLICIT_AND_TAG_IS(e, BOOL_TAG)) {
      e->value = e->value == "true" ? Val.true : Val.false;
    }
    else if (IS_NOT_IMPLICIT_AND_TAG_IS(e, INT_TAG)) {
      e->value = (int) e->value;
    }
    else if (IS_NOT_IMPLICIT_AND_TAG_IS(e, FLOAT_TAG)) {
      e->value = (float) e->value;
    }
    else if (IS_NOT_IMPLICIT_AND_TAG_IS(e, TIMESTAMP_TAG)) {
      e->value = scalar_is_date(e);
    }
    else if (IS_NOT_IMPLICIT_AND_TAG_IS(e, BINARY_TAG)) {
      e->value = MIME.decode_base64(e->value);
    }
    else if (IS_NOT_IMPLICIT_AND_TAG_IS(e, PIKE_TAG)) {
      e->value = decode_value(MIME.decode_base64(e->value));
    }
    else if (!zero_type(val = scalar_is_null(e))) {
      e->value = val;
    }
    else if (!zero_type(val = scalar_is_bool(e))) {
      e->value = val;
    }
    else if (!zero_type(val = scalar_is_date(e))) {
      e->value = val;
    }
    else if (!zero_type(val = scalar_is_numeric(e))) {
      e->value = val;
    }

    maybe_add_default_anchor(e);
  }

  protected mixed scalar_is_date(EventData e)
  {
    if (!e->value) {
      return UNDEFINED;
    }

    if (sscanf (e->value, "%*4d-%*2d-%*2d") == 3) {
      object r;
      if (mixed err = catch(r = Calendar.dwim_time(e->value))) {
        if (err = catch(r = Calendar.dwim_day(e->value))) {
          return UNDEFINED;
        }
      }

      if (r) {
        return r;
      }
    }

    return UNDEFINED;
  }

  //!
  protected Val.Null scalar_is_null(EventData e)
  {
    if (e->quoted_implicit) {
      return UNDEFINED;
    }

    if (e->plain_implicit && (< "~", "null" >)[lower_case(e->value)]) {
      return Val.null;
    }

    return e->value == NULL_TAG ? Val.null : UNDEFINED;
  }

  //!
  protected Val.Boolean scalar_is_bool(EventData e)
  {
    if (SCALAR_TAG_IS(e, BOOL_TAG) || IS_NOT_QUOTED(e)) {
      if ((< "y", "yes", "true", "on" >)[lower_case(e->value)]) {
        return Val.true;
      }

      if ((< "n", "no", "false", "off" >)[lower_case(e->value)]) {
        return Val.false;
      }
    }

    return UNDEFINED;
  }

  //!
  protected mixed scalar_is_numeric(EventData e)
  {
    string v = String.trim_all_whites(e->value);

    if (!sizeof(v) || SCALAR_IS_QUOTED(e)) {
      return UNDEFINED;
    }

    string lcv = lower_case(v);

    string prefix;

    if (lcv[0] == '+' || lcv[0] == '-') {
      prefix = lcv[0..0];
      lcv = lcv[1..];
    }

    if (lcv == ".inf") {
      if (prefix && prefix == "-") {
        return -(Math.inf);
      }

      return Math.inf;
    }

    if (lcv == ".nan") {
      return Math.nan;
    }

    multiset int_range = (< '0','1','2','3','4','5','6','7','8','9' >);

    if (!int_range[lcv[0]] && lcv[0] != '.') {
      return UNDEFINED;
    }

    string sentinel = lcv + "\0\0";
    int len = sizeof(lcv);
    int alphas = 0;
    int dots = 0;
    int lodash = 0;
    int prev;


    for (int i; i < len; i++) {
      int c = lcv[i];

      if (c == '.') {
        dots += 1;
        // Can't be a numeric value
        if (dots > 1) {
          return UNDEFINED;
        }
      }
      else if (c == '_') {
        if (zero_type(prev) || !int_range[prev]) {
          return UNDEFINED;
        }

        lodash += 1;
      }
      else if (c == 'x') {
        if (sentinel[i-1] != '0') {
          return UNDEFINED;
        }
        // Hexadecimal, break early
        break;
      }
      else if (c == 'e') {
        if (!dots || (sentinel[i+1] != '+' && !int_range[sentinel[i+2]])) {
          return UNDEFINED;
        }
        i += 2;
        c = lcv[i];
      }
      else if (!int_range[c]) {
        alphas += 1;
      }

      prev = c;
    }

    if (!alphas) {
      if (lodash) {
        lcv -= "_";
      }

      // Octal or hexadecimal. Dunno if to convert or if it can be natively
      // represented as any of this number types. Now it's converted to decimal
      // number.
      if (sizeof(lcv) > 1 && lcv[0] == '0') {
        if (lcv[1] == 'x') {
          return hex_to_dec(lcv);
        }
        else {
          return oct_to_dec(lcv);
        }
      }

      if (prefix) {
        lcv = prefix + lcv;
      }

      if (dots) {
        return (float) lcv;
      }
      else {
        return (int) lcv;
      }
    }

    return UNDEFINED;
  }


  int oct_to_dec(string o)
  {
    int len = sizeof(o);
    int x;

    for (int i = 0, j = len-1; i < len; i++, --j) {
      int c = (int)o[i..i];
      x += c * pow(8, j);
    }

    return x;
  }


  int hex_to_dec(string h)
  {
    string chars = "0123456789abcdef";

    if (h[0] == '0') {
      h = lower_case(h[2..]);
    }

    int len = sizeof(h);
    int x;

    for (int i, j = len-1; i < len; i++, --j) {
      int pos = search(chars, h[i..i]);
      x += pos * pow(16, j);
    }

    return x;
  }

  //! @endignore
}

//! YAML scanner class
//!
//! The @[Scanner] is more low level/fine grained than the @[Parser]. For basic
//! decoding you probably want to use the @[Parser]. The @[Scanner] does no
//! type conversion on scalar types or anything fancy like that.
//!
//! @example
//! @code
//! import Parser.YAML;
//!
//! Scanner s = Scanner();
//! s->set_input_file("data.yml");
//!
//! while (int t = s->scan()) {
//!   if (t == SCALAR_TOKEN) {
//!     write("Scalar value: %s\n", get_token()->value);
//!   }
//!   else if (t == FLOW_ENTRY_TOKEN) {
//!     if (peek_token()->type == KEY_TOKEN) {
//!       write("Start of array of mappings\n");
//!     }
//!   }
//! }
//! @endcode
class Scanner
{
  inherit _Scanner;

  private ADT.Queue scan_queue = ADT.Queue();
  private ADT.Queue token_queue = ADT.Queue();

  //! Scan to next position.
  //!
  //! @seealso
  //!  @[get_token()], @[peek_token()]
  //!
  //! @returns
  //!  @tt{0@} when done. Otherwise any of the @tt{*_TOKEN@} constants.
  public int scan()
  {
    if (sizeof (scan_queue)) {
      token_queue->get();
      return scan_queue->get();
    }

    return ::scan();
  }

  //! Returns the current token
  //!
  //! @seealso
  //!  @[peek_token()]
  public TokenData get_token()
  {
    if (sizeof(token_queue)) {
      scan_queue->get();
      return token_queue->get();
    }

    return ::get_token();
  }

  //! Peek next token. This can be called multiple times since the peeked
  //! tokens will get queued and returned in order on next call to
  //! @[get_token()]. Each call to @[scan()] will consume the tokens in turn.
  public TokenData peek_token()
  {
    scan_queue->put(::scan());
    TokenData t = ::get_token();
    token_queue->put(t);
    return t;
  }
}


//! ENCODING to string conversion
constant ENCODING_TO_STR = ([
  ANY_ENCODING : "ANY_ENCODING",
  UTF16BE_ENCODING : "UTF16BE_ENCODING",
  UTF16LE_ENCODING : "UTF16LE_ENCODING",
  UTF8_ENCODING : "UTF8_ENCODING",
]);

//! BREAK to string conversion
constant BREAK_TO_STR = ([
  ANY_BREAK : "ANY_BREAK",
  CRLN_BREAK : "CRLN_BREAK",
  CR_BREAK : "CR_BREAK",
  LN_BREAK : "LN_BREAK",
]);

//! ERROR_TYPE to string conversion
constant ERROR_TYPE_TO_STR = ([
  COMPOSER_ERROR : "COMPOSER_ERROR",
  EMITTER_ERROR : "EMITTER_ERROR",
  MEMORY_ERROR : "MEMORY_ERROR",
  NO_ERROR : "NO_ERROR",
  PARSER_ERROR : "PARSER_ERROR",
  READER_ERROR : "READER_ERROR",
  SCANNER_ERROR : "SCANNER_ERROR",
  WRITER_ERROR : "WRITER_ERROR",
]);

//! SCALAR_STYLE to string conversion
constant SCALAR_STYLE_TO_STR = ([
  ANY_SCALAR_STYLE : "ANY_SCALAR_STYLE",
  DOUBLE_QUOTED_SCALAR_STYLE : "DOUBLE_QUOTED_SCALAR_STYLE",
  FOLDED_SCALAR_STYLE : "FOLDED_SCALAR_STYLE",
  LITERAL_SCALAR_STYLE : "LITERAL_SCALAR_STYLE",
  PLAIN_SCALAR_STYLE : "PLAIN_SCALAR_STYLE",
  SINGLE_QUOTED_SCALAR_STYLE : "SINGLE_QUOTED_SCALAR_STYLE",
]);

//! SEQUENCE_STYLE to string conversion
constant SEQUENCE_STYLE_TO_STR = ([
  ANY_SEQUENCE_STYLE : "ANY_SEQUENCE_STYLE",
  BLOCK_SEQUENCE_STYLE : "BLOCK_SEQUENCE_STYLE",
  FLOW_SEQUENCE_STYLE : "FLOW_SEQUENCE_STYLE",
]);

//! MAPPING_STYLE to string conversion
constant MAPPING_STYLE_TO_STR = ([
  ANY_MAPPING_STYLE : "ANY_MAPPING_STYLE",
  BLOCK_MAPPING_STYLE : "BLOCK_MAPPING_STYLE",
  FLOW_MAPPING_STYLE : "FLOW_MAPPING_STYLE",
]);

//! TOKEN_TYPE to string conversion
constant TOKEN_TYPE_TO_STR = ([
  ALIAS_TOKEN : "ALIAS_TOKEN",
  ANCHOR_TOKEN : "ANCHOR_TOKEN",
  BLOCK_END_TOKEN : "BLOCK_END_TOKEN",
  BLOCK_ENTRY_TOKEN : "BLOCK_ENTRY_TOKEN",
  BLOCK_MAPPING_START_TOKEN : "BLOCK_MAPPING_START_TOKEN",
  BLOCK_SEQUENCE_START_TOKEN : "BLOCK_SEQUENCE_START_TOKEN",
  DOCUMENT_END_TOKEN : "DOCUMENT_END_TOKEN",
  DOCUMENT_START_TOKEN : "DOCUMENT_START_TOKEN",
  FLOW_ENTRY_TOKEN : "FLOW_ENTRY_TOKEN",
  FLOW_MAPPING_END_TOKEN : "FLOW_MAPPING_END_TOKEN",
  FLOW_MAPPING_START_TOKEN : "FLOW_MAPPING_START_TOKEN",
  FLOW_SEQUENCE_END_TOKEN : "FLOW_SEQUENCE_END_TOKEN",
  FLOW_SEQUENCE_START_TOKEN : "FLOW_SEQUENCE_START_TOKEN",
  KEY_TOKEN : "KEY_TOKEN",
  NO_TOKEN : "NO_TOKEN",
  SCALAR_TOKEN : "SCALAR_TOKEN",
  STREAM_END_TOKEN : "STREAM_END_TOKEN",
  STREAM_START_TOKEN : "STREAM_START_TOKEN",
  TAG_DIRECTIVE_TOKEN : "TAG_DIRECTIVE_TOKEN",
  TAG_TOKEN : "TAG_TOKEN",
  VALUE_TOKEN : "VALUE_TOKEN",
  VERSION_DIRECTIVE_TOKEN : "VERSION_DIRECTIVE_TOKEN",
]);

//! EVENT_TYPE to string conversion
constant EVENT_TYPE_TO_STR = ([
  ALIAS_EVENT : "ALIAS_EVENT",
  DOCUMENT_END_EVENT : "DOCUMENT_END_EVENT",
  DOCUMENT_START_EVENT : "DOCUMENT_START_EVENT",
  MAPPING_END_EVENT : "MAPPING_END_EVENT",
  MAPPING_START_EVENT : "MAPPING_START_EVENT",
  NO_EVENT : "NO_EVENT",
  SCALAR_EVENT : "SCALAR_EVENT",
  SEQUENCE_END_EVENT : "SEQUENCE_END_EVENT",
  SEQUENCE_START_EVENT : "SEQUENCE_START_EVENT",
  STREAM_END_EVENT : "STREAM_END_EVENT",
  STREAM_START_EVENT : "STREAM_START_EVENT",
]);

//! NODE_TYPE to string conversion
constant NODE_TYPE_TO_STR = ([
  MAPPING_NODE : "MAPPING_NODE",
  NO_NODE : "NO_NODE",
  SCALAR_NODE : "SCALAR_NODE",
  SEQUENCE_NODE : "SEQUENCE_NODE",
]);

//! PARSER_STATE to string conversion
constant PARSER_STATE_TO_STR = ([
  PARSE_BLOCK_MAPPING_FIRST_KEY_STATE : "PARSE_BLOCK_MAPPING_FIRST_KEY_STATE",
  PARSE_BLOCK_MAPPING_KEY_STATE : "PARSE_BLOCK_MAPPING_KEY_STATE",
  PARSE_BLOCK_MAPPING_VALUE_STATE : "PARSE_BLOCK_MAPPING_VALUE_STATE",
  PARSE_BLOCK_NODE_OR_INDENTLESS_SEQUENCE_STATE : "PARSE_BLOCK_NODE_OR_INDENTLESS_SEQUENCE_STATE",
  PARSE_BLOCK_NODE_STATE : "PARSE_BLOCK_NODE_STATE",
  PARSE_BLOCK_SEQUENCE_ENTRY_STATE : "PARSE_BLOCK_SEQUENCE_ENTRY_STATE",
  PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE : "PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE",
  PARSE_DOCUMENT_CONTENT_STATE : "PARSE_DOCUMENT_CONTENT_STATE",
  PARSE_DOCUMENT_END_STATE : "PARSE_DOCUMENT_END_STATE",
  PARSE_DOCUMENT_START_STATE : "PARSE_DOCUMENT_START_STATE",
  PARSE_END_STATE : "PARSE_END_STATE",
  PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE : "PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE",
  PARSE_FLOW_MAPPING_FIRST_KEY_STATE : "PARSE_FLOW_MAPPING_FIRST_KEY_STATE",
  PARSE_FLOW_MAPPING_KEY_STATE : "PARSE_FLOW_MAPPING_KEY_STATE",
  PARSE_FLOW_MAPPING_VALUE_STATE : "PARSE_FLOW_MAPPING_VALUE_STATE",
  PARSE_FLOW_NODE_STATE : "PARSE_FLOW_NODE_STATE",
  PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE : "PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE",
  PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE : "PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE",
  PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE : "PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE",
  PARSE_FLOW_SEQUENCE_ENTRY_STATE : "PARSE_FLOW_SEQUENCE_ENTRY_STATE",
  PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE : "PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE",
  PARSE_IMPLICIT_DOCUMENT_START_STATE : "PARSE_IMPLICIT_DOCUMENT_START_STATE",
  PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE : "PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE",
  PARSE_STREAM_START_STATE : "PARSE_STREAM_START_STATE",
]);

//! EMITTER_STATE to string conversion
constant EMITTER_STATE_TO_STR = ([
  EMIT_BLOCK_MAPPING_FIRST_KEY_STATE : "EMIT_BLOCK_MAPPING_FIRST_KEY_STATE",
  EMIT_BLOCK_MAPPING_KEY_STATE : "EMIT_BLOCK_MAPPING_KEY_STATE",
  EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE : "EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE",
  EMIT_BLOCK_MAPPING_VALUE_STATE : "EMIT_BLOCK_MAPPING_VALUE_STATE",
  EMIT_BLOCK_SEQUENCE_FIRST_ITEM_STATE : "EMIT_BLOCK_SEQUENCE_FIRST_ITEM_STATE",
  EMIT_BLOCK_SEQUENCE_ITEM_STATE : "EMIT_BLOCK_SEQUENCE_ITEM_STATE",
  EMIT_DOCUMENT_CONTENT_STATE : "EMIT_DOCUMENT_CONTENT_STATE",
  EMIT_DOCUMENT_END_STATE : "EMIT_DOCUMENT_END_STATE",
  EMIT_DOCUMENT_START_STATE : "EMIT_DOCUMENT_START_STATE",
  EMIT_END_STATE : "EMIT_END_STATE",
  EMIT_FIRST_DOCUMENT_START_STATE : "EMIT_FIRST_DOCUMENT_START_STATE",
  EMIT_FLOW_MAPPING_FIRST_KEY_STATE : "EMIT_FLOW_MAPPING_FIRST_KEY_STATE",
  EMIT_FLOW_MAPPING_KEY_STATE : "EMIT_FLOW_MAPPING_KEY_STATE",
  EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE : "EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE",
  EMIT_FLOW_MAPPING_VALUE_STATE : "EMIT_FLOW_MAPPING_VALUE_STATE",
  EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE : "EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE",
  EMIT_FLOW_SEQUENCE_ITEM_STATE : "EMIT_FLOW_SEQUENCE_ITEM_STATE",
  EMIT_STREAM_START_STATE : "EMIT_STREAM_START_STATE",
]);