diff --git a/Source/cmFunctionCommand.cxx b/Source/cmFunctionCommand.cxx
new file mode 100644
index 000000000..a95c04dc2
--- /dev/null
+++ b/Source/cmFunctionCommand.cxx
@@ -0,0 +1,277 @@
+/*=========================================================================
+
+  Program:   CMake - Cross-Platform Makefile Generator
+  Module:    $RCSfile$
+  Language:  C++
+  Date:      $Date$
+  Version:   $Revision$
+
+  Copyright (c) 2002 Kitware, Inc., Insight Consortium.  All rights reserved.
+  See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details.
+
+     This software is distributed WITHOUT ANY WARRANTY; without even
+     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+     PURPOSE.  See the above copyright notices for more information.
+
+=========================================================================*/
+#include "cmFunctionCommand.h"
+
+#include "cmake.h"
+
+// define the class for function commands
+class cmFunctionHelperCommand : public cmCommand
+{
+public:
+  cmFunctionHelperCommand() {}
+
+  ///! clean up any memory allocated by the function
+  ~cmFunctionHelperCommand() {};
+
+  /**
+   * This is a virtual constructor for the command.
+   */
+  virtual cmCommand* Clone()
+  {
+    cmFunctionHelperCommand *newC = new cmFunctionHelperCommand;
+    // we must copy when we clone
+    newC->Args = this->Args;
+    newC->Functions = this->Functions;
+    return newC;
+  }
+
+  /**
+   * This determines if the command is invoked when in script mode.
+   */
+  virtual bool IsScriptable() { return true; }
+
+  /**
+   * This is called when the command is first encountered in
+   * the CMakeLists.txt file.
+   */
+  virtual bool InvokeInitialPass(const std::vector<cmListFileArgument>& args);
+
+  virtual bool InitialPass(std::vector<std::string> const&) { return false; };
+
+  /**
+   * The name of the command as specified in CMakeList.txt.
+   */
+  virtual const char* GetName() { return this->Args[0].c_str(); }
+  
+  /**
+   * Succinct documentation.
+   */
+  virtual const char* GetTerseDocumentation()
+  {
+    std::string docs = "Function named: ";
+    docs += this->GetName();
+    return docs.c_str();
+  }
+
+  /**
+   * More documentation.
+   */
+  virtual const char* GetFullDocumentation()
+  {
+    return this->GetTerseDocumentation();
+  }
+
+  cmTypeMacro(cmFunctionHelperCommand, cmCommand);
+
+  std::vector<std::string> Args;
+  std::vector<cmListFileFunction> Functions;
+};
+
+
+bool cmFunctionHelperCommand::InvokeInitialPass
+(const std::vector<cmListFileArgument>& args)
+{
+  // Expand the argument list to the function.
+  std::vector<std::string> expandedArgs;
+  this->Makefile->ExpandArguments(args, expandedArgs);
+
+  // make sure the number of arguments passed is at least the number
+  // required by the signature
+  if (expandedArgs.size() < this->Args.size() - 1)
+    {
+    std::string errorMsg =
+      "Function invoked with incorrect arguments for function named: ";
+    errorMsg += this->Args[0];
+    this->SetError(errorMsg.c_str());
+    return false;
+    }
+
+  // we push a scope on the makefile
+  this->Makefile->PushScope();
+
+  // set the value of argc
+  cmOStringStream strStream;
+  strStream << expandedArgs.size();
+  this->Makefile->AddDefinition("ARGC",strStream.str().c_str());
+
+  // set the values for ARGV0 ARGV1 ...
+  for (unsigned int t = 0; t < expandedArgs.size(); ++t)
+    {
+    strStream.str("");
+    strStream << "ARGV" << t;
+    this->Makefile->AddDefinition(strStream.str().c_str(), 
+                                  expandedArgs[t].c_str());
+    }
+  
+  // define the formal arguments
+  for (unsigned int j = 1; j < this->Args.size(); ++j)
+    {
+    this->Makefile->AddDefinition(this->Args[j].c_str(), 
+                                  expandedArgs[j-1].c_str());
+    }
+
+  // define ARGV and ARGN
+  std::vector<std::string>::const_iterator eit;
+  std::string argvDef;
+  std::string argnDef;
+  unsigned int cnt = 0;
+  for ( eit = expandedArgs.begin(); eit != expandedArgs.end(); ++eit )
+    {
+    if ( argvDef.size() > 0 )
+      {
+      argvDef += ";";
+      }
+    argvDef += *eit;
+    if ( cnt >= this->Args.size()-1 )
+      {
+      if ( argnDef.size() > 0 )
+        {
+        argnDef += ";";
+        }
+      argnDef += *eit;
+      }
+    cnt ++;
+    }
+  this->Makefile->AddDefinition("ARGV", argvDef.c_str());
+  this->Makefile->AddDefinition("ARGN", argnDef.c_str());
+
+  // Invoke all the functions that were collected in the block.
+  cmListFileFunction newLFF;
+
+  // for each function
+  for(unsigned int c = 0; c < this->Functions.size(); ++c)
+    {
+    if (!this->Makefile->ExecuteCommand(this->Functions[c]))
+      {
+      cmOStringStream error;
+      error << "Error in cmake code at\n"
+            << this->Functions[c].FilePath << ":" 
+            << this->Functions[c].Line << ":\n"
+            << "A command failed during the invocation of function \""
+            << this->Args[0].c_str() << "\".";
+      cmSystemTools::Error(error.str().c_str());
+
+      // pop scope on the makefile and return
+      this->Makefile->PopScope();
+      return false;
+      }
+    }
+
+  // pop scope on the makefile
+  this->Makefile->PopScope();
+  return true;
+}
+
+bool cmFunctionFunctionBlocker::
+IsFunctionBlocked(const cmListFileFunction& lff, cmMakefile &mf)
+{
+  // record commands until we hit the ENDFUNCTION
+  // at the ENDFUNCTION call we shift gears and start looking for invocations
+  if(!cmSystemTools::Strucmp(lff.Name.c_str(),"function"))
+    {
+    this->Depth++;
+    }
+  else if(!cmSystemTools::Strucmp(lff.Name.c_str(),"endfunction"))
+    {
+    // if this is the endfunction for this function then execute
+    if (!this->Depth) 
+      {
+      std::string name = this->Args[0];
+      std::vector<std::string>::size_type cc;
+      name += "(";
+      for ( cc = 0; cc < this->Args.size(); cc ++ )
+        {
+        name += " " + this->Args[cc];
+        }
+      name += " )";
+
+      // create a new command and add it to cmake
+      cmFunctionHelperCommand *f = new cmFunctionHelperCommand();
+      f->Args = this->Args;
+      f->Functions = this->Functions;
+      std::string newName = "_" + this->Args[0];
+      mf.GetCMakeInstance()->RenameCommand(this->Args[0].c_str(), 
+                                           newName.c_str());
+      mf.AddCommand(f);
+
+      // remove the function blocker now that the function is defined
+      mf.RemoveFunctionBlocker(lff);
+      return true;
+      }
+    else
+      {
+      // decrement for each nested function that ends
+      this->Depth--;
+      }
+    }
+
+  // if it wasn't an endfunction and we are not executing then we must be
+  // recording
+  this->Functions.push_back(lff);
+  return true;
+}
+
+
+bool cmFunctionFunctionBlocker::
+ShouldRemove(const cmListFileFunction& lff, cmMakefile &mf)
+{
+  if(!cmSystemTools::Strucmp(lff.Name.c_str(),"endfunction"))
+    {
+    std::vector<std::string> expandedArguments;
+    mf.ExpandArguments(lff.Arguments, expandedArguments);
+    if ((!expandedArguments.empty() && 
+        (expandedArguments[0] == this->Args[0]))
+        || cmSystemTools::IsOn
+        (mf.GetPropertyOrDefinition("CMAKE_ALLOW_LOOSE_LOOP_CONSTRUCTS")))
+      {
+      return true;
+      }
+    }
+
+  return false;
+}
+
+void cmFunctionFunctionBlocker::
+ScopeEnded(cmMakefile &mf)
+{
+  // functions should end with an EndFunction
+  cmSystemTools::Error(
+    "The end of a CMakeLists file was reached with a FUNCTION statement that "
+    "was not closed properly. Within the directory: ",
+    mf.GetCurrentDirectory(), " with function ",
+    this->Args[0].c_str());
+}
+
+bool cmFunctionCommand::InitialPass(std::vector<std::string> const& args)
+{
+  if(args.size() < 1)
+    {
+    this->SetError("called with incorrect number of arguments");
+    return false;
+    }
+
+  // create a function blocker
+  cmFunctionFunctionBlocker *f = new cmFunctionFunctionBlocker();
+  for(std::vector<std::string>::const_iterator j = args.begin();
+      j != args.end(); ++j)
+    {   
+    f->Args.push_back(*j);
+    }
+  this->Makefile->AddFunctionBlocker(f);
+  return true;
+}
+
diff --git a/Source/cmFunctionCommand.h b/Source/cmFunctionCommand.h
new file mode 100644
index 000000000..908a668ef
--- /dev/null
+++ b/Source/cmFunctionCommand.h
@@ -0,0 +1,112 @@
+/*=========================================================================
+
+  Program:   CMake - Cross-Platform Makefile Generator
+  Module:    $RCSfile$
+  Language:  C++
+  Date:      $Date$
+  Version:   $Revision$
+
+  Copyright (c) 2002 Kitware, Inc., Insight Consortium.  All rights reserved.
+  See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details.
+
+     This software is distributed WITHOUT ANY WARRANTY; without even
+     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+     PURPOSE.  See the above copyright notices for more information.
+
+=========================================================================*/
+#ifndef cmFunctionCommand_h
+#define cmFunctionCommand_h
+
+#include "cmCommand.h"
+#include "cmFunctionBlocker.h"
+
+/** \class cmFunctionFunctionBlocker
+ * \brief subclass of function blocker
+ *
+ *
+ */
+class cmFunctionFunctionBlocker : public cmFunctionBlocker
+{
+public:
+  cmFunctionFunctionBlocker() {this->Depth=0;}
+  virtual ~cmFunctionFunctionBlocker() {}
+  virtual bool IsFunctionBlocked(const cmListFileFunction&, cmMakefile &mf);
+  virtual bool ShouldRemove(const cmListFileFunction&, cmMakefile &mf);
+  virtual void ScopeEnded(cmMakefile &mf);
+  
+  std::vector<std::string> Args;
+  std::vector<cmListFileFunction> Functions;
+  int Depth;
+};
+
+/** \class cmFunctionCommand
+ * \brief starts an if block
+ *
+ * cmFunctionCommand starts an if block
+ */
+class cmFunctionCommand : public cmCommand
+{
+public:
+  /**
+   * This is a virtual constructor for the command.
+   */
+  virtual cmCommand* Clone()
+    {
+    return new cmFunctionCommand;
+    }
+
+  /**
+   * This is called when the command is first encountered in
+   * the CMakeLists.txt file.
+   */
+  virtual bool InitialPass(std::vector<std::string> const& args);
+
+  /**
+   * This determines if the command is invoked when in script mode.
+   */
+  virtual bool IsScriptable() { return true; }
+
+  /**
+   * The name of the command as specified in CMakeList.txt.
+   */
+  virtual const char* GetName() { return "function";}
+
+  /**
+   * Succinct documentation.
+   */
+  virtual const char* GetTerseDocumentation()
+    {
+    return "Start recording a function for later invocation as a command.";
+    }
+
+  /**
+   * More documentation.
+   */
+  virtual const char* GetFullDocumentation()
+    {
+    return
+      "  function(<name> [arg1 [arg2 [arg3 ...]]])\n"
+      "    COMMAND1(ARGS ...)\n"
+      "    COMMAND2(ARGS ...)\n"
+      "    ...\n"
+      "  endfunction(<name>)\n"
+      "Define a function named <name> that takes arguments named "
+      "arg1 arg2 arg3 (...).  Commands listed after function, "
+      "but before the matching endfunction, are not invoked until the function "
+      "is invoked.  When it is invoked, the commands recorded in the "
+      "function are first modified by replacing formal parameters (${arg1}) "
+      "with the arguments passed, and then invoked as normal commands. In "
+      "addition to referencing the formal parameters you can reference "
+      "the variable ARGC which will be set to the number of arguments "
+      "passed into the function as well as ARGV0 ARGV1 ARGV2 ... which "
+      "will have the actual values of the arguments passed in. This "
+      "facilitates creating functions with optional arguments. Additionally "
+      "ARGV holds the list of all arguments given to the function and ARGN "
+      "holds the list of argument pass the last expected argument.";
+    }
+
+  cmTypeMacro(cmFunctionCommand, cmCommand);
+};
+
+
+#endif
diff --git a/Source/cmRaiseScopeCommand.cxx b/Source/cmRaiseScopeCommand.cxx
new file mode 100644
index 000000000..ffaff8ebd
--- /dev/null
+++ b/Source/cmRaiseScopeCommand.cxx
@@ -0,0 +1,30 @@
+/*=========================================================================
+
+  Program:   CMake - Cross-Platform Makefile Generator
+  Module:    $RCSfile$
+  Language:  C++
+  Date:      $Date$
+  Version:   $Revision$
+
+  Copyright (c) 2002 Kitware, Inc., Insight Consortium.  All rights reserved.
+  See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details.
+
+     This software is distributed WITHOUT ANY WARRANTY; without even 
+     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
+     PURPOSE.  See the above copyright notices for more information.
+
+=========================================================================*/
+#include "cmRaiseScopeCommand.h"
+
+// cmRaiseScopeCommand
+bool cmRaiseScopeCommand
+::InitialPass(std::vector<std::string> const& args)
+{
+  unsigned int i =0;
+  for(; i < args.size(); ++i)
+    {
+    this->Makefile->RaiseScope(args[i].c_str());
+    }
+  return true;
+}
+
diff --git a/Source/cmRaiseScopeCommand.h b/Source/cmRaiseScopeCommand.h
new file mode 100644
index 000000000..51d4f1ff2
--- /dev/null
+++ b/Source/cmRaiseScopeCommand.h
@@ -0,0 +1,85 @@
+/*=========================================================================
+
+  Program:   CMake - Cross-Platform Makefile Generator
+  Module:    $RCSfile$
+  Language:  C++
+  Date:      $Date$
+  Version:   $Revision$
+
+  Copyright (c) 2002 Kitware, Inc., Insight Consortium.  All rights reserved.
+  See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details.
+
+     This software is distributed WITHOUT ANY WARRANTY; without even 
+     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
+     PURPOSE.  See the above copyright notices for more information.
+
+=========================================================================*/
+#ifndef cmRaiseScopeCommand_h
+#define cmRaiseScopeCommand_h
+
+#include "cmCommand.h"
+
+/** \class cmRaiseScopeCommand
+ * \brief Raise the Scope a CMAKE variable one level up
+ *
+ * cmRaiseScopeCommand pushes the current state of a variable into
+ * the scope above the current scope.
+ */
+class cmRaiseScopeCommand : public cmCommand
+{
+public:
+  /**
+   * This is a virtual constructor for the command.
+   */
+  virtual cmCommand* Clone() 
+    {
+    return new cmRaiseScopeCommand;
+    }
+
+  /**
+   * This is called when the command is first encountered in
+   * the CMakeLists.txt file.
+   */
+  virtual bool InitialPass(std::vector<std::string> const& args);
+
+  /**
+   * The name of the command as specified in CMakeList.txt.
+   */
+  virtual const char* GetName() {return "raise_scope";}
+  
+  /**
+   * Succinct documentation.
+   */
+  virtual const char* GetTerseDocumentation() 
+    {
+    return "Raise the scope of the variables listed.";
+    }
+  
+  /**
+   * More documentation.
+   */
+  virtual const char* GetFullDocumentation()
+    {
+    return
+      "  raise_scope(VAR VAR2 VAR...)\n"
+      "Pushes the current state of a variable into the scope above the "
+      "current scope. Each new directory or function creates a new scope. "
+      "This command will push the current state of a variable into the "
+      "parent directory or calling function (whichever is applicable to "
+      "the case at hand)";
+    }
+
+  /**
+   * This determines if the command is invoked when in script mode.
+   * mark_as_advanced() will have no effect in script mode, but this will
+   * make many of the modules usable in cmake/ctest scripts, (among them
+   * FindUnixMake.cmake used by the CTEST_BUILD command.
+  */
+  virtual bool IsScriptable() { return true; }
+
+  cmTypeMacro(cmRaiseScopeCommand, cmCommand);
+};
+
+
+
+#endif
diff --git a/Tests/FunctionTest/CMakeLists.txt b/Tests/FunctionTest/CMakeLists.txt
new file mode 100644
index 000000000..76c2511fe
--- /dev/null
+++ b/Tests/FunctionTest/CMakeLists.txt
@@ -0,0 +1,86 @@
+# a simple C only test case
+PROJECT (FunctionTest)
+
+SET(CMAKE_C_FLAGS "${CMAKE_ANSI_CFLAGS} ${CMAKE_C_FLAGS}")
+
+FUNCTION(FAILED testname)
+  MESSAGE(SEND_ERROR "${testname} failed ${ARGN}")
+ENDFUNCTION(FAILED)
+
+FUNCTION(PASS testname)
+  MESSAGE("${testname} passed ${ARGN}")
+ENDFUNCTION(PASS)
+
+
+# test scope
+SET(COUNT 3)
+FUNCTION(scope_test)
+  SET(COUNT 4)
+ENDFUNCTION(scope_test)
+scope_test()
+IF(COUNT EQUAL "3")
+  PASS("scope")
+ELSE(COUNT EQUAL "3")
+  FAILED("COUNT Got: ${COUNT}")
+ENDIF(COUNT EQUAL "3")
+
+# test ARGC
+FUNCTION(weird_name)
+  IF("${ARGC}" EQUAL "3")
+    PASS("ARGC")
+  ELSE("${ARGC}" EQUAL "3")
+    FAILED("ARGC" "Got: ${ARGC}")
+  ENDIF("${ARGC}" EQUAL "3")
+ENDFUNCTION(weird_name)
+WeIrD_nAmE(a1 a2 a3)
+
+# test ARGN
+FUNCTION(test_argn_function argument)
+  IF("${ARGN}" EQUAL "3")
+    PASS("ARGN")
+  ELSE("${ARGN}" EQUAL "3")
+    FAILED("ARGN" "Got: ${ARGN}")
+  ENDIF("${ARGN}" EQUAL "3")
+ENDFUNCTION(test_argn_function)
+Test_Argn_Function(ignored 3)
+
+# test recursion and return via raise_scope
+function (factorial argument result)
+  if (argument LESS 2)
+    set (${result} 1)
+  else (argument LESS 2)
+    math (EXPR temp "${argument} - 1")
+    factorial (${temp} tresult)
+    math (EXPR ${result} "${argument}*${tresult}")
+  endif (argument LESS 2)
+  raise_scope (${result})
+endfunction (factorial)
+
+factorial (5 fresult)
+if (fresult EQUAL 120)
+  pass("factorial")
+else (fresult EQUAL 120)
+  failed ("factorial, computed ${fresult} instead of 120")
+endif (fresult EQUAL 120)
+
+
+
+# case test
+FUNCTION(strange_function m)
+  SET(${m} strange_function)
+  RAISE_SCOPE(${m})
+ENDFUNCTION(strange_function m)
+STRANGE_FUNCTION(var)
+set(second_var "second_var")
+IF("${var}" STREQUAL "strange_function" AND "${second_var}" STREQUAL "second_var")
+  PASS("Case Test" "(${var} ${second_var})")
+ELSE("${var}" STREQUAL "strange_function" AND "${second_var}" STREQUAL "second_var")
+  FAILED("Case test" "(${var} ${second_var})")
+ENDIF("${var}" STREQUAL "strange_function" AND "${second_var}" STREQUAL "second_var")
+
+# test backing up command
+FUNCTION(ADD_EXECUTABLE exec)
+  _ADD_EXECUTABLE(mini${exec} ${ARGN})
+ENDFUNCTION(ADD_EXECUTABLE)
+
+ADD_EXECUTABLE(FunctionTest functionTest.c)
diff --git a/Tests/FunctionTest/functionTest.c b/Tests/FunctionTest/functionTest.c
new file mode 100644
index 000000000..e0ced6afd
--- /dev/null
+++ b/Tests/FunctionTest/functionTest.c
@@ -0,0 +1,7 @@
+#include <stdio.h>
+
+int main(int argc, char* argv[])
+{
+  printf("Running command: %s with %d arguments\n", argv[0], argc);
+  return 0;
+}