emo/xbps
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Get rid of libfetch and proplib external dependencies.

Browse Source 
The list of required external deps is now confuse, libarchive and openssl.

libxbps now includes a wrapper for proplib prefixed with xbps_ rather than prop_.
This commit is contained in:
Juan RP
2013-06-20 10:26:12 +02:00
parent 31efece727
commit 42c0766c00
67 changed files with 3004 additions and 1487 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
bin/xbps-query/defs.h
View File

@@ -41,15 +41,15 @@ int repo_show_pkg_deps(struct xbps_handle *, const char *, bool);
int repo_show_pkg_revdeps(struct xbps_handle *, const char *);
/* from show-info-files.c */
void show_pkg_info(prop_dictionary_t);
void show_pkg_info_one(prop_dictionary_t, const char *);
void show_pkg_info(xbps_dictionary_t);
void show_pkg_info_one(xbps_dictionary_t, const char *);
int show_pkg_info_from_metadir(struct xbps_handle *, const char *,
const char *);
int show_pkg_files(prop_dictionary_t);
int show_pkg_files(xbps_dictionary_t);
int show_pkg_files_from_metadir(struct xbps_handle *, const char *);
int repo_show_pkg_files(struct xbps_handle *, const char *);
int repo_show_pkg_info(struct xbps_handle *, const char *, const char *);
int repo_show_pkg_namedesc(struct xbps_handle *, prop_object_t, void *,
int repo_show_pkg_namedesc(struct xbps_handle *, xbps_object_t, void *,
bool *);
/* from ownedby.c */
@@ -57,10 +57,10 @@ int ownedby(struct xbps_handle *, int, char **);
int repo_ownedby(struct xbps_handle *, int, char **);
/* From list.c */
unsigned int find_longest_pkgver(struct xbps_handle *, prop_object_t);
unsigned int find_longest_pkgver(struct xbps_handle *, xbps_object_t);
int list_pkgs_in_dict(struct xbps_handle *, prop_object_t, void *, bool *);
int list_manual_pkgs(struct xbps_handle *, prop_object_t, void *, bool *);
int list_pkgs_in_dict(struct xbps_handle *, xbps_object_t, void *, bool *);
int list_manual_pkgs(struct xbps_handle *, xbps_object_t, void *, bool *);
int list_orphans(struct xbps_handle *);
int list_pkgs_pkgdb(struct xbps_handle *);

50
bin/xbps-query/list.c
View File

@@ -40,7 +40,7 @@ struct list_pkgver_cb {
int
list_pkgs_in_dict(struct xbps_handle *xhp,
prop_object_t obj,
xbps_object_t obj,
void *arg,
bool *loop_done)
{
@@ -53,8 +53,8 @@ list_pkgs_in_dict(struct xbps_handle *xhp,
(void)xhp;
(void)loop_done;
prop_dictionary_get_cstring_nocopy(obj, "pkgver", &pkgver);
prop_dictionary_get_cstring_nocopy(obj, "short_desc", &short_desc);
xbps_dictionary_get_cstring_nocopy(obj, "pkgver", &pkgver);
xbps_dictionary_get_cstring_nocopy(obj, "short_desc", &short_desc);
if (!pkgver || !short_desc)
return EINVAL;
@@ -92,7 +92,7 @@ list_pkgs_in_dict(struct xbps_handle *xhp,
int
list_manual_pkgs(struct xbps_handle *xhp,
prop_object_t obj,
xbps_object_t obj,
void *arg,
bool *loop_done)
{
@@ -103,9 +103,9 @@ list_manual_pkgs(struct xbps_handle *xhp,
(void)arg;
(void)loop_done;
prop_dictionary_get_bool(obj, "automatic-install", &automatic);
xbps_dictionary_get_bool(obj, "automatic-install", &automatic);
if (automatic == false) {
prop_dictionary_get_cstring_nocopy(obj, "pkgver", &pkgver);
xbps_dictionary_get_cstring_nocopy(obj, "pkgver", &pkgver);
printf("%s\n", pkgver);
}
@@ -115,24 +115,24 @@ list_manual_pkgs(struct xbps_handle *xhp,
int
list_orphans(struct xbps_handle *xhp)
{
prop_array_t orphans;
prop_object_iterator_t iter;
prop_object_t obj;
xbps_array_t orphans;
xbps_object_iterator_t iter;
xbps_object_t obj;
const char *pkgver;
orphans = xbps_find_pkg_orphans(xhp, NULL);
if (orphans == NULL)
return EINVAL;
if (prop_array_count(orphans) == 0)
if (xbps_array_count(orphans) == 0)
return 0;
iter = prop_array_iterator(orphans);
iter = xbps_array_iterator(orphans);
if (iter == NULL)
return ENOMEM;
while ((obj = prop_object_iterator_next(iter)) != NULL) {
prop_dictionary_get_cstring_nocopy(obj, "pkgver", &pkgver);
while ((obj = xbps_object_iterator_next(iter)) != NULL) {
xbps_dictionary_get_cstring_nocopy(obj, "pkgver", &pkgver);
printf("%s\n", pkgver);
}
@@ -157,7 +157,7 @@ repo_list_uri_cb(struct xbps_repo *repo, void *arg, bool *done)
(void)done;
printf("%s (%u packages)\n", repo->uri,
prop_dictionary_count(repo->idx));
xbps_dictionary_count(repo->idx));
return 0;
}
@@ -177,30 +177,30 @@ repo_list(struct xbps_handle *xhp)
}
struct fflongest {
prop_dictionary_t d;
xbps_dictionary_t d;
unsigned int len;
};
static int
_find_longest_pkgver_cb(struct xbps_handle *xhp,
prop_object_t obj,
xbps_object_t obj,
void *arg,
bool *loop_done)
{
struct fflongest *ffl = arg;
prop_dictionary_t pkgd;
xbps_dictionary_t pkgd;
const char *pkgver;
unsigned int len;
(void)xhp;
(void)loop_done;
if (prop_object_type(obj) == PROP_TYPE_DICT_KEYSYM)
pkgd = prop_dictionary_get_keysym(ffl->d, obj);
if (xbps_object_type(obj) == XBPS_TYPE_DICT_KEYSYM)
pkgd = xbps_dictionary_get_keysym(ffl->d, obj);
else
pkgd = obj;
prop_dictionary_get_cstring_nocopy(pkgd, "pkgver", &pkgver);
xbps_dictionary_get_cstring_nocopy(pkgd, "pkgver", &pkgver);
len = strlen(pkgver);
if (ffl->len == 0 || len > ffl->len)
ffl->len = len;
@@ -209,20 +209,20 @@ _find_longest_pkgver_cb(struct xbps_handle *xhp,
}
unsigned int
find_longest_pkgver(struct xbps_handle *xhp, prop_object_t o)
find_longest_pkgver(struct xbps_handle *xhp, xbps_object_t o)
{
struct fflongest ffl;
ffl.d = o;
ffl.len = 0;
if (prop_object_type(o) == PROP_TYPE_DICTIONARY) {
prop_array_t array;
if (xbps_object_type(o) == XBPS_TYPE_DICTIONARY) {
xbps_array_t array;
array = prop_dictionary_all_keys(o);
array = xbps_dictionary_all_keys(o);
(void)xbps_callback_array_iter(xhp, array,
_find_longest_pkgver_cb, &ffl);
prop_object_release(array);
xbps_object_release(array);
} else {
(void)xbps_pkgdb_foreach_cb(xhp,
_find_longest_pkgver_cb, &ffl);

54
bin/xbps-query/ownedby.c
View File

@@ -42,18 +42,18 @@ struct ffdata {
};
static void
match_files_by_pattern(prop_dictionary_t pkg_filesd,
prop_dictionary_keysym_t key,
match_files_by_pattern(xbps_dictionary_t pkg_filesd,
xbps_dictionary_keysym_t key,
struct ffdata *ffd,
const char *pkgver)
{
prop_array_t array;
prop_object_t obj;
xbps_array_t array;
xbps_object_t obj;
const char *keyname, *filestr, *typestr;
unsigned int i;
int x;
keyname = prop_dictionary_keysym_cstring_nocopy(key);
keyname = xbps_dictionary_keysym_cstring_nocopy(key);
if (strcmp(keyname, "files") == 0)
typestr = "regular file";
@@ -66,10 +66,10 @@ match_files_by_pattern(prop_dictionary_t pkg_filesd,
else
return;
array = prop_dictionary_get_keysym(pkg_filesd, key);
for (i = 0; i < prop_array_count(array); i++) {
obj = prop_array_get(array, i);
prop_dictionary_get_cstring_nocopy(obj, "file", &filestr);
array = xbps_dictionary_get_keysym(pkg_filesd, key);
for (i = 0; i < xbps_array_count(array); i++) {
obj = xbps_array_get(array, i);
xbps_dictionary_get_cstring_nocopy(obj, "file", &filestr);
if (filestr == NULL)
continue;
for (x = 0; x < ffd->npatterns; x++) {
@@ -82,24 +82,24 @@ match_files_by_pattern(prop_dictionary_t pkg_filesd,
}
static int
ownedby_pkgdb_cb(struct xbps_handle *xhp, prop_object_t obj, void *arg, bool *done)
ownedby_pkgdb_cb(struct xbps_handle *xhp, xbps_object_t obj, void *arg, bool *done)
{
prop_dictionary_t pkgmetad;
prop_array_t files_keys;
xbps_dictionary_t pkgmetad;
xbps_array_t files_keys;
struct ffdata *ffd = arg;
unsigned int i;
const char *pkgver;
(void)done;
prop_dictionary_get_cstring_nocopy(obj, "pkgver", &pkgver);
xbps_dictionary_get_cstring_nocopy(obj, "pkgver", &pkgver);
pkgmetad = xbps_pkgdb_get_pkg_metadata(xhp, pkgver);
assert(pkgmetad);
files_keys = prop_dictionary_all_keys(pkgmetad);
for (i = 0; i < prop_array_count(files_keys); i++) {
files_keys = xbps_dictionary_all_keys(pkgmetad);
for (i = 0; i < xbps_array_count(files_keys); i++) {
match_files_by_pattern(pkgmetad,
prop_array_get(files_keys, i), ffd, pkgver);
xbps_array_get(files_keys, i), ffd, pkgver);
}
return 0;
}
@@ -123,7 +123,7 @@ ownedby(struct xbps_handle *xhp, int npatterns, char **patterns)
}
static void
repo_match_files_by_pattern(prop_array_t files,
repo_match_files_by_pattern(xbps_array_t files,
const char *pkgver,
struct ffdata *ffd)
{
@@ -131,8 +131,8 @@ repo_match_files_by_pattern(prop_array_t files,
unsigned int i;
int x;
for (i = 0; i < prop_array_count(files); i++) {
prop_array_get_cstring_nocopy(files, i, &filestr);
for (i = 0; i < xbps_array_count(files); i++) {
xbps_array_get_cstring_nocopy(files, i, &filestr);
for (x = 0; x < ffd->npatterns; x++) {
if ((fnmatch(ffd->patterns[x], filestr, FNM_PERIOD)) == 0) {
printf("%s: %s (%s)\n",
@@ -145,9 +145,9 @@ repo_match_files_by_pattern(prop_array_t files,
static int
repo_ownedby_cb(struct xbps_repo *repo, void *arg, bool *done)
{
prop_array_t allkeys, pkgar;
prop_dictionary_t filesd;
prop_dictionary_keysym_t ksym;
xbps_array_t allkeys, pkgar;
xbps_dictionary_t filesd;
xbps_dictionary_keysym_t ksym;
struct ffdata *ffd = arg;
const char *pkgver;
unsigned int i;
@@ -156,12 +156,12 @@ repo_ownedby_cb(struct xbps_repo *repo, void *arg, bool *done)
filesd = xbps_repo_get_plist(repo, XBPS_PKGINDEX_FILES);
ffd->repouri = repo->uri;
allkeys = prop_dictionary_all_keys(filesd);
allkeys = xbps_dictionary_all_keys(filesd);
for (i = 0; i < prop_array_count(allkeys); i++) {
ksym = prop_array_get(allkeys, i);
pkgar = prop_dictionary_get_keysym(filesd, ksym);
pkgver = prop_dictionary_keysym_cstring_nocopy(ksym);
for (i = 0; i < xbps_array_count(allkeys); i++) {
ksym = xbps_array_get(allkeys, i);
pkgar = xbps_dictionary_get_keysym(filesd, ksym);
pkgver = xbps_dictionary_keysym_cstring_nocopy(ksym);
repo_match_files_by_pattern(pkgar, pkgver, ffd);
}

38
bin/xbps-query/search.c
View File

@@ -48,7 +48,7 @@ struct search_data {
int npatterns;
char **patterns;
int maxcols;
prop_array_t results;
xbps_array_t results;
};
static void
@@ -59,16 +59,16 @@ print_results(struct xbps_handle *xhp, struct search_data *sd)
unsigned int i, j, tlen = 0, len = 0;
/* Iterate over results array and find out largest pkgver string */
for (i = 0; i < prop_array_count(sd->results); i++) {
prop_array_get_cstring_nocopy(sd->results, i, &pkgver);
for (i = 0; i < xbps_array_count(sd->results); i++) {
xbps_array_get_cstring_nocopy(sd->results, i, &pkgver);
len = strlen(pkgver);
if (tlen == 0 || len > tlen)
tlen = len;
i++;
}
for (i = 0; i < prop_array_count(sd->results); i++) {
prop_array_get_cstring_nocopy(sd->results, i, &pkgver);
prop_array_get_cstring_nocopy(sd->results, i+1, &desc);
for (i = 0; i < xbps_array_count(sd->results); i++) {
xbps_array_get_cstring_nocopy(sd->results, i, &pkgver);
xbps_array_get_cstring_nocopy(sd->results, i+1, &desc);
strncpy(tmp, pkgver, sizeof(tmp));
for (j = strlen(tmp); j < tlen; j++)
tmp[j] = ' ';
@@ -98,9 +98,9 @@ print_results(struct xbps_handle *xhp, struct search_data *sd)
static int
search_pkgs_cb(struct xbps_repo *repo, void *arg, bool *done)
{
prop_array_t allkeys;
prop_dictionary_t pkgd;
prop_dictionary_keysym_t ksym;
xbps_array_t allkeys;
xbps_dictionary_t pkgd;
xbps_dictionary_keysym_t ksym;
struct search_data *sd = arg;
const char *pkgver, *desc;
unsigned int i;
@@ -108,13 +108,13 @@ search_pkgs_cb(struct xbps_repo *repo, void *arg, bool *done)
(void)done;
allkeys = prop_dictionary_all_keys(repo->idx);
for (i = 0; i < prop_array_count(allkeys); i++) {
ksym = prop_array_get(allkeys, i);
pkgd = prop_dictionary_get_keysym(repo->idx, ksym);
allkeys = xbps_dictionary_all_keys(repo->idx);
for (i = 0; i < xbps_array_count(allkeys); i++) {
ksym = xbps_array_get(allkeys, i);
pkgd = xbps_dictionary_get_keysym(repo->idx, ksym);
prop_dictionary_get_cstring_nocopy(pkgd, "pkgver", &pkgver);
prop_dictionary_get_cstring_nocopy(pkgd, "short_desc", &desc);
xbps_dictionary_get_cstring_nocopy(pkgd, "pkgver", &pkgver);
xbps_dictionary_get_cstring_nocopy(pkgd, "short_desc", &desc);
for (x = 0; x < sd->npatterns; x++) {
bool vpkgfound = false;
@@ -125,12 +125,12 @@ search_pkgs_cb(struct xbps_repo *repo, void *arg, bool *done)
if ((xbps_pkgpattern_match(pkgver, sd->patterns[x])) ||
(strcasestr(pkgver, sd->patterns[x])) ||
(strcasestr(desc, sd->patterns[x])) || vpkgfound) {
prop_array_add_cstring_nocopy(sd->results, pkgver);
prop_array_add_cstring_nocopy(sd->results, desc);
xbps_array_add_cstring_nocopy(sd->results, pkgver);
xbps_array_add_cstring_nocopy(sd->results, desc);
}
}
}
prop_object_release(allkeys);
xbps_object_release(allkeys);
return 0;
}
@@ -144,7 +144,7 @@ repo_search(struct xbps_handle *xhp, int npatterns, char **patterns)
sd.npatterns = npatterns;
sd.patterns = patterns;
sd.maxcols = get_maxcols();
sd.results = prop_array_create();
sd.results = xbps_array_create();
rv = xbps_rpool_foreach(xhp, search_pkgs_cb, &sd);
if (rv != 0 && rv != ENOTSUP)

36
bin/xbps-query/show-deps.c
View File

@@ -34,11 +34,11 @@
#include "defs.h"
static void
print_rdeps(struct xbps_handle *xhp, prop_array_t rdeps,
print_rdeps(struct xbps_handle *xhp, xbps_array_t rdeps,
bool full, bool repo, bool origin, int *indent)
{
prop_array_t currdeps;
prop_dictionary_t pkgd;
xbps_array_t currdeps;
xbps_dictionary_t pkgd;
const char *pkgdep;
unsigned int i;
int j;
@@ -46,8 +46,8 @@ print_rdeps(struct xbps_handle *xhp, prop_array_t rdeps,
if (!origin)
(*indent)++;
for (i = 0; i < prop_array_count(rdeps); i++) {
prop_array_get_cstring_nocopy(rdeps, i, &pkgdep);
for (i = 0; i < xbps_array_count(rdeps); i++) {
xbps_array_get_cstring_nocopy(rdeps, i, &pkgdep);
if (!origin || !full)
for (j = 0; j < *indent; j++)
putchar(' ');
@@ -66,7 +66,7 @@ print_rdeps(struct xbps_handle *xhp, prop_array_t rdeps,
pkgd = xbps_pkgdb_get_virtualpkg(xhp, pkgdep);
}
if (pkgd != NULL) {
currdeps = prop_dictionary_get(pkgd, "run_depends");
currdeps = xbps_dictionary_get(pkgd, "run_depends");
if (currdeps != NULL)
print_rdeps(xhp, currdeps,
full, repo, false, indent);
@@ -78,15 +78,15 @@ print_rdeps(struct xbps_handle *xhp, prop_array_t rdeps,
int
show_pkg_deps(struct xbps_handle *xhp, const char *pkgname, bool full)
{
prop_array_t rdeps;
prop_dictionary_t pkgd;
xbps_array_t rdeps;
xbps_dictionary_t pkgd;
int indent = 0;
pkgd = xbps_pkgdb_get_pkg(xhp, pkgname);
if (pkgd == NULL)
return ENOENT;
rdeps = prop_dictionary_get(pkgd, "run_depends");
rdeps = xbps_dictionary_get(pkgd, "run_depends");
if (rdeps != NULL)
print_rdeps(xhp, rdeps, full, false, true, &indent);
@@ -96,13 +96,13 @@ show_pkg_deps(struct xbps_handle *xhp, const char *pkgname, bool full)
int
show_pkg_revdeps(struct xbps_handle *xhp, const char *pkg)
{
prop_array_t reqby;
xbps_array_t reqby;
const char *pkgdep;
unsigned int i;
if ((reqby = xbps_pkgdb_get_pkg_revdeps(xhp, pkg)) != NULL) {
for (i = 0; i < prop_array_count(reqby); i++) {
prop_array_get_cstring_nocopy(reqby, i, &pkgdep);
for (i = 0; i < xbps_array_count(reqby); i++) {
xbps_array_get_cstring_nocopy(reqby, i, &pkgdep);
printf("%s\n", pkgdep);
}
}
@@ -112,15 +112,15 @@ show_pkg_revdeps(struct xbps_handle *xhp, const char *pkg)
int
repo_show_pkg_deps(struct xbps_handle *xhp, const char *pattern, bool full)
{
prop_array_t rdeps;
prop_dictionary_t pkgd;
xbps_array_t rdeps;
xbps_dictionary_t pkgd;
int indent = 0;
if (((pkgd = xbps_rpool_get_pkg(xhp, pattern)) == NULL) &&
((pkgd = xbps_rpool_get_virtualpkg(xhp, pattern)) == NULL))
return errno;
rdeps = prop_dictionary_get(pkgd, "run_depends");
rdeps = xbps_dictionary_get(pkgd, "run_depends");
if (rdeps != NULL)
print_rdeps(xhp, rdeps, full, true, true, &indent);
@@ -130,7 +130,7 @@ repo_show_pkg_deps(struct xbps_handle *xhp, const char *pattern, bool full)
int
repo_show_pkg_revdeps(struct xbps_handle *xhp, const char *pkg)
{
prop_array_t revdeps;
xbps_array_t revdeps;
const char *pkgver;
unsigned int i;
int rv;
@@ -138,8 +138,8 @@ repo_show_pkg_revdeps(struct xbps_handle *xhp, const char *pkg)
revdeps = xbps_rpool_get_pkg_revdeps(xhp, pkg);
rv = errno;
for (i = 0; i < prop_array_count(revdeps); i++) {
prop_array_get_cstring_nocopy(revdeps, i, &pkgver);
for (i = 0; i < xbps_array_count(revdeps); i++) {
xbps_array_get_cstring_nocopy(revdeps, i, &pkgver);
printf("%s\n", pkgver);
}

138
bin/xbps-query/show-info-files.c
View File

@@ -37,11 +37,11 @@
#include "defs.h"
static void
print_value_obj(const char *keyname, prop_object_t obj,
print_value_obj(const char *keyname, xbps_object_t obj,
const char *indent, bool raw)
{
prop_array_t allkeys;
prop_object_t obj2, keysym;
xbps_array_t allkeys;
xbps_object_t obj2, keysym;
const char *ksymname, *value;
unsigned int i;
char size[8];
@@ -49,34 +49,34 @@ print_value_obj(const char *keyname, prop_object_t obj,
if (indent == NULL)
indent = "";
switch (prop_object_type(obj)) {
case PROP_TYPE_STRING:
switch (xbps_object_type(obj)) {
case XBPS_TYPE_STRING:
if (!raw)
printf("%s%s: ", indent, keyname);
printf("%s\n", prop_string_cstring_nocopy(obj));
printf("%s\n", xbps_string_cstring_nocopy(obj));
break;
case PROP_TYPE_NUMBER:
case XBPS_TYPE_NUMBER:
if (!raw)
printf("%s%s: ", indent, keyname);
if (xbps_humanize_number(size,
(int64_t)prop_number_unsigned_integer_value(obj)) == -1)
(int64_t)xbps_number_unsigned_integer_value(obj)) == -1)
printf("%ju\n",
prop_number_unsigned_integer_value(obj));
xbps_number_unsigned_integer_value(obj));
else
printf("%s\n", size);
break;
case PROP_TYPE_BOOL:
case XBPS_TYPE_BOOL:
if (!raw)
printf("%s%s: ", indent, keyname);
printf("%s\n", prop_bool_true(obj) ? "yes" : "no");
printf("%s\n", xbps_bool_true(obj) ? "yes" : "no");
break;
case PROP_TYPE_ARRAY:
case XBPS_TYPE_ARRAY:
if (!raw)
printf("%s%s:\n", indent, keyname);
for (i = 0; i < prop_array_count(obj); i++) {
obj2 = prop_array_get(obj, i);
if (prop_object_type(obj2) == PROP_TYPE_STRING) {
value = prop_string_cstring_nocopy(obj2);
for (i = 0; i < xbps_array_count(obj); i++) {
obj2 = xbps_array_get(obj, i);
if (xbps_object_type(obj2) == XBPS_TYPE_STRING) {
value = xbps_string_cstring_nocopy(obj2);
printf("%s%s%s\n", indent, !raw ? "\t" : "",
value);
} else {
@@ -84,29 +84,29 @@ print_value_obj(const char *keyname, prop_object_t obj,
}
}
break;
case PROP_TYPE_DICTIONARY:
allkeys = prop_dictionary_all_keys(obj);
for (i = 0; i < prop_array_count(allkeys); i++) {
keysym = prop_array_get(allkeys, i);
ksymname = prop_dictionary_keysym_cstring_nocopy(keysym);
obj2 = prop_dictionary_get_keysym(obj, keysym);
case XBPS_TYPE_DICTIONARY:
allkeys = xbps_dictionary_all_keys(obj);
for (i = 0; i < xbps_array_count(allkeys); i++) {
keysym = xbps_array_get(allkeys, i);
ksymname = xbps_dictionary_keysym_cstring_nocopy(keysym);
obj2 = xbps_dictionary_get_keysym(obj, keysym);
print_value_obj(ksymname, obj2, " ", raw);
}
prop_object_release(allkeys);
xbps_object_release(allkeys);
if (raw)
printf("\n");
break;
case PROP_TYPE_DATA:
case XBPS_TYPE_DATA:
if (!raw) {
xbps_humanize_number(size, (int64_t)prop_data_size(obj));
xbps_humanize_number(size, (int64_t)xbps_data_size(obj));
printf("%s%s: %s\n", indent, keyname, size);
} else {
FILE *f;
char buf[BUFSIZ-1];
void *data;
data = prop_data_data(obj);
f = fmemopen(data, prop_data_size(obj), "r");
data = xbps_data_data(obj);
f = fmemopen(data, xbps_data_size(obj), "r");
assert(f);
while (fgets(buf, BUFSIZ-1, f))
printf("%s", buf);
@@ -122,13 +122,13 @@ print_value_obj(const char *keyname, prop_object_t obj,
}
void
show_pkg_info_one(prop_dictionary_t d, const char *keys)
show_pkg_info_one(xbps_dictionary_t d, const char *keys)
{
prop_object_t obj;
xbps_object_t obj;
char *key, *p, *saveptr;
if (strchr(keys, ',') == NULL) {
obj = prop_dictionary_get(d, keys);
obj = xbps_dictionary_get(d, keys);
if (obj == NULL)
return;
print_value_obj(keys, obj, NULL, true);
@@ -139,7 +139,7 @@ show_pkg_info_one(prop_dictionary_t d, const char *keys)
abort();
for ((p = strtok_r(key, ",", &saveptr)); p;
(p = strtok_r(NULL, ",", &saveptr))) {
obj = prop_dictionary_get(d, p);
obj = xbps_dictionary_get(d, p);
if (obj == NULL)
continue;
print_value_obj(p, obj, NULL, true);
@@ -148,9 +148,9 @@ show_pkg_info_one(prop_dictionary_t d, const char *keys)
}
static void
print_srcrevs(const char *keyname, prop_string_t obj)
print_srcrevs(const char *keyname, xbps_string_t obj)
{
const char *str = prop_string_cstring_nocopy(obj);
const char *str = xbps_string_cstring_nocopy(obj);
unsigned int i;
/* parse string appending a \t after EOL */
@@ -165,18 +165,18 @@ print_srcrevs(const char *keyname, prop_string_t obj)
}
void
show_pkg_info(prop_dictionary_t dict)
show_pkg_info(xbps_dictionary_t dict)
{
prop_array_t all_keys;
prop_object_t obj, keysym;
xbps_array_t all_keys;
xbps_object_t obj, keysym;
const char *keyname;
unsigned int i;
all_keys = prop_dictionary_all_keys(dict);
for (i = 0; i < prop_array_count(all_keys); i++) {
keysym = prop_array_get(all_keys, i);
keyname = prop_dictionary_keysym_cstring_nocopy(keysym);
obj = prop_dictionary_get_keysym(dict, keysym);
all_keys = xbps_dictionary_all_keys(dict);
for (i = 0; i < xbps_array_count(all_keys); i++) {
keysym = xbps_array_get(all_keys, i);
keyname = xbps_dictionary_keysym_cstring_nocopy(keysym);
obj = xbps_dictionary_get_keysym(dict, keysym);
/* ignore objs shown by other targets */
if ((strcmp(keyname, "run_depends") == 0) ||
(strcmp(keyname, "files") == 0) ||
@@ -195,37 +195,37 @@ show_pkg_info(prop_dictionary_t dict)
}
int
show_pkg_files(prop_dictionary_t filesd)
show_pkg_files(xbps_dictionary_t filesd)
{
prop_array_t array, allkeys;
prop_object_t obj;
prop_dictionary_keysym_t ksym;
xbps_array_t array, allkeys;
xbps_object_t obj;
xbps_dictionary_keysym_t ksym;
const char *keyname, *file;
unsigned int i, x;
if (prop_object_type(filesd) != PROP_TYPE_DICTIONARY)
if (xbps_object_type(filesd) != XBPS_TYPE_DICTIONARY)
return EINVAL;
allkeys = prop_dictionary_all_keys(filesd);
for (i = 0; i < prop_array_count(allkeys); i++) {
ksym = prop_array_get(allkeys, i);
keyname = prop_dictionary_keysym_cstring_nocopy(ksym);
allkeys = xbps_dictionary_all_keys(filesd);
for (i = 0; i < xbps_array_count(allkeys); i++) {
ksym = xbps_array_get(allkeys, i);
keyname = xbps_dictionary_keysym_cstring_nocopy(ksym);
if ((strcmp(keyname, "files") &&
(strcmp(keyname, "conf_files") &&
(strcmp(keyname, "links")))))
continue;
array = prop_dictionary_get(filesd, keyname);
if (array == NULL || prop_array_count(array) == 0)
array = xbps_dictionary_get(filesd, keyname);
if (array == NULL || xbps_array_count(array) == 0)
continue;
for (x = 0; x < prop_array_count(array); x++) {
obj = prop_array_get(array, x);
if (prop_object_type(obj) != PROP_TYPE_DICTIONARY)
for (x = 0; x < xbps_array_count(array); x++) {
obj = xbps_array_get(array, x);
if (xbps_object_type(obj) != XBPS_TYPE_DICTIONARY)
continue;
prop_dictionary_get_cstring_nocopy(obj, "file", &file);
xbps_dictionary_get_cstring_nocopy(obj, "file", &file);
printf("%s", file);
if (prop_dictionary_get_cstring_nocopy(obj,
if (xbps_dictionary_get_cstring_nocopy(obj,
"target", &file))
printf(" -> %s", file);
@@ -241,7 +241,7 @@ show_pkg_info_from_metadir(struct xbps_handle *xhp,
const char *pkg,
const char *option)
{
prop_dictionary_t d, pkgdb_d;
xbps_dictionary_t d, pkgdb_d;
const char *instdate;
bool autoinst;
pkg_state_t state;
@@ -254,13 +254,13 @@ show_pkg_info_from_metadir(struct xbps_handle *xhp,
if (d == NULL)
return ENOENT;
if (prop_dictionary_get_cstring_nocopy(pkgdb_d,
if (xbps_dictionary_get_cstring_nocopy(pkgdb_d,
"install-date", &instdate))
prop_dictionary_set_cstring_nocopy(d, "install-date",
xbps_dictionary_set_cstring_nocopy(d, "install-date",
instdate);
if (prop_dictionary_get_bool(pkgdb_d, "automatic-install", &autoinst))
prop_dictionary_set_bool(d, "automatic-install", autoinst);
if (xbps_dictionary_get_bool(pkgdb_d, "automatic-install", &autoinst))
xbps_dictionary_set_bool(d, "automatic-install", autoinst);
xbps_pkg_state_dictionary(pkgdb_d, &state);
xbps_set_pkg_state_dictionary(d, state);
@@ -276,7 +276,7 @@ show_pkg_info_from_metadir(struct xbps_handle *xhp,
int
show_pkg_files_from_metadir(struct xbps_handle *xhp, const char *pkg)
{
prop_dictionary_t d;
xbps_dictionary_t d;
int rv = 0;
d = xbps_pkgdb_get_pkg_metadata(xhp, pkg);
@@ -293,7 +293,7 @@ repo_show_pkg_info(struct xbps_handle *xhp,
const char *pattern,
const char *option)
{
prop_dictionary_t ipkgd, bpkgd;
xbps_dictionary_t ipkgd, bpkgd;
if (((ipkgd = xbps_rpool_get_pkg(xhp, pattern)) == NULL) &&
((ipkgd = xbps_rpool_get_virtualpkg(xhp, pattern)) == NULL))
@@ -302,10 +302,10 @@ repo_show_pkg_info(struct xbps_handle *xhp,
if ((bpkgd = xbps_repo_get_pkg_plist(xhp, ipkgd, "./props.plist")) == NULL)
return errno;
prop_dictionary_set(bpkgd, "filename-sha256",
prop_dictionary_get(ipkgd, "filename-sha256"));
prop_dictionary_set(bpkgd, "filename-size",
prop_dictionary_get(ipkgd, "filename-size"));
xbps_dictionary_set(bpkgd, "filename-sha256",
xbps_dictionary_get(ipkgd, "filename-sha256"));
xbps_dictionary_set(bpkgd, "filename-size",
xbps_dictionary_get(ipkgd, "filename-size"));
if (option)
show_pkg_info_one(bpkgd, option);
@@ -318,7 +318,7 @@ repo_show_pkg_info(struct xbps_handle *xhp,
int
repo_show_pkg_files(struct xbps_handle *xhp, const char *pkg)
{
prop_dictionary_t pkgd;
xbps_dictionary_t pkgd;
pkgd = xbps_rpool_get_pkg_plist(xhp, pkg, "./files.plist");
if (pkgd == NULL) {