← Back to branch summary

~ubuntu-branches/ubuntu/hardy/ruby1.8/hardy-updates

« back to all changes in this revision

Viewing changes to ext/syck/syck.h

  • Committer: Bazaar Package Importer
  • Author(s): akira yamada
  • Date: 2007-03-13 22:11:58 UTC
  • mfrom: (1.1.5 upstream)
  • Revision ID: james.westby@ubuntu.com-20070313221158-h3oql37brlaf2go2
Tags: 1.8.6-1
http://bugs.debian.org/410018
* new upstream version, 1.8.6.
* libruby1.8 conflicts with libopenssl-ruby1.8 (< 1.8.6) (closes: #410018)
* changed packaging style to cdbs from dbs.

Show diffs side-by-side

added added

removed removed

Lines of Context:
ext/syck/syck.h
 
1
/*
 
2
 * syck.h
 
3
 *
 
4
 * $Author: shyouhei $
 
5
 * $Date: 2007-02-13 08:01:19 +0900 (Tue, 13 Feb 2007) $
 
6
 *
 
7
 * Copyright (C) 2003 why the lucky stiff
 
8
 */
 
9
 
 
10
#ifndef SYCK_H
 
11
#define SYCK_H
 
12
 
 
13
#define SYCK_YAML_MAJOR 1
 
14
#define SYCK_YAML_MINOR 0
 
15
 
 
16
#define SYCK_VERSION    "0.60"
 
17
#define YAML_DOMAIN     "yaml.org,2002"
 
18
 
 
19
#include <stdio.h>
 
20
#include <ctype.h>
 
21
#include "st.h"
 
22
 
 
23
#if defined(__cplusplus)
 
24
extern "C" {
 
25
#endif
 
26
 
 
27
/*
 
28
 * Memory Allocation
 
29
 */
 
30
#if defined(HAVE_ALLOCA_H) && !defined(__GNUC__)
 
31
#include <alloca.h>
 
32
#endif
 
33
 
 
34
#if DEBUG
 
35
  void syck_assert( char *, unsigned );
 
36
# define ASSERT(f) \
 
37
    if ( f ) \
 
38
        {}   \
 
39
    else     \
 
40
        syck_assert( __FILE__, __LINE__ )
 
41
#else
 
42
# define ASSERT(f)
 
43
#endif
 
44
 
 
45
#ifndef NULL
 
46
# define NULL (void *)0
 
47
#endif
 
48
 
 
49
#define ALLOC_CT 8
 
50
#define SYCK_BUFFERSIZE 4096
 
51
#define S_ALLOC_N(type,n) (type*)malloc(sizeof(type)*(n))
 
52
#define S_ALLOC(type) (type*)malloc(sizeof(type))
 
53
#define S_REALLOC_N(var,type,n) (var)=(type*)realloc((char*)(var),sizeof(type)*(n))
 
54
#define S_FREE(n) if (n) { free(n); n = NULL; }
 
55
 
 
56
#define S_ALLOCA_N(type,n) (type*)alloca(sizeof(type)*(n))
 
57
 
 
58
#define S_MEMZERO(p,type,n) memset((p), 0, sizeof(type)*(n))
 
59
#define S_MEMCPY(p1,p2,type,n) memcpy((p1), (p2), sizeof(type)*(n))
 
60
#define S_MEMMOVE(p1,p2,type,n) memmove((p1), (p2), sizeof(type)*(n))
 
61
#define S_MEMCMP(p1,p2,type,n) memcmp((p1), (p2), sizeof(type)*(n))
 
62
 
 
63
#define BLOCK_FOLD  10
 
64
#define BLOCK_LIT   20
 
65
#define BLOCK_PLAIN 30
 
66
#define NL_CHOMP    40
 
67
#define NL_KEEP     50
 
68
 
 
69
/*
 
70
 * Node definitions
 
71
 */
 
72
#ifndef ST_DATA_T_DEFINED
 
73
typedef long st_data_t;
 
74
#endif
 
75
 
 
76
#define SYMID unsigned long
 
77
 
 
78
typedef struct _syck_node SyckNode;
 
79
 
 
80
enum syck_kind_tag {
 
81
    syck_map_kind,
 
82
    syck_seq_kind,
 
83
    syck_str_kind
 
84
};
 
85
 
 
86
enum map_part {
 
87
    map_key,
 
88
    map_value
 
89
};
 
90
 
 
91
enum map_style {
 
92
    map_none,
 
93
    map_inline
 
94
};
 
95
 
 
96
enum seq_style {
 
97
    seq_none,
 
98
    seq_inline
 
99
};
 
100
 
 
101
enum scalar_style {
 
102
    scalar_none,
 
103
    scalar_1quote,
 
104
    scalar_2quote,
 
105
    scalar_fold,
 
106
    scalar_literal,
 
107
    scalar_plain
 
108
};
 
109
 
 
110
/*
 
111
 * Node metadata struct
 
112
 */
 
113
struct _syck_node {
 
114
    /* Symbol table ID */
 
115
    SYMID id;
 
116
    /* Underlying kind */
 
117
    enum syck_kind_tag kind;
 
118
    /* Fully qualified tag-uri for type */
 
119
    char *type_id;
 
120
    /* Anchor name */
 
121
    char *anchor;
 
122
    union {
 
123
        /* Storage for map data */
 
124
        struct SyckMap {
 
125
            enum map_style style;
 
126
            SYMID *keys;
 
127
            SYMID *values;
 
128
            long capa;
 
129
            long idx;
 
130
        } *pairs;
 
131
        /* Storage for sequence data */
 
132
        struct SyckSeq {
 
133
            enum seq_style style;
 
134
            SYMID *items;
 
135
            long capa;
 
136
            long idx;
 
137
        } *list;
 
138
        /* Storage for string data */
 
139
        struct SyckStr {
 
140
            enum scalar_style style;
 
141
            char *ptr;
 
142
            long len;
 
143
        } *str;
 
144
    } data;
 
145
    /* Shortcut node */
 
146
    void *shortcut;
 
147
};
 
148
 
 
149
/*
 
150
 * Parser definitions
 
151
 */
 
152
typedef struct _syck_parser SyckParser;
 
153
typedef struct _syck_file SyckIoFile;
 
154
typedef struct _syck_str SyckIoStr;
 
155
typedef struct _syck_level SyckLevel;
 
156
 
 
157
typedef SYMID (*SyckNodeHandler)(SyckParser *, SyckNode *);
 
158
typedef void (*SyckErrorHandler)(SyckParser *, char *);
 
159
typedef SyckNode * (*SyckBadAnchorHandler)(SyckParser *, char *);
 
160
typedef long (*SyckIoFileRead)(char *, SyckIoFile *, long, long); 
 
161
typedef long (*SyckIoStrRead)(char *, SyckIoStr *, long, long);
 
162
 
 
163
enum syck_io_type {
 
164
    syck_io_str,
 
165
    syck_io_file
 
166
};
 
167
 
 
168
enum syck_parser_input {
 
169
    syck_yaml_utf8,
 
170
    syck_yaml_utf16,
 
171
    syck_yaml_utf32,
 
172
    syck_bytecode_utf8
 
173
};
 
174
 
 
175
enum syck_level_status {
 
176
    syck_lvl_header,
 
177
    syck_lvl_doc,
 
178
    syck_lvl_open,
 
179
    syck_lvl_seq,
 
180
    syck_lvl_map,
 
181
    syck_lvl_block,
 
182
    syck_lvl_str,
 
183
    syck_lvl_iseq,
 
184
    syck_lvl_imap,
 
185
    syck_lvl_end,
 
186
    syck_lvl_pause,
 
187
    syck_lvl_anctag,
 
188
    syck_lvl_mapx,
 
189
    syck_lvl_seqx
 
190
};
 
191
 
 
192
/*
 
193
 * Parser structs
 
194
 */
 
195
struct _syck_file {
 
196
    /* File pointer */
 
197
    FILE *ptr;
 
198
    /* Function which FILE -> buffer */
 
199
    SyckIoFileRead read;
 
200
};
 
201
 
 
202
struct _syck_str {
 
203
    /* String buffer pointers */
 
204
    char *beg, *ptr, *end;
 
205
    /* Function which string -> buffer */
 
206
    SyckIoStrRead read;
 
207
};
 
208
 
 
209
struct _syck_level {
 
210
    /* Indent */
 
211
    int spaces;
 
212
    /* Counts nodes emitted at this level, useful for parsing 
 
213
     * keys and pairs in bytecode */
 
214
    int ncount;
 
215
    /* Does node have anchors or tags? */
 
216
    int anctag;
 
217
    /* Domain prefixing at the given level */
 
218
    char *domain;
 
219
    /* Keeps a node status */
 
220
    enum syck_level_status status;
 
221
};
 
222
 
 
223
struct _syck_parser {
 
224
    /* Root node */
 
225
    SYMID root, root_on_error;
 
226
    /* Implicit typing flag */
 
227
    int implicit_typing, taguri_expansion;
 
228
    /* Scripting language function to handle nodes */
 
229
    SyckNodeHandler handler;
 
230
    /* Error handler */
 
231
    SyckErrorHandler error_handler;
 
232
    /* InvalidAnchor handler */
 
233
    SyckBadAnchorHandler bad_anchor_handler;
 
234
    /* Parser input type */
 
235
    enum syck_parser_input input_type;
 
236
    /* IO type */
 
237
    enum syck_io_type io_type;
 
238
    /* Custom buffer size */
 
239
    size_t bufsize;
 
240
    /* Buffer pointers */
 
241
    char *buffer, *linectptr, *lineptr, *toktmp, *token, *cursor, *marker, *limit;
 
242
    /* Line counter */
 
243
    int linect;
 
244
    /* Last token from yylex() */
 
245
    int last_token;
 
246
    /* Force a token upon next call to yylex() */
 
247
    int force_token;
 
248
    /* EOF flag */
 
249
    int eof;
 
250
    union {
 
251
        SyckIoFile *file;
 
252
        SyckIoStr *str;
 
253
    } io;
 
254
    /* Symbol table for anchors */
 
255
    st_table *anchors, *bad_anchors;
 
256
    /* Optional symbol table for SYMIDs */
 
257
    st_table *syms;
 
258
    /* Levels of indentation */
 
259
    SyckLevel *levels;
 
260
    int lvl_idx;
 
261
    int lvl_capa;
 
262
    /* Pointer for extension's use */
 
263
    void *bonus;
 
264
};
 
265
 
 
266
/*
 
267
 * Emitter definitions
 
268
 */
 
269
typedef struct _syck_emitter SyckEmitter;
 
270
typedef struct _syck_emitter_node SyckEmitterNode;
 
271
 
 
272
typedef void (*SyckOutputHandler)(SyckEmitter *, char *, long); 
 
273
typedef void (*SyckEmitterHandler)(SyckEmitter *, st_data_t); 
 
274
 
 
275
enum doc_stage {
 
276
    doc_open,
 
277
    doc_processing
 
278
};
 
279
 
 
280
/*
 
281
 * Emitter struct
 
282
 */
 
283
struct _syck_emitter {
 
284
    /* Headerless doc flag */
 
285
    int headless;
 
286
    /* Force header? */
 
287
    int use_header;
 
288
    /* Force version? */
 
289
    int use_version;
 
290
    /* Sort hash keys */
 
291
    int sort_keys;
 
292
    /* Anchor format */
 
293
    char *anchor_format;
 
294
    /* Explicit typing on all collections? */
 
295
    int explicit_typing;
 
296
    /* Best width on folded scalars */
 
297
    int best_width;
 
298
    /* Use literal[1] or folded[2] blocks on all text? */
 
299
    enum scalar_style style;
 
300
    /* Stage of written document */
 
301
    enum doc_stage stage;
 
302
    /* Level counter */
 
303
    int level;
 
304
    /* Default indentation */
 
305
    int indent;
 
306
    /* Object ignore ID */
 
307
    SYMID ignore_id;
 
308
    /* Symbol table for anchors */
 
309
    st_table *markers, *anchors, *anchored;
 
310
    /* Custom buffer size */
 
311
    size_t bufsize;
 
312
    /* Buffer */
 
313
    char *buffer, *marker;
 
314
    /* Absolute position of the buffer */
 
315
    long bufpos;
 
316
    /* Handler for emitter nodes */
 
317
    SyckEmitterHandler emitter_handler;
 
318
    /* Handler for output */
 
319
    SyckOutputHandler output_handler;
 
320
    /* Levels of indentation */
 
321
    SyckLevel *levels;
 
322
    int lvl_idx;
 
323
    int lvl_capa;
 
324
    /* Pointer for extension's use */
 
325
    void *bonus;
 
326
};
 
327
 
 
328
/*
 
329
 * Emitter node metadata struct
 
330
 */
 
331
struct _syck_emitter_node {
 
332
    /* Node buffer position */
 
333
    long pos;
 
334
    /* Current indent */
 
335
    long indent;
 
336
    /* Collection? */
 
337
    int is_shortcut;
 
338
};
 
339
 
 
340
/*
 
341
 * Handler prototypes
 
342
 */
 
343
SYMID syck_hdlr_add_node( SyckParser *, SyckNode * );
 
344
SyckNode *syck_hdlr_add_anchor( SyckParser *, char *, SyckNode * );
 
345
void syck_hdlr_remove_anchor( SyckParser *, char * );
 
346
SyckNode *syck_hdlr_get_anchor( SyckParser *, char * );
 
347
void syck_add_transfer( char *, SyckNode *, int );
 
348
char *syck_xprivate( char *, int );
 
349
char *syck_taguri( char *, char *, int );
 
350
int syck_tagcmp( char *, char * );
 
351
int syck_add_sym( SyckParser *, char * );
 
352
int syck_lookup_sym( SyckParser *, SYMID, char ** );
 
353
int syck_try_implicit( SyckNode * );
 
354
char *syck_type_id_to_uri( char * );
 
355
void try_tag_implicit( SyckNode *, int );
 
356
char *syck_match_implicit( char *, size_t );
 
357
 
 
358
/*
 
359
 * API prototypes
 
360
 */
 
361
char *syck_strndup( char *, long );
 
362
long syck_io_file_read( char *, SyckIoFile *, long, long );
 
363
long syck_io_str_read( char *, SyckIoStr *, long, long );
 
364
char *syck_base64enc( char *, long );
 
365
char *syck_base64dec( char *, long );
 
366
SyckEmitter *syck_new_emitter();
 
367
SYMID syck_emitter_mark_node( SyckEmitter *, st_data_t );
 
368
void syck_emitter_ignore_id( SyckEmitter *, SYMID );
 
369
void syck_output_handler( SyckEmitter *, SyckOutputHandler );
 
370
void syck_emitter_handler( SyckEmitter *, SyckEmitterHandler );
 
371
void syck_free_emitter( SyckEmitter * );
 
372
void syck_emitter_clear( SyckEmitter * );
 
373
void syck_emitter_write( SyckEmitter *, char *, long );
 
374
void syck_emitter_escape( SyckEmitter *, char *, long );
 
375
void syck_emitter_flush( SyckEmitter *, long );
 
376
void syck_emit( SyckEmitter *, st_data_t );
 
377
void syck_emit_scalar( SyckEmitter *, char *, enum scalar_style, int, int, char, char *, long );
 
378
void syck_emit_1quoted( SyckEmitter *, int, char *, long );
 
379
void syck_emit_2quoted( SyckEmitter *, int, char *, long );
 
380
void syck_emit_folded( SyckEmitter *, int, char, char *, long );
 
381
void syck_emit_literal( SyckEmitter *, char, char *, long );
 
382
void syck_emit_seq( SyckEmitter *, char *, enum seq_style );
 
383
void syck_emit_item( SyckEmitter *, st_data_t );
 
384
void syck_emit_map( SyckEmitter *, char *, enum map_style );
 
385
void syck_emit_end( SyckEmitter * );
 
386
void syck_emit_tag( SyckEmitter *, char *, char * );
 
387
void syck_emit_indent( SyckEmitter * );
 
388
SyckLevel *syck_emitter_current_level( SyckEmitter * );
 
389
SyckLevel *syck_emitter_parent_level( SyckEmitter * );
 
390
void syck_emitter_pop_level( SyckEmitter * );
 
391
void syck_emitter_add_level( SyckEmitter *, int, enum syck_level_status );
 
392
void syck_emitter_reset_levels( SyckEmitter * );
 
393
SyckParser *syck_new_parser();
 
394
void syck_free_parser( SyckParser * );
 
395
void syck_parser_set_root_on_error( SyckParser *, SYMID );
 
396
void syck_parser_implicit_typing( SyckParser *, int );
 
397
void syck_parser_taguri_expansion( SyckParser *, int );
 
398
int syck_scan_scalar( int, char *, long );
 
399
void syck_parser_handler( SyckParser *, SyckNodeHandler );
 
400
void syck_parser_error_handler( SyckParser *, SyckErrorHandler );
 
401
void syck_parser_bad_anchor_handler( SyckParser *, SyckBadAnchorHandler );
 
402
void syck_parser_file( SyckParser *, FILE *, SyckIoFileRead );
 
403
void syck_parser_str( SyckParser *, char *, long, SyckIoStrRead );
 
404
void syck_parser_str_auto( SyckParser *, char *, SyckIoStrRead );
 
405
SyckLevel *syck_parser_current_level( SyckParser * );
 
406
void syck_parser_add_level( SyckParser *, int, enum syck_level_status );
 
407
void syck_parser_pop_level( SyckParser * );
 
408
void free_any_io( SyckParser * );
 
409
long syck_parser_read( SyckParser * );
 
410
long syck_parser_readlen( SyckParser *, long );
 
411
SYMID syck_parse( SyckParser * );
 
412
void syck_default_error_handler( SyckParser *, char * );
 
413
SYMID syck_yaml2byte_handler( SyckParser *, SyckNode * );
 
414
char *syck_yaml2byte( char * );
 
415
 
 
416
/*
 
417
 * Allocation prototypes
 
418
 */
 
419
SyckNode *syck_alloc_map();
 
420
SyckNode *syck_alloc_seq();
 
421
SyckNode *syck_alloc_str();
 
422
void syck_free_node( SyckNode * );
 
423
void syck_free_members( SyckNode * );
 
424
SyckNode *syck_new_str( char *, enum scalar_style );
 
425
SyckNode *syck_new_str2( char *, long, enum scalar_style );
 
426
void syck_replace_str( SyckNode *, char *, enum scalar_style );
 
427
void syck_replace_str2( SyckNode *, char *, long, enum scalar_style );
 
428
void syck_str_blow_away_commas( SyckNode * );
 
429
char *syck_str_read( SyckNode * );
 
430
SyckNode *syck_new_map( SYMID, SYMID );
 
431
void syck_map_empty( SyckNode * );
 
432
void syck_map_add( SyckNode *, SYMID, SYMID );
 
433
SYMID syck_map_read( SyckNode *, enum map_part, long );
 
434
void syck_map_assign( SyckNode *, enum map_part, long, SYMID );
 
435
long syck_map_count( SyckNode * );
 
436
void syck_map_update( SyckNode *, SyckNode * );
 
437
SyckNode *syck_new_seq( SYMID );
 
438
void syck_seq_empty( SyckNode * );
 
439
void syck_seq_add( SyckNode *, SYMID );
 
440
void syck_seq_assign( SyckNode *, long, SYMID );
 
441
SYMID syck_seq_read( SyckNode *, long );
 
442
long syck_seq_count( SyckNode * );
 
443
 
 
444
/*
 
445
 * Lexer prototypes
 
446
 */
 
447
void syckerror( char * );
 
448
int syckparse( void * );
 
449
union YYSTYPE;
 
450
int sycklex( union YYSTYPE *, SyckParser * );
 
451
 
 
452
#if defined(__cplusplus)
 
453
}  /* extern "C" { */
 
454
#endif
 
455
 
 
456
#endif /* ifndef SYCK_H */