diff --git a/src/Parser.cpp b/src/Parser.cpp
index 183058142..adc5a33db 100644
--- a/src/Parser.cpp
+++ b/src/Parser.cpp
@@ -182,8 +182,8 @@ Tree* Parser::parse ()
   findPattern ();
   findTag ();
   findAttribute ();
+  findAttributeModifier ();
   // GOOD ^^^
-  scan (&Parser::findAttributeModifier);
   scan (&Parser::findOperator);
   findCommand ();
   findUUIDList ();
@@ -1049,190 +1049,200 @@ void Parser::findAttribute ()
 
 ////////////////////////////////////////////////////////////////////////////////
 // <name>.<mod>[:=]['"]<value>['"]
-void Parser::findAttributeModifier (Tree* t)
+void Parser::findAttributeModifier ()
 {
-  context.debug ("findAttributeModifier");
-  context.debug (t->dump ());
+  context.debug ("Parser::findAttributeModifier");
+  bool action = false;
 
-  std::string raw = t->attribute ("raw");
-  Nibbler n (raw);
-
-  std::string name;
-  if (n.getUntil (".", name))
+  std::vector <Tree*> nodes;
+  collect (nodes, false);
+  std::vector <Tree*>::iterator i;
+  for (i = nodes.begin (); i != nodes.end (); ++i)
   {
-    std::string canonical;
-    if (canonicalize (canonical, "attribute", name) ||
-        canonicalize (canonical, "uda",       name))
+    std::string raw = (*i)->attribute ("raw");
+    Nibbler n (raw);
+
+    std::string name;
+    if (n.getUntil (".", name))
     {
-      if (n.skip ('.'))
+      std::string canonical;
+      if (canonicalize (canonical, "attribute", name) ||
+          canonicalize (canonical, "uda",       name))
       {
-        std::string sense = "+";
-        if (n.skip ('~'))
-          sense = "-";
-
-        std::string modifier;
-        n.getUntilOneOf (":=", modifier);
-
-        if (n.skip (':') ||
-            n.skip ('='))
+        if (n.skip ('.'))
         {
-          std::string value;
-          if (n.getQuoted   ('"', value)  ||
-              n.getQuoted   ('\'', value) ||
-              n.getUntilEOS (value)       ||
-              n.depleted ())
+          std::string sense = "+";
+          if (n.skip ('~'))
+            sense = "-";
+
+          std::string modifier;
+          n.getUntilOneOf (":=", modifier);
+
+          if (n.skip (':') ||
+              n.skip ('='))
           {
-            if (value == "")
-              value = "''";
-
-            t->unTag ("?");
-            t->removeAllBranches ();
-            t->tag ("ATTMOD");
-            t->attribute ("name", canonical);
-            t->attribute ("raw", value);
-            t->attribute ("modifier", modifier);
-            t->attribute ("sense", sense);
-
-            Tree* branch = t->addBranch (new Tree ("argAttmod"));
-            branch->attribute ("raw", canonical);
-
-            if (modifier == "before" || modifier == "under" || modifier == "below")
+            std::string value;
+            if (n.getQuoted   ('"', value)  ||
+                n.getQuoted   ('\'', value) ||
+                n.getUntilEOS (value)       ||
+                n.depleted ())
             {
-              branch = t->addBranch (new Tree ("argAttmod"));
-              branch->attribute ("raw", "<");
-              branch->tag ("OP");
+              if (value == "")
+                value = "''";
 
-              branch = t->addBranch (new Tree ("argAttmod"));
-              branch->attribute ("raw", value);
-            }
-            else if (modifier == "after" || modifier == "over" || modifier == "above")
-            {
-              branch = t->addBranch (new Tree ("argAttmod"));
-              branch->attribute ("raw", ">");
-              branch->tag ("OP");
+              (*i)->unTag ("?");
+              (*i)->removeAllBranches ();
+              (*i)->tag ("ATTMOD");
+              (*i)->attribute ("name", canonical);
+              (*i)->attribute ("raw", value);
+              (*i)->attribute ("modifier", modifier);
+              (*i)->attribute ("sense", sense);
+              action = true;
 
-              branch = t->addBranch (new Tree ("argAttmod"));
-              branch->attribute ("raw", value);
-            }
-            else if (modifier == "none")
-            {
-              branch = t->addBranch (new Tree ("argAttmod"));
-              branch->attribute ("raw", "==");
-              branch->tag ("OP");
+              Tree* branch = (*i)->addBranch (new Tree ("argAttmod"));
+              branch->attribute ("raw", canonical);
 
-              branch = t->addBranch (new Tree ("argAttmod"));
-              branch->attribute ("raw", "''");
-            }
-            else if (modifier == "any")
-            {
-              branch = t->addBranch (new Tree ("argAttmod"));
-              branch->attribute ("raw", "!=");
-              branch->tag ("OP");
+              if (modifier == "before" || modifier == "under" || modifier == "below")
+              {
+                branch = (*i)->addBranch (new Tree ("argAttmod"));
+                branch->attribute ("raw", "<");
+                branch->tag ("OP");
 
-              branch = t->addBranch (new Tree ("argAttmod"));
-              branch->attribute ("raw", "''");
-            }
-            else if (modifier == "is" || modifier == "equals")
-            {
-              branch = t->addBranch (new Tree ("argAttmod"));
-              branch->attribute ("raw", "==");
-              branch->tag ("OP");
+                branch = (*i)->addBranch (new Tree ("argAttmod"));
+                branch->attribute ("raw", value);
+              }
+              else if (modifier == "after" || modifier == "over" || modifier == "above")
+              {
+                branch = (*i)->addBranch (new Tree ("argAttmod"));
+                branch->attribute ("raw", ">");
+                branch->tag ("OP");
 
-              branch = t->addBranch (new Tree ("argAttmod"));
-              branch->attribute ("raw", value);
-            }
-            else if (modifier == "isnt" || modifier == "not")
-            {
-              branch = t->addBranch (new Tree ("argAttmod"));
-              branch->attribute ("raw", "!=");
-              branch->tag ("OP");
+                branch = (*i)->addBranch (new Tree ("argAttmod"));
+                branch->attribute ("raw", value);
+              }
+              else if (modifier == "none")
+              {
+                branch = (*i)->addBranch (new Tree ("argAttmod"));
+                branch->attribute ("raw", "==");
+                branch->tag ("OP");
 
-              branch = t->addBranch (new Tree ("argAttmod"));
-              branch->attribute ("raw", value);
-            }
-            else if (modifier == "has" || modifier == "contains")
-            {
-              branch = t->addBranch (new Tree ("argAttmod"));
-              branch->attribute ("raw", "~");
-              branch->tag ("OP");
+                branch = (*i)->addBranch (new Tree ("argAttmod"));
+                branch->attribute ("raw", "''");
+              }
+              else if (modifier == "any")
+              {
+                branch = (*i)->addBranch (new Tree ("argAttmod"));
+                branch->attribute ("raw", "!=");
+                branch->tag ("OP");
 
-              branch = t->addBranch (new Tree ("argAttmod"));
-              branch->attribute ("raw", value);
-            }
-            else if (modifier == "hasnt")
-            {
-              branch = t->addBranch (new Tree ("argAttmod"));
-              branch->attribute ("raw", "!~");
-              branch->tag ("OP");
+                branch = (*i)->addBranch (new Tree ("argAttmod"));
+                branch->attribute ("raw", "''");
+              }
+              else if (modifier == "is" || modifier == "equals")
+              {
+                branch = (*i)->addBranch (new Tree ("argAttmod"));
+                branch->attribute ("raw", "==");
+                branch->tag ("OP");
 
-              branch = t->addBranch (new Tree ("argAttmod"));
-              branch->attribute ("raw", value);
-            }
-            else if (modifier == "startswith" || modifier == "left")
-            {
-              branch = t->addBranch (new Tree ("argAttmod"));
-              branch->attribute ("raw", "~");
-              branch->tag ("OP");
+                branch = (*i)->addBranch (new Tree ("argAttmod"));
+                branch->attribute ("raw", value);
+              }
+              else if (modifier == "isnt" || modifier == "not")
+              {
+                branch = (*i)->addBranch (new Tree ("argAttmod"));
+                branch->attribute ("raw", "!=");
+                branch->tag ("OP");
 
-              branch = t->addBranch (new Tree ("argAttmod"));
-              branch->attribute ("raw", "'^" + value + "'");
-            }
-            else if (modifier == "endswith" || modifier == "right")
-            {
-              branch = t->addBranch (new Tree ("argAttmod"));
-              branch->attribute ("raw", "~");
-              branch->tag ("OP");
+                branch = (*i)->addBranch (new Tree ("argAttmod"));
+                branch->attribute ("raw", value);
+              }
+              else if (modifier == "has" || modifier == "contains")
+              {
+                branch = (*i)->addBranch (new Tree ("argAttmod"));
+                branch->attribute ("raw", "~");
+                branch->tag ("OP");
 
-              branch = t->addBranch (new Tree ("argAttmod"));
-              branch->attribute ("raw", "'" + value + "$'");
-            }
-            else if (modifier == "word")
-            {
-              branch = t->addBranch (new Tree ("argAttmod"));
-              branch->attribute ("raw", "~");
-              branch->tag ("OP");
+                branch = (*i)->addBranch (new Tree ("argAttmod"));
+                branch->attribute ("raw", value);
+              }
+              else if (modifier == "hasnt")
+              {
+                branch = (*i)->addBranch (new Tree ("argAttmod"));
+                branch->attribute ("raw", "!~");
+                branch->tag ("OP");
 
-              branch = t->addBranch (new Tree ("argAttmod"));
+                branch = (*i)->addBranch (new Tree ("argAttmod"));
+                branch->attribute ("raw", value);
+              }
+              else if (modifier == "startswith" || modifier == "left")
+              {
+                branch = (*i)->addBranch (new Tree ("argAttmod"));
+                branch->attribute ("raw", "~");
+                branch->tag ("OP");
+
+                branch = (*i)->addBranch (new Tree ("argAttmod"));
+                branch->attribute ("raw", "'^" + value + "'");
+              }
+              else if (modifier == "endswith" || modifier == "right")
+              {
+                branch = (*i)->addBranch (new Tree ("argAttmod"));
+                branch->attribute ("raw", "~");
+                branch->tag ("OP");
+
+                branch = (*i)->addBranch (new Tree ("argAttmod"));
+                branch->attribute ("raw", "'" + value + "$'");
+              }
+              else if (modifier == "word")
+              {
+                branch = (*i)->addBranch (new Tree ("argAttmod"));
+                branch->attribute ("raw", "~");
+                branch->tag ("OP");
+
+                branch = (*i)->addBranch (new Tree ("argAttmod"));
 
 #if defined (DARWIN)
-              branch->attribute ("raw", value);
+                branch->attribute ("raw", value);
 #elif defined (SOLARIS)
-              branch->attribute ("raw", "'\\<" + value + "\\>'");
+                branch->attribute ("raw", "'\\<" + value + "\\>'");
 #else
-              branch->attribute ("raw", "'\\b" + value + "\\b'");
+                branch->attribute ("raw", "'\\b" + value + "\\b'");
 #endif
-            }
-            else if (modifier == "noword")
-            {
-              branch = t->addBranch (new Tree ("argAttmod"));
-              branch->attribute ("raw", "!~");
-              branch->tag ("OP");
+              }
+              else if (modifier == "noword")
+              {
+                branch = (*i)->addBranch (new Tree ("argAttmod"));
+                branch->attribute ("raw", "!~");
+                branch->tag ("OP");
 
-              branch = t->addBranch (new Tree ("argAttmod"));
+                branch = (*i)->addBranch (new Tree ("argAttmod"));
 
 #if defined (DARWIN)
-              branch->attribute ("raw", value);
+                branch->attribute ("raw", value);
 #elif defined (SOLARIS)
-              branch->attribute ("raw", "'\\<" + value + "\\>'");
+                branch->attribute ("raw", "'\\<" + value + "\\>'");
 #else
-              branch->attribute ("raw", "'\\b" + value + "\\b'");
+                branch->attribute ("raw", "'\\b" + value + "\\b'");
 #endif
-            }
-            else
-              throw format (STRING_PARSER_UNKNOWN_ATTMOD, modifier);
+              }
+              else
+                throw format (STRING_PARSER_UNKNOWN_ATTMOD, modifier);
 
-            std::map <std::string, Column*>::const_iterator col;
-            col = context.columns.find (canonical);
-            if (col != context.columns.end () &&
-                col->second->modifiable ())
-            {
-              t->tag ("MODIFIABLE");
+              std::map <std::string, Column*>::const_iterator col;
+              col = context.columns.find (canonical);
+              if (col != context.columns.end () &&
+                  col->second->modifiable ())
+              {
+                (*i)->tag ("MODIFIABLE");
+              }
             }
           }
         }
       }
     }
   }
+
+  if (action)
+    context.debug (_tree->dump ());
 }
 
 ////////////////////////////////////////////////////////////////////////////////
diff --git a/src/Parser.h b/src/Parser.h
index 3de878e58..6493247ac 100644
--- a/src/Parser.h
+++ b/src/Parser.h
@@ -76,7 +76,7 @@ private:
   void findSubstitution ();
   void findTag ();
   void findAttribute ();
-  void findAttributeModifier (Tree*);
+  void findAttributeModifier ();
   void findOperator (Tree*);
   void findFilter ();
   void findModifications ();