3 #define _RPMIOB_INTERNAL
8 #define _RPMCUDF_INTERNAL
23 #if defined(WITH_CUDF)
34 fprintf(stderr,
"%s: unexpected type: %d\n", __FUNCTION__, v->typ);
50 case RPMCUDV_VPKGFORMULA:
51 cudf_free_vpkgformula(v->val.f);
55 cudf_free_vpkg(v->val.vpkg);
57 case RPMCUDV_VPKGLIST:
58 case RPMCUDV_VEQPKGLIST:
59 cudf_free_vpkglist(v->val.vpkgs);
61 case RPMCUDV_TYPEDECL:
69 cudf_free_doc(v->val.doc);
72 cudf_free_cudf(v->val.cudf);
75 g_hash_table_destroy(v->val.extra);
78 memset(v, 0,
sizeof(*v));
82 static const char * relops[] = {
98 assert(v->typ == RPMCUDV_VPKG || v->typ == RPMCUDV_VEQPKG);
101 size_t nb = strlen(v->val.vpkg->name) + 5 + 64;
105 be =
stpcpy(be, v->val.vpkg->name);
106 if (v->val.vpkg->relop) {
108 relops[v->val.vpkg->relop & 0x7],
109 v->val.vpkg->version);
123 assert(v->typ == RPMCUDV_VPKGLIST || v->typ == RPMCUDV_VEQPKGLIST);
125 for (l = v->val.vpkgs, last=g_list_last(l); l != NULL; l = g_list_next(l)) {
127 x.typ = RPMCUDV_VPKG;
128 x.val.vpkg = g_list_nth_data(l, 0);
129 rpmcudvPrint(cudf, &x, 0);
139 cudf_vpkgformula_t l;
142 assert(v->typ == RPMCUDV_VPKGFORMULA);
144 for (l = v->val.f, last=g_list_last(l); l != NULL; l = g_list_next(l)) {
146 x.typ = RPMCUDV_VPKGLIST;
147 x.val.vpkg = g_list_nth_data(l, 0);
149 print_vpkglist(cudf, &x,
" | ");
157 void print_preamble(
rpmcudf cudf)
159 static char *props[] = {
160 "preamble",
"property",
"univ-checksum",
"status-checksum",
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);
179 void print_request(
rpmcudf cudf)
181 static char *props[] = {
182 "request",
"install",
"remove",
"upgrade", NULL
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);
200 void print_keep(
rpmcudf cudf,
int keep)
205 fprintf(stderr,
"%s: unexpected keep value: %d\n", __FUNCTION__, keep);
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;
218 void print_property(
void * k,
void * v,
void * _cudf)
224 rpmcudvPrint(cudf, v, 0);
229 #define print_extra(_cudf, e) g_hash_table_foreach(e, print_property, _cudf)
233 const char * s = NULL;
241 fprintf(stderr,
"%s: unexpected type: %d\n", __FUNCTION__, v->typ);
249 snprintf(t,
sizeof(t),
"%d", v->val.i);
253 s = (v->val.i ?
"true" :
"false");
256 case RPMCUDV_PKGNAME:
261 case RPMCUDV_VPKGFORMULA:
262 print_vpkgformula(cudf, v);
263 if (free) rpmcudvFree(v);
269 case RPMCUDV_VPKGLIST:
270 case RPMCUDV_VEQPKGLIST:
271 print_vpkglist(cudf, v,
", ");
272 if (free) rpmcudvFree(v);
274 case RPMCUDV_TYPEDECL:
278 case RPMCUDV_PACKAGE:
281 case RPMCUDV_CUDFDOC:
288 print_extra(cudf, v->val.extra);
289 if (free) rpmcudvFree(v);
299 memset(cudp, 0,
sizeof(*cudp));
308 cudp->l = cudf->V.val.doc->packages;
314 if (cudp == NULL || cudp->l == 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);
322 static const char * rpmcudpName(
rpmcudp cudp)
325 assert(v->typ == RPMCUDV_PACKAGE);
326 return cudf_pkg_name(v->val.pkg);
330 static int rpmcudpVersion(
rpmcudp cudp)
333 assert(v->typ == RPMCUDV_PACKAGE);
334 return cudf_pkg_version(v->val.pkg);
337 static int rpmcudpInstalled(
rpmcudp cudp)
340 assert(v->typ == RPMCUDV_PACKAGE);
341 return cudf_pkg_installed(v->val.pkg);
344 static int rpmcudpWasInstalled(
rpmcudp cudp)
347 assert(v->typ == RPMCUDV_PACKAGE);
348 return cudf_pkg_was_installed(v->val.pkg);
362 assert(v->typ == RPMCUDV_PACKAGE);
363 return rpmcudpW(cudp, RPMCUDV_VPKGFORMULA, cudf_pkg_depends(v->val.pkg));
369 assert(v->typ == RPMCUDV_PACKAGE);
370 return rpmcudpW(cudp, RPMCUDV_VPKGLIST, cudf_pkg_conflicts(v->val.pkg));
376 assert(v->typ == RPMCUDV_PACKAGE);
377 return rpmcudpW(cudp, RPMCUDV_VPKGLIST, cudf_pkg_provides(v->val.pkg));
380 static int rpmcudpKeep(
rpmcudp cudp)
383 assert(v->typ == RPMCUDV_PACKAGE);
385 return cudf_pkg_keep(v->val.pkg);
391 assert(v->typ == RPMCUDV_PACKAGE);
392 return rpmcudpW(cudp, RPMCUDV_EXTRA, cudf_pkg_extra(v->val.pkg));
403 assert(v->typ == RPMCUDV_PACKAGE);
405 snprintf(t,
sizeof(t),
" package: %s", rpmcudpName(cudp));
408 snprintf(t,
sizeof(t),
" version: %d", rpmcudpVersion(cudp));
411 snprintf(t,
sizeof(t),
" installed: %s",
412 rpmcudpInstalled(cudp) ?
"true" :
"false");
415 snprintf(t,
sizeof(t),
" was-installed: %s",
416 rpmcudpWasInstalled(cudp) ?
"true" :
"false");
420 rpmcudvPrint(cudf, rpmcudpDepends(cudp), 1);
424 rpmcudvPrint(cudf, rpmcudpConflicts(cudp), 1);
428 rpmcudvPrint(cudf, rpmcudpProvides(cudp), 1);
432 print_keep(cudf, rpmcudpKeep(cudp));
434 rpmcudvPrint(cudf, rpmcudpExtra(cudp), 0);
449 #if defined(WITH_CUDF)
450 (void) rpmcudvFree(&cudf->V);
451 memset(&cudf->V, 0,
sizeof(cudf->V));
466 if (_rpmcudfPool == NULL) {
472 memset(((
char *)cudf)+
sizeof(cudf->_item), 0,
sizeof(*cudf)-
sizeof(cudf->_item));
481 if (_rpmcudfI == NULL)
491 (flags & 0x80000000) ? rpmcudfI() :
494 const char * fn = (av ? av[0] : NULL);
496 static int oneshot = 0;
499 #if defined(WITH_CUDF)
509 fprintf(stderr,
"==> %s(%p, %d) cudf %p\n", __FUNCTION__, av, flags, cudf);
511 #if defined(WITH_CUDF)
517 case RPMCUDV_CUDFDOC:
519 cudf->V.val.ptr = cudf_parse_from_file((
char *)fn);
523 cudf->V.val.ptr = cudf_load_from_file((
char *)fn);
532 static const char * rpmcudfSlurp(
const char *
arg)
536 const char * val = NULL;
540 if (!strcmp(arg,
"-")) {
543 if ((arg[0] ==
'/' || strchr(arg,
' ') == NULL)
545 && S_ISREG(sb.st_mode)) {
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;
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;
590 #if defined(WITH_CUDF)
591 switch(cudf->V.typ) {
592 default: assert(0);
break;
593 case RPMCUDV_NOTYPE:
break;
595 rc = cudf_is_consistent(cudf->V.val.cudf->universe);
605 #if defined(WITH_CUDF)
606 switch(cudf->V.typ) {
607 default: assert(0);
break;
608 case RPMCUDV_NOTYPE:
break;
610 rc = cudf_installed_size(cudf->V.val.cudf->universe);
620 #if defined(WITH_CUDF)
621 switch(cudf->V.typ) {
622 default: assert(0);
break;
623 case RPMCUDV_NOTYPE:
break;
625 rc = cudf_universe_size(cudf->V.val.cudf->universe);
634 #if defined(WITH_CUDF)
639 print_preamble(cudf);
647 #if defined(WITH_CUDF)
660 #if defined(WITH_CUDF)
661 if (cudf->V.typ == RPMCUDV_CUDFDOC) {
662 rpmcudp cudp = rpmcudpNew(cudf);
664 while (rpmcudpNext(cudp) != NULL)
665 print_package(cudf, cudp);
666 cudp = rpmcudpFree(cudp);
669 if (cudf->V.typ == RPMCUDV_CUDFDOC) {
670 cudf_universe_t univ = cudf_load_universe(cudf->V.val.doc->packages);
673 snprintf(t,
sizeof(t),
"Universe size: %d/%d (installed/total)",
674 cudf_installed_size(univ), cudf_universe_size(univ));
676 snprintf(t,
sizeof(t),
"Universe consistent: %s",
677 cudf_is_consistent(univ) ?
"yes" :
"no");
679 cudf_free_universe(univ);
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);
rpmcudf rpmcudfNew(char **av, uint32_t flags)
Create and load a cudf interpreter.
char * xstrdup(const char *str)
int rpmcudfHasRequest(rpmcudf cudf)
int rpmcudfIsSolution(rpmcudf X, rpmcudf Y)
int Stat(const char *path, struct stat *st)
stat(2) clone.
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.
int rpmiobSlurp(const char *fn, rpmiob *iobp)
void * xcalloc(size_t nmemb, size_t size)
const char const bson_bool_t v
struct rpmcudv_s * rpmcudv
rpmioItem rpmioGetPool(rpmioPool pool, size_t size)
Get unused item from pool, or alloc a new item.
static rpmcudf rpmcudfGetPool(rpmioPool pool)
int rpmcudfHasPreamble(rpmcudf cudf)
char * rpmExpand(const char *arg,...)
Return (malloc'ed) concatenated macro expansion(s).
struct rpmcudf_s * rpmcudf
const char const char int arg
rpmiob rpmiobNew(size_t len)
Create an I/O buffer.
const char const bson int mongo_write_concern int flags
struct rpmcudp_s * rpmcudp
int rpmcudfInstalledSize(rpmcudf cudf)
char * rpmiobStr(rpmiob iob)
Return I/O buffer (as string).
rpmcudf rpmcudfLink(rpmcudf cudf)
Reference a cudf interpreter instance.
static int snprintf(char *buf, int nb, const char *fmt,...)
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.
int rpmcudfUniverseSize(rpmcudf cudf)
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.
static void rpmcudfFini(void *_cudf)
void rpmcudfPrintRequest(rpmcudf cudf)
int rpmcudfIsConsistent(rpmcudf cudf)
void rpmcudfPrintUniverse(rpmcudf cudf)
void rpmcudfPrintPreamble(rpmcudf cudf)