CMakeLua/Source/cmSetCommand.cxx

   1 /*=========================================================================
   2
   3   Program:   CMake - Cross-Platform Makefile Generator
   4   Module:    $RCSfile: cmSetCommand.cxx,v $
   5   Language:  C++
   6   Date:      $Date: 2008/01/23 15:27:59 $
   7   Version:   $Revision: 1.32 $
   8
   9   Copyright (c) 2002 Kitware, Inc., Insight Consortium.  All rights reserved.
  10   See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details.
  11
  12      This software is distributed WITHOUT ANY WARRANTY; without even
  13      the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  14      PURPOSE.  See the above copyright notices for more information.
  15
  16 =========================================================================*/
  17 #include "cmSetCommand.h"
  18
  19 // cmSetCommand
  20 bool cmSetCommand
  21 ::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
  22 {
  23   if(args.size() < 1 )
  24     {
  25     this->SetError("called with incorrect number of arguments");
  26     return false;
  27     }
  28
  29   // watch for ENV signatures
  30   const char* variable = args[0].c_str(); // VAR is always first
  31   if (!strncmp(variable,"ENV{",4) && strlen(variable) > 5)
  32     {
  33     // what is the variable name
  34     char *varName = new char [strlen(variable)];
  35     strncpy(varName,variable+4,strlen(variable)-5);
  36     varName[strlen(variable)-5] = '\0';
  37     std::string putEnvArg = varName;
  38     putEnvArg += "=";
  39
  40     // what is the current value if any
  41     const char *currValue = getenv(varName);
  42     delete [] varName;
  43
  44     // will it be set to something, then set it
  45     if (args.size() > 1 && args[1].size())
  46       {
  47       // but only if it is different from current value
  48       if (!currValue || strcmp(currValue,args[1].c_str()))
  49         {
  50         putEnvArg += args[1];
  51         cmSystemTools::PutEnv(putEnvArg.c_str());
  52         }
  53       return true;
  54       }
  55
  56     // if it will be cleared, then clear it if it isn;t already clear
  57     if (currValue)
  58       {
  59       cmSystemTools::PutEnv(putEnvArg.c_str());
  60       }
  61     return true;
  62     }
  63
  64   // SET (VAR) // Removes the definition of VAR.
  65   if (args.size() == 1)
  66     {
  67     this->Makefile->RemoveDefinition(args[0].c_str());
  68     return true;
  69     }
  70
  71   // here are the remaining options
  72   //  SET (VAR value )
  73   //  SET (VAR CACHE TYPE "doc String" [FORCE])
  74   //  SET (VAR value CACHE TYPE "doc string" [FORCE])
  75   std::string value;  // optional
  76   bool cache = false; // optional
  77   bool force = false; // optional
  78   bool parentScope = false;
  79   cmCacheManager::CacheEntryType type
  80     = cmCacheManager::STRING; // required if cache
  81   const char* docstring = 0; // required if cache
  82   std::string::size_type cacheStart = 0;
  83
  84   unsigned int ignoreLastArgs = 0;
  85   // look for PARENT_SCOPE argument
  86   if (args.size() > 1 && args[args.size()-1] == "PARENT_SCOPE")
  87     {
  88     parentScope = true;
  89     ignoreLastArgs++;
  90     }
  91   else
  92     {
  93     // look for FORCE argument
  94     if (args.size() > 4 && args[args.size()-1] == "FORCE")
  95       {
  96       force = true;
  97       ignoreLastArgs++;
  98       }
  99
 100     // check for cache signature
 101     if (args.size() > 3 && args[args.size() - 3 - (force ? 1 : 0)] == "CACHE")
 102       {
 103       cache = true;
 104       ignoreLastArgs+=3;
 105       }
 106     }
 107
 108   // collect any values into a single semi-colon seperated value list
 109   if(static_cast<unsigned short>(args.size()) >
 110      static_cast<unsigned short>(1 + ignoreLastArgs))
 111     {
 112     value = args[1];
 113     size_t endPos = args.size() - ignoreLastArgs;
 114     for(size_t i = 2; i < endPos; ++i)
 115       {
 116       value += ";";
 117       value += args[i];
 118       }
 119     }
 120
 121   if (parentScope)
 122     {
 123     if (value.empty())
 124       {
 125       this->Makefile->RaiseScope(variable, 0);
 126       }
 127     else
 128       {
 129       this->Makefile->RaiseScope(variable, value.c_str());
 130       }
 131       return true;
 132     }
 133
 134
 135   // we should be nice and try to catch some simple screwups if the last or
 136   // next to last args are CACHE then they screwed up.  If they used FORCE
 137   // without CACHE they screwed up
 138   if (args[args.size() - 1] == "CACHE" ||
 139       args.size() > 1 && args[args.size() - 2] == "CACHE" ||
 140       force && !cache)
 141     {
 142     std::string message;
 143     message += "Syntax error in SET:\n";
 144     message += "See the help for the SET command:\n";
 145     message += "SET (";
 146     for(std::vector<std::string>::const_iterator i = args.begin();
 147         i != args.end(); ++i)
 148       {
 149       message += *i;
 150       }
 151     message += ")\n";
 152     this->SetError(message.c_str());
 153     return false;
 154     }
 155
 156   if(cache)
 157     {
 158     cacheStart = args.size() - 3 - (force ? 1 : 0);
 159     type = cmCacheManager::StringToType(args[cacheStart+1].c_str());
 160     docstring = args[cacheStart+2].c_str();
 161     }
 162
 163   // see if this is already in the cache
 164   cmCacheManager::CacheIterator it =
 165     this->Makefile->GetCacheManager()->GetCacheIterator(variable);
 166   if(!it.IsAtEnd() && (it.GetType() != cmCacheManager::UNINITIALIZED))
 167     {
 168     // if the set is trying to CACHE the value but the value
 169     // is already in the cache and the type is not internal
 170     // then leave now without setting any definitions in the cache
 171     // or the makefile
 172     if(cache && type != cmCacheManager::INTERNAL && !force)
 173       {
 174       return true;
 175       }
 176     }
 177
 178   // if it is meant to be in the cache then define it in the cache
 179   if(cache)
 180     {
 181     this->Makefile->AddCacheDefinition(variable,
 182                                    value.c_str(),
 183                                    docstring,
 184                                    type);
 185     }
 186   else
 187     {
 188     // add the definition
 189     this->Makefile->AddDefinition(variable, value.c_str());
 190     }
 191   return true;
 192 }
 193