rpm  5.4.15
rpmsyck.c
Go to the documentation of this file.
1 #include "system.h"
2 
3 #if defined(WITH_SYCK)
4 #include <syck.h>
5 #include <rpmhash.h>
6 #include <rpmsyck.h>
7 #endif
8 #include <rpmio.h>
9 
10 #include "debug.h"
11 
12 #ifdef __cplusplus
13 GENfree(rpmsyck_node)
14 #endif /* __cplusplus */
15 
17 
19 
20 #if defined(WITH_SYCK)
21 
22 static int rpmSyckFreeNode(char *key, rpmsyck_node node, char *arg) {
23  switch (node->type) {
24  case T_STR:
25  node->value.key = _free(node->value.key);
26  break;
27 
28  case T_SEQ:
29  node->value.seq = _free(node->value.seq);
30  break;
31 
32  case T_MAP:
33  node->value.map = htFree(node->value.map);
34  break;
35 
36  default:
37  break;
38  }
39  node->tag = _free(node->tag);
40  node = _free(node);
41 
42  return ST_CONTINUE;
43 }
44 
45 static void rsFini(void * _rpmSyck)
46 {
47  rpmSyck rs = (rpmSyck) _rpmSyck;
48  if(rs->syms)
49  st_foreach(rs->syms, (enum st_retval (*)(const char *, const void *, void *))rpmSyckFreeNode, 0);
50 
51  st_free_table(rs->syms);
52  rs->syms = NULL;
53  rs->firstNode = NULL;
54 }
55 
56 static rpmSyck rpmSyckGetPool(/*@null@*/ rpmioPool pool)
57  /*@globals _rpmsyckPool, fileSystem @*/
58  /*@modifies pool, _rpmsyckPool, fileSystem @*/
59 {
60  rpmSyck rs;
61 
62  if (_rpmsyckPool == NULL) {
63  _rpmsyckPool = rpmioNewPool("syck", sizeof(*rs), -1, _rpmsyck_debug,
64  NULL, NULL, rsFini);
65  pool = _rpmsyckPool;
66  }
67  return (rpmSyck) rpmioGetPool(pool, sizeof(*rs));
68 }
69 
70 
71 rpmSyck rpmSyckCreate(void)
72 {
73  rpmSyck rs = rpmSyckGetPool(_rpmsyckPool);
74  rs->syms = NULL;
75  rs->firstNode = NULL;
76 
77  return (rpmSyck) rpmSyckLink(rs);
78 }
79 
80 static SYMID
81 rpmsyck_parse_handler(SyckParser *p, SyckNode *n)
82 {
83  rpmsyck_node node = (rpmsyck_node) xcalloc(1, sizeof(*node));
84 
85  switch (n->kind) {
86  case syck_str_kind:
87  node->type = T_STR;
88  node->value.key = syck_strndup(n->data.str->ptr, n->data.str->len);
89  break;
90 
91  case syck_seq_kind: {
92  rpmsyck_node val;
93  rpmsyck_node seq = (rpmsyck_node) xcalloc(n->data.list->idx + 1, sizeof(*node));
94  int i;
95  node->type = T_SEQ;
96 
97  for (i = 0; i < n->data.list->idx; i++) {
98  SYMID oid = syck_seq_read(n, i);
99  syck_lookup_sym(p, oid, (char **)&val);
100  seq[i] = val[0];
101  }
102  seq[n->data.list->idx].type = T_END;
103  node->value.seq = seq;
104  }
105  break;
106 
107  case syck_map_kind: {
108  hashTable ht = htCreate(n->data.pairs->idx * 2, 0, 0, NULL, NULL);
109  rpmsyck_node val;
110  int i;
111  node->type = T_MAP;
112  for (i = 0; i < n->data.pairs->idx; i++) {
113  char *key;
114  SYMID oid = syck_map_read(n, map_key, i);
115  syck_lookup_sym(p, oid, (char **)&val);
116  key = val[0].value.key;
117 
118  oid = syck_map_read(n, map_value, i);
119  syck_lookup_sym(p, oid, (char **)&val);
120 
121  htAddEntry(ht, key, val);
122  }
123  node->value.map = ht;
124  }
125  break;
126  }
127 
128  node->tag = n->type_id ? syck_strndup(n->type_id, strlen(n->type_id)) : NULL;
129 
130  return syck_add_sym(p, (char *) node);
131 }
132 
133 rpmSyck rpmSyckLoad(char *yaml) {
134  SyckParser *parser;
135  SYMID v;
136  rpmSyck rs;
137 
138  rs = rpmSyckCreate();
139 
140  parser = syck_new_parser();
141 
142  syck_parser_str_auto(parser, yaml, NULL);
143  syck_parser_handler(parser, rpmsyck_parse_handler);
144  syck_parser_error_handler(parser, NULL);
145  syck_parser_implicit_typing(parser, 1);
146  syck_parser_taguri_expansion(parser, 1);
147 
148  if((v = syck_parse(parser)))
149  syck_lookup_sym( parser, v, (char **)&rs->firstNode);
150 
151  rs->syms = parser->syms;
152  parser->syms = NULL;
153  syck_free_parser(parser);
154 
155  return rs;
156 }
157 
158 #endif
Hash table implemenation.
rpmioPool _rpmsyckPool
Definition: rpmsyck.c:18
void * xcalloc(size_t nmemb, size_t size)
Definition: rpmmalloc.c:300
const char const bson_bool_t v
Definition: bson.h:919
rpmioItem rpmioGetPool(rpmioPool pool, size_t size)
Get unused item from pool, or alloc a new item.
Definition: rpmmalloc.c:220
const char const bson_oid_t * oid
Definition: bson.h:757
hashTable htFree(hashTable ht)
Destroy hash table.
int _rpmsyck_debug
Definition: rpmsyck.c:16
const char const char int arg
Definition: mongo.h:777
const char const int i
Definition: bson.h:778
void htAddEntry(hashTable ht, const void *key, const void *data)
Add item to hash table.
Definition: rpmhash.c:150
const char const bson * key
Definition: mongo.h:717
rpmioPool rpmioNewPool(const char *name, size_t size, int limit, int flags, char *(*dbg)(void *item), void(*init)(void *item), void(*fini)(void *item))
Create a memory pool.
Definition: rpmmalloc.c:109
static void * _free(const void *p)
Wrapper to free(3), hides const compilation noise, permit NULL, return NULL.
Definition: rpmiotypes.h:756
hashTable htCreate(int numBuckets, size_t keySize, int freeData, hashFunctionType fn, hashEqualityType eq)
Create hash table.
Definition: rpmhash.c:277