rpm  5.4.15
rpmcudf.c
Go to the documentation of this file.
1 #include "system.h"
2 
3 #define _RPMIOB_INTERNAL /* XXX necessary? */
4 #include <rpmiotypes.h>
5 #include <rpmmacro.h>
6 #include <argv.h>
7 
8 #define _RPMCUDF_INTERNAL
9 #include "rpmcudf.h"
10 
11 #include "debug.h"
12 
13 /*@unchecked@*/
15 
16 #ifdef NOTYET
17 /*@unchecked@*/ /*@relnull@*/
18 rpmcudf _rpmcudfI = NULL;
19 #endif
20 
21 /*==============================================================*/
22 
23 #if defined(WITH_CUDF)
24 
25 /* forward ref */
26 static void rpmcudvPrint(rpmcudf cudf, rpmcudv v, int free);
27 
28 static rpmcudv rpmcudvFree(rpmcudv v)
29 {
30  if (v == NULL)
31  return NULL;
32  switch (v->typ) {
33  default :
34  fprintf(stderr, "%s: unexpected type: %d\n", __FUNCTION__, v->typ);
35 assert(0);
36  break;
37  case RPMCUDV_NOTYPE:
38  break;
39  case RPMCUDV_INT:
40  case RPMCUDV_POSINT:
41  case RPMCUDV_NAT:
42  case RPMCUDV_BOOL:
43  break;
44  case RPMCUDV_STRING:
45  case RPMCUDV_PKGNAME:
46  case RPMCUDV_IDENT:
47  case RPMCUDV_ENUM:
48  free(v->val.s);
49  break;
50  case RPMCUDV_VPKGFORMULA:
51  cudf_free_vpkgformula(v->val.f);
52  break;
53  case RPMCUDV_VPKG:
54  case RPMCUDV_VEQPKG:
55  cudf_free_vpkg(v->val.vpkg);
56  break;
57  case RPMCUDV_VPKGLIST:
58  case RPMCUDV_VEQPKGLIST:
59  cudf_free_vpkglist(v->val.vpkgs);
60  break;
61  case RPMCUDV_TYPEDECL:
62 assert(0); /* XXX unimplemented */
63  break;
64 
65  case RPMCUDV_PACKAGE:
66 assert(0); /* XXX unimplemented */
67  break;
68  case RPMCUDV_CUDFDOC:
69  cudf_free_doc(v->val.doc);
70  break;
71  case RPMCUDV_CUDF:
72  cudf_free_cudf(v->val.cudf);
73  break;
74  case RPMCUDV_EXTRA:
75  g_hash_table_destroy(v->val.extra);
76  break;
77  }
78  memset(v, 0, sizeof(*v)); /* trash & burn */
79  return NULL;
80 }
81 
82 static const char * relops[] = {
83  "?0?", /* 0 RELOP_NOP */
84  "=", /* 1 RELOP_EQ */
85  "!=", /* 2 RELOP_NEQ */
86  ">=", /* 3 RELOP_GEQ */
87  ">", /* 4 RELOP_GT */
88  "<=", /* 5 RELOP_LEQ */
89  "<", /* 6 RELOP_LT */
90  "?7?", /* 7 */
91 };
92 
93 /* Print a package version predicate */
94 static
95 void print_vpkg(rpmcudf cudf, rpmcudv v)
96 {
97 
98 assert(v->typ == RPMCUDV_VPKG || v->typ == RPMCUDV_VEQPKG);
99 
100  if (v->val.vpkg) {
101  size_t nb = strlen(v->val.vpkg->name) + 5 + 64;
102  char * b = alloca(nb);
103  char * be = b;
104 
105  be = stpcpy(be, v->val.vpkg->name);
106  if (v->val.vpkg->relop) {
107  snprintf(be, 5+64, " %s %d",
108  relops[v->val.vpkg->relop & 0x7],
109  v->val.vpkg->version);
110  be += strlen(be);
111  }
112  rpmiobAppend(cudf->iob, b, 0);
113  }
114 }
115 
116 /* Print a list of package predicates, separated by a given separator */
117 static
118 void print_vpkglist(rpmcudf cudf, rpmcudv v, const char * sep)
119 {
120 cudf_vpkglist_t l;
121 GList * last;
122 
123 assert(v->typ == RPMCUDV_VPKGLIST || v->typ == RPMCUDV_VEQPKGLIST);
124 
125  for (l = v->val.vpkgs, last=g_list_last(l); l != NULL; l = g_list_next(l)) {
126 struct rpmcudv_s x;
127 x.typ = RPMCUDV_VPKG;
128 x.val.vpkg = g_list_nth_data(l, 0);
129 rpmcudvPrint(cudf, &x, 0);
130  if (l != last)
131  rpmiobAppend(cudf->iob, sep, 0);
132  }
133 }
134 
135 /* Print a package formula */
136 static
137 void print_vpkgformula(rpmcudf cudf, rpmcudv v)
138 {
139 cudf_vpkgformula_t l;
140 GList * last;
141 
142 assert(v->typ == RPMCUDV_VPKGFORMULA);
143 
144  for (l = v->val.f, last=g_list_last(l); l != NULL; l = g_list_next(l)) {
145  struct rpmcudv_s x;
146  x.typ = RPMCUDV_VPKGLIST;
147  x.val.vpkg = g_list_nth_data(l, 0);
148  /* XXX use rpmcudvPrint? */
149  print_vpkglist(cudf, &x, " | ");
150  if (l != last)
151  rpmiobAppend(cudf->iob, ", ", 0);
152  }
153 }
154 
155 /* Print a CUDF preamble */
156 static
157 void print_preamble(rpmcudf cudf)
158 {
159  static char *props[] = {
160  "preamble", "property", "univ-checksum", "status-checksum",
161  "req-checksum", NULL
162  };
163  char ** prop;
164 
165 rpmcudv v = &cudf->V;
166 assert(v->typ == RPMCUDV_CUDFDOC);
167  if (v->val.doc->has_preamble)
168  for (prop = props; *prop != NULL; prop++) {
169  const char * s = cudf_pre_property(v->val.doc->preamble, *prop);
170  char * t = rpmExpand(" ", *prop, ": ", s, NULL);
171  rpmiobAppend(cudf->iob, t, 1);
172  t = _free(t);
173  s = _free(s);
174  }
175 }
176 
177 /* Print a CUDF request */
178 static
179 void print_request(rpmcudf cudf)
180 {
181  static char *props[] = {
182  "request", "install", "remove", "upgrade", NULL
183  };
184  char ** prop;
185 
186 rpmcudv v = &cudf->V;
187 assert(v->typ == RPMCUDV_CUDFDOC);
188  if (v->val.doc->has_request)
189  for (prop = props; *prop != NULL; prop++) {
190  const char * s = cudf_req_property(v->val.doc->request, *prop);
191  char * t = rpmExpand(" ", *prop, ": ", s, NULL);
192  rpmiobAppend(cudf->iob, t, 1);
193  t = _free(t);
194  s = _free(s);
195  }
196 }
197 
198 /* Print a possible value of the "keep" package property */
199 static
200 void print_keep(rpmcudf cudf, int keep)
201 {
202  const char * s;
203  switch (keep) {
204  default :
205  fprintf(stderr, "%s: unexpected keep value: %d\n", __FUNCTION__, keep);
206 assert(0);
207  break;
208  case KEEP_NONE: s = " keep: version"; break;
209  case KEEP_VERSION: s = " keep: version"; break;
210  case KEEP_PACKAGE: s = " keep: package"; break;
211  case KEEP_FEATURE: s = " keep: feature"; break;
212  }
213  rpmiobAppend(cudf->iob, s, 1);
214 }
215 
216 /* Print a generic property, i.e. a pair <name, typed value> */
217 static
218 void print_property(void * k, void * v, void * _cudf)
219 {
220  rpmcudf cudf = _cudf;
221  rpmiobAppend(cudf->iob, " ", 0);
222  rpmiobAppend(cudf->iob, (char *)k, 0);
223  rpmiobAppend(cudf->iob, ": ", 0);
224  rpmcudvPrint(cudf, v, 0);
225  rpmiobAppend(cudf->iob, "", 1);
226 }
227 
228 /* Print to stdout a set of extra properties */
229 #define print_extra(_cudf, e) g_hash_table_foreach(e, print_property, _cudf)
230 
231 static void rpmcudvPrint(rpmcudf cudf, rpmcudv v, int free)
232 {
233  const char * s = NULL;
234  char t[64];
235 
236  if (v == NULL)
237  return;
238 
239  switch (v->typ) {
240  default :
241  fprintf(stderr, "%s: unexpected type: %d\n", __FUNCTION__, v->typ);
242 assert(0);
243  break;
244  case RPMCUDV_NOTYPE:
245  break;
246  case RPMCUDV_INT:
247  case RPMCUDV_POSINT:
248  case RPMCUDV_NAT:
249  snprintf(t, sizeof(t), "%d", v->val.i);
250  s = t;
251  break;
252  case RPMCUDV_BOOL:
253  s = (v->val.i ? "true" : "false");
254  break;
255  case RPMCUDV_STRING:
256  case RPMCUDV_PKGNAME:
257  case RPMCUDV_IDENT:
258  case RPMCUDV_ENUM:
259  s = v->val.s;
260  break;
261  case RPMCUDV_VPKGFORMULA:
262  print_vpkgformula(cudf, v);
263 if (free) rpmcudvFree(v);
264  break;
265  case RPMCUDV_VPKG:
266  case RPMCUDV_VEQPKG:
267  print_vpkg(cudf, v);
268  break;
269  case RPMCUDV_VPKGLIST:
270  case RPMCUDV_VEQPKGLIST:
271  print_vpkglist(cudf, v, ", ");
272 if (free) rpmcudvFree(v);
273  break;
274  case RPMCUDV_TYPEDECL:
275 assert(0); /* XXX unimplemented */
276  break;
277 
278  case RPMCUDV_PACKAGE:
279 assert(0); /* XXX unimplemented */
280  break;
281  case RPMCUDV_CUDFDOC:
282 assert(0); /* XXX unimplemented */
283  break;
284  case RPMCUDV_CUDF:
285 assert(0); /* XXX unimplemented */
286  break;
287  case RPMCUDV_EXTRA:
288  print_extra(cudf, v->val.extra);
289 if (free) rpmcudvFree(v);
290  break;
291  }
292  if (s)
293  rpmiobAppend(cudf->iob, s, 0);
294 }
295 
296 static rpmcudp rpmcudpFree(rpmcudp cudp)
297 {
298  if (cudp) {
299  memset(cudp, 0, sizeof(*cudp)); /* trash & burn */
300  free(cudp);
301  }
302  return NULL;
303 }
304 
305 static rpmcudp rpmcudpNew(rpmcudf cudf)
306 {
307  rpmcudp cudp = xcalloc(1, sizeof(*cudp));
308  cudp->l = cudf->V.val.doc->packages;
309  return cudp;
310 }
311 
312 static rpmcudv rpmcudpNext(rpmcudp cudp)
313 {
314  if (cudp == NULL || cudp->l == NULL)
315  return NULL;
316  cudp->V.typ = RPMCUDV_PACKAGE;
317  cudp->V.val.pkg = (cudf_package_t) g_list_nth_data(cudp->l, 0);
318  cudp->l = g_list_next(cudp->l);
319  return &cudp->V;
320 }
321 
322 static const char * rpmcudpName(rpmcudp cudp)
323 {
324 rpmcudv v = &cudp->V;
325 assert(v->typ == RPMCUDV_PACKAGE);
326  return cudf_pkg_name(v->val.pkg);
327 }
328 
329 /* XXX const char * return? */
330 static int rpmcudpVersion(rpmcudp cudp)
331 {
332 rpmcudv v = &cudp->V;
333 assert(v->typ == RPMCUDV_PACKAGE);
334  return cudf_pkg_version(v->val.pkg);
335 }
336 
337 static int rpmcudpInstalled(rpmcudp cudp)
338 {
339 rpmcudv v = &cudp->V;
340 assert(v->typ == RPMCUDV_PACKAGE);
341  return cudf_pkg_installed(v->val.pkg);
342 }
343 
344 static int rpmcudpWasInstalled(rpmcudp cudp)
345 {
346 rpmcudv v = &cudp->V;
347 assert(v->typ == RPMCUDV_PACKAGE);
348  return cudf_pkg_was_installed(v->val.pkg);
349 }
350 
351 static rpmcudv rpmcudpW(rpmcudp cudp, int typ, void * ptr)
352 {
353 rpmcudv w = &cudp->W;
354  w->typ = typ;
355  w->val.ptr = ptr;
356  return w;
357 }
358 
359 static rpmcudv rpmcudpDepends(rpmcudp cudp)
360 {
361 rpmcudv v = &cudp->V;
362 assert(v->typ == RPMCUDV_PACKAGE);
363  return rpmcudpW(cudp, RPMCUDV_VPKGFORMULA, cudf_pkg_depends(v->val.pkg));
364 }
365 
366 static rpmcudv rpmcudpConflicts(rpmcudp cudp)
367 {
368 rpmcudv v = &cudp->V;
369 assert(v->typ == RPMCUDV_PACKAGE);
370  return rpmcudpW(cudp, RPMCUDV_VPKGLIST, cudf_pkg_conflicts(v->val.pkg));
371 }
372 
373 static rpmcudv rpmcudpProvides(rpmcudp cudp)
374 {
375 rpmcudv v = &cudp->V;
376 assert(v->typ == RPMCUDV_PACKAGE);
377  return rpmcudpW(cudp, RPMCUDV_VPKGLIST, cudf_pkg_provides(v->val.pkg));
378 }
379 
380 static int rpmcudpKeep(rpmcudp cudp)
381 {
382 rpmcudv v = &cudp->V;
383 assert(v->typ == RPMCUDV_PACKAGE);
384  /* XXX return rpmcudv instead? */
385  return cudf_pkg_keep(v->val.pkg);
386 }
387 
388 static rpmcudv rpmcudpExtra(rpmcudp cudp)
389 {
390 rpmcudv v = &cudp->V;
391 assert(v->typ == RPMCUDV_PACKAGE);
392  return rpmcudpW(cudp, RPMCUDV_EXTRA, cudf_pkg_extra(v->val.pkg));
393 }
394 
395 /* Print a CUDF package */
396 static
397 void print_package(rpmcudf cudf, rpmcudp cudp)
398 {
399  char t[256];
400 rpmcudv v;
401 
402 v = &cudp->V;
403 assert(v->typ == RPMCUDV_PACKAGE);
404 
405  snprintf(t, sizeof(t), " package: %s", rpmcudpName(cudp));
406  rpmiobAppend(cudf->iob, t, 1);
407 
408  snprintf(t, sizeof(t), " version: %d", rpmcudpVersion(cudp));
409  rpmiobAppend(cudf->iob, t, 1);
410 
411  snprintf(t, sizeof(t), " installed: %s",
412  rpmcudpInstalled(cudp) ? "true" : "false");
413  rpmiobAppend(cudf->iob, t, 1);
414 
415  snprintf(t, sizeof(t), " was-installed: %s",
416  rpmcudpWasInstalled(cudp) ? "true" : "false");
417  rpmiobAppend(cudf->iob, t, 1);
418 
419  rpmiobAppend(cudf->iob, " depends: ", 0);
420  rpmcudvPrint(cudf, rpmcudpDepends(cudp), 1);
421  rpmiobAppend(cudf->iob, "", 1);
422 
423  rpmiobAppend(cudf->iob, " conflicts: ", 0);
424  rpmcudvPrint(cudf, rpmcudpConflicts(cudp), 1);
425  rpmiobAppend(cudf->iob, "", 1);
426 
427  rpmiobAppend(cudf->iob, " provides: ", 0);
428  rpmcudvPrint(cudf, rpmcudpProvides(cudp), 1);
429  rpmiobAppend(cudf->iob, "", 1);
430 
431  /* XXX use rpmcudvPrint? */
432  print_keep(cudf, rpmcudpKeep(cudp));
433 
434  rpmcudvPrint(cudf, rpmcudpExtra(cudp), 0);
435 
436  rpmiobAppend(cudf->iob, "", 1);
437 
438 }
439 #endif /* WITH_CUDF */
440 
441 /*==============================================================*/
442 
443 static void rpmcudfFini(void * _cudf)
444  /*@globals fileSystem @*/
445  /*@modifies *_cudf, fileSystem @*/
446 {
447  rpmcudf cudf = (rpmcudf) _cudf;
448 
449 #if defined(WITH_CUDF)
450  (void) rpmcudvFree(&cudf->V);
451  memset(&cudf->V, 0, sizeof(cudf->V));
452 #endif
453  (void)rpmiobFree(cudf->iob);
454  cudf->iob = NULL;
455 }
456 
457 /*@unchecked@*/ /*@only@*/ /*@null@*/
459 
461  /*@globals _rpmcudfPool, fileSystem @*/
462  /*@modifies pool, _rpmcudfPool, fileSystem @*/
463 {
464  rpmcudf cudf;
465 
466  if (_rpmcudfPool == NULL) {
467  _rpmcudfPool = rpmioNewPool("cudf", sizeof(*cudf), -1, _rpmcudf_debug,
468  NULL, NULL, rpmcudfFini);
469  pool = _rpmcudfPool;
470  }
471  cudf = (rpmcudf) rpmioGetPool(pool, sizeof(*cudf));
472  memset(((char *)cudf)+sizeof(cudf->_item), 0, sizeof(*cudf)-sizeof(cudf->_item));
473  return cudf;
474 }
475 
476 #ifdef NOTYET
477 static rpmcudf rpmcudfI(void)
478  /*@globals _rpmcudfI @*/
479  /*@modifies _rpmcudfI @*/
480 {
481  if (_rpmcudfI == NULL)
482  _rpmcudfI = rpmcudfNew(NULL, 0);
483  return _rpmcudfI;
484 }
485 #endif
486 
487 rpmcudf rpmcudfNew(char ** av, uint32_t flags)
488 {
489  rpmcudf cudf =
490 #ifdef NOTYET
491  (flags & 0x80000000) ? rpmcudfI() :
492 #endif
493  rpmcudfGetPool(_rpmcudfPool);
494  const char * fn = (av ? av[0] : NULL);
495  int typ = flags;
496  static int oneshot = 0;
497 
498  if (!oneshot) {
499 #if defined(WITH_CUDF)
500  cudf_init();
501 #else
502  fn = fn;
503  typ = typ;
504 #endif
505  oneshot++;
506  }
507 
508 if (_rpmcudf_debug)
509 fprintf(stderr, "==> %s(%p, %d) cudf %p\n", __FUNCTION__, av, flags, cudf);
510 
511 #if defined(WITH_CUDF)
512  if (fn != NULL)
513  switch (typ) {
514  default:
515 assert(0);
516  break;
517  case RPMCUDV_CUDFDOC:
518  cudf->V.typ = typ;
519  cudf->V.val.ptr = cudf_parse_from_file((char *)fn);
520  break;
521  case RPMCUDV_CUDF:
522  cudf->V.typ = typ;
523  cudf->V.val.ptr = cudf_load_from_file((char *)fn);
524  break;
525  }
526 #endif
527  cudf->iob = rpmiobNew(0);
528  return rpmcudfLink(cudf);
529 }
530 
531 #ifdef NOTYET
532 static const char * rpmcudfSlurp(const char * arg)
533  /*@*/
534 {
535  rpmiob iob = NULL;
536  const char * val = NULL;
537  struct stat sb;
538  int xx;
539 
540  if (!strcmp(arg, "-")) { /* Macros from stdin arg. */
541  xx = rpmiobSlurp(arg, &iob);
542  } else
543  if ((arg[0] == '/' || strchr(arg, ' ') == NULL)
544  && !Stat(arg, &sb)
545  && S_ISREG(sb.st_mode)) { /* Macros from a file arg. */
546  xx = rpmiobSlurp(arg, &iob);
547  } else { /* Macros from string arg. */
548  iob = rpmiobAppend(rpmiobNew(strlen(arg)+1), arg, 0);
549  }
550 
551  val = xstrdup(rpmiobStr(iob));
552  iob = rpmiobFree(iob);
553  return val;
554 }
555 #endif
556 
557 /*==============================================================*/
558 
560 {
561  int rc = 0;
562 #if defined(WITH_CUDF)
563  switch(cudf->V.typ) {
564  default: assert(0); break;
565  case RPMCUDV_NOTYPE: break;
566  case RPMCUDV_CUDFDOC: rc = cudf->V.val.doc->has_preamble; break;
567  case RPMCUDV_CUDF: rc = cudf->V.val.cudf->has_preamble; break;
568  }
569 #endif
570  return rc;
571 }
572 
574 {
575  int rc = 0;
576 #if defined(WITH_CUDF)
577  switch(cudf->V.typ) {
578  default: assert(0); break;
579  case RPMCUDV_NOTYPE: break;
580  case RPMCUDV_CUDFDOC: rc = cudf->V.val.doc->has_request; break;
581  case RPMCUDV_CUDF: rc = cudf->V.val.cudf->has_request; break;
582  }
583 #endif
584  return rc;
585 }
586 
588 {
589  int rc = 0;
590 #if defined(WITH_CUDF)
591  switch(cudf->V.typ) {
592  default: assert(0); break;
593  case RPMCUDV_NOTYPE: break;
594  case RPMCUDV_CUDF:
595  rc = cudf_is_consistent(cudf->V.val.cudf->universe);
596  break;
597  }
598 #endif
599  return rc;
600 }
601 
603 {
604  int rc = 0;
605 #if defined(WITH_CUDF)
606  switch(cudf->V.typ) {
607  default: assert(0); break;
608  case RPMCUDV_NOTYPE: break;
609  case RPMCUDV_CUDF:
610  rc = cudf_installed_size(cudf->V.val.cudf->universe);
611  break;
612  }
613 #endif
614  return rc;
615 }
616 
618 {
619  int rc = 0;
620 #if defined(WITH_CUDF)
621  switch(cudf->V.typ) {
622  default: assert(0); break;
623  case RPMCUDV_NOTYPE: break;
624  case RPMCUDV_CUDF:
625  rc = cudf_universe_size(cudf->V.val.cudf->universe);
626  break;
627  }
628 #endif
629  return rc;
630 }
631 
633 {
634 #if defined(WITH_CUDF)
635  rpmiobAppend(cudf->iob, "Has preamble: ", 0);
636  rpmiobAppend(cudf->iob, (rpmcudfHasPreamble(cudf) ? "yes" : "no"), 1);
637  if (rpmcudfHasPreamble(cudf)) {
638  rpmiobAppend(cudf->iob, "Preamble: ", 1);
639  print_preamble(cudf);
640  rpmiobAppend(cudf->iob, "", 1);
641  }
642 #endif
643 }
644 
646 {
647 #if defined(WITH_CUDF)
648  rpmiobAppend(cudf->iob, "Has request: ", 0);
649  rpmiobAppend(cudf->iob, (rpmcudfHasRequest(cudf) ? "yes" : "no"), 1);
650  if (rpmcudfHasRequest(cudf)) {
651  rpmiobAppend(cudf->iob, "Request: ", 1);
652  print_request(cudf);
653  rpmiobAppend(cudf->iob, "", 1);
654  }
655 #endif
656 }
657 
659 {
660 #if defined(WITH_CUDF)
661  if (cudf->V.typ == RPMCUDV_CUDFDOC) {
662  rpmcudp cudp = rpmcudpNew(cudf);
663  rpmiobAppend(cudf->iob, "Universe:", 1);
664  while (rpmcudpNext(cudp) != NULL)
665  print_package(cudf, cudp);
666  cudp = rpmcudpFree(cudp);
667  }
668 
669  if (cudf->V.typ == RPMCUDV_CUDFDOC) {
670  cudf_universe_t univ = cudf_load_universe(cudf->V.val.doc->packages);
671  char t[256];
672 
673  snprintf(t, sizeof(t), "Universe size: %d/%d (installed/total)",
674  cudf_installed_size(univ), cudf_universe_size(univ));
675  rpmiobAppend(cudf->iob, t, 1);
676  snprintf(t, sizeof(t), "Universe consistent: %s",
677  cudf_is_consistent(univ) ? "yes" : "no");
678  rpmiobAppend(cudf->iob, t, 1);
679  cudf_free_universe(univ);
680  }
681 #endif
682 }
683 
685 {
686  int rc = 0;
687 #if defined(WITH_CUDF)
688 assert(X->V.typ == RPMCUDV_CUDF);
689 assert(Y->V.typ == RPMCUDV_CUDF);
690  rc = cudf_is_solution(X->V.val.cudf, Y->V.val.cudf->universe);
691 #endif
692  return rc;
693 }
const bson * b
Definition: bson.h:280
rpmcudf rpmcudfNew(char **av, uint32_t flags)
Create and load a cudf interpreter.
Definition: rpmcudf.c:487
char * xstrdup(const char *str)
Definition: rpmmalloc.c:321
int _rpmcudf_debug
Definition: rpmcudf.c:14
int rpmcudfHasRequest(rpmcudf cudf)
Definition: rpmcudf.c:573
int rpmcudfIsSolution(rpmcudf X, rpmcudf Y)
Definition: rpmcudf.c:684
int Stat(const char *path, struct stat *st)
stat(2) clone.
Definition: rpmrpc.c:1361
rpmiob rpmiobFree(rpmiob iob)
Destroy a I/O buffer instance.
rpmiob rpmiobAppend(rpmiob iob, const char *s, size_t nl)
Append string to I/O buffer.
Definition: rpmiob.c:77
int rpmiobSlurp(const char *fn, rpmiob *iobp)
Definition: rpmiob.c:129
char * alloca()
void * xcalloc(size_t nmemb, size_t size)
Definition: rpmmalloc.c:300
const char const bson_bool_t v
Definition: bson.h:919
struct rpmcudv_s * rpmcudv
Definition: rpmcudf.h:13
int w
Definition: mongo.h:436
rpmioItem rpmioGetPool(rpmioPool pool, size_t size)
Get unused item from pool, or alloc a new item.
Definition: rpmmalloc.c:220
static rpmcudf rpmcudfGetPool(rpmioPool pool)
Definition: rpmcudf.c:460
int rpmcudfHasPreamble(rpmcudf cudf)
Definition: rpmcudf.c:559
char * rpmExpand(const char *arg,...)
Return (malloc'ed) concatenated macro expansion(s).
Definition: macro.c:3238
struct rpmcudf_s * rpmcudf
Definition: rpmcudf.h:11
const char const char int arg
Definition: mongo.h:777
rpmiob rpmiobNew(size_t len)
Create an I/O buffer.
Definition: rpmiob.c:44
const char const bson int mongo_write_concern int flags
Definition: mongo.h:485
struct rpmcudp_s * rpmcudp
Definition: rpmcudf.h:12
int rpmcudfInstalledSize(rpmcudf cudf)
Definition: rpmcudf.c:602
char * rpmiobStr(rpmiob iob)
Return I/O buffer (as string).
Definition: rpmiob.c:112
rpmcudf rpmcudfLink(rpmcudf cudf)
Reference a cudf interpreter instance.
static int snprintf(char *buf, int nb, const char *fmt,...)
Definition: rpmps.c:220
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
int rpmcudfUniverseSize(rpmcudf cudf)
Definition: rpmcudf.c:617
char * stpcpy(char *dest, const char *src)
static void * _free(const void *p)
Wrapper to free(3), hides const compilation noise, permit NULL, return NULL.
Definition: rpmiotypes.h:756
struct rpmiob_s * rpmiob
Definition: rpmiotypes.h:60
static void rpmcudfFini(void *_cudf)
Definition: rpmcudf.c:443
void rpmcudfPrintRequest(rpmcudf cudf)
Definition: rpmcudf.c:645
int rpmcudfIsConsistent(rpmcudf cudf)
Definition: rpmcudf.c:587
void rpmcudfPrintUniverse(rpmcudf cudf)
Definition: rpmcudf.c:658
void rpmcudfPrintPreamble(rpmcudf cudf)
Definition: rpmcudf.c:632
rpmioPool _rpmcudfPool
Definition: rpmcudf.c:458