ENH: Moved ExpandListVariables out of individual commands. Argument evaluation rules are now very consistent. Double quotes can always be used to create exactly one argument, regardless of contents inside.

53 files changed, 607 insertions, 629 deletions

diff --git a/Source/cmAbstractFilesCommand.cxx b/Source/cmAbstractFilesCommand.cxx
index e74653e..e0601cb 100644
--- a/Source/cmAbstractFilesCommand.cxx
+++ b/Source/cmAbstractFilesCommand.cxx
@@ -19,7 +19,7 @@
 #include "cmSourceFile.h"
 
 // cmAbstractFilesCommand
-bool cmAbstractFilesCommand::InitialPass(std::vector<std::string> const& argsIn)
+bool cmAbstractFilesCommand::InitialPass(std::vector<std::string> const& args)
 {
   const char* versionValue
     = m_Makefile->GetDefinition("CMAKE_MINIMUM_REQUIRED_VERSION");
@@ -29,13 +29,11 @@ bool cmAbstractFilesCommand::InitialPass(std::vector<std::string> const& argsIn)
     return false;
     }
   
-  if(argsIn.size() < 1 )
+  if(args.size() < 1 )
     {
     this->SetError("called with incorrect number of arguments");
     return false;
     }
-  std::vector<std::string> args;
-  cmSystemTools::ExpandListArguments(argsIn, args);
 
   bool ret = true;
   std::string m = "could not find source file(s):\n";
diff --git a/Source/cmAddCustomCommandCommand.cxx b/Source/cmAddCustomCommandCommand.cxx
index 6b1c09c..a0a017d 100644
--- a/Source/cmAddCustomCommandCommand.cxx
+++ b/Source/cmAddCustomCommandCommand.cxx
@@ -18,19 +18,17 @@
 
 
 // cmAddCustomCommandCommand
-bool cmAddCustomCommandCommand::InitialPass(std::vector<std::string> const& argsIn)
+bool cmAddCustomCommandCommand::InitialPass(std::vector<std::string> const& args)
 {
   /* Let's complain at the end of this function about the lack of a particular
      arg. For the moment, let's say that COMMAND, TARGET are always 
      required.
   */
-  if (argsIn.size() < 4)
+  if (args.size() < 4)
     {
       this->SetError("called with wrong number of arguments.");
       return false;
     }
-  std::vector<std::string> args;
-  cmSystemTools::ExpandListArguments(argsIn, args);
 
   std::string source, command, target, comment;
   std::vector<std::string> command_args, depends, outputs;
diff --git a/Source/cmAddCustomTargetCommand.cxx b/Source/cmAddCustomTargetCommand.cxx
index c14264d..77ab3ef 100644
--- a/Source/cmAddCustomTargetCommand.cxx
+++ b/Source/cmAddCustomTargetCommand.cxx
@@ -17,17 +17,15 @@
 #include "cmAddCustomTargetCommand.h"
 
 // cmAddCustomTargetCommand
-bool cmAddCustomTargetCommand::InitialPass(std::vector<std::string> const& argsIn)
+bool cmAddCustomTargetCommand::InitialPass(std::vector<std::string> const& args)
 {
   bool all = false;
   
-  if(argsIn.size() < 2 )
+  if(args.size() < 2 )
     {
     this->SetError("called with incorrect number of arguments");
     return false;
     }
-  std::vector<std::string> args;
-  cmSystemTools::ExpandListArguments(argsIn, args);
 
   // all target option
   std::string arguments;
diff --git a/Source/cmAddDefinitionsCommand.cxx b/Source/cmAddDefinitionsCommand.cxx
index 4cb42dd..5067e3f 100644
--- a/Source/cmAddDefinitionsCommand.cxx
+++ b/Source/cmAddDefinitionsCommand.cxx
@@ -17,15 +17,13 @@
 #include "cmAddDefinitionsCommand.h"
 
 // cmAddDefinitionsCommand
-bool cmAddDefinitionsCommand::InitialPass(std::vector<std::string> const& argsIn)
+bool cmAddDefinitionsCommand::InitialPass(std::vector<std::string> const& args)
 {
   // it is OK to have no arguments
-  if(argsIn.size() < 1 )
+  if(args.size() < 1 )
     {
     return true;
     }
-  std::vector<std::string> args;
-  cmSystemTools::ExpandListArguments(argsIn, args);
 
   for(std::vector<std::string>::const_iterator i = args.begin();
       i != args.end(); ++i)
diff --git a/Source/cmAddDependenciesCommand.cxx b/Source/cmAddDependenciesCommand.cxx
index 57034d4..cfae2ce 100644
--- a/Source/cmAddDependenciesCommand.cxx
+++ b/Source/cmAddDependenciesCommand.cxx
@@ -17,15 +17,13 @@
 #include "cmAddDependenciesCommand.h"
 
 // cmDependenciesCommand
-bool cmAddDependenciesCommand::InitialPass(std::vector<std::string> const& argsIn)
+bool cmAddDependenciesCommand::InitialPass(std::vector<std::string> const& args)
 {
-  if(argsIn.size() < 2 )
+  if(args.size() < 2 )
     {
     this->SetError("called with incorrect number of arguments");
     return false;
     }
-  std::vector<std::string> args;
-  cmSystemTools::ExpandListArguments(argsIn, args);
 
   std::string target_name = args[0];
 
diff --git a/Source/cmAddExecutableCommand.cxx b/Source/cmAddExecutableCommand.cxx
index cfae79f..09aae18 100644
--- a/Source/cmAddExecutableCommand.cxx
+++ b/Source/cmAddExecutableCommand.cxx
@@ -17,16 +17,14 @@
 #include "cmAddExecutableCommand.h"
 
 // cmExecutableCommand
-bool cmAddExecutableCommand::InitialPass(std::vector<std::string> const& argsIn)
+bool cmAddExecutableCommand::InitialPass(std::vector<std::string> const& args)
 {
-  if(argsIn.size() < 2 )
+  if(args.size() < 2 )
     {
     this->SetError("called with incorrect number of arguments");
     return false;
     }
-  std::vector<std::string> args;
-  cmSystemTools::ExpandListArguments(argsIn, args);
-  std::vector<std::string>::iterator s = args.begin();
+  std::vector<std::string>::const_iterator s = args.begin();
 
   std::string exename = *s;
 
diff --git a/Source/cmAddLibraryCommand.cxx b/Source/cmAddLibraryCommand.cxx
index b61b6ac..cb7c2d7 100644
--- a/Source/cmAddLibraryCommand.cxx
+++ b/Source/cmAddLibraryCommand.cxx
@@ -17,15 +17,13 @@
 #include "cmAddLibraryCommand.h"
 
 // cmLibraryCommand
-bool cmAddLibraryCommand::InitialPass(std::vector<std::string> const& argsIn)
+bool cmAddLibraryCommand::InitialPass(std::vector<std::string> const& args)
 {
-  if(argsIn.size() < 1 )
+  if(args.size() < 1 )
     {
     this->SetError("called with incorrect number of arguments");
     return false;
     }
-  std::vector<std::string> args;
-  cmSystemTools::ExpandListArguments(argsIn, args);
   // Library type defaults to value of BUILD_SHARED_LIBS, if it exists,
   // otherwise it defaults to static library.
   int shared = !cmSystemTools::IsOff(m_Makefile->GetDefinition("BUILD_SHARED_LIBS"));
diff --git a/Source/cmAddTestCommand.cxx b/Source/cmAddTestCommand.cxx
index 09417a1..5802779 100644
--- a/Source/cmAddTestCommand.cxx
+++ b/Source/cmAddTestCommand.cxx
@@ -32,8 +32,7 @@ bool cmAddTestCommand::InitialPass(std::vector<std::string> const& args)
   // store the arguments for the final pass
   // also expand any CMake variables
 
-  m_Args.erase(m_Args.begin(), m_Args.end());
-  cmSystemTools::ExpandListArguments(args, m_Args);
+  m_Args = args;
   return true;
 }
 
diff --git a/Source/cmCPluginAPI.cxx b/Source/cmCPluginAPI.cxx
index 56da7d3..7116f4d 100644
--- a/Source/cmCPluginAPI.cxx
+++ b/Source/cmCPluginAPI.cxx
@@ -296,12 +296,14 @@ void cmExecuteCommand(void *arg, const char *name,
 {
   cmMakefile *mf = static_cast<cmMakefile *>(arg);
   std::vector<std::string> args2;
-  int i;
-  for (i = 0; i < numArgs; ++i)
+  cmListFileFunction lff;
+  lff.m_Name = name;
+  for(int i = 0; i < numArgs; ++i)
     {
-    args2.push_back(args[i]);
+    // Assume all arguments are quoted.
+    lff.m_Arguments.push_back(cmListFileArgument(args[i], true));
     }
-  mf->ExecuteCommand(std::string(name), args2);
+  mf->ExecuteCommand(lff);
 }
 
 void cmExpandSourceListArguments(void *arg, 
diff --git a/Source/cmCommand.h b/Source/cmCommand.h
index 66228da..44e95d2 100644
--- a/Source/cmCommand.h
+++ b/Source/cmCommand.h
@@ -18,7 +18,8 @@
 #define cmCommand_h
 
 #include "cmStandardIncludes.h"
-class cmMakefile;
+#include "cmListFileCache.h"
+#include "cmMakefile.h"
 
 /** \class cmCommand
  * \brief Superclass for all commands in CMake.
@@ -51,6 +52,18 @@ public:
     {m_Makefile = m; }
 
   /**
+   * This is called by the cmMakefile when the command is first
+   * encountered in the CMakeLists.txt file.  It expands the command's
+   * arguments and then invokes the InitialPass.
+   */
+  virtual bool InvokeInitialPass(const std::vector<cmListFileArgument>& args)
+    {
+    std::vector<std::string> expandedArguments;
+    m_Makefile->ExpandArguments(args, expandedArguments);
+    return this->InitialPass(expandedArguments);
+    }
+
+  /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
@@ -159,13 +172,14 @@ private:
 
 // All subclasses of cmCommand should invoke this macro.
 #define cmTypeMacro(thisClass,superclass) \
+typedef superclass Superclass; \
 static bool IsTypeOf(const char *type) \
 { \
   if ( !strcmp(#thisClass,type) ) \
     { \
     return true; \
     } \
-  return superclass::IsTypeOf(type); \
+  return Superclass::IsTypeOf(type); \
 } \
 virtual bool IsA(const char *type) \
 { \
diff --git a/Source/cmCreateTestSourceList.cxx b/Source/cmCreateTestSourceList.cxx
index 5ed0f44..8de8865 100644
--- a/Source/cmCreateTestSourceList.cxx
+++ b/Source/cmCreateTestSourceList.cxx
@@ -18,18 +18,16 @@
 #include "cmSourceFile.h"
 
 // cmCreateTestSourceList
-bool cmCreateTestSourceList::InitialPass(std::vector<std::string> const& argsIn)
+bool cmCreateTestSourceList::InitialPass(std::vector<std::string> const& args)
 {
-  if (argsIn.size() < 3)
+  if (args.size() < 3)
     {
     this->SetError("called with wrong number of arguments.");
     return false;
     }
 
-  std::vector<std::string> args;
-  cmSystemTools::ExpandListArguments(argsIn, args);
   
-  std::vector<std::string>::iterator i = args.begin();
+  std::vector<std::string>::const_iterator i = args.begin();
   std::string extraInclude;
   std::string function;
   std::vector<std::string> tests;
@@ -120,7 +118,7 @@ bool cmCreateTestSourceList::InitialPass(std::vector<std::string> const& argsIn)
     "/* Forward declare test functions. */\n"
     "\n";
 
-  std::vector<std::string>::iterator testsBegin = i;
+  std::vector<std::string>::const_iterator testsBegin = i;
   std::vector<std::string> tests_func_name;
 
   // The rest of the arguments consist of a list of test source files.
diff --git a/Source/cmEndForEachCommand.cxx b/Source/cmEndForEachCommand.cxx
index 7a0dca9..f29feb9 100644
--- a/Source/cmEndForEachCommand.cxx
+++ b/Source/cmEndForEachCommand.cxx
@@ -16,7 +16,7 @@
 =========================================================================*/
 #include "cmEndForEachCommand.h"
 
-bool cmEndForEachCommand::InitialPass(std::vector<std::string> const& args)
+bool cmEndForEachCommand::InvokeInitialPass(std::vector<cmListFileArgument> const& args)
 {
   if(args.size() < 1 )
     {
@@ -25,7 +25,10 @@ bool cmEndForEachCommand::InitialPass(std::vector<std::string> const& args)
     }
 
   // remove any function blockers for this define
-  m_Makefile->RemoveFunctionBlocker("ENDFOREACH",args);
+  cmListFileFunction lff;
+  lff.m_Name = "ENDFOREACH";
+  lff.m_Arguments = args;
+  m_Makefile->RemoveFunctionBlocker(lff);
   
   return true;
 }
diff --git a/Source/cmEndForEachCommand.h b/Source/cmEndForEachCommand.h
index 101dcb3..e250177 100644
--- a/Source/cmEndForEachCommand.h
+++ b/Source/cmEndForEachCommand.h
@@ -37,10 +37,16 @@ public:
     }
 
   /**
+   * Override cmCommand::InvokeInitialPass to get arguments before
+   * expansion.
+   */
+  virtual bool InvokeInitialPass(std::vector<cmListFileArgument> const&);
+  
+  /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args);
+  virtual bool InitialPass(std::vector<std::string> const&) {}
 
   /**
    * This determines if the command gets propagated down
diff --git a/Source/cmFindFileCommand.cxx b/Source/cmFindFileCommand.cxx
index f04429e..54f4d27 100644
--- a/Source/cmFindFileCommand.cxx
+++ b/Source/cmFindFileCommand.cxx
@@ -31,12 +31,12 @@ bool cmFindFileCommand::InitialPass(std::vector<std::string> const& argsIn)
   std::string helpString = "Where can the ";
   helpString += argsIn[1] + " file be found";
   size_t size = argsIn.size();
-  std::vector<std::string> argst;
+  std::vector<std::string> args;
   for(unsigned int j = 0; j < size; ++j)
     {
     if(argsIn[j] != "DOC")
       {
-      argst.push_back(argsIn[j]);
+      args.push_back(argsIn[j]);
       }
     else
       {
@@ -47,8 +47,6 @@ bool cmFindFileCommand::InitialPass(std::vector<std::string> const& argsIn)
       break;
       }
     }
-  std::vector<std::string> args;
-  cmSystemTools::ExpandListArguments(argst, args);
 
   std::vector<std::string>::const_iterator i = args.begin();
   // Use the first argument as the name of something to be defined
diff --git a/Source/cmFindLibraryCommand.cxx b/Source/cmFindLibraryCommand.cxx
index ff7bf44..70c97a4 100644
--- a/Source/cmFindLibraryCommand.cxx
+++ b/Source/cmFindLibraryCommand.cxx
@@ -27,12 +27,12 @@ bool cmFindLibraryCommand::InitialPass(std::vector<std::string> const& argsIn)
     } 
   std::string helpString;
   size_t size = argsIn.size();
-  std::vector<std::string> argst;
+  std::vector<std::string> args;
   for(unsigned int j = 0; j < size; ++j)
     {
     if(argsIn[j] != "DOC")
       {
-      argst.push_back(argsIn[j]);
+      args.push_back(argsIn[j]);
       }
     else
       {
@@ -43,8 +43,6 @@ bool cmFindLibraryCommand::InitialPass(std::vector<std::string> const& argsIn)
       break;
       }
     }
-  std::vector<std::string> args;
-  cmSystemTools::ExpandListArguments(argst, args);
 
   std::vector<std::string> path;
   std::vector<std::string> names;
diff --git a/Source/cmFindPathCommand.cxx b/Source/cmFindPathCommand.cxx
index e23ffad..dd7c870 100644
--- a/Source/cmFindPathCommand.cxx
+++ b/Source/cmFindPathCommand.cxx
@@ -30,13 +30,13 @@ bool cmFindPathCommand::InitialPass(std::vector<std::string> const& argsIn)
   // already, if so use that value and don't look for the program
   std::string helpString = "What is the path where the file ";
   helpString += argsIn[1] + " can be found";
-  std::vector<std::string> argst;
+  std::vector<std::string> args;
   size_t size = argsIn.size();
   for(unsigned int j = 0; j < size; ++j)
     {
     if(argsIn[j] != "DOC")
       {
-      argst.push_back(argsIn[j]);
+      args.push_back(argsIn[j]);
       }
     else
       {
@@ -47,8 +47,6 @@ bool cmFindPathCommand::InitialPass(std::vector<std::string> const& argsIn)
       break;
       }
     }
-  std::vector<std::string> args;
-  cmSystemTools::ExpandListArguments(argst, args);
 
   const char* cacheValue
     = m_Makefile->GetDefinition(args[0].c_str());
diff --git a/Source/cmFindProgramCommand.cxx b/Source/cmFindProgramCommand.cxx
index 1ec03a9..84f7dab 100644
--- a/Source/cmFindProgramCommand.cxx
+++ b/Source/cmFindProgramCommand.cxx
@@ -30,12 +30,12 @@ bool cmFindProgramCommand::InitialPass(std::vector<std::string> const& argsIn)
     }
   std::string doc = "Path to a program.";
   size_t size = argsIn.size();
-  std::vector<std::string> argst;
+  std::vector<std::string> args;
   for(unsigned int j = 0; j < size; ++j)
     {
     if(argsIn[j] != "DOC")
       {
-      argst.push_back(argsIn[j]);
+      args.push_back(argsIn[j]);
       }
     else
       {
@@ -46,9 +46,6 @@ bool cmFindProgramCommand::InitialPass(std::vector<std::string> const& argsIn)
       break;
       }
     }
-  std::vector<std::string> args;
-  cmSystemTools::ExpandListArguments(argst, args);
-
 
   std::vector<std::string>::iterator i = args.begin();
   // Use the first argument as the name of something to be defined
diff --git a/Source/cmForEachCommand.cxx b/Source/cmForEachCommand.cxx
index 9c344e1..e8d1ac6 100644
--- a/Source/cmForEachCommand.cxx
+++ b/Source/cmForEachCommand.cxx
@@ -17,68 +17,71 @@
 #include "cmForEachCommand.h"
 
 bool cmForEachFunctionBlocker::
-IsFunctionBlocked(const char *name, const std::vector<std::string> &args, 
-                  cmMakefile &mf) 
+IsFunctionBlocked(const cmListFileFunction& lff, cmMakefile &mf) 
 {
-  // prevent recusion and don't let this blobker blobk its own commands
+  // Prevent recusion and don't let this blobker block its own
+  // commands.
   if (m_Executing)
     {
     return false;
     }
   
   // at end of for each execute recorded commands
-  if (!strcmp(name,"ENDFOREACH") && args[0] == m_Args[0])
+  if (lff.m_Name == "ENDFOREACH")
     {
-    m_Executing = true;
-    std::string variable = "${";
-    variable += m_Args[0];
-    variable += "}"; 
-    std::vector<std::string>::const_iterator j = m_Args.begin();
-    ++j;
-    
-    for( ; j != m_Args.end(); ++j)
-      {   
-      // perform string replace
-        for(unsigned int c = 0; c < m_Commands.size(); ++c)
-        {
-        std::vector<std::string> newArgs;
-        for (std::vector<std::string>::const_iterator k = 
-               m_CommandArguments[c].begin();
-             k != m_CommandArguments[c].end(); ++k)
+    std::vector<std::string> expandedArguments;
+    mf.ExpandArguments(lff.m_Arguments, expandedArguments);
+    if(!expandedArguments.empty() && (expandedArguments[0] == m_Args[0]))
+      {
+      m_Executing = true;
+      std::string variable = "${";
+      variable += m_Args[0];
+      variable += "}"; 
+      std::vector<std::string>::const_iterator j = m_Args.begin();
+      ++j;
+      
+      for( ; j != m_Args.end(); ++j)
+        {   
+        // Invoke all the functions that were collected in the block.
+        for(unsigned int c = 0; c < m_Functions.size(); ++c)
           {
-          std::string tmps = *k;
-          cmSystemTools::ReplaceString(tmps, variable.c_str(),
-                                       j->c_str());
-          newArgs.push_back(tmps);
+          // Replace the loop variable and then invoke the command.
+          cmListFileFunction newLFF;
+          newLFF.m_Name = m_Functions[c].m_Name;
+          for (std::vector<cmListFileArgument>::const_iterator k = 
+                 m_Functions[c].m_Arguments.begin();
+               k != m_Functions[c].m_Arguments.end(); ++k)
+            {
+            std::string tmps = k->Value;
+            cmSystemTools::ReplaceString(tmps, variable.c_str(), j->c_str());
+            cmListFileArgument arg(tmps, k->Quoted);
+            newLFF.m_Arguments.push_back(arg);
+            }
+          mf.ExecuteCommand(newLFF);
           }
-        // execute command
-        mf.ExecuteCommand(m_Commands[c],newArgs);
         }
+      return false;
       }
-    return false;
     }
 
   // record the command
-  m_Commands.push_back(name);
-  std::vector<std::string> newArgs;
-  for(std::vector<std::string>::const_iterator j = args.begin();
-      j != args.end(); ++j)
-    {   
-    newArgs.push_back(*j);
-    }
-  m_CommandArguments.push_back(newArgs);
+  m_Functions.push_back(lff);
   
   // always return true
   return true;
 }
 
 bool cmForEachFunctionBlocker::
-ShouldRemove(const char *name, const std::vector<std::string> &args, 
-             cmMakefile &) 
+ShouldRemove(const cmListFileFunction& lff, cmMakefile& mf)
 {
-  if (!strcmp(name,"ENDFOREACH") && args[0] == m_Args[0])
+  if(lff.m_Name == "ENDFOREACH")
     {
-    return true;
+    std::vector<std::string> expandedArguments;
+    mf.ExpandArguments(lff.m_Arguments, expandedArguments);
+    if(!expandedArguments.empty() && (expandedArguments[0] == m_Args[0]))
+      {
+      return true;
+      }
     }
   return false;
 }
@@ -90,11 +93,8 @@ ScopeEnded(cmMakefile &mf)
                        mf.GetCurrentDirectory());
 }
 
-bool cmForEachCommand::InitialPass(std::vector<std::string> const& argsIn)
+bool cmForEachCommand::InitialPass(std::vector<std::string> const& args)
 {
-  std::vector<std::string> args;
-  cmSystemTools::ExpandListArguments(argsIn, args);
-
   if(args.size() < 1)
     {
     this->SetError("called with incorrect number of arguments");
@@ -103,11 +103,7 @@ bool cmForEachCommand::InitialPass(std::vector<std::string> const& argsIn)
   
   // create a function blocker
   cmForEachFunctionBlocker *f = new cmForEachFunctionBlocker();
-  for(std::vector<std::string>::const_iterator j = args.begin();
-      j != args.end(); ++j)
-    {   
-    f->m_Args.push_back(*j);
-    }
+  f->m_Args = args;
   m_Makefile->AddFunctionBlocker(f);
   
   return true;
diff --git a/Source/cmForEachCommand.h b/Source/cmForEachCommand.h
index 8e73d82..95911e6 100644
--- a/Source/cmForEachCommand.h
+++ b/Source/cmForEachCommand.h
@@ -20,6 +20,7 @@
 #include "cmStandardIncludes.h"
 #include "cmCommand.h"
 #include "cmFunctionBlocker.h"
+#include "cmListFileCache.h"
 
 /** \class cmForEachFunctionBlocker
  * \brief subclass of function blocker
@@ -31,19 +32,13 @@ class cmForEachFunctionBlocker : public cmFunctionBlocker
 public:
   cmForEachFunctionBlocker() {m_Executing = false;}
   virtual ~cmForEachFunctionBlocker() {}
-  virtual bool IsFunctionBlocked(const char *name, 
-                                 const std::vector<std::string> &args, 
+  virtual bool IsFunctionBlocked(const cmListFileFunction& lff,
                                  cmMakefile &mf);
-  virtual bool ShouldRemove(const char *name, 
-                            const std::vector<std::string> &args, 
-                            cmMakefile &mf);
+  virtual bool ShouldRemove(const cmListFileFunction& lff, cmMakefile &mf);
   virtual void ScopeEnded(cmMakefile &mf);
   
-  virtual int NeedExpandedVariables () { return 0; };
-
   std::vector<std::string> m_Args;
-  std::vector<std::string> m_Commands;
-  std::vector<std::vector<std::string> > m_CommandArguments;
+  std::vector<cmListFileFunction> m_Functions;
   bool m_Executing;
 };
 
diff --git a/Source/cmFunctionBlocker.h b/Source/cmFunctionBlocker.h
index 95ee945..09b80ca 100644
--- a/Source/cmFunctionBlocker.h
+++ b/Source/cmFunctionBlocker.h
@@ -31,15 +31,14 @@ public:
   /**
    * should a function be blocked
    */
-  virtual bool IsFunctionBlocked(const char *name, const std::vector<std::string> &args, 
+  virtual bool IsFunctionBlocked(const cmListFileFunction& lff,
                                  cmMakefile&mf) = 0;
 
   /**
    * should this function blocker be removed, useful when one function adds a
    * blocker and another must remove it 
    */
-  virtual bool ShouldRemove(const char *, 
-                            const std::vector<std::string>&,
+  virtual bool ShouldRemove(const cmListFileFunction& lff,
                             cmMakefile&) {return false;}
 
   /**
@@ -50,8 +49,6 @@ public:
   virtual void ScopeEnded(cmMakefile&) {}
 
   virtual ~cmFunctionBlocker() {}
-
-  virtual int NeedExpandedVariables () { return 1; };
 };
 
 #endif
diff --git a/Source/cmITKWrapTclCommand.cxx b/Source/cmITKWrapTclCommand.cxx
index e762ce5..c7a2cc8 100644
--- a/Source/cmITKWrapTclCommand.cxx
+++ b/Source/cmITKWrapTclCommand.cxx
@@ -59,15 +59,13 @@ cmITKWrapTclCommand::AddDependencies(cmDependInformation const *info,
 }
 
 // cmITKWrapTclCommand
-bool cmITKWrapTclCommand::InitialPass(std::vector<std::string> const& argsIn)
+bool cmITKWrapTclCommand::InitialPass(std::vector<std::string> const& args)
 {
-  if(argsIn.size() < 2 )
+  if(args.size() < 2 )
     {
     this->SetError("called with incorrect number of arguments");
     return false;
     }
-  std::vector<std::string> args;
-  cmSystemTools::ExpandListArguments(argsIn, args);
   // keep the target name
   m_TargetName = args[0];
   m_Target = &m_Makefile->GetTargets()[m_TargetName.c_str()];
diff --git a/Source/cmIfCommand.cxx b/Source/cmIfCommand.cxx
index 98491e9..df1b06c 100644
--- a/Source/cmIfCommand.cxx
+++ b/Source/cmIfCommand.cxx
@@ -17,9 +17,10 @@
 #include "cmIfCommand.h"
 
 bool cmIfFunctionBlocker::
-IsFunctionBlocked(const char *name, const std::vector<std::string> &args, 
-                  cmMakefile &mf)
+IsFunctionBlocked(const cmListFileFunction& lff, cmMakefile &mf)
 {
+  const char* name = lff.m_Name.c_str();
+  const std::vector<cmListFileArgument>& args = lff.m_Arguments;
   // always let if statements through
   if (!strcmp(name,"IF"))
     {
@@ -40,7 +41,7 @@ IsFunctionBlocked(const char *name, const std::vector<std::string> &args,
         }
       // otherwise it must be an ENDIF statement, in that case remove the
       // function blocker
-      mf.RemoveFunctionBlocker("ENDIF",args);
+      mf.RemoveFunctionBlocker(lff);
       return true;
       }
     else if(args.empty())
@@ -50,10 +51,12 @@ IsFunctionBlocked(const char *name, const std::vector<std::string> &args,
       err += ".  Did you mean ";
       err += name;
       err += "( ";
-      for(std::vector<std::string>::const_iterator a = m_Args.begin();
+      for(std::vector<cmListFileArgument>::const_iterator a = m_Args.begin();
           a != m_Args.end();++a)
         {
-        err += *a;
+        err += (a->Quoted?"\"":"");
+        err += a->Value;
+        err += (a->Quoted?"\"":"");
         err += " ";
         }
       err += ")?";
@@ -63,13 +66,12 @@ IsFunctionBlocked(const char *name, const std::vector<std::string> &args,
   return m_IsBlocking;
 }
 
-bool cmIfFunctionBlocker::
-ShouldRemove(const char *name, const std::vector<std::string> &args, 
-             cmMakefile &) 
+bool cmIfFunctionBlocker::ShouldRemove(const cmListFileFunction& lff,
+                                       cmMakefile&)
 {
-  if (!strcmp(name,"ENDIF"))
+  if (lff.m_Name == "ENDIF")
     {
-    if (args == m_Args)
+    if (lff.m_Arguments == m_Args)
       {
       return true;
       }
@@ -90,19 +92,24 @@ ScopeEnded(cmMakefile &mf)
   std::string errmsg = "The end of a CMakeLists file was reached with an IF statement that was not closed properly.\nWithin the directory: ";
   errmsg += mf.GetCurrentDirectory();
   errmsg += "\nThe arguments are: ";
-  for(std::vector<std::string>::const_iterator j = m_Args.begin();
+  for(std::vector<cmListFileArgument>::const_iterator j = m_Args.begin();
       j != m_Args.end(); ++j)
     {   
-    errmsg += *j;
+    errmsg += (j->Quoted?"\"":"");
+    errmsg += j->Value;
+    errmsg += (j->Quoted?"\"":"");
     errmsg += " ";
     }
   cmSystemTools::Error(errmsg.c_str());
 }
 
-bool cmIfCommand::InitialPass(std::vector<std::string> const& args)
+bool cmIfCommand::InvokeInitialPass(const std::vector<cmListFileArgument>& args)
 {
   bool isValid;
-  bool isTrue = cmIfCommand::IsTrue(args,isValid,m_Makefile);
+  
+  std::vector<std::string> expandedArguments;
+  m_Makefile->ExpandArguments(args, expandedArguments);
+  bool isTrue = cmIfCommand::IsTrue(expandedArguments,isValid,m_Makefile);
   
   if (!isValid)
     {
@@ -110,7 +117,9 @@ bool cmIfCommand::InitialPass(std::vector<std::string> const& args)
     unsigned int i;
     for(i =0; i < args.size(); ++i)
       {
-      err += args[i];
+      err += (args[i].Quoted?"\"":"");
+      err += args[i].Value;
+      err += (args[i].Quoted?"\"":"");
       err += " ";
       }
     this->SetError(err.c_str());
@@ -120,25 +129,21 @@ bool cmIfCommand::InitialPass(std::vector<std::string> const& args)
   cmIfFunctionBlocker *f = new cmIfFunctionBlocker();
   // if is isn't true block the commands
   f->m_IsBlocking = !isTrue;
-  for(std::vector<std::string>::const_iterator j = args.begin();
-      j != args.end(); ++j)
-    {   
-    f->m_Args.push_back(*j);
-    }
+  f->m_Args = args;
   m_Makefile->AddFunctionBlocker(f);
   
   return true;
 }
 
-bool cmIfCommand::IsTrue(const std::vector<std::string> &args, bool &isValid,
-                         const cmMakefile *makefile)
+bool cmIfCommand::IsTrue(const std::vector<std::string> &args,
+                         bool &isValid, const cmMakefile *makefile)
 {
   // check for the different signatures
   bool isTrue = true;
   isValid = false;
   const char *def;
   const char *def2;
-
+  
   if(args.size() < 1 )
     {
     isValid = true;
diff --git a/Source/cmIfCommand.h b/Source/cmIfCommand.h
index 3e30a4e..152fcc2 100644
--- a/Source/cmIfCommand.h
+++ b/Source/cmIfCommand.h
@@ -31,15 +31,13 @@ class cmIfFunctionBlocker : public cmFunctionBlocker
 public:
   cmIfFunctionBlocker() {}
   virtual ~cmIfFunctionBlocker() {}
-  virtual bool IsFunctionBlocked(const char *name, 
-                                 const std::vector<std::string> &args, 
+  virtual bool IsFunctionBlocked(const cmListFileFunction& lff,
                                  cmMakefile &mf);
-  virtual bool ShouldRemove(const char *name, 
-                            const std::vector<std::string> &args, 
+  virtual bool ShouldRemove(const cmListFileFunction& lff,
                             cmMakefile &mf);
   virtual void ScopeEnded(cmMakefile &mf);
   
-  std::vector<std::string> m_Args;
+  std::vector<cmListFileArgument> m_Args;
   bool m_IsBlocking;
 };
 
@@ -60,10 +58,16 @@ public:
     }
 
   /**
+   * This overrides the default InvokeInitialPass implementation.
+   * It records the arguments before expansion.
+   */
+  virtual bool InvokeInitialPass(const std::vector<cmListFileArgument>& args);
+    
+  /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args);
+  virtual bool InitialPass(std::vector<std::string> const& args) { return false; }
 
   /**
    * The name of the command as specified in CMakeList.txt.
diff --git a/Source/cmIncludeDirectoryCommand.cxx b/Source/cmIncludeDirectoryCommand.cxx
index 6d2d5d3..48bede4 100644
--- a/Source/cmIncludeDirectoryCommand.cxx
+++ b/Source/cmIncludeDirectoryCommand.cxx
@@ -17,14 +17,12 @@
 #include "cmIncludeDirectoryCommand.h"
 
 // cmIncludeDirectoryCommand
-bool cmIncludeDirectoryCommand::InitialPass(std::vector<std::string> const& argsIn)
+bool cmIncludeDirectoryCommand::InitialPass(std::vector<std::string> const& args)
 {
-  if(argsIn.size() < 1 )
+  if(args.size() < 1 )
     {
     return true;
     }
-  std::vector<std::string> args;
-  cmSystemTools::ExpandListArguments(argsIn, args);
 
   std::vector<std::string>::const_iterator i = args.begin();
 
diff --git a/Source/cmInstallProgramsCommand.cxx b/Source/cmInstallProgramsCommand.cxx
index 396742d..00dffd2 100644
--- a/Source/cmInstallProgramsCommand.cxx
+++ b/Source/cmInstallProgramsCommand.cxx
@@ -17,15 +17,13 @@
 #include "cmInstallProgramsCommand.h"
 
 // cmExecutableCommand
-bool cmInstallProgramsCommand::InitialPass(std::vector<std::string> const& argsIn)
+bool cmInstallProgramsCommand::InitialPass(std::vector<std::string> const& args)
 {
-  if(argsIn.size() < 2)
+  if(args.size() < 2)
     {
     this->SetError("called with incorrect number of arguments");
     return false;
     }
-  std::vector<std::string> args;
-  cmSystemTools::ExpandListArguments(argsIn, args);
 
   // Create an INSTALL_PROGRAMS target specifically for this path.
   m_TargetName = "INSTALL_PROGRAMS_"+args[0];
diff --git a/Source/cmInstallTargetsCommand.cxx b/Source/cmInstallTargetsCommand.cxx
index a01fd86..1553754 100644
--- a/Source/cmInstallTargetsCommand.cxx
+++ b/Source/cmInstallTargetsCommand.cxx
@@ -17,15 +17,13 @@
 #include "cmInstallTargetsCommand.h"
 
 // cmExecutableCommand
-bool cmInstallTargetsCommand::InitialPass(std::vector<std::string> const& argsIn)
+bool cmInstallTargetsCommand::InitialPass(std::vector<std::string> const& args)
 {
-  if(argsIn.size() < 2 )
+  if(args.size() < 2 )
     {
     this->SetError("called with incorrect number of arguments");
     return false;
     }
-  std::vector<std::string> args;
-  cmSystemTools::ExpandListArguments(argsIn, args);
 
   cmTargets &tgts = m_Makefile->GetTargets();
   std::vector<std::string>::const_iterator s = args.begin();
diff --git a/Source/cmLinkDirectoriesCommand.cxx b/Source/cmLinkDirectoriesCommand.cxx
index 717c71f..67994f7 100644
--- a/Source/cmLinkDirectoriesCommand.cxx
+++ b/Source/cmLinkDirectoriesCommand.cxx
@@ -17,14 +17,12 @@
 #include "cmLinkDirectoriesCommand.h"
 
 // cmLinkDirectoriesCommand
-bool cmLinkDirectoriesCommand::InitialPass(std::vector<std::string> const& argsIn)
+bool cmLinkDirectoriesCommand::InitialPass(std::vector<std::string> const& args)
 {
- if(argsIn.size() < 1 )
+ if(args.size() < 1 )
     {
     return true;
     }
- std::vector<std::string> args;
- cmSystemTools::ExpandListArguments(argsIn, args);
 
   for(std::vector<std::string>::const_iterator i = args.begin();
       i != args.end(); ++i)
diff --git a/Source/cmLinkLibrariesCommand.cxx b/Source/cmLinkLibrariesCommand.cxx
index 35b1ec3..d45f246 100644
--- a/Source/cmLinkLibrariesCommand.cxx
+++ b/Source/cmLinkLibrariesCommand.cxx
@@ -17,14 +17,12 @@
 #include "cmLinkLibrariesCommand.h"
 
 // cmLinkLibrariesCommand
-bool cmLinkLibrariesCommand::InitialPass(std::vector<std::string> const& argsIn)
+bool cmLinkLibrariesCommand::InitialPass(std::vector<std::string> const& args)
 {
-  if(argsIn.size() < 1 )
+  if(args.size() < 1 )
     {
     return true;
     }
-  std::vector<std::string> args;
-  cmSystemTools::ExpandListArguments(argsIn, args);
   // add libraries, nothe that there is an optional prefix 
   // of debug and optimized than can be used
   for(std::vector<std::string>::const_iterator i = args.begin();
diff --git a/Source/cmListFileCache.cxx b/Source/cmListFileCache.cxx
index 0893cf6..fce13db 100644
--- a/Source/cmListFileCache.cxx
+++ b/Source/cmListFileCache.cxx
@@ -16,7 +16,7 @@
 =========================================================================*/
 #include "cmListFileCache.h"
 #include "cmSystemTools.h"
-
+#include "cmRegularExpression.h"
 
 cmListFileCache* cmListFileCache::Instance = 0;
 
@@ -89,17 +89,17 @@ bool cmListFileCache::CacheFile(const char* path, bool requireProjectCommand)
     cmSystemTools::Error("cmListFileCache: error can not open file ", path);
     return false;
     }
+  long line=0;
   cmListFile inFile;
   inFile.m_ModifiedTime = cmSystemTools::ModifiedTime(path);
   bool parseError;
   while ( fin )
     {
     cmListFileFunction inFunction;
-    if(cmSystemTools::ParseFunction(fin, 
-                                    inFunction.m_Name,
-                                    inFunction.m_Arguments,
-                                    path, parseError))
+    if(cmListFileCache::ParseFunction(fin, inFunction, path, parseError,
+                                      &line))
       {
+      inFunction.m_FilePath = path;
       inFile.m_Functions.push_back(inFunction);
       }
     if (parseError)
@@ -126,7 +126,8 @@ bool cmListFileCache::CacheFile(const char* path, bool requireProjectCommand)
       {
       cmListFileFunction project;
       project.m_Name = "PROJECT";
-      project.m_Arguments.push_back("Project");
+      cmListFileArgument prj("Project", false);
+      project.m_Arguments.push_back(prj);
       inFile.m_Functions.insert(inFile.m_Functions.begin(),project);
       }
     }
@@ -143,3 +144,179 @@ void cmListFileCache::FlushCache(const char* path)
     return;
     }
 }
+
+inline void RemoveComments(char* ptr)
+{
+  while(*ptr)
+    {
+    if(*ptr == '#')
+      {
+      *ptr = 0;
+      break;
+      }
+    ++ptr;
+    }
+}
+
+bool cmListFileCache::ParseFunction(std::ifstream& fin,
+                                    cmListFileFunction& function,
+                                    const char* filename,
+                                    bool& parseError,
+                                    long* line)
+{
+  parseError = false;
+  std::string& name = function.m_Name;
+  std::vector<cmListFileArgument>& arguments = function.m_Arguments;
+  name = "";
+  arguments = std::vector<cmListFileArgument>();
+  const int BUFFER_SIZE = 4096;
+  char inbuffer[BUFFER_SIZE];
+  if(!fin)
+    {
+    return false;
+    }
+  if(fin.getline(inbuffer, BUFFER_SIZE ) )
+    {
+    if(line) { ++*line; }
+    RemoveComments(inbuffer);
+    cmRegularExpression blankLine("^[ \t\r]*$");
+    cmRegularExpression oneLiner("^[ \t]*([A-Za-z_0-9]*)[ \t]*\\((.*)\\)[ \t\r]*$");
+    cmRegularExpression multiLine("^[ \t]*([A-Za-z_0-9]*)[ \t]*\\((.*)$");
+    cmRegularExpression lastLine("^(.*)\\)[ \t\r]*$");
+
+    // check for blank line or comment
+    if(blankLine.find(inbuffer) )
+      {
+      return false;
+      }
+    // look for a oneline fun(arg arg2) 
+    else if(oneLiner.find(inbuffer))
+      {
+      // the arguments are the second match
+      std::string args = oneLiner.match(2);
+      name = oneLiner.match(1);
+      // break up the arguments
+      cmListFileCache::GetArguments(args, arguments);
+      if(line)
+        {
+        function.m_Line = *line;
+        }
+      return true;
+      }
+    // look for a start of a multiline with no trailing ")"  fun(arg arg2 
+    else if(multiLine.find(inbuffer))
+      {
+      name = multiLine.match(1);
+      std::string args = multiLine.match(2);
+      cmListFileCache::GetArguments(args, arguments);
+      if(line)
+        {
+        function.m_Line = *line;
+        }
+      // Read lines until the closing paren is hit
+      bool done = false;
+      while(!done)
+        {
+        // read lines until the end paren is found
+        if(fin.getline(inbuffer, BUFFER_SIZE ) )
+          {
+          ++line;
+          RemoveComments(inbuffer);
+          // Check for comment lines and ignore them.
+          if(blankLine.find(inbuffer))
+            { continue; }
+          // Is this the last line?
+          if(lastLine.find(inbuffer))
+            {
+            done = true;
+            std::string gargs = lastLine.match(1);
+            cmListFileCache::GetArguments(gargs, arguments);
+            }
+          else
+            {
+            std::string line = inbuffer;
+            cmListFileCache::GetArguments(line, arguments);
+            }
+          }
+        else
+          {
+          parseError = true;
+          cmSystemTools::Error("Parse error in read function missing end )\nIn File: ",
+                               filename, "\nCurrent line:", inbuffer);
+          return false;
+          }
+        }
+      return true;
+      }
+    else
+      {
+      parseError = true;
+      cmSystemTools::Error("Parse error in read function\nIn file:", 
+                           filename, "\nCurrent line:", inbuffer);
+      return false;
+      }
+    }
+  return false;
+
+}
+
+void cmListFileCache::GetArguments(std::string& line,
+                                 std::vector<cmListFileArgument>& arguments)
+{
+  // Match a normal argument (not quoted, no spaces).
+  cmRegularExpression normalArgument("[ \t]*(([^ \t\r\\]|[\\].)+)[ \t\r]*");
+  // Match a quoted argument (surrounded by double quotes, spaces allowed).
+  cmRegularExpression quotedArgument("[ \t]*(\"([^\"\\]|[\\].)*\")[ \t\r]*");
+
+  bool done = false;
+  while(!done)
+    {
+    std::string arg;
+    std::string::size_type endpos=0;
+    bool quoted = false;
+    bool foundQuoted = quotedArgument.find(line.c_str());
+    bool foundNormal = normalArgument.find(line.c_str());
+
+    if(foundQuoted && foundNormal)
+      {
+      // Both matches were found.  Take the earlier one.
+      // Favor double-quoted version if there is a tie.
+      if(normalArgument.start(1) < quotedArgument.start(1))
+        {
+        arg = normalArgument.match(1);
+        endpos = normalArgument.end(1);
+        }
+      else
+        {
+        arg = quotedArgument.match(1);
+        endpos = quotedArgument.end(1);
+        // Strip off the double quotes on the ends.
+        arg = arg.substr(1, arg.length()-2);
+        quoted = true;
+        }
+      }    
+    else if(foundQuoted)
+      {
+      arg = quotedArgument.match(1);
+      endpos = quotedArgument.end(1);
+      // Strip off the double quotes on the ends.
+      arg = arg.substr(1, arg.length()-2);
+      quoted = true;
+      }
+    else if(foundNormal)
+      {
+      arg = normalArgument.match(1);
+      endpos = normalArgument.end(1);
+      }
+    else
+      {
+      done = true;
+      }
+    if(!done)
+      {
+      cmListFileArgument a(cmSystemTools::RemoveEscapes(arg.c_str()), quoted);
+      arguments.push_back(a);
+      line = line.substr(endpos, line.length() - endpos);
+      }
+    }
+}
diff --git a/Source/cmListFileCache.h b/Source/cmListFileCache.h
index 2520eca..9dc8073 100644
--- a/Source/cmListFileCache.h
+++ b/Source/cmListFileCache.h
@@ -26,10 +26,25 @@
  * cmake list files.
  */
 
+struct cmListFileArgument
+{
+  cmListFileArgument(): Value(), Quoted(false) {}
+  cmListFileArgument(const cmListFileArgument& r): Value(r.Value), Quoted(r.Quoted) {}
+  cmListFileArgument(const std::string& v, bool q): Value(v), Quoted(q) {}
+  bool operator == (const cmListFileArgument& r) const
+    {
+    return (this->Value == r.Value) && (this->Quoted == r.Quoted);
+    }
+  std::string Value;
+  bool Quoted;
+};
+
 struct cmListFileFunction
 {
   std::string m_Name;
-  std::vector<std::string> m_Arguments;
+  std::vector<cmListFileArgument> m_Arguments;
+  std::string m_FilePath;
+  long m_Line;
 };
 
 struct cmListFile
@@ -60,7 +75,25 @@ public:
 
   //! Flush cache file out of cache.
   void FlushCache(const char* path);
+    
+  /**
+   * Read a CMake command (or function) from an input file.  This
+   * returns the name of the function and a list of its 
+   * arguments.  The last argument is the name of the file that 
+   * the ifstream points to, and is used for debug info only.
+   */
+  static bool ParseFunction(std::ifstream&, cmListFileFunction& function,
+                            const char* filename, bool& parseError,
+                            long* line = 0);
 
+  /**
+   *  Extract white-space separated arguments from a string.
+   *  Double quoted strings are accepted with spaces.
+   *  This is called by ParseFunction.
+   */
+  static void GetArguments(std::string& line,
+                           std::vector<cmListFileArgument>& arguments);
+  
 private:
   // Cache the file
   bool CacheFile(const char* path, bool requireProjectCommand);
diff --git a/Source/cmLoadCacheCommand.cxx b/Source/cmLoadCacheCommand.cxx
index 0ec5cab..ef3fe26 100644
--- a/Source/cmLoadCacheCommand.cxx
+++ b/Source/cmLoadCacheCommand.cxx
@@ -18,14 +18,12 @@
 
 
 // cmLoadCacheCommand
-bool cmLoadCacheCommand::InitialPass(std::vector<std::string> const& argsIn)
+bool cmLoadCacheCommand::InitialPass(std::vector<std::string> const& args)
 {
-  if (argsIn.size()< 1)
+  if (args.size()< 1)
     {
     this->SetError("called with wrong number of arguments.");
     }
-  std::vector<std::string> args;
-  cmSystemTools::ExpandListArguments(argsIn, args);
 
   if(args.size() >= 2 && args[1] == "READ_WITH_PREFIX")
     {
diff --git a/Source/cmLoadCommandCommand.cxx b/Source/cmLoadCommandCommand.cxx
index d5a2f3a..b307148 100644
--- a/Source/cmLoadCommandCommand.cxx
+++ b/Source/cmLoadCommandCommand.cxx
@@ -166,18 +166,16 @@ cmLoadedCommand::~cmLoadedCommand()
 }
 
 // cmLoadCommandCommand
-bool cmLoadCommandCommand::InitialPass(std::vector<std::string> const& argsIn)
+bool cmLoadCommandCommand::InitialPass(std::vector<std::string> const& args)
 {
-  if(argsIn.size() < 1 )
+  if(args.size() < 1 )
     {
     return true;
     }
   
   // the file must exist
   std::string fullPath = cmDynamicLoader::LibPrefix();
-  fullPath += "cm" + argsIn[0] + cmDynamicLoader::LibExtension();
-  std::vector<std::string> args;
-  cmSystemTools::ExpandListArguments(argsIn, args);
+  fullPath += "cm" + args[0] + cmDynamicLoader::LibExtension();
 
   // search for the file
   std::vector<std::string> path;
@@ -197,7 +195,7 @@ bool cmLoadCommandCommand::InitialPass(std::vector<std::string> const& argsIn)
     {
     fullPath = "Attempt to load command failed from file : ";
     fullPath += cmDynamicLoader::LibPrefix();
-    fullPath += "cm" + argsIn[0] + cmDynamicLoader::LibExtension();
+    fullPath += "cm" + args[0] + cmDynamicLoader::LibExtension();
     this->SetError(fullPath.c_str());
     return false;
     }
diff --git a/Source/cmLocalUnixMakefileGenerator.cxx b/Source/cmLocalUnixMakefileGenerator.cxx
index 5e72e0f..5092045 100644
--- a/Source/cmLocalUnixMakefileGenerator.cxx
+++ b/Source/cmLocalUnixMakefileGenerator.cxx
@@ -812,7 +812,7 @@ void cmLocalUnixMakefileGenerator::OutputLibraryRule(std::ostream& fout,
   // expand multi-command semi-colon separated lists
   // of commands into separate commands
   std::vector<std::string> commands;
-  cmSystemTools::ExpandListArguments(rules, commands);
+  cmSystemTools::ExpandList(rules, commands);
   // collect custom commands for this target and add them to the list
   std::string customCommands = this->CreateTargetRules(t, name);
   if(customCommands.size() > 0)
@@ -986,7 +986,7 @@ void cmLocalUnixMakefileGenerator::OutputExecutableRule(std::ostream& fout,
   std::string comment = "executable";
   
   std::vector<std::string> commands;
-  cmSystemTools::ExpandListArguments(rules, commands);
+  cmSystemTools::ExpandList(rules, commands);
   std::string customCommands = this->CreateTargetRules(t, name);
   if(customCommands.size() > 0)
     {
@@ -2339,7 +2339,7 @@ OutputBuildObjectFromSource(std::ostream& fout,
   // expand multi-command semi-colon separated lists
   // of commands into separate commands
   std::vector<std::string> commands;
-  cmSystemTools::ExpandListArguments(rules, commands);
+  cmSystemTools::ExpandList(rules, commands);
   for(std::vector<std::string>::iterator i = commands.begin();
       i != commands.end(); ++i)
     {
diff --git a/Source/cmMacroCommand.cxx b/Source/cmMacroCommand.cxx
index 2cdcb09..58871a2 100644
--- a/Source/cmMacroCommand.cxx
+++ b/Source/cmMacroCommand.cxx
@@ -17,66 +17,67 @@
 #include "cmMacroCommand.h"
 
 bool cmMacroFunctionBlocker::
-IsFunctionBlocked(const char *name, const std::vector<std::string> &args, 
-                  cmMakefile &mf) 
+IsFunctionBlocked(const cmListFileFunction& lff, cmMakefile &mf) 
 {
   // record commands until we hit the ENDMACRO
   // at the ENDMACRO call we shift gears and start looking for invocations
-  if (!strcmp(name,"ENDMACRO") && args[0] == m_Args[0])
+  if(lff.m_Name == "ENDMACRO")
     {
-    m_Executing = true;
-    return true;
+    std::vector<std::string> expandedArguments;
+    mf.ExpandArguments(lff.m_Arguments, expandedArguments);
+    if(!expandedArguments.empty() && (expandedArguments[0] == m_Args[0]))
+      {
+      m_Executing = true;
+      return true;
+      }
     }
   
   if (!m_Executing)
     {
     // if it wasn't an endmacro and we are not executing then we must be
     // recording
-    m_Commands.push_back(name);
-    std::vector<std::string> newArgs;
-    for(std::vector<std::string>::const_iterator j = args.begin();
-        j != args.end(); ++j)
-      {   
-      newArgs.push_back(*j);
-      }
-    m_CommandArguments.push_back(newArgs);
+    m_Functions.push_back(lff);
     return true;
     }
   
   // otherwise the macro has been recorded and we are executing
   // so we look for macro invocations
-  if (!strcmp(name,m_Args[0].c_str()))
+  if(lff.m_Name == m_Args[0])
     {
+    // Expand the argument list to the macro.
+    std::vector<std::string> expandedArguments;
+    mf.ExpandArguments(lff.m_Arguments, expandedArguments);
     // make sure the number of arguments matches
-    if (args.size() != m_Args.size() - 1)
+    if (expandedArguments.size() != m_Args.size() - 1)
       {
       cmSystemTools::Error("A macro was invoked without the correct number of arguments. The macro name was: ", m_Args[0].c_str());
       }
-    // for each recorded command
-    for(unsigned int c = 0; c < m_Commands.size(); ++c)
+    
+    // Invoke all the functions that were collected in the block.
+    for(unsigned int c = 0; c < m_Functions.size(); ++c)
       {
-      // perform argument replacement
-      std::vector<std::string> newArgs;
-      // for each argument of this command
-      for (std::vector<std::string>::const_iterator k = 
-             m_CommandArguments[c].begin();
-           k != m_CommandArguments[c].end(); ++k)
+      // Replace the formal arguments and then invoke the command.
+      cmListFileFunction newLFF;
+      newLFF.m_Name = m_Functions[c].m_Name;
+      for (std::vector<cmListFileArgument>::const_iterator k = 
+             m_Functions[c].m_Arguments.begin();
+           k != m_Functions[c].m_Arguments.end(); ++k)
         {
-        // replace any matches with the formal arguments
-        std::string tmps = *k;
-        // for each formal macro argument
+        std::string tmps = k->Value;
         for (unsigned int j = 1; j < m_Args.size(); ++j)
           {
           std::string variable = "${";
           variable += m_Args[j];
           variable += "}"; 
           cmSystemTools::ReplaceString(tmps, variable.c_str(),
-                                       args[j-1].c_str());
+                                       expandedArguments[j-1].c_str());
           }
-        newArgs.push_back(tmps);
+        cmListFileArgument arg(tmps, k->Quoted);
+        newLFF.m_Arguments.push_back(arg);
+        newLFF.m_FilePath = m_Functions[c].m_FilePath;
+        newLFF.m_Line = m_Functions[c].m_Line;
         }
-      // execute command
-      mf.ExecuteCommand(m_Commands[c],newArgs);
+      mf.ExecuteCommand(newLFF);
       }
     return true;
     }
@@ -86,8 +87,7 @@ IsFunctionBlocked(const char *name, const std::vector<std::string> &args,
 }
 
 bool cmMacroFunctionBlocker::
-ShouldRemove(const char *, const std::vector<std::string> &, 
-             cmMakefile &) 
+ShouldRemove(const cmListFileFunction&, cmMakefile &) 
 {
   return false;
 }
@@ -98,11 +98,8 @@ ScopeEnded(cmMakefile &)
   // macros never leave scope
 }
 
-bool cmMacroCommand::InitialPass(std::vector<std::string> const& argsIn)
+bool cmMacroCommand::InitialPass(std::vector<std::string> const& args)
 {
-  std::vector<std::string> args;
-  cmSystemTools::ExpandListArguments(argsIn, args);
-
   if(args.size() < 1)
     {
     this->SetError("called with incorrect number of arguments");
diff --git a/Source/cmMacroCommand.h b/Source/cmMacroCommand.h
index 0705be7..e090ec7 100644
--- a/Source/cmMacroCommand.h
+++ b/Source/cmMacroCommand.h
@@ -31,19 +31,12 @@ class cmMacroFunctionBlocker : public cmFunctionBlocker
 public:
   cmMacroFunctionBlocker() {m_Executing = false;}
   virtual ~cmMacroFunctionBlocker() {}
-  virtual bool IsFunctionBlocked(const char *name, 
-                                 const std::vector<std::string> &args, 
-                                 cmMakefile &mf);
-  virtual bool ShouldRemove(const char *name, 
-                            const std::vector<std::string> &args, 
-                            cmMakefile &mf);
+  virtual bool IsFunctionBlocked(const cmListFileFunction&, cmMakefile &mf);
+  virtual bool ShouldRemove(const cmListFileFunction&, cmMakefile &mf);
   virtual void ScopeEnded(cmMakefile &mf);
   
-  virtual int NeedExpandedVariables () { return 0; };
-
   std::vector<std::string> m_Args;
-  std::vector<std::string> m_Commands;
-  std::vector<std::vector<std::string> > m_CommandArguments;
+  std::vector<cmListFileFunction> m_Functions;
   bool m_Executing;
 };
 
diff --git a/Source/cmMakefile.cxx b/Source/cmMakefile.cxx
index 9c5dc9f..db4a1ba 100644
--- a/Source/cmMakefile.cxx
+++ b/Source/cmMakefile.cxx
@@ -157,14 +157,14 @@ bool cmMakefile::CommandExists(const char* name) const
   return m_LocalGenerator->GetGlobalGenerator()->GetCMakeInstance()->CommandExists(name);
 }
       
-void cmMakefile::ExecuteCommand(std::string const &name,
-                                std::vector<std::string> const& arguments)
+void cmMakefile::ExecuteCommand(const cmListFileFunction& lff)
 {
   // quick return if blocked
-  if(this->IsFunctionBlocked(name.c_str(), arguments))
+  if(this->IsFunctionBlocked(lff))
     {
     return;
     }
+  std::string name = lff.m_Name;
   // execute the command
   cmCommand *rm = 
     m_LocalGenerator->GetGlobalGenerator()->GetCMakeInstance()->GetCommand(name.c_str());
@@ -179,27 +179,13 @@ void cmMakefile::ExecuteCommand(std::string const &name,
       // if the command is inherited then InitialPass it.
       if(!m_Inheriting || usedCommand->IsInherited())
         {
-        std::vector<std::string> expandedArguments;
-        for(std::vector<std::string>::const_iterator i = arguments.begin();
-            i != arguments.end(); ++i)
+        if(!usedCommand->InvokeInitialPass(lff.m_Arguments))
           {
-          std::string tmps = *i;
-          this->ExpandVariablesInString(tmps);
-          if (tmps.find_first_not_of(" ") != std::string::npos)
-            {
-            // we found something in the args
-            expandedArguments.push_back(tmps);
-            }
-          }
-        if(!usedCommand->InitialPass(expandedArguments))
-          {
-          std::string error;
-          error = usedCommand->GetName();
-          error += ": Error : \n";
-          error += usedCommand->GetError();
-          error += " from CMakeLists.txt file in directory: ";
-          error += m_cmCurrentDirectory;
-          cmSystemTools::Error(error.c_str());
+          cmOStringStream error;
+          error << "Error in cmake code at\n"
+                << lff.m_FilePath << ":" << lff.m_Line << ":\n"
+                << usedCommand->GetError();
+          cmSystemTools::Error(error.str().c_str());
           }
         else
           {
@@ -216,18 +202,13 @@ void cmMakefile::ExecuteCommand(std::string const &name,
       delete usedCommand;
       }
     }
-  else if((name == "CABLE_WRAP_TCL") || (name == "CABLE_CLASS_SET") ||
-          (name == "CONFIGURE_GCCXML"))
-    {
-    cmSystemTools::Error("The command ", name.c_str(),
-                         " is not implemented in this version of CMake.\n"
-                         "Contact cable@public.kitware.com for more information.");
-    }
   else
     {
-    cmSystemTools::Error("unknown CMake command:", name.c_str(), 
-                         "\nReading cmake file in directory:" , 
-                         m_cmCurrentDirectory.c_str());
+    cmOStringStream error;
+    error << "Error in cmake code at\n"
+          << lff.m_FilePath << ":" << lff.m_Line << ":\n"
+          << "Unknown CMake command \"" << lff.m_Name.c_str() << "\".";
+    cmSystemTools::Error(error.str().c_str());
     }
 }
 
@@ -335,9 +316,7 @@ bool cmMakefile::ReadListFile(const char* filename, const char* external)
   const size_t numberFunctions = lf->m_Functions.size();
   for(size_t i =0; i < numberFunctions; ++i)
     {
-    cmListFileFunction& curFunction = lf->m_Functions[i];
-    this->ExecuteCommand(curFunction.m_Name,
-                         curFunction.m_Arguments);
+    this->ExecuteCommand(lf->m_Functions[i]);
     }
 
   // send scope ended to and funciton blockers
@@ -1161,8 +1140,7 @@ cmMakefile::FindSourceGroup(const char* source,
   return groups.front();
 }
 
-bool cmMakefile::IsFunctionBlocked(const char *name,
-                                   std::vector<std::string> const&args)
+bool cmMakefile::IsFunctionBlocked(const cmListFileFunction& lff)
 {
   // if there are no blockers get out of here
   if (m_FunctionBlockers.begin() == m_FunctionBlockers.end())
@@ -1171,51 +1149,52 @@ bool cmMakefile::IsFunctionBlocked(const char *name,
     }
 
   // loop over all function blockers to see if any block this command
-  std::vector<std::string> expandedArguments;
-  for(std::vector<std::string>::const_iterator i = args.begin();
-      i != args.end(); ++i)
-    {
-    std::string tmps = *i;
-    this->ExpandVariablesInString(tmps);
-    if (tmps.find_first_not_of(" ") != std::string::npos)
-      {
-      // we found something in the args
-      expandedArguments.push_back(tmps);
-      }
-    }
   // evaluate in reverse, this is critical for balanced IF statements etc
   std::list<cmFunctionBlocker *>::reverse_iterator pos;
   for (pos = m_FunctionBlockers.rbegin(); 
        pos != m_FunctionBlockers.rend(); ++pos)
     {
-    if ((*pos)->NeedExpandedVariables()) 
+    if((*pos)->IsFunctionBlocked(lff, *this))
       {
-      if ((*pos)->IsFunctionBlocked(name, expandedArguments, *this))
-        {
-        return true;
-        }
+      return true;
+      }
+    }
+  
+  return false;
+}
+
+void cmMakefile::ExpandArguments(
+  std::vector<cmListFileArgument> const& inArgs,
+  std::vector<std::string>& outArgs)
+{
+  std::vector<cmListFileArgument>::const_iterator i;
+  for(i = inArgs.begin(); i != inArgs.end(); ++i)
+    {
+    // Expand the variables in the argument.
+    std::string value = i->Value;
+    this->ExpandVariablesInString(value);
+    
+    // If the argument is quoted, it should be one argument.
+    // Otherwise, it may be a list of arguments.
+    if(i->Quoted)
+      {
+      outArgs.push_back(value);
       }
     else
       {
-      if ((*pos)->IsFunctionBlocked(name, args, *this))
-        {
-        return true;
-        }
+      cmSystemTools::ExpandListArgument(value, outArgs);
       }
     }
-  
-  return false;
 }
 
-void cmMakefile::RemoveFunctionBlocker(const char *name,
-                                       const std::vector<std::string> &args)
+void cmMakefile::RemoveFunctionBlocker(const cmListFileFunction& lff)
 {
   // loop over all function blockers to see if any block this command
   std::list<cmFunctionBlocker *>::reverse_iterator pos;
   for (pos = m_FunctionBlockers.rbegin(); 
        pos != m_FunctionBlockers.rend(); ++pos)
     {
-    if ((*pos)->ShouldRemove(name, args, *this))
+    if ((*pos)->ShouldRemove(lff, *this))
       {
       cmFunctionBlocker* b = *pos;
       m_FunctionBlockers.remove(b);
@@ -1348,7 +1327,6 @@ void cmMakefile::ExpandSourceListArguments(
     }
   
   // now expand the args
-  std::vector<std::string> tmpArgs;
   unsigned int i;
   for(i = 0; i < arguments.size(); ++i)
     {
@@ -1356,14 +1334,16 @@ void cmMakefile::ExpandSourceListArguments(
     const char *def = this->GetDefinition(arguments[i].c_str());
     if (def && oldVersion && i >= start)
       {
-      tmpArgs.push_back(def);
+      // Definition lookup could result in a list that needs to be
+      // expanded.
+      cmSystemTools::ExpandListArgument(def, newargs);
       }
     else
       {
-      tmpArgs.push_back(arguments[i]);
+      // List expansion will have been done already.
+      newargs.push_back(arguments[i]);
       }
     }
-  cmSystemTools::ExpandListArguments(tmpArgs, newargs);
 }
 
 int cmMakefile::TryCompile(const char *srcdir, const char *bindir, 
diff --git a/Source/cmMakefile.h b/Source/cmMakefile.h
index dbb62af..de8e3eb 100644
--- a/Source/cmMakefile.h
+++ b/Source/cmMakefile.h
@@ -22,6 +22,7 @@
 #include "cmSystemTools.h"
 #include "cmSourceGroup.h"
 #include "cmTarget.h"
+#include "cmListFileCache.h"
 #include "cmCacheManager.h"
 
 class cmFunctionBlocker;
@@ -77,7 +78,7 @@ public:
     { m_FunctionBlockers.push_back(fb);}
   void RemoveFunctionBlocker(cmFunctionBlocker *fb)
     { m_FunctionBlockers.remove(fb);}
-  void RemoveFunctionBlocker(const char *name, const std::vector<std::string> &args);
+  void RemoveFunctionBlocker(const cmListFileFunction& lff);
   
   /**
    * Try running cmake and building a file. This is used for dynalically
@@ -511,7 +512,7 @@ public:
   /**
    * execute a single CMake command
    */
-  void ExecuteCommand(std::string const &name, std::vector<std::string> const& args);
+  void ExecuteCommand(const cmListFileFunction& lff);
   
   /** Check if a command exists. */
   bool CommandExists(const char* name) const;
@@ -535,6 +536,13 @@ public:
 
   ///! Display progress or status message.
   void DisplayStatus(const char*, float);
+  
+  /**
+   * Expand the given list file arguments into the full set after
+   * variable replacement and list expansion.
+   */
+  void ExpandArguments(std::vector<cmListFileArgument> const& inArgs,
+                       std::vector<std::string>& outArgs);
 protected:
   // add link libraries and directories to the target
   void AddGlobalLinkInformation(const char* name, cmTarget& target);
@@ -581,7 +589,7 @@ protected:
   DefinitionMap m_Definitions;
   std::vector<cmCommand*> m_UsedCommands;
   cmLocalGenerator* m_LocalGenerator;
-  bool IsFunctionBlocked(const char *name, std::vector<std::string> const& args);
+  bool IsFunctionBlocked(const cmListFileFunction& lff);
   
 private:
   /**
diff --git a/Source/cmMarkAsAdvancedCommand.cxx b/Source/cmMarkAsAdvancedCommand.cxx
index b50202a..3195387 100644
--- a/Source/cmMarkAsAdvancedCommand.cxx
+++ b/Source/cmMarkAsAdvancedCommand.cxx
@@ -17,15 +17,13 @@
 #include "cmMarkAsAdvancedCommand.h"
 
 // cmMarkAsAdvancedCommand
-bool cmMarkAsAdvancedCommand::InitialPass(std::vector<std::string> const& argsIn)
+bool cmMarkAsAdvancedCommand::InitialPass(std::vector<std::string> const& args)
 {
-  if(argsIn.size() < 1 )
+  if(args.size() < 1 )
     {
     this->SetError("called with incorrect number of arguments");
     return false;
     }
-  std::vector<std::string> args;
-  cmSystemTools::ExpandListArguments(argsIn, args);
 
   unsigned int i =0;
   const char* value = "1";
diff --git a/Source/cmMessageCommand.cxx b/Source/cmMessageCommand.cxx
index 45c6dc9..c6e8e16 100644
--- a/Source/cmMessageCommand.cxx
+++ b/Source/cmMessageCommand.cxx
@@ -17,15 +17,13 @@
 #include "cmMessageCommand.h"
 
 // cmLibraryCommand
-bool cmMessageCommand::InitialPass(std::vector<std::string> const& argsIn)
+bool cmMessageCommand::InitialPass(std::vector<std::string> const& args)
 {
-  if(argsIn.size() < 1 )
+  if(args.size() < 1 )
     {
     this->SetError("called with incorrect number of arguments");
     return false;
     }
-  std::vector<std::string> args;
-  cmSystemTools::ExpandListArguments(argsIn, args);
   std::string message;
   std::vector<std::string>::const_iterator i = args.begin();
 
diff --git a/Source/cmProjectCommand.cxx b/Source/cmProjectCommand.cxx
index a9ec7ba..8f48fd6 100644
--- a/Source/cmProjectCommand.cxx
+++ b/Source/cmProjectCommand.cxx
@@ -17,15 +17,13 @@
 #include "cmProjectCommand.h"
 
 // cmProjectCommand
-bool cmProjectCommand::InitialPass(std::vector<std::string> const& argsIn)
+bool cmProjectCommand::InitialPass(std::vector<std::string> const& args)
 {
-  if(argsIn.size() < 1 )
+  if(args.size() < 1 )
     {
     this->SetError("PROJECT called with incorrect number of arguments");
     return false;
     } 
-  std::vector<std::string> args;
-  cmSystemTools::ExpandListArguments(argsIn, args);
   m_Makefile->SetProjectName(args[0].c_str());
 
   std::string bindir = args[0];
diff --git a/Source/cmRemoveCommand.cxx b/Source/cmRemoveCommand.cxx
index 136b973..44c33d4 100644
--- a/Source/cmRemoveCommand.cxx
+++ b/Source/cmRemoveCommand.cxx
@@ -37,19 +37,17 @@ bool cmRemoveCommand::InitialPass(std::vector<std::string> const& args)
   
   // expand the variable
   std::vector<std::string> varArgsExpanded;
-  std::vector<std::string> temp;
-  temp.push_back(std::string(cacheValue));
-  cmSystemTools::ExpandListArguments(temp, varArgsExpanded);
+  cmSystemTools::ExpandListArgument(cacheValue, varArgsExpanded);
   
   // expand the args
   // check for REMOVE(VAR v1 v2 ... vn) 
   std::vector<std::string> argsExpanded;
-  std::vector<std::string> temp2;
+  std::vector<std::string> temp;
   for(unsigned int j = 1; j < args.size(); ++j)
     {
-    temp2.push_back(args[j]);
+    temp.push_back(args[j]);
     }
-  cmSystemTools::ExpandListArguments(temp2, argsExpanded);
+  cmSystemTools::ExpandList(temp, argsExpanded);
   
   // now create the new value
   std::string value;
diff --git a/Source/cmSetSourceFilesPropertiesCommand.cxx b/Source/cmSetSourceFilesPropertiesCommand.cxx
index 64f6a25..3933321 100644
--- a/Source/cmSetSourceFilesPropertiesCommand.cxx
+++ b/Source/cmSetSourceFilesPropertiesCommand.cxx
@@ -18,15 +18,13 @@
 
 // cmSetSourceFilesPropertiesCommand
 bool cmSetSourceFilesPropertiesCommand::InitialPass(
-  std::vector<std::string> const& argsIn)
+  std::vector<std::string> const& args)
 {
-  if(argsIn.size() < 2 )
+  if(args.size() < 2 )
     {
     this->SetError("called with incorrect number of arguments");
     return false;
     }
-  std::vector<std::string> args;
-  cmSystemTools::ExpandListArguments(argsIn, args);
 
   // first collect up the list of files
   std::vector<std::string> propertyPairs;
diff --git a/Source/cmSourceFilesCommand.cxx b/Source/cmSourceFilesCommand.cxx
index 8fe4e1c..fc1171c 100644
--- a/Source/cmSourceFilesCommand.cxx
+++ b/Source/cmSourceFilesCommand.cxx
@@ -17,7 +17,7 @@
 #include "cmSourceFilesCommand.h"
 
 // cmSourceFilesCommand
-bool cmSourceFilesCommand::InitialPass(std::vector<std::string> const& argsIn)
+bool cmSourceFilesCommand::InitialPass(std::vector<std::string> const& args)
 {
   const char* versionValue
     = m_Makefile->GetDefinition("CMAKE_MINIMUM_REQUIRED_VERSION");
@@ -27,13 +27,11 @@ bool cmSourceFilesCommand::InitialPass(std::vector<std::string> const& argsIn)
     return false;
     }
 
-  if(argsIn.size() < 1 )
+  if(args.size() < 1 )
     {
     this->SetError("called with incorrect number of arguments");
     return false;
     }
-  std::vector<std::string> args;
-  cmSystemTools::ExpandListArguments(argsIn, args);
   std::string sourceListValue;
   
   // was the list already populated
diff --git a/Source/cmSourceFilesRemoveCommand.cxx b/Source/cmSourceFilesRemoveCommand.cxx
index cff9ffb..7fb9b7a 100644
--- a/Source/cmSourceFilesRemoveCommand.cxx
+++ b/Source/cmSourceFilesRemoveCommand.cxx
@@ -40,19 +40,17 @@ bool cmSourceFilesRemoveCommand::InitialPass(std::vector<std::string> const& arg
 
   // expand the variable
   std::vector<std::string> varArgsExpanded;
-  std::vector<std::string> temp;
-  temp.push_back(std::string(cacheValue));
-  cmSystemTools::ExpandListArguments(temp, varArgsExpanded);
+  cmSystemTools::ExpandListArgument(cacheValue, varArgsExpanded);
   
   // expand the args
   // check for REMOVE(VAR v1 v2 ... vn) 
   std::vector<std::string> argsExpanded;
-  std::vector<std::string> temp2;
+  std::vector<std::string> temp;
   for(unsigned int j = 1; j < args.size(); ++j)
     {
-    temp2.push_back(args[j]);
+    temp.push_back(args[j]);
     }
-  cmSystemTools::ExpandListArguments(temp2, argsExpanded);
+  cmSystemTools::ExpandList(temp, argsExpanded);
   
   // now create the new value
   std::string value;
diff --git a/Source/cmSubdirCommand.cxx b/Source/cmSubdirCommand.cxx
index 10bb916..7fcf814 100644
--- a/Source/cmSubdirCommand.cxx
+++ b/Source/cmSubdirCommand.cxx
@@ -17,15 +17,13 @@
 #include "cmSubdirCommand.h"
 
 // cmSubdirCommand
-bool cmSubdirCommand::InitialPass(std::vector<std::string> const& argsIn)
+bool cmSubdirCommand::InitialPass(std::vector<std::string> const& args)
 {
-  if(argsIn.size() < 1 )
+  if(args.size() < 1 )
     {
     this->SetError("called with incorrect number of arguments");
     return false;
     }
-  std::vector<std::string> args;
-  cmSystemTools::ExpandListArguments(argsIn, args);
   bool res = true;
 
   for(std::vector<std::string>::const_iterator i = args.begin();
diff --git a/Source/cmSystemTools.cxx b/Source/cmSystemTools.cxx
index ff27805..28163a8 100644
--- a/Source/cmSystemTools.cxx
+++ b/Source/cmSystemTools.cxx
@@ -843,168 +843,6 @@ std::string cmSystemTools::ConvertToWindowsOutputPath(const char* path)
   return ret;
 }
 
-inline void RemoveComments(char* ptr)
-{
-  while(*ptr)
-    {
-    if(*ptr == '#')
-      {
-      *ptr = 0;
-      break;
-      }
-    ++ptr;
-    }
-}
-
-bool cmSystemTools::ParseFunction(std::ifstream& fin,
-                                  std::string& name,
-                                  std::vector<std::string>& arguments,
-                                  const char* filename,
-                                  bool& parseError)
-{
-  parseError = false;
-  name = "";
-  arguments = std::vector<std::string>();
-  const int BUFFER_SIZE = 4096;
-  char inbuffer[BUFFER_SIZE];
-  if(!fin)
-    {
-    return false;
-    }
-  if(fin.getline(inbuffer, BUFFER_SIZE ) )
-    {
-    RemoveComments(inbuffer);
-    cmRegularExpression blankLine("^[ \t\r]*$");
-//    cmRegularExpression comment("^[ \t]*#.*$");
-    cmRegularExpression oneLiner("^[ \t]*([A-Za-z_0-9]*)[ \t]*\\((.*)\\)[ \t\r]*$");
-    cmRegularExpression multiLine("^[ \t]*([A-Za-z_0-9]*)[ \t]*\\((.*)$");
-    cmRegularExpression lastLine("^(.*)\\)[ \t\r]*$");
-
-    // check for blank line or comment
-    if(blankLine.find(inbuffer) )
-      {
-      return false;
-      }
-    // look for a oneline fun(arg arg2) 
-    else if(oneLiner.find(inbuffer))
-      {
-      // the arguments are the second match
-      std::string args = oneLiner.match(2);
-      name = oneLiner.match(1);
-      // break up the arguments
-      cmSystemTools::GetArguments(args, arguments);
-      return true;
-      }
-    // look for a start of a multiline with no trailing ")"  fun(arg arg2 
-    else if(multiLine.find(inbuffer))
-      {
-      name = multiLine.match(1);
-      std::string args = multiLine.match(2);
-      cmSystemTools::GetArguments(args, arguments);
-      // Read lines until the closing paren is hit
-      bool done = false;
-      while(!done)
-        {
-        // read lines until the end paren is found
-        if(fin.getline(inbuffer, BUFFER_SIZE ) )
-          {
-          RemoveComments(inbuffer);
-          // Check for comment lines and ignore them.
-          if(blankLine.find(inbuffer))
-            { continue; }
-          // Is this the last line?
-          if(lastLine.find(inbuffer))
-            {
-            done = true;
-            std::string gargs = lastLine.match(1);
-            cmSystemTools::GetArguments(gargs, arguments);
-            }
-          else
-            {
-            std::string line = inbuffer;
-            cmSystemTools::GetArguments(line, arguments);
-            }
-          }
-        else
-          {
-          parseError = true;
-          cmSystemTools::Error("Parse error in read function missing end )\nIn File: ",
-                               filename, "\nCurrent line:", inbuffer);
-          return false;
-          }
-        }
-      return true;
-      }
-    else
-      {
-      parseError = true;
-      cmSystemTools::Error("Parse error in read function\nIn file:", 
-                           filename, "\nCurrent line:", inbuffer);
-      return false;
-      }
-    }
-  return false;
-
-}
-
-void cmSystemTools::GetArguments(std::string& line,
-                                 std::vector<std::string>& arguments)
-{
-  // Match a normal argument (not quoted, no spaces).
-  cmRegularExpression normalArgument("[ \t]*(([^ \t\r\\]|[\\].)+)[ \t\r]*");
-  // Match a quoted argument (surrounded by double quotes, spaces allowed).
-  cmRegularExpression quotedArgument("[ \t]*(\"([^\"\\]|[\\].)*\")[ \t\r]*");
-
-  bool done = false;
-  while(!done)
-    {
-    std::string arg;
-    std::string::size_type endpos=0;
-    bool foundQuoted = quotedArgument.find(line.c_str());
-    bool foundNormal = normalArgument.find(line.c_str());
-
-    if(foundQuoted && foundNormal)
-      {
-      // Both matches were found.  Take the earlier one.
-      // Favor double-quoted version if there is a tie.
-      if(normalArgument.start(1) < quotedArgument.start(1))
-        {
-        arg = normalArgument.match(1);
-        endpos = normalArgument.end(1);
-        }
-      else
-        {
-        arg = quotedArgument.match(1);
-        endpos = quotedArgument.end(1);
-        // Strip off the double quotes on the ends.
-        arg = arg.substr(1, arg.length()-2);
-        }
-      }    
-    else if (foundQuoted)
-      {
-      arg = quotedArgument.match(1);
-      endpos = quotedArgument.end(1);
-      // Strip off the double quotes on the ends.
-      arg = arg.substr(1, arg.length()-2);
-      }
-    else if(foundNormal)
-      {
-      arg = normalArgument.match(1);
-      endpos = normalArgument.end(1);
-      }
-    else
-      {
-      done = true;
-      }
-    if(!done)
-      {
-      arguments.push_back(cmSystemTools::RemoveEscapes(arg.c_str()));
-      line = line.substr(endpos, line.length() - endpos);
-      }
-    }
-}
-
-
 std::string cmSystemTools::RemoveEscapes(const char* s)
 {
   std::string result = "";
@@ -2141,90 +1979,101 @@ void cmSystemTools::GlobDirs(const char *fullPath,
 }
 
 
-void cmSystemTools::ExpandListArguments(std::vector<std::string> const& arguments, 
-                                        std::vector<std::string>& newargs)
+void cmSystemTools::ExpandList(std::vector<std::string> const& arguments, 
+                               std::vector<std::string>& newargs)
 {
   std::vector<std::string>::const_iterator i;
-  std::string newarg;
   for(i = arguments.begin();i != arguments.end(); ++i)
     {
-    // if there are no ; in the name then just copy the current string
-    if(i->find(';') == std::string::npos)
-      {
-      newargs.push_back(*i);
-      }
-    else
+    cmSystemTools::ExpandListArgument(*i, newargs);
+    }
+}
+
+void cmSystemTools::ExpandListArgument(const std::string& arg,
+                                       std::vector<std::string>& newargs)
+{
+  std::string newarg;
+  // If argument is empty, it is an empty list.
+  if(arg.length() == 0)
+    {
+    return;
+    }
+  // if there are no ; in the name then just copy the current string
+  if(arg.find(';') == std::string::npos)
+    {
+    newargs.push_back(arg);
+    }
+  else
+    {
+    std::string::size_type start = 0;
+    std::string::size_type endpos = 0;
+    const std::string::size_type size = arg.size();
+    // break up ; separated sections of the string into separate strings
+    while(endpos != size)
       {
-      std::string::size_type start = 0;
-      std::string::size_type endpos = 0;
-      const std::string::size_type size = i->size();
-      // break up ; separated sections of the string into separate strings
-      while(endpos != size)
+      endpos = arg.find(';', start); 
+      if(endpos == std::string::npos)
         {
-        endpos = i->find(';', start); 
+        endpos = arg.size();
+        }
+      else
+        {
+        // skip right over escaped ; ( \; )
+        while((endpos != std::string::npos)
+              && (endpos > 0) 
+              && ((arg)[endpos-1] == '\\') )
+          {
+          endpos = arg.find(';', endpos+1);
+          }
         if(endpos == std::string::npos)
           {
-          endpos = i->size();
+          endpos = arg.size();
           }
-        else
+        }
+      std::string::size_type len = endpos - start;
+      if (len > 0)
+        {
+        // check for a closing ] after the start position
+        if(arg.find('[', start) == std::string::npos)
           {
-          // skip right over escaped ; ( \; )
-          while((endpos != std::string::npos)
-                && (endpos > 0) 
-                && ((*i)[endpos-1] == '\\') )
-            {
-            endpos = i->find(';', endpos+1);
-            }
-          if(endpos == std::string::npos)
-            {
-            endpos = i->size();
-            }
+          // if there is no [ in the string then keep it
+          newarg = arg.substr(start, len);
           }
-        std::string::size_type len = endpos - start;
-        if (len > 0)
+        else
           {
-          // check for a closing ] after the start position
-          if(i->find('[', start) == std::string::npos)
+          int opencount = 0;
+          int closecount = 0;
+          for(std::string::size_type j = start; j < endpos; ++j)
             {
-            // if there is no [ in the string then keep it
-            newarg = i->substr(start, len);
-            }
-          else
-            {
-            int opencount = 0;
-            int closecount = 0;
-            for(std::string::size_type j = start; j < endpos; ++j)
+            if(arg.at(j) == '[')
               {
-              if(i->at(j) == '[')
-                {
-                ++opencount;
-                }
-              else if (i->at(j) == ']')
-                {
-                ++closecount;
-                }
+              ++opencount;
               }
-            if(opencount != closecount)
+            else if (arg.at(j) == ']')
               {
-              // skip this one
-              endpos = i->find(';', endpos+1);  
-              if(endpos == std::string::npos)
-                {
-                endpos = i->size();
-                }
-              len = endpos - start;
+              ++closecount;
               }
-            newarg = i->substr(start, len);
             }
-          std::string::size_type pos = newarg.find("\\;");
-          if(pos != std::string::npos)
+          if(opencount != closecount)
             {
-            newarg.erase(pos, 1);
+            // skip this one
+            endpos = arg.find(';', endpos+1);  
+            if(endpos == std::string::npos)
+              {
+              endpos = arg.size();
+              }
+            len = endpos - start;
             }
-          newargs.push_back(newarg);
+          newarg = arg.substr(start, len);
           }
-        start = endpos+1;
+        std::string::size_type pos = newarg.find("\\;");
+        if(pos != std::string::npos)
+          {
+          newarg.erase(pos, 1);
+          }
+        newargs.push_back(newarg);
         }
+      start = endpos+1;
       }
     }
 }
diff --git a/Source/cmSystemTools.h b/Source/cmSystemTools.h
index 0e41691..f9ff94f 100644
--- a/Source/cmSystemTools.h
+++ b/Source/cmSystemTools.h
@@ -56,8 +56,10 @@ public:
    *  strings into multiple arguements.  A new vector is created 
    *  containing the expanded versions of all arguments in argsIn.
    */
-  static void ExpandListArguments(std::vector<std::string> const& argsIn,
-                                  std::vector<std::string>& argsOut);
+  static void ExpandList(std::vector<std::string> const& argsIn,
+                         std::vector<std::string>& argsOut);
+  static void ExpandListArgument(const std::string& arg,
+                                 std::vector<std::string>& argsOut);
 
   /**
    * Read a registry value
@@ -117,25 +119,6 @@ public:
   
   ///! Return true if a file exists in the current directory.
   static bool FileExists(const char* filename);
-
-  /**
-   * Read a CMake command (or function) from an input file.  This
-   * returns the name of the function and a list of its 
-   * arguments.  The last argument is the name of the file that 
-   * the ifstream points to, and is used for debug info only.
-   */
-  static bool ParseFunction(std::ifstream&, 
-                            std::string& name,
-                            std::vector<std::string>& arguments,
-                            const char* filename, bool& parseError);
-
-  /**
-   *  Extract white-space separated arguments from a string.
-   *  Double quoted strings are accepted with spaces.
-   *  This is called by ParseFunction.
-   */
-  static void GetArguments(std::string& line,
-                           std::vector<std::string>& arguments);
   
   /**
    * Given a string, replace any escape sequences with the corresponding
@@ -389,5 +372,4 @@ private:
   static std::string s_Windows9xComspecSubstitute;
 };
 
-
 #endif
diff --git a/Source/cmTarget.cxx b/Source/cmTarget.cxx
index 92fd063..1e97557 100644
--- a/Source/cmTarget.cxx
+++ b/Source/cmTarget.cxx
@@ -75,10 +75,8 @@ void cmTarget::GenerateSourceFilesFromSourceLists( cmMakefile &mf)
         // if the definition exists
         if (varValue)
           {
-          std::vector<std::string> tval;
-          tval.push_back(varValue);
           std::vector<std::string> args;
-          cmSystemTools::ExpandListArguments(tval, args);
+          cmSystemTools::ExpandListArgument(varValue, args);
           unsigned int i;
           for (i = 0; i < args.size(); ++i)
             {
diff --git a/Source/cmTargetLinkLibrariesCommand.cxx b/Source/cmTargetLinkLibrariesCommand.cxx
index aabbcf7..70ba944 100644
--- a/Source/cmTargetLinkLibrariesCommand.cxx
+++ b/Source/cmTargetLinkLibrariesCommand.cxx
@@ -17,21 +17,19 @@
 #include "cmTargetLinkLibrariesCommand.h"
 
 // cmTargetLinkLibrariesCommand
-bool cmTargetLinkLibrariesCommand::InitialPass(std::vector<std::string> const& argsIn)
+bool cmTargetLinkLibrariesCommand::InitialPass(std::vector<std::string> const& args)
 {
   // must have one argument
-  if(argsIn.size() < 1)
+  if(args.size() < 1)
     {
     this->SetError("called with incorrect number of arguments");
     return false;
     }
   // but we might not have any libs after variable expansion
-  if(argsIn.size() < 2)
+  if(args.size() < 2)
     {
     return true;
     }
-  std::vector<std::string> args;
-  cmSystemTools::ExpandListArguments(argsIn, args);
   // add libraries, nothe that there is an optional prefix 
   // of debug and optimized than can be used
   std::vector<std::string>::const_iterator i = args.begin();
diff --git a/Source/cmUtilitySourceCommand.cxx b/Source/cmUtilitySourceCommand.cxx
index 1a33762..10cefb8 100644
--- a/Source/cmUtilitySourceCommand.cxx
+++ b/Source/cmUtilitySourceCommand.cxx
@@ -17,15 +17,13 @@
 #include "cmUtilitySourceCommand.h"
 
 // cmUtilitySourceCommand
-bool cmUtilitySourceCommand::InitialPass(std::vector<std::string> const& argsIn)
+bool cmUtilitySourceCommand::InitialPass(std::vector<std::string> const& args)
 {
-  if(argsIn.size() < 3)
+  if(args.size() < 3)
     {
     this->SetError("called with incorrect number of arguments");
     return false;
     }
-  std::vector<std::string> args;
-  cmSystemTools::ExpandListArguments(argsIn, args);
 
   std::vector<std::string>::const_iterator arg = args.begin();
   
diff --git a/Source/cmVariableRequiresCommand.cxx b/Source/cmVariableRequiresCommand.cxx
index 2433ca2..81e1f86 100644
--- a/Source/cmVariableRequiresCommand.cxx
+++ b/Source/cmVariableRequiresCommand.cxx
@@ -25,7 +25,7 @@ bool cmVariableRequiresCommand::InitialPass(std::vector<std::string> const& args
     this->SetError("called with incorrect number of arguments");
     return false;
     }
-  cmSystemTools::ExpandListArguments(args, m_Arguments);
+  m_Arguments = args;
   return true;
 }
 
diff --git a/Source/cmWriteFileCommand.cxx b/Source/cmWriteFileCommand.cxx
index ab7f957..79a8b46 100644
--- a/Source/cmWriteFileCommand.cxx
+++ b/Source/cmWriteFileCommand.cxx
@@ -17,15 +17,13 @@
 #include "cmWriteFileCommand.h"
 
 // cmLibraryCommand
-bool cmWriteFileCommand::InitialPass(std::vector<std::string> const& argsIn)
+bool cmWriteFileCommand::InitialPass(std::vector<std::string> const& args)
 {
-  if(argsIn.size() < 2 )
+  if(args.size() < 2 )
     {
     this->SetError("called with incorrect number of arguments");
     return false;
     }
-  std::vector<std::string> args;
-  cmSystemTools::ExpandListArguments(argsIn, args);
   std::string message;
   std::vector<std::string>::const_iterator i = args.begin();
 
diff --git a/Source/ctest.cxx b/Source/ctest.cxx
index 4fba9b1..20a183e 100644
--- a/Source/ctest.cxx
+++ b/Source/ctest.cxx
@@ -17,6 +17,7 @@
 #include "ctest.h"
 #include "cmRegularExpression.h"
 #include "cmSystemTools.h"
+#include "cmListFileCache.h"
 
 #include <stdio.h>
 #include <time.h>
@@ -1111,17 +1112,19 @@ void ctest::ProcessDirectory(std::vector<std::string> &passed,
   bool parseError;
   while ( fin )
     {
-    if(cmSystemTools::ParseFunction(fin, name, args, "DartTestfile.txt",
-                                    parseError))
+    cmListFileFunction lff;
+    if(cmListFileCache::ParseFunction(fin, lff, "DartTestfile.txt", parseError))
       {
+      const std::string& name = lff.m_Name;
+      const std::vector<cmListFileArgument>& args = lff.m_Arguments;
       if (name == "SUBDIRS")
         {
         std::string cwd = cmSystemTools::GetCurrentWorkingDirectory();
-        for(std::vector<std::string>::iterator j = args.begin();
+        for(std::vector<cmListFileArgument>::const_iterator j = args.begin();
             j != args.end(); ++j)
           {   
           std::string nwd = cwd + "/";
-          nwd += *j;
+          nwd += j->Value;
           if (cmSystemTools::FileIsDirectory(nwd.c_str()))
             {
             cmSystemTools::ChangeDirectory(nwd.c_str());
@@ -1136,17 +1139,17 @@ void ctest::ProcessDirectory(std::vector<std::string> &passed,
         {
         if (this->m_UseExcludeRegExp && 
             this->m_UseExcludeRegExpFirst && 
-            ereg.find(args[0].c_str()))
+            ereg.find(args[0].Value.c_str()))
           {
           continue;
           }
-        if (this->m_UseIncludeRegExp && !ireg.find(args[0].c_str()))
+        if (this->m_UseIncludeRegExp && !ireg.find(args[0].Value.c_str()))
           {
           continue;
           }
         if (this->m_UseExcludeRegExp && 
             !this->m_UseExcludeRegExpFirst && 
-            ereg.find(args[0].c_str()))
+            ereg.find(args[0].Value.c_str()))
           {
           continue;
           }
@@ -1159,30 +1162,30 @@ void ctest::ProcessDirectory(std::vector<std::string> &passed,
           std::cerr << "Changing directory into " << nwd.c_str() << "\n";
           firstTest = 0;
           }
-        cres.m_Name = args[0];
-        fprintf(stderr,"Testing %-30s ",args[0].c_str());
+        cres.m_Name = args[0].Value;
+        fprintf(stderr,"Testing %-30s ",args[0].Value.c_str());
         fflush(stderr);
         //std::cerr << "Testing " << args[0] << " ... ";
         // find the test executable
-        std::string testCommand = this->FindExecutable(args[1].c_str());
+        std::string testCommand = this->FindExecutable(args[1].Value.c_str());
         testCommand = cmSystemTools::ConvertToOutputPath(testCommand.c_str());
 
         // continue if we did not find the executable
         if (testCommand == "")
           {
           std::cerr << "Unable to find executable: " << 
-            args[1].c_str() << "\n";
+            args[1].Value.c_str() << "\n";
           continue;
           }
         
         // add the arguments
-        std::vector<std::string>::iterator j = args.begin();
+        std::vector<cmListFileArgument>::const_iterator j = args.begin();
         ++j;
         ++j;
         for(;j != args.end(); ++j)
           {   
           testCommand += " ";
-          testCommand += cmSystemTools::EscapeSpaces(j->c_str());
+          testCommand += cmSystemTools::EscapeSpaces(j->Value.c_str());
           }
         /**
          * Run an executable command and put the stdout in output.
@@ -1219,7 +1222,7 @@ void ctest::ProcessDirectory(std::vector<std::string> &passed,
               std::cerr << output.c_str() << "\n";
               }
             }
-          failed.push_back(args[0]); 
+          failed.push_back(args[0].Value); 
           }
         else
           {
@@ -1236,7 +1239,7 @@ void ctest::ProcessDirectory(std::vector<std::string> &passed,
               std::cerr << output.c_str() << "\n";
               }
             }
-          passed.push_back(args[0]); 
+          passed.push_back(args[0].Value); 
           }
         cres.m_Output = output;
         cres.m_ReturnValue = retVal;