| 1 |
|
| /* |
| 2 |
|
| * handler.c |
| 3 |
|
| * |
| 4 |
|
| * $Author: why $ |
| 5 |
|
| * $Date: 2005-09-20 13:21:06 +0800 (二, 20 9 2005) $ |
| 6 |
|
| * |
| 7 |
|
| * Copyright (C) 2003 why the lucky stiff |
| 8 |
|
| */ |
| 9 |
|
| |
| 10 |
|
| #include "syck.h" |
| 11 |
|
| |
| 12 |
|
| SYMID |
| 13 |
18726988 |
| syck_hdlr_add_node( SyckParser *p, SyckNode *n ) |
| 14 |
|
| { |
| 15 |
|
| SYMID id; |
| 16 |
|
| |
| 17 |
18726988 |
▶ | if ( ! n->id ) |
Branch: 1 branch
| Branch | True | False | Total |
| if ( ! n->id ) |
18726925 |
63 |
18726988 |
|
| 18 |
|
| { |
| 19 |
18726925 |
| n->id = (p->handler)( p, n ); |
| 20 |
|
| } |
| 21 |
18726977 |
| id = n->id; |
| 22 |
|
| |
| 23 |
18726977 |
▶ | if ( n->anchor == NULL ) |
Branch: 1 branch
| Branch | True | False | Total |
| if ( n->anchor == NULL ) |
18726882 |
95 |
18726977 |
|
| 24 |
|
| { |
| 25 |
18726882 |
| syck_free_node( n ); |
| 26 |
|
| } |
| 27 |
18726977 |
| return id; |
| 28 |
|
| } |
| 29 |
|
| |
| 30 |
|
| /* |
| 31 |
|
| * A node evicted from the anchors table by redefinition may still be live on |
| 32 |
|
| * the parser's value stack, so it cannot be freed here. Keep it for teardown. |
| 33 |
|
| */ |
| 34 |
|
| void |
| 35 |
1 |
| syck_retire_node( SyckParser *p, SyckNode *n ) |
| 36 |
|
| { |
| 37 |
1 |
▶ | if ( p->retired == NULL ) |
Branch: 1 branch
| Branch | True | False | Total |
| if ( p->retired == NULL ) |
1 |
0 |
1 |
|
| 38 |
|
| { |
| 39 |
1 |
| p->retired = st_init_numtable(); |
| 40 |
|
| } |
| 41 |
1 |
| st_insert( p->retired, (st_data_t)( p->retired->num_entries + 1 ), |
| 42 |
|
| (st_data_t)n ); |
| 43 |
1 |
| } |
| 44 |
|
| |
| 45 |
|
| SyckNode * |
| 46 |
33 |
| syck_hdlr_add_anchor( SyckParser *p, char *a, SyckNode *n ) |
| 47 |
|
| { |
| 48 |
33 |
| SyckNode *ntmp = NULL; |
| 49 |
|
| |
| 50 |
33 |
▶ | if (n->anchor != NULL) { |
Branch: 1 branch
| Branch | True | False | Total |
| if (n->anchor != NULL) { |
1 |
32 |
33 |
|
| 51 |
|
| /* |
| 52 |
|
| * Note: An error should be returned here. But this is better than |
| 53 |
|
| * not checking at all because it will abort the program with a |
| 54 |
|
| * memory corruption error. |
| 55 |
|
| * Happens if you have two anchors after each other or an anchor |
| 56 |
|
| * before an alias |
| 57 |
|
| * */ |
| 58 |
1 |
| S_FREE(a); |
| 59 |
1 |
| return n; |
| 60 |
|
| } |
| 61 |
32 |
| n->anchor = a; |
| 62 |
32 |
▶ | if ( p->bad_anchors != NULL ) |
Branch: 1 branch
| Branch | True | False | Total |
| if ( p->bad_anchors != NULL ) |
8 |
24 |
32 |
|
| 63 |
|
| { |
| 64 |
|
| SyckNode *bad; |
| 65 |
8 |
▶ | if ( st_lookup( p->bad_anchors, (st_data_t)a, (st_data_t *)&bad ) ) |
Branch: 1 branch
| Branch | True | False | Total |
| if ( st_lookup( p->bad_anchors, (st_data_t)a, (st_data_t *)&bad ) ) |
7 |
1 |
8 |
|
| 66 |
|
| { |
| 67 |
7 |
▶ | if ( n->kind != syck_str_kind ) |
Branch: 1 branch
| Branch | True | False | Total |
| if ( n->kind != syck_str_kind ) |
7 |
0 |
7 |
|
| 68 |
|
| { |
| 69 |
7 |
| n->id = bad->id; |
| 70 |
7 |
| (p->handler)( p, n ); |
| 71 |
|
| } |
| 72 |
|
| } |
| 73 |
|
| } |
| 74 |
32 |
▶ | if ( p->anchors == NULL ) |
Branch: 1 branch
| Branch | True | False | Total |
| if ( p->anchors == NULL ) |
0 |
32 |
32 |
|
| 75 |
|
| { |
| 76 |
0 |
| p->anchors = st_init_strtable(); |
| 77 |
|
| } |
| 78 |
32 |
▶ | if ( st_lookup( p->anchors, (st_data_t)a, (st_data_t *)&ntmp ) ) |
Branch: 1 branch
| Branch | True | False | Total |
| if ( st_lookup( p->anchors, (st_data_t)a, (st_data_t *)&ntmp ) ) |
32 |
0 |
32 |
|
| 79 |
|
| { |
| 80 |
32 |
▶ | if ( ntmp != (void *)1 ) |
Branch: 1 branch
| Branch | True | False | Total |
| if ( ntmp != (void *)1 ) |
0 |
32 |
32 |
|
| 81 |
|
| { |
| 82 |
0 |
| syck_retire_node( p, ntmp ); |
| 83 |
|
| } |
| 84 |
32 |
| st_insert( p->anchors, (st_data_t)a, (st_data_t)n ); |
| 85 |
|
| } |
| 86 |
|
| else |
| 87 |
|
| { |
| 88 |
0 |
| st_insert( p->anchors, (st_data_t)syck_strndup( a, strlen( a ) ), |
| 89 |
|
| (st_data_t)n ); |
| 90 |
|
| } |
| 91 |
32 |
| return n; |
| 92 |
|
| } |
| 93 |
|
| |
| 94 |
|
| void |
| 95 |
35 |
| syck_hdlr_remove_anchor( SyckParser *p, char *a ) |
| 96 |
|
| { |
| 97 |
35 |
| char *atmp = a; |
| 98 |
|
| SyckNode *ntmp; |
| 99 |
35 |
▶ | if ( p->anchors == NULL ) |
Branch: 1 branch
| Branch | True | False | Total |
| if ( p->anchors == NULL ) |
24 |
11 |
35 |
|
| 100 |
|
| { |
| 101 |
24 |
| p->anchors = st_init_strtable(); |
| 102 |
|
| } |
| 103 |
35 |
▶ | if ( st_delete( p->anchors, (st_data_t *)&atmp, (st_data_t *)&ntmp ) ) |
Branch: 1 branch
| Branch | True | False | Total |
| if ( st_delete( p->anchors, (st_data_t *)&atmp, (st_data_t *)&ntmp ) ) |
2 |
33 |
35 |
|
| 104 |
|
| { |
| 105 |
2 |
▶ | if ( ntmp != (void *)1 ) |
Branch: 1 branch
| Branch | True | False | Total |
| if ( ntmp != (void *)1 ) |
1 |
1 |
2 |
|
| 106 |
|
| { |
| 107 |
1 |
| syck_retire_node( p, ntmp ); |
| 108 |
|
| } |
| 109 |
2 |
| S_FREE( atmp ); |
| 110 |
|
| } |
| 111 |
35 |
| st_insert( p->anchors, (st_data_t)syck_strndup( a, strlen( a ) ), |
| 112 |
|
| (st_data_t)1 ); |
| 113 |
35 |
| } |
| 114 |
|
| |
| 115 |
|
| SyckNode * |
| 116 |
63 |
| syck_hdlr_get_anchor( SyckParser *p, char *a ) |
| 117 |
|
| { |
| 118 |
63 |
| SyckNode *n = NULL; |
| 119 |
|
| |
| 120 |
63 |
▶ | if ( p->anchors != NULL ) |
Branch: 1 branch
| Branch | True | False | Total |
| if ( p->anchors != NULL ) |
63 |
0 |
63 |
|
| 121 |
|
| { |
| 122 |
63 |
▶ | if ( st_lookup( p->anchors, (st_data_t)a, (st_data_t *)&n ) ) |
Branch: 1 branch
| Branch | True | False | Total |
| if ( st_lookup( p->anchors, (st_data_t)a, (st_data_t *)&n ) ) |
63 |
0 |
63 |
|
| 123 |
|
| { |
| 124 |
63 |
▶ | if ( n != (void *)1 ) |
Branch: 1 branch
| Branch | True | False | Total |
| if ( n != (void *)1 ) |
51 |
12 |
63 |
|
| 125 |
|
| { |
| 126 |
51 |
| S_FREE( a ); |
| 127 |
51 |
| return n; |
| 128 |
|
| } |
| 129 |
|
| else |
| 130 |
|
| { |
| 131 |
12 |
▶ | if ( p->bad_anchors == NULL ) |
Branch: 1 branch
| Branch | True | False | Total |
| if ( p->bad_anchors == NULL ) |
6 |
6 |
12 |
|
| 132 |
|
| { |
| 133 |
6 |
| p->bad_anchors = st_init_strtable(); |
| 134 |
|
| } |
| 135 |
12 |
▶ | if ( ! st_lookup( p->bad_anchors, (st_data_t)a, (st_data_t *)&n ) ) |
Branch: 1 branch
| Branch | True | False | Total |
| if ( ! st_lookup( p->bad_anchors, (st_data_t)a, (st_data_t *)&n ) ) |
7 |
5 |
12 |
|
| 136 |
|
| { |
| 137 |
7 |
| n = (p->bad_anchor_handler)( p, a ); |
| 138 |
7 |
| st_insert( p->bad_anchors, |
| 139 |
7 |
| (st_data_t)syck_strndup( a, strlen( a ) ), |
| 140 |
|
| (st_data_t)n ); |
| 141 |
|
| } |
| 142 |
|
| } |
| 143 |
|
| } |
| 144 |
|
| } |
| 145 |
|
| |
| 146 |
12 |
▶ | if ( n == NULL ) |
Branch: 1 branch
| Branch | True | False | Total |
| if ( n == NULL ) |
0 |
12 |
12 |
|
| 147 |
|
| { |
| 148 |
0 |
| n = (p->bad_anchor_handler)( p, a ); |
| 149 |
|
| } |
| 150 |
|
| |
| 151 |
12 |
▶ | if ( n->anchor ) |
Branch: 1 branch
| Branch | True | False | Total |
| if ( n->anchor ) |
5 |
7 |
12 |
|
| 152 |
|
| { |
| 153 |
5 |
| S_FREE( a ); |
| 154 |
|
| } |
| 155 |
|
| else |
| 156 |
|
| { |
| 157 |
7 |
| n->anchor = a; |
| 158 |
|
| } |
| 159 |
|
| |
| 160 |
12 |
| return n; |
| 161 |
|
| } |
| 162 |
|
| |
| 163 |
|
| void |
| 164 |
689 |
| syck_add_transfer( char *uri, SyckNode *n, int taguri ) |
| 165 |
|
| { |
| 166 |
689 |
▶ | if ( n->type_id != NULL ) |
Branch: 1 branch
| Branch | True | False | Total |
| if ( n->type_id != NULL ) |
226 |
463 |
689 |
|
| 167 |
|
| { |
| 168 |
226 |
| S_FREE( n->type_id ); |
| 169 |
|
| } |
| 170 |
|
| |
| 171 |
689 |
▶ | if ( taguri == 0 ) |
Branch: 1 branch
| Branch | True | False | Total |
| if ( taguri == 0 ) |
689 |
0 |
689 |
|
| 172 |
|
| { |
| 173 |
689 |
| n->type_id = uri; |
| 174 |
689 |
| return; |
| 175 |
|
| } |
| 176 |
|
| |
| 177 |
0 |
| n->type_id = syck_type_id_to_uri( uri ); |
| 178 |
0 |
| S_FREE( uri ); |
| 179 |
|
| } |
| 180 |
|
| |
| 181 |
|
| char * |
| 182 |
0 |
| syck_xprivate( char *type_id, int type_len ) |
| 183 |
|
| { |
| 184 |
0 |
| char *uri = S_ALLOC_N( char, type_len + 14 ); |
| 185 |
0 |
| uri[0] = '\0'; |
| 186 |
0 |
| strcat( uri, "x-private:" ); |
| 187 |
0 |
| strncat( uri, type_id, type_len ); |
| 188 |
0 |
| return uri; |
| 189 |
|
| } |
| 190 |
|
| |
| 191 |
|
| char * |
| 192 |
0 |
| syck_taguri( const char *domain, const char *type_id, int type_len ) |
| 193 |
|
| { |
| 194 |
0 |
| char *uri = S_ALLOC_N( char, strlen( domain ) + type_len + 14 ); |
| 195 |
0 |
| uri[0] = '\0'; |
| 196 |
0 |
| strcat( uri, "tag:" ); |
| 197 |
0 |
| strcat( uri, domain ); |
| 198 |
0 |
| strcat( uri, ":" ); |
| 199 |
0 |
| strncat( uri, type_id, type_len ); |
| 200 |
0 |
| return uri; |
| 201 |
|
| } |
| 202 |
|
| |
| 203 |
|
| int |
| 204 |
0 |
| syck_try_implicit( SyckNode *n ) |
| 205 |
|
| { |
| 206 |
0 |
| return 1; |
| 207 |
|
| } |
| 208 |
|
| |