- name: freebsd13-amd64

                  freebsd_instance:

                     image: freebsd-13-0-release-amd64

                - name: freebsd14-amd64

                  freebsd_instance:

                     image_family: freebsd-14-0-snap

                - make -j4 || make V=1

        check_script: make check || { kyua report --verbose ; exit 1 ; }

alpine_task:

        container:

	make-template $dir/Makefile.autosetup $dir/Makefile

}

	funopen.c

LOCAL_CFLAGS=	-I$(top_srcdir)/compat \

include $(MK)/static-lib.mk

MAN5GZ=	$(MAN5:.5=.5.gz)

MAN8GZ=	$(MAN8:.8=.8.gz)

.SUFFIXES: .3.gz .5.gz .8.gz .3 .5 .8

all: $(MAN3GZ) $(MAN5GZ) $(MAN8GZ)

.3.3.gz:

.5.5.gz:

.8.8.gz:

clean:

	rm -f *.gz

SRCS=	blake2b-ref.c blake2s-ref.c

LOCAL_CFLAGS=	-I$(top_srcdir)/compat -O3

include $(MK)/static-lib.mk

LOCAL_CFLAGS=	-I$(top_srcdir)/compat \

		-I$(top_srcdir) \

		-Wno-unused-parameter \

		-Wno-pointer-sign \

		-DWITH_SSL \

		-DINET6

include $(MK)/static-lib.mk

		-Wno-unused-parameter \

		-Wno-pointer-sign

include $(MK)/static-lib.mk

include @builddir@/mk/defs.mk

LIB=	linenoise

SRCS=	linenoise.c

include $(MK)/static-lib.mk

SRCS=	msgpuck.c \

	hints.c

include $(MK)/static-lib.mk

	version.c

LOCAL_CFLAGS=	-Wno-strict-aliasing \

		-Wno-unused -DNGETRUSAGE

include $(MK)/static-lib.mk

	shell.c

LOCAL_CFLAGS=	-I$(top_srcdir)/external/linenoise \

		-D_HAVE_SQLITE_CONFIG_H \

		-DHAVE_LINENOISE \

		-Wno-unused-variable \

		-Dmain=sqlite3_shell \

		-DNDEBUG

include $(MK)/static-lib.mk

SRCS=	yxml.c

include $(MK)/static-lib.mk

		-I$(top_srcdir)/external/liblua/ \

		-I$(top_srcdir)/external/msgpuck \

		-I$(top_srcdir)/libpkg/repo \

		-I$(top_srcdir)/libpkg \

		-I$(top_srcdir) \

		-Wno-pointer-sign \

		-Wno-missing-field-initializers \

		-Wno-sign-compare \

SRCS+=		pkg_macho.c

@else

SRCS+=		pkg_elf.c

@endif

@if libelf-internal

LOCAL_LDFLAGS+=	@PKG_LIBLDNS_LDFLAGS@ @PKG_LIBLDNS_LIBS@

@endif

include $(MK)/lib.mk

$(OBJS) $(SHOBJS): $(top_builddir)/pkg_config.h

int pkg_add(struct pkgdb *db, const char *path, unsigned flags,

    struct pkg_manifest_key *keys, const char *location);

#define PKG_ADD_UPGRADE			(1U << 0)

/* (1U << 1) removed intentionally */

#define PKG_ADD_AUTOMATIC		(1U << 2)

}

static int

{

	struct pkg_file *f;

	int ret = EPKG_OK;

						backup_library(db, old, f->path);

					}

				}

				pkg_delete_file(old, f, flags & PKG_DELETE_FORCE ? 1 : 0);

			}

		}

static int

pkg_add_common(struct pkgdb *db, const char *path, unsigned flags,

    struct pkg_manifest_key *keys, const char *reloc, struct pkg *remote,

{

	struct archive		*a;

	struct archive_entry	*ae;

	if (local != NULL) {

		pkg_open_root_fd(local);

		pkg_debug(1, "Cleaning up old version");

			retcode = EPKG_FATAL;

			goto cleanup;

		}

pkg_add(struct pkgdb *db, const char *path, unsigned flags,

    struct pkg_manifest_key *keys, const char *location)

{

}

int

pkg_add_from_remote(struct pkgdb *db, const char *path, unsigned flags,

{

}

int

pkg_add_upgrade(struct pkgdb *db, const char *path, unsigned flags,

    struct pkg_manifest_key *keys, const char *location,

{

	if (pkgdb_ensure_loaded(db, lp,

	    PKG_LOAD_FILES|PKG_LOAD_SCRIPTS|PKG_LOAD_DIRS|PKG_LOAD_LUA_SCRIPTS) != EPKG_OK)

		return (EPKG_FATAL);

}

int

			 * forget all stuff parsed

			 */

			pkg_debug(1, "PkgConfig: disabling repo %s", rname);

			pkg_repo_free(r);

			return;

		}

	ucl_object_iter_t it = NULL;

	struct pkg_repo *r;

	const char *key;

	while ((cur = ucl_iterate_object(obj, &it, true))) {

		key = ucl_object_key(cur);

			pkg_debug(1, "PkgConfig: overwriting repository %s", key);

		if (cur->type == UCL_OBJECT)

			add_repo(cur, r, key, flags);

			pkg_emit_error("Ignoring bad configuration entry in %s: %s",

	}

}

#endif

int

{

	xstring		*message = NULL;

	int		 ret;

		}

	}

            != EPKG_OK)

		return (ret);

}

int

	/* force: 0 ... be careful and vocal about it.

	 *        1 ... remove files without bothering about checksums.

	 *        2 ... like 1, but remain silent if removal fails.

	while (pkg_files(pkg, &file) == EPKG_OK) {

		append_touched_file(file->path);

		pkg_emit_progress_tick(cur_file++, nfiles);

		pkg_delete_file(pkg, file, force);

	}

	(*j)->pinning = true;

	(*j)->flags = PKG_FLAG_NONE;

	(*j)->conservative = pkg_object_bool(pkg_config_get("CONSERVATIVE_UPGRADE"));

	return (EPKG_OK);

}

	pkg_jobs_universe_free(j->universe);

	LL_FREE(j->jobs, free);

	LL_FREE(j->patterns, pkg_jobs_pattern_free);

	free(j);

}

}

static int

{

	struct pkg *p = NULL;

	struct pkgdb_it *it;

				PKG_LOAD_ANNOTATIONS|PKG_LOAD_CONFLICTS;

	int rc = EPKG_FATAL;

	xstring *qmsg = NULL;

	if ((it = pkgdb_repo_query_cond(j->db, cond, pattern, m, j->reponame)) == NULL)

		return (EPKG_FATAL);

			pkg_debug(1, "replacement %s is already used", p->uid);

			continue;

		}

	}

	/* First of all, try to search a package with the same name */

	pos = strchr(pattern, '/');

	if (pos != NULL && pos[1] != '\0') {

						== EPKG_OK)

			return (EPKG_OK);

		/* Try exact pattern without numbers */

		cpy = xmalloc(len + 1);

		strlcpy(cpy, pos, len + 1);

			free(cpy);

			cpy = sqlite3_mprintf(" WHERE name REGEXP ('^' || %.*Q || '[0-9.]*$')",

					len, pos);

					== EPKG_OK)

				rc = EPKG_OK;

			sqlite3_free(cpy);

		flags |= PKG_ADD_AUTOMATIC;

	if (old != NULL)

	else

	return (retcode);

}

	int flags = 0;

	int retcode = EPKG_FATAL;

	pkg_plugin_hook_t pre, post;

	if (j->type == PKG_JOBS_INSTALL) {

		pre = PKG_PLUGIN_HOOK_PRE_INSTALL;

		post = PKG_PLUGIN_HOOK_POST_INSTALL;

			 * in further they will be upgraded correctly.

			 */

			if (j->type == PKG_JOBS_UPGRADE)

			else

			if (retcode != EPKG_OK)

				goto cleanup;

			break;

	}

	pkg_plugins_hook_run(post, j, j->db);

cleanup:

	pkgdb_release_lock(j->db, PKGDB_LOCK_EXCLUSIVE);

			if (libfound && strcmp(pkg->arch, orig->arch) != 0) {

				pkg_debug(2, "solver: require %s: package %s-%s(%c) provides wrong ABI %s, "

					"wanted %s", pr->provide, pkg->name, pkg->version,

				continue;

			}

		}

/*-

 * Copyright (c) 2011-2012 Julien Laffaye <jlaffaye@FreeBSD.org>

 * Copyright (c) 2013 Matthew Seaman <matthew@FreeBSD.org>

 * Copyright (c) 2013-2017 Vsevolod Stakhov <vsevolod@FreeBSD.org>

};

typedef tll(struct trigger *) trigger_t;

struct pkg_create {

	bool overwrite;

	bool expand_manifest;

 * required by other packages.

 * @return An error code.

 */

#define PKG_DELETE_FORCE (1<<0)

#define PKG_DELETE_UPGRADE (1<<1)

#define PKG_DELETE_NOSCRIPT (1<<2)

const char* packing_format_to_string(pkg_formats format);

bool packing_is_valid_format(const char *str);

int pkg_delete_dirs(struct pkgdb *db, struct pkg *pkg, struct pkg *p);

/* pkgdb commands */

int pkg_add_upgrade(struct pkgdb *db, const char *path, unsigned flags,

    struct pkg_manifest_key *keys, const char *location,

void pkg_delete_dir(struct pkg *pkg, struct pkg_dir *dir);

void pkg_delete_file(struct pkg *pkg, struct pkg_file *file, unsigned force);

int pkg_open_root_fd(struct pkg *pkg);

trigger_t *triggers_load(bool cleanup_only);

int triggers_execute(trigger_t *cleanup_triggers);

void append_touched_dir(const char *path);

void append_touched_file(const char *path);

bool stringlist_contains(stringlist_t *l, const char *name);

	bool conservative;

	bool pinning;

	void		*lockedpkgs;

};

#define PKG_PATTERN_FLAG_FILE (1 << 0)

	query.c \

	update.c

LOCAL_CFLAGS=	-I$(top_srcdir)/libpkg \

		-I$(top_srcdir)/external/uthash \

		-I$(top_srcdir)/external/sqlite \

		-I$(top_srcdir)/external/libucl/include \

		-I$(top_srcdir)/external/include \

		-I$(top_srcdir)/compat \

		-I$(top_srcdir)/ \

include $(MK)/static-lib.mk

	fd = openat(dfd, name, O_RDONLY);

	if (fd == -1) {

		pkg_emit_error("Unable to open the tigger: %s", name);

		return (NULL);

	}

	return (NULL);

}

trigger_t *

triggers_load(bool cleanup_only)

{

triggers_execute(trigger_t *cleanup_triggers)

{

	trigger_t *triggers;

	int ret = EPKG_OK;

	triggers = triggers_load(false);

	pkg_emit_triggers_begin();

	if (cleanup_triggers != NULL) {

		tll_foreach(*cleanup_triggers, it) {

	pkg_emit_triggers_finished();

cleanup:

	tll_free_and_free(*triggers, trigger_free);

	free(triggers);

	 * keep if suffix of at least 5 if possible

	 */

	if (fname != NULL) {

			prefix = ".";

		snprintf(buf, buflen, "%.*s%s%s", (int)(fname - path), path, prefix, fname);

		nbuflen = buflen;

	} else {

			prefix = ".";

		snprintf(buf, buflen, "%s%s", prefix, path);

		nbuflen = NAME_MAX;

COMPLETION=	completion/_pkg \

		completion/_pkg.bash

all: $(PDAILY) $(PSECURITY) $(PWEEKLY) $(COMPLETION)

clean:

		-I$(top_srcdir)/external/libucl/include \

		-I$(top_srcdir)/external/include \

		-I$(top_builddir)/ \

		-I$(top_builddir)/libpkg \

		-DGITHASH=\"@GITHASH@\" \

		-DHAVE_CONFIG_H

STATIC_LDFLAGS=	$(LIBPKGFLAT) $(LIBS) $(OTHER_LIBS)

@endif

include $(MK)/prog.mk

install: $(PROG)

	install -d -m 755 $(DESTDIR)$(sbindir)

	install -m 755 pkg $(DESTDIR)$(sbindir)/pkg

clean: clean-pkg-static

clean-pkg-static:

		foundone = false;

		while ((ret = pkgdb_it_next(it, &pkg, query_flags)) == EPKG_OK) {

			tll_push_back(pkg_head, pkg);

			foundone = true;

		}

		if (!foundone) {

{

	const pkg_object	*conf;

	struct pkg_plugin	*p = NULL;

	while (pkg_plugins(&p) == EPKG_OK) {

		conf = pkg_plugin_conf(p);

		printf("Configuration for plugin: %s\n",

		    pkg_plugin_get(p, PKG_PLUGIN_NAME));

	}

}

{

	struct category	*cat = NULL;

	xstring		*makecmd;

	char		*argv[5];

	makecmd = xstring_new();

	pkghash_add(categories, cat->name, cat, NULL);

	while ((d = strsep(&results, " \n")) != NULL)

cleanup:

	xstring_free(makecmd);