Ruby  1.9.3p551(2014-11-13revision48407)
syck.h
Go to the documentation of this file.
1 /*
2  * syck.h
3  *
4  * $Author: naruse $
5  *
6  * Copyright (C) 2003 why the lucky stiff
7  */
8 
9 #ifndef SYCK_H
10 #define SYCK_H
11 
12 #define SYCK_YAML_MAJOR 1
13 #define SYCK_YAML_MINOR 0
14 
15 #define YAML_DOMAIN "yaml.org,2002"
16 
17 #include <stdio.h>
18 #include <stdlib.h>
19 #include <ctype.h>
20 #include "ruby/st.h"
21 
22 #if defined(__cplusplus)
23 extern "C" {
24 #endif
25 
26 /*
27  * Memory Allocation
28  */
29 #if defined(HAVE_ALLOCA_H) && !defined(__GNUC__)
30 #include <alloca.h>
31 #endif
32 
33 #ifdef DEBUG
34 void syck_assert( const char *, unsigned, const char * );
35 # define ASSERT(f) \
36  (( f ) ? (void)0 : syck_assert( __FILE__, __LINE__, #f ))
37 #else
38 # define ASSERT(f) ((void)0)
39 #endif
40 
41 #ifndef NULL
42 # define NULL (void *)0
43 #endif
44 
45 #define ALLOC_CT 8
46 #define SYCK_BUFFERSIZE 4096
47 #define S_ALLOC_N(type,n) (type*)malloc(sizeof(type)*(n))
48 #define S_ALLOC(type) (type*)malloc(sizeof(type))
49 #define S_REALLOC_N(var,type,n) (var)=(type*)realloc((char*)(var),sizeof(type)*(n))
50 #define S_FREE(n) if (n) { free(n); n = NULL; }
51 
52 #define S_ALLOCA_N(type,n) (type*)alloca(sizeof(type)*(n))
53 
54 #define S_MEMZERO(p,type,n) memset((p), 0, sizeof(type)*(n))
55 #define S_MEMCPY(p1,p2,type,n) memcpy((p1), (p2), sizeof(type)*(n))
56 #define S_MEMMOVE(p1,p2,type,n) memmove((p1), (p2), sizeof(type)*(n))
57 #define S_MEMCMP(p1,p2,type,n) memcmp((p1), (p2), sizeof(type)*(n))
58 
59 #define BLOCK_FOLD 10
60 #define BLOCK_LIT 20
61 #define BLOCK_PLAIN 30
62 #define NL_CHOMP 40
63 #define NL_KEEP 50
64 
65 /*
66  * Node definitions
67  */
68 #ifndef ST_DATA_T_DEFINED
69 typedef long st_data_t;
70 #endif
71 
72 #define SYMID st_data_t
73 
74 typedef struct _syck_node SyckNode;
75 
80 };
81 
82 enum map_part {
85 };
86 
87 enum map_style {
90 };
91 
92 enum seq_style {
95 };
96 
104 };
105 
106 /*
107  * Node metadata struct
108  */
109 struct _syck_node {
110  /* Symbol table ID */
112  /* Underlying kind */
114  /* Fully qualified tag-uri for type */
115  char *type_id;
116  /* Anchor name */
117  char *anchor;
118  union {
119  /* Storage for map data */
120  struct SyckMap {
124  long capa;
125  long idx;
126  } *pairs;
127  /* Storage for sequence data */
128  struct SyckSeq {
131  long capa;
132  long idx;
133  } *list;
134  /* Storage for string data */
135  struct SyckStr {
137  char *ptr;
138  long len;
139  } *str;
140  } data;
141  /* Shortcut node */
142  void *shortcut;
143 };
144 
145 /*
146  * Parser definitions
147  */
148 typedef struct _syck_parser SyckParser;
149 typedef struct _syck_file SyckIoFile;
150 typedef struct _syck_str SyckIoStr;
151 typedef struct _syck_level SyckLevel;
152 
154 typedef void (*SyckErrorHandler)(SyckParser *, const char *);
155 typedef SyckNode * (*SyckBadAnchorHandler)(SyckParser *, char *);
156 typedef long (*SyckIoFileRead)(char *, SyckIoFile *, long, long);
157 typedef long (*SyckIoStrRead)(char *, SyckIoStr *, long, long);
158 
162 };
163 
169 };
170 
186 };
187 
188 /*
189  * Parser structs
190  */
191 struct _syck_file {
192  /* File pointer */
194  /* Function which FILE -> buffer */
196 };
197 
198 struct _syck_str {
199  /* String buffer pointers */
200  char *beg, *ptr, *end;
201  /* Function which string -> buffer */
203 };
204 
205 struct _syck_level {
206  /* Indent */
207  int spaces;
208  /* Counts nodes emitted at this level, useful for parsing
209  * keys and pairs in bytecode */
210  int ncount;
211  /* Does node have anchors or tags? */
212  int anctag;
213  /* Domain prefixing at the given level */
214  char *domain;
215  /* Keeps a node status */
217 };
218 
219 struct _syck_parser {
220  /* Root node */
222  /* Implicit typing flag */
224  /* Scripting language function to handle nodes */
226  /* Error handler */
228  /* InvalidAnchor handler */
230  /* Parser input type */
232  /* IO type */
234  /* Custom buffer size */
235  size_t bufsize;
236  /* Buffer pointers */
238  /* Line counter */
239  int linect;
240  /* Last token from yylex() */
242  /* Force a token upon next call to yylex() */
244  /* EOF flag */
245  int eof;
246  union {
247  SyckIoFile *file;
248  SyckIoStr *str;
249  } io;
250  /* Symbol table for anchors */
252  /* Optional symbol table for SYMIDs */
254  /* Levels of indentation */
256  int lvl_idx;
257  int lvl_capa;
258  /* Pointer for extension's use */
259  void *bonus;
260 };
261 
262 /*
263  * Emitter definitions
264  */
265 typedef struct _syck_emitter SyckEmitter;
267 
268 typedef void (*SyckOutputHandler)(SyckEmitter *, char *, long);
269 typedef void (*SyckEmitterHandler)(SyckEmitter *, st_data_t);
270 
271 enum doc_stage {
274 };
275 
276 /*
277  * Emitter struct
278  */
280  /* Headerless doc flag */
281  int headless;
282  /* Force header? */
284  /* Force version? */
286  /* Sort hash keys */
288  /* Anchor format */
290  /* Explicit typing on all collections? */
292  /* Best width on folded scalars */
294  /* Use literal[1] or folded[2] blocks on all text? */
296  /* Stage of written document */
298  /* Level counter */
299  int level;
300  /* Default indentation */
301  int indent;
302  /* Object ignore ID */
304  /* Symbol table for anchors */
306  /* Custom buffer size */
307  size_t bufsize;
308  /* Buffer */
309  char *buffer, *marker;
310  /* Absolute position of the buffer */
311  long bufpos;
312  /* Handler for emitter nodes */
314  /* Handler for output */
316  /* Levels of indentation */
318  int lvl_idx;
319  int lvl_capa;
320  /* Pointer for extension's use */
321  void *bonus;
322 };
323 
324 /*
325  * Emitter node metadata struct
326  */
328  /* Node buffer position */
329  long pos;
330  /* Current indent */
331  long indent;
332  /* Collection? */
334 };
335 
336 /*
337  * Handler prototypes
338  */
339 SYMID syck_hdlr_add_node( SyckParser *, SyckNode * );
340 SyckNode *syck_hdlr_add_anchor( SyckParser *, char *, SyckNode * );
341 void syck_hdlr_remove_anchor( SyckParser *, char * );
342 SyckNode *syck_hdlr_get_anchor( SyckParser *, char * );
343 void syck_add_transfer( char *, SyckNode *, int );
344 char *syck_xprivate( const char *, int );
345 char *syck_taguri( const char *, const char *, int );
346 int syck_tagcmp( const char *, const char * );
347 int syck_add_sym( SyckParser *, void * );
348 int syck_lookup_sym( SyckParser *, SYMID, void ** );
349 int syck_try_implicit( SyckNode * );
350 char *syck_type_id_to_uri( const char * );
351 void try_tag_implicit( SyckNode *, int );
352 const char *syck_match_implicit( const char *, size_t );
353 
354 /*
355  * API prototypes
356  */
357 char *syck_strndup( const char *, long );
358 long syck_io_file_read( char *, SyckIoFile *, long, long );
359 long syck_io_str_read( char *, SyckIoStr *, long, long );
360 char *syck_base64enc( char *, long );
361 char *syck_base64dec( char *, long );
362 SyckEmitter *syck_new_emitter(void);
363 SYMID syck_emitter_mark_node( SyckEmitter *, st_data_t );
364 void syck_emitter_ignore_id( SyckEmitter *, SYMID );
365 void syck_output_handler( SyckEmitter *, SyckOutputHandler );
366 void syck_emitter_handler( SyckEmitter *, SyckEmitterHandler );
367 void syck_free_emitter( SyckEmitter * );
368 void syck_emitter_clear( SyckEmitter * );
369 void syck_emitter_write( SyckEmitter *, const char *, long );
370 void syck_emitter_escape( SyckEmitter *, const char *, long );
371 void syck_emitter_flush( SyckEmitter *, long );
372 void syck_emit( SyckEmitter *, st_data_t );
373 void syck_emit_scalar( SyckEmitter *, const char *, enum scalar_style, int, int, char, const char *, long );
374 void syck_emit_1quoted( SyckEmitter *, int, const char *, long );
375 void syck_emit_2quoted( SyckEmitter *, int, const char *, long );
376 void syck_emit_folded( SyckEmitter *, int, char, const char *, long );
377 void syck_emit_literal( SyckEmitter *, char, const char *, long );
378 void syck_emit_seq( SyckEmitter *, const char *, enum seq_style );
379 void syck_emit_item( SyckEmitter *, st_data_t );
380 void syck_emit_map( SyckEmitter *, const char *, enum map_style );
381 void syck_emit_end( SyckEmitter * );
382 void syck_emit_tag( SyckEmitter *, const char *, const char * );
383 void syck_emit_indent( SyckEmitter * );
384 SyckLevel *syck_emitter_current_level( SyckEmitter * );
385 SyckLevel *syck_emitter_parent_level( SyckEmitter * );
386 void syck_emitter_pop_level( SyckEmitter * );
387 void syck_emitter_add_level( SyckEmitter *, int, enum syck_level_status );
388 void syck_emitter_reset_levels( SyckEmitter * );
389 SyckParser *syck_new_parser(void);
390 void syck_free_parser( SyckParser * );
391 void syck_parser_set_root_on_error( SyckParser *, SYMID );
392 void syck_parser_implicit_typing( SyckParser *, int );
393 void syck_parser_taguri_expansion( SyckParser *, int );
394 int syck_scan_scalar( int, const char *, long );
395 void syck_parser_handler( SyckParser *, SyckNodeHandler );
396 void syck_parser_error_handler( SyckParser *, SyckErrorHandler );
398 void syck_parser_set_input_type( SyckParser *, enum syck_parser_input );
399 void syck_parser_file( SyckParser *, FILE *, SyckIoFileRead );
400 void syck_parser_str( SyckParser *, char *, long, SyckIoStrRead );
401 void syck_parser_str_auto( SyckParser *, char *, SyckIoStrRead );
402 SyckLevel *syck_parser_current_level( SyckParser * );
403 void syck_parser_add_level( SyckParser *, int, enum syck_level_status );
404 void syck_parser_pop_level( SyckParser * );
405 void free_any_io( SyckParser * );
406 long syck_parser_read( SyckParser * );
407 long syck_parser_readlen( SyckParser *, long );
408 SYMID syck_parse( SyckParser * );
409 void syck_default_error_handler( SyckParser *, const char * );
410 SYMID syck_yaml2byte_handler( SyckParser *, SyckNode * );
411 char *syck_yaml2byte( char * );
412 
413 /*
414  * Allocation prototypes
415  */
416 SyckNode *syck_alloc_map(void);
417 SyckNode *syck_alloc_seq(void);
418 SyckNode *syck_alloc_str(void);
419 void syck_free_node( SyckNode * );
420 void syck_free_members( SyckNode * );
421 SyckNode *syck_new_str( const char *, enum scalar_style );
422 SyckNode *syck_new_str2( const char *, long, enum scalar_style );
423 void syck_replace_str( SyckNode *, char *, enum scalar_style );
424 void syck_replace_str2( SyckNode *, char *, long, enum scalar_style );
426 char *syck_str_read( SyckNode * );
428 void syck_map_empty( SyckNode * );
429 void syck_map_add( SyckNode *, SYMID, SYMID );
430 SYMID syck_map_read( SyckNode *, enum map_part, long );
431 void syck_map_assign( SyckNode *, enum map_part, long, SYMID );
432 long syck_map_count( SyckNode * );
433 void syck_map_update( SyckNode *, SyckNode * );
435 void syck_seq_empty( SyckNode * );
436 void syck_seq_add( SyckNode *, SYMID );
437 void syck_seq_assign( SyckNode *, long, SYMID );
438 SYMID syck_seq_read( SyckNode *, long );
439 long syck_seq_count( SyckNode * );
440 
441 /*
442  * Lexer prototypes
443  */
444 void syckerror( const char * );
445 int syckparse( void * );
446 union YYSTYPE;
447 int sycklex( union YYSTYPE *, SyckParser * );
448 
449 #if defined(__cplusplus)
450 } /* extern "C" { */
451 #endif
452 
453 #endif /* ifndef SYCK_H */
454