Merge remote-tracking branch 'allan/ALPM'

Conflicts:
	lib/libalpm/be_local.c
	lib/libalpm/be_package.c
	lib/libalpm/conflict.c
	lib/libalpm/diskspace.c
	lib/libalpm/dload.c
	lib/libalpm/remove.c

22 files changed, 739 insertions, 739 deletions

diff --git a/lib/libalpm/add.c b/lib/libalpm/add.c
index 702e4d63..9ed4d818 100644
--- a/lib/libalpm/add.c
+++ b/lib/libalpm/add.c
@@ -58,20 +58,20 @@ 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;
 
-	_alpm_log(handle, PM_LOG_DEBUG, "adding package '%s'\n", pkgname);
+	_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);
@@ -81,25 +81,25 @@ int SYMEXPORT alpm_add_pkg(alpm_handle_t *handle, alpm_pkg_t *pkg)
 		int cmp = _alpm_pkg_compare_versions(pkg, local);
 
 		if(cmp == 0) {
-			if(trans->flags & PM_TRANS_FLAG_NEEDED) {
+			if(trans->flags & ALPM_TRANS_FLAG_NEEDED) {
 				/* with the NEEDED flag, packages up to date are not reinstalled */
-				_alpm_log(handle, PM_LOG_WARNING, _("%s-%s is up to date -- skipping\n"),
+				_alpm_log(handle, ALPM_LOG_WARNING, _("%s-%s is up to date -- skipping\n"),
 						localpkgname, localpkgver);
 				return 0;
-			} else if(!(trans->flags & PM_TRANS_FLAG_DOWNLOADONLY)) {
-				_alpm_log(handle, PM_LOG_WARNING, _("%s-%s is up to date -- reinstalling\n"),
+			} else if(!(trans->flags & ALPM_TRANS_FLAG_DOWNLOADONLY)) {
+				_alpm_log(handle, ALPM_LOG_WARNING, _("%s-%s is up to date -- reinstalling\n"),
 						localpkgname, localpkgver);
 			}
 		} else if(cmp < 0) {
 			/* local version is newer */
-			_alpm_log(handle, PM_LOG_WARNING, _("downgrading package %s (%s => %s)\n"),
+			_alpm_log(handle, ALPM_LOG_WARNING, _("downgrading package %s (%s => %s)\n"),
 					localpkgname, localpkgver, pkgver);
 		}
 	}
 
 	/* add the package to the transaction */
-	pkg->reason = PM_PKG_REASON_EXPLICIT;
-	_alpm_log(handle, PM_LOG_DEBUG, "adding package %s-%s to the transaction add list\n",
+	pkg->reason = ALPM_PKG_REASON_EXPLICIT;
+	_alpm_log(handle, ALPM_LOG_DEBUG, "adding package %s-%s to the transaction add list\n",
 						pkgname, pkgver);
 	trans->add = alpm_list_add(trans->add, pkg);
 
@@ -119,10 +119,10 @@ static int perform_extraction(alpm_handle_t *handle, struct archive *archive,
 	ret = archive_read_extract(archive, entry, archive_flags);
 	if(ret == ARCHIVE_WARN && archive_errno(archive) != ENOSPC) {
 		/* operation succeeded but a "non-critical" error was encountered */
-		_alpm_log(handle, PM_LOG_WARNING, _("warning given when extracting %s (%s)\n"),
+		_alpm_log(handle, ALPM_LOG_WARNING, _("warning given when extracting %s (%s)\n"),
 				origname, archive_error_string(archive));
 	} else if(ret != ARCHIVE_OK) {
-		_alpm_log(handle, PM_LOG_ERROR, _("could not extract %s (%s)\n"),
+		_alpm_log(handle, ALPM_LOG_ERROR, _("could not extract %s (%s)\n"),
 				origname, archive_error_string(archive));
 		alpm_logaction(handle, "error: could not extract %s (%s)\n",
 				origname, archive_error_string(archive));
@@ -160,7 +160,7 @@ static int extract_single_file(alpm_handle_t *handle, struct archive *archive,
 	} else if(*entryname == '.') {
 		/* for now, ignore all files starting with '.' that haven't
 		 * already been handled (for future possibilities) */
-		_alpm_log(handle, PM_LOG_DEBUG, "skipping extraction of '%s'\n", entryname);
+		_alpm_log(handle, ALPM_LOG_DEBUG, "skipping extraction of '%s'\n", entryname);
 		archive_read_data_skip(archive);
 		return 0;
 	} else {
@@ -170,7 +170,7 @@ static int extract_single_file(alpm_handle_t *handle, struct archive *archive,
 
 	/* if a file is in NoExtract then we never extract it */
 	if(alpm_list_find_str(handle->noextract, entryname)) {
-		_alpm_log(handle, PM_LOG_DEBUG, "%s is in NoExtract, skipping extraction\n",
+		_alpm_log(handle, ALPM_LOG_DEBUG, "%s is in NoExtract, skipping extraction\n",
 				entryname);
 		alpm_logaction(handle, "note: %s is in NoExtract, skipping extraction\n",
 				entryname);
@@ -209,20 +209,20 @@ static int extract_single_file(alpm_handle_t *handle, struct archive *archive,
 				if(lsbuf.st_mode != entrymode) {
 					/* if filesystem perms are different than pkg perms, warn user */
 					mode_t mask = 07777;
-					_alpm_log(handle, PM_LOG_WARNING, _("directory permissions differ on %s\n"
+					_alpm_log(handle, ALPM_LOG_WARNING, _("directory permissions differ on %s\n"
 								"filesystem: %o  package: %o\n"), entryname, lsbuf.st_mode & mask,
 							entrymode & mask);
 					alpm_logaction(handle, "warning: directory permissions differ on %s\n"
 							"filesystem: %o  package: %o\n", entryname, lsbuf.st_mode & mask,
 							entrymode & mask);
 				}
-				_alpm_log(handle, PM_LOG_DEBUG, "extract: skipping dir extraction of %s\n",
+				_alpm_log(handle, ALPM_LOG_DEBUG, "extract: skipping dir extraction of %s\n",
 						entryname);
 				archive_read_data_skip(archive);
 				return 0;
 			} else {
 				/* case 10/11: trying to overwrite dir with file/symlink, don't allow it */
-				_alpm_log(handle, PM_LOG_ERROR, _("extract: not overwriting dir with file %s\n"),
+				_alpm_log(handle, ALPM_LOG_ERROR, _("extract: not overwriting dir with file %s\n"),
 						entryname);
 				archive_read_data_skip(archive);
 				return 1;
@@ -231,20 +231,20 @@ static int extract_single_file(alpm_handle_t *handle, struct archive *archive,
 			/* case 9: existing symlink, dir in package */
 			if(S_ISDIR(sbuf.st_mode)) {
 				/* the symlink on FS is to a directory, so we'll use it */
-				_alpm_log(handle, PM_LOG_DEBUG, "extract: skipping symlink overwrite of %s\n",
+				_alpm_log(handle, ALPM_LOG_DEBUG, "extract: skipping symlink overwrite of %s\n",
 						entryname);
 				archive_read_data_skip(archive);
 				return 0;
 			} else {
 				/* this is BAD. symlink was not to a directory */
-				_alpm_log(handle, PM_LOG_ERROR, _("extract: symlink %s does not point to dir\n"),
+				_alpm_log(handle, ALPM_LOG_ERROR, _("extract: symlink %s does not point to dir\n"),
 						entryname);
 				archive_read_data_skip(archive);
 				return 1;
 			}
 		} else if(S_ISREG(lsbuf.st_mode) && S_ISDIR(entrymode)) {
 			/* case 6: trying to overwrite file with dir */
-			_alpm_log(handle, PM_LOG_DEBUG, "extract: overwriting file with dir %s\n",
+			_alpm_log(handle, ALPM_LOG_DEBUG, "extract: overwriting file with dir %s\n",
 					entryname);
 		} else if(S_ISREG(entrymode)) {
 			/* case 4,7: */
@@ -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,15 +305,15 @@ 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;
 		}
 
-		_alpm_log(handle, PM_LOG_DEBUG, "checking hashes for %s\n", entryname_orig);
-		_alpm_log(handle, PM_LOG_DEBUG, "current:  %s\n", hash_local);
-		_alpm_log(handle, PM_LOG_DEBUG, "new:      %s\n", hash_pkg);
-		_alpm_log(handle, PM_LOG_DEBUG, "original: %s\n", hash_orig);
+		_alpm_log(handle, ALPM_LOG_DEBUG, "checking hashes for %s\n", entryname_orig);
+		_alpm_log(handle, ALPM_LOG_DEBUG, "current:  %s\n", hash_local);
+		_alpm_log(handle, ALPM_LOG_DEBUG, "new:      %s\n", hash_pkg);
+		_alpm_log(handle, ALPM_LOG_DEBUG, "original: %s\n", hash_orig);
 
 		if(!oldpkg) {
 			if(hash_local && hash_pkg && strcmp(hash_local, hash_pkg) != 0) {
@@ -324,7 +324,7 @@ static int extract_single_file(alpm_handle_t *handle, struct archive *archive,
 
 				/* move the existing file to the "pacorig" */
 				if(rename(filename, newpath)) {
-					_alpm_log(handle, PM_LOG_ERROR, _("could not rename %s to %s (%s)\n"),
+					_alpm_log(handle, ALPM_LOG_ERROR, _("could not rename %s to %s (%s)\n"),
 							filename, newpath, strerror(errno));
 					alpm_logaction(handle, "error: could not rename %s to %s (%s)\n",
 							filename, newpath, strerror(errno));
@@ -332,13 +332,13 @@ static int extract_single_file(alpm_handle_t *handle, struct archive *archive,
 				} else {
 					/* rename the file we extracted to the real name */
 					if(rename(checkfile, filename)) {
-						_alpm_log(handle, PM_LOG_ERROR, _("could not rename %s to %s (%s)\n"),
+						_alpm_log(handle, ALPM_LOG_ERROR, _("could not rename %s to %s (%s)\n"),
 								checkfile, filename, strerror(errno));
 						alpm_logaction(handle, "error: could not rename %s to %s (%s)\n",
 								checkfile, filename, strerror(errno));
 						errors++;
 					} else {
-						_alpm_log(handle, PM_LOG_WARNING, _("%s saved as %s\n"), filename, newpath);
+						_alpm_log(handle, ALPM_LOG_WARNING, _("%s saved as %s\n"), filename, newpath);
 						alpm_logaction(handle, "warning: %s saved as %s\n", filename, newpath);
 					}
 				}
@@ -352,11 +352,11 @@ static int extract_single_file(alpm_handle_t *handle, struct archive *archive,
 			if(hash_local && strcmp(hash_orig, hash_local) == 0) {
 				/* installed file has NOT been changed by user */
 				if(hash_pkg && strcmp(hash_orig, hash_pkg) != 0) {
-					_alpm_log(handle, PM_LOG_DEBUG, "action: installing new file: %s\n",
+					_alpm_log(handle, ALPM_LOG_DEBUG, "action: installing new file: %s\n",
 							entryname_orig);
 
 					if(rename(checkfile, filename)) {
-						_alpm_log(handle, PM_LOG_ERROR, _("could not rename %s to %s (%s)\n"),
+						_alpm_log(handle, ALPM_LOG_ERROR, _("could not rename %s to %s (%s)\n"),
 								checkfile, filename, strerror(errno));
 						alpm_logaction(handle, "error: could not rename %s to %s (%s)\n",
 								checkfile, filename, strerror(errno));
@@ -365,33 +365,33 @@ static int extract_single_file(alpm_handle_t *handle, struct archive *archive,
 				} else {
 					/* no sense in installing the same file twice, install
 					 * ONLY if the original and package hashes differ */
-					_alpm_log(handle, PM_LOG_DEBUG, "action: leaving existing file in place\n");
+					_alpm_log(handle, ALPM_LOG_DEBUG, "action: leaving existing file in place\n");
 					unlink(checkfile);
 				}
 			} else if(hash_pkg && strcmp(hash_orig, hash_pkg) == 0) {
 				/* originally installed file and new file are the same - this
 				 * implies the case above failed - i.e. the file was changed by a
 				 * user */
-				_alpm_log(handle, PM_LOG_DEBUG, "action: leaving existing file in place\n");
+				_alpm_log(handle, ALPM_LOG_DEBUG, "action: leaving existing file in place\n");
 				unlink(checkfile);
 			} else if(hash_local && hash_pkg && strcmp(hash_local, hash_pkg) == 0) {
 				/* this would be magical.  The above two cases failed, but the
 				 * user changes just so happened to make the new file exactly the
 				 * same as the one in the package... skip it */
-				_alpm_log(handle, PM_LOG_DEBUG, "action: leaving existing file in place\n");
+				_alpm_log(handle, ALPM_LOG_DEBUG, "action: leaving existing file in place\n");
 				unlink(checkfile);
 			} else {
 				char newpath[PATH_MAX];
-				_alpm_log(handle, PM_LOG_DEBUG, "action: keeping current file and installing"
+				_alpm_log(handle, ALPM_LOG_DEBUG, "action: keeping current file and installing"
 						" new one with .pacnew ending\n");
 				snprintf(newpath, PATH_MAX, "%s.pacnew", filename);
 				if(rename(checkfile, newpath)) {
-					_alpm_log(handle, PM_LOG_ERROR, _("could not install %s as %s (%s)\n"),
+					_alpm_log(handle, ALPM_LOG_ERROR, _("could not install %s as %s (%s)\n"),
 							filename, newpath, strerror(errno));
 					alpm_logaction(handle, "error: could not install %s as %s (%s)\n",
 							filename, newpath, strerror(errno));
 				} else {
-					_alpm_log(handle, PM_LOG_WARNING, _("%s installed as %s\n"),
+					_alpm_log(handle, ALPM_LOG_WARNING, _("%s installed as %s\n"),
 							filename, newpath);
 					alpm_logaction(handle, "warning: %s installed as %s\n",
 							filename, newpath);
@@ -407,15 +407,15 @@ static int extract_single_file(alpm_handle_t *handle, struct archive *archive,
 		/* we didn't need a backup */
 		if(notouch) {
 			/* change the path to a .pacnew extension */
-			_alpm_log(handle, PM_LOG_DEBUG, "%s is in NoUpgrade -- skipping\n", filename);
-			_alpm_log(handle, PM_LOG_WARNING, _("extracting %s as %s.pacnew\n"), filename, filename);
+			_alpm_log(handle, ALPM_LOG_DEBUG, "%s is in NoUpgrade -- skipping\n", filename);
+			_alpm_log(handle, ALPM_LOG_WARNING, _("extracting %s as %s.pacnew\n"), filename, filename);
 			alpm_logaction(handle, "warning: extracting %s as %s.pacnew\n", filename, filename);
 			strncat(filename, ".pacnew", PATH_MAX - strlen(filename));
 		} else {
-			_alpm_log(handle, PM_LOG_DEBUG, "extracting %s\n", filename);
+			_alpm_log(handle, ALPM_LOG_DEBUG, "extracting %s\n", filename);
 		}
 
-		if(handle->trans->flags & PM_TRANS_FLAG_FORCE) {
+		if(handle->trans->flags & ALPM_TRANS_FLAG_FORCE) {
 			/* if FORCE was used, unlink() each file (whether it's there
 			 * or not) before extracting. This prevents the old "Text file busy"
 			 * error that crops up if forcing a glibc or pacman upgrade. */
@@ -437,7 +437,7 @@ static int extract_single_file(alpm_handle_t *handle, struct archive *archive,
 			if(!backup->name || strcmp(backup->name, entryname_orig) != 0) {
 				continue;
 			}
-			_alpm_log(handle, PM_LOG_DEBUG, "appending backup entry for %s\n", entryname_orig);
+			_alpm_log(handle, ALPM_LOG_DEBUG, "appending backup entry for %s\n", entryname_orig);
 			newhash = alpm_compute_md5sum(filename);
 			FREE(backup->hash);
 			backup->hash = newhash;
@@ -471,43 +471,43 @@ static int commit_single_pkg(alpm_handle_t *handle, alpm_pkg_t *newpkg,
 		/* we'll need to save some record for backup checks later */
 		oldpkg = _alpm_pkg_dup(local);
 
-		EVENT(trans, PM_TRANS_EVT_UPGRADE_START, newpkg, oldpkg);
-		_alpm_log(handle, PM_LOG_DEBUG, "upgrading package %s-%s\n",
+		EVENT(trans, ALPM_TRANS_EVT_UPGRADE_START, newpkg, oldpkg);
+		_alpm_log(handle, ALPM_LOG_DEBUG, "upgrading package %s-%s\n",
 				newpkg->name, newpkg->version);
 
 		/* copy over the install reason */
 		newpkg->reason = alpm_pkg_get_reason(oldpkg);
 
 		/* pre_upgrade scriptlet */
-		if(alpm_pkg_has_scriptlet(newpkg) && !(trans->flags & PM_TRANS_FLAG_NOSCRIPTLET)) {
+		if(alpm_pkg_has_scriptlet(newpkg) && !(trans->flags & ALPM_TRANS_FLAG_NOSCRIPTLET)) {
 			_alpm_runscriptlet(handle, newpkg->origin_data.file,
 					"pre_upgrade", newpkg->version, oldpkg->version);
 		}
 	} else {
 		is_upgrade = 0;
 
-		EVENT(trans, PM_TRANS_EVT_ADD_START, newpkg, NULL);
-		_alpm_log(handle, PM_LOG_DEBUG, "adding package %s-%s\n",
+		EVENT(trans, ALPM_TRANS_EVT_ADD_START, newpkg, NULL);
+		_alpm_log(handle, ALPM_LOG_DEBUG, "adding package %s-%s\n",
 				newpkg->name, newpkg->version);
 
 		/* pre_install scriptlet */
-		if(alpm_pkg_has_scriptlet(newpkg) && !(trans->flags & PM_TRANS_FLAG_NOSCRIPTLET)) {
+		if(alpm_pkg_has_scriptlet(newpkg) && !(trans->flags & ALPM_TRANS_FLAG_NOSCRIPTLET)) {
 			_alpm_runscriptlet(handle, newpkg->origin_data.file,
 					"pre_install", newpkg->version, NULL);
 		}
 	}
 
 	/* we override any pre-set reason if we have alldeps or allexplicit set */
-	if(trans->flags & PM_TRANS_FLAG_ALLDEPS) {
-		newpkg->reason = PM_PKG_REASON_DEPEND;
-	} else if(trans->flags & PM_TRANS_FLAG_ALLEXPLICIT) {
-		newpkg->reason = PM_PKG_REASON_EXPLICIT;
+	if(trans->flags & ALPM_TRANS_FLAG_ALLDEPS) {
+		newpkg->reason = ALPM_PKG_REASON_DEPEND;
+	} else if(trans->flags & ALPM_TRANS_FLAG_ALLEXPLICIT) {
+		newpkg->reason = ALPM_PKG_REASON_EXPLICIT;
 	}
 
 	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,21 +518,21 @@ 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;
 	}
 
-	if(!(trans->flags & PM_TRANS_FLAG_DBONLY)) {
+	if(!(trans->flags & ALPM_TRANS_FLAG_DBONLY)) {
 		struct archive *archive;
 		struct archive_entry *entry;
 		char cwd[PATH_MAX] = "";
 		int restore_cwd = 0;
 
-		_alpm_log(handle, PM_LOG_DEBUG, "extracting files\n");
+		_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;
 		}
@@ -540,24 +540,24 @@ static int commit_single_pkg(alpm_handle_t *handle, alpm_pkg_t *newpkg,
 		archive_read_support_compression_all(archive);
 		archive_read_support_format_all(archive);
 
-		_alpm_log(handle, PM_LOG_DEBUG, "archive: %s\n", newpkg->origin_data.file);
+		_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;
 		}
 
 		/* save the cwd so we can restore it later */
 		if(getcwd(cwd, PATH_MAX) == NULL) {
-			_alpm_log(handle, PM_LOG_ERROR, _("could not get current working directory\n"));
+			_alpm_log(handle, ALPM_LOG_ERROR, _("could not get current working directory\n"));
 		} else {
 			restore_cwd = 1;
 		}
 
 		/* libarchive requires this for extracting hard links */
 		if(chdir(handle->root) != 0) {
-			_alpm_log(handle, PM_LOG_ERROR, _("could not change directory to %s (%s)\n"),
+			_alpm_log(handle, ALPM_LOG_ERROR, _("could not change directory to %s (%s)\n"),
 					handle->root, strerror(errno));
 			ret = -1;
 			goto cleanup;
@@ -565,10 +565,10 @@ static int commit_single_pkg(alpm_handle_t *handle, alpm_pkg_t *newpkg,
 
 		/* call PROGRESS once with 0 percent, as we sort-of skip that here */
 		if(is_upgrade) {
-			PROGRESS(trans, PM_TRANS_PROGRESS_UPGRADE_START,
+			PROGRESS(trans, ALPM_TRANS_PROGRESS_UPGRADE_START,
 					alpm_pkg_get_name(newpkg), 0, pkg_count, pkg_current);
 		} else {
-			PROGRESS(trans, PM_TRANS_PROGRESS_ADD_START,
+			PROGRESS(trans, ALPM_TRANS_PROGRESS_ADD_START,
 					alpm_pkg_get_name(newpkg), 0, pkg_count, pkg_current);
 		}
 
@@ -581,7 +581,7 @@ static int commit_single_pkg(alpm_handle_t *handle, alpm_pkg_t *newpkg,
 				 * (missing metadata sizes) */
 				int64_t pos = archive_position_compressed(archive);
 				percent = (pos * 100) / newpkg->size;
-				_alpm_log(handle, PM_LOG_DEBUG, "decompression progress: "
+				_alpm_log(handle, ALPM_LOG_DEBUG, "decompression progress: "
 						"%d%% (%"PRId64" / %jd)\n",
 						percent, pos, (intmax_t)newpkg->size);
 				if(percent >= 100) {
@@ -592,11 +592,11 @@ static int commit_single_pkg(alpm_handle_t *handle, alpm_pkg_t *newpkg,
 			}
 
 			if(is_upgrade) {
-				PROGRESS(trans, PM_TRANS_PROGRESS_UPGRADE_START,
+				PROGRESS(trans, ALPM_TRANS_PROGRESS_UPGRADE_START,
 						alpm_pkg_get_name(newpkg), percent, pkg_count,
 						pkg_current);
 			} else {
-				PROGRESS(trans, PM_TRANS_PROGRESS_ADD_START,
+				PROGRESS(trans, ALPM_TRANS_PROGRESS_ADD_START,
 						alpm_pkg_get_name(newpkg), percent, pkg_count,
 						pkg_current);
 			}
@@ -608,18 +608,18 @@ static int commit_single_pkg(alpm_handle_t *handle, alpm_pkg_t *newpkg,
 
 		/* restore the old cwd if we have it */
 		if(restore_cwd && chdir(cwd) != 0) {
-			_alpm_log(handle, PM_LOG_ERROR, _("could not change directory to %s (%s)\n"), cwd, strerror(errno));
+			_alpm_log(handle, ALPM_LOG_ERROR, _("could not change directory to %s (%s)\n"), cwd, strerror(errno));
 		}
 
 		if(errors) {
 			ret = -1;
 			if(is_upgrade) {
-				_alpm_log(handle, PM_LOG_ERROR, _("problem occurred while upgrading %s\n"),
+				_alpm_log(handle, ALPM_LOG_ERROR, _("problem occurred while upgrading %s\n"),
 						newpkg->name);
 				alpm_logaction(handle, "error: problem occurred while upgrading %s\n",
 						newpkg->name);
 			} else {
-				_alpm_log(handle, PM_LOG_ERROR, _("problem occurred while installing %s\n"),
+				_alpm_log(handle, ALPM_LOG_ERROR, _("problem occurred while installing %s\n"),
 						newpkg->name);
 				alpm_logaction(handle, "error: problem occurred while installing %s\n",
 						newpkg->name);
@@ -630,35 +630,35 @@ static int commit_single_pkg(alpm_handle_t *handle, alpm_pkg_t *newpkg,
 	/* make an install date (in UTC) */
 	newpkg->installdate = time(NULL);
 
-	_alpm_log(handle, PM_LOG_DEBUG, "updating database\n");
-	_alpm_log(handle, PM_LOG_DEBUG, "adding database entry '%s'\n", newpkg->name);
+	_alpm_log(handle, ALPM_LOG_DEBUG, "updating database\n");
+	_alpm_log(handle, ALPM_LOG_DEBUG, "adding database entry '%s'\n", newpkg->name);
 
 	if(_alpm_local_db_write(db, newpkg, INFRQ_ALL)) {
-		_alpm_log(handle, PM_LOG_ERROR, _("could not update database entry %s-%s\n"),
+		_alpm_log(handle, ALPM_LOG_ERROR, _("could not update database entry %s-%s\n"),
 				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;
 	}
 
 	if(_alpm_db_add_pkgincache(db, newpkg) == -1) {
-		_alpm_log(handle, PM_LOG_ERROR, _("could not add entry '%s' in cache\n"),
+		_alpm_log(handle, ALPM_LOG_ERROR, _("could not add entry '%s' in cache\n"),
 				alpm_pkg_get_name(newpkg));
 	}
 
 	if(is_upgrade) {
-		PROGRESS(trans, PM_TRANS_PROGRESS_UPGRADE_START,
+		PROGRESS(trans, ALPM_TRANS_PROGRESS_UPGRADE_START,
 				alpm_pkg_get_name(newpkg), 100, pkg_count, pkg_current);
 	} else {
-		PROGRESS(trans, PM_TRANS_PROGRESS_ADD_START,
+		PROGRESS(trans, ALPM_TRANS_PROGRESS_ADD_START,
 				alpm_pkg_get_name(newpkg), 100, pkg_count, pkg_current);
 	}
 
 	/* run the post-install script if it exists  */
 	if(alpm_pkg_has_scriptlet(newpkg)
-			&& !(trans->flags & PM_TRANS_FLAG_NOSCRIPTLET)) {
+			&& !(trans->flags & ALPM_TRANS_FLAG_NOSCRIPTLET)) {
 		if(is_upgrade) {
 			_alpm_runscriptlet(handle, scriptlet, "post_upgrade",
 					alpm_pkg_get_version(newpkg),
@@ -670,9 +670,9 @@ static int commit_single_pkg(alpm_handle_t *handle, alpm_pkg_t *newpkg,
 	}
 
 	if(is_upgrade) {
-		EVENT(trans, PM_TRANS_EVT_UPGRADE_DONE, newpkg, oldpkg);
+		EVENT(trans, ALPM_TRANS_EVT_UPGRADE_DONE, newpkg, oldpkg);
 	} else {
-		EVENT(trans, PM_TRANS_EVT_ADD_DONE, newpkg, oldpkg);
+		EVENT(trans, ALPM_TRANS_EVT_ADD_DONE, newpkg, oldpkg);
 	}
 
 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 88aef37f..e733eb2d 100644
--- a/lib/libalpm/alpm.h
+++ b/lib/libalpm/alpm.h
@@ -55,25 +55,25 @@ extern "C" {
  */
 typedef enum _alpm_pkgreason_t {
 	/** Explicitly requested by the user. */
-	PM_PKG_REASON_EXPLICIT = 0,
+	ALPM_PKG_REASON_EXPLICIT = 0,
 	/** Installed as a dependency for another package. */
-	PM_PKG_REASON_DEPEND = 1
+	ALPM_PKG_REASON_DEPEND = 1
 } alpm_pkgreason_t;
 
 /** Types of version constraints in dependency specs. */
 typedef enum _alpm_depmod_t {
   /** No version constraint */
-	PM_DEP_MOD_ANY = 1,
+	ALPM_DEP_MOD_ANY = 1,
   /** Test version equality (package=x.y.z) */
-	PM_DEP_MOD_EQ,
+	ALPM_DEP_MOD_EQ,
   /** Test for at least a version (package>=x.y.z) */
-	PM_DEP_MOD_GE,
+	ALPM_DEP_MOD_GE,
   /** Test for at most a version (package<=x.y.z) */
-	PM_DEP_MOD_LE,
+	ALPM_DEP_MOD_LE,
   /** Test for greater than some version (package>x.y.z) */
-	PM_DEP_MOD_GT,
+	ALPM_DEP_MOD_GT,
   /** Test for less than some version (package<x.y.z) */
-	PM_DEP_MOD_LT
+	ALPM_DEP_MOD_LT
 } alpm_depmod_t;
 
 /**
@@ -82,8 +82,8 @@ typedef enum _alpm_depmod_t {
  * another target in the transaction.
  */
 typedef enum _alpm_fileconflicttype_t {
-	PM_FILECONFLICT_TARGET = 1,
-	PM_FILECONFLICT_FILESYSTEM
+	ALPM_FILECONFLICT_TARGET = 1,
+	ALPM_FILECONFLICT_FILESYSTEM
 } alpm_fileconflicttype_t;
 
 /**
@@ -181,10 +181,10 @@ typedef struct _alpm_backup_t {
  * Logging Levels
  */
 typedef enum _alpm_loglevel_t {
-	PM_LOG_ERROR    = 1,
-	PM_LOG_WARNING  = (1 << 1),
-	PM_LOG_DEBUG    = (1 << 2),
-	PM_LOG_FUNCTION = (1 << 3)
+	ALPM_LOG_ERROR    = 1,
+	ALPM_LOG_WARNING  = (1 << 1),
+	ALPM_LOG_DEBUG    = (1 << 2),
+	ALPM_LOG_FUNCTION = (1 << 3)
 } alpm_loglevel_t;
 
 typedef void (*alpm_cb_log)(alpm_loglevel_t, const char *, va_list);
@@ -739,39 +739,39 @@ alpm_pkg_t *alpm_sync_newversion(alpm_pkg_t *pkg, alpm_list_t *dbs_sync);
 /** Transaction flags */
 typedef enum _alpm_transflag_t {
 	/** Ignore dependency checks. */
-	PM_TRANS_FLAG_NODEPS = 1,
+	ALPM_TRANS_FLAG_NODEPS = 1,
 	/** Ignore file conflicts and overwrite files. */
-	PM_TRANS_FLAG_FORCE = (1 << 1),
+	ALPM_TRANS_FLAG_FORCE = (1 << 1),
 	/** Delete files even if they are tagged as backup. */
-	PM_TRANS_FLAG_NOSAVE = (1 << 2),
+	ALPM_TRANS_FLAG_NOSAVE = (1 << 2),
 	/** Ignore version numbers when checking dependencies. */
-	PM_TRANS_FLAG_NODEPVERSION = (1 << 3),
+	ALPM_TRANS_FLAG_NODEPVERSION = (1 << 3),
 	/** Remove also any packages depending on a package being removed. */
-	PM_TRANS_FLAG_CASCADE = (1 << 4),
+	ALPM_TRANS_FLAG_CASCADE = (1 << 4),
 	/** Remove packages and their unneeded deps (not explicitly installed). */
-	PM_TRANS_FLAG_RECURSE = (1 << 5),
+	ALPM_TRANS_FLAG_RECURSE = (1 << 5),
 	/** Modify database but do not commit changes to the filesystem. */
-	PM_TRANS_FLAG_DBONLY = (1 << 6),
+	ALPM_TRANS_FLAG_DBONLY = (1 << 6),
 	/* (1 << 7) flag can go here */
-	/** Use PM_PKG_REASON_DEPEND when installing packages. */
-	PM_TRANS_FLAG_ALLDEPS = (1 << 8),
+	/** Use ALPM_PKG_REASON_DEPEND when installing packages. */
+	ALPM_TRANS_FLAG_ALLDEPS = (1 << 8),
 	/** Only download packages and do not actually install. */
-	PM_TRANS_FLAG_DOWNLOADONLY = (1 << 9),
+	ALPM_TRANS_FLAG_DOWNLOADONLY = (1 << 9),
 	/** Do not execute install scriptlets after installing. */
-	PM_TRANS_FLAG_NOSCRIPTLET = (1 << 10),
+	ALPM_TRANS_FLAG_NOSCRIPTLET = (1 << 10),
 	/** Ignore dependency conflicts. */
-	PM_TRANS_FLAG_NOCONFLICTS = (1 << 11),
+	ALPM_TRANS_FLAG_NOCONFLICTS = (1 << 11),
 	/* (1 << 12) flag can go here */
 	/** Do not install a package if it is already installed and up to date. */
-	PM_TRANS_FLAG_NEEDED = (1 << 13),
-	/** Use PM_PKG_REASON_EXPLICIT when installing packages. */
-	PM_TRANS_FLAG_ALLEXPLICIT = (1 << 14),
+	ALPM_TRANS_FLAG_NEEDED = (1 << 13),
+	/** Use ALPM_PKG_REASON_EXPLICIT when installing packages. */
+	ALPM_TRANS_FLAG_ALLEXPLICIT = (1 << 14),
 	/** Do not remove a package if it is needed by another one. */
-	PM_TRANS_FLAG_UNNEEDED = (1 << 15),
-	/** Remove also explicitly installed unneeded deps (use with PM_TRANS_FLAG_RECURSE). */
-	PM_TRANS_FLAG_RECURSEALL = (1 << 16),
+	ALPM_TRANS_FLAG_UNNEEDED = (1 << 15),
+	/** Remove also explicitly installed unneeded deps (use with ALPM_TRANS_FLAG_RECURSE). */
+	ALPM_TRANS_FLAG_RECURSEALL = (1 << 16),
 	/** Do not lock the database during the operation. */
-	PM_TRANS_FLAG_NOLOCK = (1 << 17)
+	ALPM_TRANS_FLAG_NOLOCK = (1 << 17)
 } alpm_transflag_t;
 
 /** Transaction events.
@@ -779,100 +779,100 @@ typedef enum _alpm_transflag_t {
  */
 typedef enum _alpm_transevt_t {
 	/** Dependencies will be computed for a package. */
-	PM_TRANS_EVT_CHECKDEPS_START = 1,
+	ALPM_TRANS_EVT_CHECKDEPS_START = 1,
 	/** Dependencies were computed for a package. */
-	PM_TRANS_EVT_CHECKDEPS_DONE,
+	ALPM_TRANS_EVT_CHECKDEPS_DONE,
 	/** File conflicts will be computed for a package. */
-	PM_TRANS_EVT_FILECONFLICTS_START,
+	ALPM_TRANS_EVT_FILECONFLICTS_START,
 	/** File conflicts were computed for a package. */
-	PM_TRANS_EVT_FILECONFLICTS_DONE,
+	ALPM_TRANS_EVT_FILECONFLICTS_DONE,
 	/** Dependencies will be resolved for target package. */
-	PM_TRANS_EVT_RESOLVEDEPS_START,
+	ALPM_TRANS_EVT_RESOLVEDEPS_START,
 	/** Dependencies were resolved for target package. */
-	PM_TRANS_EVT_RESOLVEDEPS_DONE,
+	ALPM_TRANS_EVT_RESOLVEDEPS_DONE,
 	/** Inter-conflicts will be checked for target package. */
-	PM_TRANS_EVT_INTERCONFLICTS_START,
+	ALPM_TRANS_EVT_INTERCONFLICTS_START,
 	/** Inter-conflicts were checked for target package. */
-	PM_TRANS_EVT_INTERCONFLICTS_DONE,
+	ALPM_TRANS_EVT_INTERCONFLICTS_DONE,
 	/** Package will be installed.
 	 * A pointer to the target package is passed to the callback.
 	 */
-	PM_TRANS_EVT_ADD_START,
+	ALPM_TRANS_EVT_ADD_START,
 	/** Package was installed.
 	 * A pointer to the new package is passed to the callback.
 	 */
-	PM_TRANS_EVT_ADD_DONE,
+	ALPM_TRANS_EVT_ADD_DONE,
 	/** Package will be removed.
 	 * A pointer to the target package is passed to the callback.
 	 */
-	PM_TRANS_EVT_REMOVE_START,
+	ALPM_TRANS_EVT_REMOVE_START,
 	/** Package was removed.
 	 * A pointer to the removed package is passed to the callback.
 	 */
-	PM_TRANS_EVT_REMOVE_DONE,
+	ALPM_TRANS_EVT_REMOVE_DONE,
 	/** Package will be upgraded.
 	 * A pointer to the upgraded package is passed to the callback.
 	 */
-	PM_TRANS_EVT_UPGRADE_START,
+	ALPM_TRANS_EVT_UPGRADE_START,
 	/** Package was upgraded.
 	 * A pointer to the new package, and a pointer to the old package is passed
 	 * to the callback, respectively.
 	 */
-	PM_TRANS_EVT_UPGRADE_DONE,
+	ALPM_TRANS_EVT_UPGRADE_DONE,
 	/** Target package's integrity will be checked. */
-	PM_TRANS_EVT_INTEGRITY_START,
+	ALPM_TRANS_EVT_INTEGRITY_START,
 	/** Target package's integrity was checked. */
-	PM_TRANS_EVT_INTEGRITY_DONE,
+	ALPM_TRANS_EVT_INTEGRITY_DONE,
 	/** Target deltas's integrity will be checked. */
-	PM_TRANS_EVT_DELTA_INTEGRITY_START,
+	ALPM_TRANS_EVT_DELTA_INTEGRITY_START,
 	/** Target delta's integrity was checked. */
-	PM_TRANS_EVT_DELTA_INTEGRITY_DONE,
+	ALPM_TRANS_EVT_DELTA_INTEGRITY_DONE,
 	/** Deltas will be applied to packages. */
-	PM_TRANS_EVT_DELTA_PATCHES_START,
+	ALPM_TRANS_EVT_DELTA_PATCHES_START,
 	/** Deltas were applied to packages. */
-	PM_TRANS_EVT_DELTA_PATCHES_DONE,
+	ALPM_TRANS_EVT_DELTA_PATCHES_DONE,
 	/** Delta patch will be applied to target package.
 	 * The filename of the package and the filename of the patch is passed to the
 	 * callback.
 	 */
-	PM_TRANS_EVT_DELTA_PATCH_START,
+	ALPM_TRANS_EVT_DELTA_PATCH_START,
 	/** Delta patch was applied to target package. */
-	PM_TRANS_EVT_DELTA_PATCH_DONE,
+	ALPM_TRANS_EVT_DELTA_PATCH_DONE,
 	/** Delta patch failed to apply to target package. */
-	PM_TRANS_EVT_DELTA_PATCH_FAILED,
+	ALPM_TRANS_EVT_DELTA_PATCH_FAILED,
 	/** Scriptlet has printed information.
 	 * A line of text is passed to the callback.
 	 */
-	PM_TRANS_EVT_SCRIPTLET_INFO,
+	ALPM_TRANS_EVT_SCRIPTLET_INFO,
 	/** Files will be downloaded from a repository.
 	 * The repository's tree name is passed to the callback.
 	 */
-	PM_TRANS_EVT_RETRIEVE_START,
+	ALPM_TRANS_EVT_RETRIEVE_START,
 	/** Disk space usage will be computed for a package */
-	PM_TRANS_EVT_DISKSPACE_START,
+	ALPM_TRANS_EVT_DISKSPACE_START,
 	/** Disk space usage was computed for a package */
-	PM_TRANS_EVT_DISKSPACE_DONE,
+	ALPM_TRANS_EVT_DISKSPACE_DONE,
 } alpm_transevt_t;
 
 /** Transaction Conversations (ie, questions) */
 typedef enum _alpm_transconv_t {
-	PM_TRANS_CONV_INSTALL_IGNOREPKG = 1,
-	PM_TRANS_CONV_REPLACE_PKG = (1 << 1),
-	PM_TRANS_CONV_CONFLICT_PKG = (1 << 2),
-	PM_TRANS_CONV_CORRUPTED_PKG = (1 << 3),
-	PM_TRANS_CONV_LOCAL_NEWER = (1 << 4),
-	PM_TRANS_CONV_REMOVE_PKGS = (1 << 5),
-	PM_TRANS_CONV_SELECT_PROVIDER = (1 << 6),
+	ALPM_TRANS_CONV_INSTALL_IGNOREPKG = 1,
+	ALPM_TRANS_CONV_REPLACE_PKG = (1 << 1),
+	ALPM_TRANS_CONV_CONFLICT_PKG = (1 << 2),
+	ALPM_TRANS_CONV_CORRUPTED_PKG = (1 << 3),
+	ALPM_TRANS_CONV_LOCAL_NEWER = (1 << 4),
+	ALPM_TRANS_CONV_REMOVE_PKGS = (1 << 5),
+	ALPM_TRANS_CONV_SELECT_PROVIDER = (1 << 6),
 } alpm_transconv_t;
 
 /** Transaction Progress */
 typedef enum _alpm_transprog_t {
-	PM_TRANS_PROGRESS_ADD_START,
-	PM_TRANS_PROGRESS_UPGRADE_START,
-	PM_TRANS_PROGRESS_REMOVE_START,
-	PM_TRANS_PROGRESS_CONFLICTS_START,
-	PM_TRANS_PROGRESS_DISKSPACE_START,
-	PM_TRANS_PROGRESS_INTEGRITY_START,
+	ALPM_TRANS_PROGRESS_ADD_START,
+	ALPM_TRANS_PROGRESS_UPGRADE_START,
+	ALPM_TRANS_PROGRESS_REMOVE_START,
+	ALPM_TRANS_PROGRESS_CONFLICTS_START,
+	ALPM_TRANS_PROGRESS_DISKSPACE_START,
+	ALPM_TRANS_PROGRESS_INTEGRITY_START,
 } alpm_transprog_t;
 
 /** Transaction Event callback */
@@ -1007,67 +1007,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 f1056d40..70f242d2 100644
--- a/lib/libalpm/be_local.c
+++ b/lib/libalpm/be_local.c
@@ -280,15 +280,15 @@ static int checkdbdir(alpm_db_t *db)
 	const char *path = _alpm_db_path(db);
 
 	if(stat(path, &buf) != 0) {
-		_alpm_log(db->handle, PM_LOG_DEBUG, "database dir '%s' does not exist, creating it\n",
+		_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, PM_LOG_WARNING, _("removing invalid database: %s\n"), path);
+		_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,12 +437,12 @@ 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),
 					&(pkg->name_hash)) != 0) {
-			_alpm_log(db->handle, PM_LOG_ERROR, _("invalid name for database entry '%s'\n"),
+			_alpm_log(db->handle, ALPM_LOG_ERROR, _("invalid name for database entry '%s'\n"),
 					name);
 			_alpm_pkg_free(pkg);
 			continue;
@@ -450,7 +450,7 @@ static int local_db_populate(alpm_db_t *db)
 
 		/* duplicated database entries are not allowed */
 		if(_alpm_pkghash_find(db->pkgcache, pkg->name)) {
-			_alpm_log(db->handle, PM_LOG_ERROR, _("duplicated database entry '%s'\n"), pkg->name);
+			_alpm_log(db->handle, ALPM_LOG_ERROR, _("duplicated database entry '%s'\n"), pkg->name);
 			_alpm_pkg_free(pkg);
 			continue;
 		}
@@ -462,13 +462,13 @@ static int local_db_populate(alpm_db_t *db)
 
 		/* explicitly read with only 'BASE' data, accessors will handle the rest */
 		if(local_db_read(pkg, INFRQ_BASE) == -1) {
-			_alpm_log(db->handle, PM_LOG_ERROR, _("corrupted database entry '%s'\n"), name);
+			_alpm_log(db->handle, ALPM_LOG_ERROR, _("corrupted database entry '%s'\n"), name);
 			_alpm_pkg_free(pkg);
 			continue;
 		}
 
 		/* add to the collection */
-		_alpm_log(db->handle, PM_LOG_FUNCTION, "adding '%s' to package cache for db '%s'\n",
+		_alpm_log(db->handle, ALPM_LOG_FUNCTION, "adding '%s' to package cache for db '%s'\n",
 				pkg->name, db->treename);
 		db->pkgcache = _alpm_pkghash_add(db->pkgcache, pkg);
 		count++;
@@ -478,7 +478,7 @@ static int local_db_populate(alpm_db_t *db)
 	if(count > 0) {
 		db->pkgcache->list = alpm_list_msort(db->pkgcache->list, (size_t)count, _alpm_pkg_cmp);
 	}
-	_alpm_log(db->handle, PM_LOG_DEBUG, "added %d packages to package cache for db '%s'\n",
+	_alpm_log(db->handle, ALPM_LOG_DEBUG, "added %d packages to package cache for db '%s'\n",
 			count, db->treename);
 
 	return count;
@@ -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;
 }
@@ -533,7 +533,7 @@ static int local_db_read(alpm_pkg_t *info, alpm_dbinfrq_t inforeq)
 		/* already loaded all of this info, do nothing */
 		return 0;
 	}
-	_alpm_log(db->handle, PM_LOG_FUNCTION, "loading package data for %s : level=0x%x\n",
+	_alpm_log(db->handle, ALPM_LOG_FUNCTION, "loading package data for %s : level=0x%x\n",
 			info->name, inforeq);
 
 	/* clear out 'line', to be certain - and to make valgrind happy */
@@ -543,7 +543,7 @@ static int local_db_read(alpm_pkg_t *info, alpm_dbinfrq_t inforeq)
 
 	if(access(pkgpath, F_OK)) {
 		/* directory doesn't exist or can't be opened */
-		_alpm_log(db->handle, PM_LOG_DEBUG, "cannot find '%s-%s' in db '%s'\n",
+		_alpm_log(db->handle, ALPM_LOG_DEBUG, "cannot find '%s-%s' in db '%s'\n",
 				info->name, info->version, db->treename);
 		goto error;
 	}
@@ -552,7 +552,7 @@ static int local_db_read(alpm_pkg_t *info, alpm_dbinfrq_t inforeq)
 	if(inforeq & INFRQ_DESC && !(info->infolevel & INFRQ_DESC)) {
 		snprintf(path, PATH_MAX, "%sdesc", pkgpath);
 		if((fp = fopen(path, "r")) == NULL) {
-			_alpm_log(db->handle, PM_LOG_ERROR, _("could not open file %s: %s\n"), path, strerror(errno));
+			_alpm_log(db->handle, ALPM_LOG_ERROR, _("could not open file %s: %s\n"), path, strerror(errno));
 			goto error;
 		}
 		while(!feof(fp)) {
@@ -560,13 +560,13 @@ static int local_db_read(alpm_pkg_t *info, alpm_dbinfrq_t inforeq)
 			if(strcmp(line, "%NAME%") == 0) {
 				READ_NEXT();
 				if(strcmp(line, info->name) != 0) {
-					_alpm_log(db->handle, PM_LOG_ERROR, _("%s database is inconsistent: name "
+					_alpm_log(db->handle, ALPM_LOG_ERROR, _("%s database is inconsistent: name "
 								"mismatch on package %s\n"), db->treename, info->name);
 				}
 			} else if(strcmp(line, "%VERSION%") == 0) {
 				READ_NEXT();
 				if(strcmp(line, info->version) != 0) {
-					_alpm_log(db->handle, PM_LOG_ERROR, _("%s database is inconsistent: version "
+					_alpm_log(db->handle, ALPM_LOG_ERROR, _("%s database is inconsistent: version "
 								"mismatch on package %s\n"), db->treename, info->name);
 				}
 			} else if(strcmp(line, "%DESC%") == 0) {
@@ -625,7 +625,7 @@ static int local_db_read(alpm_pkg_t *info, alpm_dbinfrq_t inforeq)
 	if(inforeq & INFRQ_FILES && !(info->infolevel & INFRQ_FILES)) {
 		snprintf(path, PATH_MAX, "%sfiles", pkgpath);
 		if((fp = fopen(path, "r")) == NULL) {
-			_alpm_log(db->handle, PM_LOG_ERROR, _("could not open file %s: %s\n"), path, strerror(errno));
+			_alpm_log(db->handle, ALPM_LOG_ERROR, _("could not open file %s: %s\n"), path, strerror(errno));
 			goto error;
 		}
 		while(fgets(line, sizeof(line), fp)) {
@@ -689,7 +689,7 @@ int _alpm_local_db_prepare(alpm_db_t *db, alpm_pkg_t *info)
 	pkgpath = get_pkgpath(db, info);
 
 	if((retval = mkdir(pkgpath, 0755)) != 0) {
-		_alpm_log(db->handle, PM_LOG_ERROR, _("could not create directory %s: %s\n"),
+		_alpm_log(db->handle, ALPM_LOG_ERROR, _("could not create directory %s: %s\n"),
 				pkgpath, strerror(errno));
 	}
 
@@ -723,11 +723,11 @@ int _alpm_local_db_write(alpm_db_t *db, alpm_pkg_t *info, alpm_dbinfrq_t inforeq
 
 	/* DESC */
 	if(inforeq & INFRQ_DESC) {
-		_alpm_log(db->handle, PM_LOG_DEBUG, "writing %s-%s DESC information back to db\n",
+		_alpm_log(db->handle, ALPM_LOG_DEBUG, "writing %s-%s DESC information back to db\n",
 				info->name, info->version);
 		snprintf(path, PATH_MAX, "%sdesc", pkgpath);
 		if((fp = fopen(path, "w")) == NULL) {
-			_alpm_log(db->handle, PM_LOG_ERROR, _("could not open file %s: %s\n"),
+			_alpm_log(db->handle, ALPM_LOG_ERROR, _("could not open file %s: %s\n"),
 					path, strerror(errno));
 			retval = -1;
 			goto cleanup;
@@ -825,11 +825,11 @@ int _alpm_local_db_write(alpm_db_t *db, alpm_pkg_t *info, alpm_dbinfrq_t inforeq
 
 	/* FILES */
 	if(inforeq & INFRQ_FILES) {
-		_alpm_log(db->handle, PM_LOG_DEBUG, "writing %s-%s FILES information back to db\n",
+		_alpm_log(db->handle, ALPM_LOG_DEBUG, "writing %s-%s FILES information back to db\n",
 				info->name, info->version);
 		snprintf(path, PATH_MAX, "%sfiles", pkgpath);
 		if((fp = fopen(path, "w")) == NULL) {
-			_alpm_log(db->handle, PM_LOG_ERROR, _("could not open file %s: %s\n"),
+			_alpm_log(db->handle, ALPM_LOG_ERROR, _("could not open file %s: %s\n"),
 					path, strerror(errno));
 			retval = -1;
 			goto cleanup;
@@ -893,11 +893,11 @@ alpm_db_t *_alpm_db_register_local(alpm_handle_t *handle)
 {
 	alpm_db_t *db;
 
-	_alpm_log(handle, PM_LOG_DEBUG, "registering local database\n");
+	_alpm_log(handle, ALPM_LOG_DEBUG, "registering local database\n");
 
 	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 da5076e5..af213241 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;
 	}
@@ -158,7 +158,7 @@ static int parse_descfile(alpm_handle_t *handle, struct archive *a, alpm_pkg_t *
 		ptr = line;
 		key = strsep(&ptr, "=");
 		if(key == NULL || ptr == NULL) {
-			_alpm_log(handle, PM_LOG_DEBUG, "%s: syntax error in description file line %d\n",
+			_alpm_log(handle, ALPM_LOG_DEBUG, "%s: syntax error in description file line %d\n",
 								newpkg->name ? newpkg->name : "error", linenum);
 		} else {
 			key = _alpm_strtrim(key);
@@ -209,14 +209,14 @@ static int parse_descfile(alpm_handle_t *handle, struct archive *a, alpm_pkg_t *
 			} else if(strcmp(key, "makepkgopt") == 0) {
 				/* not used atm */
 			} else {
-				_alpm_log(handle, PM_LOG_DEBUG, "%s: unknown key '%s' in description file line %d\n",
+				_alpm_log(handle, ALPM_LOG_DEBUG, "%s: unknown key '%s' in description file line %d\n",
 									newpkg->name ? newpkg->name : "error", key, linenum);
 			}
 		}
 		line[0] = '\0';
 	}
 	if(ret != ARCHIVE_EOF) {
-		_alpm_log(handle, PM_LOG_DEBUG, "error parsing package descfile\n");
+		_alpm_log(handle, ALPM_LOG_DEBUG, "error parsing package descfile\n");
 		return -1;
 	}
 
@@ -244,47 +244,47 @@ 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 */
-	_alpm_log(handle, PM_LOG_DEBUG, "md5sum: %s\n", md5sum);
+	_alpm_log(handle, ALPM_LOG_DEBUG, "md5sum: %s\n", md5sum);
 	if(md5sum) {
-		_alpm_log(handle, PM_LOG_DEBUG, "checking md5sum for %s\n", 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);
 		}
 	}
 
-	_alpm_log(handle, PM_LOG_DEBUG, "base64_sig: %s\n", base64_sig);
+	_alpm_log(handle, ALPM_LOG_DEBUG, "base64_sig: %s\n", base64_sig);
 	if(check_sig != PM_PGP_VERIFY_NEVER) {
-		_alpm_log(handle, PM_LOG_DEBUG, "checking signature for %s\n", pkgfile);
+		_alpm_log(handle, ALPM_LOG_DEBUG, "checking signature for %s\n", pkgfile);
 		ret = _alpm_gpgme_checksig(handle, pkgfile, base64_sig);
 		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,10 +293,10 @@ 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, PM_LOG_DEBUG, "starting package load for %s\n", pkgfile);
+	_alpm_log(handle, ALPM_LOG_DEBUG, "starting package load for %s\n", pkgfile);
 
 	/* If full is false, only read through the archive until we find our needed
 	 * metadata. If it is true, read through the entire archive, which serves
@@ -307,16 +307,16 @@ alpm_pkg_t *_alpm_pkg_load_internal(alpm_handle_t *handle, const char *pkgfile,
 		if(strcmp(entry_name, ".PKGINFO") == 0) {
 			/* parse the info file */
 			if(parse_descfile(handle, archive, newpkg) != 0) {
-				_alpm_log(handle, PM_LOG_ERROR, _("could not parse package description file in %s\n"),
+				_alpm_log(handle, ALPM_LOG_ERROR, _("could not parse package description file in %s\n"),
 						pkgfile);
 				goto pkg_invalid;
 			}
 			if(newpkg->name == NULL || strlen(newpkg->name) == 0) {
-				_alpm_log(handle, PM_LOG_ERROR, _("missing package name in %s\n"), pkgfile);
+				_alpm_log(handle, ALPM_LOG_ERROR, _("missing package name in %s\n"), pkgfile);
 				goto pkg_invalid;
 			}
 			if(newpkg->version == NULL || strlen(newpkg->version) == 0) {
-				_alpm_log(handle, PM_LOG_ERROR, _("missing package version in %s\n"), pkgfile);
+				_alpm_log(handle, ALPM_LOG_ERROR, _("missing package version in %s\n"), pkgfile);
 				goto pkg_invalid;
 			}
 			config = 1;
@@ -338,9 +338,9 @@ alpm_pkg_t *_alpm_pkg_load_internal(alpm_handle_t *handle, const char *pkgfile,
 		}
 
 		if(archive_read_data_skip(archive)) {
-			_alpm_log(handle, PM_LOG_ERROR, _("error while reading package %s: %s\n"),
+			_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;
 		}
 
@@ -351,14 +351,14 @@ 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, PM_LOG_ERROR, _("error while reading package %s: %s\n"),
+		_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;
 	}
 
 	if(!config) {
-		_alpm_log(handle, PM_LOG_ERROR, _("missing package metadata in %s\n"), pkgfile);
+		_alpm_log(handle, ALPM_LOG_ERROR, _("missing package metadata in %s\n"), pkgfile);
 		goto pkg_invalid;
 	}
 
@@ -372,7 +372,7 @@ alpm_pkg_t *_alpm_pkg_load_internal(alpm_handle_t *handle, const char *pkgfile,
 
 	if(full) {
 		/* "checking for conflicts" requires a sorted list, ensure that here */
-		_alpm_log(handle, PM_LOG_DEBUG, "sorting package filelist for %s\n", pkgfile);
+		_alpm_log(handle, ALPM_LOG_DEBUG, "sorting package filelist for %s\n", pkgfile);
 		newpkg->files = alpm_list_msort(newpkg->files, files_count,
 				_alpm_files_cmp);
 		newpkg->infolevel = INFRQ_ALL;
@@ -387,7 +387,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);
@@ -399,7 +399,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 cf12ef7a..368accea 100644
--- a/lib/libalpm/be_sync.c
+++ b/lib/libalpm/be_sync.c
@@ -46,21 +46,21 @@ 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) {
-		_alpm_log(handle, PM_LOG_DEBUG, "database dir '%s' does not exist, creating it\n",
+		_alpm_log(handle, ALPM_LOG_DEBUG, "database dir '%s' does not exist, creating it\n",
 				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, PM_LOG_WARNING, _("removing invalid file: %s\n"), syncpath);
+		_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);
 		}
 	}
 
@@ -93,12 +93,12 @@ static int sync_db_validate(alpm_db_t *db)
 			return 0;
 		}
 
-		_alpm_log(db->handle, PM_LOG_DEBUG, "checking signature for %s\n",
+		_alpm_log(db->handle, ALPM_LOG_DEBUG, "checking signature for %s\n",
 				db->treename);
 		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);
@@ -218,7 +218,7 @@ int SYMEXPORT alpm_db_update(int force, alpm_db_t *db)
 		goto cleanup;
 	} else if(ret == -1) {
 		/* pm_errno was set by the download code */
-		_alpm_log(handle, PM_LOG_DEBUG, "failed to sync db: %s\n",
+		_alpm_log(handle, ALPM_LOG_DEBUG, "failed to sync db: %s\n",
 				alpm_strerror(handle->pm_errno));
 		goto cleanup;
 	}
@@ -235,7 +235,7 @@ int SYMEXPORT alpm_db_update(int force, alpm_db_t *db)
 cleanup:
 
 	if(_alpm_handle_unlock(handle)) {
-		_alpm_log(handle, PM_LOG_WARNING, _("could not remove lock file %s\n"),
+		_alpm_log(handle, ALPM_LOG_WARNING, _("could not remove lock file %s\n"),
 				alpm_option_get_lockfile(handle));
 	}
 	free(syncpath);
@@ -264,7 +264,7 @@ static alpm_pkg_t *load_pkg_for_entry(alpm_db_t *db, const char *entryname,
 		}
 	}
 	if(_alpm_splitname(entryname, &pkgname, &pkgver, &pkgname_hash) != 0) {
-		_alpm_log(db->handle, PM_LOG_ERROR,
+		_alpm_log(db->handle, ALPM_LOG_ERROR,
 				_("invalid name for database entry '%s'\n"), entryname);
 		return NULL;
 	}
@@ -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;
@@ -290,7 +290,7 @@ static alpm_pkg_t *load_pkg_for_entry(alpm_db_t *db, const char *entryname,
 		pkg->handle = db->handle;
 
 		/* add to the collection */
-		_alpm_log(db->handle, PM_LOG_FUNCTION, "adding '%s' to package cache for db '%s'\n",
+		_alpm_log(db->handle, ALPM_LOG_FUNCTION, "adding '%s' to package cache for db '%s'\n",
 				pkg->name, db->treename);
 		db->pkgcache = _alpm_pkghash_add(db->pkgcache, pkg);
 	} else {
@@ -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);
@@ -383,24 +383,24 @@ static int sync_db_populate(alpm_db_t *db)
 		return -1;
 	}
 
-	_alpm_log(db->handle, PM_LOG_DEBUG, "opening database archive %s\n", dbpath);
+	_alpm_log(db->handle, ALPM_LOG_DEBUG, "opening database archive %s\n", dbpath);
 
 	if(archive_read_open_filename(archive, dbpath,
 				ARCHIVE_DEFAULT_BYTES_PER_BLOCK) != ARCHIVE_OK) {
-		_alpm_log(db->handle, PM_LOG_ERROR, _("could not open file %s: %s\n"), dbpath,
+		_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) {
@@ -413,7 +413,7 @@ static int sync_db_populate(alpm_db_t *db)
 		} else {
 			/* we have desc, depends or deltas - parse it */
 			if(sync_db_read(db, archive, entry, &pkg) != 0) {
-				_alpm_log(db->handle, PM_LOG_ERROR,
+				_alpm_log(db->handle, ALPM_LOG_ERROR,
 						_("could not parse package description file '%s' from db '%s'\n"),
 						archive_entry_pathname(entry), db->treename);
 				continue;
@@ -427,7 +427,7 @@ static int sync_db_populate(alpm_db_t *db)
 		db->pkgcache->list = alpm_list_msort(db->pkgcache->list, (size_t)count, _alpm_pkg_cmp);
 	}
 	archive_read_finish(archive);
-	_alpm_log(db->handle, PM_LOG_DEBUG, "added %d packages to package cache for db '%s'\n",
+	_alpm_log(db->handle, ALPM_LOG_DEBUG, "added %d packages to package cache for db '%s'\n",
 			count, db->treename);
 
 	return count;
@@ -460,12 +460,12 @@ static int sync_db_read(alpm_db_t *db, struct archive *archive,
 
 	entryname = archive_entry_pathname(entry);
 	if(entryname == NULL) {
-		_alpm_log(db->handle, PM_LOG_DEBUG,
+		_alpm_log(db->handle, ALPM_LOG_DEBUG,
 				"invalid archive entry provided to _alpm_sync_db_read, skipping\n");
 		return -1;
 	}
 
-	_alpm_log(db->handle, PM_LOG_FUNCTION, "loading package data from archive entry %s\n",
+	_alpm_log(db->handle, ALPM_LOG_FUNCTION, "loading package data from archive entry %s\n",
 			entryname);
 
 	memset(&buf, 0, sizeof(buf));
@@ -475,7 +475,7 @@ static int sync_db_read(alpm_db_t *db, struct archive *archive,
 	pkg = load_pkg_for_entry(db, entryname, &filename, *likely_pkg);
 
 	if(pkg == NULL) {
-		_alpm_log(db->handle, PM_LOG_DEBUG,
+		_alpm_log(db->handle, ALPM_LOG_DEBUG,
 				"entry %s could not be loaded into %s sync database",
 				entryname, db->treename);
 		return -1;
@@ -490,13 +490,13 @@ static int sync_db_read(alpm_db_t *db, struct archive *archive,
 			if(strcmp(line, "%NAME%") == 0) {
 				READ_NEXT();
 				if(strcmp(line, pkg->name) != 0) {
-					_alpm_log(db->handle, PM_LOG_ERROR, _("%s database is inconsistent: name "
+					_alpm_log(db->handle, ALPM_LOG_ERROR, _("%s database is inconsistent: name "
 								"mismatch on package %s\n"), db->treename, pkg->name);
 				}
 			} else if(strcmp(line, "%VERSION%") == 0) {
 				READ_NEXT();
 				if(strcmp(line, pkg->version) != 0) {
-					_alpm_log(db->handle, PM_LOG_ERROR, _("%s database is inconsistent: version "
+					_alpm_log(db->handle, ALPM_LOG_ERROR, _("%s database is inconsistent: version "
 								"mismatch on package %s\n"), db->treename, pkg->name);
 				}
 			} else if(strcmp(line, "%FILENAME%") == 0) {
@@ -569,13 +569,13 @@ static int sync_db_read(alpm_db_t *db, struct archive *archive,
 		/* currently do nothing with this file */
 	} else {
 		/* unknown database file */
-		_alpm_log(db->handle, PM_LOG_DEBUG, "unknown database file: %s\n", filename);
+		_alpm_log(db->handle, ALPM_LOG_DEBUG, "unknown database file: %s\n", filename);
 	}
 
 	return 0;
 
 error:
-	_alpm_log(db->handle, PM_LOG_DEBUG, "error parsing database file: %s\n", filename);
+	_alpm_log(db->handle, ALPM_LOG_DEBUG, "error parsing database file: %s\n", filename);
 	return -1;
 }
 
@@ -590,11 +590,11 @@ alpm_db_t *_alpm_db_register_sync(alpm_handle_t *handle, const char *treename,
 {
 	alpm_db_t *db;
 
-	_alpm_log(handle, PM_LOG_DEBUG, "registering sync database '%s'\n", treename);
+	_alpm_log(handle, ALPM_LOG_DEBUG, "registering sync database '%s'\n", 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 3a6fb764..8cf16191 100644
--- a/lib/libalpm/conflict.c
+++ b/lib/libalpm/conflict.c
@@ -108,7 +108,7 @@ static int add_conflict(alpm_handle_t *handle, alpm_list_t **baddeps,
 	if(!conflict) {
 		return -1;
 	}
-	_alpm_log(handle, PM_LOG_DEBUG, "package %s conflicts with %s (by %s)\n",
+	_alpm_log(handle, ALPM_LOG_DEBUG, "package %s conflicts with %s (by %s)\n",
 			pkg1, pkg2, reason);
 	if(!conflict_isin(conflict, *baddeps)) {
 		*baddeps = alpm_list_add(*baddeps, conflict);
@@ -175,7 +175,7 @@ alpm_list_t *_alpm_innerconflicts(alpm_handle_t *handle, alpm_list_t *packages)
 {
 	alpm_list_t *baddeps = NULL;
 
-	_alpm_log(handle, PM_LOG_DEBUG, "check targets vs targets\n");
+	_alpm_log(handle, ALPM_LOG_DEBUG, "check targets vs targets\n");
 	check_conflict(handle, packages, packages, &baddeps, 0);
 
 	return baddeps;
@@ -197,9 +197,9 @@ alpm_list_t *_alpm_outerconflicts(alpm_db_t *db, alpm_list_t *packages)
 			packages, _alpm_pkg_cmp);
 
 	/* two checks to be done here for conflicts */
-	_alpm_log(db->handle, PM_LOG_DEBUG, "check targets vs db\n");
+	_alpm_log(db->handle, ALPM_LOG_DEBUG, "check targets vs db\n");
 	check_conflict(db->handle, packages, dblist, &baddeps, 1);
-	_alpm_log(db->handle, PM_LOG_DEBUG, "check db vs targets\n");
+	_alpm_log(db->handle, ALPM_LOG_DEBUG, "check db vs targets\n");
 	check_conflict(db->handle, dblist, packages, &baddeps, -1);
 
 	alpm_list_free(dblist);
@@ -281,7 +281,7 @@ static alpm_list_t *filelist_operation(alpm_list_t *filesA, alpm_list_t *filesB,
 }
 
 /* Adds alpm_fileconflict_t to a conflicts list. Pass the conflicts list, type
- * (either PM_FILECONFLICT_TARGET or PM_FILECONFLICT_FILESYSTEM), a file
+ * (either ALPM_FILECONFLICT_TARGET or ALPM_FILECONFLICT_FILESYSTEM), a file
  * string, and either two package names or one package name and NULL. This is
  * a wrapper for former functionality that was done inline.
  */
@@ -302,13 +302,13 @@ static alpm_list_t *add_fileconflict(alpm_handle_t *handle,
 	}
 
 	conflicts = alpm_list_add(conflicts, conflict);
-	_alpm_log(handle, PM_LOG_DEBUG, "found file conflict %s, packages %s and %s\n",
+	_alpm_log(handle, ALPM_LOG_DEBUG, "found file conflict %s, packages %s and %s\n",
 	          filestr, name1, name2 ? name2 : "(filesystem)");
 
 	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)
@@ -404,10 +404,10 @@ alpm_list_t *_alpm_db_find_fileconflicts(alpm_handle_t *handle,
 		alpm_pkg_t *dbpkg;
 
 		int percent = (current * 100) / numtargs;
-		PROGRESS(trans, PM_TRANS_PROGRESS_CONFLICTS_START, "", percent,
+		PROGRESS(trans, ALPM_TRANS_PROGRESS_CONFLICTS_START, "", percent,
 		         numtargs, current);
 		/* CHECK 1: check every target against every target */
-		_alpm_log(handle, PM_LOG_DEBUG, "searching for file conflicts: %s\n",
+		_alpm_log(handle, ALPM_LOG_DEBUG, "searching for file conflicts: %s\n",
 								alpm_pkg_get_name(p1));
 		for(j = i->next; j; j = j->next) {
 			alpm_list_t *common_files;
@@ -421,9 +421,9 @@ alpm_list_t *_alpm_db_find_fileconflicts(alpm_handle_t *handle,
 				for(k = common_files; k; k = k->next) {
 					snprintf(path, PATH_MAX, "%s%s", handle->root, (char *)k->data);
 					conflicts = add_fileconflict(handle, conflicts,
-							PM_FILECONFLICT_TARGET, path,
+							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;
@@ -434,7 +434,7 @@ alpm_list_t *_alpm_db_find_fileconflicts(alpm_handle_t *handle,
 		}
 
 		/* CHECK 2: check every target against the filesystem */
-		_alpm_log(handle, PM_LOG_DEBUG, "searching for filesystem conflicts: %s\n",
+		_alpm_log(handle, ALPM_LOG_DEBUG, "searching for filesystem conflicts: %s\n",
 				p1->name);
 		dbpkg = _alpm_db_get_pkgfromcache(handle->db_local, p1->name);
 
@@ -472,12 +472,12 @@ alpm_list_t *_alpm_db_find_fileconflicts(alpm_handle_t *handle,
 			if(S_ISDIR(file->mode)) {
 				struct stat sbuf;
 				if(S_ISDIR(lsbuf.st_mode)) {
-					_alpm_log(handle, PM_LOG_DEBUG, "%s is a directory, not a conflict\n", path);
+					_alpm_log(handle, ALPM_LOG_DEBUG, "%s is a directory, not a conflict\n", path);
 					continue;
 				}
 				stat(path, &sbuf);
 				if(S_ISLNK(lsbuf.st_mode) && S_ISDIR(sbuf.st_mode)) {
-					_alpm_log(handle, PM_LOG_DEBUG,
+					_alpm_log(handle, ALPM_LOG_DEBUG,
 							"%s is a symlink to a dir, hopefully not a conflict\n", path);
 					continue;
 				}
@@ -487,7 +487,7 @@ alpm_list_t *_alpm_db_find_fileconflicts(alpm_handle_t *handle,
 				path[strlen(path) - 1] = '\0';
 			}
 
-			_alpm_log(handle, PM_LOG_DEBUG, "checking possible conflict: %s\n", path);
+			_alpm_log(handle, ALPM_LOG_DEBUG, "checking possible conflict: %s\n", path);
 			relative_path = path + strlen(handle->root);
 
 			/* Check remove list (will we remove the conflicting local file?) */
@@ -495,7 +495,7 @@ alpm_list_t *_alpm_db_find_fileconflicts(alpm_handle_t *handle,
 				alpm_pkg_t *rempkg = k->data;
 				if(rempkg && _alpm_filelist_contains(alpm_pkg_get_files(rempkg),
 							relative_path)) {
-					_alpm_log(handle, PM_LOG_DEBUG,
+					_alpm_log(handle, ALPM_LOG_DEBUG,
 							"local file will be removed, not a conflict: %s\n", path);
 					resolved_conflict = 1;
 				}
@@ -516,7 +516,7 @@ alpm_list_t *_alpm_db_find_fileconflicts(alpm_handle_t *handle,
 					 * by its new owner (whether the file is in backup array or not */
 					handle->trans->skip_remove =
 						alpm_list_add(handle->trans->skip_remove, strdup(filestr));
-					_alpm_log(handle, PM_LOG_DEBUG,
+					_alpm_log(handle, ALPM_LOG_DEBUG,
 							"file changed packages, adding to remove skiplist: %s\n", path);
 					resolved_conflict = 1;
 				}
@@ -527,7 +527,7 @@ alpm_list_t *_alpm_db_find_fileconflicts(alpm_handle_t *handle,
 				char *dir = malloc(strlen(filestr) + 2);
 				sprintf(dir, "%s/", filestr);
 				if(_alpm_filelist_contains(alpm_pkg_get_files(dbpkg), dir)) {
-					_alpm_log(handle, PM_LOG_DEBUG,
+					_alpm_log(handle, ALPM_LOG_DEBUG,
 							"check if all files in %s belongs to %s\n",
 							dir, dbpkg->name);
 					resolved_conflict = dir_belongsto_pkg(handle->root, filestr, dbpkg);
@@ -551,8 +551,8 @@ alpm_list_t *_alpm_db_find_fileconflicts(alpm_handle_t *handle,
 
 			if(!resolved_conflict) {
 				conflicts = add_fileconflict(handle, conflicts,
-						PM_FILECONFLICT_FILESYSTEM, path, p1->name, NULL);
-				if(handle->pm_errno == PM_ERR_MEMORY) {
+						ALPM_FILECONFLICT_FILESYSTEM, path, p1->name, NULL);
+				if(handle->pm_errno == ALPM_ERR_MEMORY) {
 					FREELIST(conflicts);
 					if(dbpkg) {
 						/* only freed if it was generated from filelist_operation() */
@@ -567,7 +567,7 @@ alpm_list_t *_alpm_db_find_fileconflicts(alpm_handle_t *handle,
 			alpm_list_free(tmpfiles);
 		}
 	}
-	PROGRESS(trans, PM_TRANS_PROGRESS_CONFLICTS_START, "", 100,
+	PROGRESS(trans, ALPM_TRANS_PROGRESS_CONFLICTS_START, "", 100,
 			numtargs, current);
 
 	return conflicts;
diff --git a/lib/libalpm/db.c b/lib/libalpm/db.c
index 6c1b95c0..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);
 }
@@ -65,7 +65,7 @@ void _alpm_db_unregister(alpm_db_t *db)
 		return;
 	}
 
-	_alpm_log(db->handle, PM_LOG_DEBUG, "unregistering database '%s'\n", db->treename);
+	_alpm_log(db->handle, ALPM_LOG_DEBUG, "unregistering database '%s'\n", db->treename);
 	_alpm_db_free(db);
 }
 
@@ -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,14 +168,14 @@ 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) {
 		return -1;
 	}
 	db->servers = alpm_list_add(db->servers, newurl);
-	_alpm_log(db->handle, PM_LOG_DEBUG, "adding new server URL to database '%s': %s\n",
+	_alpm_log(db->handle, ALPM_LOG_DEBUG, "adding new server URL to database '%s': %s\n",
 			db->treename, newurl);
 
 	return 0;
@@ -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) {
@@ -203,7 +203,7 @@ int SYMEXPORT alpm_db_remove_server(alpm_db_t *db, const char *url)
 	db->servers = alpm_list_remove_str(db->servers, newurl, &vdata);
 	free(newurl);
 	if(vdata) {
-		_alpm_log(db->handle, PM_LOG_DEBUG, "removed server URL from database '%s': %s\n",
+		_alpm_log(db->handle, ALPM_LOG_DEBUG, "removed server URL from database '%s': %s\n",
 				db->treename, newurl);
 		free(vdata);
 		return 0;
@@ -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,14 +292,14 @@ 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, PM_LOG_DEBUG, "setting install reason %u for %s/%s\n", reason, db->treename, name);
+	_alpm_log(db->handle, ALPM_LOG_DEBUG, "setting install reason %u for %s/%s\n", reason, db->treename, name);
 	if(alpm_pkg_get_reason(pkg) == reason) {
 		/* we are done */
 		return 0;
@@ -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;
@@ -352,21 +352,21 @@ const char *_alpm_db_path(alpm_db_t *db)
 
 		dbpath = alpm_option_get_dbpath(db->handle);
 		if(!dbpath) {
-			_alpm_log(db->handle, PM_LOG_ERROR, _("database path is undefined\n"));
-			RET_ERR(db->handle, PM_ERR_DB_OPEN, NULL);
+			_alpm_log(db->handle, ALPM_LOG_ERROR, _("database path is undefined\n"));
+			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);
 		}
-		_alpm_log(db->handle, PM_LOG_DEBUG, "database path for tree %s set to %s\n",
+		_alpm_log(db->handle, ALPM_LOG_DEBUG, "database path for tree %s set to %s\n",
 				db->treename, db->_path);
 	}
 	return db->_path;
@@ -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;
 }
@@ -409,10 +409,10 @@ alpm_list_t *_alpm_db_search(alpm_db_t *db, const alpm_list_t *needles)
 		}
 		ret = NULL;
 		targ = i->data;
-		_alpm_log(db->handle, PM_LOG_DEBUG, "searching for target '%s'\n", targ);
+		_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) {
@@ -451,7 +451,7 @@ alpm_list_t *_alpm_db_search(alpm_db_t *db, const alpm_list_t *needles)
 			}
 
 			if(matched != NULL) {
-				_alpm_log(db->handle, PM_LOG_DEBUG, "    search target '%s' matched '%s'\n",
+				_alpm_log(db->handle, ALPM_LOG_DEBUG, "    search target '%s' matched '%s'\n",
 				          targ, matched);
 				ret = alpm_list_add(ret, pkg);
 			}
@@ -474,10 +474,10 @@ static int load_pkgcache(alpm_db_t *db)
 {
 	_alpm_db_free_pkgcache(db);
 
-	_alpm_log(db->handle, PM_LOG_DEBUG, "loading package cache for repository '%s'\n",
+	_alpm_log(db->handle, ALPM_LOG_DEBUG, "loading package cache for repository '%s'\n",
 			db->treename);
 	if(db->ops->populate(db) == -1) {
-		_alpm_log(db->handle, PM_LOG_DEBUG,
+		_alpm_log(db->handle, ALPM_LOG_DEBUG,
 				"failed to load package cache for repository '%s'\n", db->treename);
 		return -1;
 	}
@@ -492,7 +492,7 @@ void _alpm_db_free_pkgcache(alpm_db_t *db)
 		return;
 	}
 
-	_alpm_log(db->handle, PM_LOG_DEBUG,
+	_alpm_log(db->handle, ALPM_LOG_DEBUG,
 			"freeing package cache for repository '%s'\n", db->treename);
 
 	alpm_list_free_inner(_alpm_db_get_pkgcache(db),
@@ -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)) {
@@ -545,7 +545,7 @@ int _alpm_db_add_pkgincache(alpm_db_t *db, alpm_pkg_t *pkg)
 		return -1;
 	}
 
-	_alpm_log(db->handle, PM_LOG_DEBUG, "adding entry '%s' in '%s' cache\n",
+	_alpm_log(db->handle, ALPM_LOG_DEBUG, "adding entry '%s' in '%s' cache\n",
 						alpm_pkg_get_name(newpkg), db->treename);
 	db->pkgcache = _alpm_pkghash_add_sorted(db->pkgcache, newpkg);
 
@@ -562,13 +562,13 @@ int _alpm_db_remove_pkgfromcache(alpm_db_t *db, alpm_pkg_t *pkg)
 		return -1;
 	}
 
-	_alpm_log(db->handle, PM_LOG_DEBUG, "removing entry '%s' from '%s' cache\n",
+	_alpm_log(db->handle, ALPM_LOG_DEBUG, "removing entry '%s' from '%s' cache\n",
 						alpm_pkg_get_name(pkg), db->treename);
 
 	db->pkgcache = _alpm_pkghash_remove(db->pkgcache, pkg, &data);
 	if(data == NULL) {
 		/* package not found */
-		_alpm_log(db->handle, PM_LOG_DEBUG, "cannot remove entry '%s' from '%s' cache: not found\n",
+		_alpm_log(db->handle, ALPM_LOG_DEBUG, "cannot remove entry '%s' from '%s' cache: not found\n",
 							alpm_pkg_get_name(pkg), db->treename);
 		return -1;
 	}
@@ -604,7 +604,7 @@ static int load_grpcache(alpm_db_t *db)
 		return -1;
 	}
 
-	_alpm_log(db->handle, PM_LOG_DEBUG, "loading group cache for repository '%s'\n",
+	_alpm_log(db->handle, ALPM_LOG_DEBUG, "loading group cache for repository '%s'\n",
 			db->treename);
 
 	for(lp = _alpm_db_get_pkgcache(db); lp; lp = lp->next) {
@@ -654,7 +654,7 @@ void _alpm_db_free_groupcache(alpm_db_t *db)
 		return;
 	}
 
-	_alpm_log(db->handle, PM_LOG_DEBUG,
+	_alpm_log(db->handle, ALPM_LOG_DEBUG,
 			"freeing group cache for repository '%s'\n", db->treename);
 
 	for(lg = db->grpcache; lg; lg = lg->next) {
@@ -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/delta.c b/lib/libalpm/delta.c
index d2c2fe80..1b7e3eec 100644
--- a/lib/libalpm/delta.c
+++ b/lib/libalpm/delta.c
@@ -198,14 +198,14 @@ off_t _alpm_shortest_delta_path(alpm_handle_t *handle, alpm_list_t *deltas,
 		return bestsize;
 	}
 
-	_alpm_log(handle, PM_LOG_DEBUG, "started delta shortest-path search for '%s'\n", to);
+	_alpm_log(handle, ALPM_LOG_DEBUG, "started delta shortest-path search for '%s'\n", to);
 
 	vertices = graph_init(deltas, 0);
 	graph_init_size(handle, vertices);
 	dijkstra(vertices);
 	bestsize = shortest_path(vertices, to, &bestpath);
 
-	_alpm_log(handle, PM_LOG_DEBUG, "delta shortest-path search complete : '%jd'\n", (intmax_t)bestsize);
+	_alpm_log(handle, ALPM_LOG_DEBUG, "delta shortest-path search complete : '%jd'\n", (intmax_t)bestsize);
 
 	alpm_list_free_inner(vertices, _alpm_graph_free);
 	alpm_list_free(vertices);
diff --git a/lib/libalpm/deps.c b/lib/libalpm/deps.c
index 34f74a57..c3681b34 100644
--- a/lib/libalpm/deps.c
+++ b/lib/libalpm/deps.c
@@ -138,7 +138,7 @@ alpm_list_t *_alpm_sortbydeps(alpm_handle_t *handle,
 		return NULL;
 	}
 
-	_alpm_log(handle, PM_LOG_DEBUG, "started sorting dependencies\n");
+	_alpm_log(handle, ALPM_LOG_DEBUG, "started sorting dependencies\n");
 
 	vertices = dep_graph_init(targets);
 
@@ -161,13 +161,13 @@ alpm_list_t *_alpm_sortbydeps(alpm_handle_t *handle,
 				alpm_pkg_t *childpkg = nextchild->data;
 				const char *message;
 
-				_alpm_log(handle, PM_LOG_WARNING, _("dependency cycle detected:\n"));
+				_alpm_log(handle, ALPM_LOG_WARNING, _("dependency cycle detected:\n"));
 				if(reverse) {
 					message =_("%s will be removed after its %s dependency\n");
 				} else {
 					message =_("%s will be installed before its %s dependency\n");
 				}
-				_alpm_log(handle, PM_LOG_WARNING, message, vertexpkg->name, childpkg->name);
+				_alpm_log(handle, ALPM_LOG_WARNING, message, vertexpkg->name, childpkg->name);
 			}
 		}
 		if(!found) {
@@ -186,7 +186,7 @@ alpm_list_t *_alpm_sortbydeps(alpm_handle_t *handle,
 		}
 	}
 
-	_alpm_log(handle, PM_LOG_DEBUG, "sorting dependencies finished\n");
+	_alpm_log(handle, ALPM_LOG_DEBUG, "sorting dependencies finished\n");
 
 	if(reverse) {
 		/* reverse the order */
@@ -205,7 +205,7 @@ alpm_list_t *_alpm_sortbydeps(alpm_handle_t *handle,
 static int no_dep_version(alpm_handle_t *handle)
 {
 	int flags = alpm_trans_get_flags(handle);
-	return flags != -1 && (flags & PM_TRANS_FLAG_NODEPVERSION);
+	return flags != -1 && (flags & ALPM_TRANS_FLAG_NODEPVERSION);
 }
 
 static alpm_depend_t *filtered_depend(alpm_depend_t *dep, int nodepversion)
@@ -213,7 +213,7 @@ static alpm_depend_t *filtered_depend(alpm_depend_t *dep, int nodepversion)
 	if(nodepversion) {
 		alpm_depend_t *newdep = _alpm_dep_dup(dep);
 		ASSERT(newdep, return dep);
-		newdep->mod = PM_DEP_MOD_ANY;
+		newdep->mod = ALPM_DEP_MOD_ANY;
 		dep = newdep;
 	}
 	return dep;
@@ -289,7 +289,7 @@ alpm_list_t SYMEXPORT *alpm_checkdeps(alpm_handle_t *handle, alpm_list_t *pkglis
 	/* look for unsatisfied dependencies of the upgrade list */
 	for(i = upgrade; i; i = i->next) {
 		alpm_pkg_t *tp = i->data;
-		_alpm_log(handle, PM_LOG_DEBUG, "checkdeps: package %s-%s\n",
+		_alpm_log(handle, ALPM_LOG_DEBUG, "checkdeps: package %s-%s\n",
 				alpm_pkg_get_name(tp), alpm_pkg_get_version(tp));
 
 		for(j = alpm_pkg_get_depends(tp); j; j = j->next) {
@@ -302,7 +302,7 @@ alpm_list_t SYMEXPORT *alpm_checkdeps(alpm_handle_t *handle, alpm_list_t *pkglis
 				/* Unsatisfied dependency in the upgrade list */
 				alpm_depmissing_t *miss;
 				char *missdepstring = alpm_dep_compute_string(depend);
-				_alpm_log(handle, PM_LOG_DEBUG, "checkdeps: missing dependency '%s' for package '%s'\n",
+				_alpm_log(handle, ALPM_LOG_DEBUG, "checkdeps: missing dependency '%s' for package '%s'\n",
 						missdepstring, alpm_pkg_get_name(tp));
 				free(missdepstring);
 				miss = depmiss_new(alpm_pkg_get_name(tp), depend, NULL);
@@ -329,7 +329,7 @@ alpm_list_t SYMEXPORT *alpm_checkdeps(alpm_handle_t *handle, alpm_list_t *pkglis
 				   !find_dep_satisfier(dblist, depend)) {
 					alpm_depmissing_t *miss;
 					char *missdepstring = alpm_dep_compute_string(depend);
-					_alpm_log(handle, PM_LOG_DEBUG, "checkdeps: transaction would break '%s' dependency of '%s'\n",
+					_alpm_log(handle, ALPM_LOG_DEBUG, "checkdeps: transaction would break '%s' dependency of '%s'\n",
 							missdepstring, alpm_pkg_get_name(lp));
 					free(missdepstring);
 					miss = depmiss_new(lp->name, depend, alpm_pkg_get_name(causingpkg));
@@ -351,16 +351,16 @@ static int dep_vercmp(const char *version1, alpm_depmod_t mod,
 {
 	int equal = 0;
 
-	if(mod == PM_DEP_MOD_ANY) {
+	if(mod == ALPM_DEP_MOD_ANY) {
 		equal = 1;
 	} else {
 		int cmp = alpm_pkg_vercmp(version1, version2);
 		switch(mod) {
-			case PM_DEP_MOD_EQ: equal = (cmp == 0); break;
-			case PM_DEP_MOD_GE: equal = (cmp >= 0); break;
-			case PM_DEP_MOD_LE: equal = (cmp <= 0); break;
-			case PM_DEP_MOD_LT: equal = (cmp < 0); break;
-			case PM_DEP_MOD_GT: equal = (cmp > 0); break;
+			case ALPM_DEP_MOD_EQ: equal = (cmp == 0); break;
+			case ALPM_DEP_MOD_GE: equal = (cmp >= 0); break;
+			case ALPM_DEP_MOD_LE: equal = (cmp <= 0); break;
+			case ALPM_DEP_MOD_LT: equal = (cmp < 0); break;
+			case ALPM_DEP_MOD_GT: equal = (cmp > 0); break;
 			default: equal = 1; break;
 		}
 	}
@@ -390,7 +390,7 @@ int _alpm_depcmp(alpm_pkg_t *pkg, alpm_depend_t *dep)
 		const char *provver = strchr(provision, '=');
 
 		if(provver == NULL) { /* no provision version */
-			satisfy = (dep->mod == PM_DEP_MOD_ANY
+			satisfy = (dep->mod == ALPM_DEP_MOD_ANY
 					&& strcmp(provision, dep->name) == 0);
 		} else {
 			/* This is a bit tricker than the old code for performance reasons. To
@@ -423,24 +423,24 @@ alpm_depend_t *_alpm_splitdep(const char *depstring)
 	/* Find a version comparator if one exists. If it does, set the type and
 	 * increment the ptr accordingly so we can copy the right strings. */
 	if((ptr = strstr(depstring, ">="))) {
-		depend->mod = PM_DEP_MOD_GE;
+		depend->mod = ALPM_DEP_MOD_GE;
 		version = ptr + 2;
 	} else if((ptr = strstr(depstring, "<="))) {
-		depend->mod = PM_DEP_MOD_LE;
+		depend->mod = ALPM_DEP_MOD_LE;
 		version = ptr + 2;
 	} else if((ptr = strstr(depstring, "="))) {
 		/* Note: we must do =,<,> checks after <=, >= checks */
-		depend->mod = PM_DEP_MOD_EQ;
+		depend->mod = ALPM_DEP_MOD_EQ;
 		version = ptr + 1;
 	} else if((ptr = strstr(depstring, "<"))) {
-		depend->mod = PM_DEP_MOD_LT;
+		depend->mod = ALPM_DEP_MOD_LT;
 		version = ptr + 1;
 	} else if((ptr = strstr(depstring, ">"))) {
-		depend->mod = PM_DEP_MOD_GT;
+		depend->mod = ALPM_DEP_MOD_GT;
 		version = ptr + 1;
 	} else {
 		/* no version specified, leave version and ptr NULL */
-		depend->mod = PM_DEP_MOD_ANY;
+		depend->mod = ALPM_DEP_MOD_ANY;
 	}
 
 	/* copy the right parts to the right places */
@@ -481,8 +481,8 @@ static int can_remove_package(alpm_db_t *db, alpm_pkg_t *pkg, alpm_list_t *targe
 
 	if(!include_explicit) {
 		/* see if it was explicitly installed */
-		if(alpm_pkg_get_reason(pkg) == PM_PKG_REASON_EXPLICIT) {
-			_alpm_log(db->handle, PM_LOG_DEBUG, "excluding %s -- explicitly installed\n",
+		if(alpm_pkg_get_reason(pkg) == ALPM_PKG_REASON_EXPLICIT) {
+			_alpm_log(db->handle, ALPM_LOG_DEBUG, "excluding %s -- explicitly installed\n",
 					alpm_pkg_get_name(pkg));
 			return 0;
 		}
@@ -530,7 +530,7 @@ void _alpm_recursedeps(alpm_db_t *db, alpm_list_t *targs, int include_explicit)
 			alpm_pkg_t *deppkg = j->data;
 			if(_alpm_dep_edge(pkg, deppkg)
 					&& can_remove_package(db, deppkg, targs, include_explicit)) {
-				_alpm_log(db->handle, PM_LOG_DEBUG, "adding '%s' to the targets\n",
+				_alpm_log(db->handle, ALPM_LOG_DEBUG, "adding '%s' to the targets\n",
 						alpm_pkg_get_name(deppkg));
 				/* add it to the target list */
 				targs = alpm_list_add(targs, _alpm_pkg_dup(deppkg));
@@ -568,10 +568,10 @@ static alpm_pkg_t *resolvedep(alpm_handle_t *handle, alpm_depend_t *dep,
 			if(_alpm_pkg_should_ignore(handle, pkg)) {
 				int install = 0;
 				if(prompt) {
-					QUESTION(handle->trans, PM_TRANS_CONV_INSTALL_IGNOREPKG, pkg,
+					QUESTION(handle->trans, ALPM_TRANS_CONV_INSTALL_IGNOREPKG, pkg,
 							 NULL, NULL, &install);
 				} else {
-					_alpm_log(handle, PM_LOG_WARNING, _("ignoring package %s-%s\n"), pkg->name, pkg->version);
+					_alpm_log(handle, ALPM_LOG_WARNING, _("ignoring package %s-%s\n"), pkg->name, pkg->version);
 				}
 				if(!install) {
 					ignored = 1;
@@ -590,17 +590,17 @@ static alpm_pkg_t *resolvedep(alpm_handle_t *handle, alpm_depend_t *dep,
 				if(_alpm_pkg_should_ignore(handle, pkg)) {
 					int install = 0;
 					if(prompt) {
-						QUESTION(handle->trans, PM_TRANS_CONV_INSTALL_IGNOREPKG,
+						QUESTION(handle->trans, ALPM_TRANS_CONV_INSTALL_IGNOREPKG,
 									pkg, NULL, NULL, &install);
 					} else {
-						_alpm_log(handle, PM_LOG_WARNING, _("ignoring package %s-%s\n"), pkg->name, pkg->version);
+						_alpm_log(handle, ALPM_LOG_WARNING, _("ignoring package %s-%s\n"), pkg->name, pkg->version);
 					}
 					if(!install) {
 						ignored = 1;
 						continue;
 					}
 				}
-				_alpm_log(handle, PM_LOG_DEBUG, "provider found (%s provides %s)\n",
+				_alpm_log(handle, ALPM_LOG_DEBUG, "provider found (%s provides %s)\n",
 						pkg->name, dep->name);
 				providers = alpm_list_add(providers, pkg);
 				/* keep looking for other providers in the all dbs */
@@ -622,7 +622,7 @@ static alpm_pkg_t *resolvedep(alpm_handle_t *handle, alpm_depend_t *dep,
 		int index = 0;
 		if(count > 1) {
 			/* if there is more than one provider, we ask the user */
-			QUESTION(handle->trans, PM_TRANS_CONV_SELECT_PROVIDER,
+			QUESTION(handle->trans, ALPM_TRANS_CONV_SELECT_PROVIDER,
 					providers, dep, NULL, &index);
 		}
 		if(index >= 0 && index < count) {
@@ -635,9 +635,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;
 }
@@ -658,7 +658,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);
@@ -708,7 +708,7 @@ int _alpm_resolvedeps(alpm_handle_t *handle, alpm_list_t *localpkgs, alpm_pkg_t
 	   on that list */
 	*packages = alpm_list_add(*packages, pkg);
 
-	_alpm_log(handle, PM_LOG_DEBUG, "started resolving dependencies\n");
+	_alpm_log(handle, ALPM_LOG_DEBUG, "started resolving dependencies\n");
 	for(i = alpm_list_last(*packages); i; i = i->next) {
 		alpm_pkg_t *tpkg = i->data;
 		targ = alpm_list_add(NULL, tpkg);
@@ -732,9 +732,9 @@ 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, PM_LOG_WARNING,
+				_alpm_log(handle, ALPM_LOG_WARNING,
 						_("cannot resolve \"%s\", a dependency of \"%s\"\n"),
 						missdepstring, tpkg->name);
 				free(missdepstring);
@@ -743,7 +743,7 @@ int _alpm_resolvedeps(alpm_handle_t *handle, alpm_list_t *localpkgs, alpm_pkg_t
 				}
 				ret = -1;
 			} else {
-				_alpm_log(handle, PM_LOG_DEBUG, "pulling dependency %s (needed by %s)\n",
+				_alpm_log(handle, ALPM_LOG_DEBUG, "pulling dependency %s (needed by %s)\n",
 						alpm_pkg_get_name(spkg), alpm_pkg_get_name(tpkg));
 				*packages = alpm_list_add(*packages, spkg);
 				_alpm_depmiss_free(miss);
@@ -758,7 +758,7 @@ int _alpm_resolvedeps(alpm_handle_t *handle, alpm_list_t *localpkgs, alpm_pkg_t
 	} else {
 		alpm_list_free(packages_copy);
 	}
-	_alpm_log(handle, PM_LOG_DEBUG, "finished resolving dependencies\n");
+	_alpm_log(handle, ALPM_LOG_DEBUG, "finished resolving dependencies\n");
 	return ret;
 }
 
@@ -782,22 +782,22 @@ char SYMEXPORT *alpm_dep_compute_string(const alpm_depend_t *dep)
 	}
 
 	switch(dep->mod) {
-		case PM_DEP_MOD_ANY:
+		case ALPM_DEP_MOD_ANY:
 			opr = "";
 			break;
-		case PM_DEP_MOD_GE:
+		case ALPM_DEP_MOD_GE:
 			opr = ">=";
 			break;
-		case PM_DEP_MOD_LE:
+		case ALPM_DEP_MOD_LE:
 			opr = "<=";
 			break;
-		case PM_DEP_MOD_EQ:
+		case ALPM_DEP_MOD_EQ:
 			opr = "=";
 			break;
-		case PM_DEP_MOD_LT:
+		case ALPM_DEP_MOD_LT:
 			opr = "<";
 			break;
-		case PM_DEP_MOD_GT:
+		case ALPM_DEP_MOD_GT:
 			opr = ">";
 			break;
 		default:
@@ -805,14 +805,14 @@ char SYMEXPORT *alpm_dep_compute_string(const alpm_depend_t *dep)
 			break;
 	}
 
-	if(dep->mod != PM_DEP_MOD_ANY && dep->version) {
+	if(dep->mod != ALPM_DEP_MOD_ANY && dep->version) {
 		ver = dep->version;
 	} else {
 		ver = "";
 	}
 
 	/* we can always compute len and print the string like this because opr
-	 * and ver will be empty when PM_DEP_MOD_ANY is the depend type. the
+	 * and ver will be empty when ALPM_DEP_MOD_ANY is the depend type. the
 	 * reassignments above also ensure we do not do a strlen(NULL). */
 	len = strlen(name) + strlen(opr) + strlen(ver) + 1;
 	MALLOC(str, len, return NULL);
diff --git a/lib/libalpm/diskspace.c b/lib/libalpm/diskspace.c
index b5d2ed22..3ab62a86 100644
--- a/lib/libalpm/diskspace.c
+++ b/lib/libalpm/diskspace.c
@@ -73,17 +73,17 @@ static alpm_list_t *mount_point_list(alpm_handle_t *handle)
 
 	while((mnt = getmntent(fp))) {
 		if(!mnt) {
-			_alpm_log(handle, PM_LOG_WARNING, _("could not get filesystem information\n"));
+			_alpm_log(handle, ALPM_LOG_WARNING, _("could not get filesystem information\n"));
 			continue;
 		}
 		if(statvfs(mnt->mnt_dir, &fsp) != 0) {
-			_alpm_log(handle, PM_LOG_WARNING,
+			_alpm_log(handle, ALPM_LOG_WARNING,
 					_("could not get filesystem information for %s: %s\n"),
 					mnt->mnt_dir, strerror(errno));
 			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));
@@ -104,7 +104,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));
@@ -122,7 +122,7 @@ static alpm_list_t *mount_point_list(alpm_handle_t *handle)
 			mount_point_cmp);
 	for(ptr = mount_points; ptr != NULL; ptr = ptr->next) {
 		mp = ptr->data;
-		_alpm_log(handle, PM_LOG_DEBUG, "mountpoint: %s\n", mp->mount_dir);
+		_alpm_log(handle, ALPM_LOG_DEBUG, "mountpoint: %s\n", mp->mount_dir);
 	}
 	return mount_points;
 }
@@ -168,7 +168,7 @@ static int calculate_removed_size(alpm_handle_t *handle,
 
 		mp = match_mount_point(mount_points, path);
 		if(mp == NULL) {
-			_alpm_log(handle, PM_LOG_WARNING,
+			_alpm_log(handle, ALPM_LOG_WARNING,
 					_("could not determine mount point for file %s\n"), filename);
 			continue;
 		}
@@ -210,7 +210,7 @@ static int calculate_installed_size(alpm_handle_t *handle,
 
 		mp = match_mount_point(mount_points, path);
 		if(mp == NULL) {
-			_alpm_log(handle, PM_LOG_WARNING,
+			_alpm_log(handle, ALPM_LOG_WARNING,
 					_("could not determine mount point for file %s\n"), filename);
 			continue;
 		}
@@ -236,12 +236,12 @@ int _alpm_check_diskspace(alpm_handle_t *handle)
 	numtargs = alpm_list_count(trans->add);
 	mount_points = mount_point_list(handle);
 	if(mount_points == NULL) {
-		_alpm_log(handle, PM_LOG_ERROR, _("could not determine filesystem mount points\n"));
+		_alpm_log(handle, ALPM_LOG_ERROR, _("could not determine filesystem mount points\n"));
 		return -1;
 	}
 	root_mp = match_mount_point(mount_points, handle->root);
 	if(root_mp == NULL) {
-		_alpm_log(handle, PM_LOG_ERROR, _("could not determine root mount point %s\n"),
+		_alpm_log(handle, ALPM_LOG_ERROR, _("could not determine root mount point %s\n"),
 				handle->root);
 		return -1;
 	}
@@ -252,7 +252,7 @@ int _alpm_check_diskspace(alpm_handle_t *handle)
 		for(targ = trans->remove; targ; targ = targ->next, current++) {
 			alpm_pkg_t *local_pkg;
 			int percent = (current * 100) / numtargs;
-			PROGRESS(trans, PM_TRANS_PROGRESS_DISKSPACE_START, "", percent,
+			PROGRESS(trans, ALPM_TRANS_PROGRESS_DISKSPACE_START, "", percent,
 					numtargs, current);
 
 			local_pkg = targ->data;
@@ -263,7 +263,7 @@ int _alpm_check_diskspace(alpm_handle_t *handle)
 	for(targ = trans->add; targ; targ = targ->next, current++) {
 		alpm_pkg_t *pkg, *local_pkg;
 		int percent = (current * 100) / numtargs;
-		PROGRESS(trans, PM_TRANS_PROGRESS_DISKSPACE_START, "", percent,
+		PROGRESS(trans, ALPM_TRANS_PROGRESS_DISKSPACE_START, "", percent,
 				numtargs, current);
 
 		pkg = targ->data;
@@ -282,13 +282,13 @@ int _alpm_check_diskspace(alpm_handle_t *handle)
 		}
 	}
 
-	PROGRESS(trans, PM_TRANS_PROGRESS_DISKSPACE_START, "", 100,
+	PROGRESS(trans, ALPM_TRANS_PROGRESS_DISKSPACE_START, "", 100,
 			numtargs, current);
 
 	for(i = mount_points; i; i = alpm_list_next(i)) {
 		alpm_mountpoint_t *data = i->data;
 		if(data->used && data->read_only) {
-			_alpm_log(handle, PM_LOG_ERROR, _("Partition %s is mounted read only\n"),
+			_alpm_log(handle, ALPM_LOG_ERROR, _("Partition %s is mounted read only\n"),
 					data->mount_dir);
 			error = 1;
 		} else if(data->used & USED_INSTALL) {
@@ -297,12 +297,12 @@ int _alpm_check_diskspace(alpm_handle_t *handle)
 			long twentymb = (20 * 1024 * 1024 / (long)data->fsp.f_bsize) + 1;
 			long cushion = fivepc < twentymb ? fivepc : twentymb;
 
-			_alpm_log(handle, PM_LOG_DEBUG, "partition %s, needed %ld, cushion %ld, free %ld\n",
+			_alpm_log(handle, ALPM_LOG_DEBUG, "partition %s, needed %ld, cushion %ld, free %ld\n",
 					data->mount_dir, data->max_blocks_needed, cushion,
 					(unsigned long)data->fsp.f_bfree);
 			if(data->max_blocks_needed + cushion >= 0 &&
 			   (unsigned long)(data->max_blocks_needed + cushion) > data->fsp.f_bfree) {
-				_alpm_log(handle, PM_LOG_ERROR, _("Partition %s too full: %ld blocks needed, %ld blocks free\n"),
+				_alpm_log(handle, ALPM_LOG_ERROR, _("Partition %s too full: %ld blocks needed, %ld blocks free\n"),
 						data->mount_dir, data->max_blocks_needed + cushion,
 						(unsigned long)data->fsp.f_bfree);
 				error = 1;
@@ -317,7 +317,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 9042544d..c7a1c2b2 100644
--- a/lib/libalpm/dload.c
+++ b/lib/libalpm/dload.c
@@ -171,8 +171,8 @@ static int curl_download_internal(alpm_handle_t *handle,
 	dlfile.initial_size = 0.0;
 	dlfile.filename = get_filename(url);
 	if(!dlfile.filename || curl_gethost(url, hostname) != 0) {
-		_alpm_log(handle, PM_LOG_ERROR, _("url '%s' is invalid\n"), url);
-		RET_ERR(handle, PM_ERR_SERVER_BAD_URL, -1);
+		_alpm_log(handle, ALPM_LOG_ERROR, _("url '%s' is invalid\n"), url);
+		RET_ERR(handle, ALPM_ERR_SERVER_BAD_URL, -1);
 	}
 
 	destfile = get_fullpath(localpath, dlfile.filename, "");
@@ -211,7 +211,7 @@ static int curl_download_internal(alpm_handle_t *handle,
 		/* a previous partial download exists, resume from end of file. */
 		open_mode = "ab";
 		curl_easy_setopt(handle->curl, CURLOPT_RESUME_FROM, (long)st.st_size);
-		_alpm_log(handle, PM_LOG_DEBUG, "tempfile found, attempting continuation\n");
+		_alpm_log(handle, ALPM_LOG_DEBUG, "tempfile found, attempting continuation\n");
 		dlfile.initial_size = (double)st.st_size;
 	}
 
@@ -248,11 +248,11 @@ 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;
-			_alpm_log(handle, PM_LOG_ERROR, _("failed retrieving file '%s' from %s : %s\n"),
+			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 {
-			_alpm_log(handle, PM_LOG_DEBUG, "failed retrieving file '%s' from %s : %s\n",
+			_alpm_log(handle, ALPM_LOG_DEBUG, "failed retrieving file '%s' from %s : %s\n",
 					dlfile.filename, hostname, error_buffer);
 		}
 		unlink(tempfile);
@@ -278,8 +278,8 @@ 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;
-		_alpm_log(handle, PM_LOG_ERROR, _("%s appears to be truncated: %jd/%jd bytes\n"),
+		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;
 	}
@@ -357,10 +357,10 @@ char SYMEXPORT *alpm_fetch_pkgurl(alpm_handle_t *handle, const char *url)
 	/* download the file */
 	ret = _alpm_download(handle, url, cachedir, 0, 1, 0);
 	if(ret == -1) {
-		_alpm_log(handle, PM_LOG_WARNING, _("failed to download %s\n"), url);
+		_alpm_log(handle, ALPM_LOG_WARNING, _("failed to download %s\n"), url);
 		return NULL;
 	}
-	_alpm_log(handle, PM_LOG_DEBUG, "successfully downloaded %s\n", url);
+	_alpm_log(handle, ALPM_LOG_DEBUG, "successfully downloaded %s\n", url);
 
 	/* attempt to download the signature */
 	if(ret == 0 && (handle->sigverify == PM_PGP_VERIFY_ALWAYS ||
@@ -370,16 +370,16 @@ 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);
 		if(ret == -1 && !errors_ok) {
-			_alpm_log(handle, PM_LOG_WARNING, _("failed to download %s\n"), sig_url);
+			_alpm_log(handle, ALPM_LOG_WARNING, _("failed to download %s\n"), sig_url);
 			/* Warn now, but don't return NULL. We will fail later during package
 			 * load time. */
 		} else if(ret == 0) {
-			_alpm_log(handle, PM_LOG_DEBUG, "successfully downloaded %s\n", sig_url);
+			_alpm_log(handle, ALPM_LOG_DEBUG, "successfully downloaded %s\n", sig_url);
 		}
 		FREE(sig_url);
 	}
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 8486851f..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,16 +342,16 @@ 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, PM_LOG_DEBUG, "option 'cachedir' = %s\n", newcachedir);
+	_alpm_log(handle, ALPM_LOG_DEBUG, "option 'cachedir' = %s\n", newcachedir);
 	return 0;
 }
 
@@ -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;
 	}
 
@@ -412,7 +412,7 @@ int SYMEXPORT alpm_option_set_logfile(alpm_handle_t *handle, const char *logfile
 		fclose(handle->logstream);
 		handle->logstream = NULL;
 	}
-	_alpm_log(handle, PM_LOG_DEBUG, "option 'logfile' = %s\n", handle->logfile);
+	_alpm_log(handle, ALPM_LOG_DEBUG, "option 'logfile' = %s\n", handle->logfile);
 	return 0;
 }
 
@@ -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;
 	}
 
@@ -429,7 +429,7 @@ int SYMEXPORT alpm_option_set_gpgdir(alpm_handle_t *handle, const char *gpgdir)
 	}
 	handle->gpgdir = strdup(gpgdir);
 
-	_alpm_log(handle, PM_LOG_DEBUG, "option 'gpgdir' = %s\n", handle->gpgdir);
+	_alpm_log(handle, ALPM_LOG_DEBUG, "option 'gpgdir' = %s\n", handle->gpgdir);
 	return 0;
 }
 
@@ -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 f69ba0b3..ae9b9a9d 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 d967780c..59374dcb 100644
--- a/lib/libalpm/remove.c
+++ b/lib/libalpm/remove.c
@@ -52,20 +52,20 @@ 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, PM_LOG_DEBUG, "adding package %s to the transaction remove list\n",
+	_alpm_log(handle, ALPM_LOG_DEBUG, "adding package %s to the transaction remove list\n",
 			pkgname);
 	trans->remove = alpm_list_add(trans->remove, _alpm_pkg_dup(pkg));
 	return 0;
@@ -82,12 +82,12 @@ static void remove_prepare_cascade(alpm_handle_t *handle, alpm_list_t *lp)
 			alpm_pkg_t *info = _alpm_db_get_pkgfromcache(handle->db_local, miss->target);
 			if(info) {
 				if(!_alpm_pkg_find(trans->remove, alpm_pkg_get_name(info))) {
-					_alpm_log(handle, PM_LOG_DEBUG, "pulling %s in target list\n",
+					_alpm_log(handle, ALPM_LOG_DEBUG, "pulling %s in target list\n",
 							alpm_pkg_get_name(info));
 					trans->remove = alpm_list_add(trans->remove, _alpm_pkg_dup(info));
 				}
 			} else {
-				_alpm_log(handle, PM_LOG_ERROR, _("could not find %s in database -- skipping\n"),
+				_alpm_log(handle, ALPM_LOG_ERROR, _("could not find %s in database -- skipping\n"),
 									miss->target);
 			}
 		}
@@ -116,7 +116,7 @@ static void remove_prepare_keep_needed(alpm_handle_t *handle, alpm_list_t *lp)
 					&vpkg);
 			pkg = vpkg;
 			if(pkg) {
-				_alpm_log(handle, PM_LOG_WARNING, _("removing %s from target list\n"),
+				_alpm_log(handle, ALPM_LOG_WARNING, _("removing %s from target list\n"),
 						alpm_pkg_get_name(pkg));
 				_alpm_pkg_free(pkg);
 			}
@@ -141,22 +141,22 @@ int _alpm_remove_prepare(alpm_handle_t *handle, alpm_list_t **data)
 	alpm_trans_t *trans = handle->trans;
 	alpm_db_t *db = handle->db_local;
 
-	if((trans->flags & PM_TRANS_FLAG_RECURSE) && !(trans->flags & PM_TRANS_FLAG_CASCADE)) {
-		_alpm_log(handle, PM_LOG_DEBUG, "finding removable dependencies\n");
+	if((trans->flags & ALPM_TRANS_FLAG_RECURSE) && !(trans->flags & ALPM_TRANS_FLAG_CASCADE)) {
+		_alpm_log(handle, ALPM_LOG_DEBUG, "finding removable dependencies\n");
 		_alpm_recursedeps(db, trans->remove,
-				trans->flags & PM_TRANS_FLAG_RECURSEALL);
+				trans->flags & ALPM_TRANS_FLAG_RECURSEALL);
 	}
 
-	if(!(trans->flags & PM_TRANS_FLAG_NODEPS)) {
-		EVENT(trans, PM_TRANS_EVT_CHECKDEPS_START, NULL, NULL);
+	if(!(trans->flags & ALPM_TRANS_FLAG_NODEPS)) {
+		EVENT(trans, ALPM_TRANS_EVT_CHECKDEPS_START, NULL, NULL);
 
-		_alpm_log(handle, PM_LOG_DEBUG, "looking for unsatisfied dependencies\n");
+		_alpm_log(handle, ALPM_LOG_DEBUG, "looking for unsatisfied dependencies\n");
 		lp = alpm_checkdeps(handle, _alpm_db_get_pkgcache(db), trans->remove, NULL, 1);
 		if(lp != NULL) {
 
-			if(trans->flags & PM_TRANS_FLAG_CASCADE) {
+			if(trans->flags & ALPM_TRANS_FLAG_CASCADE) {
 				remove_prepare_cascade(handle, lp);
-			} else if(trans->flags & PM_TRANS_FLAG_UNNEEDED) {
+			} else if(trans->flags & ALPM_TRANS_FLAG_UNNEEDED) {
 				/* Remove needed packages (which would break dependencies)
 				 * from target list */
 				remove_prepare_keep_needed(handle, lp);
@@ -167,26 +167,26 @@ 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);
 			}
 		}
 	}
 
 	/* re-order w.r.t. dependencies */
-	_alpm_log(handle, PM_LOG_DEBUG, "sorting by dependencies\n");
+	_alpm_log(handle, ALPM_LOG_DEBUG, "sorting by dependencies\n");
 	lp = _alpm_sortbydeps(handle, trans->remove, 1);
 	/* free the old alltargs */
 	alpm_list_free(trans->remove);
 	trans->remove = lp;
 
 	/* -Rcs == -Rc then -Rs */
-	if((trans->flags & PM_TRANS_FLAG_CASCADE) && (trans->flags & PM_TRANS_FLAG_RECURSE)) {
-		_alpm_log(handle, PM_LOG_DEBUG, "finding removable dependencies\n");
-		_alpm_recursedeps(db, trans->remove, trans->flags & PM_TRANS_FLAG_RECURSEALL);
+	if((trans->flags & ALPM_TRANS_FLAG_CASCADE) && (trans->flags & ALPM_TRANS_FLAG_RECURSE)) {
+		_alpm_log(handle, ALPM_LOG_DEBUG, "finding removable dependencies\n");
+		_alpm_recursedeps(db, trans->remove, trans->flags & ALPM_TRANS_FLAG_RECURSEALL);
 	}
 
-	if(!(trans->flags & PM_TRANS_FLAG_NODEPS)) {
-		EVENT(trans, PM_TRANS_EVT_CHECKDEPS_DONE, NULL, NULL);
+	if(!(trans->flags & ALPM_TRANS_FLAG_NODEPS)) {
+		EVENT(trans, ALPM_TRANS_EVT_CHECKDEPS_DONE, NULL, NULL);
 	}
 
 	return 0;
@@ -209,7 +209,7 @@ static int can_remove_file(alpm_handle_t *handle, const alpm_file_t *file,
 		if(errno != EACCES && errno != ETXTBSY && access(filepath, F_OK) == 0) {
 			/* only return failure if the file ACTUALLY exists and we can't write to
 			 * it - ignore "chmod -w" simple permission failures */
-			_alpm_log(handle, PM_LOG_ERROR, _("cannot remove file '%s': %s\n"),
+			_alpm_log(handle, ALPM_LOG_ERROR, _("cannot remove file '%s': %s\n"),
 					filepath, strerror(errno));
 			return 0;
 		}
@@ -232,7 +232,7 @@ static void unlink_file(alpm_handle_t *handle, alpm_pkg_t *info,
 	 * see the big comment block in db_find_fileconflicts() for an
 	 * explanation. */
 	if(alpm_list_find_str(skip_remove, fileobj->name)) {
-		_alpm_log(handle, PM_LOG_DEBUG, "%s is in skip_remove, skipping removal\n",
+		_alpm_log(handle, ALPM_LOG_DEBUG, "%s is in skip_remove, skipping removal\n",
 				file);
 		return;
 	}
@@ -242,23 +242,23 @@ static void unlink_file(alpm_handle_t *handle, alpm_pkg_t *info,
 	 * filesystem, we want to work with the linked directory instead of the
 	 * actual symlink */
 	if(lstat(file, &buf)) {
-		_alpm_log(handle, PM_LOG_DEBUG, "file %s does not exist\n", file);
+		_alpm_log(handle, ALPM_LOG_DEBUG, "file %s does not exist\n", file);
 		return;
 	}
 
 	if(S_ISDIR(buf.st_mode)) {
 		if(rmdir(file)) {
 			/* this is okay, other packages are probably using it (like /usr) */
-			_alpm_log(handle, PM_LOG_DEBUG, "keeping directory %s\n", file);
+			_alpm_log(handle, ALPM_LOG_DEBUG, "keeping directory %s\n", file);
 		} else {
-			_alpm_log(handle, PM_LOG_DEBUG, "removing directory %s\n", file);
+			_alpm_log(handle, ALPM_LOG_DEBUG, "removing directory %s\n", file);
 		}
 	} else {
 		/* if the file needs backup and has been modified, back it up to .pacsave */
 		alpm_backup_t *backup = _alpm_needbackup(fileobj->name, alpm_pkg_get_backup(info));
 		if(backup) {
 			if(nosave) {
-				_alpm_log(handle, PM_LOG_DEBUG, "transaction is set to NOSAVE, not backing up '%s'\n", file);
+				_alpm_log(handle, ALPM_LOG_DEBUG, "transaction is set to NOSAVE, not backing up '%s'\n", file);
 			} else {
 				char *filehash = alpm_compute_md5sum(file);
 				int cmp = filehash ? strcmp(filehash, backup->hash) : 0;
@@ -267,17 +267,17 @@ static void unlink_file(alpm_handle_t *handle, alpm_pkg_t *info,
 					char newpath[PATH_MAX];
 					snprintf(newpath, PATH_MAX, "%s.pacsave", file);
 					rename(file, newpath);
-					_alpm_log(handle, PM_LOG_WARNING, _("%s saved as %s\n"), file, newpath);
+					_alpm_log(handle, ALPM_LOG_WARNING, _("%s saved as %s\n"), file, newpath);
 					alpm_logaction(handle, "warning: %s saved as %s\n", file, newpath);
 					return;
 				}
 			}
 		}
 
-		_alpm_log(handle, PM_LOG_DEBUG, "unlinking %s\n", file);
+		_alpm_log(handle, ALPM_LOG_DEBUG, "unlinking %s\n", file);
 
 		if(unlink(file) == -1) {
-			_alpm_log(handle, PM_LOG_ERROR, _("cannot remove file '%s': %s\n"),
+			_alpm_log(handle, ALPM_LOG_ERROR, _("cannot remove file '%s': %s\n"),
 					file, strerror(errno));
 		}
 	}
@@ -291,10 +291,10 @@ int _alpm_upgraderemove_package(alpm_handle_t *handle,
 	alpm_list_t *files = alpm_pkg_get_files(oldpkg);
 	const char *pkgname = alpm_pkg_get_name(oldpkg);
 
-	_alpm_log(handle, PM_LOG_DEBUG, "removing old package first (%s-%s)\n",
+	_alpm_log(handle, ALPM_LOG_DEBUG, "removing old package first (%s-%s)\n",
 			oldpkg->name, oldpkg->version);
 
-	if(handle->trans->flags & PM_TRANS_FLAG_DBONLY) {
+	if(handle->trans->flags & ALPM_TRANS_FLAG_DBONLY) {
 		goto db;
 	}
 
@@ -312,21 +312,21 @@ int _alpm_upgraderemove_package(alpm_handle_t *handle,
 		if(!_alpm_filelist_contains(filelist, backup->name)) {
 			continue;
 		}
-		_alpm_log(handle, PM_LOG_DEBUG, "adding %s to the skip_remove array\n",
+		_alpm_log(handle, ALPM_LOG_DEBUG, "adding %s to the skip_remove array\n",
 				backup->name);
 		skip_remove = alpm_list_add(skip_remove, strdup(backup->name));
 	}
 
 	for(lp = files; lp; lp = lp->next) {
 		if(!can_remove_file(handle, lp->data, skip_remove)) {
-			_alpm_log(handle, PM_LOG_DEBUG,
+			_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++;
 	}
 
-	_alpm_log(handle, PM_LOG_DEBUG, "removing %ld files\n", (unsigned long)filenum);
+	_alpm_log(handle, ALPM_LOG_DEBUG, "removing %ld files\n", (unsigned long)filenum);
 
 	/* iterate through the list backwards, unlinking files */
 	for(lp = alpm_list_last(files); lp; lp = alpm_list_previous(files, lp)) {
@@ -336,15 +336,15 @@ int _alpm_upgraderemove_package(alpm_handle_t *handle,
 
 db:
 	/* remove the package from the database */
-	_alpm_log(handle, PM_LOG_DEBUG, "updating database\n");
-	_alpm_log(handle, PM_LOG_DEBUG, "removing database entry '%s'\n", pkgname);
+	_alpm_log(handle, ALPM_LOG_DEBUG, "updating database\n");
+	_alpm_log(handle, ALPM_LOG_DEBUG, "removing database entry '%s'\n", pkgname);
 	if(_alpm_local_db_remove(handle->db_local, oldpkg) == -1) {
-		_alpm_log(handle, PM_LOG_ERROR, _("could not remove database entry %s-%s\n"),
+		_alpm_log(handle, ALPM_LOG_ERROR, _("could not remove database entry %s-%s\n"),
 				pkgname, alpm_pkg_get_version(oldpkg));
 	}
 	/* remove the package from the cache */
 	if(_alpm_db_remove_pkgfromcache(handle->db_local, oldpkg) == -1) {
-		_alpm_log(handle, PM_LOG_ERROR, _("could not remove entry '%s' from cache\n"),
+		_alpm_log(handle, ALPM_LOG_ERROR, _("could not remove entry '%s' from cache\n"),
 				pkgname);
 	}
 
@@ -376,72 +376,72 @@ int _alpm_remove_packages(alpm_handle_t *handle)
 		snprintf(scriptlet, PATH_MAX, "%s%s-%s/install",
 				_alpm_db_path(handle->db_local), pkgname, alpm_pkg_get_version(info));
 
-		EVENT(trans, PM_TRANS_EVT_REMOVE_START, info, NULL);
-		_alpm_log(handle, PM_LOG_DEBUG, "removing package %s-%s\n",
+		EVENT(trans, ALPM_TRANS_EVT_REMOVE_START, info, NULL);
+		_alpm_log(handle, ALPM_LOG_DEBUG, "removing package %s-%s\n",
 				pkgname, alpm_pkg_get_version(info));
 
 		/* run the pre-remove scriptlet if it exists  */
-		if(alpm_pkg_has_scriptlet(info) && !(trans->flags & PM_TRANS_FLAG_NOSCRIPTLET)) {
+		if(alpm_pkg_has_scriptlet(info) && !(trans->flags & ALPM_TRANS_FLAG_NOSCRIPTLET)) {
 			_alpm_runscriptlet(handle, scriptlet, "pre_remove",
 					alpm_pkg_get_version(info), NULL);
 		}
 
-		if(!(trans->flags & PM_TRANS_FLAG_DBONLY)) {
+		if(!(trans->flags & ALPM_TRANS_FLAG_DBONLY)) {
 			alpm_list_t *files = alpm_pkg_get_files(info);
 			size_t filenum = 0;
 
 			for(lp = files; lp; lp = lp->next) {
 				if(!can_remove_file(handle, lp->data, NULL)) {
-					_alpm_log(handle, PM_LOG_DEBUG, "not removing package '%s', can't remove all files\n",
+					_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++;
 			}
 
-			_alpm_log(handle, PM_LOG_DEBUG, "removing %ld files\n", (unsigned long)filenum);
+			_alpm_log(handle, ALPM_LOG_DEBUG, "removing %ld files\n", (unsigned long)filenum);
 
 			/* init progress bar */
-			PROGRESS(trans, PM_TRANS_PROGRESS_REMOVE_START, info->name, 0,
+			PROGRESS(trans, ALPM_TRANS_PROGRESS_REMOVE_START, info->name, 0,
 					pkg_count, (pkg_count - targcount + 1));
 
 			/* iterate through the list backwards, unlinking files */
 			for(lp = alpm_list_last(files); lp; lp = alpm_list_previous(files, lp)) {
 				int percent;
-				unlink_file(handle, info, lp->data, NULL, trans->flags & PM_TRANS_FLAG_NOSAVE);
+				unlink_file(handle, info, lp->data, NULL, trans->flags & ALPM_TRANS_FLAG_NOSAVE);
 
 				/* update progress bar after each file */
 				percent = (position * 100) / filenum;
-				PROGRESS(trans, PM_TRANS_PROGRESS_REMOVE_START, info->name,
+				PROGRESS(trans, ALPM_TRANS_PROGRESS_REMOVE_START, info->name,
 						percent, pkg_count, (pkg_count - targcount + 1));
 				position++;
 			}
 		}
 
 		/* set progress to 100% after we finish unlinking files */
-		PROGRESS(trans, PM_TRANS_PROGRESS_REMOVE_START, pkgname, 100,
+		PROGRESS(trans, ALPM_TRANS_PROGRESS_REMOVE_START, pkgname, 100,
 		         pkg_count, (pkg_count - targcount + 1));
 
 		/* run the post-remove script if it exists  */
-		if(alpm_pkg_has_scriptlet(info) && !(trans->flags & PM_TRANS_FLAG_NOSCRIPTLET)) {
+		if(alpm_pkg_has_scriptlet(info) && !(trans->flags & ALPM_TRANS_FLAG_NOSCRIPTLET)) {
 			_alpm_runscriptlet(handle, scriptlet, "post_remove",
 					alpm_pkg_get_version(info), NULL);
 		}
 
 		/* remove the package from the database */
-		_alpm_log(handle, PM_LOG_DEBUG, "updating database\n");
-		_alpm_log(handle, PM_LOG_DEBUG, "removing database entry '%s'\n", pkgname);
+		_alpm_log(handle, ALPM_LOG_DEBUG, "updating database\n");
+		_alpm_log(handle, ALPM_LOG_DEBUG, "removing database entry '%s'\n", pkgname);
 		if(_alpm_local_db_remove(handle->db_local, info) == -1) {
-			_alpm_log(handle, PM_LOG_ERROR, _("could not remove database entry %s-%s\n"),
+			_alpm_log(handle, ALPM_LOG_ERROR, _("could not remove database entry %s-%s\n"),
 			          pkgname, alpm_pkg_get_version(info));
 		}
 		/* remove the package from the cache */
 		if(_alpm_db_remove_pkgfromcache(handle->db_local, info) == -1) {
-			_alpm_log(handle, PM_LOG_ERROR, _("could not remove entry '%s' from cache\n"),
+			_alpm_log(handle, ALPM_LOG_ERROR, _("could not remove entry '%s' from cache\n"),
 			          pkgname);
 		}
 
-		EVENT(trans, PM_TRANS_EVT_REMOVE_DONE, info, NULL);
+		EVENT(trans, ALPM_TRANS_EVT_REMOVE_DONE, info, NULL);
 	}
 
 	/* run ldconfig if it exists */
diff --git a/lib/libalpm/signing.c b/lib/libalpm/signing.c
index 4e03ddcc..1ac9963a 100644
--- a/lib/libalpm/signing.c
+++ b/lib/libalpm/signing.c
@@ -118,13 +118,13 @@ 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
 	 * some internal library setup code */
 	version = gpgme_check_version(NULL);
-	_alpm_log(handle, PM_LOG_DEBUG, "GPGME version: %s\n", version);
+	_alpm_log(handle, ALPM_LOG_DEBUG, "GPGME version: %s\n", version);
 	gpgme_set_locale(NULL, LC_CTYPE, setlocale(LC_CTYPE, NULL));
 #ifdef LC_MESSAGES
 	gpgme_set_locale(NULL, LC_MESSAGES, setlocale(LC_MESSAGES, NULL));
@@ -146,15 +146,15 @@ static int init_gpgme(alpm_handle_t *handle)
 	CHECK_ERR();
 	err = gpgme_get_engine_info(&enginfo);
 	CHECK_ERR();
-	_alpm_log(handle, PM_LOG_DEBUG, "GPGME engine info: file=%s, home=%s\n",
+	_alpm_log(handle, ALPM_LOG_DEBUG, "GPGME engine info: file=%s, home=%s\n",
 			enginfo->file_name, enginfo->home_dir);
 
 	init = 1;
 	return 0;
 
 error:
-	_alpm_log(handle, PM_LOG_ERROR, _("GPGME error: %s\n"), gpgme_strerror(err));
-	RET_ERR(handle, PM_ERR_GPGME, 1);
+	_alpm_log(handle, ALPM_LOG_ERROR, _("GPGME error: %s\n"), gpgme_strerror(err));
+	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);
 		}
 	}
 
@@ -238,7 +238,7 @@ int _alpm_gpgme_checksig(alpm_handle_t *handle, const char *path,
 		return -1;
 	}
 
-	_alpm_log(handle, PM_LOG_DEBUG, "checking signature for %s\n", path);
+	_alpm_log(handle, ALPM_LOG_DEBUG, "checking signature for %s\n", path);
 
 	memset(&ctx, 0, sizeof(ctx));
 	memset(&sigdata, 0, sizeof(sigdata));
@@ -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;
 		}
@@ -287,7 +287,7 @@ int _alpm_gpgme_checksig(alpm_handle_t *handle, const char *path,
 	result = gpgme_op_verify_result(ctx);
 	gpgsig = result->signatures;
 	if(!gpgsig) {
-		_alpm_log(handle, PM_LOG_DEBUG, "no signatures returned\n");
+		_alpm_log(handle, ALPM_LOG_DEBUG, "no signatures returned\n");
 		ret = -1;
 		goto error;
 	}
@@ -295,16 +295,16 @@ int _alpm_gpgme_checksig(alpm_handle_t *handle, const char *path,
 	while(gpgsig) {
 		alpm_list_t *summary_list, *summary;
 
-		_alpm_log(handle, PM_LOG_DEBUG, "fingerprint: %s\n", gpgsig->fpr);
+		_alpm_log(handle, ALPM_LOG_DEBUG, "fingerprint: %s\n", gpgsig->fpr);
 		summary_list = list_sigsum(gpgsig->summary);
 		for(summary = summary_list; summary; summary = summary->next) {
-			_alpm_log(handle, PM_LOG_DEBUG, "summary: %s\n", (const char *)summary->data);
+			_alpm_log(handle, ALPM_LOG_DEBUG, "summary: %s\n", (const char *)summary->data);
 		}
 		alpm_list_free(summary_list);
-		_alpm_log(handle, PM_LOG_DEBUG, "status: %s\n", gpgme_strerror(gpgsig->status));
-		_alpm_log(handle, PM_LOG_DEBUG, "timestamp: %lu\n", gpgsig->timestamp);
-		_alpm_log(handle, PM_LOG_DEBUG, "exp_timestamp: %lu\n", gpgsig->exp_timestamp);
-		_alpm_log(handle, PM_LOG_DEBUG, "validity: %s; reason: %s\n",
+		_alpm_log(handle, ALPM_LOG_DEBUG, "status: %s\n", gpgme_strerror(gpgsig->status));
+		_alpm_log(handle, ALPM_LOG_DEBUG, "timestamp: %lu\n", gpgsig->timestamp);
+		_alpm_log(handle, ALPM_LOG_DEBUG, "exp_timestamp: %lu\n", gpgsig->exp_timestamp);
+		_alpm_log(handle, ALPM_LOG_DEBUG, "validity: %s; reason: %s\n",
 				string_validity(gpgsig->validity),
 				gpgme_strerror(gpgsig->validity_reason));
 
@@ -313,23 +313,23 @@ int _alpm_gpgme_checksig(alpm_handle_t *handle, const char *path,
 		 * worst case wins out. */
 		if(gpgsig->summary & GPGME_SIGSUM_VALID) {
 			/* definite good signature */
-			_alpm_log(handle, PM_LOG_DEBUG, "result: valid signature\n");
+			_alpm_log(handle, ALPM_LOG_DEBUG, "result: valid signature\n");
 		} else if(gpgsig->summary & GPGME_SIGSUM_GREEN) {
 			/* good signature */
-			_alpm_log(handle, PM_LOG_DEBUG, "result: green signature\n");
+			_alpm_log(handle, ALPM_LOG_DEBUG, "result: green signature\n");
 		} else if(gpgsig->summary & GPGME_SIGSUM_RED) {
 			/* definite bad signature, error */
-			_alpm_log(handle, PM_LOG_DEBUG, "result: red signature\n");
-			handle->pm_errno = PM_ERR_SIG_INVALID;
+			_alpm_log(handle, ALPM_LOG_DEBUG, "result: red signature\n");
+			handle->pm_errno = ALPM_ERR_SIG_INVALID;
 			ret = 1;
 		} else if(gpgsig->summary & GPGME_SIGSUM_KEY_MISSING) {
-			_alpm_log(handle, PM_LOG_DEBUG, "result: signature from unknown key\n");
-			handle->pm_errno = PM_ERR_SIG_UNKNOWN;
+			_alpm_log(handle, ALPM_LOG_DEBUG, "result: signature from unknown key\n");
+			handle->pm_errno = ALPM_ERR_SIG_UNKNOWN;
 			ret = 1;
 		} else {
 			/* we'll capture everything else here */
-			_alpm_log(handle, PM_LOG_DEBUG, "result: invalid signature\n");
-			handle->pm_errno = PM_ERR_SIG_INVALID;
+			_alpm_log(handle, ALPM_LOG_DEBUG, "result: invalid signature\n");
+			handle->pm_errno = ALPM_ERR_SIG_INVALID;
 			ret = 1;
 		}
 
@@ -349,8 +349,8 @@ error:
 	FREE(sigpath);
 	FREE(decoded_sigdata);
 	if(err != GPG_ERR_NO_ERROR) {
-		_alpm_log(handle, PM_LOG_ERROR, _("GPGME error: %s\n"), gpgme_strerror(err));
-		RET_ERR(handle, PM_ERR_GPGME, -1);
+		_alpm_log(handle, ALPM_LOG_ERROR, _("GPGME error: %s\n"), gpgme_strerror(err));
+		RET_ERR(handle, ALPM_ERR_GPGME, -1);
 	}
 	return ret;
 }
diff --git a/lib/libalpm/sync.c b/lib/libalpm/sync.c
index 8f038400..d6b54ba0 100644
--- a/lib/libalpm/sync.c
+++ b/lib/libalpm/sync.c
@@ -66,14 +66,14 @@ alpm_pkg_t SYMEXPORT *alpm_sync_newversion(alpm_pkg_t *pkg, alpm_list_t *dbs_syn
 	}
 
 	if(spkg == NULL) {
-		_alpm_log(pkg->handle, PM_LOG_DEBUG, "'%s' not found in sync db => no upgrade\n",
+		_alpm_log(pkg->handle, ALPM_LOG_DEBUG, "'%s' not found in sync db => no upgrade\n",
 				alpm_pkg_get_name(pkg));
 		return NULL;
 	}
 
 	/* compare versions and see if spkg is an upgrade */
 	if(_alpm_pkg_compare_versions(spkg, pkg) > 0) {
-		_alpm_log(pkg->handle, PM_LOG_DEBUG, "new version of '%s' found (%s => %s)\n",
+		_alpm_log(pkg->handle, ALPM_LOG_DEBUG, "new version of '%s' found (%s => %s)\n",
 					alpm_pkg_get_name(pkg), alpm_pkg_get_version(pkg),
 					alpm_pkg_get_version(spkg));
 		return spkg;
@@ -94,15 +94,15 @@ 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, PM_LOG_DEBUG, "checking for package upgrades\n");
+	_alpm_log(handle, ALPM_LOG_DEBUG, "checking for package upgrades\n");
 	for(i = _alpm_db_get_pkgcache(db_local); i; i = i->next) {
 		alpm_pkg_t *lpkg = i->data;
 
 		if(_alpm_pkg_find(trans->add, lpkg->name)) {
-			_alpm_log(handle, PM_LOG_DEBUG, "%s is already in the target list -- skipping\n", lpkg->name);
+			_alpm_log(handle, ALPM_LOG_DEBUG, "%s is already in the target list -- skipping\n", lpkg->name);
 			continue;
 		}
 
@@ -116,15 +116,15 @@ int SYMEXPORT alpm_sync_sysupgrade(alpm_handle_t *handle, int enable_downgrade)
 				/* 1. literal was found in sdb */
 				int cmp = _alpm_pkg_compare_versions(spkg, lpkg);
 				if(cmp > 0) {
-					_alpm_log(handle, PM_LOG_DEBUG, "new version of '%s' found (%s => %s)\n",
+					_alpm_log(handle, ALPM_LOG_DEBUG, "new version of '%s' found (%s => %s)\n",
 								lpkg->name, lpkg->version, spkg->version);
 					/* check IgnorePkg/IgnoreGroup */
 					if(_alpm_pkg_should_ignore(handle, spkg)
 							|| _alpm_pkg_should_ignore(handle, lpkg)) {
-						_alpm_log(handle, PM_LOG_WARNING, _("%s: ignoring package upgrade (%s => %s)\n"),
+						_alpm_log(handle, ALPM_LOG_WARNING, _("%s: ignoring package upgrade (%s => %s)\n"),
 								lpkg->name, lpkg->version, spkg->version);
 					} else {
-						_alpm_log(handle, PM_LOG_DEBUG, "adding package %s-%s to the transaction targets\n",
+						_alpm_log(handle, ALPM_LOG_DEBUG, "adding package %s-%s to the transaction targets\n",
 												spkg->name, spkg->version);
 						trans->add = alpm_list_add(trans->add, spkg);
 					}
@@ -133,15 +133,15 @@ int SYMEXPORT alpm_sync_sysupgrade(alpm_handle_t *handle, int enable_downgrade)
 						/* check IgnorePkg/IgnoreGroup */
 						if(_alpm_pkg_should_ignore(handle, spkg)
 								|| _alpm_pkg_should_ignore(handle, lpkg)) {
-							_alpm_log(handle, PM_LOG_WARNING, _("%s: ignoring package downgrade (%s => %s)\n"),
+							_alpm_log(handle, ALPM_LOG_WARNING, _("%s: ignoring package downgrade (%s => %s)\n"),
 											lpkg->name, lpkg->version, spkg->version);
 						} else {
-							_alpm_log(handle, PM_LOG_WARNING, _("%s: downgrading from version %s to version %s\n"),
+							_alpm_log(handle, ALPM_LOG_WARNING, _("%s: downgrading from version %s to version %s\n"),
 											lpkg->name, lpkg->version, spkg->version);
 							trans->add = alpm_list_add(trans->add, spkg);
 						}
 					} else {
-						_alpm_log(handle, PM_LOG_WARNING, _("%s: local (%s) is newer than %s (%s)\n"),
+						_alpm_log(handle, ALPM_LOG_WARNING, _("%s: local (%s) is newer than %s (%s)\n"),
 								lpkg->name, lpkg->version, sdb->treename, spkg->version);
 					}
 				}
@@ -157,13 +157,13 @@ int SYMEXPORT alpm_sync_sysupgrade(alpm_handle_t *handle, int enable_downgrade)
 						/* check IgnorePkg/IgnoreGroup */
 						if(_alpm_pkg_should_ignore(handle, spkg)
 								|| _alpm_pkg_should_ignore(handle, lpkg)) {
-							_alpm_log(handle, PM_LOG_WARNING, _("ignoring package replacement (%s-%s => %s-%s)\n"),
+							_alpm_log(handle, ALPM_LOG_WARNING, _("ignoring package replacement (%s-%s => %s-%s)\n"),
 										lpkg->name, lpkg->version, spkg->name, spkg->version);
 							continue;
 						}
 
 						int doreplace = 0;
-						QUESTION(trans, PM_TRANS_CONV_REPLACE_PKG, lpkg, spkg, sdb->treename, &doreplace);
+						QUESTION(trans, ALPM_TRANS_CONV_REPLACE_PKG, lpkg, spkg, sdb->treename, &doreplace);
 						if(!doreplace) {
 							continue;
 						}
@@ -174,23 +174,23 @@ int SYMEXPORT alpm_sync_sysupgrade(alpm_handle_t *handle, int enable_downgrade)
 						if(tpkg) {
 							/* sanity check, multiple repos can contain spkg->name */
 							if(tpkg->origin_data.db != sdb) {
-								_alpm_log(handle, PM_LOG_WARNING, _("cannot replace %s by %s\n"),
+								_alpm_log(handle, ALPM_LOG_WARNING, _("cannot replace %s by %s\n"),
 													lpkg->name, spkg->name);
 								continue;
 							}
-							_alpm_log(handle, PM_LOG_DEBUG, "appending %s to the removes list of %s\n",
+							_alpm_log(handle, ALPM_LOG_DEBUG, "appending %s to the removes list of %s\n",
 												lpkg->name, tpkg->name);
 							tpkg->removes = alpm_list_add(tpkg->removes, lpkg);
 							/* check the to-be-replaced package's reason field */
-							if(alpm_pkg_get_reason(lpkg) == PM_PKG_REASON_EXPLICIT) {
-								tpkg->reason = PM_PKG_REASON_EXPLICIT;
+							if(alpm_pkg_get_reason(lpkg) == ALPM_PKG_REASON_EXPLICIT) {
+								tpkg->reason = ALPM_PKG_REASON_EXPLICIT;
 							}
 						} else {
 							/* add spkg to the target list */
 							/* copy over reason */
 							spkg->reason = alpm_pkg_get_reason(lpkg);
 							spkg->removes = alpm_list_add(NULL, lpkg);
-							_alpm_log(handle, PM_LOG_DEBUG, "adding package %s-%s to the transaction targets\n",
+							_alpm_log(handle, ALPM_LOG_DEBUG, "adding package %s-%s to the transaction targets\n",
 													spkg->name, spkg->version);
 							trans->add = alpm_list_add(trans->add, spkg);
 						}
@@ -234,7 +234,7 @@ alpm_list_t SYMEXPORT *alpm_find_group_pkgs(alpm_list_t *dbs,
 			if(_alpm_pkg_should_ignore(db->handle, pkg)) {
 				ignorelist = alpm_list_add(ignorelist, pkg);
 				int install = 0;
-				QUESTION(db->handle->trans, PM_TRANS_CONV_INSTALL_IGNOREPKG, pkg,
+				QUESTION(db->handle->trans, ALPM_TRANS_CONV_INSTALL_IGNOREPKG, pkg,
 						NULL, NULL, &install);
 				if(!install)
 					continue;
@@ -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) {
@@ -282,10 +282,10 @@ static int compute_download_size(alpm_pkg_t *newpkg)
 			&newpkg->delta_path);
 
 		if(newpkg->delta_path && (dltsize < pkgsize * MAX_DELTA_RATIO)) {
-			_alpm_log(handle, PM_LOG_DEBUG, "using delta size\n");
+			_alpm_log(handle, ALPM_LOG_DEBUG, "using delta size\n");
 			size = dltsize;
 		} else {
-			_alpm_log(handle, PM_LOG_DEBUG, "using package size\n");
+			_alpm_log(handle, ALPM_LOG_DEBUG, "using package size\n");
 			size = alpm_pkg_get_size(newpkg);
 			alpm_list_free(newpkg->delta_path);
 			newpkg->delta_path = NULL;
@@ -294,7 +294,7 @@ static int compute_download_size(alpm_pkg_t *newpkg)
 		size = alpm_pkg_get_size(newpkg);
 	}
 
-	_alpm_log(handle, PM_LOG_DEBUG, "setting download size %jd for pkg %s\n",
+	_alpm_log(handle, ALPM_LOG_DEBUG, "setting download size %jd for pkg %s\n",
 			(intmax_t)size, alpm_pkg_get_name(newpkg));
 
 	newpkg->infolevel |= INFRQ_DSIZE;
@@ -315,13 +315,13 @@ int _alpm_sync_prepare(alpm_handle_t *handle, alpm_list_t **data)
 		*data = NULL;
 	}
 
-	if(!(trans->flags & PM_TRANS_FLAG_NODEPS)) {
+	if(!(trans->flags & ALPM_TRANS_FLAG_NODEPS)) {
 		alpm_list_t *resolved = NULL; /* target list after resolvedeps */
 
 		/* Build up list by repeatedly resolving each transaction package */
 		/* Resolve targets dependencies */
-		EVENT(trans, PM_TRANS_EVT_RESOLVEDEPS_START, NULL, NULL);
-		_alpm_log(handle, PM_LOG_DEBUG, "resolving target's dependencies\n");
+		EVENT(trans, ALPM_TRANS_EVT_RESOLVEDEPS_START, NULL, NULL);
+		_alpm_log(handle, ALPM_LOG_DEBUG, "resolving target's dependencies\n");
 
 		/* build remove list for resolvedeps */
 		for(i = trans->add; i; i = i->next) {
@@ -353,7 +353,7 @@ int _alpm_sync_prepare(alpm_handle_t *handle, alpm_list_t **data)
 		   see if they'd like to ignore them rather than failing the sync */
 		if(unresolvable != NULL) {
 			int remove_unresolvable = 0;
-			QUESTION(trans, PM_TRANS_CONV_REMOVE_PKGS, unresolvable,
+			QUESTION(trans, ALPM_TRANS_CONV_REMOVE_PKGS, unresolvable,
 					NULL, NULL, &remove_unresolvable);
 			if(remove_unresolvable) {
 				/* User wants to remove the unresolvable packages from the
@@ -378,7 +378,7 @@ int _alpm_sync_prepare(alpm_handle_t *handle, alpm_list_t **data)
 		for(i = resolved; i; i = i->next) {
 			alpm_pkg_t *pkg = i->data;
 			if(!_alpm_pkg_find(trans->add, pkg->name)) {
-				pkg->reason = PM_PKG_REASON_DEPEND;
+				pkg->reason = ALPM_PKG_REASON_DEPEND;
 			}
 		}
 
@@ -391,17 +391,17 @@ int _alpm_sync_prepare(alpm_handle_t *handle, alpm_list_t **data)
 		trans->add = _alpm_sortbydeps(handle, resolved, 0);
 		alpm_list_free(resolved);
 
-		EVENT(trans, PM_TRANS_EVT_RESOLVEDEPS_DONE, NULL, NULL);
+		EVENT(trans, ALPM_TRANS_EVT_RESOLVEDEPS_DONE, NULL, NULL);
 	}
 
-	if(!(trans->flags & PM_TRANS_FLAG_NOCONFLICTS)) {
+	if(!(trans->flags & ALPM_TRANS_FLAG_NOCONFLICTS)) {
 		/* check for inter-conflicts and whatnot */
-		EVENT(trans, PM_TRANS_EVT_INTERCONFLICTS_START, NULL, NULL);
+		EVENT(trans, ALPM_TRANS_EVT_INTERCONFLICTS_START, NULL, NULL);
 
-		_alpm_log(handle, PM_LOG_DEBUG, "looking for conflicts\n");
+		_alpm_log(handle, ALPM_LOG_DEBUG, "looking for conflicts\n");
 
 		/* 1. check for conflicts in the target list */
-		_alpm_log(handle, PM_LOG_DEBUG, "check targets vs targets\n");
+		_alpm_log(handle, ALPM_LOG_DEBUG, "check targets vs targets\n");
 		deps = _alpm_innerconflicts(handle, trans->add);
 
 		for(i = deps; i; i = i->next) {
@@ -415,7 +415,7 @@ int _alpm_sync_prepare(alpm_handle_t *handle, alpm_list_t **data)
 				continue;
 			}
 
-			_alpm_log(handle, PM_LOG_DEBUG, "conflicting packages in the sync list: '%s' <-> '%s'\n",
+			_alpm_log(handle, ALPM_LOG_DEBUG, "conflicting packages in the sync list: '%s' <-> '%s'\n",
 					conflict->package1, conflict->package2);
 
 			/* if sync1 provides sync2, we remove sync2 from the targets, and vice versa */
@@ -428,8 +428,8 @@ int _alpm_sync_prepare(alpm_handle_t *handle, alpm_list_t **data)
 				rsync = sync1;
 				sync = sync2;
 			} else {
-				_alpm_log(handle, PM_LOG_ERROR, _("unresolvable package conflicts detected\n"));
-				handle->pm_errno = PM_ERR_CONFLICTING_DEPS;
+				_alpm_log(handle, ALPM_LOG_ERROR, _("unresolvable package conflicts detected\n"));
+				handle->pm_errno = ALPM_ERR_CONFLICTING_DEPS;
 				ret = -1;
 				if(data) {
 					alpm_conflict_t *newconflict = _alpm_conflict_dup(conflict);
@@ -447,7 +447,7 @@ int _alpm_sync_prepare(alpm_handle_t *handle, alpm_list_t **data)
 			_alpm_dep_free(dep2);
 
 			/* Prints warning */
-			_alpm_log(handle, PM_LOG_WARNING,
+			_alpm_log(handle, ALPM_LOG_WARNING,
 					_("removing '%s' from target list because it conflicts with '%s'\n"),
 					rsync->name, sync->name);
 			trans->add = alpm_list_remove(trans->add, rsync, _alpm_pkg_cmp, NULL);
@@ -460,7 +460,7 @@ int _alpm_sync_prepare(alpm_handle_t *handle, alpm_list_t **data)
 		deps = NULL;
 
 		/* 2. we check for target vs db conflicts (and resolve)*/
-		_alpm_log(handle, PM_LOG_DEBUG, "check targets vs db and db vs targets\n");
+		_alpm_log(handle, ALPM_LOG_DEBUG, "check targets vs db and db vs targets\n");
 		deps = _alpm_outerconflicts(handle->db_local, trans->add);
 
 		for(i = deps; i; i = i->next) {
@@ -479,21 +479,21 @@ int _alpm_sync_prepare(alpm_handle_t *handle, alpm_list_t **data)
 				continue;
 			}
 
-			_alpm_log(handle, PM_LOG_DEBUG, "package '%s' conflicts with '%s'\n",
+			_alpm_log(handle, ALPM_LOG_DEBUG, "package '%s' conflicts with '%s'\n",
 					conflict->package1, conflict->package2);
 
 			alpm_pkg_t *sync = _alpm_pkg_find(trans->add, conflict->package1);
 			alpm_pkg_t *local = _alpm_db_get_pkgfromcache(handle->db_local, conflict->package2);
 			int doremove = 0;
-			QUESTION(trans, PM_TRANS_CONV_CONFLICT_PKG, conflict->package1,
+			QUESTION(trans, ALPM_TRANS_CONV_CONFLICT_PKG, conflict->package1,
 							conflict->package2, conflict->reason, &doremove);
 			if(doremove) {
 				/* append to the removes list */
-				_alpm_log(handle, PM_LOG_DEBUG, "electing '%s' for removal\n", conflict->package2);
+				_alpm_log(handle, ALPM_LOG_DEBUG, "electing '%s' for removal\n", conflict->package2);
 				sync->removes = alpm_list_add(sync->removes, local);
 			} else { /* abort */
-				_alpm_log(handle, PM_LOG_ERROR, _("unresolvable package conflicts detected\n"));
-				handle->pm_errno = PM_ERR_CONFLICTING_DEPS;
+				_alpm_log(handle, ALPM_LOG_ERROR, _("unresolvable package conflicts detected\n"));
+				handle->pm_errno = ALPM_ERR_CONFLICTING_DEPS;
 				ret = -1;
 				if(data) {
 					alpm_conflict_t *newconflict = _alpm_conflict_dup(conflict);
@@ -506,7 +506,7 @@ int _alpm_sync_prepare(alpm_handle_t *handle, alpm_list_t **data)
 				goto cleanup;
 			}
 		}
-		EVENT(trans, PM_TRANS_EVT_INTERCONFLICTS_DONE, NULL, NULL);
+		EVENT(trans, ALPM_TRANS_EVT_INTERCONFLICTS_DONE, NULL, NULL);
 		alpm_list_free_inner(deps, (alpm_list_fn_free)_alpm_conflict_free);
 		alpm_list_free(deps);
 	}
@@ -517,18 +517,18 @@ int _alpm_sync_prepare(alpm_handle_t *handle, alpm_list_t **data)
 		for(j = spkg->removes; j; j = j->next) {
 			alpm_pkg_t *rpkg = j->data;
 			if(!_alpm_pkg_find(trans->remove, rpkg->name)) {
-				_alpm_log(handle, PM_LOG_DEBUG, "adding '%s' to remove list\n", rpkg->name);
+				_alpm_log(handle, ALPM_LOG_DEBUG, "adding '%s' to remove list\n", rpkg->name);
 				trans->remove = alpm_list_add(trans->remove, _alpm_pkg_dup(rpkg));
 			}
 		}
 	}
 
-	if(!(trans->flags & PM_TRANS_FLAG_NODEPS)) {
-		_alpm_log(handle, PM_LOG_DEBUG, "checking dependencies\n");
+	if(!(trans->flags & ALPM_TRANS_FLAG_NODEPS)) {
+		_alpm_log(handle, ALPM_LOG_DEBUG, "checking dependencies\n");
 		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 */
@@ -627,13 +627,13 @@ static int apply_deltas(alpm_handle_t *handle)
 				snprintf(command, PATH_MAX, "xdelta3 -d -q -s %s %s %s", from, delta, to);
 			}
 
-			_alpm_log(handle, PM_LOG_DEBUG, "command: %s\n", command);
+			_alpm_log(handle, ALPM_LOG_DEBUG, "command: %s\n", command);
 
-			EVENT(trans, PM_TRANS_EVT_DELTA_PATCH_START, d->to, d->delta);
+			EVENT(trans, ALPM_TRANS_EVT_DELTA_PATCH_START, d->to, d->delta);
 
 			int retval = system(command);
 			if(retval == 0) {
-				EVENT(trans, PM_TRANS_EVT_DELTA_PATCH_DONE, NULL, NULL);
+				EVENT(trans, ALPM_TRANS_EVT_DELTA_PATCH_DONE, NULL, NULL);
 
 				/* delete the delta file */
 				unlink(delta);
@@ -651,8 +651,8 @@ static int apply_deltas(alpm_handle_t *handle)
 
 			if(retval != 0) {
 				/* one delta failed for this package, cancel the remaining ones */
-				EVENT(trans, PM_TRANS_EVT_DELTA_PATCH_FAILED, NULL, NULL);
-				handle->pm_errno = PM_ERR_DLT_PATCHFAILED;
+				EVENT(trans, ALPM_TRANS_EVT_DELTA_PATCH_FAILED, NULL, NULL);
+				handle->pm_errno = ALPM_ERR_DLT_PATCHFAILED;
 				ret = 1;
 				break;
 			}
@@ -679,7 +679,7 @@ static int test_md5sum(alpm_trans_t *trans, const char *filepath,
 	int ret = _alpm_test_md5sum(filepath, md5sum);
 	if(ret == 1) {
 		int doremove = 0;
-		QUESTION(trans, PM_TRANS_CONV_CORRUPTED_PKG, (char *)filepath,
+		QUESTION(trans, ALPM_TRANS_CONV_CORRUPTED_PKG, (char *)filepath,
 				NULL, NULL, &doremove);
 		if(doremove) {
 			unlink(filepath);
@@ -701,7 +701,7 @@ static int validate_deltas(alpm_handle_t *handle, alpm_list_t *deltas,
 	}
 
 	/* Check integrity of deltas */
-	EVENT(trans, PM_TRANS_EVT_DELTA_INTEGRITY_START, NULL, NULL);
+	EVENT(trans, ALPM_TRANS_EVT_DELTA_INTEGRITY_START, NULL, NULL);
 
 	for(i = deltas; i; i = i->next) {
 		alpm_delta_t *d = alpm_list_getdata(i);
@@ -714,15 +714,15 @@ 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, PM_TRANS_EVT_DELTA_INTEGRITY_DONE, NULL, NULL);
+	EVENT(trans, ALPM_TRANS_EVT_DELTA_INTEGRITY_DONE, NULL, NULL);
 
 	/* Use the deltas to generate the packages */
-	EVENT(trans, PM_TRANS_EVT_DELTA_PATCHES_START, NULL, NULL);
+	EVENT(trans, ALPM_TRANS_EVT_DELTA_PATCHES_START, NULL, NULL);
 	ret = apply_deltas(handle);
-	EVENT(trans, PM_TRANS_EVT_DELTA_PATCHES_DONE, NULL, NULL);
+	EVENT(trans, ALPM_TRANS_EVT_DELTA_PATCHES_DONE, NULL, NULL);
 	return ret;
 }
 
@@ -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 */
@@ -782,7 +782,7 @@ static int download_files(alpm_handle_t *handle, alpm_list_t **deltas)
 		}
 
 		if(files) {
-			EVENT(handle->trans, PM_TRANS_EVT_RETRIEVE_START, current->treename, NULL);
+			EVENT(handle->trans, ALPM_TRANS_EVT_RETRIEVE_START, current->treename, NULL);
 			for(j = files; j; j = j->next) {
 				const char *filename = j->data;
 				alpm_list_t *server;
@@ -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);
@@ -810,10 +810,10 @@ static int download_files(alpm_handle_t *handle, alpm_list_t **deltas)
 
 			FREELIST(files);
 			if(errors) {
-				_alpm_log(handle, PM_LOG_WARNING, _("failed to retrieve some files from %s\n"),
+				_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;
 			}
@@ -854,7 +854,7 @@ int _alpm_sync_commit(alpm_handle_t *handle, alpm_list_t **data)
 
 	/* Check integrity of packages */
 	numtargs = alpm_list_count(trans->add);
-	EVENT(trans, PM_TRANS_EVT_INTEGRITY_START, NULL, NULL);
+	EVENT(trans, ALPM_TRANS_EVT_INTEGRITY_START, NULL, NULL);
 
 	errors = 0;
 
@@ -865,7 +865,7 @@ int _alpm_sync_commit(alpm_handle_t *handle, alpm_list_t **data)
 		char *filepath;
 		pgp_verify_t check_sig;
 
-		PROGRESS(trans, PM_TRANS_PROGRESS_INTEGRITY_START, "", percent,
+		PROGRESS(trans, ALPM_TRANS_PROGRESS_INTEGRITY_START, "", percent,
 				numtargs, current);
 		if(spkg->origin == PKG_FROM_FILE) {
 			continue; /* pkg_load() has been already called, this package is valid */
@@ -878,7 +878,7 @@ int _alpm_sync_commit(alpm_handle_t *handle, alpm_list_t **data)
 
 		/* load the package file and replace pkgcache entry with it in the target list */
 		/* TODO: alpm_pkg_get_db() will not work on this target anymore */
-		_alpm_log(handle, PM_LOG_DEBUG,
+		_alpm_log(handle, ALPM_LOG_DEBUG,
 				"replacing pkgcache entry with package file for target %s\n",
 				spkg->name);
 		alpm_pkg_t *pkgfile =_alpm_pkg_load_internal(handle, filepath, 1, spkg->md5sum,
@@ -895,16 +895,16 @@ int _alpm_sync_commit(alpm_handle_t *handle, alpm_list_t **data)
 		_alpm_pkg_free_trans(spkg); /* spkg has been removed from the target list */
 	}
 
-	PROGRESS(trans, PM_TRANS_PROGRESS_INTEGRITY_START, "", 100,
+	PROGRESS(trans, ALPM_TRANS_PROGRESS_INTEGRITY_START, "", 100,
 			numtargs, current);
-	EVENT(trans, PM_TRANS_EVT_INTEGRITY_DONE, NULL, NULL);
+	EVENT(trans, ALPM_TRANS_EVT_INTEGRITY_DONE, NULL, NULL);
 
 
 	if(errors) {
-		RET_ERR(handle, PM_ERR_PKG_INVALID, -1);
+		RET_ERR(handle, ALPM_ERR_PKG_INVALID, -1);
 	}
 
-	if(trans->flags & PM_TRANS_FLAG_DOWNLOADONLY) {
+	if(trans->flags & ALPM_TRANS_FLAG_DOWNLOADONLY) {
 		return 0;
 	}
 
@@ -913,10 +913,10 @@ int _alpm_sync_commit(alpm_handle_t *handle, alpm_list_t **data)
 	replaces = alpm_list_count(trans->remove);
 
 	/* fileconflict check */
-	if(!(trans->flags & PM_TRANS_FLAG_FORCE)) {
-		EVENT(trans, PM_TRANS_EVT_FILECONFLICTS_START, NULL, NULL);
+	if(!(trans->flags & ALPM_TRANS_FLAG_FORCE)) {
+		EVENT(trans, ALPM_TRANS_EVT_FILECONFLICTS_START, NULL, NULL);
 
-		_alpm_log(handle, PM_LOG_DEBUG, "looking for file conflicts\n");
+		_alpm_log(handle, ALPM_LOG_DEBUG, "looking for file conflicts\n");
 		alpm_list_t *conflict = _alpm_db_find_fileconflicts(handle,
 				trans->add, trans->remove);
 		if(conflict) {
@@ -926,39 +926,39 @@ 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, PM_TRANS_EVT_FILECONFLICTS_DONE, NULL, NULL);
+		EVENT(trans, ALPM_TRANS_EVT_FILECONFLICTS_DONE, NULL, NULL);
 	}
 
 	/* check available disk space */
 	if(handle->checkspace) {
-		EVENT(trans, PM_TRANS_EVT_DISKSPACE_START, NULL, NULL);
+		EVENT(trans, ALPM_TRANS_EVT_DISKSPACE_START, NULL, NULL);
 
-		_alpm_log(handle, PM_LOG_DEBUG, "checking available disk space\n");
+		_alpm_log(handle, ALPM_LOG_DEBUG, "checking available disk space\n");
 		if(_alpm_check_diskspace(handle) == -1) {
-			_alpm_log(handle, PM_LOG_ERROR, "%s\n", _("not enough free disk space"));
+			_alpm_log(handle, ALPM_LOG_ERROR, "%s\n", _("not enough free disk space"));
 			return -1;
 		}
 
-		EVENT(trans, PM_TRANS_EVT_DISKSPACE_DONE, NULL, NULL);
+		EVENT(trans, ALPM_TRANS_EVT_DISKSPACE_DONE, NULL, NULL);
 	}
 
 	/* remove conflicting and to-be-replaced packages */
 	if(replaces) {
-		_alpm_log(handle, PM_LOG_DEBUG, "removing conflicting and to-be-replaced packages\n");
+		_alpm_log(handle, ALPM_LOG_DEBUG, "removing conflicting and to-be-replaced packages\n");
 		/* we want the frontend to be aware of commit details */
 		if(_alpm_remove_packages(handle) == -1) {
-			_alpm_log(handle, PM_LOG_ERROR, _("could not commit removal transaction\n"));
+			_alpm_log(handle, ALPM_LOG_ERROR, _("could not commit removal transaction\n"));
 			return -1;
 		}
 	}
 
 	/* install targets */
-	_alpm_log(handle, PM_LOG_DEBUG, "installing packages\n");
+	_alpm_log(handle, ALPM_LOG_DEBUG, "installing packages\n");
 	if(_alpm_upgrade_packages(handle) == -1) {
-		_alpm_log(handle, PM_LOG_ERROR, _("could not commit transaction\n"));
+		_alpm_log(handle, ALPM_LOG_ERROR, _("could not commit transaction\n"));
 		return -1;
 	}
 
diff --git a/lib/libalpm/trans.c b/lib/libalpm/trans.c
index 29a74bf9..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 & PM_TRANS_FLAG_NOLOCK)) {
+	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 & PM_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,10 +220,10 @@ 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 & PM_TRANS_FLAG_NOLOCK;
+	int nolock_flag = trans->flags & ALPM_TRANS_FLAG_NOLOCK;
 
 	_alpm_trans_free(trans);
 	handle->trans = NULL;
@@ -231,7 +231,7 @@ int SYMEXPORT alpm_trans_release(alpm_handle_t *handle)
 	/* unlock db */
 	if(!nolock_flag) {
 		if(_alpm_handle_unlock(handle)) {
-			_alpm_log(handle, PM_LOG_WARNING, _("could not remove lock file %s\n"),
+			_alpm_log(handle, ALPM_LOG_WARNING, _("could not remove lock file %s\n"),
 					alpm_option_get_lockfile(handle));
 			alpm_logaction(handle, "warning: could not remove lock file %s\n",
 					alpm_option_get_lockfile(handle));
@@ -298,7 +298,7 @@ int _alpm_runscriptlet(alpm_handle_t *handle, const char *installfn,
 
 	if(access(installfn, R_OK)) {
 		/* not found */
-		_alpm_log(handle, PM_LOG_DEBUG, "scriptlet '%s' not found\n", installfn);
+		_alpm_log(handle, ALPM_LOG_DEBUG, "scriptlet '%s' not found\n", installfn);
 		return 0;
 	}
 
@@ -309,7 +309,7 @@ int _alpm_runscriptlet(alpm_handle_t *handle, const char *installfn,
 	}
 	snprintf(tmpdir, PATH_MAX, "%stmp/alpm_XXXXXX", handle->root);
 	if(mkdtemp(tmpdir) == NULL) {
-		_alpm_log(handle, PM_LOG_ERROR, _("could not create temp directory\n"));
+		_alpm_log(handle, ALPM_LOG_ERROR, _("could not create temp directory\n"));
 		return 1;
 	} else {
 		clean_tmpdir = 1;
@@ -323,7 +323,7 @@ int _alpm_runscriptlet(alpm_handle_t *handle, const char *installfn,
 		}
 	} else {
 		if(_alpm_copyfile(installfn, scriptfn)) {
-			_alpm_log(handle, PM_LOG_ERROR, _("could not copy tempfile to %s (%s)\n"), scriptfn, strerror(errno));
+			_alpm_log(handle, ALPM_LOG_ERROR, _("could not copy tempfile to %s (%s)\n"), scriptfn, strerror(errno));
 			retval = 1;
 		}
 	}
@@ -347,13 +347,13 @@ int _alpm_runscriptlet(alpm_handle_t *handle, const char *installfn,
 				scriptpath, script, ver);
 	}
 
-	_alpm_log(handle, PM_LOG_DEBUG, "executing \"%s\"\n", cmdline);
+	_alpm_log(handle, ALPM_LOG_DEBUG, "executing \"%s\"\n", cmdline);
 
 	retval = _alpm_run_chroot(handle, "/bin/sh", argv);
 
 cleanup:
 	if(clean_tmpdir && _alpm_rmrf(tmpdir)) {
-		_alpm_log(handle, PM_LOG_WARNING, _("could not remove tmpdir %s\n"), tmpdir);
+		_alpm_log(handle, ALPM_LOG_WARNING, _("could not remove tmpdir %s\n"), tmpdir);
 	}
 
 	return retval;
@@ -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 8bcb5463..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);
@@ -262,23 +262,23 @@ int _alpm_unpack(alpm_handle_t *handle, const char *archive, const char *prefix,
 
 	if(archive_read_open_filename(_archive, archive,
 				ARCHIVE_DEFAULT_BYTES_PER_BLOCK) != ARCHIVE_OK) {
-		_alpm_log(handle, PM_LOG_ERROR, _("could not open file %s: %s\n"), archive,
+		_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);
 
 	/* save the cwd so we can restore it later */
 	if(getcwd(cwd, PATH_MAX) == NULL) {
-		_alpm_log(handle, PM_LOG_ERROR, _("could not get current working directory\n"));
+		_alpm_log(handle, ALPM_LOG_ERROR, _("could not get current working directory\n"));
 	} else {
 		restore_cwd = 1;
 	}
 
 	/* just in case our cwd was removed in the upgrade operation */
 	if(chdir(prefix) != 0) {
-		_alpm_log(handle, PM_LOG_ERROR, _("could not change directory to %s (%s)\n"),
+		_alpm_log(handle, ALPM_LOG_ERROR, _("could not change directory to %s (%s)\n"),
 				prefix, strerror(errno));
 		ret = 1;
 		goto cleanup;
@@ -313,7 +313,7 @@ int _alpm_unpack(alpm_handle_t *handle, const char *archive, const char *prefix,
 				}
 				continue;
 			} else {
-				_alpm_log(handle, PM_LOG_DEBUG, "extracting: %s\n", entryname);
+				_alpm_log(handle, ALPM_LOG_DEBUG, "extracting: %s\n", entryname);
 			}
 		}
 
@@ -321,10 +321,10 @@ int _alpm_unpack(alpm_handle_t *handle, const char *archive, const char *prefix,
 		int readret = archive_read_extract(_archive, entry, 0);
 		if(readret == ARCHIVE_WARN) {
 			/* operation succeeded but a non-critical error was encountered */
-			_alpm_log(handle, PM_LOG_WARNING, _("warning given when extracting %s (%s)\n"),
+			_alpm_log(handle, ALPM_LOG_WARNING, _("warning given when extracting %s (%s)\n"),
 					entryname, archive_error_string(_archive));
 		} else if(readret != ARCHIVE_OK) {
-			_alpm_log(handle, PM_LOG_ERROR, _("could not extract %s (%s)\n"),
+			_alpm_log(handle, ALPM_LOG_ERROR, _("could not extract %s (%s)\n"),
 					entryname, archive_error_string(_archive));
 			ret = 1;
 			goto cleanup;
@@ -339,7 +339,7 @@ cleanup:
 	umask(oldmask);
 	archive_read_finish(_archive);
 	if(restore_cwd && chdir(cwd) != 0) {
-		_alpm_log(handle, PM_LOG_ERROR, _("could not change directory to %s (%s)\n"),
+		_alpm_log(handle, ALPM_LOG_ERROR, _("could not change directory to %s (%s)\n"),
 				cwd, strerror(errno));
 	}
 	return ret;
@@ -429,26 +429,26 @@ int _alpm_run_chroot(alpm_handle_t *handle, const char *path, char *const argv[]
 
 	/* save the cwd so we can restore it later */
 	if(getcwd(cwd, PATH_MAX) == NULL) {
-		_alpm_log(handle, PM_LOG_ERROR, _("could not get current working directory\n"));
+		_alpm_log(handle, ALPM_LOG_ERROR, _("could not get current working directory\n"));
 	} else {
 		restore_cwd = 1;
 	}
 
 	/* just in case our cwd was removed in the upgrade operation */
 	if(chdir(handle->root) != 0) {
-		_alpm_log(handle, PM_LOG_ERROR, _("could not change directory to %s (%s)\n"),
+		_alpm_log(handle, ALPM_LOG_ERROR, _("could not change directory to %s (%s)\n"),
 				handle->root, strerror(errno));
 		goto cleanup;
 	}
 
-	_alpm_log(handle, PM_LOG_DEBUG, "executing \"%s\" under chroot \"%s\"\n",
+	_alpm_log(handle, ALPM_LOG_DEBUG, "executing \"%s\" under chroot \"%s\"\n",
 			path, handle->root);
 
 	/* Flush open fds before fork() to avoid cloning buffers */
 	fflush(NULL);
 
 	if(pipe(pipefd) == -1) {
-		_alpm_log(handle, PM_LOG_ERROR, _("could not create pipe (%s)\n"), strerror(errno));
+		_alpm_log(handle, ALPM_LOG_ERROR, _("could not create pipe (%s)\n"), strerror(errno));
 		retval = 1;
 		goto cleanup;
 	}
@@ -456,7 +456,7 @@ int _alpm_run_chroot(alpm_handle_t *handle, const char *path, char *const argv[]
 	/* fork- parent and child each have seperate code blocks below */
 	pid = fork();
 	if(pid == -1) {
-		_alpm_log(handle, PM_LOG_ERROR, _("could not fork a new process (%s)\n"), strerror(errno));
+		_alpm_log(handle, ALPM_LOG_ERROR, _("could not fork a new process (%s)\n"), strerror(errno));
 		retval = 1;
 		goto cleanup;
 	}
@@ -500,14 +500,14 @@ int _alpm_run_chroot(alpm_handle_t *handle, const char *path, char *const argv[]
 				if(fgets(line, PATH_MAX, pipe_file) == NULL)
 					break;
 				alpm_logaction(handle, "%s", line);
-				EVENT(handle->trans, PM_TRANS_EVT_SCRIPTLET_INFO, line, NULL);
+				EVENT(handle->trans, ALPM_TRANS_EVT_SCRIPTLET_INFO, line, NULL);
 			}
 			fclose(pipe_file);
 		}
 
 		while(waitpid(pid, &status, 0) == -1) {
 			if(errno != EINTR) {
-				_alpm_log(handle, PM_LOG_ERROR, _("call to waitpid failed (%s)\n"), strerror(errno));
+				_alpm_log(handle, ALPM_LOG_ERROR, _("call to waitpid failed (%s)\n"), strerror(errno));
 				retval = 1;
 				goto cleanup;
 			}
@@ -515,14 +515,14 @@ int _alpm_run_chroot(alpm_handle_t *handle, const char *path, char *const argv[]
 
 		/* report error from above after the child has exited */
 		if(retval != 0) {
-			_alpm_log(handle, PM_LOG_ERROR, _("could not open pipe (%s)\n"), strerror(errno));
+			_alpm_log(handle, ALPM_LOG_ERROR, _("could not open pipe (%s)\n"), strerror(errno));
 			goto cleanup;
 		}
 		/* check the return status, make sure it is 0 (success) */
 		if(WIFEXITED(status)) {
-			_alpm_log(handle, PM_LOG_DEBUG, "call to waitpid succeeded\n");
+			_alpm_log(handle, ALPM_LOG_DEBUG, "call to waitpid succeeded\n");
 			if(WEXITSTATUS(status) != 0) {
-				_alpm_log(handle, PM_LOG_ERROR, _("command failed to execute correctly\n"));
+				_alpm_log(handle, ALPM_LOG_ERROR, _("command failed to execute correctly\n"));
 				retval = 1;
 			}
 		}
@@ -530,7 +530,7 @@ int _alpm_run_chroot(alpm_handle_t *handle, const char *path, char *const argv[]
 
 cleanup:
 	if(restore_cwd && chdir(cwd) != 0) {
-		_alpm_log(handle, PM_LOG_ERROR, _("could not change directory to %s (%s)\n"), cwd, strerror(errno));
+		_alpm_log(handle, ALPM_LOG_ERROR, _("could not change directory to %s (%s)\n"), cwd, strerror(errno));
 	}
 
 	return retval;
@@ -540,7 +540,7 @@ int _alpm_ldconfig(alpm_handle_t *handle)
 {
 	char line[PATH_MAX];
 
-	_alpm_log(handle, PM_LOG_DEBUG, "running ldconfig\n");
+	_alpm_log(handle, ALPM_LOG_DEBUG, "running ldconfig\n");
 
 	snprintf(line, PATH_MAX, "%setc/ld.so.conf", handle->root);
 	if(access(line, F_OK) == 0) {
@@ -579,7 +579,7 @@ char *_alpm_filecache_find(alpm_handle_t *handle, const char *filename)
 				filename);
 		if(stat(path, &buf) == 0 && S_ISREG(buf.st_mode)) {
 			retpath = strdup(path);
-			_alpm_log(handle, PM_LOG_DEBUG, "found cached pkg: %s\n", retpath);
+			_alpm_log(handle, ALPM_LOG_DEBUG, "found cached pkg: %s\n", retpath);
 			return retpath;
 		}
 	}
@@ -603,17 +603,17 @@ const char *_alpm_filecache_setup(alpm_handle_t *handle)
 		cachedir = alpm_list_getdata(i);
 		if(stat(cachedir, &buf) != 0) {
 			/* cache directory does not exist.... try creating it */
-			_alpm_log(handle, PM_LOG_WARNING, _("no %s cache exists, creating...\n"),
+			_alpm_log(handle, ALPM_LOG_WARNING, _("no %s cache exists, creating...\n"),
 					cachedir);
 			if(_alpm_makepath(cachedir) == 0) {
-				_alpm_log(handle, PM_LOG_DEBUG, "using cachedir: %s\n", cachedir);
+				_alpm_log(handle, ALPM_LOG_DEBUG, "using cachedir: %s\n", cachedir);
 				return cachedir;
 			}
 		} else if(S_ISDIR(buf.st_mode) && (buf.st_mode & S_IWUSR)) {
-			_alpm_log(handle, PM_LOG_DEBUG, "using cachedir: %s\n", cachedir);
+			_alpm_log(handle, ALPM_LOG_DEBUG, "using cachedir: %s\n", cachedir);
 			return cachedir;
 		} else {
-			_alpm_log(handle, PM_LOG_DEBUG, "skipping cachedir: %s\n", cachedir);
+			_alpm_log(handle, ALPM_LOG_DEBUG, "skipping cachedir: %s\n", cachedir);
 		}
 	}
 
@@ -621,8 +621,8 @@ const char *_alpm_filecache_setup(alpm_handle_t *handle)
 	tmp = alpm_list_add(NULL, "/tmp/");
 	alpm_option_set_cachedirs(handle, tmp);
 	alpm_list_free(tmp);
-	_alpm_log(handle, PM_LOG_DEBUG, "using cachedir: %s\n", "/tmp/");
-	_alpm_log(handle, PM_LOG_WARNING, _("couldn't create package cache, using /tmp instead\n"));
+	_alpm_log(handle, ALPM_LOG_DEBUG, "using cachedir: %s\n", "/tmp/");
+	_alpm_log(handle, ALPM_LOG_WARNING, _("couldn't create package cache, using /tmp instead\n"));
 	return "/tmp/";
 }
 
diff --git a/lib/libalpm/util.h b/lib/libalpm/util.h
index 614c2fbb..fd97824a 100644
--- a/lib/libalpm/util.h
+++ b/lib/libalpm/util.h
@@ -62,12 +62,12 @@
 #define ASSERT(cond, action) do { if(!(cond)) { action; } } while(0)
 
 #define RET_ERR_VOID(handle, err) do { \
-	_alpm_log(handle, PM_LOG_DEBUG, "returning error %d from %s : %s\n", err, __func__, alpm_strerror(err)); \
+	_alpm_log(handle, ALPM_LOG_DEBUG, "returning error %d from %s : %s\n", err, __func__, alpm_strerror(err)); \
 	(handle)->pm_errno = (err); \
 	return; } while(0)
 
 #define RET_ERR(handle, err, ret) do { \
-	_alpm_log(handle, PM_LOG_DEBUG, "returning error %d from %s : %s\n", err, __func__, alpm_strerror(err)); \
+	_alpm_log(handle, ALPM_LOG_DEBUG, "returning error %d from %s : %s\n", err, __func__, alpm_strerror(err)); \
 	(handle)->pm_errno = (err); \
 	return (ret); } while(0)