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]="$( cat ${PACKAGE_USE_PATH}/* \

			| sed -re "s/#.*$//" )"

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

		ACTIVE_FLAGS[4]="$(sed -re "/#.*$/ d" < ${PACKAGE_USE_PATH})"

	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

	#

	# Traverse through use.mask and use.force (0.5s)

	#ACTIVE_FLAGS[6]=$(reduce_incrementals \

	#	$(cat $(traverse_profile "use.mask") \

	#		| sed -re "/^#.*$/ {d}"))

	#ACTIVE_FLAGS[7]=$(reduce_incrementals \

	#	$(cat $(traverse_profile "use.force") \

	#		| sed -re "/^#.*$/ {d}"))

	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)

	# $2 version (7.2)

	#

	# TODO: Scrap ${2} input. Get a folder listing of the ebuilds,

	#		derive version from each file name and create use flag list

	#		from each file's contents. Store by package name and

	#		version.

	#

	local known=$(echo "${ACTIVE_FLAGS[5]}" | egrep "^${1};${2}")

	if [[ -n $known ]]; then

		# Isolate the flags part

		echo $known | cut -d\; -f4 | cut -d\" -f2 

		return

	fi

	local pkg=$(echo ${1} | cut -d/ -f2)

	# Open the ebuild file and retrieve defined USE flags

	[[ ! -d "$(get_portdir)/${1}" ]] && return 1

	for file in $(get_portdir)/${1}/*.ebuild; do

		# Crazy sed script matches IUSE variable if it spans

		# multiple lines

		local flags=$(sed -nr -e '/IUSE="/{;:loop;/"$/{;s/\n//g;p;q;};N;b loop;}' ${file})

		local slot=$(grep "^SLOT=" ${file})

		local version=$(basename ${file} | sed -re "s:${pkg}-(.+)\.ebuild:\1:")

		ACTIVE_FLAGS[5]="${ACTIVE_FLAGS[5]}"$'\n'"${1};${version};${slot};${flags}"

	done

}

# get all make.defaults by traversing the cascaded profile directories

get_all_make_defaults() {

	if [[ -n $MAKE_DEFAULTS ]]; then

		echo $MAKE_DEFAULTS

		return

	fi

	traverse_profile "make.defaults"

}

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

	fi

	get_flagstatus_helper "$@"

}

get_flagstatus_helper_ebuild() {

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

		echo -n "${4:- }" 

		return

	fi

	#local info=$( get_useflaglist_ebuild "${5}" "${6}")

	local flags=$(echo $2 | cut -d\" -f2) 

	local flag=$(echo " $flags " | grep -Eo " [+-]?$1 ")

	if [[ ${flag:1:1} == "+" ]]; then

		echo -en "${3}"

	elif [[ ${flag:1:1} == "-" ]]; then

		echo -en "${3}" | tr [:upper:]+ [:lower:]-

	elif [[ -z $flag ]]; then

		echo -en "!"

	else

		echo -en "${4:- }"

	fi

}

	set -f

				echo

		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} | grep -Ee "[^#]*${pkg_re}") ]]; then	

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

                # for this package, then remove the whole line

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

						grep -Pe "^[^#]*${pkg_re}[ ]*-?${flag}[ ]$") ]]; 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" &&

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

			$( 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

set +f