text: #include "config.h"
  #ifdef I_STDLIB
  #define HAVE_STDLIB_H
  #endif
  #ifdef I_STRING
  #define HAVE_STRING_H
  #endif
  
  /*
   * syck.h
   *
   * $Author: why $
   * $Date: 2005-11-14 07:43:56 +0800 (一, 14 11 2005) $
   *
   * Copyright (C) 2003 why the lucky stiff
   */
  
  #ifndef SYCK_H
  #define SYCK_H
  
  #define SYCK_YAML_MAJOR 1
  #define SYCK_YAML_MINOR 0
  
  #define SYCK_VERSION    "0.61"
  #define YAML_DOMAIN     "yaml.org,2002"
  
  #ifdef HAVE_STDLIB_H
  # include <stdlib.h>
  #endif
  
  #ifdef HAVE_STRING_H
  # include <string.h>
  #else
  # include <strings.h>
  #endif
  
  #ifdef HAVE_INTRINSICS_H
  # include <intrinsics.h>
  #endif
  
  #include <stddef.h>
  #include <stdint.h>
  #include <stdio.h>
  #include <ctype.h>
  #ifdef HAVE_ST_H
  #include <st.h>
  #else
  #include "syck_st.h"
  #endif
  
  #if defined(__cplusplus)
  extern "C" {
  #endif
  
  /*
   * Memory Allocation
   */
  #if defined(HAVE_ALLOCA_H) && !defined(__GNUC__)
  #include <alloca.h>
  #endif
  
  #if DEBUG
    void syck_assert( char *, unsigned );
  # define ASSERT(f) \
      if ( f ) \
          {}   \
      else     \
          syck_assert( __FILE__, __LINE__ )
  #else
  # define ASSERT(f)
  #endif
  
  #ifndef NULL
  # define NULL (void *)0
  #endif
  
  #define ALLOC_CT 8
  #define SYCK_BUFFERSIZE 4096
  #define S_ALLOC_N(type,n) (type*)malloc(sizeof(type)*(n))
  #define S_ALLOC(type) (type*)malloc(sizeof(type))
  #define S_REALLOC_N(var,type,n) (var)=(type*)realloc((char*)(var),sizeof(type)*(n))
  #define S_FREE(n) free(n); n = NULL;
  
  #define S_ALLOCA_N(type,n) (type*)alloca(sizeof(type)*(n))
  
  #define S_MEMZERO(p,type,n) memset((p), 0, sizeof(type)*(n))
  #define S_MEMCPY(p1,p2,type,n) memcpy((p1), (p2), sizeof(type)*(n))
  #define S_MEMMOVE(p1,p2,type,n) memmove((p1), (p2), sizeof(type)*(n))
  #define S_MEMCMP(p1,p2,type,n) memcmp((p1), (p2), sizeof(type)*(n))
  
  #define BLOCK_FOLD  10
  #define BLOCK_LIT   20
  #define BLOCK_PLAIN 30
  #define NL_CHOMP    40
  #define NL_KEEP     50
  
  #define EMITTER_MARK_NODE_FLAG_PERMIT_DUPLICATE_NODES 1
  
  /*
   * Node definitions
   */
  #ifndef ST_DATA_T_DEFINED
  typedef uintptr_t st_data_t;
  #endif
  
  #define SYMID uintptr_t
  
  typedef struct _syck_node SyckNode;
  
  enum syck_kind_tag {
      syck_map_kind,
      syck_seq_kind,
      syck_str_kind
  };
  
  enum map_part {
      map_key,
      map_value
  };
  
  enum map_style {
      map_none,
      map_inline
  };
  
  enum seq_style {
      seq_none,
      seq_inline
  };
  
  enum scalar_style {
      scalar_none,
      scalar_1quote,
      scalar_2quote,
      scalar_fold,
      scalar_literal,
      scalar_plain,
      scalar_2quote_1 /* Added by Audrey Tang to support JSON's single quoting */
  };
  
  /*
   * Node metadata struct
   */
  struct _syck_node {
      /* Symbol table ID */
      SYMID id;
      /* Underlying kind */
      enum syck_kind_tag kind;
      /* Fully qualified tag-uri for type */
      char *type_id;
      /* Anchor name */
      char *anchor;
      union {
          /* Storage for map data */
          struct SyckMap {
              enum map_style style;
              SYMID *keys;
              SYMID *values;
              long capa;
              long idx;
          } *pairs;
          /* Storage for sequence data */
          struct SyckSeq {
              enum seq_style style;
              SYMID *items;
              long capa;
              long idx;
          } *list;
          /* Storage for string data */
          struct SyckStr {
              enum scalar_style style;
              char *ptr;
              long len;
          } *str;
      } data;
      /* Shortcut node */
      void *shortcut;
  };
  
  /*
   * Parser definitions
   */
  typedef struct _syck_parser SyckParser;
  typedef struct _syck_file SyckIoFile;
  typedef struct _syck_str SyckIoStr;
  typedef struct _syck_level SyckLevel;
  
  typedef SYMID (*SyckNodeHandler)(SyckParser *, SyckNode *);
  typedef void (*SyckErrorHandler)(SyckParser *, char *);
  typedef SyckNode * (*SyckBadAnchorHandler)(SyckParser *, char *);
  typedef long (*SyckIoFileRead)(char *, SyckIoFile *, long, long); 
  typedef long (*SyckIoStrRead)(char *, SyckIoStr *, long, long);
  
  enum syck_io_type {
      syck_io_str,
      syck_io_file
  };
  
  enum syck_parser_input {
      syck_yaml_utf8,
      syck_yaml_utf16,
      syck_yaml_utf32,
      syck_bytecode_utf8
  };
  
  enum syck_level_status {
      syck_lvl_header,
      syck_lvl_doc,
      syck_lvl_open,
      syck_lvl_seq,
      syck_lvl_map,
      syck_lvl_block,
      syck_lvl_str,
      syck_lvl_iseq,
      syck_lvl_imap,
      syck_lvl_end,
      syck_lvl_pause,
      syck_lvl_anctag,
      syck_lvl_mapx,
      syck_lvl_seqx
  };
  
  /*
   * Parser structs
   */
  struct _syck_file {
      /* File pointer */
      FILE *ptr;
      /* Function which FILE -> buffer */
      SyckIoFileRead read;
  };
  
  struct _syck_str {
      /* String buffer pointers */
      char *beg, *ptr, *end;
      /* Function which string -> buffer */
      SyckIoStrRead read;
  };
  
  struct _syck_level {
      /* Indent */
      int spaces;
      /* Counts nodes emitted at this level, useful for parsing 
       * keys and pairs in bytecode */
      int ncount;
      /* Does node have anchors or tags? */
      int anctag;
      /* Domain prefixing at the given level */
      char *domain;
      /* Keeps a node status */
      enum syck_level_status status;
  };
  
  struct _syck_parser {
      /* Root node */
      SYMID root, root_on_error;
      /* Implicit typing flag */
      int implicit_typing, taguri_expansion;
      /* Scripting language function to handle nodes */
      SyckNodeHandler handler;
      /* Error handler */
      SyckErrorHandler error_handler;
      /* InvalidAnchor handler */
      SyckBadAnchorHandler bad_anchor_handler;
      /* Parser input type */
      enum syck_parser_input input_type;
      /* IO type */
      enum syck_io_type io_type;
      /* Custom buffer size */
      size_t bufsize;
      /* Buffer pointers */
      char *buffer, *linectptr, *lineptr, *toktmp, *token, *cursor, *marker, *limit;
      /* Line counter */
      int linect;
      /* Last token from yylex() */
      int last_token;
      /* Force a token upon next call to yylex() */
      int force_token;
      /* EOF flag */
      int eof;
      union {
          SyckIoFile *file;
          SyckIoStr *str;
      } io;
      /* Symbol table for anchors */
      st_table *anchors, *bad_anchors;
      /* Optional symbol table for SYMIDs */
      st_table *syms;
      /* Levels of indentation */
      SyckLevel *levels;
      int lvl_idx;
      int lvl_capa;
      /* Pointer for extension's use */
      void *bonus;
  };
  
  /*
   * Emitter definitions
   */
  typedef struct _syck_emitter SyckEmitter;
  typedef struct _syck_emitter_node SyckEmitterNode;
  
  typedef void (*SyckOutputHandler)(SyckEmitter *, char *, long); 
  typedef void (*SyckEmitterHandler)(SyckEmitter *, st_data_t); 
  
  enum doc_stage {
      doc_open,
      doc_processing
  };
  
  /*
   * Emitter struct
   */
  struct _syck_emitter {
      /* Headerless doc flag */
      int headless;
      /* Force header? */
      int use_header;
      /* Force version? */
      int use_version;
      /* Sort hash keys */
      int sort_keys;
      /* Anchor format */
      char *anchor_format;
      /* Explicit typing on all collections? */
      int explicit_typing;
      /* Best width on folded scalars */
      int best_width;
      /* Use literal[1] or folded[2] blocks on all text? */
      enum scalar_style style;
      /* Stage of written document */
      enum doc_stage stage;
      /* Level counter */
      int level;
      /* Default indentation */
      int indent;
      /* Object ignore ID */
      SYMID ignore_id;
      /* Symbol table for anchors */
      st_table *markers, *anchors, *anchored;
      /* Custom buffer size */
      size_t bufsize;
      /* Buffer */
      char *buffer, *marker;
      /* Absolute position of the buffer */
      long bufpos;
      /* Handler for emitter nodes */
      SyckEmitterHandler emitter_handler;
      /* Handler for output */
      SyckOutputHandler output_handler;
      /* Levels of indentation */
      SyckLevel *levels;
      int lvl_idx;
      int lvl_capa;
      int max_depth;
      int depth;
      /* Pointer for extension's use */
      void *bonus;
  };
  
  /*
   * Emitter node metadata struct
   */
  struct _syck_emitter_node {
      /* Node buffer position */
      long pos;
      /* Current indent */
      long indent;
      /* Collection? */
      int is_shortcut;
  };
  
  /*
   * Handler prototypes
   */
  SYMID syck_hdlr_add_node( SyckParser *, SyckNode * );
  SyckNode *syck_hdlr_add_anchor( SyckParser *, char *, SyckNode * );
  void syck_hdlr_remove_anchor( SyckParser *, char * );
  SyckNode *syck_hdlr_get_anchor( SyckParser *, char * );
  void syck_add_transfer( char *, SyckNode *, int );
  char *syck_xprivate( char *, int );
  char *syck_taguri( const char *, const char *, int );
  int syck_tagcmp( const char *, const char * );
  int syck_add_sym( SyckParser *, char * );
  int syck_lookup_sym( SyckParser *, SYMID, char ** );
  int syck_try_implicit( SyckNode * );
  char *syck_type_id_to_uri( char * );
  void try_tag_implicit( SyckNode *, int );
  char *syck_match_implicit( char *, size_t );
  
  /*
   * API prototypes
   */
  char *syck_strndup( char *, long );
  int syck_str_is_unquotable_integer(char*, long);
  long syck_io_file_read( char *, SyckIoFile *, long, long );
  long syck_io_str_read( char *, SyckIoStr *, long, long );
  char *syck_base64enc( char *, long );
  char *syck_base64dec( char *, long, long * );
  SyckEmitter *syck_new_emitter( void );
  SYMID syck_emitter_mark_node( SyckEmitter *, st_data_t, int );
  void syck_emitter_ignore_id( SyckEmitter *, SYMID );
  void syck_output_handler( SyckEmitter *, SyckOutputHandler );
  void syck_emitter_handler( SyckEmitter *, SyckEmitterHandler );
  void syck_free_emitter( SyckEmitter * );
  void syck_emitter_clear( SyckEmitter * );
  void syck_emitter_write( SyckEmitter *, const char *, long );
  void syck_emitter_escape( SyckEmitter *, unsigned char *, long );
  void syck_emitter_flush( SyckEmitter *, long );
  void syck_emit( SyckEmitter *, st_data_t );
  void syck_emit_scalar( SyckEmitter *, char *, enum scalar_style, int, int, char, char *, long );
  void syck_emit_1quoted( SyckEmitter *, int, char *, long );
  void syck_emit_2quoted( SyckEmitter *, int, char *, long );
  void syck_emit_2quoted_1( SyckEmitter *, int, char *, long );
  void syck_emit_folded( SyckEmitter *, int, char, char *, long );
  void syck_emit_literal( SyckEmitter *, char, char *, long );
  void syck_emit_seq( SyckEmitter *, char *, enum seq_style );
  void syck_emit_item( SyckEmitter *, st_data_t );
  void syck_emit_map( SyckEmitter *, char *, enum map_style );
  void syck_emit_end( SyckEmitter * );
  void syck_emit_tag( SyckEmitter *, const char *, const char * );
  void syck_emit_indent( SyckEmitter * );
  SyckLevel *syck_emitter_current_level( SyckEmitter * );
  SyckLevel *syck_emitter_parent_level( SyckEmitter * );
  void syck_emitter_pop_level( SyckEmitter * );
  void syck_emitter_add_level( SyckEmitter *, int, enum syck_level_status );
  void syck_emitter_reset_levels( SyckEmitter * );
  SyckParser *syck_new_parser();
  void syck_free_parser( SyckParser * );
  void syck_parser_set_root_on_error( SyckParser *, SYMID );
  void syck_parser_implicit_typing( SyckParser *, int );
  void syck_parser_taguri_expansion( SyckParser *, int );
  int syck_scan_scalar( int, char *, long );
  void syck_parser_handler( SyckParser *, SyckNodeHandler );
  void syck_parser_error_handler( SyckParser *, SyckErrorHandler );
  void syck_parser_bad_anchor_handler( SyckParser *, SyckBadAnchorHandler );
  void syck_parser_file( SyckParser *, FILE *, SyckIoFileRead );
  void syck_parser_str( SyckParser *, char *, long, SyckIoStrRead );
  void syck_parser_str_auto( SyckParser *, char *, SyckIoStrRead );
  SyckLevel *syck_parser_current_level( SyckParser * );
  void syck_parser_add_level( SyckParser *, int, enum syck_level_status );
  void syck_parser_pop_level( SyckParser * );
  void free_any_io( SyckParser * );
  long syck_parser_read( SyckParser * );
  long syck_parser_readlen( SyckParser *, long );
  SYMID syck_parse( SyckParser * );
  void syck_default_error_handler( SyckParser *, char * );
  SYMID syck_yaml2byte_handler( SyckParser *, SyckNode * );
  char *syck_yaml2byte( char * );
  
  /*
   * Allocation prototypes
   */
  SyckNode *syck_alloc_map();
  SyckNode *syck_alloc_seq();
  SyckNode *syck_alloc_str();
  void syck_free_node( SyckNode * );
  void syck_free_members( SyckNode * );
  SyckNode *syck_new_str( const char *, enum scalar_style );
  SyckNode *syck_new_str2( const char *, long, enum scalar_style );
  void syck_replace_str( SyckNode *, char *, enum scalar_style );
  void syck_replace_str2( SyckNode *, char *, long, enum scalar_style );
  void syck_str_blow_away_commas( SyckNode * );
  char *syck_str_read( SyckNode * );
  SyckNode *syck_new_map( SYMID, SYMID );
  void syck_map_empty( SyckNode * );
  void syck_map_add( SyckNode *, SYMID, SYMID );
  SYMID syck_map_read( SyckNode *, enum map_part, long );
  void syck_map_assign( SyckNode *, enum map_part, long, SYMID );
  long syck_map_count( SyckNode * );
  void syck_map_update( SyckNode *, SyckNode * );
  SyckNode *syck_new_seq( SYMID );
  void syck_seq_empty( SyckNode * );
  void syck_seq_add( SyckNode *, SYMID );
  void syck_seq_assign( SyckNode *, long, SYMID );
  SYMID syck_seq_read( SyckNode *, long );
  long syck_seq_count( SyckNode * );
  
  /*
   * Lexer prototypes
   */
  void syckerror( char * );
  int syckparse( void * );
  
  #if defined(__cplusplus)
  }  /* extern "C" { */
  #endif
  
  #endif /* ifndef SYCK_H */
  