rubysl-syck 1.0.1
Sign up to get free protection for your applications and to get access to all the features.
- checksums.yaml +7 -0
- data/.gitignore +17 -0
- data/Gemfile +4 -0
- data/LICENSE +25 -0
- data/README.md +29 -0
- data/Rakefile +1 -0
- data/ext/rubysl/syck/bytecode.c +1166 -0
- data/ext/rubysl/syck/emitter.c +1242 -0
- data/ext/rubysl/syck/extconf.rb +5 -0
- data/ext/rubysl/syck/gram.c +1894 -0
- data/ext/rubysl/syck/gram.h +79 -0
- data/ext/rubysl/syck/handler.c +174 -0
- data/ext/rubysl/syck/implicit.c +2990 -0
- data/ext/rubysl/syck/node.c +408 -0
- data/ext/rubysl/syck/rubyext.c +2366 -0
- data/ext/rubysl/syck/st.c +576 -0
- data/ext/rubysl/syck/st.h +72 -0
- data/ext/rubysl/syck/syck.c +504 -0
- data/ext/rubysl/syck/syck.h +458 -0
- data/ext/rubysl/syck/token.c +2725 -0
- data/ext/rubysl/syck/yaml2byte.c +257 -0
- data/ext/rubysl/syck/yamlbyte.h +170 -0
- data/lib/rubysl/syck/version.rb +5 -0
- data/lib/rubysl/syck.rb +7 -0
- data/rubysl-syck.gemspec +22 -0
- metadata +97 -0
@@ -0,0 +1,408 @@
|
|
1
|
+
/*
|
2
|
+
* node.c
|
3
|
+
*
|
4
|
+
* $Author: shyouhei $
|
5
|
+
* $Date: 2007-02-12 15:01:19 -0800 (Mon, 12 Feb 2007) $
|
6
|
+
*
|
7
|
+
* Copyright (C) 2003 why the lucky stiff
|
8
|
+
*/
|
9
|
+
|
10
|
+
#include "ruby.h"
|
11
|
+
#include "syck.h"
|
12
|
+
|
13
|
+
/*
|
14
|
+
* Node allocation functions
|
15
|
+
*/
|
16
|
+
SyckNode *
|
17
|
+
syck_alloc_node( enum syck_kind_tag type )
|
18
|
+
{
|
19
|
+
SyckNode *s;
|
20
|
+
|
21
|
+
s = S_ALLOC( SyckNode );
|
22
|
+
s->kind = type;
|
23
|
+
s->id = 0;
|
24
|
+
s->type_id = NULL;
|
25
|
+
s->anchor = NULL;
|
26
|
+
s->shortcut = NULL;
|
27
|
+
|
28
|
+
return s;
|
29
|
+
}
|
30
|
+
|
31
|
+
void
|
32
|
+
syck_free_node( SyckNode *n )
|
33
|
+
{
|
34
|
+
syck_free_members( n );
|
35
|
+
if ( n->type_id != NULL )
|
36
|
+
{
|
37
|
+
S_FREE( n->type_id );
|
38
|
+
n->type_id = NULL;
|
39
|
+
}
|
40
|
+
if ( n->anchor != NULL )
|
41
|
+
{
|
42
|
+
S_FREE( n->anchor );
|
43
|
+
n->anchor = NULL;
|
44
|
+
}
|
45
|
+
S_FREE( n );
|
46
|
+
}
|
47
|
+
|
48
|
+
SyckNode *
|
49
|
+
syck_alloc_map()
|
50
|
+
{
|
51
|
+
SyckNode *n;
|
52
|
+
struct SyckMap *m;
|
53
|
+
|
54
|
+
m = S_ALLOC( struct SyckMap );
|
55
|
+
m->style = map_none;
|
56
|
+
m->idx = 0;
|
57
|
+
m->capa = ALLOC_CT;
|
58
|
+
m->keys = S_ALLOC_N( SYMID, m->capa );
|
59
|
+
m->values = S_ALLOC_N( SYMID, m->capa );
|
60
|
+
|
61
|
+
n = syck_alloc_node( syck_map_kind );
|
62
|
+
n->data.pairs = m;
|
63
|
+
|
64
|
+
return n;
|
65
|
+
}
|
66
|
+
|
67
|
+
SyckNode *
|
68
|
+
syck_alloc_seq()
|
69
|
+
{
|
70
|
+
SyckNode *n;
|
71
|
+
struct SyckSeq *s;
|
72
|
+
|
73
|
+
s = S_ALLOC( struct SyckSeq );
|
74
|
+
s->style = seq_none;
|
75
|
+
s->idx = 0;
|
76
|
+
s->capa = ALLOC_CT;
|
77
|
+
s->items = S_ALLOC_N( SYMID, s->capa );
|
78
|
+
|
79
|
+
n = syck_alloc_node( syck_seq_kind );
|
80
|
+
n->data.list = s;
|
81
|
+
|
82
|
+
return n;
|
83
|
+
}
|
84
|
+
|
85
|
+
SyckNode *
|
86
|
+
syck_alloc_str()
|
87
|
+
{
|
88
|
+
SyckNode *n;
|
89
|
+
struct SyckStr *s;
|
90
|
+
|
91
|
+
s = S_ALLOC( struct SyckStr );
|
92
|
+
s->len = 0;
|
93
|
+
s->ptr = NULL;
|
94
|
+
s->style = scalar_none;
|
95
|
+
|
96
|
+
n = syck_alloc_node( syck_str_kind );
|
97
|
+
n->data.str = s;
|
98
|
+
|
99
|
+
return n;
|
100
|
+
}
|
101
|
+
|
102
|
+
SyckNode *
|
103
|
+
syck_new_str( char *str, enum scalar_style style )
|
104
|
+
{
|
105
|
+
return syck_new_str2( str, strlen( str ), style );
|
106
|
+
}
|
107
|
+
|
108
|
+
SyckNode *
|
109
|
+
syck_new_str2( char *str, long len, enum scalar_style style )
|
110
|
+
{
|
111
|
+
SyckNode *n;
|
112
|
+
|
113
|
+
n = syck_alloc_str();
|
114
|
+
n->data.str->ptr = S_ALLOC_N( char, len + 1 );
|
115
|
+
n->data.str->len = len;
|
116
|
+
n->data.str->style = style;
|
117
|
+
memcpy( n->data.str->ptr, str, len );
|
118
|
+
n->data.str->ptr[len] = '\0';
|
119
|
+
|
120
|
+
return n;
|
121
|
+
}
|
122
|
+
|
123
|
+
void
|
124
|
+
syck_replace_str( SyckNode *n, char *str, enum scalar_style style )
|
125
|
+
{
|
126
|
+
syck_replace_str2( n, str, strlen( str ), style );
|
127
|
+
}
|
128
|
+
|
129
|
+
void
|
130
|
+
syck_replace_str2( SyckNode *n, char *str, long len, enum scalar_style style )
|
131
|
+
{
|
132
|
+
if ( n->data.str != NULL )
|
133
|
+
{
|
134
|
+
S_FREE( n->data.str->ptr );
|
135
|
+
n->data.str->ptr = NULL;
|
136
|
+
n->data.str->len = 0;
|
137
|
+
}
|
138
|
+
n->data.str->ptr = S_ALLOC_N( char, len + 1 );
|
139
|
+
n->data.str->len = len;
|
140
|
+
n->data.str->style = style;
|
141
|
+
memcpy( n->data.str->ptr, str, len );
|
142
|
+
n->data.str->ptr[len] = '\0';
|
143
|
+
}
|
144
|
+
|
145
|
+
void
|
146
|
+
syck_str_blow_away_commas( SyckNode *n )
|
147
|
+
{
|
148
|
+
char *go, *end;
|
149
|
+
|
150
|
+
go = n->data.str->ptr;
|
151
|
+
end = go + n->data.str->len;
|
152
|
+
while ( *(++go) != '\0' )
|
153
|
+
{
|
154
|
+
if ( *go == ',' )
|
155
|
+
{
|
156
|
+
n->data.str->len -= 1;
|
157
|
+
memmove( go, go + 1, end - go );
|
158
|
+
end -= 1;
|
159
|
+
}
|
160
|
+
}
|
161
|
+
}
|
162
|
+
|
163
|
+
char *
|
164
|
+
syck_str_read( SyckNode *n )
|
165
|
+
{
|
166
|
+
ASSERT( n != NULL );
|
167
|
+
return n->data.str->ptr;
|
168
|
+
}
|
169
|
+
|
170
|
+
SyckNode *
|
171
|
+
syck_new_map( SYMID key, SYMID value )
|
172
|
+
{
|
173
|
+
SyckNode *n;
|
174
|
+
|
175
|
+
n = syck_alloc_map();
|
176
|
+
syck_map_add( n, key, value );
|
177
|
+
|
178
|
+
return n;
|
179
|
+
}
|
180
|
+
|
181
|
+
void
|
182
|
+
syck_map_empty( SyckNode *n )
|
183
|
+
{
|
184
|
+
struct SyckMap *m;
|
185
|
+
ASSERT( n != NULL );
|
186
|
+
ASSERT( n->data.list != NULL );
|
187
|
+
|
188
|
+
S_FREE( n->data.pairs->keys );
|
189
|
+
S_FREE( n->data.pairs->values );
|
190
|
+
m = n->data.pairs;
|
191
|
+
m->idx = 0;
|
192
|
+
m->capa = ALLOC_CT;
|
193
|
+
m->keys = S_ALLOC_N( SYMID, m->capa );
|
194
|
+
m->values = S_ALLOC_N( SYMID, m->capa );
|
195
|
+
}
|
196
|
+
|
197
|
+
void
|
198
|
+
syck_map_add( SyckNode *map, SYMID key, SYMID value )
|
199
|
+
{
|
200
|
+
struct SyckMap *m;
|
201
|
+
long idx;
|
202
|
+
|
203
|
+
ASSERT( map != NULL );
|
204
|
+
ASSERT( map->data.pairs != NULL );
|
205
|
+
|
206
|
+
m = map->data.pairs;
|
207
|
+
idx = m->idx;
|
208
|
+
m->idx += 1;
|
209
|
+
if ( m->idx > m->capa )
|
210
|
+
{
|
211
|
+
m->capa += ALLOC_CT;
|
212
|
+
S_REALLOC_N( m->keys, SYMID, m->capa );
|
213
|
+
S_REALLOC_N( m->values, SYMID, m->capa );
|
214
|
+
}
|
215
|
+
m->keys[idx] = key;
|
216
|
+
m->values[idx] = value;
|
217
|
+
}
|
218
|
+
|
219
|
+
void
|
220
|
+
syck_map_update( SyckNode *map1, SyckNode *map2 )
|
221
|
+
{
|
222
|
+
struct SyckMap *m1, *m2;
|
223
|
+
long new_idx, new_capa;
|
224
|
+
ASSERT( map1 != NULL );
|
225
|
+
ASSERT( map2 != NULL );
|
226
|
+
|
227
|
+
m1 = map1->data.pairs;
|
228
|
+
m2 = map2->data.pairs;
|
229
|
+
if ( m2->idx < 1 ) return;
|
230
|
+
|
231
|
+
new_idx = m1->idx;
|
232
|
+
new_idx += m2->idx;
|
233
|
+
new_capa = m1->capa;
|
234
|
+
while ( new_idx > new_capa )
|
235
|
+
{
|
236
|
+
new_capa += ALLOC_CT;
|
237
|
+
}
|
238
|
+
if ( new_capa > m1->capa )
|
239
|
+
{
|
240
|
+
m1->capa = new_capa;
|
241
|
+
S_REALLOC_N( m1->keys, SYMID, m1->capa );
|
242
|
+
S_REALLOC_N( m1->values, SYMID, m1->capa );
|
243
|
+
}
|
244
|
+
for ( new_idx = 0; new_idx < m2->idx; m1->idx++, new_idx++ )
|
245
|
+
{
|
246
|
+
m1->keys[m1->idx] = m2->keys[new_idx];
|
247
|
+
m1->values[m1->idx] = m2->values[new_idx];
|
248
|
+
}
|
249
|
+
}
|
250
|
+
|
251
|
+
long
|
252
|
+
syck_map_count( SyckNode *map )
|
253
|
+
{
|
254
|
+
ASSERT( map != NULL );
|
255
|
+
ASSERT( map->data.pairs != NULL );
|
256
|
+
return map->data.pairs->idx;
|
257
|
+
}
|
258
|
+
|
259
|
+
void
|
260
|
+
syck_map_assign( SyckNode *map, enum map_part p, long idx, SYMID id )
|
261
|
+
{
|
262
|
+
struct SyckMap *m;
|
263
|
+
|
264
|
+
ASSERT( map != NULL );
|
265
|
+
m = map->data.pairs;
|
266
|
+
ASSERT( m != NULL );
|
267
|
+
if ( p == map_key )
|
268
|
+
{
|
269
|
+
m->keys[idx] = id;
|
270
|
+
}
|
271
|
+
else
|
272
|
+
{
|
273
|
+
m->values[idx] = id;
|
274
|
+
}
|
275
|
+
}
|
276
|
+
|
277
|
+
SYMID
|
278
|
+
syck_map_read( SyckNode *map, enum map_part p, long idx )
|
279
|
+
{
|
280
|
+
struct SyckMap *m;
|
281
|
+
|
282
|
+
ASSERT( map != NULL );
|
283
|
+
m = map->data.pairs;
|
284
|
+
ASSERT( m != NULL );
|
285
|
+
if ( p == map_key )
|
286
|
+
{
|
287
|
+
return m->keys[idx];
|
288
|
+
}
|
289
|
+
else
|
290
|
+
{
|
291
|
+
return m->values[idx];
|
292
|
+
}
|
293
|
+
}
|
294
|
+
|
295
|
+
SyckNode *
|
296
|
+
syck_new_seq( SYMID value )
|
297
|
+
{
|
298
|
+
SyckNode *n;
|
299
|
+
|
300
|
+
n = syck_alloc_seq();
|
301
|
+
syck_seq_add( n, value );
|
302
|
+
|
303
|
+
return n;
|
304
|
+
}
|
305
|
+
|
306
|
+
void
|
307
|
+
syck_seq_empty( SyckNode *n )
|
308
|
+
{
|
309
|
+
struct SyckSeq *s;
|
310
|
+
ASSERT( n != NULL );
|
311
|
+
ASSERT( n->data.list != NULL );
|
312
|
+
|
313
|
+
S_FREE( n->data.list->items );
|
314
|
+
s = n->data.list;
|
315
|
+
s->idx = 0;
|
316
|
+
s->capa = ALLOC_CT;
|
317
|
+
s->items = S_ALLOC_N( SYMID, s->capa );
|
318
|
+
}
|
319
|
+
|
320
|
+
void
|
321
|
+
syck_seq_add( SyckNode *arr, SYMID value )
|
322
|
+
{
|
323
|
+
struct SyckSeq *s;
|
324
|
+
long idx;
|
325
|
+
|
326
|
+
ASSERT( arr != NULL );
|
327
|
+
ASSERT( arr->data.list != NULL );
|
328
|
+
|
329
|
+
s = arr->data.list;
|
330
|
+
idx = s->idx;
|
331
|
+
s->idx += 1;
|
332
|
+
if ( s->idx > s->capa )
|
333
|
+
{
|
334
|
+
s->capa += ALLOC_CT;
|
335
|
+
S_REALLOC_N( s->items, SYMID, s->capa );
|
336
|
+
}
|
337
|
+
s->items[idx] = value;
|
338
|
+
}
|
339
|
+
|
340
|
+
long
|
341
|
+
syck_seq_count( SyckNode *seq )
|
342
|
+
{
|
343
|
+
ASSERT( seq != NULL );
|
344
|
+
ASSERT( seq->data.list != NULL );
|
345
|
+
return seq->data.list->idx;
|
346
|
+
}
|
347
|
+
|
348
|
+
void
|
349
|
+
syck_seq_assign( SyckNode *seq, long idx, SYMID id )
|
350
|
+
{
|
351
|
+
struct SyckSeq *s;
|
352
|
+
|
353
|
+
ASSERT( map != NULL );
|
354
|
+
s = seq->data.list;
|
355
|
+
ASSERT( m != NULL );
|
356
|
+
s->items[idx] = id;
|
357
|
+
}
|
358
|
+
|
359
|
+
SYMID
|
360
|
+
syck_seq_read( SyckNode *seq, long idx )
|
361
|
+
{
|
362
|
+
struct SyckSeq *s;
|
363
|
+
|
364
|
+
ASSERT( seq != NULL );
|
365
|
+
s = seq->data.list;
|
366
|
+
ASSERT( s != NULL );
|
367
|
+
return s->items[idx];
|
368
|
+
}
|
369
|
+
|
370
|
+
void
|
371
|
+
syck_free_members( SyckNode *n )
|
372
|
+
{
|
373
|
+
if ( n == NULL ) return;
|
374
|
+
|
375
|
+
switch ( n->kind )
|
376
|
+
{
|
377
|
+
case syck_str_kind:
|
378
|
+
if ( n->data.str != NULL )
|
379
|
+
{
|
380
|
+
S_FREE( n->data.str->ptr );
|
381
|
+
n->data.str->ptr = NULL;
|
382
|
+
n->data.str->len = 0;
|
383
|
+
S_FREE( n->data.str );
|
384
|
+
n->data.str = NULL;
|
385
|
+
}
|
386
|
+
break;
|
387
|
+
|
388
|
+
case syck_seq_kind:
|
389
|
+
if ( n->data.list != NULL )
|
390
|
+
{
|
391
|
+
S_FREE( n->data.list->items );
|
392
|
+
S_FREE( n->data.list );
|
393
|
+
n->data.list = NULL;
|
394
|
+
}
|
395
|
+
break;
|
396
|
+
|
397
|
+
case syck_map_kind:
|
398
|
+
if ( n->data.pairs != NULL )
|
399
|
+
{
|
400
|
+
S_FREE( n->data.pairs->keys );
|
401
|
+
S_FREE( n->data.pairs->values );
|
402
|
+
S_FREE( n->data.pairs );
|
403
|
+
n->data.pairs = NULL;
|
404
|
+
}
|
405
|
+
break;
|
406
|
+
}
|
407
|
+
}
|
408
|
+
|