node.c

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