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