From git at git.pioto.org  Mon Sep  1 09:43:44 2008
From: git at git.pioto.org (git at git.pioto.org)
Date: Mon,  1 Sep 2008 09:43:44 -0400 (EDT)
Subject: [paludis-commits] paludis.git (master) -- eebdfdb by David Leverton
Message-ID: <20080901134344.15F75160584@everglades.pioto.org>


Module:    paludis.git
Branch:    master
Commit:    eebdfdbd65a7971d2cbb5812dea42ef05dd899cf
URL:       http://git.pioto.org/?p=paludis.git;a=commit;h=eebdfdbd65a7971d2cbb5812dea42ef05dd899cf

Author:    David Leverton <levertond at googlemail.com>
Committer: David Leverton <levertond at googlemail.com>
Date:      Mon Sep  1 14:43:37 2008 +0100

----

EAPI 2 will have src_prepare

----

 paludis/repositories/e/ebuild/2/Makefile.am      |    1 +
 paludis/repositories/e/ebuild/2/src_prepare.bash |   77 ++++++++++++++++++++++
 2 files changed, 78 insertions(+), 0 deletions(-)


diff --git a/paludis/repositories/e/ebuild/2/Makefile.am b/paludis/repositories/e/ebuild/2/Makefile.am
index 1e30166..75c3cdb 100644
--- a/paludis/repositories/e/ebuild/2/Makefile.am
+++ b/paludis/repositories/e/ebuild/2/Makefile.am
@@ -10,6 +10,7 @@ libexecprog2_SCRIPTS = \
 	src_compile.bash \
 	src_configure.bash \
 	src_install.bash \
+	src_prepare.bash \
 	src_test.bash \
 	src_unpack.bash \
 	output_functions.bash
diff --git a/paludis/repositories/e/ebuild/2/src_prepare.bash b/paludis/repositories/e/ebuild/2/src_prepare.bash
new file mode 100644
index 0000000..8e02299
--- /dev/null
+++ b/paludis/repositories/e/ebuild/2/src_prepare.bash
@@ -0,0 +1,77 @@
+#!/usr/bin/env bash
+# vim: set sw=4 sts=4 et :
+
+# Copyright (c) 2006, 2007 Ciaran McCreesh
+# Copyright (c) 2008 David Leverton
+#
+# Based in part upon ebuild.sh from Portage, which is Copyright 1995-2005
+# Gentoo Foundation and distributed under the terms of the GNU General
+# Public License v2.
+#
+# This file is part of the Paludis package manager. Paludis is free software;
+# you can redistribute it and/or modify it under the terms of the GNU General
+# Public License, version 2, as published by the Free Software Foundation.
+#
+# Paludis is distributed in the hope that it will be useful, but WITHOUT ANY
+# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+# details.
+#
+# You should have received a copy of the GNU General Public License along with
+# this program; if not, write to the Free Software Foundation, Inc., 59 Temple
+# Place, Suite 330, Boston, MA  02111-1307  USA
+
+eapi0_src_prepare()
+{
+    die "${FUNCNAME} is not supported"
+}
+
+eapi1_src_prepare()
+{
+    die "${FUNCNAME} is not supported"
+}
+
+eapi2_src_prepare()
+{
+    :
+}
+
+default_src_prepare()
+{
+    eapi2_src_prepare
+}
+
+src_prepare()
+{
+    default_src_prepare
+}
+
+ebuild_f_prepare()
+{
+    if [[ -d "${S}" ]] ; then
+        cd "${S}" || die "cd to \${S} (\"${S}\") failed"
+    elif [[ -d "${WORKDIR}" ]] ; then
+        cd "${WORKDIR}" || die "cd to \${WORKDIR} (\"${WORKDIR}\") failed"
+    fi
+
+    if hasq "prepare" ${SKIP_FUNCTIONS} ; then
+        ebuild_section "Skipping src_prepare (SKIP_FUNCTIONS)"
+    else
+        if [[ $(type -t pre_src_prepare ) == "function" ]] ; then
+            ebuild_section "Starting pre_src_prepare"
+            pre_src_prepare
+            ebuild_section "Done pre_src_prepare"
+        fi
+
+        ebuild_section "Starting src_prepare"
+        src_prepare
+        ebuild_section "Done src_prepare"
+
+        if [[ $(type -t post_src_prepare ) == "function" ]] ; then
+            ebuild_section "Starting post_src_prepare"
+            post_src_prepare
+            ebuild_section "Done post_src_prepare"
+        fi
+    fi
+}
+
---

From git at git.pioto.org  Mon Sep  1 09:47:24 2008
From: git at git.pioto.org (git at git.pioto.org)
Date: Mon,  1 Sep 2008 09:47:24 -0400 (EDT)
Subject: [paludis-commits] paludis.git (0.30) -- cc2a1c6 by David Leverton
Message-ID: <20080901134724.E8783160075@everglades.pioto.org>


Module:    paludis.git
Branch:    0.30
Commit:    cc2a1c69df22ddf094348ee2c83138181564f299
URL:       http://git.pioto.org/?p=paludis.git;a=commit;h=cc2a1c69df22ddf094348ee2c83138181564f299

Author:    David Leverton <levertond at googlemail.com>
Committer: David Leverton <levertond at googlemail.com>
Date:      Mon Sep  1 14:43:37 2008 +0100

----

EAPI 2 will have src_prepare

----

 paludis/repositories/e/ebuild/2/Makefile.am      |    1 +
 paludis/repositories/e/ebuild/2/src_prepare.bash |   77 ++++++++++++++++++++++
 2 files changed, 78 insertions(+), 0 deletions(-)


diff --git a/paludis/repositories/e/ebuild/2/Makefile.am b/paludis/repositories/e/ebuild/2/Makefile.am
index 1e30166..75c3cdb 100644
--- a/paludis/repositories/e/ebuild/2/Makefile.am
+++ b/paludis/repositories/e/ebuild/2/Makefile.am
@@ -10,6 +10,7 @@ libexecprog2_SCRIPTS = \
 	src_compile.bash \
 	src_configure.bash \
 	src_install.bash \
+	src_prepare.bash \
 	src_test.bash \
 	src_unpack.bash \
 	output_functions.bash
diff --git a/paludis/repositories/e/ebuild/2/src_prepare.bash b/paludis/repositories/e/ebuild/2/src_prepare.bash
new file mode 100644
index 0000000..8e02299
--- /dev/null
+++ b/paludis/repositories/e/ebuild/2/src_prepare.bash
@@ -0,0 +1,77 @@
+#!/usr/bin/env bash
+# vim: set sw=4 sts=4 et :
+
+# Copyright (c) 2006, 2007 Ciaran McCreesh
+# Copyright (c) 2008 David Leverton
+#
+# Based in part upon ebuild.sh from Portage, which is Copyright 1995-2005
+# Gentoo Foundation and distributed under the terms of the GNU General
+# Public License v2.
+#
+# This file is part of the Paludis package manager. Paludis is free software;
+# you can redistribute it and/or modify it under the terms of the GNU General
+# Public License, version 2, as published by the Free Software Foundation.
+#
+# Paludis is distributed in the hope that it will be useful, but WITHOUT ANY
+# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+# details.
+#
+# You should have received a copy of the GNU General Public License along with
+# this program; if not, write to the Free Software Foundation, Inc., 59 Temple
+# Place, Suite 330, Boston, MA  02111-1307  USA
+
+eapi0_src_prepare()
+{
+    die "${FUNCNAME} is not supported"
+}
+
+eapi1_src_prepare()
+{
+    die "${FUNCNAME} is not supported"
+}
+
+eapi2_src_prepare()
+{
+    :
+}
+
+default_src_prepare()
+{
+    eapi2_src_prepare
+}
+
+src_prepare()
+{
+    default_src_prepare
+}
+
+ebuild_f_prepare()
+{
+    if [[ -d "${S}" ]] ; then
+        cd "${S}" || die "cd to \${S} (\"${S}\") failed"
+    elif [[ -d "${WORKDIR}" ]] ; then
+        cd "${WORKDIR}" || die "cd to \${WORKDIR} (\"${WORKDIR}\") failed"
+    fi
+
+    if hasq "prepare" ${SKIP_FUNCTIONS} ; then
+        ebuild_section "Skipping src_prepare (SKIP_FUNCTIONS)"
+    else
+        if [[ $(type -t pre_src_prepare ) == "function" ]] ; then
+            ebuild_section "Starting pre_src_prepare"
+            pre_src_prepare
+            ebuild_section "Done pre_src_prepare"
+        fi
+
+        ebuild_section "Starting src_prepare"
+        src_prepare
+        ebuild_section "Done src_prepare"
+
+        if [[ $(type -t post_src_prepare ) == "function" ]] ; then
+            ebuild_section "Starting post_src_prepare"
+            post_src_prepare
+            ebuild_section "Done post_src_prepare"
+        fi
+    fi
+}
+
---

From git at git.pioto.org  Mon Sep  1 11:30:58 2008
From: git at git.pioto.org (git at git.pioto.org)
Date: Mon,  1 Sep 2008 11:30:58 -0400 (EDT)
Subject: [paludis-commits] paludis.git (master) -- 78ce4a6 by Ciaran McCreesh
Message-ID: <20080901153101.D01A7160585@everglades.pioto.org>


Module:    paludis.git
Branch:    master
Commit:    78ce4a65b080ac2a3bb8a569c2f9d317f0906e67
URL:       http://git.pioto.org/?p=paludis.git;a=commit;h=78ce4a65b080ac2a3bb8a569c2f9d317f0906e67

Author:    Ciaran McCreesh <ciaran.mccreesh at googlemail.com>
Committer: Ciaran McCreesh <ciaran.mccreesh at googlemail.com>
Date:      Mon Sep  1 16:30:15 2008 +0100

----

userpriv is mandatory on exherbo

Fixes: ticket:638

----

 paludis/distributions/exherbo/paludis.conf         |    1 +
 paludis/distributions/gentoo/paludis.conf          |    1 +
 .../paludis/extra_distribution_data.cc             |    2 +
 .../paludis/extra_distribution_data.hh             |    2 +
 paludis/environments/paludis/paludis_config.cc     |   23 ++++++++++++++++---
 5 files changed, 25 insertions(+), 4 deletions(-)


diff --git a/paludis/distributions/exherbo/paludis.conf b/paludis/distributions/exherbo/paludis.conf
index b3d12cf..cd01858 100644
--- a/paludis/distributions/exherbo/paludis.conf
+++ b/paludis/distributions/exherbo/paludis.conf
@@ -1,6 +1,7 @@
 bashrc_filename = bashrc
 keywords_filename_part = platforms
 licenses_filename_part = licences
+mandatory_userpriv = true
 mirrors_filename_part = mirrors
 package_mask_filename_part = package_mask
 package_unmask_filename_part = package_unmask
diff --git a/paludis/distributions/gentoo/paludis.conf b/paludis/distributions/gentoo/paludis.conf
index 204670e..1c5b97e 100644
--- a/paludis/distributions/gentoo/paludis.conf
+++ b/paludis/distributions/gentoo/paludis.conf
@@ -1,6 +1,7 @@
 bashrc_filename = bashrc
 keywords_filename_part = keywords
 licenses_filename_part = licenses
+mandatory_userpriv = false
 mirrors_filename_part = mirrors
 package_mask_filename_part = package_mask
 package_unmask_filename_part = package_unmask
diff --git a/paludis/environments/paludis/extra_distribution_data.cc b/paludis/environments/paludis/extra_distribution_data.cc
index 345d67e..68d1d07 100644
--- a/paludis/environments/paludis/extra_distribution_data.cc
+++ b/paludis/environments/paludis/extra_distribution_data.cc
@@ -18,6 +18,7 @@
  */
 
 #include <paludis/environments/paludis/extra_distribution_data.hh>
+#include <paludis/util/destringify.hh>
 #include <paludis/util/make_named_values.hh>
 #include <paludis/util/make_shared_ptr.hh>
 #include <paludis/distribution-impl.hh>
@@ -41,6 +42,7 @@ namespace paludis
                             value_for<n::bashrc_filename>(k->get("bashrc_filename")),
                             value_for<n::keywords_filename_part>(k->get("keywords_filename_part")),
                             value_for<n::licenses_filename_part>(k->get("licenses_filename_part")),
+                            value_for<n::mandatory_userpriv>(destringify<bool>(k->get("mandatory_userpriv"))),
                             value_for<n::mirrors_filename_part>(k->get("mirrors_filename_part")),
                             value_for<n::package_mask_filename_part>(k->get("package_mask_filename_part")),
                             value_for<n::package_unmask_filename_part>(k->get("package_unmask_filename_part")),
diff --git a/paludis/environments/paludis/extra_distribution_data.hh b/paludis/environments/paludis/extra_distribution_data.hh
index 7c4de48..963fa6f 100644
--- a/paludis/environments/paludis/extra_distribution_data.hh
+++ b/paludis/environments/paludis/extra_distribution_data.hh
@@ -31,6 +31,7 @@ namespace paludis
         struct bashrc_filename;
         struct keywords_filename_part;
         struct licenses_filename_part;
+        struct mandatory_userpriv;
         struct mirrors_filename_part;
         struct package_mask_filename_part;
         struct package_unmask_filename_part;
@@ -46,6 +47,7 @@ namespace paludis
             NamedValue<n::bashrc_filename, std::string> bashrc_filename;
             NamedValue<n::keywords_filename_part, std::string> keywords_filename_part;
             NamedValue<n::licenses_filename_part, std::string> licenses_filename_part;
+            NamedValue<n::mandatory_userpriv, bool> mandatory_userpriv;
             NamedValue<n::mirrors_filename_part, std::string> mirrors_filename_part;
             NamedValue<n::package_mask_filename_part, std::string> package_mask_filename_part;
             NamedValue<n::package_unmask_filename_part, std::string> package_unmask_filename_part;
diff --git a/paludis/environments/paludis/paludis_config.cc b/paludis/environments/paludis/paludis_config.cc
index 53ac71c..1f4cc63 100644
--- a/paludis/environments/paludis/paludis_config.cc
+++ b/paludis/environments/paludis/paludis_config.cc
@@ -443,6 +443,11 @@ PaludisConfig::PaludisConfig(PaludisEnvironment * const e, const std::string & s
 
     _imp->root = root_prefix.empty() ? "/" : root_prefix;
     _imp->config_dir = stringify(local_config_dir);
+
+    const std::tr1::shared_ptr<const PaludisDistribution> dist(
+            PaludisExtraDistributionData::get_instance()->data_from_distribution(
+                *DistributionData::get_instance()->distribution_from_string(distribution())));
+
     /* check that we can safely use userpriv */
     {
         Command cmd(Command("ls -ld '" + stringify(local_config_dir) + "'/* >/dev/null 2>/dev/null")
@@ -456,11 +461,21 @@ PaludisConfig::PaludisConfig(PaludisEnvironment * const e, const std::string & s
             _imp->reduced_uid.reset(new uid_t(getuid()));
             _imp->reduced_gid.reset(new gid_t(getgid()));
         }
-    }
 
-    const std::tr1::shared_ptr<const PaludisDistribution> dist(
-            PaludisExtraDistributionData::get_instance()->data_from_distribution(
-                *DistributionData::get_instance()->distribution_from_string(distribution())));
+        if (dist->mandatory_userpriv() && ((0 == *_imp->reduced_uid || 0 == *_imp->reduced_gid)))
+        {
+            std::string s;
+            if (0 == *_imp->reduced_uid)
+                s = "uid " + stringify(*_imp->reduced_uid);
+            if (0 == *_imp->reduced_gid)
+            {
+                if (! s.empty())
+                    s.append(" or ");
+                s.append("gid " + stringify(*_imp->reduced_gid));
+            }
+            throw PaludisConfigError("Cannot use " + s + " for userpriv");
+        }
+    }
 
     std::tr1::function<std::string (const std::string &)> predefined_conf_vars_func(
             std::tr1::bind(&initial_conf_vars, root_prefix, std::tr1::placeholders::_1));
---

From git at git.pioto.org  Mon Sep  1 12:13:20 2008
From: git at git.pioto.org (git at git.pioto.org)
Date: Mon,  1 Sep 2008 12:13:20 -0400 (EDT)
Subject: [paludis-commits] paludis.git (master) -- f687f23 by Ciaran McCreesh
Message-ID: <20080901161320.BF046160586@everglades.pioto.org>


Module:    paludis.git
Branch:    master
Commit:    f687f2305ab5a3964829b0f11d26cfb42171e444
URL:       http://git.pioto.org/?p=paludis.git;a=commit;h=f687f2305ab5a3964829b0f11d26cfb42171e444

Author:    Ciaran McCreesh <ciaran.mccreesh at googlemail.com>
Committer: Ciaran McCreesh <ciaran.mccreesh at googlemail.com>
Date:      Mon Sep  1 17:12:51 2008 +0100

----

Some EAPIs require reduced user id != 0

----

 paludis/repositories/e/eapi.cc              |    3 ++-
 paludis/repositories/e/eapi.hh              |    2 ++
 paludis/repositories/e/eapis/0.conf         |    1 +
 paludis/repositories/e/eapis/exheres-0.conf |    1 +
 paludis/repositories/e/eapis/paludis-1.conf |    1 +
 paludis/repositories/e/ebuild.cc            |   12 ++++++++++++
 6 files changed, 19 insertions(+), 1 deletions(-)


diff --git a/paludis/repositories/e/eapi.cc b/paludis/repositories/e/eapi.cc
index 90b9b37..78a0deb 100644
--- a/paludis/repositories/e/eapi.cc
+++ b/paludis/repositories/e/eapi.cc
@@ -261,7 +261,8 @@ namespace
                         value_for<n::package_dep_spec_parse_options>(package_dep_spec_parse_options),
                         value_for<n::pipe_commands>(make_pipe_commands(k)),
                         value_for<n::tools_options>(make_tool_options(k)),
-                        value_for<n::uri_labels>(make_shared_ptr(new const EAPILabels(check_get(k, "uri_labels"))))
+                        value_for<n::uri_labels>(make_shared_ptr(new const EAPILabels(check_get(k, "uri_labels")))),
+                        value_for<n::userpriv_cannot_use_root>(destringify_key<bool>(k, "userpriv_cannot_use_root"))
                         )));
     }
 }
diff --git a/paludis/repositories/e/eapi.hh b/paludis/repositories/e/eapi.hh
index d0b87b2..33f8fae 100644
--- a/paludis/repositories/e/eapi.hh
+++ b/paludis/repositories/e/eapi.hh
@@ -138,6 +138,7 @@ namespace paludis
         struct uri_labels;
         struct use;
         struct use_expand_separator;
+        struct userpriv_cannot_use_root;
         struct utility_path_suffixes;
         struct vdb_from_env_unless_empty_variables;
         struct vdb_from_env_variables;
@@ -224,6 +225,7 @@ namespace paludis
             NamedValue<n::pipe_commands, std::tr1::shared_ptr<const EAPIPipeCommands> > pipe_commands;
             NamedValue<n::tools_options, std::tr1::shared_ptr<const EAPIToolsOptions> > tools_options;
             NamedValue<n::uri_labels, std::tr1::shared_ptr<const EAPILabels> > uri_labels;
+            NamedValue<n::userpriv_cannot_use_root, bool> userpriv_cannot_use_root;
         };
 
         struct EAPIEbuildEnvironmentVariables
diff --git a/paludis/repositories/e/eapis/0.conf b/paludis/repositories/e/eapis/0.conf
index f4b9f43..51fd238 100644
--- a/paludis/repositories/e/eapis/0.conf
+++ b/paludis/repositories/e/eapis/0.conf
@@ -20,6 +20,7 @@ ebuild_module_suffixes = 0
 f_function_prefix = ebuild_f
 ignore_pivot_env_functions =
 ignore_pivot_env_variables =
+userpriv_cannot_use_root = false
 
 vdb_from_env_variables = \
     CATEGORY CHOST COUNTER DEPEND DESCRIPTION EAPI FEATURES \
diff --git a/paludis/repositories/e/eapis/exheres-0.conf b/paludis/repositories/e/eapis/exheres-0.conf
index 4e9791d..63afb8f 100644
--- a/paludis/repositories/e/eapis/exheres-0.conf
+++ b/paludis/repositories/e/eapis/exheres-0.conf
@@ -23,6 +23,7 @@ use_expand_separator = :
 f_function_prefix = exheres_internal
 ignore_pivot_env_functions =
 ignore_pivot_env_variables =
+userpriv_cannot_use_root = true
 
 vdb_from_env_variables = \
     CATEGORY CHOST DEPENDENCIES SUMMARY EAPI \
diff --git a/paludis/repositories/e/eapis/paludis-1.conf b/paludis/repositories/e/eapis/paludis-1.conf
index f37f88c..50ed2d7 100644
--- a/paludis/repositories/e/eapis/paludis-1.conf
+++ b/paludis/repositories/e/eapis/paludis-1.conf
@@ -23,6 +23,7 @@ use_expand_separator = _
 f_function_prefix = ebuild_f
 ignore_pivot_env_variables =
 ignore_pivot_env_functions =
+userpriv_cannot_use_root = false
 
 vdb_from_env_variables = \
     CATEGORY CHOST COUNTER DEPEND DESCRIPTION EAPI FEATURES \
diff --git a/paludis/repositories/e/ebuild.cc b/paludis/repositories/e/ebuild.cc
index 66c92e2..3f3183b 100644
--- a/paludis/repositories/e/ebuild.cc
+++ b/paludis/repositories/e/ebuild.cc
@@ -92,14 +92,26 @@ EbuildCommand::failure()
 bool
 EbuildCommand::operator() ()
 {
+    Context context("When running an ebuild command on '" + stringify(*params.package_id()) + "':");
+
     Command cmd(getenv_with_default("PALUDIS_EBUILD_DIR", LIBEXECDIR "/paludis") +
             "/ebuild.bash '" + ebuild_file() + "' " + commands());
 
+    if (! params.package_id()->eapi()->supported())
+        throw InternalError(PALUDIS_HERE, "Tried to run EbuildCommand on an unsupported EAPI");
+
     if (params.sandbox())
         cmd.with_sandbox();
 
     if (params.userpriv())
+    {
+        if (params.package_id()->eapi()->supported()->userpriv_cannot_use_root())
+        {
+            if (0 == params.environment()->reduced_uid() || 0 == params.environment()->reduced_gid())
+                throw ActionError("Need to be able to use non-0 user and group for userpriv for '" + stringify(*params.package_id()) + "'");
+        }
         cmd.with_uid_gid(params.environment()->reduced_uid(), params.environment()->reduced_gid());
+    }
 
     using namespace std::tr1::placeholders;
     cmd.with_pipe_command_handler(std::tr1::bind(&pipe_command_handler, params.environment(), params.package_id(), _1));
---

From git at git.pioto.org  Mon Sep  1 12:18:15 2008
From: git at git.pioto.org (git at git.pioto.org)
Date: Mon,  1 Sep 2008 12:18:15 -0400 (EDT)
Subject: [paludis-commits] paludis.git (master) -- df9ef00 by David Leverton
Message-ID: <20080901161816.14951160075@everglades.pioto.org>


Module:    paludis.git
Branch:    master
Commit:    df9ef00684498f74e18b5a4be8b56b8cdc61eb84
URL:       http://git.pioto.org/?p=paludis.git;a=commit;h=df9ef00684498f74e18b5a4be8b56b8cdc61eb84

Author:    David Leverton <levertond at googlemail.com>
Committer: David Leverton <levertond at googlemail.com>
Date:      Mon Sep  1 17:16:25 2008 +0100

----

Change the handling of the two USE-dep syntaxes.

Make it possible for an EAPI to accept both, and do so for paludis-1.
Allow both anyway if strict parsing is disabled.

----

 paludis/elike_package_dep_spec-fwd.hh       |    2 +-
 paludis/elike_package_dep_spec.cc           |   52 ++--
 paludis/elike_use_requirement.cc            |  121 +++++--
 paludis/elike_use_requirement.se            |    2 +
 paludis/elike_use_requirement_TEST.cc       |  532 ++++++++++++++++++++++++---
 paludis/repositories/e/eapis/paludis-1.conf |    2 +-
 6 files changed, 603 insertions(+), 108 deletions(-)


diff --git a/paludis/elike_package_dep_spec-fwd.hh b/paludis/elike_package_dep_spec-fwd.hh
index aaf40ae..5b4960c 100644
--- a/paludis/elike_package_dep_spec-fwd.hh
+++ b/paludis/elike_package_dep_spec-fwd.hh
@@ -57,7 +57,7 @@ namespace paludis
 
     bool elike_remove_trailing_square_bracket_if_exists(std::string & s, PartiallyMadePackageDepSpec & result,
             const ELikePackageDepSpecOptions & options, bool & had_bracket_version_requirements,
-            const std::tr1::shared_ptr<const PackageID> & id) PALUDIS_VISIBLE;
+            bool & had_use_requirements, const std::tr1::shared_ptr<const PackageID> & id) PALUDIS_VISIBLE;
 
     void elike_remove_trailing_repo_if_exists(std::string & s, PartiallyMadePackageDepSpec & result,
             const ELikePackageDepSpecOptions & options) PALUDIS_VISIBLE;
diff --git a/paludis/elike_package_dep_spec.cc b/paludis/elike_package_dep_spec.cc
index 96d82e2..17e2f2b 100644
--- a/paludis/elike_package_dep_spec.cc
+++ b/paludis/elike_package_dep_spec.cc
@@ -86,7 +86,7 @@ paludis::elike_check_sanity(const std::string & s)
 bool
 paludis::elike_remove_trailing_square_bracket_if_exists(std::string & s, PartiallyMadePackageDepSpec & result,
         const ELikePackageDepSpecOptions & options, bool & had_bracket_version_requirements,
-        const std::tr1::shared_ptr<const PackageID> & id)
+        bool & had_use_requirements, const std::tr1::shared_ptr<const PackageID> & id)
 {
     std::string::size_type use_group_p;
     if (std::string::npos == ((use_group_p = s.rfind('['))))
@@ -143,6 +143,7 @@ paludis::elike_remove_trailing_square_bracket_if_exists(std::string & s, Partial
                     opos = flag.find_first_of("|&");
                     if (std::string::npos == opos)
                     {
+
                         ver = flag;
                         flag.clear();
                     }
@@ -178,31 +179,38 @@ paludis::elike_remove_trailing_square_bracket_if_exists(std::string & s, Partial
             break;
 
         default:
-            if (options[epdso_allow_use_deps_portage] || ! options[epdso_allow_use_deps])
+            if (! options[epdso_allow_use_deps] && ! options[epdso_allow_use_deps_portage])
             {
-                if (! options[epdso_allow_use_deps_portage])
+                if (options[epdso_strict_parsing])
+                    throw PackageDepSpecError("USE dependencies not safe for use here");
+                else
                 {
-                    if (options[epdso_strict_parsing])
-                        throw PackageDepSpecError("USE dependencies not safe for use here");
-                    else
-                    {
-                        // Use Portage syntax for this case, as it
-                        // should only happen in Gentoo EAPIs
-                        Log::get_instance()->message("e.package_dep_spec.use_not_allowed", ll_warning, lc_context)
-                            << "USE dependencies not safe for use here";
-                    }
+                    Log::get_instance()->message("e.package_dep_spec.use_not_allowed", ll_warning, lc_context)
+                        << "USE dependencies not safe for use here";
                 }
-
-                std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req(parse_elike_use_requirement(flag,
-                            id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_portage_syntax));
-                result.additional_requirement(req);
             }
-            else
+
+            if (! options[epdso_allow_use_deps] && had_use_requirements)
             {
-                std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req(parse_elike_use_requirement(flag,
-                            id, ELikeUseRequirementOptions() + euro_allow_self_deps));
-                result.additional_requirement(req);
+                if (options[epdso_strict_parsing])
+                    throw PackageDepSpecError("multiple sets of USE dependencies not safe for use here");
+                else
+                {
+                    Log::get_instance()->message("e.package_dep_spec.use_multiple_not_allowed", ll_warning, lc_context)
+                        << "multiple sets of USE dependencies not safe for use here";
+                }
             }
+            had_use_requirements = true;
+
+            ELikeUseRequirementOptions euro;
+            euro += euro_allow_self_deps;
+            if (options[epdso_allow_use_deps_portage])
+                euro += options[epdso_allow_use_deps] ? euro_both_syntaxes : euro_portage_syntax;
+            if (options[epdso_strict_parsing])
+                euro += euro_strict_parsing;
+
+            std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req(parse_elike_use_requirement(flag, id, euro));
+            result.additional_requirement(req);
 
             break;
     };
@@ -428,7 +436,7 @@ paludis::partial_parse_elike_package_dep_spec(
 
     Context context("When parsing elike package dep spec '" + ss + "':");
 
-    bool had_bracket_version_requirements(false);
+    bool had_bracket_version_requirements(false), had_use_requirements(false);
 
     return partial_parse_generic_elike_package_dep_spec(ss, make_named_values<GenericELikePackageDepSpecParseFunctions>(
                 value_for<n::add_package_requirement>(std::tr1::bind(&elike_add_package_requirement, _1, _2)),
@@ -441,7 +449,7 @@ paludis::partial_parse_elike_package_dep_spec(
                 value_for<n::remove_trailing_repo_if_exists>(std::tr1::bind(&elike_remove_trailing_repo_if_exists, _1, _2, options)),
                 value_for<n::remove_trailing_slot_if_exists>(std::tr1::bind(&elike_remove_trailing_slot_if_exists, _1, _2, options)),
                 value_for<n::remove_trailing_square_bracket_if_exists>(std::tr1::bind(&elike_remove_trailing_square_bracket_if_exists,
-                        _1, _2, options, std::tr1::ref(had_bracket_version_requirements), id))
+                        _1, _2, options, std::tr1::ref(had_bracket_version_requirements), std::tr1::ref(had_use_requirements), id))
                 ));
 }
 
diff --git a/paludis/elike_use_requirement.cc b/paludis/elike_use_requirement.cc
index acac8eb..d3ae113 100644
--- a/paludis/elike_use_requirement.cc
+++ b/paludis/elike_use_requirement.cc
@@ -23,6 +23,7 @@
 #include <paludis/util/stringify.hh>
 #include <paludis/util/join.hh>
 #include <paludis/util/tokeniser.hh>
+#include <paludis/util/log.hh>
 #include <paludis/dep_spec.hh>
 #include <paludis/name.hh>
 #include <paludis/environment.hh>
@@ -278,10 +279,35 @@ namespace
             flag.erase(flag.length() - 1);
             if (flag.empty())
                 throw ELikeUseRequirementError(s, "Invalid [] contents");
-            std::string::size_type not_position(options[euro_portage_syntax] ? 0 : flag.length() - 1);
-            if ('!' == flag.at(not_position))
+
+            if ('!' == flag.at(flag.length() - 1))
+            {
+                if (options[euro_portage_syntax] && ! options[euro_both_syntaxes])
+                {
+                    if (options[euro_strict_parsing])
+                        throw ELikeUseRequirementError(s, "[use!=] not safe for use here");
+                    else
+                        Log::get_instance()->message("e.use_requirement.flag_not_equal_not_allowed", ll_warning, lc_context)
+                            << "[use!=] not safe for use here";
+                }
+
+                flag.erase(flag.length() - 1, 1);
+                if (flag.empty())
+                    throw ELikeUseRequirementError(s, "Invalid [] contents");
+                return make_shared_ptr(new NotEqualUseRequirement(UseFlagName(flag), id));
+            }
+            else if ('!' == flag.at(0))
             {
-                flag.erase(not_position, 1);
+                if (! options[euro_portage_syntax] && ! options[euro_both_syntaxes])
+                {
+                    if (options[euro_strict_parsing])
+                        throw ELikeUseRequirementError(s, "[!use=] not safe for use here");
+                    else
+                        Log::get_instance()->message("e.use_requirement.not_flag_equal_not_allowed", ll_warning, lc_context)
+                            << "[!use=] not safe for use here";
+                }
+
+                flag.erase(0, 1);
                 if (flag.empty())
                     throw ELikeUseRequirementError(s, "Invalid [] contents");
                 return make_shared_ptr(new NotEqualUseRequirement(UseFlagName(flag), id));
@@ -297,16 +323,24 @@ namespace
             flag.erase(flag.length() - 1);
             if (flag.empty())
                 throw ELikeUseRequirementError(s, "Invalid [] contents");
-            std::string::size_type not_position(options[euro_portage_syntax] ? 0 : flag.length() - 1);
-            if ('!' == flag.at(not_position))
+
+            if ('!' == flag.at(flag.length() - 1))
             {
-                flag.erase(not_position, 1);
+                flag.erase(flag.length() - 1, 1);
                 if (flag.empty())
                     throw ELikeUseRequirementError(s, "Invalid [] contents");
-                if (options[euro_portage_syntax])
-                    return make_shared_ptr(new IfNotMineThenNotUseRequirement(UseFlagName(flag), id));
-                else if ('-' == flag.at(0))
+
+                if ('-' == flag.at(0))
                 {
+                    if (options[euro_portage_syntax] && ! options[euro_both_syntaxes])
+                    {
+                        if (options[euro_strict_parsing])
+                            throw ELikeUseRequirementError(s, "[-use!?] not safe for use here");
+                        else
+                            Log::get_instance()->message("e.use_requirement.minus_flag_not_question_not_allowed", ll_warning, lc_context)
+                                << "[-use!?] not safe for use here";
+                    }
+
                     flag.erase(0, 1);
                     if (flag.empty())
                         throw ELikeUseRequirementError(s, "Invalid [] contents");
@@ -314,12 +348,49 @@ namespace
                     return make_shared_ptr(new IfNotMineThenNotUseRequirement(UseFlagName(flag), id));
                 }
                 else
+                {
+                    if (options[euro_portage_syntax] && ! options[euro_both_syntaxes])
+                    {
+                        if (options[euro_strict_parsing])
+                            throw ELikeUseRequirementError(s, "[use!?] not safe for use here");
+                        else
+                            Log::get_instance()->message("e.use_requirement.flag_not_question_not_allowed", ll_warning, lc_context)
+                                << "[use!?] not safe for use here";
+                    }
+
                     return make_shared_ptr(new IfNotMineThenUseRequirement(UseFlagName(flag), id));
+                }
+            }
+            else if ('!' == flag.at(0))
+            {
+                if (! options[euro_portage_syntax] && ! options[euro_both_syntaxes])
+                {
+                    if (options[euro_strict_parsing])
+                        throw ELikeUseRequirementError(s, "[!use?] not safe for use here");
+                    else
+                        Log::get_instance()->message("e.use_requirement.not_flag_question_not_allowed", ll_warning, lc_context)
+                            << "[!use?] not safe for use here";
+                }
+
+                flag.erase(0, 1);
+                if (flag.empty())
+                    throw ELikeUseRequirementError(s, "Invalid [] contents");
+
+                return make_shared_ptr(new IfNotMineThenNotUseRequirement(UseFlagName(flag), id));
             }
             else
             {
-                if (! options[euro_portage_syntax] && '-' == flag.at(0))
+                if ('-' == flag.at(0))
                 {
+                    if (options[euro_portage_syntax] && ! options[euro_both_syntaxes])
+                    {
+                        if (options[euro_strict_parsing])
+                            throw ELikeUseRequirementError(s, "[-use?] not safe for use here");
+                        else
+                            Log::get_instance()->message("e.use_requirement.minus_flag_question_not_allowed", ll_warning, lc_context)
+                                << "[-use?] not safe for use here";
+                    }
+
                     flag.erase(0, 1);
                     if (flag.empty())
                         throw ELikeUseRequirementError(s, "Invalid [] contents");
@@ -354,23 +425,25 @@ paludis::parse_elike_use_requirement(const std::string & s,
     Context context("When parsing use requirement '" + s + "':");
 
     std::tr1::shared_ptr<UseRequirements> result(new UseRequirements("[" + s + "]"));
-    if (options[euro_portage_syntax])
+    std::string::size_type pos(0);
+    for (;;)
     {
-        std::string::size_type pos(0);
-        for (;;)
+        std::string::size_type comma(s.find(',', pos));
+        std::string flag(s.substr(pos, std::string::npos == comma ? comma : comma - pos));
+        result->add_requirement(parse_one_use_requirement(s, flag, id, options));
+        if (std::string::npos == comma)
+            break;
+
+        if (! options[euro_portage_syntax] && ! options[euro_both_syntaxes])
         {
-            std::string::size_type comma(s.find(',', pos));
-            std::string flag(s.substr(pos, std::string::npos == comma ? comma : comma - pos));
-            result->add_requirement(parse_one_use_requirement(s, flag, id, options));
-            if (std::string::npos == comma)
-                break;
-            pos = comma + 1;
+            if (options[euro_strict_parsing])
+                throw ELikeUseRequirementError(s, "[use,use] not safe for use here");
+            else
+                Log::get_instance()->message("e.use_requirement.comma_separated_not_allowed", ll_warning, lc_context)
+                    << "[use,use] not safe for use here";
         }
-    }
-    else
-    {
-        std::string flag(s);
-        result->add_requirement(parse_one_use_requirement(s, flag, id, options));
+
+        pos = comma + 1;
     }
 
     return result;
diff --git a/paludis/elike_use_requirement.se b/paludis/elike_use_requirement.se
index 4e61a01..cdda575 100644
--- a/paludis/elike_use_requirement.se
+++ b/paludis/elike_use_requirement.se
@@ -8,5 +8,7 @@ make_enum_ELikeUseRequirementOption()
 
     key euro_allow_self_deps          "Allow self-dependent use deps"
     key euro_portage_syntax           "Parse using Portage syntax"
+    key euro_both_syntaxes            "Accept both Portage and Paludis syntax"
+    key euro_strict_parsing           "Error rather than warn for violations"
 }
 
diff --git a/paludis/elike_use_requirement_TEST.cc b/paludis/elike_use_requirement_TEST.cc
index 62d9e5c..02d21ca 100644
--- a/paludis/elike_use_requirement_TEST.cc
+++ b/paludis/elike_use_requirement_TEST.cc
@@ -44,25 +44,25 @@ namespace test_cases
             id->iuse_key()->set_from_string("enabled disabled", IUseFlagParseOptions());
 
             std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req1(
-                parse_elike_use_requirement("enabled", std::tr1::shared_ptr<const PackageID>(), ELikeUseRequirementOptions()));
+                parse_elike_use_requirement("enabled", std::tr1::shared_ptr<const PackageID>(), ELikeUseRequirementOptions() + euro_strict_parsing));
             TEST_CHECK_EQUAL(req1->as_raw_string(), "[enabled]");
             TEST_CHECK_EQUAL(req1->as_human_string(), "Flag 'enabled' enabled");
             TEST_CHECK(req1->requirement_met(&env, *id));
 
             std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req2(
-                parse_elike_use_requirement("disabled", std::tr1::shared_ptr<const PackageID>(), ELikeUseRequirementOptions()));
+                parse_elike_use_requirement("disabled", std::tr1::shared_ptr<const PackageID>(), ELikeUseRequirementOptions() + euro_strict_parsing));
             TEST_CHECK_EQUAL(req2->as_raw_string(), "[disabled]");
             TEST_CHECK_EQUAL(req2->as_human_string(), "Flag 'disabled' enabled");
             TEST_CHECK(! req2->requirement_met(&env, *id));
 
             std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req3(
-                parse_elike_use_requirement("-enabled", std::tr1::shared_ptr<const PackageID>(), ELikeUseRequirementOptions()));
+                parse_elike_use_requirement("-enabled", std::tr1::shared_ptr<const PackageID>(), ELikeUseRequirementOptions() + euro_strict_parsing));
             TEST_CHECK_EQUAL(req3->as_raw_string(), "[-enabled]");
             TEST_CHECK_EQUAL(req3->as_human_string(), "Flag 'enabled' disabled");
             TEST_CHECK(! req3->requirement_met(&env, *id));
 
             std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req4(
-                parse_elike_use_requirement("-disabled", std::tr1::shared_ptr<const PackageID>(), ELikeUseRequirementOptions()));
+                parse_elike_use_requirement("-disabled", std::tr1::shared_ptr<const PackageID>(), ELikeUseRequirementOptions() + euro_strict_parsing));
             TEST_CHECK_EQUAL(req4->as_raw_string(), "[-disabled]");
             TEST_CHECK_EQUAL(req4->as_human_string(), "Flag 'disabled' disabled");
             TEST_CHECK(req4->requirement_met(&env, *id));
@@ -82,25 +82,25 @@ namespace test_cases
             id->iuse_key()->set_from_string("enabled disabled", IUseFlagParseOptions());
 
             std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req1(
-                parse_elike_use_requirement("enabled", std::tr1::shared_ptr<const PackageID>(), ELikeUseRequirementOptions() + euro_portage_syntax));
+                parse_elike_use_requirement("enabled", std::tr1::shared_ptr<const PackageID>(), ELikeUseRequirementOptions() + euro_portage_syntax + euro_strict_parsing));
             TEST_CHECK_EQUAL(req1->as_raw_string(), "[enabled]");
             TEST_CHECK_EQUAL(req1->as_human_string(), "Flag 'enabled' enabled");
             TEST_CHECK(req1->requirement_met(&env, *id));
 
             std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req2(
-                parse_elike_use_requirement("disabled", std::tr1::shared_ptr<const PackageID>(), ELikeUseRequirementOptions() + euro_portage_syntax));
+                parse_elike_use_requirement("disabled", std::tr1::shared_ptr<const PackageID>(), ELikeUseRequirementOptions() + euro_portage_syntax + euro_strict_parsing));
             TEST_CHECK_EQUAL(req2->as_raw_string(), "[disabled]");
             TEST_CHECK_EQUAL(req2->as_human_string(), "Flag 'disabled' enabled");
             TEST_CHECK(! req2->requirement_met(&env, *id));
 
             std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req3(
-                parse_elike_use_requirement("-enabled", std::tr1::shared_ptr<const PackageID>(), ELikeUseRequirementOptions() + euro_portage_syntax));
+                parse_elike_use_requirement("-enabled", std::tr1::shared_ptr<const PackageID>(), ELikeUseRequirementOptions() + euro_portage_syntax + euro_strict_parsing));
             TEST_CHECK_EQUAL(req3->as_raw_string(), "[-enabled]");
             TEST_CHECK_EQUAL(req3->as_human_string(), "Flag 'enabled' disabled");
             TEST_CHECK(! req3->requirement_met(&env, *id));
 
             std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req4(
-                parse_elike_use_requirement("-disabled", std::tr1::shared_ptr<const PackageID>(), ELikeUseRequirementOptions() + euro_portage_syntax));
+                parse_elike_use_requirement("-disabled", std::tr1::shared_ptr<const PackageID>(), ELikeUseRequirementOptions() + euro_portage_syntax + euro_strict_parsing));
             TEST_CHECK_EQUAL(req4->as_raw_string(), "[-disabled]");
             TEST_CHECK_EQUAL(req4->as_human_string(), "Flag 'disabled' disabled");
             TEST_CHECK(req4->requirement_met(&env, *id));
@@ -120,31 +120,31 @@ namespace test_cases
             id->iuse_key()->set_from_string("enabled disabled", IUseFlagParseOptions());
 
             std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req1(
-                parse_elike_use_requirement("enabled,-disabled", std::tr1::shared_ptr<const PackageID>(), ELikeUseRequirementOptions() + euro_portage_syntax));
+                parse_elike_use_requirement("enabled,-disabled", std::tr1::shared_ptr<const PackageID>(), ELikeUseRequirementOptions() + euro_portage_syntax + euro_strict_parsing));
             TEST_CHECK_EQUAL(req1->as_raw_string(), "[enabled,-disabled]");
             TEST_CHECK_EQUAL(req1->as_human_string(), "Flag 'enabled' enabled; Flag 'disabled' disabled");
             TEST_CHECK(req1->requirement_met(&env, *id));
 
             std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req2(
-                parse_elike_use_requirement("enabled,disabled", std::tr1::shared_ptr<const PackageID>(), ELikeUseRequirementOptions() + euro_portage_syntax));
+                parse_elike_use_requirement("enabled,disabled", std::tr1::shared_ptr<const PackageID>(), ELikeUseRequirementOptions() + euro_portage_syntax + euro_strict_parsing));
             TEST_CHECK_EQUAL(req2->as_raw_string(), "[enabled,disabled]");
             TEST_CHECK_EQUAL(req2->as_human_string(), "Flag 'enabled' enabled; Flag 'disabled' enabled");
             TEST_CHECK(! req2->requirement_met(&env, *id));
 
             std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req3(
-                parse_elike_use_requirement("-enabled,-disabled", std::tr1::shared_ptr<const PackageID>(), ELikeUseRequirementOptions() + euro_portage_syntax));
+                parse_elike_use_requirement("-enabled,-disabled", std::tr1::shared_ptr<const PackageID>(), ELikeUseRequirementOptions() + euro_portage_syntax + euro_strict_parsing));
             TEST_CHECK_EQUAL(req3->as_raw_string(), "[-enabled,-disabled]");
             TEST_CHECK_EQUAL(req3->as_human_string(), "Flag 'enabled' disabled; Flag 'disabled' disabled");
             TEST_CHECK(! req3->requirement_met(&env, *id));
 
             std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req4(
-                parse_elike_use_requirement("enabled,-disabled,-enabled", std::tr1::shared_ptr<const PackageID>(), ELikeUseRequirementOptions() + euro_portage_syntax));
+                parse_elike_use_requirement("enabled,-disabled,-enabled", std::tr1::shared_ptr<const PackageID>(), ELikeUseRequirementOptions() + euro_portage_syntax + euro_strict_parsing));
             TEST_CHECK_EQUAL(req4->as_raw_string(), "[enabled,-disabled,-enabled]");
             TEST_CHECK_EQUAL(req4->as_human_string(), "Flag 'enabled' enabled; Flag 'disabled' disabled; Flag 'enabled' disabled");
             TEST_CHECK(! req4->requirement_met(&env, *id));
 
             std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req5(
-                parse_elike_use_requirement("enabled,-disabled,enabled", std::tr1::shared_ptr<const PackageID>(), ELikeUseRequirementOptions() + euro_portage_syntax));
+                parse_elike_use_requirement("enabled,-disabled,enabled", std::tr1::shared_ptr<const PackageID>(), ELikeUseRequirementOptions() + euro_portage_syntax + euro_strict_parsing));
             TEST_CHECK_EQUAL(req5->as_raw_string(), "[enabled,-disabled,enabled]");
             TEST_CHECK_EQUAL(req5->as_human_string(), "Flag 'enabled' enabled; Flag 'disabled' disabled; Flag 'enabled' enabled");
             TEST_CHECK(req5->requirement_met(&env, *id));
@@ -166,84 +166,84 @@ namespace test_cases
             id2->iuse_key()->set_from_string("pkgname", IUseFlagParseOptions());
 
             std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req1(
-                parse_elike_use_requirement("pkgname?", id, ELikeUseRequirementOptions() + euro_allow_self_deps));
+                parse_elike_use_requirement("pkgname?", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_strict_parsing));
             TEST_CHECK_EQUAL(req1->as_raw_string(), "[pkgname?]");
             TEST_CHECK_EQUAL(req1->as_human_string(), "Flag 'pkgname' enabled if it is enabled for 'cat/enabled-1:0::fake'");
             TEST_CHECK(req1->requirement_met(&env, *id));
             TEST_CHECK(! req1->requirement_met(&env, *id2));
 
             std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req2(
-                parse_elike_use_requirement("pkgname?", id2, ELikeUseRequirementOptions() + euro_allow_self_deps));
+                parse_elike_use_requirement("pkgname?", id2, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_strict_parsing));
             TEST_CHECK_EQUAL(req2->as_raw_string(), "[pkgname?]");
             TEST_CHECK_EQUAL(req2->as_human_string(), "Flag 'pkgname' enabled if it is enabled for 'cat/disabled-1:0::fake'");
             TEST_CHECK(req2->requirement_met(&env, *id));
             TEST_CHECK(req2->requirement_met(&env, *id2));
 
             std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req3(
-                parse_elike_use_requirement("-pkgname?", id, ELikeUseRequirementOptions() + euro_allow_self_deps));
+                parse_elike_use_requirement("-pkgname?", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_strict_parsing));
             TEST_CHECK_EQUAL(req3->as_raw_string(), "[-pkgname?]");
             TEST_CHECK_EQUAL(req3->as_human_string(), "Flag 'pkgname' disabled if it is enabled for 'cat/enabled-1:0::fake'");
             TEST_CHECK(! req3->requirement_met(&env, *id));
             TEST_CHECK(req3->requirement_met(&env, *id2));
 
             std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req4(
-                parse_elike_use_requirement("-pkgname?", id2, ELikeUseRequirementOptions() + euro_allow_self_deps));
+                parse_elike_use_requirement("-pkgname?", id2, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_strict_parsing));
             TEST_CHECK_EQUAL(req4->as_raw_string(), "[-pkgname?]");
             TEST_CHECK_EQUAL(req4->as_human_string(), "Flag 'pkgname' disabled if it is enabled for 'cat/disabled-1:0::fake'");
             TEST_CHECK(req4->requirement_met(&env, *id));
             TEST_CHECK(req4->requirement_met(&env, *id2));
 
             std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req5(
-                parse_elike_use_requirement("pkgname!?", id, ELikeUseRequirementOptions() + euro_allow_self_deps));
+                parse_elike_use_requirement("pkgname!?", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_strict_parsing));
             TEST_CHECK_EQUAL(req5->as_raw_string(), "[pkgname!?]");
             TEST_CHECK_EQUAL(req5->as_human_string(), "Flag 'pkgname' enabled if it is disabled for 'cat/enabled-1:0::fake'");
             TEST_CHECK(req5->requirement_met(&env, *id));
             TEST_CHECK(req5->requirement_met(&env, *id2));
 
             std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req6(
-                parse_elike_use_requirement("pkgname!?", id2, ELikeUseRequirementOptions() + euro_allow_self_deps));
+                parse_elike_use_requirement("pkgname!?", id2, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_strict_parsing));
             TEST_CHECK_EQUAL(req6->as_raw_string(), "[pkgname!?]");
             TEST_CHECK_EQUAL(req6->as_human_string(), "Flag 'pkgname' enabled if it is disabled for 'cat/disabled-1:0::fake'");
             TEST_CHECK(req6->requirement_met(&env, *id));
             TEST_CHECK(! req6->requirement_met(&env, *id2));
 
             std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req7(
-                parse_elike_use_requirement("-pkgname!?", id, ELikeUseRequirementOptions() + euro_allow_self_deps));
+                parse_elike_use_requirement("-pkgname!?", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_strict_parsing));
             TEST_CHECK_EQUAL(req7->as_raw_string(), "[-pkgname!?]");
             TEST_CHECK_EQUAL(req7->as_human_string(), "Flag 'pkgname' disabled if it is disabled for 'cat/enabled-1:0::fake'");
             TEST_CHECK(req7->requirement_met(&env, *id));
             TEST_CHECK(req7->requirement_met(&env, *id2));
 
             std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req8(
-                parse_elike_use_requirement("-pkgname!?", id2, ELikeUseRequirementOptions() + euro_allow_self_deps));
+                parse_elike_use_requirement("-pkgname!?", id2, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_strict_parsing));
             TEST_CHECK_EQUAL(req8->as_raw_string(), "[-pkgname!?]");
             TEST_CHECK_EQUAL(req8->as_human_string(), "Flag 'pkgname' disabled if it is disabled for 'cat/disabled-1:0::fake'");
             TEST_CHECK(! req8->requirement_met(&env, *id));
             TEST_CHECK(req8->requirement_met(&env, *id2));
 
             std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req9(
-                parse_elike_use_requirement("pkgname=", id, ELikeUseRequirementOptions() + euro_allow_self_deps));
+                parse_elike_use_requirement("pkgname=", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_strict_parsing));
             TEST_CHECK_EQUAL(req9->as_raw_string(), "[pkgname=]");
             TEST_CHECK_EQUAL(req9->as_human_string(), "Flag 'pkgname' enabled or disabled like it is for 'cat/enabled-1:0::fake'");
             TEST_CHECK(req9->requirement_met(&env, *id));
             TEST_CHECK(! req9->requirement_met(&env, *id2));
 
             std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req10(
-                parse_elike_use_requirement("pkgname=", id2, ELikeUseRequirementOptions() + euro_allow_self_deps));
+                parse_elike_use_requirement("pkgname=", id2, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_strict_parsing));
             TEST_CHECK_EQUAL(req10->as_raw_string(), "[pkgname=]");
             TEST_CHECK_EQUAL(req10->as_human_string(), "Flag 'pkgname' enabled or disabled like it is for 'cat/disabled-1:0::fake'");
             TEST_CHECK(! req10->requirement_met(&env, *id));
             TEST_CHECK(req10->requirement_met(&env, *id2));
 
             std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req11(
-                parse_elike_use_requirement("pkgname!=", id, ELikeUseRequirementOptions() + euro_allow_self_deps));
+                parse_elike_use_requirement("pkgname!=", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_strict_parsing));
             TEST_CHECK_EQUAL(req11->as_raw_string(), "[pkgname!=]");
             TEST_CHECK_EQUAL(req11->as_human_string(), "Flag 'pkgname' enabled or disabled opposite to how it is for 'cat/enabled-1:0::fake'");
             TEST_CHECK(! req11->requirement_met(&env, *id));
             TEST_CHECK(req11->requirement_met(&env, *id2));
 
             std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req12(
-                parse_elike_use_requirement("pkgname!=", id2, ELikeUseRequirementOptions() + euro_allow_self_deps));
+                parse_elike_use_requirement("pkgname!=", id2, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_strict_parsing));
             TEST_CHECK_EQUAL(req12->as_raw_string(), "[pkgname!=]");
             TEST_CHECK_EQUAL(req12->as_human_string(), "Flag 'pkgname' enabled or disabled opposite to how it is for 'cat/disabled-1:0::fake'");
             TEST_CHECK(req12->requirement_met(&env, *id));
@@ -266,56 +266,56 @@ namespace test_cases
             id2->iuse_key()->set_from_string("pkgname", IUseFlagParseOptions());
 
             std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req1(
-                parse_elike_use_requirement("pkgname?", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_portage_syntax));
+                parse_elike_use_requirement("pkgname?", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_portage_syntax + euro_strict_parsing));
             TEST_CHECK_EQUAL(req1->as_raw_string(), "[pkgname?]");
             TEST_CHECK_EQUAL(req1->as_human_string(), "Flag 'pkgname' enabled if it is enabled for 'cat/enabled-1:0::fake'");
             TEST_CHECK(req1->requirement_met(&env, *id));
             TEST_CHECK(! req1->requirement_met(&env, *id2));
 
             std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req2(
-                parse_elike_use_requirement("pkgname?", id2, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_portage_syntax));
+                parse_elike_use_requirement("pkgname?", id2, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_portage_syntax + euro_strict_parsing));
             TEST_CHECK_EQUAL(req2->as_raw_string(), "[pkgname?]");
             TEST_CHECK_EQUAL(req2->as_human_string(), "Flag 'pkgname' enabled if it is enabled for 'cat/disabled-1:0::fake'");
             TEST_CHECK(req2->requirement_met(&env, *id));
             TEST_CHECK(req2->requirement_met(&env, *id2));
 
             std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req7(
-                parse_elike_use_requirement("!pkgname?", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_portage_syntax));
+                parse_elike_use_requirement("!pkgname?", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_portage_syntax + euro_strict_parsing));
             TEST_CHECK_EQUAL(req7->as_raw_string(), "[!pkgname?]");
             TEST_CHECK_EQUAL(req7->as_human_string(), "Flag 'pkgname' disabled if it is disabled for 'cat/enabled-1:0::fake'");
             TEST_CHECK(req7->requirement_met(&env, *id));
             TEST_CHECK(req7->requirement_met(&env, *id2));
 
             std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req8(
-                parse_elike_use_requirement("!pkgname?", id2, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_portage_syntax));
+                parse_elike_use_requirement("!pkgname?", id2, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_portage_syntax + euro_strict_parsing));
             TEST_CHECK_EQUAL(req8->as_raw_string(), "[!pkgname?]");
             TEST_CHECK_EQUAL(req8->as_human_string(), "Flag 'pkgname' disabled if it is disabled for 'cat/disabled-1:0::fake'");
             TEST_CHECK(! req8->requirement_met(&env, *id));
             TEST_CHECK(req8->requirement_met(&env, *id2));
 
             std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req9(
-                parse_elike_use_requirement("pkgname=", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_portage_syntax));
+                parse_elike_use_requirement("pkgname=", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_portage_syntax + euro_strict_parsing));
             TEST_CHECK_EQUAL(req9->as_raw_string(), "[pkgname=]");
             TEST_CHECK_EQUAL(req9->as_human_string(), "Flag 'pkgname' enabled or disabled like it is for 'cat/enabled-1:0::fake'");
             TEST_CHECK(req9->requirement_met(&env, *id));
             TEST_CHECK(! req9->requirement_met(&env, *id2));
 
             std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req10(
-                parse_elike_use_requirement("pkgname=", id2, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_portage_syntax));
+                parse_elike_use_requirement("pkgname=", id2, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_portage_syntax + euro_strict_parsing));
             TEST_CHECK_EQUAL(req10->as_raw_string(), "[pkgname=]");
             TEST_CHECK_EQUAL(req10->as_human_string(), "Flag 'pkgname' enabled or disabled like it is for 'cat/disabled-1:0::fake'");
             TEST_CHECK(! req10->requirement_met(&env, *id));
             TEST_CHECK(req10->requirement_met(&env, *id2));
 
             std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req11(
-                parse_elike_use_requirement("!pkgname=", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_portage_syntax));
+                parse_elike_use_requirement("!pkgname=", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_portage_syntax + euro_strict_parsing));
             TEST_CHECK_EQUAL(req11->as_raw_string(), "[!pkgname=]");
             TEST_CHECK_EQUAL(req11->as_human_string(), "Flag 'pkgname' enabled or disabled opposite to how it is for 'cat/enabled-1:0::fake'");
             TEST_CHECK(! req11->requirement_met(&env, *id));
             TEST_CHECK(req11->requirement_met(&env, *id2));
 
             std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req12(
-                parse_elike_use_requirement("!pkgname=", id2, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_portage_syntax));
+                parse_elike_use_requirement("!pkgname=", id2, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_portage_syntax + euro_strict_parsing));
             TEST_CHECK_EQUAL(req12->as_raw_string(), "[!pkgname=]");
             TEST_CHECK_EQUAL(req12->as_human_string(), "Flag 'pkgname' enabled or disabled opposite to how it is for 'cat/disabled-1:0::fake'");
             TEST_CHECK(req12->requirement_met(&env, *id));
@@ -323,6 +323,134 @@ namespace test_cases
         }
     } test_complex_use_requirements_portage_syntax;
 
+    struct ComplexUseRequirementsBothSyntaxesTest : TestCase
+    {
+        ComplexUseRequirementsBothSyntaxesTest() : TestCase("complex use requirements both syntaxes") { }
+
+        void run()
+        {
+            TestEnvironment env;
+            std::tr1::shared_ptr<FakeRepository> fake(new FakeRepository(&env, RepositoryName("fake")));
+            env.package_database()->add_repository(1, fake);
+            std::tr1::shared_ptr<FakePackageID> id(fake->add_version("cat", "enabled", "1"));
+            id->iuse_key()->set_from_string("pkgname", IUseFlagParseOptions());
+            std::tr1::shared_ptr<FakePackageID> id2(fake->add_version("cat", "disabled", "1"));
+            id2->iuse_key()->set_from_string("pkgname", IUseFlagParseOptions());
+
+            std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req1(
+                parse_elike_use_requirement("pkgname?", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_both_syntaxes + euro_strict_parsing));
+            TEST_CHECK_EQUAL(req1->as_raw_string(), "[pkgname?]");
+            TEST_CHECK_EQUAL(req1->as_human_string(), "Flag 'pkgname' enabled if it is enabled for 'cat/enabled-1:0::fake'");
+            TEST_CHECK(req1->requirement_met(&env, *id));
+            TEST_CHECK(! req1->requirement_met(&env, *id2));
+
+            std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req2(
+                parse_elike_use_requirement("pkgname?", id2, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_both_syntaxes + euro_strict_parsing));
+            TEST_CHECK_EQUAL(req2->as_raw_string(), "[pkgname?]");
+            TEST_CHECK_EQUAL(req2->as_human_string(), "Flag 'pkgname' enabled if it is enabled for 'cat/disabled-1:0::fake'");
+            TEST_CHECK(req2->requirement_met(&env, *id));
+            TEST_CHECK(req2->requirement_met(&env, *id2));
+
+            std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req7(
+                parse_elike_use_requirement("!pkgname?", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_both_syntaxes + euro_strict_parsing));
+            TEST_CHECK_EQUAL(req7->as_raw_string(), "[!pkgname?]");
+            TEST_CHECK_EQUAL(req7->as_human_string(), "Flag 'pkgname' disabled if it is disabled for 'cat/enabled-1:0::fake'");
+            TEST_CHECK(req7->requirement_met(&env, *id));
+            TEST_CHECK(req7->requirement_met(&env, *id2));
+
+            std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req8(
+                parse_elike_use_requirement("!pkgname?", id2, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_both_syntaxes + euro_strict_parsing));
+            TEST_CHECK_EQUAL(req8->as_raw_string(), "[!pkgname?]");
+            TEST_CHECK_EQUAL(req8->as_human_string(), "Flag 'pkgname' disabled if it is disabled for 'cat/disabled-1:0::fake'");
+            TEST_CHECK(! req8->requirement_met(&env, *id));
+            TEST_CHECK(req8->requirement_met(&env, *id2));
+
+            std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req9(
+                parse_elike_use_requirement("pkgname=", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_both_syntaxes + euro_strict_parsing));
+            TEST_CHECK_EQUAL(req9->as_raw_string(), "[pkgname=]");
+            TEST_CHECK_EQUAL(req9->as_human_string(), "Flag 'pkgname' enabled or disabled like it is for 'cat/enabled-1:0::fake'");
+            TEST_CHECK(req9->requirement_met(&env, *id));
+            TEST_CHECK(! req9->requirement_met(&env, *id2));
+
+            std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req10(
+                parse_elike_use_requirement("pkgname=", id2, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_both_syntaxes + euro_strict_parsing));
+            TEST_CHECK_EQUAL(req10->as_raw_string(), "[pkgname=]");
+            TEST_CHECK_EQUAL(req10->as_human_string(), "Flag 'pkgname' enabled or disabled like it is for 'cat/disabled-1:0::fake'");
+            TEST_CHECK(! req10->requirement_met(&env, *id));
+            TEST_CHECK(req10->requirement_met(&env, *id2));
+
+            std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req11(
+                parse_elike_use_requirement("!pkgname=", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_both_syntaxes + euro_strict_parsing));
+            TEST_CHECK_EQUAL(req11->as_raw_string(), "[!pkgname=]");
+            TEST_CHECK_EQUAL(req11->as_human_string(), "Flag 'pkgname' enabled or disabled opposite to how it is for 'cat/enabled-1:0::fake'");
+            TEST_CHECK(! req11->requirement_met(&env, *id));
+            TEST_CHECK(req11->requirement_met(&env, *id2));
+
+            std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req12(
+                parse_elike_use_requirement("!pkgname=", id2, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_both_syntaxes + euro_strict_parsing));
+            TEST_CHECK_EQUAL(req12->as_raw_string(), "[!pkgname=]");
+            TEST_CHECK_EQUAL(req12->as_human_string(), "Flag 'pkgname' enabled or disabled opposite to how it is for 'cat/disabled-1:0::fake'");
+            TEST_CHECK(req12->requirement_met(&env, *id));
+            TEST_CHECK(! req12->requirement_met(&env, *id2));
+
+            std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req13(
+                parse_elike_use_requirement("-pkgname?", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_both_syntaxes + euro_strict_parsing));
+            TEST_CHECK_EQUAL(req13->as_raw_string(), "[-pkgname?]");
+            TEST_CHECK_EQUAL(req13->as_human_string(), "Flag 'pkgname' disabled if it is enabled for 'cat/enabled-1:0::fake'");
+            TEST_CHECK(! req13->requirement_met(&env, *id));
+            TEST_CHECK(req13->requirement_met(&env, *id2));
+
+            std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req14(
+                parse_elike_use_requirement("-pkgname?", id2, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_both_syntaxes + euro_strict_parsing));
+            TEST_CHECK_EQUAL(req14->as_raw_string(), "[-pkgname?]");
+            TEST_CHECK_EQUAL(req14->as_human_string(), "Flag 'pkgname' disabled if it is enabled for 'cat/disabled-1:0::fake'");
+            TEST_CHECK(req14->requirement_met(&env, *id));
+            TEST_CHECK(req14->requirement_met(&env, *id2));
+
+            std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req15(
+                parse_elike_use_requirement("pkgname!?", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_both_syntaxes + euro_strict_parsing));
+            TEST_CHECK_EQUAL(req15->as_raw_string(), "[pkgname!?]");
+            TEST_CHECK_EQUAL(req15->as_human_string(), "Flag 'pkgname' enabled if it is disabled for 'cat/enabled-1:0::fake'");
+            TEST_CHECK(req15->requirement_met(&env, *id));
+            TEST_CHECK(req15->requirement_met(&env, *id2));
+
+            std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req16(
+                parse_elike_use_requirement("pkgname!?", id2, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_both_syntaxes + euro_strict_parsing));
+            TEST_CHECK_EQUAL(req16->as_raw_string(), "[pkgname!?]");
+            TEST_CHECK_EQUAL(req16->as_human_string(), "Flag 'pkgname' enabled if it is disabled for 'cat/disabled-1:0::fake'");
+            TEST_CHECK(req16->requirement_met(&env, *id));
+            TEST_CHECK(! req16->requirement_met(&env, *id2));
+
+            std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req17(
+                parse_elike_use_requirement("-pkgname!?", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_both_syntaxes + euro_strict_parsing));
+            TEST_CHECK_EQUAL(req17->as_raw_string(), "[-pkgname!?]");
+            TEST_CHECK_EQUAL(req17->as_human_string(), "Flag 'pkgname' disabled if it is disabled for 'cat/enabled-1:0::fake'");
+            TEST_CHECK(req17->requirement_met(&env, *id));
+            TEST_CHECK(req17->requirement_met(&env, *id2));
+
+            std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req18(
+                parse_elike_use_requirement("-pkgname!?", id2, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_both_syntaxes + euro_strict_parsing));
+            TEST_CHECK_EQUAL(req18->as_raw_string(), "[-pkgname!?]");
+            TEST_CHECK_EQUAL(req18->as_human_string(), "Flag 'pkgname' disabled if it is disabled for 'cat/disabled-1:0::fake'");
+            TEST_CHECK(! req18->requirement_met(&env, *id));
+            TEST_CHECK(req18->requirement_met(&env, *id2));
+
+            std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req19(
+                parse_elike_use_requirement("pkgname!=", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_both_syntaxes + euro_strict_parsing));
+            TEST_CHECK_EQUAL(req19->as_raw_string(), "[pkgname!=]");
+            TEST_CHECK_EQUAL(req19->as_human_string(), "Flag 'pkgname' enabled or disabled opposite to how it is for 'cat/enabled-1:0::fake'");
+            TEST_CHECK(! req19->requirement_met(&env, *id));
+            TEST_CHECK(req19->requirement_met(&env, *id2));
+
+            std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req20(
+                parse_elike_use_requirement("pkgname!=", id2, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_both_syntaxes + euro_strict_parsing));
+            TEST_CHECK_EQUAL(req20->as_raw_string(), "[pkgname!=]");
+            TEST_CHECK_EQUAL(req20->as_human_string(), "Flag 'pkgname' enabled or disabled opposite to how it is for 'cat/disabled-1:0::fake'");
+            TEST_CHECK(req20->requirement_met(&env, *id));
+            TEST_CHECK(! req20->requirement_met(&env, *id2));
+        }
+    } test_complex_use_requirements_both_syntaxes;
+
     struct MalformedUseRequirementsTest : TestCase
     {
         MalformedUseRequirementsTest() : TestCase("malformed use requirements") { }
@@ -335,20 +463,20 @@ namespace test_cases
             std::tr1::shared_ptr<FakePackageID> id(fake->add_version("cat", "enabled", "1"));
             id->iuse_key()->set_from_string("pkgname", IUseFlagParseOptions());
 
-            TEST_CHECK_THROWS(parse_elike_use_requirement("te/st", id, ELikeUseRequirementOptions() + euro_allow_self_deps), NameError);
+            TEST_CHECK_THROWS(parse_elike_use_requirement("te/st", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_strict_parsing), NameError);
 
-            TEST_CHECK_THROWS(parse_elike_use_requirement("", id, ELikeUseRequirementOptions() + euro_allow_self_deps), ELikeUseRequirementError);
-            TEST_CHECK_THROWS(parse_elike_use_requirement("-", id, ELikeUseRequirementOptions() + euro_allow_self_deps), ELikeUseRequirementError);
-            TEST_CHECK_THROWS(parse_elike_use_requirement("?", id, ELikeUseRequirementOptions() + euro_allow_self_deps), ELikeUseRequirementError);
-            TEST_CHECK_THROWS(parse_elike_use_requirement("-?", id, ELikeUseRequirementOptions() + euro_allow_self_deps), ELikeUseRequirementError);
-            TEST_CHECK_THROWS(parse_elike_use_requirement("!?", id, ELikeUseRequirementOptions() + euro_allow_self_deps), ELikeUseRequirementError);
-            TEST_CHECK_THROWS(parse_elike_use_requirement("-!?", id, ELikeUseRequirementOptions() + euro_allow_self_deps), ELikeUseRequirementError);
-            TEST_CHECK_THROWS(parse_elike_use_requirement("=", id, ELikeUseRequirementOptions() + euro_allow_self_deps), ELikeUseRequirementError);
-            TEST_CHECK_THROWS(parse_elike_use_requirement("!=", id, ELikeUseRequirementOptions() + euro_allow_self_deps), ELikeUseRequirementError);
+            TEST_CHECK_THROWS(parse_elike_use_requirement("", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_strict_parsing), ELikeUseRequirementError);
+            TEST_CHECK_THROWS(parse_elike_use_requirement("-", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_strict_parsing), ELikeUseRequirementError);
+            TEST_CHECK_THROWS(parse_elike_use_requirement("?", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_strict_parsing), ELikeUseRequirementError);
+            TEST_CHECK_THROWS(parse_elike_use_requirement("-?", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_strict_parsing), ELikeUseRequirementError);
+            TEST_CHECK_THROWS(parse_elike_use_requirement("!?", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_strict_parsing), ELikeUseRequirementError);
+            TEST_CHECK_THROWS(parse_elike_use_requirement("-!?", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_strict_parsing), ELikeUseRequirementError);
+            TEST_CHECK_THROWS(parse_elike_use_requirement("=", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_strict_parsing), ELikeUseRequirementError);
+            TEST_CHECK_THROWS(parse_elike_use_requirement("!=", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_strict_parsing), ELikeUseRequirementError);
 
-            TEST_CHECK_THROWS(parse_elike_use_requirement("!test?", id, ELikeUseRequirementOptions() + euro_allow_self_deps), NameError);
-            TEST_CHECK_THROWS(parse_elike_use_requirement("!test=", id, ELikeUseRequirementOptions() + euro_allow_self_deps), NameError);
-            TEST_CHECK_THROWS(parse_elike_use_requirement("test1,test2", id, ELikeUseRequirementOptions() + euro_allow_self_deps), NameError);
+            TEST_CHECK_THROWS(parse_elike_use_requirement("!test?", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_strict_parsing), ELikeUseRequirementError);
+            TEST_CHECK_THROWS(parse_elike_use_requirement("!test=", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_strict_parsing), ELikeUseRequirementError);
+            TEST_CHECK_THROWS(parse_elike_use_requirement("test1,test2", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_strict_parsing), ELikeUseRequirementError);
         }
     } test_malformed_use_requirements;
 
@@ -364,25 +492,309 @@ namespace test_cases
             std::tr1::shared_ptr<FakePackageID> id(fake->add_version("cat", "enabled", "1"));
             id->iuse_key()->set_from_string("pkgname", IUseFlagParseOptions());
 
-            TEST_CHECK_THROWS(parse_elike_use_requirement("te/st", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_portage_syntax), NameError);
+            TEST_CHECK_THROWS(parse_elike_use_requirement("te/st", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_portage_syntax + euro_strict_parsing), NameError);
 
-            TEST_CHECK_THROWS(parse_elike_use_requirement("", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_portage_syntax), ELikeUseRequirementError);
-            TEST_CHECK_THROWS(parse_elike_use_requirement("-", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_portage_syntax), ELikeUseRequirementError);
-            TEST_CHECK_THROWS(parse_elike_use_requirement("?", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_portage_syntax), ELikeUseRequirementError);
-            TEST_CHECK_THROWS(parse_elike_use_requirement("!?", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_portage_syntax), ELikeUseRequirementError);
-            TEST_CHECK_THROWS(parse_elike_use_requirement("=", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_portage_syntax), ELikeUseRequirementError);
-            TEST_CHECK_THROWS(parse_elike_use_requirement("!=", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_portage_syntax), ELikeUseRequirementError);
+            TEST_CHECK_THROWS(parse_elike_use_requirement("", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_portage_syntax + euro_strict_parsing), ELikeUseRequirementError);
+            TEST_CHECK_THROWS(parse_elike_use_requirement("-", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_portage_syntax + euro_strict_parsing), ELikeUseRequirementError);
+            TEST_CHECK_THROWS(parse_elike_use_requirement("?", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_portage_syntax + euro_strict_parsing), ELikeUseRequirementError);
+            TEST_CHECK_THROWS(parse_elike_use_requirement("!?", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_portage_syntax + euro_strict_parsing), ELikeUseRequirementError);
+            TEST_CHECK_THROWS(parse_elike_use_requirement("=", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_portage_syntax + euro_strict_parsing), ELikeUseRequirementError);
+            TEST_CHECK_THROWS(parse_elike_use_requirement("!=", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_portage_syntax + euro_strict_parsing), ELikeUseRequirementError);
 
-            TEST_CHECK_THROWS(parse_elike_use_requirement(",", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_portage_syntax), ELikeUseRequirementError);
-            TEST_CHECK_THROWS(parse_elike_use_requirement("test,", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_portage_syntax), ELikeUseRequirementError);
-            TEST_CHECK_THROWS(parse_elike_use_requirement(",test", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_portage_syntax), ELikeUseRequirementError);
-            TEST_CHECK_THROWS(parse_elike_use_requirement("test,,test", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_portage_syntax), ELikeUseRequirementError);
+            TEST_CHECK_THROWS(parse_elike_use_requirement(",", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_portage_syntax + euro_strict_parsing), ELikeUseRequirementError);
+            TEST_CHECK_THROWS(parse_elike_use_requirement("test,", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_portage_syntax + euro_strict_parsing), ELikeUseRequirementError);
+            TEST_CHECK_THROWS(parse_elike_use_requirement(",test", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_portage_syntax + euro_strict_parsing), ELikeUseRequirementError);
+            TEST_CHECK_THROWS(parse_elike_use_requirement("test,,test", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_portage_syntax + euro_strict_parsing), ELikeUseRequirementError);
 
-            TEST_CHECK_THROWS(parse_elike_use_requirement("test!?", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_portage_syntax), NameError);
-            TEST_CHECK_THROWS(parse_elike_use_requirement("-test?", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_portage_syntax), NameError);
-            TEST_CHECK_THROWS(parse_elike_use_requirement("-test!?", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_portage_syntax), NameError);
-            TEST_CHECK_THROWS(parse_elike_use_requirement("test!=", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_portage_syntax), NameError);
+            TEST_CHECK_THROWS(parse_elike_use_requirement("test!?", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_portage_syntax + euro_strict_parsing), ELikeUseRequirementError);
+            TEST_CHECK_THROWS(parse_elike_use_requirement("-test?", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_portage_syntax + euro_strict_parsing), ELikeUseRequirementError);
+            TEST_CHECK_THROWS(parse_elike_use_requirement("-test!?", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_portage_syntax + euro_strict_parsing), ELikeUseRequirementError);
+            TEST_CHECK_THROWS(parse_elike_use_requirement("test!=", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_portage_syntax + euro_strict_parsing), ELikeUseRequirementError);
         }
     } test_malformed_use_requirements_portage_syntax;
+
+    struct MalformedUseRequirementsBothSyntaxesTest : TestCase
+    {
+        MalformedUseRequirementsBothSyntaxesTest() : TestCase("malformed use requirements both syntaxes") { }
+
+        void run()
+        {
+            TestEnvironment env;
+            std::tr1::shared_ptr<FakeRepository> fake(new FakeRepository(&env, RepositoryName("fake")));
+            env.package_database()->add_repository(1, fake);
+            std::tr1::shared_ptr<FakePackageID> id(fake->add_version("cat", "enabled", "1"));
+            id->iuse_key()->set_from_string("pkgname", IUseFlagParseOptions());
+
+            TEST_CHECK_THROWS(parse_elike_use_requirement("te/st", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_both_syntaxes + euro_strict_parsing), NameError);
+
+            TEST_CHECK_THROWS(parse_elike_use_requirement("", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_both_syntaxes + euro_strict_parsing), ELikeUseRequirementError);
+            TEST_CHECK_THROWS(parse_elike_use_requirement("-", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_both_syntaxes + euro_strict_parsing), ELikeUseRequirementError);
+            TEST_CHECK_THROWS(parse_elike_use_requirement("?", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_both_syntaxes + euro_strict_parsing), ELikeUseRequirementError);
+            TEST_CHECK_THROWS(parse_elike_use_requirement("!?", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_both_syntaxes + euro_strict_parsing), ELikeUseRequirementError);
+            TEST_CHECK_THROWS(parse_elike_use_requirement("=", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_both_syntaxes + euro_strict_parsing), ELikeUseRequirementError);
+            TEST_CHECK_THROWS(parse_elike_use_requirement("!=", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_both_syntaxes + euro_strict_parsing), ELikeUseRequirementError);
+
+            TEST_CHECK_THROWS(parse_elike_use_requirement(",", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_both_syntaxes + euro_strict_parsing), ELikeUseRequirementError);
+            TEST_CHECK_THROWS(parse_elike_use_requirement("test,", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_both_syntaxes + euro_strict_parsing), ELikeUseRequirementError);
+            TEST_CHECK_THROWS(parse_elike_use_requirement(",test", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_both_syntaxes + euro_strict_parsing), ELikeUseRequirementError);
+            TEST_CHECK_THROWS(parse_elike_use_requirement("test,,test", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_both_syntaxes + euro_strict_parsing), ELikeUseRequirementError);
+        }
+    } test_malformed_use_requirements_both_syntaxes;
+
+    struct ComplexUseRequirementsNonstrictTest : TestCase
+    {
+        ComplexUseRequirementsNonstrictTest() : TestCase("complex use requirements non-strict") { }
+
+        void run()
+        {
+            TestEnvironment env;
+            std::tr1::shared_ptr<FakeRepository> fake(new FakeRepository(&env, RepositoryName("fake")));
+            env.package_database()->add_repository(1, fake);
+            std::tr1::shared_ptr<FakePackageID> id(fake->add_version("cat", "enabled", "1"));
+            id->iuse_key()->set_from_string("pkgname", IUseFlagParseOptions());
+            std::tr1::shared_ptr<FakePackageID> id2(fake->add_version("cat", "disabled", "1"));
+            id2->iuse_key()->set_from_string("pkgname", IUseFlagParseOptions());
+
+            std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req1(
+                parse_elike_use_requirement("pkgname?", id, ELikeUseRequirementOptions() + euro_allow_self_deps));
+            TEST_CHECK_EQUAL(req1->as_raw_string(), "[pkgname?]");
+            TEST_CHECK_EQUAL(req1->as_human_string(), "Flag 'pkgname' enabled if it is enabled for 'cat/enabled-1:0::fake'");
+            TEST_CHECK(req1->requirement_met(&env, *id));
+            TEST_CHECK(! req1->requirement_met(&env, *id2));
+
+            std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req2(
+                parse_elike_use_requirement("pkgname?", id2, ELikeUseRequirementOptions() + euro_allow_self_deps));
+            TEST_CHECK_EQUAL(req2->as_raw_string(), "[pkgname?]");
+            TEST_CHECK_EQUAL(req2->as_human_string(), "Flag 'pkgname' enabled if it is enabled for 'cat/disabled-1:0::fake'");
+            TEST_CHECK(req2->requirement_met(&env, *id));
+            TEST_CHECK(req2->requirement_met(&env, *id2));
+
+            std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req7(
+                parse_elike_use_requirement("!pkgname?", id, ELikeUseRequirementOptions() + euro_allow_self_deps));
+            TEST_CHECK_EQUAL(req7->as_raw_string(), "[!pkgname?]");
+            TEST_CHECK_EQUAL(req7->as_human_string(), "Flag 'pkgname' disabled if it is disabled for 'cat/enabled-1:0::fake'");
+            TEST_CHECK(req7->requirement_met(&env, *id));
+            TEST_CHECK(req7->requirement_met(&env, *id2));
+
+            std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req8(
+                parse_elike_use_requirement("!pkgname?", id2, ELikeUseRequirementOptions() + euro_allow_self_deps));
+            TEST_CHECK_EQUAL(req8->as_raw_string(), "[!pkgname?]");
+            TEST_CHECK_EQUAL(req8->as_human_string(), "Flag 'pkgname' disabled if it is disabled for 'cat/disabled-1:0::fake'");
+            TEST_CHECK(! req8->requirement_met(&env, *id));
+            TEST_CHECK(req8->requirement_met(&env, *id2));
+
+            std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req9(
+                parse_elike_use_requirement("pkgname=", id, ELikeUseRequirementOptions() + euro_allow_self_deps));
+            TEST_CHECK_EQUAL(req9->as_raw_string(), "[pkgname=]");
+            TEST_CHECK_EQUAL(req9->as_human_string(), "Flag 'pkgname' enabled or disabled like it is for 'cat/enabled-1:0::fake'");
+            TEST_CHECK(req9->requirement_met(&env, *id));
+            TEST_CHECK(! req9->requirement_met(&env, *id2));
+
+            std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req10(
+                parse_elike_use_requirement("pkgname=", id2, ELikeUseRequirementOptions() + euro_allow_self_deps));
+            TEST_CHECK_EQUAL(req10->as_raw_string(), "[pkgname=]");
+            TEST_CHECK_EQUAL(req10->as_human_string(), "Flag 'pkgname' enabled or disabled like it is for 'cat/disabled-1:0::fake'");
+            TEST_CHECK(! req10->requirement_met(&env, *id));
+            TEST_CHECK(req10->requirement_met(&env, *id2));
+
+            std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req11(
+                parse_elike_use_requirement("!pkgname=", id, ELikeUseRequirementOptions() + euro_allow_self_deps));
+            TEST_CHECK_EQUAL(req11->as_raw_string(), "[!pkgname=]");
+            TEST_CHECK_EQUAL(req11->as_human_string(), "Flag 'pkgname' enabled or disabled opposite to how it is for 'cat/enabled-1:0::fake'");
+            TEST_CHECK(! req11->requirement_met(&env, *id));
+            TEST_CHECK(req11->requirement_met(&env, *id2));
+
+            std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req12(
+                parse_elike_use_requirement("!pkgname=", id2, ELikeUseRequirementOptions() + euro_allow_self_deps));
+            TEST_CHECK_EQUAL(req12->as_raw_string(), "[!pkgname=]");
+            TEST_CHECK_EQUAL(req12->as_human_string(), "Flag 'pkgname' enabled or disabled opposite to how it is for 'cat/disabled-1:0::fake'");
+            TEST_CHECK(req12->requirement_met(&env, *id));
+            TEST_CHECK(! req12->requirement_met(&env, *id2));
+
+            std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req13(
+                parse_elike_use_requirement("-pkgname?", id, ELikeUseRequirementOptions() + euro_allow_self_deps));
+            TEST_CHECK_EQUAL(req13->as_raw_string(), "[-pkgname?]");
+            TEST_CHECK_EQUAL(req13->as_human_string(), "Flag 'pkgname' disabled if it is enabled for 'cat/enabled-1:0::fake'");
+            TEST_CHECK(! req13->requirement_met(&env, *id));
+            TEST_CHECK(req13->requirement_met(&env, *id2));
+
+            std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req14(
+                parse_elike_use_requirement("-pkgname?", id2, ELikeUseRequirementOptions() + euro_allow_self_deps));
+            TEST_CHECK_EQUAL(req14->as_raw_string(), "[-pkgname?]");
+            TEST_CHECK_EQUAL(req14->as_human_string(), "Flag 'pkgname' disabled if it is enabled for 'cat/disabled-1:0::fake'");
+            TEST_CHECK(req14->requirement_met(&env, *id));
+            TEST_CHECK(req14->requirement_met(&env, *id2));
+
+            std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req15(
+                parse_elike_use_requirement("pkgname!?", id, ELikeUseRequirementOptions() + euro_allow_self_deps));
+            TEST_CHECK_EQUAL(req15->as_raw_string(), "[pkgname!?]");
+            TEST_CHECK_EQUAL(req15->as_human_string(), "Flag 'pkgname' enabled if it is disabled for 'cat/enabled-1:0::fake'");
+            TEST_CHECK(req15->requirement_met(&env, *id));
+            TEST_CHECK(req15->requirement_met(&env, *id2));
+
+            std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req16(
+                parse_elike_use_requirement("pkgname!?", id2, ELikeUseRequirementOptions() + euro_allow_self_deps));
+            TEST_CHECK_EQUAL(req16->as_raw_string(), "[pkgname!?]");
+            TEST_CHECK_EQUAL(req16->as_human_string(), "Flag 'pkgname' enabled if it is disabled for 'cat/disabled-1:0::fake'");
+            TEST_CHECK(req16->requirement_met(&env, *id));
+            TEST_CHECK(! req16->requirement_met(&env, *id2));
+
+            std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req17(
+                parse_elike_use_requirement("-pkgname!?", id, ELikeUseRequirementOptions() + euro_allow_self_deps));
+            TEST_CHECK_EQUAL(req17->as_raw_string(), "[-pkgname!?]");
+            TEST_CHECK_EQUAL(req17->as_human_string(), "Flag 'pkgname' disabled if it is disabled for 'cat/enabled-1:0::fake'");
+            TEST_CHECK(req17->requirement_met(&env, *id));
+            TEST_CHECK(req17->requirement_met(&env, *id2));
+
+            std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req18(
+                parse_elike_use_requirement("-pkgname!?", id2, ELikeUseRequirementOptions() + euro_allow_self_deps));
+            TEST_CHECK_EQUAL(req18->as_raw_string(), "[-pkgname!?]");
+            TEST_CHECK_EQUAL(req18->as_human_string(), "Flag 'pkgname' disabled if it is disabled for 'cat/disabled-1:0::fake'");
+            TEST_CHECK(! req18->requirement_met(&env, *id));
+            TEST_CHECK(req18->requirement_met(&env, *id2));
+
+            std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req19(
+                parse_elike_use_requirement("pkgname!=", id, ELikeUseRequirementOptions() + euro_allow_self_deps));
+            TEST_CHECK_EQUAL(req19->as_raw_string(), "[pkgname!=]");
+            TEST_CHECK_EQUAL(req19->as_human_string(), "Flag 'pkgname' enabled or disabled opposite to how it is for 'cat/enabled-1:0::fake'");
+            TEST_CHECK(! req19->requirement_met(&env, *id));
+            TEST_CHECK(req19->requirement_met(&env, *id2));
+
+            std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req20(
+                parse_elike_use_requirement("pkgname!=", id2, ELikeUseRequirementOptions() + euro_allow_self_deps));
+            TEST_CHECK_EQUAL(req20->as_raw_string(), "[pkgname!=]");
+            TEST_CHECK_EQUAL(req20->as_human_string(), "Flag 'pkgname' enabled or disabled opposite to how it is for 'cat/disabled-1:0::fake'");
+            TEST_CHECK(req20->requirement_met(&env, *id));
+            TEST_CHECK(! req20->requirement_met(&env, *id2));
+        }
+    } test_complex_use_requirements_nonstrict;
+
+    struct ComplexUseRequirementsPortageSyntaxNonstrictTest : TestCase
+    {
+        ComplexUseRequirementsPortageSyntaxNonstrictTest() : TestCase("complex use requirements portage syntax non-strict") { }
+
+        void run()
+        {
+            TestEnvironment env;
+            std::tr1::shared_ptr<FakeRepository> fake(new FakeRepository(&env, RepositoryName("fake")));
+            env.package_database()->add_repository(1, fake);
+            std::tr1::shared_ptr<FakePackageID> id(fake->add_version("cat", "enabled", "1"));
+            id->iuse_key()->set_from_string("pkgname", IUseFlagParseOptions());
+            std::tr1::shared_ptr<FakePackageID> id2(fake->add_version("cat", "disabled", "1"));
+            id2->iuse_key()->set_from_string("pkgname", IUseFlagParseOptions());
+
+            std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req1(
+                parse_elike_use_requirement("pkgname?", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_portage_syntax));
+            TEST_CHECK_EQUAL(req1->as_raw_string(), "[pkgname?]");
+            TEST_CHECK_EQUAL(req1->as_human_string(), "Flag 'pkgname' enabled if it is enabled for 'cat/enabled-1:0::fake'");
+            TEST_CHECK(req1->requirement_met(&env, *id));
+            TEST_CHECK(! req1->requirement_met(&env, *id2));
+
+            std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req2(
+                parse_elike_use_requirement("pkgname?", id2, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_portage_syntax));
+            TEST_CHECK_EQUAL(req2->as_raw_string(), "[pkgname?]");
+            TEST_CHECK_EQUAL(req2->as_human_string(), "Flag 'pkgname' enabled if it is enabled for 'cat/disabled-1:0::fake'");
+            TEST_CHECK(req2->requirement_met(&env, *id));
+            TEST_CHECK(req2->requirement_met(&env, *id2));
+
+            std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req7(
+                parse_elike_use_requirement("!pkgname?", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_portage_syntax));
+            TEST_CHECK_EQUAL(req7->as_raw_string(), "[!pkgname?]");
+            TEST_CHECK_EQUAL(req7->as_human_string(), "Flag 'pkgname' disabled if it is disabled for 'cat/enabled-1:0::fake'");
+            TEST_CHECK(req7->requirement_met(&env, *id));
+            TEST_CHECK(req7->requirement_met(&env, *id2));
+
+            std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req8(
+                parse_elike_use_requirement("!pkgname?", id2, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_portage_syntax));
+            TEST_CHECK_EQUAL(req8->as_raw_string(), "[!pkgname?]");
+            TEST_CHECK_EQUAL(req8->as_human_string(), "Flag 'pkgname' disabled if it is disabled for 'cat/disabled-1:0::fake'");
+            TEST_CHECK(! req8->requirement_met(&env, *id));
+            TEST_CHECK(req8->requirement_met(&env, *id2));
+
+            std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req9(
+                parse_elike_use_requirement("pkgname=", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_portage_syntax));
+            TEST_CHECK_EQUAL(req9->as_raw_string(), "[pkgname=]");
+            TEST_CHECK_EQUAL(req9->as_human_string(), "Flag 'pkgname' enabled or disabled like it is for 'cat/enabled-1:0::fake'");
+            TEST_CHECK(req9->requirement_met(&env, *id));
+            TEST_CHECK(! req9->requirement_met(&env, *id2));
+
+            std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req10(
+                parse_elike_use_requirement("pkgname=", id2, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_portage_syntax));
+            TEST_CHECK_EQUAL(req10->as_raw_string(), "[pkgname=]");
+            TEST_CHECK_EQUAL(req10->as_human_string(), "Flag 'pkgname' enabled or disabled like it is for 'cat/disabled-1:0::fake'");
+            TEST_CHECK(! req10->requirement_met(&env, *id));
+            TEST_CHECK(req10->requirement_met(&env, *id2));
+
+            std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req11(
+                parse_elike_use_requirement("!pkgname=", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_portage_syntax));
+            TEST_CHECK_EQUAL(req11->as_raw_string(), "[!pkgname=]");
+            TEST_CHECK_EQUAL(req11->as_human_string(), "Flag 'pkgname' enabled or disabled opposite to how it is for 'cat/enabled-1:0::fake'");
+            TEST_CHECK(! req11->requirement_met(&env, *id));
+            TEST_CHECK(req11->requirement_met(&env, *id2));
+
+            std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req12(
+                parse_elike_use_requirement("!pkgname=", id2, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_portage_syntax));
+            TEST_CHECK_EQUAL(req12->as_raw_string(), "[!pkgname=]");
+            TEST_CHECK_EQUAL(req12->as_human_string(), "Flag 'pkgname' enabled or disabled opposite to how it is for 'cat/disabled-1:0::fake'");
+            TEST_CHECK(req12->requirement_met(&env, *id));
+            TEST_CHECK(! req12->requirement_met(&env, *id2));
+
+            std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req13(
+                parse_elike_use_requirement("-pkgname?", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_portage_syntax));
+            TEST_CHECK_EQUAL(req13->as_raw_string(), "[-pkgname?]");
+            TEST_CHECK_EQUAL(req13->as_human_string(), "Flag 'pkgname' disabled if it is enabled for 'cat/enabled-1:0::fake'");
+            TEST_CHECK(! req13->requirement_met(&env, *id));
+            TEST_CHECK(req13->requirement_met(&env, *id2));
+
+            std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req14(
+                parse_elike_use_requirement("-pkgname?", id2, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_portage_syntax));
+            TEST_CHECK_EQUAL(req14->as_raw_string(), "[-pkgname?]");
+            TEST_CHECK_EQUAL(req14->as_human_string(), "Flag 'pkgname' disabled if it is enabled for 'cat/disabled-1:0::fake'");
+            TEST_CHECK(req14->requirement_met(&env, *id));
+            TEST_CHECK(req14->requirement_met(&env, *id2));
+
+            std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req15(
+                parse_elike_use_requirement("pkgname!?", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_portage_syntax));
+            TEST_CHECK_EQUAL(req15->as_raw_string(), "[pkgname!?]");
+            TEST_CHECK_EQUAL(req15->as_human_string(), "Flag 'pkgname' enabled if it is disabled for 'cat/enabled-1:0::fake'");
+            TEST_CHECK(req15->requirement_met(&env, *id));
+            TEST_CHECK(req15->requirement_met(&env, *id2));
+
+            std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req16(
+                parse_elike_use_requirement("pkgname!?", id2, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_portage_syntax));
+            TEST_CHECK_EQUAL(req16->as_raw_string(), "[pkgname!?]");
+            TEST_CHECK_EQUAL(req16->as_human_string(), "Flag 'pkgname' enabled if it is disabled for 'cat/disabled-1:0::fake'");
+            TEST_CHECK(req16->requirement_met(&env, *id));
+            TEST_CHECK(! req16->requirement_met(&env, *id2));
+
+            std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req17(
+                parse_elike_use_requirement("-pkgname!?", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_portage_syntax));
+            TEST_CHECK_EQUAL(req17->as_raw_string(), "[-pkgname!?]");
+            TEST_CHECK_EQUAL(req17->as_human_string(), "Flag 'pkgname' disabled if it is disabled for 'cat/enabled-1:0::fake'");
+            TEST_CHECK(req17->requirement_met(&env, *id));
+            TEST_CHECK(req17->requirement_met(&env, *id2));
+
+            std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req18(
+                parse_elike_use_requirement("-pkgname!?", id2, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_portage_syntax));
+            TEST_CHECK_EQUAL(req18->as_raw_string(), "[-pkgname!?]");
+            TEST_CHECK_EQUAL(req18->as_human_string(), "Flag 'pkgname' disabled if it is disabled for 'cat/disabled-1:0::fake'");
+            TEST_CHECK(! req18->requirement_met(&env, *id));
+            TEST_CHECK(req18->requirement_met(&env, *id2));
+
+            std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req19(
+                parse_elike_use_requirement("pkgname!=", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_portage_syntax));
+            TEST_CHECK_EQUAL(req19->as_raw_string(), "[pkgname!=]");
+            TEST_CHECK_EQUAL(req19->as_human_string(), "Flag 'pkgname' enabled or disabled opposite to how it is for 'cat/enabled-1:0::fake'");
+            TEST_CHECK(! req19->requirement_met(&env, *id));
+            TEST_CHECK(req19->requirement_met(&env, *id2));
+
+            std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req20(
+                parse_elike_use_requirement("pkgname!=", id2, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_portage_syntax));
+            TEST_CHECK_EQUAL(req20->as_raw_string(), "[pkgname!=]");
+            TEST_CHECK_EQUAL(req20->as_human_string(), "Flag 'pkgname' enabled or disabled opposite to how it is for 'cat/disabled-1:0::fake'");
+            TEST_CHECK(req20->requirement_met(&env, *id));
+            TEST_CHECK(! req20->requirement_met(&env, *id2));
+        }
+    } test_complex_use_requirements_portage_syntax_nonstrict;
 }
 
diff --git a/paludis/repositories/e/eapis/paludis-1.conf b/paludis/repositories/e/eapis/paludis-1.conf
index 50ed2d7..baee76f 100644
--- a/paludis/repositories/e/eapis/paludis-1.conf
+++ b/paludis/repositories/e/eapis/paludis-1.conf
@@ -5,7 +5,7 @@
 exported_name = paludis-1
 can_be_pbin = true
 
-package_dep_spec_parse_options = allow_slot_deps allow_use_deps allow_ranged_deps \
+package_dep_spec_parse_options = allow_slot_deps allow_use_deps allow_use_deps_portage allow_ranged_deps \
     allow_repository_deps allow_tilde_greater_deps strict_parsing \
     allow_slot_equal_deps allow_slot_star_deps
 dependency_spec_tree_parse_options = disallow_any_use uri_supports_arrow
---

From git at git.pioto.org  Mon Sep  1 12:19:22 2008
From: git at git.pioto.org (git at git.pioto.org)
Date: Mon,  1 Sep 2008 12:19:22 -0400 (EDT)
Subject: [paludis-commits] paludis.git (0.30) -- d8ba0ef by David Leverton
Message-ID: <20080901161922.A912F160586@everglades.pioto.org>


Module:    paludis.git
Branch:    0.30
Commit:    d8ba0efff36aa24dd5a0dbe128011f7516cafd73
URL:       http://git.pioto.org/?p=paludis.git;a=commit;h=d8ba0efff36aa24dd5a0dbe128011f7516cafd73

Author:    David Leverton <levertond at googlemail.com>
Committer: David Leverton <levertond at googlemail.com>
Date:      Mon Sep  1 17:16:25 2008 +0100

----

Change the handling of the two USE-dep syntaxes.

Make it possible for an EAPI to accept both, and do so for paludis-1.
Allow both anyway if strict parsing is disabled.

----

 paludis/elike_package_dep_spec-fwd.hh       |    2 +-
 paludis/elike_package_dep_spec.cc           |   52 ++--
 paludis/elike_use_requirement.cc            |  121 +++++--
 paludis/elike_use_requirement.se            |    2 +
 paludis/elike_use_requirement_TEST.cc       |  532 ++++++++++++++++++++++++---
 paludis/repositories/e/eapis/paludis-1.conf |    2 +-
 6 files changed, 603 insertions(+), 108 deletions(-)


diff --git a/paludis/elike_package_dep_spec-fwd.hh b/paludis/elike_package_dep_spec-fwd.hh
index aaf40ae..5b4960c 100644
--- a/paludis/elike_package_dep_spec-fwd.hh
+++ b/paludis/elike_package_dep_spec-fwd.hh
@@ -57,7 +57,7 @@ namespace paludis
 
     bool elike_remove_trailing_square_bracket_if_exists(std::string & s, PartiallyMadePackageDepSpec & result,
             const ELikePackageDepSpecOptions & options, bool & had_bracket_version_requirements,
-            const std::tr1::shared_ptr<const PackageID> & id) PALUDIS_VISIBLE;
+            bool & had_use_requirements, const std::tr1::shared_ptr<const PackageID> & id) PALUDIS_VISIBLE;
 
     void elike_remove_trailing_repo_if_exists(std::string & s, PartiallyMadePackageDepSpec & result,
             const ELikePackageDepSpecOptions & options) PALUDIS_VISIBLE;
diff --git a/paludis/elike_package_dep_spec.cc b/paludis/elike_package_dep_spec.cc
index 96d82e2..17e2f2b 100644
--- a/paludis/elike_package_dep_spec.cc
+++ b/paludis/elike_package_dep_spec.cc
@@ -86,7 +86,7 @@ paludis::elike_check_sanity(const std::string & s)
 bool
 paludis::elike_remove_trailing_square_bracket_if_exists(std::string & s, PartiallyMadePackageDepSpec & result,
         const ELikePackageDepSpecOptions & options, bool & had_bracket_version_requirements,
-        const std::tr1::shared_ptr<const PackageID> & id)
+        bool & had_use_requirements, const std::tr1::shared_ptr<const PackageID> & id)
 {
     std::string::size_type use_group_p;
     if (std::string::npos == ((use_group_p = s.rfind('['))))
@@ -143,6 +143,7 @@ paludis::elike_remove_trailing_square_bracket_if_exists(std::string & s, Partial
                     opos = flag.find_first_of("|&");
                     if (std::string::npos == opos)
                     {
+
                         ver = flag;
                         flag.clear();
                     }
@@ -178,31 +179,38 @@ paludis::elike_remove_trailing_square_bracket_if_exists(std::string & s, Partial
             break;
 
         default:
-            if (options[epdso_allow_use_deps_portage] || ! options[epdso_allow_use_deps])
+            if (! options[epdso_allow_use_deps] && ! options[epdso_allow_use_deps_portage])
             {
-                if (! options[epdso_allow_use_deps_portage])
+                if (options[epdso_strict_parsing])
+                    throw PackageDepSpecError("USE dependencies not safe for use here");
+                else
                 {
-                    if (options[epdso_strict_parsing])
-                        throw PackageDepSpecError("USE dependencies not safe for use here");
-                    else
-                    {
-                        // Use Portage syntax for this case, as it
-                        // should only happen in Gentoo EAPIs
-                        Log::get_instance()->message("e.package_dep_spec.use_not_allowed", ll_warning, lc_context)
-                            << "USE dependencies not safe for use here";
-                    }
+                    Log::get_instance()->message("e.package_dep_spec.use_not_allowed", ll_warning, lc_context)
+                        << "USE dependencies not safe for use here";
                 }
-
-                std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req(parse_elike_use_requirement(flag,
-                            id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_portage_syntax));
-                result.additional_requirement(req);
             }
-            else
+
+            if (! options[epdso_allow_use_deps] && had_use_requirements)
             {
-                std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req(parse_elike_use_requirement(flag,
-                            id, ELikeUseRequirementOptions() + euro_allow_self_deps));
-                result.additional_requirement(req);
+                if (options[epdso_strict_parsing])
+                    throw PackageDepSpecError("multiple sets of USE dependencies not safe for use here");
+                else
+                {
+                    Log::get_instance()->message("e.package_dep_spec.use_multiple_not_allowed", ll_warning, lc_context)
+                        << "multiple sets of USE dependencies not safe for use here";
+                }
             }
+            had_use_requirements = true;
+
+            ELikeUseRequirementOptions euro;
+            euro += euro_allow_self_deps;
+            if (options[epdso_allow_use_deps_portage])
+                euro += options[epdso_allow_use_deps] ? euro_both_syntaxes : euro_portage_syntax;
+            if (options[epdso_strict_parsing])
+                euro += euro_strict_parsing;
+
+            std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req(parse_elike_use_requirement(flag, id, euro));
+            result.additional_requirement(req);
 
             break;
     };
@@ -428,7 +436,7 @@ paludis::partial_parse_elike_package_dep_spec(
 
     Context context("When parsing elike package dep spec '" + ss + "':");
 
-    bool had_bracket_version_requirements(false);
+    bool had_bracket_version_requirements(false), had_use_requirements(false);
 
     return partial_parse_generic_elike_package_dep_spec(ss, make_named_values<GenericELikePackageDepSpecParseFunctions>(
                 value_for<n::add_package_requirement>(std::tr1::bind(&elike_add_package_requirement, _1, _2)),
@@ -441,7 +449,7 @@ paludis::partial_parse_elike_package_dep_spec(
                 value_for<n::remove_trailing_repo_if_exists>(std::tr1::bind(&elike_remove_trailing_repo_if_exists, _1, _2, options)),
                 value_for<n::remove_trailing_slot_if_exists>(std::tr1::bind(&elike_remove_trailing_slot_if_exists, _1, _2, options)),
                 value_for<n::remove_trailing_square_bracket_if_exists>(std::tr1::bind(&elike_remove_trailing_square_bracket_if_exists,
-                        _1, _2, options, std::tr1::ref(had_bracket_version_requirements), id))
+                        _1, _2, options, std::tr1::ref(had_bracket_version_requirements), std::tr1::ref(had_use_requirements), id))
                 ));
 }
 
diff --git a/paludis/elike_use_requirement.cc b/paludis/elike_use_requirement.cc
index acac8eb..d3ae113 100644
--- a/paludis/elike_use_requirement.cc
+++ b/paludis/elike_use_requirement.cc
@@ -23,6 +23,7 @@
 #include <paludis/util/stringify.hh>
 #include <paludis/util/join.hh>
 #include <paludis/util/tokeniser.hh>
+#include <paludis/util/log.hh>
 #include <paludis/dep_spec.hh>
 #include <paludis/name.hh>
 #include <paludis/environment.hh>
@@ -278,10 +279,35 @@ namespace
             flag.erase(flag.length() - 1);
             if (flag.empty())
                 throw ELikeUseRequirementError(s, "Invalid [] contents");
-            std::string::size_type not_position(options[euro_portage_syntax] ? 0 : flag.length() - 1);
-            if ('!' == flag.at(not_position))
+
+            if ('!' == flag.at(flag.length() - 1))
+            {
+                if (options[euro_portage_syntax] && ! options[euro_both_syntaxes])
+                {
+                    if (options[euro_strict_parsing])
+                        throw ELikeUseRequirementError(s, "[use!=] not safe for use here");
+                    else
+                        Log::get_instance()->message("e.use_requirement.flag_not_equal_not_allowed", ll_warning, lc_context)
+                            << "[use!=] not safe for use here";
+                }
+
+                flag.erase(flag.length() - 1, 1);
+                if (flag.empty())
+                    throw ELikeUseRequirementError(s, "Invalid [] contents");
+                return make_shared_ptr(new NotEqualUseRequirement(UseFlagName(flag), id));
+            }
+            else if ('!' == flag.at(0))
             {
-                flag.erase(not_position, 1);
+                if (! options[euro_portage_syntax] && ! options[euro_both_syntaxes])
+                {
+                    if (options[euro_strict_parsing])
+                        throw ELikeUseRequirementError(s, "[!use=] not safe for use here");
+                    else
+                        Log::get_instance()->message("e.use_requirement.not_flag_equal_not_allowed", ll_warning, lc_context)
+                            << "[!use=] not safe for use here";
+                }
+
+                flag.erase(0, 1);
                 if (flag.empty())
                     throw ELikeUseRequirementError(s, "Invalid [] contents");
                 return make_shared_ptr(new NotEqualUseRequirement(UseFlagName(flag), id));
@@ -297,16 +323,24 @@ namespace
             flag.erase(flag.length() - 1);
             if (flag.empty())
                 throw ELikeUseRequirementError(s, "Invalid [] contents");
-            std::string::size_type not_position(options[euro_portage_syntax] ? 0 : flag.length() - 1);
-            if ('!' == flag.at(not_position))
+
+            if ('!' == flag.at(flag.length() - 1))
             {
-                flag.erase(not_position, 1);
+                flag.erase(flag.length() - 1, 1);
                 if (flag.empty())
                     throw ELikeUseRequirementError(s, "Invalid [] contents");
-                if (options[euro_portage_syntax])
-                    return make_shared_ptr(new IfNotMineThenNotUseRequirement(UseFlagName(flag), id));
-                else if ('-' == flag.at(0))
+
+                if ('-' == flag.at(0))
                 {
+                    if (options[euro_portage_syntax] && ! options[euro_both_syntaxes])
+                    {
+                        if (options[euro_strict_parsing])
+                            throw ELikeUseRequirementError(s, "[-use!?] not safe for use here");
+                        else
+                            Log::get_instance()->message("e.use_requirement.minus_flag_not_question_not_allowed", ll_warning, lc_context)
+                                << "[-use!?] not safe for use here";
+                    }
+
                     flag.erase(0, 1);
                     if (flag.empty())
                         throw ELikeUseRequirementError(s, "Invalid [] contents");
@@ -314,12 +348,49 @@ namespace
                     return make_shared_ptr(new IfNotMineThenNotUseRequirement(UseFlagName(flag), id));
                 }
                 else
+                {
+                    if (options[euro_portage_syntax] && ! options[euro_both_syntaxes])
+                    {
+                        if (options[euro_strict_parsing])
+                            throw ELikeUseRequirementError(s, "[use!?] not safe for use here");
+                        else
+                            Log::get_instance()->message("e.use_requirement.flag_not_question_not_allowed", ll_warning, lc_context)
+                                << "[use!?] not safe for use here";
+                    }
+
                     return make_shared_ptr(new IfNotMineThenUseRequirement(UseFlagName(flag), id));
+                }
+            }
+            else if ('!' == flag.at(0))
+            {
+                if (! options[euro_portage_syntax] && ! options[euro_both_syntaxes])
+                {
+                    if (options[euro_strict_parsing])
+                        throw ELikeUseRequirementError(s, "[!use?] not safe for use here");
+                    else
+                        Log::get_instance()->message("e.use_requirement.not_flag_question_not_allowed", ll_warning, lc_context)
+                            << "[!use?] not safe for use here";
+                }
+
+                flag.erase(0, 1);
+                if (flag.empty())
+                    throw ELikeUseRequirementError(s, "Invalid [] contents");
+
+                return make_shared_ptr(new IfNotMineThenNotUseRequirement(UseFlagName(flag), id));
             }
             else
             {
-                if (! options[euro_portage_syntax] && '-' == flag.at(0))
+                if ('-' == flag.at(0))
                 {
+                    if (options[euro_portage_syntax] && ! options[euro_both_syntaxes])
+                    {
+                        if (options[euro_strict_parsing])
+                            throw ELikeUseRequirementError(s, "[-use?] not safe for use here");
+                        else
+                            Log::get_instance()->message("e.use_requirement.minus_flag_question_not_allowed", ll_warning, lc_context)
+                                << "[-use?] not safe for use here";
+                    }
+
                     flag.erase(0, 1);
                     if (flag.empty())
                         throw ELikeUseRequirementError(s, "Invalid [] contents");
@@ -354,23 +425,25 @@ paludis::parse_elike_use_requirement(const std::string & s,
     Context context("When parsing use requirement '" + s + "':");
 
     std::tr1::shared_ptr<UseRequirements> result(new UseRequirements("[" + s + "]"));
-    if (options[euro_portage_syntax])
+    std::string::size_type pos(0);
+    for (;;)
     {
-        std::string::size_type pos(0);
-        for (;;)
+        std::string::size_type comma(s.find(',', pos));
+        std::string flag(s.substr(pos, std::string::npos == comma ? comma : comma - pos));
+        result->add_requirement(parse_one_use_requirement(s, flag, id, options));
+        if (std::string::npos == comma)
+            break;
+
+        if (! options[euro_portage_syntax] && ! options[euro_both_syntaxes])
         {
-            std::string::size_type comma(s.find(',', pos));
-            std::string flag(s.substr(pos, std::string::npos == comma ? comma : comma - pos));
-            result->add_requirement(parse_one_use_requirement(s, flag, id, options));
-            if (std::string::npos == comma)
-                break;
-            pos = comma + 1;
+            if (options[euro_strict_parsing])
+                throw ELikeUseRequirementError(s, "[use,use] not safe for use here");
+            else
+                Log::get_instance()->message("e.use_requirement.comma_separated_not_allowed", ll_warning, lc_context)
+                    << "[use,use] not safe for use here";
         }
-    }
-    else
-    {
-        std::string flag(s);
-        result->add_requirement(parse_one_use_requirement(s, flag, id, options));
+
+        pos = comma + 1;
     }
 
     return result;
diff --git a/paludis/elike_use_requirement.se b/paludis/elike_use_requirement.se
index 4e61a01..cdda575 100644
--- a/paludis/elike_use_requirement.se
+++ b/paludis/elike_use_requirement.se
@@ -8,5 +8,7 @@ make_enum_ELikeUseRequirementOption()
 
     key euro_allow_self_deps          "Allow self-dependent use deps"
     key euro_portage_syntax           "Parse using Portage syntax"
+    key euro_both_syntaxes            "Accept both Portage and Paludis syntax"
+    key euro_strict_parsing           "Error rather than warn for violations"
 }
 
diff --git a/paludis/elike_use_requirement_TEST.cc b/paludis/elike_use_requirement_TEST.cc
index 62d9e5c..02d21ca 100644
--- a/paludis/elike_use_requirement_TEST.cc
+++ b/paludis/elike_use_requirement_TEST.cc
@@ -44,25 +44,25 @@ namespace test_cases
             id->iuse_key()->set_from_string("enabled disabled", IUseFlagParseOptions());
 
             std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req1(
-                parse_elike_use_requirement("enabled", std::tr1::shared_ptr<const PackageID>(), ELikeUseRequirementOptions()));
+                parse_elike_use_requirement("enabled", std::tr1::shared_ptr<const PackageID>(), ELikeUseRequirementOptions() + euro_strict_parsing));
             TEST_CHECK_EQUAL(req1->as_raw_string(), "[enabled]");
             TEST_CHECK_EQUAL(req1->as_human_string(), "Flag 'enabled' enabled");
             TEST_CHECK(req1->requirement_met(&env, *id));
 
             std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req2(
-                parse_elike_use_requirement("disabled", std::tr1::shared_ptr<const PackageID>(), ELikeUseRequirementOptions()));
+                parse_elike_use_requirement("disabled", std::tr1::shared_ptr<const PackageID>(), ELikeUseRequirementOptions() + euro_strict_parsing));
             TEST_CHECK_EQUAL(req2->as_raw_string(), "[disabled]");
             TEST_CHECK_EQUAL(req2->as_human_string(), "Flag 'disabled' enabled");
             TEST_CHECK(! req2->requirement_met(&env, *id));
 
             std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req3(
-                parse_elike_use_requirement("-enabled", std::tr1::shared_ptr<const PackageID>(), ELikeUseRequirementOptions()));
+                parse_elike_use_requirement("-enabled", std::tr1::shared_ptr<const PackageID>(), ELikeUseRequirementOptions() + euro_strict_parsing));
             TEST_CHECK_EQUAL(req3->as_raw_string(), "[-enabled]");
             TEST_CHECK_EQUAL(req3->as_human_string(), "Flag 'enabled' disabled");
             TEST_CHECK(! req3->requirement_met(&env, *id));
 
             std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req4(
-                parse_elike_use_requirement("-disabled", std::tr1::shared_ptr<const PackageID>(), ELikeUseRequirementOptions()));
+                parse_elike_use_requirement("-disabled", std::tr1::shared_ptr<const PackageID>(), ELikeUseRequirementOptions() + euro_strict_parsing));
             TEST_CHECK_EQUAL(req4->as_raw_string(), "[-disabled]");
             TEST_CHECK_EQUAL(req4->as_human_string(), "Flag 'disabled' disabled");
             TEST_CHECK(req4->requirement_met(&env, *id));
@@ -82,25 +82,25 @@ namespace test_cases
             id->iuse_key()->set_from_string("enabled disabled", IUseFlagParseOptions());
 
             std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req1(
-                parse_elike_use_requirement("enabled", std::tr1::shared_ptr<const PackageID>(), ELikeUseRequirementOptions() + euro_portage_syntax));
+                parse_elike_use_requirement("enabled", std::tr1::shared_ptr<const PackageID>(), ELikeUseRequirementOptions() + euro_portage_syntax + euro_strict_parsing));
             TEST_CHECK_EQUAL(req1->as_raw_string(), "[enabled]");
             TEST_CHECK_EQUAL(req1->as_human_string(), "Flag 'enabled' enabled");
             TEST_CHECK(req1->requirement_met(&env, *id));
 
             std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req2(
-                parse_elike_use_requirement("disabled", std::tr1::shared_ptr<const PackageID>(), ELikeUseRequirementOptions() + euro_portage_syntax));
+                parse_elike_use_requirement("disabled", std::tr1::shared_ptr<const PackageID>(), ELikeUseRequirementOptions() + euro_portage_syntax + euro_strict_parsing));
             TEST_CHECK_EQUAL(req2->as_raw_string(), "[disabled]");
             TEST_CHECK_EQUAL(req2->as_human_string(), "Flag 'disabled' enabled");
             TEST_CHECK(! req2->requirement_met(&env, *id));
 
             std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req3(
-                parse_elike_use_requirement("-enabled", std::tr1::shared_ptr<const PackageID>(), ELikeUseRequirementOptions() + euro_portage_syntax));
+                parse_elike_use_requirement("-enabled", std::tr1::shared_ptr<const PackageID>(), ELikeUseRequirementOptions() + euro_portage_syntax + euro_strict_parsing));
             TEST_CHECK_EQUAL(req3->as_raw_string(), "[-enabled]");
             TEST_CHECK_EQUAL(req3->as_human_string(), "Flag 'enabled' disabled");
             TEST_CHECK(! req3->requirement_met(&env, *id));
 
             std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req4(
-                parse_elike_use_requirement("-disabled", std::tr1::shared_ptr<const PackageID>(), ELikeUseRequirementOptions() + euro_portage_syntax));
+                parse_elike_use_requirement("-disabled", std::tr1::shared_ptr<const PackageID>(), ELikeUseRequirementOptions() + euro_portage_syntax + euro_strict_parsing));
             TEST_CHECK_EQUAL(req4->as_raw_string(), "[-disabled]");
             TEST_CHECK_EQUAL(req4->as_human_string(), "Flag 'disabled' disabled");
             TEST_CHECK(req4->requirement_met(&env, *id));
@@ -120,31 +120,31 @@ namespace test_cases
             id->iuse_key()->set_from_string("enabled disabled", IUseFlagParseOptions());
 
             std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req1(
-                parse_elike_use_requirement("enabled,-disabled", std::tr1::shared_ptr<const PackageID>(), ELikeUseRequirementOptions() + euro_portage_syntax));
+                parse_elike_use_requirement("enabled,-disabled", std::tr1::shared_ptr<const PackageID>(), ELikeUseRequirementOptions() + euro_portage_syntax + euro_strict_parsing));
             TEST_CHECK_EQUAL(req1->as_raw_string(), "[enabled,-disabled]");
             TEST_CHECK_EQUAL(req1->as_human_string(), "Flag 'enabled' enabled; Flag 'disabled' disabled");
             TEST_CHECK(req1->requirement_met(&env, *id));
 
             std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req2(
-                parse_elike_use_requirement("enabled,disabled", std::tr1::shared_ptr<const PackageID>(), ELikeUseRequirementOptions() + euro_portage_syntax));
+                parse_elike_use_requirement("enabled,disabled", std::tr1::shared_ptr<const PackageID>(), ELikeUseRequirementOptions() + euro_portage_syntax + euro_strict_parsing));
             TEST_CHECK_EQUAL(req2->as_raw_string(), "[enabled,disabled]");
             TEST_CHECK_EQUAL(req2->as_human_string(), "Flag 'enabled' enabled; Flag 'disabled' enabled");
             TEST_CHECK(! req2->requirement_met(&env, *id));
 
             std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req3(
-                parse_elike_use_requirement("-enabled,-disabled", std::tr1::shared_ptr<const PackageID>(), ELikeUseRequirementOptions() + euro_portage_syntax));
+                parse_elike_use_requirement("-enabled,-disabled", std::tr1::shared_ptr<const PackageID>(), ELikeUseRequirementOptions() + euro_portage_syntax + euro_strict_parsing));
             TEST_CHECK_EQUAL(req3->as_raw_string(), "[-enabled,-disabled]");
             TEST_CHECK_EQUAL(req3->as_human_string(), "Flag 'enabled' disabled; Flag 'disabled' disabled");
             TEST_CHECK(! req3->requirement_met(&env, *id));
 
             std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req4(
-                parse_elike_use_requirement("enabled,-disabled,-enabled", std::tr1::shared_ptr<const PackageID>(), ELikeUseRequirementOptions() + euro_portage_syntax));
+                parse_elike_use_requirement("enabled,-disabled,-enabled", std::tr1::shared_ptr<const PackageID>(), ELikeUseRequirementOptions() + euro_portage_syntax + euro_strict_parsing));
             TEST_CHECK_EQUAL(req4->as_raw_string(), "[enabled,-disabled,-enabled]");
             TEST_CHECK_EQUAL(req4->as_human_string(), "Flag 'enabled' enabled; Flag 'disabled' disabled; Flag 'enabled' disabled");
             TEST_CHECK(! req4->requirement_met(&env, *id));
 
             std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req5(
-                parse_elike_use_requirement("enabled,-disabled,enabled", std::tr1::shared_ptr<const PackageID>(), ELikeUseRequirementOptions() + euro_portage_syntax));
+                parse_elike_use_requirement("enabled,-disabled,enabled", std::tr1::shared_ptr<const PackageID>(), ELikeUseRequirementOptions() + euro_portage_syntax + euro_strict_parsing));
             TEST_CHECK_EQUAL(req5->as_raw_string(), "[enabled,-disabled,enabled]");
             TEST_CHECK_EQUAL(req5->as_human_string(), "Flag 'enabled' enabled; Flag 'disabled' disabled; Flag 'enabled' enabled");
             TEST_CHECK(req5->requirement_met(&env, *id));
@@ -166,84 +166,84 @@ namespace test_cases
             id2->iuse_key()->set_from_string("pkgname", IUseFlagParseOptions());
 
             std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req1(
-                parse_elike_use_requirement("pkgname?", id, ELikeUseRequirementOptions() + euro_allow_self_deps));
+                parse_elike_use_requirement("pkgname?", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_strict_parsing));
             TEST_CHECK_EQUAL(req1->as_raw_string(), "[pkgname?]");
             TEST_CHECK_EQUAL(req1->as_human_string(), "Flag 'pkgname' enabled if it is enabled for 'cat/enabled-1:0::fake'");
             TEST_CHECK(req1->requirement_met(&env, *id));
             TEST_CHECK(! req1->requirement_met(&env, *id2));
 
             std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req2(
-                parse_elike_use_requirement("pkgname?", id2, ELikeUseRequirementOptions() + euro_allow_self_deps));
+                parse_elike_use_requirement("pkgname?", id2, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_strict_parsing));
             TEST_CHECK_EQUAL(req2->as_raw_string(), "[pkgname?]");
             TEST_CHECK_EQUAL(req2->as_human_string(), "Flag 'pkgname' enabled if it is enabled for 'cat/disabled-1:0::fake'");
             TEST_CHECK(req2->requirement_met(&env, *id));
             TEST_CHECK(req2->requirement_met(&env, *id2));
 
             std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req3(
-                parse_elike_use_requirement("-pkgname?", id, ELikeUseRequirementOptions() + euro_allow_self_deps));
+                parse_elike_use_requirement("-pkgname?", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_strict_parsing));
             TEST_CHECK_EQUAL(req3->as_raw_string(), "[-pkgname?]");
             TEST_CHECK_EQUAL(req3->as_human_string(), "Flag 'pkgname' disabled if it is enabled for 'cat/enabled-1:0::fake'");
             TEST_CHECK(! req3->requirement_met(&env, *id));
             TEST_CHECK(req3->requirement_met(&env, *id2));
 
             std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req4(
-                parse_elike_use_requirement("-pkgname?", id2, ELikeUseRequirementOptions() + euro_allow_self_deps));
+                parse_elike_use_requirement("-pkgname?", id2, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_strict_parsing));
             TEST_CHECK_EQUAL(req4->as_raw_string(), "[-pkgname?]");
             TEST_CHECK_EQUAL(req4->as_human_string(), "Flag 'pkgname' disabled if it is enabled for 'cat/disabled-1:0::fake'");
             TEST_CHECK(req4->requirement_met(&env, *id));
             TEST_CHECK(req4->requirement_met(&env, *id2));
 
             std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req5(
-                parse_elike_use_requirement("pkgname!?", id, ELikeUseRequirementOptions() + euro_allow_self_deps));
+                parse_elike_use_requirement("pkgname!?", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_strict_parsing));
             TEST_CHECK_EQUAL(req5->as_raw_string(), "[pkgname!?]");
             TEST_CHECK_EQUAL(req5->as_human_string(), "Flag 'pkgname' enabled if it is disabled for 'cat/enabled-1:0::fake'");
             TEST_CHECK(req5->requirement_met(&env, *id));
             TEST_CHECK(req5->requirement_met(&env, *id2));
 
             std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req6(
-                parse_elike_use_requirement("pkgname!?", id2, ELikeUseRequirementOptions() + euro_allow_self_deps));
+                parse_elike_use_requirement("pkgname!?", id2, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_strict_parsing));
             TEST_CHECK_EQUAL(req6->as_raw_string(), "[pkgname!?]");
             TEST_CHECK_EQUAL(req6->as_human_string(), "Flag 'pkgname' enabled if it is disabled for 'cat/disabled-1:0::fake'");
             TEST_CHECK(req6->requirement_met(&env, *id));
             TEST_CHECK(! req6->requirement_met(&env, *id2));
 
             std::tr1::shared_ptr<const AdditionalPackageDepSpecRequirement> req7(
-                parse_elike_use_requirement("-pkgname!?", id, ELikeUseRequirementOptions() + euro_allow_self_deps));
+                parse_elike_use_requirement("-pkgname!?", id, ELikeUseRequirementOptions() + euro_allow_self_deps + euro_strict_parsing));
             TEST_CHECK_EQUAL(req7->as_raw_string(), "[-pkgname!?]");
             TEST_CHECK_EQUAL(req7->as_human_string(), "Flag 'pkgname' disabled if it is disabled for 'cat/enabled-1:0::fake'");
             TEST_CHECK(re