PACKAGE_USE_PATH=/etc/portage/package.use

			-p | --package)	       MODE="modify"; shift; PACKAGE=${1};;

warn() {

	echo "WARNING: ${1}"

}

	[ "${MODE}" == "modify" -a -s "${PACKAGE_USE_PATH}" -a ! -w "${PACKAGE_USE_PATH}" ] && error ""${PACKAGE_USE_PATH}" is not writable"

# Similar to reduce_incrementals except converts lines from package atoms

# in /etc/portage/package.use files to lines of "pkg {[-]flag}*"

reduce_package_use() {

    echo "${@}" | python -c "import sys,re

h={}; atom=re.compile(r'[<>]?=?([a-z][\w/-]+[a-z])(-[\dpr._*-]+)?', re.I); 

getflags=re.compile(r'(-?[\w*-]+)')

for x in sys.stdin.read().split('\n'):

	if not x: continue

	parts = x.lstrip().split(' ',1)

	if len(parts)==1: continue

	try:

		pkg = atom.match(parts[0]).group(1)

	except:

		continue

	flags = getflags.findall(parts[1])

	if not pkg in h: h[pkg]=[]

	r=h[pkg]

	for x in flags:

		if x[0] == '-' and x[1:] in r:

			r.remove(x[1:])

			r.append(x)

		elif x[0] != '-' and '-'+x in r:

			r.remove('-'+x)

			r.append(x)

		elif x == '-*':

			r = h[pkg] = ['-*']

		elif x not in r:

			r.append(x)

print '\n'.join([' %s %s ' % (pkg,' '.join(flgs)) for pkg,flgs in h.iteritems() if len(flgs)])"

}

	# Parse through /etc/portage/package.use

	if [[ -d ${PACKAGE_USE_PATH} ]]; then

		ACTIVE_FLAGS[4]="$( find ${PACKAGE_USE_PATH} -type f -exec cat {} \; \

			-exec echo \; | sed -re "s/#.*$//" )"

	elif [[ -e ${PACKAGE_USE_PATH} ]]; then

		ACTIVE_FLAGS[4]="$( cat ${PACKAGE_USE_PATH} | sed -re "s/#.*$//")"

	fi

	# Simplify ACTIVE_FLAGS[4] to be lines of pkg {[-]flag}*

	ACTIVE_FLAGS[4]="$(reduce_package_use "${ACTIVE_FLAGS[4]}")"

	#

	# ACTIVE_FLAGS[5] reserved for USE flags defined in ebuilds and

	# is generated/maintained in the get_useflaglist_ebuild() function

	#

	USE_FLAGS_CALCULATED=1

}

# Fetch USE flags reported active by Portage

get_portageuseflags() {

	# only calculate once as calling emerge is painfully slow

	[ -n "${_PORTAGE_USE_FLAGS_CALCULATED}" ] && return

get_useflaglist_ebuild() {

	# $1 package atom (app-editor/vim)

	#

	local known=$(echo "${ACTIVE_FLAGS[5]}" | egrep ^${1} | sed -e s:^${1}\s::)

	if [[ ! -z $known ]]; then

		echo $known

		return

	fi

	# Fetch list of package ebuilds matching the query from equery.

	# 	Since determining the current version of a package requires

	#	scanning for available ones, inpecting the KEYWORDS variable

	#	and then checking in a heap of other places for exceptions,

	#   equery is a simple alternative

	if [[ "$MODE" != "showinstdesc" ]]; then

		local exclude_installed="--exclude-installed"

	fi

	# The last one in the list would be the one to be installed.

	local ebuild

	for T in $(equery -N list --portage-tree $exclude_installed \

			${1} | grep "${1}" | egrep -v "\[M.\]" | \

			cut -d\  -f 5 | sed -e s:^[^/]*/::); do

		ebuild=${T}

	done

	# Open the ebuild file and retrieve defined USE flags

	if [[ ! -e "$(get_portdir)/${1}/${ebuild}.ebuild" ]]; then

		return 1

	fi

	local flags="$(cat $(get_portdir)/${1}/${ebuild}.ebuild | \

		python -c "import re,sys; print re.compile(r'^IUSE=\"[^\"]*\"', re.M)\

			.search(sys.stdin.read()).group(0)")"

	ACTIVE_FLAGS[5]="$(echo -ne ${ACTIVE_FLAGS[5]}$'\n'${1} ${flags})"

	echo ${flags}

}

		return 1

get_flagstatus_helper_pkg() {

	if [[ -z ${flags} ]]; then

		local flags=$(echo " ${ACTIVE_FLAGS[${2}]} " | grep "${5} ");

	fi;

	if [[ -z ${5} || -z ${flags} ]]; then

		echo -e -n "${4:- }"

		return 1;

	fi

	get_flagstatus_helper "$@"

	return $?

}

get_flagstatus_helper_ebuild() {

	if [[ -z ${5} ]]; then 

		echo -e -n "${4:- }" 

		return 1 

	fi

	local flags=$( get_useflaglist_ebuild "${5}" )

	get_flagstatus_helper_pkg "$@"

	return $?

}

	[[ ! -z ${2} ]] && get_useflaglist_ebuild "${2}" > /dev/null

		get_portageuseflags

		if echo " ${ACTIVE_FLAGS[4]} " | egrep -e " -?${1} " > /dev/null; then

			for pkg in $( echo "${ACTIVE_FLAGS[4]}" | \

					egrep " -?${1} " | cut -d " " -f 2); do

				printf "%-20s" ${1}

				SCOPE="local" get_flagstatus ${1} "${pkg}"

				printf "(%s)\n" ${pkg}

			done;

		fi

# Simple utility to remove empty files from package.use

clean_package_use() {

if [[ -d ${PACKAGE_USE_PATH} ]]; then

	for f in $(find ${PACKAGE_USE_PATH} -size 0); do

		echo "Removing empty file ""${f}"""

		rm ${f}

	done;

fi

}

# Utility to remove a use flag from a file in package.use[/]

# Args: (1) File, (2) Use flag

scrub_use_flag() {

	local atom_re="^[<>]?=?([a-z][\da-z/-]+[a-z])(-[0-9pr._*-]+)?"

	local filename=${1}

	# Ignore leading - on flag

	local flag=${2#*-}

	local pkg=$(echo "${PACKAGE}" | sed -re "s/${atom_re}/\1/")

	local pkg_re="[<>]?=?${pkg}(-[\dpr._*-]+)?"

	while read line; do

		# Skip (preserve) comments on their own lines

		if [[ -z $(echo "${line}" | sed -re "s/^ *#.*$//") ]]; then

			echo "${line}"

		# Detect if requested package is defined on this line

		elif [[ -n ${PACKAGE} ]]; then

			if [[ -n $(echo ${line} | egrep -E "[^#]*${pkg_re}") ]]; then	

				# If this is the only (remaining) use flag defined

                # for this package, then remove the whole line

                if [[ -z $(echo ${line} | \

						egrep -E "[^#]*${pkg_re}\s*-?${flag}\s*$") ]]; then

					# Remove flag from this line

					echo "${line}" | sed -re "s/-?\b${flag}\b//"

				fi

			else

				# Passthru

				echo "${line}"

			fi

		# If line only has this use flag, let it be removed 

		# (used if PACKAGE is not defined -- from pruning)

		elif [[ -z $(echo ${line} | \

				grep -re "[^#]*${atom_re}.*-?${flag}") ]]; then

			# Remove flag from this line

			echo "${line}" | sed -re "s/-?\b${flag}\b//"

		else

			# Passthru

			echo "${line}"

		fi;

	done < <(cat "${filename}") > "${filename}";

}

modify_package() {

	get_useflags

	local atom_re="^[<>]?=?([a-z][\da-z/-]+[a-z])(-[0-9pr._*-]+)?"

	local pkg=$(echo "${PACKAGE}" | sed -re "s/${atom_re}/\1/")

	local pkg_re="[<>]?=?${pkg}(-[\dpr._*-]+)?"

	while [[ -n ${1} ]]; do

	local flag=${1}

	#

	# --- Sanity checks

	# (1) make sure ${pkg} exists in portdir

	if [[ ! -d "$(get_portdir)/${pkg}" ]]; then

		error "Package ""${pkg}"" does not exist"

	#

	# (2) make sure ${flag} is defined in get_useflaglist

	elif [[ ! -n $(echo " $(get_useflaglist) " | grep "${flag}") ]]; then

		warn "USE flag ""${flag}"" does not exist"

		# Don't bail just because of this, just warn

	fi;

	# If flag is enabled in portage USE flags (emerge --info), 

	# then "remove"ing the flag should be replaced with adding

	# the negative flag instead

	if [[ "${ACTION}" == "remove" && \

			$( get_flagstatus ${flag} ${pkg} | grep "+" ) ]]; then

		flag="-${flag}"

		ACTION="add"

	# If flag is currently disabled for the package requested 

	# to be enabled in, then "remove" the negative

	elif [[ "${ACTION}" == "add" &&

			-n $( echo " ${ACTIVE_FLAGS[4]} " | egrep -e " ${PACKAGE}.*-${flag}\b" ) ]]; then

		flag="-${flag}"

		ACTION="remove"

	fi;

	case "${ACTION}" in

		"add")

			local filename

			if [[ -d ${PACKAGE_USE_PATH} ]]; then

				# Use naming convention of package.use/package

				filename="${PACKAGE_USE_PATH}/${pkg#*/}"

				if [[ ! -s "${filename}" ]]; then

					# Create new file to contain flag

					echo "${PACKAGE} ${flag}" > "${filename}"

					echo "Adding ""${PACKAGE}:${flag}"" use flag to new file ""${filename}"""

					return

				fi;

			else	

				# Add to package.use file instead

				filename=${PACKAGE_USE_PATH}

				# Create as necessary

				touch "${filename}"

			fi;

			# Walk through the file and add the flag manually

			echo "Adding ""${PACKAGE}:${flag}"" use flag in ""${filename}"""

            local added=0

			while read line; do

				if [[ -n $(echo "${line}" | egrep -e "^[^#]*${pkg_re}") ]]; then

					echo "$(reduce_package_use "${line} ${flag}" | cut -d " " -f 2-)"

					added=1

				else

					# Passthru

					echo "${line}"

				fi;

			done < <(cat "${filename}") > ${filename}

			if [[ ${added} == 0 ]]; then

				echo "${PACKAGE} ${flag}" >> "${filename}"

			fi

			;;

		"remove")

			local filename

			if [[ -d ${PACKAGE_USE_PATH} ]]; then

				# Scan for file containing named package and use flag

				filename=$( egrep -rle "${pkg_re}.*[^-]${flag}( |$)" "${PACKAGE_USE_PATH}")

				if [[ -z "${filename}" ]]; then

					error ""${flag}" is not defined for package "${PACKAGE}""

					return

				fi;

			else

				# Remove from package.use instead

				filename=${PACKAGE_USE_PATH}

				# Create as necessary

				touch "${filename}"

			fi;

			# Scrub use flag from matched files

			for f in ${filename}; do

				# Remove current flags in file

				echo "Removing ""${PACKAGE}:${flag}"" use flag in ""${f}"""

				scrub_use_flag ${f} ${flag}

			done;

			# Remove empty files

			clean_package_use

			;;

	esac;

	shift;

	done;

}

	if [[ -n ${PACKAGE} ]]; then

		modify_package ${*}

		return;

	fi;

			# Locate use flag in package.use

			local filename

			if [[ -d ${PACKAGE_USE_PATH} ]]; then

				filename=$( egrep -rle "-?\b${1}\b" "${PACKAGE_USE_PATH}")

			else

				# Scrub from package.use file

				filename=${PACKAGE_USE_PATH}

			fi

			# Scrub use flag from matched files

			for f in ${filename}; do

				# Remove current flags in file

				echo "Disabling ""${1}"" use flag in ""${f}"""

				scrub_use_flag ${f} ${1} 

			done;

			# Remove empty files from package.use

			clean_package_use