Prefix _alpm_errno_t members with ALPM

Signed-off-by: Allan McRae <allan@archlinux.org>

26 files changed, 287 insertions, 287 deletions

diff --git a/lib/libalpm/add.c b/lib/libalpm/add.c
index a0e5f1db..9ed4d818 100644
--- a/lib/libalpm/add.c
+++ b/lib/libalpm/add.c
@@ -58,12 +58,12 @@ int SYMEXPORT alpm_add_pkg(alpm_handle_t *handle, alpm_pkg_t *pkg)
 
 	/* Sanity checks */
 	CHECK_HANDLE(handle, return -1);
-	ASSERT(pkg != NULL, RET_ERR(handle, PM_ERR_WRONG_ARGS, -1));
-	ASSERT(handle == pkg->handle, RET_ERR(handle, PM_ERR_WRONG_ARGS, -1));
+	ASSERT(pkg != NULL, RET_ERR(handle, ALPM_ERR_WRONG_ARGS, -1));
+	ASSERT(handle == pkg->handle, RET_ERR(handle, ALPM_ERR_WRONG_ARGS, -1));
 	trans = handle->trans;
-	ASSERT(trans != NULL, RET_ERR(handle, PM_ERR_TRANS_NULL, -1));
+	ASSERT(trans != NULL, RET_ERR(handle, ALPM_ERR_TRANS_NULL, -1));
 	ASSERT(trans->state == STATE_INITIALIZED,
-			RET_ERR(handle, PM_ERR_TRANS_NOT_INITIALIZED, -1));
+			RET_ERR(handle, ALPM_ERR_TRANS_NOT_INITIALIZED, -1));
 
 	pkgname = pkg->name;
 	pkgver = pkg->version;
@@ -71,7 +71,7 @@ int SYMEXPORT alpm_add_pkg(alpm_handle_t *handle, alpm_pkg_t *pkg)
 	_alpm_log(handle, ALPM_LOG_DEBUG, "adding package '%s'\n", pkgname);
 
 	if(_alpm_pkg_find(trans->add, pkgname)) {
-		RET_ERR(handle, PM_ERR_TRANS_DUP_TARGET, -1);
+		RET_ERR(handle, ALPM_ERR_TRANS_DUP_TARGET, -1);
 	}
 
 	local = _alpm_db_get_pkgfromcache(handle->db_local, pkgname);
@@ -278,7 +278,7 @@ static int extract_single_file(alpm_handle_t *handle, struct archive *archive,
 
 	/* we need access to the original entryname later after calls to
 	 * archive_entry_set_pathname(), so we need to dupe it and free() later */
-	STRDUP(entryname_orig, entryname, RET_ERR(handle, PM_ERR_MEMORY, -1));
+	STRDUP(entryname_orig, entryname, RET_ERR(handle, ALPM_ERR_MEMORY, -1));
 
 	if(needbackup) {
 		char checkfile[PATH_MAX];
@@ -305,7 +305,7 @@ static int extract_single_file(alpm_handle_t *handle, struct archive *archive,
 			if(!backup->name || strcmp(backup->name, entryname_orig) != 0) {
 				continue;
 			}
-			STRDUP(newhash, hash_pkg, RET_ERR(handle, PM_ERR_MEMORY, -1));
+			STRDUP(newhash, hash_pkg, RET_ERR(handle, ALPM_ERR_MEMORY, -1));
 			FREE(backup->hash);
 			backup->hash = newhash;
 		}
@@ -507,7 +507,7 @@ static int commit_single_pkg(alpm_handle_t *handle, alpm_pkg_t *newpkg,
 	if(oldpkg) {
 		/* set up fake remove transaction */
 		if(_alpm_upgraderemove_package(handle, oldpkg, newpkg) == -1) {
-			handle->pm_errno = PM_ERR_TRANS_ABORT;
+			handle->pm_errno = ALPM_ERR_TRANS_ABORT;
 			ret = -1;
 			goto cleanup;
 		}
@@ -518,7 +518,7 @@ static int commit_single_pkg(alpm_handle_t *handle, alpm_pkg_t *newpkg,
 	if(_alpm_local_db_prepare(db, newpkg)) {
 		alpm_logaction(handle, "error: could not create database entry %s-%s\n",
 				alpm_pkg_get_name(newpkg), alpm_pkg_get_version(newpkg));
-		handle->pm_errno = PM_ERR_DB_WRITE;
+		handle->pm_errno = ALPM_ERR_DB_WRITE;
 		ret = -1;
 		goto cleanup;
 	}
@@ -532,7 +532,7 @@ static int commit_single_pkg(alpm_handle_t *handle, alpm_pkg_t *newpkg,
 		_alpm_log(handle, ALPM_LOG_DEBUG, "extracting files\n");
 
 		if((archive = archive_read_new()) == NULL) {
-			handle->pm_errno = PM_ERR_LIBARCHIVE;
+			handle->pm_errno = ALPM_ERR_LIBARCHIVE;
 			ret = -1;
 			goto cleanup;
 		}
@@ -543,7 +543,7 @@ static int commit_single_pkg(alpm_handle_t *handle, alpm_pkg_t *newpkg,
 		_alpm_log(handle, ALPM_LOG_DEBUG, "archive: %s\n", newpkg->origin_data.file);
 		if(archive_read_open_filename(archive, newpkg->origin_data.file,
 					ARCHIVE_DEFAULT_BYTES_PER_BLOCK) != ARCHIVE_OK) {
-			handle->pm_errno = PM_ERR_PKG_OPEN;
+			handle->pm_errno = ALPM_ERR_PKG_OPEN;
 			ret = -1;
 			goto cleanup;
 		}
@@ -638,7 +638,7 @@ static int commit_single_pkg(alpm_handle_t *handle, alpm_pkg_t *newpkg,
 				alpm_pkg_get_name(newpkg), alpm_pkg_get_version(newpkg));
 		alpm_logaction(handle, "error: could not update database entry %s-%s\n",
 				alpm_pkg_get_name(newpkg), alpm_pkg_get_version(newpkg));
-		handle->pm_errno = PM_ERR_DB_WRITE;
+		handle->pm_errno = ALPM_ERR_DB_WRITE;
 		ret = -1;
 		goto cleanup;
 	}
@@ -705,7 +705,7 @@ int _alpm_upgrade_packages(alpm_handle_t *handle)
 		if(commit_single_pkg(handle, newpkg, pkg_current, pkg_count)) {
 			/* something screwed up on the commit, abort the trans */
 			trans->state = STATE_INTERRUPTED;
-			handle->pm_errno = PM_ERR_TRANS_ABORT;
+			handle->pm_errno = ALPM_ERR_TRANS_ABORT;
 			/* running ldconfig at this point could possibly screw system */
 			skip_ldconfig = 1;
 			ret = -1;
diff --git a/lib/libalpm/alpm.c b/lib/libalpm/alpm.c
index 7780c1fd..585c6a82 100644
--- a/lib/libalpm/alpm.c
+++ b/lib/libalpm/alpm.c
@@ -55,7 +55,7 @@ alpm_handle_t SYMEXPORT *alpm_initialize(const char *root, const char *dbpath,
 	alpm_handle_t *myhandle = _alpm_handle_new();
 
 	if(myhandle == NULL) {
-		myerr = PM_ERR_MEMORY;
+		myerr = ALPM_ERR_MEMORY;
 		goto cleanup;
 	}
 	if((myerr = _alpm_set_directory_option(root, &(myhandle->root), 1))) {
diff --git a/lib/libalpm/alpm.h b/lib/libalpm/alpm.h
index b891e453..8d458c3e 100644
--- a/lib/libalpm/alpm.h
+++ b/lib/libalpm/alpm.h
@@ -1000,67 +1000,67 @@ char *alpm_compute_md5sum(const char *name);
  * @{
  */
 enum _alpm_errno_t {
-	PM_ERR_MEMORY = 1,
-	PM_ERR_SYSTEM,
-	PM_ERR_BADPERMS,
-	PM_ERR_NOT_A_FILE,
-	PM_ERR_NOT_A_DIR,
-	PM_ERR_WRONG_ARGS,
-	PM_ERR_DISK_SPACE,
+	ALPM_ERR_MEMORY = 1,
+	ALPM_ERR_SYSTEM,
+	ALPM_ERR_BADPERMS,
+	ALPM_ERR_NOT_A_FILE,
+	ALPM_ERR_NOT_A_DIR,
+	ALPM_ERR_WRONG_ARGS,
+	ALPM_ERR_DISK_SPACE,
 	/* Interface */
-	PM_ERR_HANDLE_NULL,
-	PM_ERR_HANDLE_NOT_NULL,
-	PM_ERR_HANDLE_LOCK,
+	ALPM_ERR_HANDLE_NULL,
+	ALPM_ERR_HANDLE_NOT_NULL,
+	ALPM_ERR_HANDLE_LOCK,
 	/* Databases */
-	PM_ERR_DB_OPEN,
-	PM_ERR_DB_CREATE,
-	PM_ERR_DB_NULL,
-	PM_ERR_DB_NOT_NULL,
-	PM_ERR_DB_NOT_FOUND,
-	PM_ERR_DB_INVALID,
-	PM_ERR_DB_VERSION,
-	PM_ERR_DB_WRITE,
-	PM_ERR_DB_REMOVE,
+	ALPM_ERR_DB_OPEN,
+	ALPM_ERR_DB_CREATE,
+	ALPM_ERR_DB_NULL,
+	ALPM_ERR_DB_NOT_NULL,
+	ALPM_ERR_DB_NOT_FOUND,
+	ALPM_ERR_DB_INVALID,
+	ALPM_ERR_DB_VERSION,
+	ALPM_ERR_DB_WRITE,
+	ALPM_ERR_DB_REMOVE,
 	/* Servers */
-	PM_ERR_SERVER_BAD_URL,
-	PM_ERR_SERVER_NONE,
+	ALPM_ERR_SERVER_BAD_URL,
+	ALPM_ERR_SERVER_NONE,
 	/* Transactions */
-	PM_ERR_TRANS_NOT_NULL,
-	PM_ERR_TRANS_NULL,
-	PM_ERR_TRANS_DUP_TARGET,
-	PM_ERR_TRANS_NOT_INITIALIZED,
-	PM_ERR_TRANS_NOT_PREPARED,
-	PM_ERR_TRANS_ABORT,
-	PM_ERR_TRANS_TYPE,
-	PM_ERR_TRANS_NOT_LOCKED,
+	ALPM_ERR_TRANS_NOT_NULL,
+	ALPM_ERR_TRANS_NULL,
+	ALPM_ERR_TRANS_DUP_TARGET,
+	ALPM_ERR_TRANS_NOT_INITIALIZED,
+	ALPM_ERR_TRANS_NOT_PREPARED,
+	ALPM_ERR_TRANS_ABORT,
+	ALPM_ERR_TRANS_TYPE,
+	ALPM_ERR_TRANS_NOT_LOCKED,
 	/* Packages */
-	PM_ERR_PKG_NOT_FOUND,
-	PM_ERR_PKG_IGNORED,
-	PM_ERR_PKG_INVALID,
-	PM_ERR_PKG_OPEN,
-	PM_ERR_PKG_CANT_REMOVE,
-	PM_ERR_PKG_INVALID_NAME,
-	PM_ERR_PKG_INVALID_ARCH,
-	PM_ERR_PKG_REPO_NOT_FOUND,
+	ALPM_ERR_PKG_NOT_FOUND,
+	ALPM_ERR_PKG_IGNORED,
+	ALPM_ERR_PKG_INVALID,
+	ALPM_ERR_PKG_OPEN,
+	ALPM_ERR_PKG_CANT_REMOVE,
+	ALPM_ERR_PKG_INVALID_NAME,
+	ALPM_ERR_PKG_INVALID_ARCH,
+	ALPM_ERR_PKG_REPO_NOT_FOUND,
 	/* Signatures */
-	PM_ERR_SIG_MISSINGDIR,
-	PM_ERR_SIG_INVALID,
-	PM_ERR_SIG_UNKNOWN,
+	ALPM_ERR_SIG_MISSINGDIR,
+	ALPM_ERR_SIG_INVALID,
+	ALPM_ERR_SIG_UNKNOWN,
 	/* Deltas */
-	PM_ERR_DLT_INVALID,
-	PM_ERR_DLT_PATCHFAILED,
+	ALPM_ERR_DLT_INVALID,
+	ALPM_ERR_DLT_PATCHFAILED,
 	/* Dependencies */
-	PM_ERR_UNSATISFIED_DEPS,
-	PM_ERR_CONFLICTING_DEPS,
-	PM_ERR_FILE_CONFLICTS,
+	ALPM_ERR_UNSATISFIED_DEPS,
+	ALPM_ERR_CONFLICTING_DEPS,
+	ALPM_ERR_FILE_CONFLICTS,
 	/* Misc */
-	PM_ERR_RETRIEVE,
-	PM_ERR_INVALID_REGEX,
+	ALPM_ERR_RETRIEVE,
+	ALPM_ERR_INVALID_REGEX,
 	/* External library errors */
-	PM_ERR_LIBARCHIVE,
-	PM_ERR_LIBCURL,
-	PM_ERR_EXTERNAL_DOWNLOAD,
-	PM_ERR_GPGME
+	ALPM_ERR_LIBARCHIVE,
+	ALPM_ERR_LIBCURL,
+	ALPM_ERR_EXTERNAL_DOWNLOAD,
+	ALPM_ERR_GPGME
 };
 
 /** Returns the current error code from the handle. */
diff --git a/lib/libalpm/be_local.c b/lib/libalpm/be_local.c
index a98b1bba..304a5a13 100644
--- a/lib/libalpm/be_local.c
+++ b/lib/libalpm/be_local.c
@@ -283,12 +283,12 @@ static int checkdbdir(alpm_db_t *db)
 		_alpm_log(db->handle, ALPM_LOG_DEBUG, "database dir '%s' does not exist, creating it\n",
 				path);
 		if(_alpm_makepath(path) != 0) {
-			RET_ERR(db->handle, PM_ERR_SYSTEM, -1);
+			RET_ERR(db->handle, ALPM_ERR_SYSTEM, -1);
 		}
 	} else if(!S_ISDIR(buf.st_mode)) {
 		_alpm_log(db->handle, ALPM_LOG_WARNING, _("removing invalid database: %s\n"), path);
 		if(unlink(path) != 0 || _alpm_makepath(path) != 0) {
-			RET_ERR(db->handle, PM_ERR_SYSTEM, -1);
+			RET_ERR(db->handle, ALPM_ERR_SYSTEM, -1);
 		}
 	}
 	return 0;
@@ -328,7 +328,7 @@ static int local_db_validate(alpm_db_t *db)
 
 	dbpath = _alpm_db_path(db);
 	if(dbpath == NULL) {
-		RET_ERR(db->handle, PM_ERR_DB_OPEN, -1);
+		RET_ERR(db->handle, ALPM_ERR_DB_OPEN, -1);
 	}
 	dbdir = opendir(dbpath);
 	if(dbdir == NULL) {
@@ -337,7 +337,7 @@ static int local_db_validate(alpm_db_t *db)
 			db->status |= DB_STATUS_VALID;
 			return 0;
 		} else {
-			RET_ERR(db->handle, PM_ERR_DB_OPEN, -1);
+			RET_ERR(db->handle, ALPM_ERR_DB_OPEN, -1);
 		}
 	}
 
@@ -355,7 +355,7 @@ static int local_db_validate(alpm_db_t *db)
 		snprintf(path, PATH_MAX, "%s%s/depends", dbpath, name);
 		if(access(path, F_OK) == 0) {
 			/* we found a depends file- bail */
-			db->handle->pm_errno = PM_ERR_DB_VERSION;
+			db->handle->pm_errno = ALPM_ERR_DB_VERSION;
 			goto done;
 		}
 	}
@@ -392,10 +392,10 @@ static int local_db_populate(alpm_db_t *db)
 			/* no database existing yet is not an error */
 			return 0;
 		}
-		RET_ERR(db->handle, PM_ERR_DB_OPEN, -1);
+		RET_ERR(db->handle, ALPM_ERR_DB_OPEN, -1);
 	}
 	if(fstat(dirfd(dbdir), &buf) != 0) {
-		RET_ERR(db->handle, PM_ERR_DB_OPEN, -1);
+		RET_ERR(db->handle, ALPM_ERR_DB_OPEN, -1);
 	}
 	if(buf.st_nlink >= 2) {
 		est_count = buf.st_nlink;
@@ -419,7 +419,7 @@ static int local_db_populate(alpm_db_t *db)
 	db->pkgcache = _alpm_pkghash_create(est_count * 2);
 	if(db->pkgcache == NULL){
 		closedir(dbdir);
-		RET_ERR(db->handle, PM_ERR_MEMORY, -1);
+		RET_ERR(db->handle, ALPM_ERR_MEMORY, -1);
 	}
 
 	while((ent = readdir(dbdir)) != NULL) {
@@ -437,7 +437,7 @@ static int local_db_populate(alpm_db_t *db)
 		pkg = _alpm_pkg_new();
 		if(pkg == NULL) {
 			closedir(dbdir);
-			RET_ERR(db->handle, PM_ERR_MEMORY, -1);
+			RET_ERR(db->handle, ALPM_ERR_MEMORY, -1);
 		}
 		/* split the db entry name */
 		if(_alpm_splitname(name, &(pkg->name), &(pkg->version),
@@ -493,7 +493,7 @@ static char *get_pkgpath(alpm_db_t *db, alpm_pkg_t *info)
 
 	dbpath = _alpm_db_path(db);
 	len = strlen(dbpath) + strlen(info->name) + strlen(info->version) + 3;
-	MALLOC(pkgpath, len, RET_ERR(db->handle, PM_ERR_MEMORY, NULL));
+	MALLOC(pkgpath, len, RET_ERR(db->handle, ALPM_ERR_MEMORY, NULL));
 	sprintf(pkgpath, "%s%s-%s/", dbpath, info->name, info->version);
 	return pkgpath;
 }
@@ -928,7 +928,7 @@ alpm_db_t *_alpm_db_register_local(alpm_handle_t *handle)
 
 	db = _alpm_db_new("local", 1);
 	if(db == NULL) {
-		handle->pm_errno = PM_ERR_DB_CREATE;
+		handle->pm_errno = ALPM_ERR_DB_CREATE;
 		return NULL;
 	}
 	db->ops = &local_db_ops;
diff --git a/lib/libalpm/be_package.c b/lib/libalpm/be_package.c
index 57f01233..16132144 100644
--- a/lib/libalpm/be_package.c
+++ b/lib/libalpm/be_package.c
@@ -52,7 +52,7 @@ static void *_package_changelog_open(alpm_pkg_t *pkg)
 	const char *pkgfile = pkg->origin_data.file;
 
 	if((archive = archive_read_new()) == NULL) {
-		RET_ERR(pkg->handle, PM_ERR_LIBARCHIVE, NULL);
+		RET_ERR(pkg->handle, ALPM_ERR_LIBARCHIVE, NULL);
 	}
 
 	archive_read_support_compression_all(archive);
@@ -60,7 +60,7 @@ static void *_package_changelog_open(alpm_pkg_t *pkg)
 
 	if(archive_read_open_filename(archive, pkgfile,
 				ARCHIVE_DEFAULT_BYTES_PER_BLOCK) != ARCHIVE_OK) {
-		RET_ERR(pkg->handle, PM_ERR_PKG_OPEN, NULL);
+		RET_ERR(pkg->handle, ALPM_ERR_PKG_OPEN, NULL);
 	}
 
 	while(archive_read_next_header(archive, &entry) == ARCHIVE_OK) {
@@ -92,7 +92,7 @@ static size_t _package_changelog_read(void *ptr, size_t size,
 	ssize_t sret = archive_read_data((struct archive *)fp, ptr, size);
 	/* Report error (negative values) */
 	if(sret < 0) {
-		RET_ERR(pkg->handle, PM_ERR_LIBARCHIVE, 0);
+		RET_ERR(pkg->handle, ALPM_ERR_LIBARCHIVE, 0);
 	} else {
 		return (size_t)sret;
 	}
@@ -244,20 +244,20 @@ alpm_pkg_t *_alpm_pkg_load_internal(alpm_handle_t *handle, const char *pkgfile,
 	size_t files_count = 0;
 
 	if(pkgfile == NULL || strlen(pkgfile) == 0) {
-		RET_ERR(handle, PM_ERR_WRONG_ARGS, NULL);
+		RET_ERR(handle, ALPM_ERR_WRONG_ARGS, NULL);
 	}
 
 	/* attempt to stat the package file, ensure it exists */
 	if(stat(pkgfile, &st) == 0) {
 		newpkg = _alpm_pkg_new();
 		if(newpkg == NULL) {
-			RET_ERR(handle, PM_ERR_MEMORY, NULL);
+			RET_ERR(handle, ALPM_ERR_MEMORY, NULL);
 		}
 		newpkg->filename = strdup(pkgfile);
 		newpkg->size = st.st_size;
 	} else {
 		/* couldn't stat the pkgfile, return an error */
-		RET_ERR(handle, PM_ERR_PKG_OPEN, NULL);
+		RET_ERR(handle, ALPM_ERR_PKG_OPEN, NULL);
 	}
 
 	/* first steps- validate the package file */
@@ -266,7 +266,7 @@ alpm_pkg_t *_alpm_pkg_load_internal(alpm_handle_t *handle, const char *pkgfile,
 		_alpm_log(handle, ALPM_LOG_DEBUG, "checking md5sum for %s\n", pkgfile);
 		if(_alpm_test_md5sum(pkgfile, md5sum) != 0) {
 			alpm_pkg_free(newpkg);
-			RET_ERR(handle, PM_ERR_PKG_INVALID, NULL);
+			RET_ERR(handle, ALPM_ERR_PKG_INVALID, NULL);
 		}
 	}
 
@@ -277,14 +277,14 @@ alpm_pkg_t *_alpm_pkg_load_internal(alpm_handle_t *handle, const char *pkgfile,
 		if((check_sig == PM_PGP_VERIFY_ALWAYS && ret != 0) ||
 				(check_sig == PM_PGP_VERIFY_OPTIONAL && ret == 1)) {
 			alpm_pkg_free(newpkg);
-			RET_ERR(handle, PM_ERR_SIG_INVALID, NULL);
+			RET_ERR(handle, ALPM_ERR_SIG_INVALID, NULL);
 		}
 	}
 
 	/* next- try to create an archive object to read in the package */
 	if((archive = archive_read_new()) == NULL) {
 		alpm_pkg_free(newpkg);
-		RET_ERR(handle, PM_ERR_LIBARCHIVE, NULL);
+		RET_ERR(handle, ALPM_ERR_LIBARCHIVE, NULL);
 	}
 
 	archive_read_support_compression_all(archive);
@@ -293,7 +293,7 @@ alpm_pkg_t *_alpm_pkg_load_internal(alpm_handle_t *handle, const char *pkgfile,
 	if(archive_read_open_filename(archive, pkgfile,
 				ARCHIVE_DEFAULT_BYTES_PER_BLOCK) != ARCHIVE_OK) {
 		alpm_pkg_free(newpkg);
-		RET_ERR(handle, PM_ERR_PKG_OPEN, NULL);
+		RET_ERR(handle, ALPM_ERR_PKG_OPEN, NULL);
 	}
 
 	_alpm_log(handle, ALPM_LOG_DEBUG, "starting package load for %s\n", pkgfile);
@@ -335,7 +335,7 @@ alpm_pkg_t *_alpm_pkg_load_internal(alpm_handle_t *handle, const char *pkgfile,
 		if(archive_read_data_skip(archive)) {
 			_alpm_log(handle, ALPM_LOG_ERROR, _("error while reading package %s: %s\n"),
 					pkgfile, archive_error_string(archive));
-			handle->pm_errno = PM_ERR_LIBARCHIVE;
+			handle->pm_errno = ALPM_ERR_LIBARCHIVE;
 			goto error;
 		}
 
@@ -348,7 +348,7 @@ alpm_pkg_t *_alpm_pkg_load_internal(alpm_handle_t *handle, const char *pkgfile,
 	if(ret != ARCHIVE_EOF && ret != ARCHIVE_OK) { /* An error occured */
 		_alpm_log(handle, ALPM_LOG_ERROR, _("error while reading package %s: %s\n"),
 				pkgfile, archive_error_string(archive));
-		handle->pm_errno = PM_ERR_LIBARCHIVE;
+		handle->pm_errno = ALPM_ERR_LIBARCHIVE;
 		goto error;
 	}
 
@@ -379,7 +379,7 @@ alpm_pkg_t *_alpm_pkg_load_internal(alpm_handle_t *handle, const char *pkgfile,
 	return newpkg;
 
 pkg_invalid:
-	handle->pm_errno = PM_ERR_PKG_INVALID;
+	handle->pm_errno = ALPM_ERR_PKG_INVALID;
 error:
 	_alpm_pkg_free(newpkg);
 	archive_read_finish(archive);
@@ -391,7 +391,7 @@ int SYMEXPORT alpm_pkg_load(alpm_handle_t *handle, const char *filename, int ful
 		pgp_verify_t check_sig, alpm_pkg_t **pkg)
 {
 	CHECK_HANDLE(handle, return -1);
-	ASSERT(pkg != NULL, RET_ERR(handle, PM_ERR_WRONG_ARGS, -1));
+	ASSERT(pkg != NULL, RET_ERR(handle, ALPM_ERR_WRONG_ARGS, -1));
 
 	*pkg = _alpm_pkg_load_internal(handle, filename, full, NULL, NULL, check_sig);
 	if(*pkg == NULL) {
diff --git a/lib/libalpm/be_sync.c b/lib/libalpm/be_sync.c
index 3f24b3fa..cda1e097 100644
--- a/lib/libalpm/be_sync.c
+++ b/lib/libalpm/be_sync.c
@@ -46,7 +46,7 @@ static char *get_sync_dir(alpm_handle_t *handle)
 	char *syncpath;
 	struct stat buf;
 
-	MALLOC(syncpath, len, RET_ERR(handle, PM_ERR_MEMORY, NULL));
+	MALLOC(syncpath, len, RET_ERR(handle, ALPM_ERR_MEMORY, NULL));
 	sprintf(syncpath, "%s%s", dbpath, "sync/");
 
 	if(stat(syncpath, &buf) != 0) {
@@ -54,13 +54,13 @@ static char *get_sync_dir(alpm_handle_t *handle)
 				syncpath);
 		if(_alpm_makepath(syncpath) != 0) {
 			free(syncpath);
-			RET_ERR(handle, PM_ERR_SYSTEM, NULL);
+			RET_ERR(handle, ALPM_ERR_SYSTEM, NULL);
 		}
 	} else if(!S_ISDIR(buf.st_mode)) {
 		_alpm_log(handle, ALPM_LOG_WARNING, _("removing invalid file: %s\n"), syncpath);
 		if(unlink(syncpath) != 0 || _alpm_makepath(syncpath) != 0) {
 			free(syncpath);
-			RET_ERR(handle, PM_ERR_SYSTEM, NULL);
+			RET_ERR(handle, ALPM_ERR_SYSTEM, NULL);
 		}
 	}
 
@@ -98,7 +98,7 @@ static int sync_db_validate(alpm_db_t *db)
 		ret = _alpm_gpgme_checksig(db->handle, dbpath, NULL);
 		if((check_sig == PM_PGP_VERIFY_ALWAYS && ret != 0) ||
 				(check_sig == PM_PGP_VERIFY_OPTIONAL && ret == 1)) {
-			RET_ERR(db->handle, PM_ERR_SIG_INVALID, -1);
+			RET_ERR(db->handle, ALPM_ERR_SIG_INVALID, -1);
 		}
 	}
 
@@ -155,8 +155,8 @@ int SYMEXPORT alpm_db_update(int force, alpm_db_t *db)
 	ASSERT(db != NULL, return -1);
 	handle = db->handle;
 	handle->pm_errno = 0;
-	ASSERT(db != handle->db_local, RET_ERR(handle, PM_ERR_WRONG_ARGS, -1));
-	ASSERT(db->servers != NULL, RET_ERR(handle, PM_ERR_SERVER_NONE, -1));
+	ASSERT(db != handle->db_local, RET_ERR(handle, ALPM_ERR_WRONG_ARGS, -1));
+	ASSERT(db->servers != NULL, RET_ERR(handle, ALPM_ERR_SERVER_NONE, -1));
 
 	syncpath = get_sync_dir(handle);
 	if(!syncpath) {
@@ -170,7 +170,7 @@ int SYMEXPORT alpm_db_update(int force, alpm_db_t *db)
 
 	/* attempt to grab a lock */
 	if(_alpm_handle_lock(handle)) {
-		RET_ERR(handle, PM_ERR_HANDLE_LOCK, -1);
+		RET_ERR(handle, ALPM_ERR_HANDLE_LOCK, -1);
 	}
 
 	for(i = db->servers; i; i = i->next) {
@@ -181,7 +181,7 @@ int SYMEXPORT alpm_db_update(int force, alpm_db_t *db)
 
 		/* print server + filename into a buffer (leave space for .sig) */
 		len = strlen(server) + strlen(db->treename) + 9;
-		CALLOC(fileurl, len, sizeof(char), RET_ERR(handle, PM_ERR_MEMORY, -1));
+		CALLOC(fileurl, len, sizeof(char), RET_ERR(handle, ALPM_ERR_MEMORY, -1));
 		snprintf(fileurl, len, "%s/%s.db", server, db->treename);
 
 		ret = _alpm_download(handle, fileurl, syncpath, force, 0, 0);
@@ -277,7 +277,7 @@ static alpm_pkg_t *load_pkg_for_entry(alpm_db_t *db, const char *entryname,
 	if(pkg == NULL) {
 		pkg = _alpm_pkg_new();
 		if(pkg == NULL) {
-			RET_ERR(db->handle, PM_ERR_MEMORY, NULL);
+			RET_ERR(db->handle, ALPM_ERR_MEMORY, NULL);
 		}
 
 		pkg->name = pkgname;
@@ -371,7 +371,7 @@ static int sync_db_populate(alpm_db_t *db)
 	alpm_pkg_t *pkg = NULL;
 
 	if((archive = archive_read_new()) == NULL) {
-		RET_ERR(db->handle, PM_ERR_LIBARCHIVE, -1);
+		RET_ERR(db->handle, ALPM_ERR_LIBARCHIVE, -1);
 	}
 
 	archive_read_support_compression_all(archive);
@@ -390,17 +390,17 @@ static int sync_db_populate(alpm_db_t *db)
 		_alpm_log(db->handle, ALPM_LOG_ERROR, _("could not open file %s: %s\n"), dbpath,
 				archive_error_string(archive));
 		archive_read_finish(archive);
-		RET_ERR(db->handle, PM_ERR_DB_OPEN, -1);
+		RET_ERR(db->handle, ALPM_ERR_DB_OPEN, -1);
 	}
 	if(stat(dbpath, &buf) != 0) {
-		RET_ERR(db->handle, PM_ERR_DB_OPEN, -1);
+		RET_ERR(db->handle, ALPM_ERR_DB_OPEN, -1);
 	}
 	est_count = estimate_package_count(&buf, archive);
 
 	/* initialize hash at 66% full */
 	db->pkgcache = _alpm_pkghash_create(est_count * 3 / 2);
 	if(db->pkgcache == NULL) {
-		RET_ERR(db->handle, PM_ERR_MEMORY, -1);
+		RET_ERR(db->handle, ALPM_ERR_MEMORY, -1);
 	}
 
 	while(archive_read_next_header(archive, &entry) == ARCHIVE_OK) {
@@ -594,7 +594,7 @@ alpm_db_t *_alpm_db_register_sync(alpm_handle_t *handle, const char *treename,
 
 	db = _alpm_db_new(treename, 0);
 	if(db == NULL) {
-		RET_ERR(handle, PM_ERR_DB_CREATE, NULL);
+		RET_ERR(handle, ALPM_ERR_DB_CREATE, NULL);
 	}
 	db->ops = &sync_db_ops;
 	db->handle = handle;
diff --git a/lib/libalpm/conflict.c b/lib/libalpm/conflict.c
index af1bce15..ad689dcf 100644
--- a/lib/libalpm/conflict.c
+++ b/lib/libalpm/conflict.c
@@ -303,7 +303,7 @@ static alpm_list_t *add_fileconflict(alpm_handle_t *handle,
 	return conflicts;
 
 error:
-	RET_ERR(handle, PM_ERR_MEMORY, conflicts);
+	RET_ERR(handle, ALPM_ERR_MEMORY, conflicts);
 }
 
 void _alpm_fileconflict_free(alpm_fileconflict_t *conflict)
@@ -409,7 +409,7 @@ alpm_list_t *_alpm_db_find_fileconflicts(alpm_handle_t *handle,
 					conflicts = add_fileconflict(handle, conflicts,
 							ALPM_FILECONFLICT_TARGET, path,
 							alpm_pkg_get_name(p1), alpm_pkg_get_name(p2));
-					if(handle->pm_errno == PM_ERR_MEMORY) {
+					if(handle->pm_errno == ALPM_ERR_MEMORY) {
 						FREELIST(conflicts);
 						FREELIST(common_files);
 						return NULL;
@@ -535,7 +535,7 @@ alpm_list_t *_alpm_db_find_fileconflicts(alpm_handle_t *handle,
 			if(!resolved_conflict) {
 				conflicts = add_fileconflict(handle, conflicts,
 						ALPM_FILECONFLICT_FILESYSTEM, path, p1->name, NULL);
-				if(handle->pm_errno == PM_ERR_MEMORY) {
+				if(handle->pm_errno == ALPM_ERR_MEMORY) {
 					FREELIST(conflicts);
 					if(dbpkg) {
 						/* only freed if it was generated from filelist_operation() */
diff --git a/lib/libalpm/db.c b/lib/libalpm/db.c
index b7f0c9a3..17f26e90 100644
--- a/lib/libalpm/db.c
+++ b/lib/libalpm/db.c
@@ -51,9 +51,9 @@ alpm_db_t SYMEXPORT *alpm_db_register_sync(alpm_handle_t *handle, const char *tr
 	/* Sanity checks */
 	CHECK_HANDLE(handle, return NULL);
 	ASSERT(treename != NULL && strlen(treename) != 0,
-			RET_ERR(handle, PM_ERR_WRONG_ARGS, NULL));
+			RET_ERR(handle, ALPM_ERR_WRONG_ARGS, NULL));
 	/* Do not register a database if a transaction is on-going */
-	ASSERT(handle->trans == NULL, RET_ERR(handle, PM_ERR_TRANS_NOT_NULL, NULL));
+	ASSERT(handle->trans == NULL, RET_ERR(handle, ALPM_ERR_TRANS_NOT_NULL, NULL));
 
 	return _alpm_db_register_sync(handle, treename, check_sig);
 }
@@ -78,7 +78,7 @@ int SYMEXPORT alpm_db_unregister_all(alpm_handle_t *handle)
 	/* Sanity checks */
 	CHECK_HANDLE(handle, return -1);
 	/* Do not unregister a database if a transaction is on-going */
-	ASSERT(handle->trans == NULL, RET_ERR(handle, PM_ERR_TRANS_NOT_NULL, -1));
+	ASSERT(handle->trans == NULL, RET_ERR(handle, ALPM_ERR_TRANS_NOT_NULL, -1));
 
 	/* unregister all sync dbs */
 	for(i = handle->dbs_sync; i; i = i->next) {
@@ -101,7 +101,7 @@ int SYMEXPORT alpm_db_unregister(alpm_db_t *db)
 	/* Do not unregister a database if a transaction is on-going */
 	handle = db->handle;
 	handle->pm_errno = 0;
-	ASSERT(handle->trans == NULL, RET_ERR(handle, PM_ERR_TRANS_NOT_NULL, -1));
+	ASSERT(handle->trans == NULL, RET_ERR(handle, ALPM_ERR_TRANS_NOT_NULL, -1));
 
 	if(db == handle->db_local) {
 		handle->db_local = NULL;
@@ -120,7 +120,7 @@ int SYMEXPORT alpm_db_unregister(alpm_db_t *db)
 	}
 
 	if(!found) {
-		RET_ERR(handle, PM_ERR_DB_NOT_FOUND, -1);
+		RET_ERR(handle, ALPM_ERR_DB_NOT_FOUND, -1);
 	}
 
 	db->ops->unregister(db);
@@ -168,7 +168,7 @@ int SYMEXPORT alpm_db_add_server(alpm_db_t *db, const char *url)
 	/* Sanity checks */
 	ASSERT(db != NULL, return -1);
 	db->handle->pm_errno = 0;
-	ASSERT(url != NULL && strlen(url) != 0, RET_ERR(db->handle, PM_ERR_WRONG_ARGS, -1));
+	ASSERT(url != NULL && strlen(url) != 0, RET_ERR(db->handle, ALPM_ERR_WRONG_ARGS, -1));
 
 	newurl = sanitize_url(url);
 	if(!newurl) {
@@ -194,7 +194,7 @@ int SYMEXPORT alpm_db_remove_server(alpm_db_t *db, const char *url)
 	/* Sanity checks */
 	ASSERT(db != NULL, return -1);
 	db->handle->pm_errno = 0;
-	ASSERT(url != NULL && strlen(url) != 0, RET_ERR(db->handle, PM_ERR_WRONG_ARGS, -1));
+	ASSERT(url != NULL && strlen(url) != 0, RET_ERR(db->handle, ALPM_ERR_WRONG_ARGS, -1));
 
 	newurl = sanitize_url(url);
 	if(!newurl) {
@@ -244,7 +244,7 @@ alpm_pkg_t SYMEXPORT *alpm_db_get_pkg(alpm_db_t *db, const char *name)
 	ASSERT(db != NULL, return NULL);
 	db->handle->pm_errno = 0;
 	ASSERT(name != NULL && strlen(name) != 0,
-			RET_ERR(db->handle, PM_ERR_WRONG_ARGS, NULL));
+			RET_ERR(db->handle, ALPM_ERR_WRONG_ARGS, NULL));
 
 	return _alpm_db_get_pkgfromcache(db, name);
 }
@@ -263,7 +263,7 @@ alpm_group_t SYMEXPORT *alpm_db_readgroup(alpm_db_t *db, const char *name)
 	ASSERT(db != NULL, return NULL);
 	db->handle->pm_errno = 0;
 	ASSERT(name != NULL && strlen(name) != 0,
-			RET_ERR(db->handle, PM_ERR_WRONG_ARGS, NULL));
+			RET_ERR(db->handle, ALPM_ERR_WRONG_ARGS, NULL));
 
 	return _alpm_db_get_groupfromcache(db, name);
 }
@@ -292,11 +292,11 @@ int SYMEXPORT alpm_db_set_pkgreason(alpm_db_t *db, const char *name, alpm_pkgrea
 	ASSERT(db != NULL, return -1);
 	db->handle->pm_errno = 0;
 	/* TODO assert db == db_local ? shouldn't need a db param at all here... */
-	ASSERT(name != NULL, RET_ERR(db->handle, PM_ERR_WRONG_ARGS, -1));
+	ASSERT(name != NULL, RET_ERR(db->handle, ALPM_ERR_WRONG_ARGS, -1));
 
 	alpm_pkg_t *pkg = _alpm_db_get_pkgfromcache(db, name);
 	if(pkg == NULL) {
-		RET_ERR(db->handle, PM_ERR_PKG_NOT_FOUND, -1);
+		RET_ERR(db->handle, ALPM_ERR_PKG_NOT_FOUND, -1);
 	}
 
 	_alpm_log(db->handle, ALPM_LOG_DEBUG, "setting install reason %u for %s/%s\n", reason, db->treename, name);
@@ -308,7 +308,7 @@ int SYMEXPORT alpm_db_set_pkgreason(alpm_db_t *db, const char *name, alpm_pkgrea
 	pkg->reason = reason;
 	/* write DESC */
 	if(_alpm_local_db_write(db, pkg, INFRQ_DESC)) {
-		RET_ERR(db->handle, PM_ERR_DB_WRITE, -1);
+		RET_ERR(db->handle, ALPM_ERR_DB_WRITE, -1);
 	}
 
 	return 0;
@@ -353,16 +353,16 @@ const char *_alpm_db_path(alpm_db_t *db)
 		dbpath = alpm_option_get_dbpath(db->handle);
 		if(!dbpath) {
 			_alpm_log(db->handle, ALPM_LOG_ERROR, _("database path is undefined\n"));
-			RET_ERR(db->handle, PM_ERR_DB_OPEN, NULL);
+			RET_ERR(db->handle, ALPM_ERR_DB_OPEN, NULL);
 		}
 
 		if(db->is_local) {
 			pathsize = strlen(dbpath) + strlen(db->treename) + 2;
-			CALLOC(db->_path, 1, pathsize, RET_ERR(db->handle, PM_ERR_MEMORY, NULL));
+			CALLOC(db->_path, 1, pathsize, RET_ERR(db->handle, ALPM_ERR_MEMORY, NULL));
 			sprintf(db->_path, "%s%s/", dbpath, db->treename);
 		} else {
 			pathsize = strlen(dbpath) + 5 + strlen(db->treename) + 4;
-			CALLOC(db->_path, 1, pathsize, RET_ERR(db->handle, PM_ERR_MEMORY, NULL));
+			CALLOC(db->_path, 1, pathsize, RET_ERR(db->handle, ALPM_ERR_MEMORY, NULL));
 			/* all sync DBs now reside in the sync/ subdir of the dbpath */
 			sprintf(db->_path, "%ssync/%s.db", dbpath, db->treename);
 		}
@@ -381,7 +381,7 @@ char *_alpm_db_sig_path(alpm_db_t *db)
 		return NULL;
 	}
 	len = strlen(dbfile) + strlen(".sig") + 1;
-	CALLOC(sigpath, len, sizeof(char), RET_ERR(db->handle, PM_ERR_MEMORY, NULL));
+	CALLOC(sigpath, len, sizeof(char), RET_ERR(db->handle, ALPM_ERR_MEMORY, NULL));
 	sprintf(sigpath, "%s.sig", dbfile);
 	return sigpath;
 }
@@ -412,7 +412,7 @@ alpm_list_t *_alpm_db_search(alpm_db_t *db, const alpm_list_t *needles)
 		_alpm_log(db->handle, ALPM_LOG_DEBUG, "searching for target '%s'\n", targ);
 
 		if(regcomp(&reg, targ, REG_EXTENDED | REG_NOSUB | REG_ICASE | REG_NEWLINE) != 0) {
-			RET_ERR(db->handle, PM_ERR_INVALID_REGEX, NULL);
+			RET_ERR(db->handle, ALPM_ERR_INVALID_REGEX, NULL);
 		}
 
 		for(j = list; j; j = j->next) {
@@ -510,7 +510,7 @@ alpm_pkghash_t *_alpm_db_get_pkgcache_hash(alpm_db_t *db)
 	}
 
 	if(!(db->status & DB_STATUS_VALID)) {
-		RET_ERR(db->handle, PM_ERR_DB_INVALID, NULL);
+		RET_ERR(db->handle, ALPM_ERR_DB_INVALID, NULL);
 	}
 
 	if(!(db->status & DB_STATUS_PKGCACHE)) {
@@ -672,7 +672,7 @@ alpm_list_t *_alpm_db_get_groupcache(alpm_db_t *db)
 	}
 
 	if(!(db->status & DB_STATUS_VALID)) {
-		RET_ERR(db->handle, PM_ERR_DB_INVALID, NULL);
+		RET_ERR(db->handle, ALPM_ERR_DB_INVALID, NULL);
 	}
 
 	if(!(db->status & DB_STATUS_GRPCACHE)) {
diff --git a/lib/libalpm/deps.c b/lib/libalpm/deps.c
index f06e93cd..0319d291 100644
--- a/lib/libalpm/deps.c
+++ b/lib/libalpm/deps.c
@@ -637,9 +637,9 @@ static alpm_pkg_t *resolvedep(alpm_handle_t *handle, alpm_depend_t *dep,
 	}
 
 	if(ignored) { /* resolvedeps will override these */
-		handle->pm_errno = PM_ERR_PKG_IGNORED;
+		handle->pm_errno = ALPM_ERR_PKG_IGNORED;
 	} else {
-		handle->pm_errno = PM_ERR_PKG_NOT_FOUND;
+		handle->pm_errno = ALPM_ERR_PKG_NOT_FOUND;
 	}
 	return NULL;
 }
@@ -660,7 +660,7 @@ alpm_pkg_t SYMEXPORT *alpm_find_dbs_satisfier(alpm_handle_t *handle,
 	alpm_pkg_t *pkg;
 
 	CHECK_HANDLE(handle, return NULL);
-	ASSERT(dbs, RET_ERR(handle, PM_ERR_WRONG_ARGS, NULL));
+	ASSERT(dbs, RET_ERR(handle, ALPM_ERR_WRONG_ARGS, NULL));
 
 	dep = _alpm_splitdep(depstring);
 	ASSERT(dep, return NULL);
@@ -734,7 +734,7 @@ int _alpm_resolvedeps(alpm_handle_t *handle, alpm_list_t *localpkgs, alpm_pkg_t
 				spkg = resolvedep(handle, missdep, handle->dbs_sync, *packages, 0);
 			}
 			if(!spkg) {
-				handle->pm_errno = PM_ERR_UNSATISFIED_DEPS;
+				handle->pm_errno = ALPM_ERR_UNSATISFIED_DEPS;
 				char *missdepstring = alpm_dep_compute_string(missdep);
 				_alpm_log(handle, ALPM_LOG_WARNING,
 						_("cannot resolve \"%s\", a dependency of \"%s\"\n"),
diff --git a/lib/libalpm/diskspace.c b/lib/libalpm/diskspace.c
index 0ce4332d..52364a0e 100644
--- a/lib/libalpm/diskspace.c
+++ b/lib/libalpm/diskspace.c
@@ -87,7 +87,7 @@ static alpm_list_t *mount_point_list(alpm_handle_t *handle)
 			continue;
 		}
 
-		CALLOC(mp, 1, sizeof(alpm_mountpoint_t), RET_ERR(handle, PM_ERR_MEMORY, NULL));
+		CALLOC(mp, 1, sizeof(alpm_mountpoint_t), RET_ERR(handle, ALPM_ERR_MEMORY, NULL));
 		mp->mount_dir = strdup(mnt->mnt_dir);
 		mp->mount_dir_len = strlen(mp->mount_dir);
 		memcpy(&(mp->fsp), &fsp, sizeof(struct statvfs));
@@ -108,7 +108,7 @@ static alpm_list_t *mount_point_list(alpm_handle_t *handle)
 	}
 
 	for(; entries-- > 0; fsp++) {
-		CALLOC(mp, 1, sizeof(alpm_mountpoint_t), RET_ERR(PM_ERR_MEMORY, NULL));
+		CALLOC(mp, 1, sizeof(alpm_mountpoint_t), RET_ERR(ALPM_ERR_MEMORY, NULL));
 		mp->mount_dir = strdup(fsp->f_mntonname);
 		mp->mount_dir_len = strlen(mp->mount_dir);
 		memcpy(&(mp->fsp), fsp, sizeof(FSSTATSTYPE));
@@ -193,7 +193,7 @@ static int calculate_installed_size(alpm_handle_t *handle,
 	struct archive_entry *entry;
 
 	if((archive = archive_read_new()) == NULL) {
-		handle->pm_errno = PM_ERR_LIBARCHIVE;
+		handle->pm_errno = ALPM_ERR_LIBARCHIVE;
 		ret = -1;
 		goto cleanup;
 	}
@@ -203,7 +203,7 @@ static int calculate_installed_size(alpm_handle_t *handle,
 
 	if(archive_read_open_filename(archive, pkg->origin_data.file,
 				ARCHIVE_DEFAULT_BYTES_PER_BLOCK) != ARCHIVE_OK) {
-		handle->pm_errno = PM_ERR_PKG_OPEN;
+		handle->pm_errno = ALPM_ERR_PKG_OPEN;
 		ret = -1;
 		goto cleanup;
 	}
@@ -246,7 +246,7 @@ static int calculate_installed_size(alpm_handle_t *handle,
 		if(archive_read_data_skip(archive)) {
 			_alpm_log(handle, ALPM_LOG_ERROR, _("error while reading package %s: %s\n"),
 					pkg->name, archive_error_string(archive));
-			handle->pm_errno = PM_ERR_LIBARCHIVE;
+			handle->pm_errno = ALPM_ERR_LIBARCHIVE;
 			break;
 		}
 	}
@@ -350,7 +350,7 @@ int _alpm_check_diskspace(alpm_handle_t *handle)
 	FREELIST(mount_points);
 
 	if(error) {
-		RET_ERR(handle, PM_ERR_DISK_SPACE, -1);
+		RET_ERR(handle, ALPM_ERR_DISK_SPACE, -1);
 	}
 
 	return 0;
diff --git a/lib/libalpm/dload.c b/lib/libalpm/dload.c
index 0a9a81ad..dc8ee395 100644
--- a/lib/libalpm/dload.c
+++ b/lib/libalpm/dload.c
@@ -172,7 +172,7 @@ static int curl_download_internal(alpm_handle_t *handle,
 	dlfile.filename = get_filename(url);
 	if(!dlfile.filename || curl_gethost(url, hostname) != 0) {
 		_alpm_log(handle, ALPM_LOG_ERROR, _("url '%s' is invalid\n"), url);
-		RET_ERR(handle, PM_ERR_SERVER_BAD_URL, -1);
+		RET_ERR(handle, ALPM_ERR_SERVER_BAD_URL, -1);
 	}
 
 	destfile = get_fullpath(localpath, dlfile.filename, "");
@@ -248,7 +248,7 @@ static int curl_download_internal(alpm_handle_t *handle,
 		goto cleanup;
 	} else if(handle->curlerr != CURLE_OK) {
 		if(!errors_ok) {
-			handle->pm_errno = PM_ERR_LIBCURL;
+			handle->pm_errno = ALPM_ERR_LIBCURL;
 			_alpm_log(handle, ALPM_LOG_ERROR, _("failed retrieving file '%s' from %s : %s\n"),
 					dlfile.filename, hostname, error_buffer);
 		} else {
@@ -278,7 +278,7 @@ static int curl_download_internal(alpm_handle_t *handle,
 	 * as actually being transferred during curl_easy_perform() */
 	if(!DOUBLE_EQ(remote_size, -1) && !DOUBLE_EQ(bytes_dl, -1) &&
 			!DOUBLE_EQ(bytes_dl, remote_size)) {
-		handle->pm_errno = PM_ERR_RETRIEVE;
+		handle->pm_errno = ALPM_ERR_RETRIEVE;
 		_alpm_log(handle, ALPM_LOG_ERROR, _("%s appears to be truncated: %jd/%jd bytes\n"),
 				dlfile.filename, (intmax_t)bytes_dl, (intmax_t)remote_size);
 		goto cleanup;
@@ -329,12 +329,12 @@ int _alpm_download(alpm_handle_t *handle, const char *url, const char *localpath
 		return curl_download_internal(handle, url, localpath,
 				force, allow_resume, errors_ok);
 #else
-		RET_ERR(handle, PM_ERR_EXTERNAL_DOWNLOAD, -1);
+		RET_ERR(handle, ALPM_ERR_EXTERNAL_DOWNLOAD, -1);
 #endif
 	} else {
 		int ret = handle->fetchcb(url, localpath, force);
 		if(ret == -1 && !errors_ok) {
-			RET_ERR(handle, PM_ERR_EXTERNAL_DOWNLOAD, -1);
+			RET_ERR(handle, ALPM_ERR_EXTERNAL_DOWNLOAD, -1);
 		}
 		return ret;
 	}
@@ -370,7 +370,7 @@ char SYMEXPORT *alpm_fetch_pkgurl(alpm_handle_t *handle, const char *url)
 		int errors_ok = (handle->sigverify == PM_PGP_VERIFY_OPTIONAL);
 
 		len = strlen(url) + 5;
-		CALLOC(sig_url, len, sizeof(char), RET_ERR(handle, PM_ERR_MEMORY, NULL));
+		CALLOC(sig_url, len, sizeof(char), RET_ERR(handle, ALPM_ERR_MEMORY, NULL));
 		snprintf(sig_url, len, "%s.sig", url);
 
 		ret = _alpm_download(handle, sig_url, cachedir, 1, 0, errors_ok);
diff --git a/lib/libalpm/error.c b/lib/libalpm/error.c
index 225d8859..8716109f 100644
--- a/lib/libalpm/error.c
+++ b/lib/libalpm/error.c
@@ -38,120 +38,120 @@ const char SYMEXPORT *alpm_strerror(enum _alpm_errno_t err)
 {
 	switch(err) {
 		/* System */
-		case PM_ERR_MEMORY:
+		case ALPM_ERR_MEMORY:
 			return _("out of memory!");
-		case PM_ERR_SYSTEM:
+		case ALPM_ERR_SYSTEM:
 			return _("unexpected system error");
-		case PM_ERR_BADPERMS:
+		case ALPM_ERR_BADPERMS:
 			return _("insufficient privileges");
-		case PM_ERR_NOT_A_FILE:
+		case ALPM_ERR_NOT_A_FILE:
 			return _("could not find or read file");
-		case PM_ERR_NOT_A_DIR:
+		case ALPM_ERR_NOT_A_DIR:
 			return _("could not find or read directory");
-		case PM_ERR_WRONG_ARGS:
+		case ALPM_ERR_WRONG_ARGS:
 			return _("wrong or NULL argument passed");
-		case PM_ERR_DISK_SPACE:
+		case ALPM_ERR_DISK_SPACE:
 			return _("not enough free disk space");
 		/* Interface */
-		case PM_ERR_HANDLE_NULL:
+		case ALPM_ERR_HANDLE_NULL:
 			return _("library not initialized");
-		case PM_ERR_HANDLE_NOT_NULL:
+		case ALPM_ERR_HANDLE_NOT_NULL:
 			return _("library already initialized");
-		case PM_ERR_HANDLE_LOCK:
+		case ALPM_ERR_HANDLE_LOCK:
 			return _("unable to lock database");
 		/* Databases */
-		case PM_ERR_DB_OPEN:
+		case ALPM_ERR_DB_OPEN:
 			return _("could not open database");
-		case PM_ERR_DB_CREATE:
+		case ALPM_ERR_DB_CREATE:
 			return _("could not create database");
-		case PM_ERR_DB_NULL:
+		case ALPM_ERR_DB_NULL:
 			return _("database not initialized");
-		case PM_ERR_DB_NOT_NULL:
+		case ALPM_ERR_DB_NOT_NULL:
 			return _("database already registered");
-		case PM_ERR_DB_NOT_FOUND:
+		case ALPM_ERR_DB_NOT_FOUND:
 			return _("could not find database");
-		case PM_ERR_DB_INVALID:
+		case ALPM_ERR_DB_INVALID:
 			return _("invalid or corrupted database");
-		case PM_ERR_DB_VERSION:
+		case ALPM_ERR_DB_VERSION:
 			return _("database is incorrect version");
-		case PM_ERR_DB_WRITE:
+		case ALPM_ERR_DB_WRITE:
 			return _("could not update database");
-		case PM_ERR_DB_REMOVE:
+		case ALPM_ERR_DB_REMOVE:
 			return _("could not remove database entry");
 		/* Servers */
-		case PM_ERR_SERVER_BAD_URL:
+		case ALPM_ERR_SERVER_BAD_URL:
 			return _("invalid url for server");
-		case PM_ERR_SERVER_NONE:
+		case ALPM_ERR_SERVER_NONE:
 			return _("no servers configured for repository");
 		/* Transactions */
-		case PM_ERR_TRANS_NOT_NULL:
+		case ALPM_ERR_TRANS_NOT_NULL:
 			return _("transaction already initialized");
-		case PM_ERR_TRANS_NULL:
+		case ALPM_ERR_TRANS_NULL:
 			return _("transaction not initialized");
-		case PM_ERR_TRANS_DUP_TARGET:
+		case ALPM_ERR_TRANS_DUP_TARGET:
 			return _("duplicate target");
-		case PM_ERR_TRANS_NOT_INITIALIZED:
+		case ALPM_ERR_TRANS_NOT_INITIALIZED:
 			return _("transaction not initialized");
-		case PM_ERR_TRANS_NOT_PREPARED:
+		case ALPM_ERR_TRANS_NOT_PREPARED:
 			return _("transaction not prepared");
-		case PM_ERR_TRANS_ABORT:
+		case ALPM_ERR_TRANS_ABORT:
 			return _("transaction aborted");
-		case PM_ERR_TRANS_TYPE:
+		case ALPM_ERR_TRANS_TYPE:
 			return _("operation not compatible with the transaction type");
-		case PM_ERR_TRANS_NOT_LOCKED:
+		case ALPM_ERR_TRANS_NOT_LOCKED:
 			return _("transaction commit attempt when database is not locked");
 		/* Packages */
-		case PM_ERR_PKG_NOT_FOUND:
+		case ALPM_ERR_PKG_NOT_FOUND:
 			return _("could not find or read package");
-		case PM_ERR_PKG_IGNORED:
+		case ALPM_ERR_PKG_IGNORED:
 			return _("operation cancelled due to ignorepkg");
-		case PM_ERR_PKG_INVALID:
+		case ALPM_ERR_PKG_INVALID:
 			return _("invalid or corrupted package");
-		case PM_ERR_PKG_OPEN:
+		case ALPM_ERR_PKG_OPEN:
 			return _("cannot open package file");
-		case PM_ERR_PKG_CANT_REMOVE:
+		case ALPM_ERR_PKG_CANT_REMOVE:
 			return _("cannot remove all files for package");
-		case PM_ERR_PKG_INVALID_NAME:
+		case ALPM_ERR_PKG_INVALID_NAME:
 			return _("package filename is not valid");
-		case PM_ERR_PKG_INVALID_ARCH:
+		case ALPM_ERR_PKG_INVALID_ARCH:
 			return _("package architecture is not valid");
-		case PM_ERR_PKG_REPO_NOT_FOUND:
+		case ALPM_ERR_PKG_REPO_NOT_FOUND:
 			return _("could not find repository for target");
 		/* Signatures */
-		case PM_ERR_SIG_MISSINGDIR:
+		case ALPM_ERR_SIG_MISSINGDIR:
 			return _("signature directory not configured correctly");
-		case PM_ERR_SIG_INVALID:
+		case ALPM_ERR_SIG_INVALID:
 			return _("invalid PGP signature");
-		case PM_ERR_SIG_UNKNOWN:
+		case ALPM_ERR_SIG_UNKNOWN:
 			return _("unknown PGP signature");
 		/* Deltas */
-		case PM_ERR_DLT_INVALID:
+		case ALPM_ERR_DLT_INVALID:
 			return _("invalid or corrupted delta");
-		case PM_ERR_DLT_PATCHFAILED:
+		case ALPM_ERR_DLT_PATCHFAILED:
 			return _("delta patch failed");
 		/* Dependencies */
-		case PM_ERR_UNSATISFIED_DEPS:
+		case ALPM_ERR_UNSATISFIED_DEPS:
 			return _("could not satisfy dependencies");
-		case PM_ERR_CONFLICTING_DEPS:
+		case ALPM_ERR_CONFLICTING_DEPS:
 			return _("conflicting dependencies");
-		case PM_ERR_FILE_CONFLICTS:
+		case ALPM_ERR_FILE_CONFLICTS:
 			return _("conflicting files");
 		/* Miscellaenous */
-		case PM_ERR_RETRIEVE:
+		case ALPM_ERR_RETRIEVE:
 			return _("failed to retrieve some files");
-		case PM_ERR_INVALID_REGEX:
+		case ALPM_ERR_INVALID_REGEX:
 			return _("invalid regular expression");
 		/* Errors from external libraries- our own wrapper error */
-		case PM_ERR_LIBARCHIVE:
+		case ALPM_ERR_LIBARCHIVE:
 			/* it would be nice to use archive_error_string() here, but that
 			 * requires the archive struct, so we can't. Just use a generic
 			 * error string instead. */
 			return _("libarchive error");
-		case PM_ERR_LIBCURL:
+		case ALPM_ERR_LIBCURL:
 			return _("download library error");
-		case PM_ERR_GPGME:
+		case ALPM_ERR_GPGME:
 			return _("gpgme error");
-		case PM_ERR_EXTERNAL_DOWNLOAD:
+		case ALPM_ERR_EXTERNAL_DOWNLOAD:
 			return _("error invoking external downloader");
 		/* Unknown error! */
 		default:
diff --git a/lib/libalpm/handle.c b/lib/libalpm/handle.c
index 66fb935b..22f3fc8f 100644
--- a/lib/libalpm/handle.c
+++ b/lib/libalpm/handle.c
@@ -312,16 +312,16 @@ enum _alpm_errno_t _alpm_set_directory_option(const char *value,
 
 	path = value;
 	if(!path) {
-		return PM_ERR_WRONG_ARGS;
+		return ALPM_ERR_WRONG_ARGS;
 	}
 	if(must_exist) {
 		if(stat(path, &st) == -1 || !S_ISDIR(st.st_mode)) {
-			return PM_ERR_NOT_A_DIR;
+			return ALPM_ERR_NOT_A_DIR;
 		}
-		CALLOC(real, PATH_MAX, sizeof(char), return PM_ERR_MEMORY);
+		CALLOC(real, PATH_MAX, sizeof(char), return ALPM_ERR_MEMORY);
 		if(!realpath(path, real)) {
 			free(real);
-			return PM_ERR_NOT_A_DIR;
+			return ALPM_ERR_NOT_A_DIR;
 		}
 		path = real;
 	}
@@ -331,7 +331,7 @@ enum _alpm_errno_t _alpm_set_directory_option(const char *value,
 	}
 	*storage = canonicalize_path(path);
 	if(!*storage) {
-		return PM_ERR_MEMORY;
+		return ALPM_ERR_MEMORY;
 	}
 	free(real);
 	return 0;
@@ -342,13 +342,13 @@ int SYMEXPORT alpm_option_add_cachedir(alpm_handle_t *handle, const char *cached
 	char *newcachedir;
 
 	CHECK_HANDLE(handle, return -1);
-	ASSERT(cachedir != NULL, RET_ERR(handle, PM_ERR_WRONG_ARGS, -1));
+	ASSERT(cachedir != NULL, RET_ERR(handle, ALPM_ERR_WRONG_ARGS, -1));
 	/* don't stat the cachedir yet, as it may not even be needed. we can
 	 * fail later if it is needed and the path is invalid. */
 
 	newcachedir = canonicalize_path(cachedir);
 	if(!newcachedir) {
-		RET_ERR(handle, PM_ERR_MEMORY, -1);
+		RET_ERR(handle, ALPM_ERR_MEMORY, -1);
 	}
 	handle->cachedirs = alpm_list_add(handle->cachedirs, newcachedir);
 	_alpm_log(handle, ALPM_LOG_DEBUG, "option 'cachedir' = %s\n", newcachedir);
@@ -376,11 +376,11 @@ int SYMEXPORT alpm_option_remove_cachedir(alpm_handle_t *handle, const char *cac
 	char *vdata = NULL;
 	char *newcachedir;
 	CHECK_HANDLE(handle, return -1);
-	ASSERT(cachedir != NULL, RET_ERR(handle, PM_ERR_WRONG_ARGS, -1));
+	ASSERT(cachedir != NULL, RET_ERR(handle, ALPM_ERR_WRONG_ARGS, -1));
 
 	newcachedir = canonicalize_path(cachedir);
 	if(!newcachedir) {
-		RET_ERR(handle, PM_ERR_MEMORY, -1);
+		RET_ERR(handle, ALPM_ERR_MEMORY, -1);
 	}
 	handle->cachedirs = alpm_list_remove_str(handle->cachedirs, newcachedir, &vdata);
 	FREE(newcachedir);
@@ -397,7 +397,7 @@ int SYMEXPORT alpm_option_set_logfile(alpm_handle_t *handle, const char *logfile
 
 	CHECK_HANDLE(handle, return -1);
 	if(!logfile) {
-		handle->pm_errno = PM_ERR_WRONG_ARGS;
+		handle->pm_errno = ALPM_ERR_WRONG_ARGS;
 		return -1;
 	}
 
@@ -420,7 +420,7 @@ int SYMEXPORT alpm_option_set_gpgdir(alpm_handle_t *handle, const char *gpgdir)
 {
 	CHECK_HANDLE(handle, return -1);
 	if(!gpgdir) {
-		handle->pm_errno = PM_ERR_WRONG_ARGS;
+		handle->pm_errno = ALPM_ERR_WRONG_ARGS;
 		return -1;
 	}
 
@@ -577,7 +577,7 @@ int SYMEXPORT alpm_option_set_checkspace(alpm_handle_t *handle, int checkspace)
 int SYMEXPORT alpm_option_set_default_sigverify(alpm_handle_t *handle, pgp_verify_t level)
 {
 	CHECK_HANDLE(handle, return -1);
-	ASSERT(level != PM_PGP_VERIFY_UNKNOWN, RET_ERR(handle, PM_ERR_WRONG_ARGS, -1));
+	ASSERT(level != PM_PGP_VERIFY_UNKNOWN, RET_ERR(handle, ALPM_ERR_WRONG_ARGS, -1));
 	handle->sigverify = level;
 	return 0;
 }
diff --git a/lib/libalpm/log.c b/lib/libalpm/log.c
index eeeaef3c..692ff79c 100644
--- a/lib/libalpm/log.c
+++ b/lib/libalpm/log.c
@@ -53,11 +53,11 @@ int SYMEXPORT alpm_logaction(alpm_handle_t *handle, const char *fmt, ...)
 		/* if we couldn't open it, we have an issue */
 		if(handle->logstream == NULL) {
 			if(errno == EACCES) {
-				handle->pm_errno = PM_ERR_BADPERMS;
+				handle->pm_errno = ALPM_ERR_BADPERMS;
 			} else if(errno == ENOENT) {
-				handle->pm_errno = PM_ERR_NOT_A_DIR;
+				handle->pm_errno = ALPM_ERR_NOT_A_DIR;
 			} else {
-				handle->pm_errno = PM_ERR_SYSTEM;
+				handle->pm_errno = ALPM_ERR_SYSTEM;
 			}
 			return -1;
 		}
diff --git a/lib/libalpm/package.c b/lib/libalpm/package.c
index 21984b37..28fa08cb 100644
--- a/lib/libalpm/package.c
+++ b/lib/libalpm/package.c
@@ -65,7 +65,7 @@ int SYMEXPORT alpm_pkg_checkmd5sum(alpm_pkg_t *pkg)
 	pkg->handle->pm_errno = 0;
 	/* We only inspect packages from sync repositories */
 	ASSERT(pkg->origin == PKG_FROM_SYNCDB,
-			RET_ERR(pkg->handle, PM_ERR_WRONG_ARGS, -1));
+			RET_ERR(pkg->handle, ALPM_ERR_WRONG_ARGS, -1));
 
 	fpath = _alpm_filecache_find(pkg->handle, alpm_pkg_get_filename(pkg));
 
@@ -74,7 +74,7 @@ int SYMEXPORT alpm_pkg_checkmd5sum(alpm_pkg_t *pkg)
 	if(retval == 0) {
 		return 0;
 	} else if(retval == 1) {
-		pkg->handle->pm_errno = PM_ERR_PKG_INVALID;
+		pkg->handle->pm_errno = ALPM_ERR_PKG_INVALID;
 		retval = -1;
 	}
 
diff --git a/lib/libalpm/remove.c b/lib/libalpm/remove.c
index a90cd13a..2d6fcf64 100644
--- a/lib/libalpm/remove.c
+++ b/lib/libalpm/remove.c
@@ -51,17 +51,17 @@ int SYMEXPORT alpm_remove_pkg(alpm_handle_t *handle, alpm_pkg_t *pkg)
 
 	/* Sanity checks */
 	CHECK_HANDLE(handle, return -1);
-	ASSERT(pkg != NULL, RET_ERR(handle, PM_ERR_WRONG_ARGS, -1));
-	ASSERT(handle == pkg->handle, RET_ERR(handle, PM_ERR_WRONG_ARGS, -1));
+	ASSERT(pkg != NULL, RET_ERR(handle, ALPM_ERR_WRONG_ARGS, -1));
+	ASSERT(handle == pkg->handle, RET_ERR(handle, ALPM_ERR_WRONG_ARGS, -1));
 	trans = handle->trans;
-	ASSERT(trans != NULL, RET_ERR(handle, PM_ERR_TRANS_NULL, -1));
+	ASSERT(trans != NULL, RET_ERR(handle, ALPM_ERR_TRANS_NULL, -1));
 	ASSERT(trans->state == STATE_INITIALIZED,
-			RET_ERR(handle, PM_ERR_TRANS_NOT_INITIALIZED, -1));
+			RET_ERR(handle, ALPM_ERR_TRANS_NOT_INITIALIZED, -1));
 
 	pkgname = pkg->name;
 
 	if(_alpm_pkg_find(trans->remove, pkgname)) {
-		RET_ERR(handle, PM_ERR_TRANS_DUP_TARGET, -1);
+		RET_ERR(handle, ALPM_ERR_TRANS_DUP_TARGET, -1);
 	}
 
 	_alpm_log(handle, ALPM_LOG_DEBUG, "adding package %s to the transaction remove list\n",
@@ -166,7 +166,7 @@ int _alpm_remove_prepare(alpm_handle_t *handle, alpm_list_t **data)
 					alpm_list_free_inner(lp, (alpm_list_fn_free)_alpm_depmiss_free);
 					alpm_list_free(lp);
 				}
-				RET_ERR(handle, PM_ERR_UNSATISFIED_DEPS, -1);
+				RET_ERR(handle, ALPM_ERR_UNSATISFIED_DEPS, -1);
 			}
 		}
 	}
@@ -321,7 +321,7 @@ int _alpm_upgraderemove_package(alpm_handle_t *handle,
 		if(!can_remove_file(handle, lp->data, skip_remove)) {
 			_alpm_log(handle, ALPM_LOG_DEBUG,
 					"not removing package '%s', can't remove all files\n", pkgname);
-			RET_ERR(handle, PM_ERR_PKG_CANT_REMOVE, -1);
+			RET_ERR(handle, ALPM_ERR_PKG_CANT_REMOVE, -1);
 		}
 		filenum++;
 	}
@@ -397,7 +397,7 @@ int _alpm_remove_packages(alpm_handle_t *handle)
 				if(!can_remove_file(handle, lp->data, NULL)) {
 					_alpm_log(handle, ALPM_LOG_DEBUG, "not removing package '%s', can't remove all files\n",
 					          pkgname);
-					RET_ERR(handle, PM_ERR_PKG_CANT_REMOVE, -1);
+					RET_ERR(handle, ALPM_ERR_PKG_CANT_REMOVE, -1);
 				}
 				filenum++;
 			}
diff --git a/lib/libalpm/signing.c b/lib/libalpm/signing.c
index 8ac457af..1ac9963a 100644
--- a/lib/libalpm/signing.c
+++ b/lib/libalpm/signing.c
@@ -118,7 +118,7 @@ static int init_gpgme(alpm_handle_t *handle)
 
 	sigdir = alpm_option_get_gpgdir(handle);
 	if(!sigdir) {
-		RET_ERR(handle, PM_ERR_SIG_MISSINGDIR, 1);
+		RET_ERR(handle, ALPM_ERR_SIG_MISSINGDIR, 1);
 	}
 
 	/* calling gpgme_check_version() returns the current version and runs
@@ -154,7 +154,7 @@ static int init_gpgme(alpm_handle_t *handle)
 
 error:
 	_alpm_log(handle, ALPM_LOG_ERROR, _("GPGME error: %s\n"), gpgme_strerror(err));
-	RET_ERR(handle, PM_ERR_GPGME, 1);
+	RET_ERR(handle, ALPM_ERR_GPGME, 1);
 }
 
 /**
@@ -219,17 +219,17 @@ int _alpm_gpgme_checksig(alpm_handle_t *handle, const char *path,
 	FILE *file = NULL, *sigfile = NULL;
 
 	if(!path || access(path, R_OK) != 0) {
-		RET_ERR(handle, PM_ERR_NOT_A_FILE, -1);
+		RET_ERR(handle, ALPM_ERR_NOT_A_FILE, -1);
 	}
 
 	if(!base64_sig) {
 		size_t len = strlen(path) + 5;
-		CALLOC(sigpath, len, sizeof(char), RET_ERR(handle, PM_ERR_MEMORY, -1));
+		CALLOC(sigpath, len, sizeof(char), RET_ERR(handle, ALPM_ERR_MEMORY, -1));
 		snprintf(sigpath, len, "%s.sig", path);
 
 		if(!access(sigpath, R_OK) == 0) {
 			FREE(sigpath);
-			RET_ERR(handle, PM_ERR_SIG_UNKNOWN, -1);
+			RET_ERR(handle, ALPM_ERR_SIG_UNKNOWN, -1);
 		}
 	}
 
@@ -250,7 +250,7 @@ int _alpm_gpgme_checksig(alpm_handle_t *handle, const char *path,
 	/* create our necessary data objects to verify the signature */
 	file = fopen(path, "rb");
 	if(file == NULL) {
-		handle->pm_errno = PM_ERR_NOT_A_FILE;
+		handle->pm_errno = ALPM_ERR_NOT_A_FILE;
 		ret = -1;
 		goto error;
 	}
@@ -273,7 +273,7 @@ int _alpm_gpgme_checksig(alpm_handle_t *handle, const char *path,
 		/* file-based, it is on disk */
 		sigfile = fopen(sigpath, "rb");
 		if(sigfile == NULL) {
-			handle->pm_errno = PM_ERR_NOT_A_FILE;
+			handle->pm_errno = ALPM_ERR_NOT_A_FILE;
 			ret = -1;
 			goto error;
 		}
@@ -320,16 +320,16 @@ int _alpm_gpgme_checksig(alpm_handle_t *handle, const char *path,
 		} else if(gpgsig->summary & GPGME_SIGSUM_RED) {
 			/* definite bad signature, error */
 			_alpm_log(handle, ALPM_LOG_DEBUG, "result: red signature\n");
-			handle->pm_errno = PM_ERR_SIG_INVALID;
+			handle->pm_errno = ALPM_ERR_SIG_INVALID;
 			ret = 1;
 		} else if(gpgsig->summary & GPGME_SIGSUM_KEY_MISSING) {
 			_alpm_log(handle, ALPM_LOG_DEBUG, "result: signature from unknown key\n");
-			handle->pm_errno = PM_ERR_SIG_UNKNOWN;
+			handle->pm_errno = ALPM_ERR_SIG_UNKNOWN;
 			ret = 1;
 		} else {
 			/* we'll capture everything else here */
 			_alpm_log(handle, ALPM_LOG_DEBUG, "result: invalid signature\n");
-			handle->pm_errno = PM_ERR_SIG_INVALID;
+			handle->pm_errno = ALPM_ERR_SIG_INVALID;
 			ret = 1;
 		}
 
@@ -350,7 +350,7 @@ error:
 	FREE(decoded_sigdata);
 	if(err != GPG_ERR_NO_ERROR) {
 		_alpm_log(handle, ALPM_LOG_ERROR, _("GPGME error: %s\n"), gpgme_strerror(err));
-		RET_ERR(handle, PM_ERR_GPGME, -1);
+		RET_ERR(handle, ALPM_ERR_GPGME, -1);
 	}
 	return ret;
 }
diff --git a/lib/libalpm/sync.c b/lib/libalpm/sync.c
index 1537347e..d6b54ba0 100644
--- a/lib/libalpm/sync.c
+++ b/lib/libalpm/sync.c
@@ -94,8 +94,8 @@ int SYMEXPORT alpm_sync_sysupgrade(alpm_handle_t *handle, int enable_downgrade)
 	trans = handle->trans;
 	db_local = handle->db_local;
 	dbs_sync = handle->dbs_sync;
-	ASSERT(trans != NULL, RET_ERR(handle, PM_ERR_TRANS_NULL, -1));
-	ASSERT(trans->state == STATE_INITIALIZED, RET_ERR(handle, PM_ERR_TRANS_NOT_INITIALIZED, -1));
+	ASSERT(trans != NULL, RET_ERR(handle, ALPM_ERR_TRANS_NULL, -1));
+	ASSERT(trans->state == STATE_INITIALIZED, RET_ERR(handle, ALPM_ERR_TRANS_NOT_INITIALIZED, -1));
 
 	_alpm_log(handle, ALPM_LOG_DEBUG, "checking for package upgrades\n");
 	for(i = _alpm_db_get_pkgcache(db_local); i; i = i->next) {
@@ -266,7 +266,7 @@ static int compute_download_size(alpm_pkg_t *newpkg)
 	}
 
 	fname = alpm_pkg_get_filename(newpkg);
-	ASSERT(fname != NULL, RET_ERR(handle, PM_ERR_PKG_INVALID_NAME, -1));
+	ASSERT(fname != NULL, RET_ERR(handle, ALPM_ERR_PKG_INVALID_NAME, -1));
 	fpath = _alpm_filecache_find(handle, fname);
 
 	if(fpath) {
@@ -429,7 +429,7 @@ int _alpm_sync_prepare(alpm_handle_t *handle, alpm_list_t **data)
 				sync = sync2;
 			} else {
 				_alpm_log(handle, ALPM_LOG_ERROR, _("unresolvable package conflicts detected\n"));
-				handle->pm_errno = PM_ERR_CONFLICTING_DEPS;
+				handle->pm_errno = ALPM_ERR_CONFLICTING_DEPS;
 				ret = -1;
 				if(data) {
 					alpm_conflict_t *newconflict = _alpm_conflict_dup(conflict);
@@ -493,7 +493,7 @@ int _alpm_sync_prepare(alpm_handle_t *handle, alpm_list_t **data)
 				sync->removes = alpm_list_add(sync->removes, local);
 			} else { /* abort */
 				_alpm_log(handle, ALPM_LOG_ERROR, _("unresolvable package conflicts detected\n"));
-				handle->pm_errno = PM_ERR_CONFLICTING_DEPS;
+				handle->pm_errno = ALPM_ERR_CONFLICTING_DEPS;
 				ret = -1;
 				if(data) {
 					alpm_conflict_t *newconflict = _alpm_conflict_dup(conflict);
@@ -528,7 +528,7 @@ int _alpm_sync_prepare(alpm_handle_t *handle, alpm_list_t **data)
 		deps = alpm_checkdeps(handle, _alpm_db_get_pkgcache(handle->db_local),
 				trans->remove, trans->add, 1);
 		if(deps) {
-			handle->pm_errno = PM_ERR_UNSATISFIED_DEPS;
+			handle->pm_errno = ALPM_ERR_UNSATISFIED_DEPS;
 			ret = -1;
 			if(data) {
 				*data = deps;
@@ -612,11 +612,11 @@ static int apply_deltas(alpm_handle_t *handle)
 			} else {
 				/* len = cachedir len + from len + '/' + null */
 				len = strlen(cachedir) + strlen(d->from) + 2;
-				CALLOC(from, len, sizeof(char), RET_ERR(handle, PM_ERR_MEMORY, 1));
+				CALLOC(from, len, sizeof(char), RET_ERR(handle, ALPM_ERR_MEMORY, 1));
 				snprintf(from, len, "%s/%s", cachedir, d->from);
 			}
 			len = strlen(cachedir) + strlen(d->to) + 2;
-			CALLOC(to, len, sizeof(char), RET_ERR(handle, PM_ERR_MEMORY, 1));
+			CALLOC(to, len, sizeof(char), RET_ERR(handle, ALPM_ERR_MEMORY, 1));
 			snprintf(to, len, "%s/%s", cachedir, d->to);
 
 			/* build the patch command */
@@ -652,7 +652,7 @@ static int apply_deltas(alpm_handle_t *handle)
 			if(retval != 0) {
 				/* one delta failed for this package, cancel the remaining ones */
 				EVENT(trans, ALPM_TRANS_EVT_DELTA_PATCH_FAILED, NULL, NULL);
-				handle->pm_errno = PM_ERR_DLT_PATCHFAILED;
+				handle->pm_errno = ALPM_ERR_DLT_PATCHFAILED;
 				ret = 1;
 				break;
 			}
@@ -714,7 +714,7 @@ static int validate_deltas(alpm_handle_t *handle, alpm_list_t *deltas,
 		FREE(filepath);
 	}
 	if(errors) {
-		handle->pm_errno = PM_ERR_DLT_INVALID;
+		handle->pm_errno = ALPM_ERR_DLT_INVALID;
 		return -1;
 	}
 	EVENT(trans, ALPM_TRANS_EVT_DELTA_INTEGRITY_DONE, NULL, NULL);
@@ -760,7 +760,7 @@ static int download_files(alpm_handle_t *handle, alpm_list_t **deltas)
 				const char *fname = NULL;
 
 				fname = alpm_pkg_get_filename(spkg);
-				ASSERT(fname != NULL, RET_ERR(handle, PM_ERR_PKG_INVALID_NAME, -1));
+				ASSERT(fname != NULL, RET_ERR(handle, ALPM_ERR_PKG_INVALID_NAME, -1));
 				alpm_list_t *delta_path = spkg->delta_path;
 				if(delta_path) {
 					/* using deltas */
@@ -794,7 +794,7 @@ static int download_files(alpm_handle_t *handle, alpm_list_t **deltas)
 
 					/* print server + filename into a buffer */
 					len = strlen(server_url) + strlen(filename) + 2;
-					CALLOC(fileurl, len, sizeof(char), RET_ERR(handle, PM_ERR_MEMORY, -1));
+					CALLOC(fileurl, len, sizeof(char), RET_ERR(handle, ALPM_ERR_MEMORY, -1));
 					snprintf(fileurl, len, "%s/%s", server_url, filename);
 
 					ret = _alpm_download(handle, fileurl, cachedir, 0, 1, 0);
@@ -813,7 +813,7 @@ static int download_files(alpm_handle_t *handle, alpm_list_t **deltas)
 				_alpm_log(handle, ALPM_LOG_WARNING, _("failed to retrieve some files from %s\n"),
 						current->treename);
 				if(handle->pm_errno == 0) {
-					handle->pm_errno = PM_ERR_RETRIEVE;
+					handle->pm_errno = ALPM_ERR_RETRIEVE;
 				}
 				return -1;
 			}
@@ -901,7 +901,7 @@ int _alpm_sync_commit(alpm_handle_t *handle, alpm_list_t **data)
 
 
 	if(errors) {
-		RET_ERR(handle, PM_ERR_PKG_INVALID, -1);
+		RET_ERR(handle, ALPM_ERR_PKG_INVALID, -1);
 	}
 
 	if(trans->flags & ALPM_TRANS_FLAG_DOWNLOADONLY) {
@@ -926,7 +926,7 @@ int _alpm_sync_commit(alpm_handle_t *handle, alpm_list_t **data)
 				alpm_list_free_inner(conflict, (alpm_list_fn_free)_alpm_fileconflict_free);
 				alpm_list_free(conflict);
 			}
-			RET_ERR(handle, PM_ERR_FILE_CONFLICTS, -1);
+			RET_ERR(handle, ALPM_ERR_FILE_CONFLICTS, -1);
 		}
 
 		EVENT(trans, ALPM_TRANS_EVT_FILECONFLICTS_DONE, NULL, NULL);
diff --git a/lib/libalpm/trans.c b/lib/libalpm/trans.c
index 01e7ccd8..26989499 100644
--- a/lib/libalpm/trans.c
+++ b/lib/libalpm/trans.c
@@ -57,23 +57,23 @@ int SYMEXPORT alpm_trans_init(alpm_handle_t *handle, alpm_transflag_t flags,
 
 	/* Sanity checks */
 	CHECK_HANDLE(handle, return -1);
-	ASSERT(handle->trans == NULL, RET_ERR(handle, PM_ERR_TRANS_NOT_NULL, -1));
+	ASSERT(handle->trans == NULL, RET_ERR(handle, ALPM_ERR_TRANS_NOT_NULL, -1));
 
 	for(i = handle->dbs_sync; i; i = i->next) {
 		const alpm_db_t *db = i->data;
 		if(!(db->status & DB_STATUS_VALID)) {
-			RET_ERR(handle, PM_ERR_DB_INVALID, -1);
+			RET_ERR(handle, ALPM_ERR_DB_INVALID, -1);
 		}
 	}
 
 	/* lock db */
 	if(!(flags & ALPM_TRANS_FLAG_NOLOCK)) {
 		if(_alpm_handle_lock(handle)) {
-			RET_ERR(handle, PM_ERR_HANDLE_LOCK, -1);
+			RET_ERR(handle, ALPM_ERR_HANDLE_LOCK, -1);
 		}
 	}
 
-	CALLOC(trans, 1, sizeof(alpm_trans_t), RET_ERR(handle, PM_ERR_MEMORY, -1));
+	CALLOC(trans, 1, sizeof(alpm_trans_t), RET_ERR(handle, ALPM_ERR_MEMORY, -1));
 	trans->flags = flags;
 	trans->cb_event = event;
 	trans->cb_conv = conv;
@@ -102,7 +102,7 @@ static alpm_list_t *check_arch(alpm_handle_t *handle, alpm_list_t *pkgs)
 			const char *pkgname = alpm_pkg_get_name(pkg);
 			const char *pkgver = alpm_pkg_get_version(pkg);
 			size_t len = strlen(pkgname) + strlen(pkgver) + strlen(pkgarch) + 3;
-			MALLOC(string, len, RET_ERR(handle, PM_ERR_MEMORY, invalid));
+			MALLOC(string, len, RET_ERR(handle, ALPM_ERR_MEMORY, invalid));
 			sprintf(string, "%s-%s-%s", pkgname, pkgver, pkgarch);
 			invalid = alpm_list_add(invalid, string);
 		}
@@ -117,12 +117,12 @@ int SYMEXPORT alpm_trans_prepare(alpm_handle_t *handle, alpm_list_t **data)
 
 	/* Sanity checks */
 	CHECK_HANDLE(handle, return -1);
-	ASSERT(data != NULL, RET_ERR(handle, PM_ERR_WRONG_ARGS, -1));
+	ASSERT(data != NULL, RET_ERR(handle, ALPM_ERR_WRONG_ARGS, -1));
 
 	trans = handle->trans;
 
-	ASSERT(trans != NULL, RET_ERR(handle, PM_ERR_TRANS_NULL, -1));
-	ASSERT(trans->state == STATE_INITIALIZED, RET_ERR(handle, PM_ERR_TRANS_NOT_INITIALIZED, -1));
+	ASSERT(trans != NULL, RET_ERR(handle, ALPM_ERR_TRANS_NULL, -1));
+	ASSERT(trans->state == STATE_INITIALIZED, RET_ERR(handle, ALPM_ERR_TRANS_NOT_INITIALIZED, -1));
 
 	/* If there's nothing to do, return without complaining */
 	if(trans->add == NULL && trans->remove == NULL) {
@@ -134,7 +134,7 @@ int SYMEXPORT alpm_trans_prepare(alpm_handle_t *handle, alpm_list_t **data)
 		if(data) {
 			*data = invalid;
 		}
-		RET_ERR(handle, PM_ERR_PKG_INVALID_ARCH, -1);
+		RET_ERR(handle, ALPM_ERR_PKG_INVALID_ARCH, -1);
 	}
 
 	if(trans->add == NULL) {
@@ -164,10 +164,10 @@ int SYMEXPORT alpm_trans_commit(alpm_handle_t *handle, alpm_list_t **data)
 
 	trans = handle->trans;
 
-	ASSERT(trans != NULL, RET_ERR(handle, PM_ERR_TRANS_NULL, -1));
-	ASSERT(trans->state == STATE_PREPARED, RET_ERR(handle, PM_ERR_TRANS_NOT_PREPARED, -1));
+	ASSERT(trans != NULL, RET_ERR(handle, ALPM_ERR_TRANS_NULL, -1));
+	ASSERT(trans->state == STATE_PREPARED, RET_ERR(handle, ALPM_ERR_TRANS_NOT_PREPARED, -1));
 
-	ASSERT(!(trans->flags & ALPM_TRANS_FLAG_NOLOCK), RET_ERR(handle, PM_ERR_TRANS_NOT_LOCKED, -1));
+	ASSERT(!(trans->flags & ALPM_TRANS_FLAG_NOLOCK), RET_ERR(handle, ALPM_ERR_TRANS_NOT_LOCKED, -1));
 
 	/* If there's nothing to do, return without complaining */
 	if(trans->add == NULL && trans->remove == NULL) {
@@ -202,9 +202,9 @@ int SYMEXPORT alpm_trans_interrupt(alpm_handle_t *handle)
 	CHECK_HANDLE(handle, return -1);
 
 	trans = handle->trans;
-	ASSERT(trans != NULL, RET_ERR(handle, PM_ERR_TRANS_NULL, -1));
+	ASSERT(trans != NULL, RET_ERR(handle, ALPM_ERR_TRANS_NULL, -1));
 	ASSERT(trans->state == STATE_COMMITING || trans->state == STATE_INTERRUPTED,
-			RET_ERR(handle, PM_ERR_TRANS_TYPE, -1));
+			RET_ERR(handle, ALPM_ERR_TRANS_TYPE, -1));
 
 	trans->state = STATE_INTERRUPTED;
 
@@ -220,8 +220,8 @@ int SYMEXPORT alpm_trans_release(alpm_handle_t *handle)
 	CHECK_HANDLE(handle, return -1);
 
 	trans = handle->trans;
-	ASSERT(trans != NULL, RET_ERR(handle, PM_ERR_TRANS_NULL, -1));
-	ASSERT(trans->state != STATE_IDLE, RET_ERR(handle, PM_ERR_TRANS_NULL, -1));
+	ASSERT(trans != NULL, RET_ERR(handle, ALPM_ERR_TRANS_NULL, -1));
+	ASSERT(trans->state != STATE_IDLE, RET_ERR(handle, ALPM_ERR_TRANS_NULL, -1));
 
 	int nolock_flag = trans->flags & ALPM_TRANS_FLAG_NOLOCK;
 
@@ -363,7 +363,7 @@ alpm_transflag_t SYMEXPORT alpm_trans_get_flags(alpm_handle_t *handle)
 {
 	/* Sanity checks */
 	CHECK_HANDLE(handle, return -1);
-	ASSERT(handle->trans != NULL, RET_ERR(handle, PM_ERR_TRANS_NULL, -1));
+	ASSERT(handle->trans != NULL, RET_ERR(handle, ALPM_ERR_TRANS_NULL, -1));
 
 	return handle->trans->flags;
 }
@@ -372,7 +372,7 @@ alpm_list_t SYMEXPORT *alpm_trans_get_add(alpm_handle_t *handle)
 {
 	/* Sanity checks */
 	CHECK_HANDLE(handle, return NULL);
-	ASSERT(handle->trans != NULL, RET_ERR(handle, PM_ERR_TRANS_NULL, NULL));
+	ASSERT(handle->trans != NULL, RET_ERR(handle, ALPM_ERR_TRANS_NULL, NULL));
 
 	return handle->trans->add;
 }
@@ -381,7 +381,7 @@ alpm_list_t SYMEXPORT *alpm_trans_get_remove(alpm_handle_t *handle)
 {
 	/* Sanity checks */
 	CHECK_HANDLE(handle, return NULL);
-	ASSERT(handle->trans != NULL, RET_ERR(handle, PM_ERR_TRANS_NULL, NULL));
+	ASSERT(handle->trans != NULL, RET_ERR(handle, ALPM_ERR_TRANS_NULL, NULL));
 
 	return handle->trans->remove;
 }
diff --git a/lib/libalpm/util.c b/lib/libalpm/util.c
index ab4051b8..cd7f19c9 100644
--- a/lib/libalpm/util.c
+++ b/lib/libalpm/util.c
@@ -254,7 +254,7 @@ int _alpm_unpack(alpm_handle_t *handle, const char *archive, const char *prefix,
 	int restore_cwd = 0;
 
 	if((_archive = archive_read_new()) == NULL) {
-		RET_ERR(handle, PM_ERR_LIBARCHIVE, 1);
+		RET_ERR(handle, ALPM_ERR_LIBARCHIVE, 1);
 	}
 
 	archive_read_support_compression_all(_archive);
@@ -264,7 +264,7 @@ int _alpm_unpack(alpm_handle_t *handle, const char *archive, const char *prefix,
 				ARCHIVE_DEFAULT_BYTES_PER_BLOCK) != ARCHIVE_OK) {
 		_alpm_log(handle, ALPM_LOG_ERROR, _("could not open file %s: %s\n"), archive,
 				archive_error_string(_archive));
-		RET_ERR(handle, PM_ERR_PKG_OPEN, 1);
+		RET_ERR(handle, ALPM_ERR_PKG_OPEN, 1);
 	}
 
 	oldmask = umask(0022);
diff --git a/src/pacman/conf.c b/src/pacman/conf.c
index 838f8e94..f2df260e 100644
--- a/src/pacman/conf.c
+++ b/src/pacman/conf.c
@@ -449,7 +449,7 @@ static int setup_libalpm(void)
 	if(!handle) {
 		pm_printf(ALPM_LOG_ERROR, _("failed to initialize alpm library (%s)\n"),
 		        alpm_strerror(err));
-		if(err == PM_ERR_DB_VERSION) {
+		if(err == ALPM_ERR_DB_VERSION) {
 			pm_printf(ALPM_LOG_ERROR, _("  try running pacman-db-upgrade\n"));
 		}
 		return -1;
diff --git a/src/pacman/remove.c b/src/pacman/remove.c
index 1221904d..3cedb892 100644
--- a/src/pacman/remove.c
+++ b/src/pacman/remove.c
@@ -106,13 +106,13 @@ int pacman_remove(alpm_list_t *targets)
 		pm_fprintf(stderr, ALPM_LOG_ERROR, _("failed to prepare transaction (%s)\n"),
 		        alpm_strerror(err));
 		switch(err) {
-			case PM_ERR_PKG_INVALID_ARCH:
+			case ALPM_ERR_PKG_INVALID_ARCH:
 				for(i = data; i; i = alpm_list_next(i)) {
 					char *pkg = alpm_list_getdata(i);
 					printf(_(":: package %s does not have a valid architecture\n"), pkg);
 				}
 				break;
-			case PM_ERR_UNSATISFIED_DEPS:
+			case ALPM_ERR_UNSATISFIED_DEPS:
 				for(i = data; i; i = alpm_list_next(i)) {
 					alpm_depmissing_t *miss = alpm_list_getdata(i);
 					char *depstring = alpm_dep_compute_string(miss->depend);
diff --git a/src/pacman/sync.c b/src/pacman/sync.c
index dd6404f7..ad6d5e5c 100644
--- a/src/pacman/sync.c
+++ b/src/pacman/sync.c
@@ -616,8 +616,8 @@ static int process_pkg(alpm_pkg_t *pkg)
 
 	if(ret == -1) {
 		enum _alpm_errno_t err = alpm_errno(config->handle);
-		if(err == PM_ERR_TRANS_DUP_TARGET
-				|| err == PM_ERR_PKG_IGNORED) {
+		if(err == ALPM_ERR_TRANS_DUP_TARGET
+				|| err == ALPM_ERR_PKG_IGNORED) {
 			/* just skip duplicate or ignored targets */
 			pm_printf(ALPM_LOG_WARNING, _("skipping target: %s\n"), alpm_pkg_get_name(pkg));
 			return 0;
@@ -681,7 +681,7 @@ static int process_targname(alpm_list_t *dblist, char *targname)
 	alpm_pkg_t *pkg = alpm_find_dbs_satisfier(config->handle, dblist, targname);
 
 	/* #FS#23342 - skip ignored packages when user says no */
-	if(alpm_errno(config->handle) == PM_ERR_PKG_IGNORED) {
+	if(alpm_errno(config->handle) == ALPM_ERR_PKG_IGNORED) {
 			pm_printf(ALPM_LOG_WARNING, _("skipping target: %s\n"), targname);
 			/* TODO how to do this, we shouldn't be fucking with it from the frontend */
 			/* pm_errno = 0; */
@@ -767,13 +767,13 @@ static int sync_trans(alpm_list_t *targets)
 		pm_fprintf(stderr, ALPM_LOG_ERROR, _("failed to prepare transaction (%s)\n"),
 		        alpm_strerror(err));
 		switch(err) {
-			case PM_ERR_PKG_INVALID_ARCH:
+			case ALPM_ERR_PKG_INVALID_ARCH:
 				for(i = data; i; i = alpm_list_next(i)) {
 					char *pkg = alpm_list_getdata(i);
 					printf(_(":: package %s does not have a valid architecture\n"), pkg);
 				}
 				break;
-			case PM_ERR_UNSATISFIED_DEPS:
+			case ALPM_ERR_UNSATISFIED_DEPS:
 				for(i = data; i; i = alpm_list_next(i)) {
 					alpm_depmissing_t *miss = alpm_list_getdata(i);
 					char *depstring = alpm_dep_compute_string(miss->depend);
@@ -781,7 +781,7 @@ static int sync_trans(alpm_list_t *targets)
 					free(depstring);
 				}
 				break;
-			case PM_ERR_CONFLICTING_DEPS:
+			case ALPM_ERR_CONFLICTING_DEPS:
 				for(i = data; i; i = alpm_list_next(i)) {
 					alpm_conflict_t *conflict = alpm_list_getdata(i);
 					/* only print reason if it contains new information */
@@ -834,7 +834,7 @@ static int sync_trans(alpm_list_t *targets)
 		pm_fprintf(stderr, ALPM_LOG_ERROR, _("failed to commit transaction (%s)\n"),
 		        alpm_strerror(err));
 		switch(err) {
-			case PM_ERR_FILE_CONFLICTS:
+			case ALPM_ERR_FILE_CONFLICTS:
 				for(i = data; i; i = alpm_list_next(i)) {
 					alpm_fileconflict_t *conflict = alpm_list_getdata(i);
 					switch(conflict->type) {
@@ -849,8 +849,8 @@ static int sync_trans(alpm_list_t *targets)
 					}
 				}
 				break;
-			case PM_ERR_PKG_INVALID:
-			case PM_ERR_DLT_INVALID:
+			case ALPM_ERR_PKG_INVALID:
+			case ALPM_ERR_DLT_INVALID:
 				for(i = data; i; i = alpm_list_next(i)) {
 					char *filename = alpm_list_getdata(i);
 					printf(_("%s is invalid or corrupted\n"), filename);
diff --git a/src/pacman/upgrade.c b/src/pacman/upgrade.c
index 2f814b0a..95b17cc1 100644
--- a/src/pacman/upgrade.c
+++ b/src/pacman/upgrade.c
@@ -98,13 +98,13 @@ int pacman_upgrade(alpm_list_t *targets)
 		pm_fprintf(stderr, ALPM_LOG_ERROR, _("failed to prepare transaction (%s)\n"),
 		        alpm_strerror(err));
 		switch(err) {
-			case PM_ERR_PKG_INVALID_ARCH:
+			case ALPM_ERR_PKG_INVALID_ARCH:
 				for(i = data; i; i = alpm_list_next(i)) {
 					char *pkg = alpm_list_getdata(i);
 					printf(_(":: package %s does not have a valid architecture\n"), pkg);
 				}
 				break;
-			case PM_ERR_UNSATISFIED_DEPS:
+			case ALPM_ERR_UNSATISFIED_DEPS:
 				for(i = data; i; i = alpm_list_next(i)) {
 					alpm_depmissing_t *miss = alpm_list_getdata(i);
 					char *depstring = alpm_dep_compute_string(miss->depend);
@@ -116,7 +116,7 @@ int pacman_upgrade(alpm_list_t *targets)
 					free(depstring);
 				}
 				break;
-			case PM_ERR_CONFLICTING_DEPS:
+			case ALPM_ERR_CONFLICTING_DEPS:
 				for(i = data; i; i = alpm_list_next(i)) {
 					alpm_conflict_t *conflict = alpm_list_getdata(i);
 					if(strcmp(conflict->package1, conflict->reason) == 0 ||
@@ -166,7 +166,7 @@ int pacman_upgrade(alpm_list_t *targets)
 		pm_fprintf(stderr, ALPM_LOG_ERROR, _("failed to commit transaction (%s)\n"),
 				alpm_strerror(err));
 		switch(err) {
-			case PM_ERR_FILE_CONFLICTS:
+			case ALPM_ERR_FILE_CONFLICTS:
 				for(i = data; i; i = alpm_list_next(i)) {
 					alpm_fileconflict_t *conflict = alpm_list_getdata(i);
 					switch(conflict->type) {
@@ -181,8 +181,8 @@ int pacman_upgrade(alpm_list_t *targets)
 					}
 				}
 				break;
-			case PM_ERR_PKG_INVALID:
-			case PM_ERR_DLT_INVALID:
+			case ALPM_ERR_PKG_INVALID:
+			case ALPM_ERR_DLT_INVALID:
 				for(i = data; i; i = alpm_list_next(i)) {
 					char *filename = alpm_list_getdata(i);
 					printf(_("%s is invalid or corrupted\n"), filename);
diff --git a/src/pacman/util.c b/src/pacman/util.c
index 2f55027a..9ced7aad 100644
--- a/src/pacman/util.c
+++ b/src/pacman/util.c
@@ -63,7 +63,7 @@ int trans_init(alpm_transflag_t flags)
 		enum _alpm_errno_t err = alpm_errno(config->handle);
 		pm_fprintf(stderr, ALPM_LOG_ERROR, _("failed to init transaction (%s)\n"),
 				alpm_strerror(err));
-		if(err == PM_ERR_HANDLE_LOCK) {
+		if(err == ALPM_ERR_HANDLE_LOCK) {
 			fprintf(stderr, _("  if you're sure a package manager is not already\n"
 						"  running, you can remove %s\n"),
 					alpm_option_get_lockfile(config->handle));
diff --git a/src/util/testpkg.c b/src/util/testpkg.c
index cfde486a..03234ed5 100644
--- a/src/util/testpkg.c
+++ b/src/util/testpkg.c
@@ -62,11 +62,11 @@ int main(int argc, char *argv[])
 			|| pkg == NULL) {
 		err = alpm_errno(handle);
 		switch(err) {
-			case PM_ERR_PKG_OPEN:
+			case ALPM_ERR_PKG_OPEN:
 				printf("Cannot open the given file.\n");
 				break;
-			case PM_ERR_LIBARCHIVE:
-			case PM_ERR_PKG_INVALID:
+			case ALPM_ERR_LIBARCHIVE:
+			case ALPM_ERR_PKG_INVALID:
 				printf("Package is invalid.\n");
 				break;
 			default: