Source/cmIDEOptions.cxx

   1 /*=========================================================================
   2
   3   Program:   CMake - Cross-Platform Makefile Generator
   4   Module:    $RCSfile: cmIDEOptions.cxx,v $
   5   Language:  C++
   6   Date:      $Date: 2009-07-29 15:29:03 $
   7   Version:   $Revision: 1.1 $
   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 "cmIDEOptions.h"
  18
  19 #include "cmSystemTools.h"
  20
  21 //----------------------------------------------------------------------------
  22 cmIDEOptions::cmIDEOptions()
  23 {
  24   this->DoingDefine = false;
  25   this->AllowDefine = true;
  26   this->AllowSlash = false;
  27   for(int i=0; i < FlagTableCount; ++i)
  28     {
  29     this->FlagTable[i] = 0;
  30     }
  31 }
  32
  33 //----------------------------------------------------------------------------
  34 cmIDEOptions::~cmIDEOptions()
  35 {
  36 }
  37
  38 //----------------------------------------------------------------------------
  39 void cmIDEOptions::HandleFlag(const char* flag)
  40 {
  41   // If the last option was -D then this option is the definition.
  42   if(this->DoingDefine)
  43     {
  44     this->DoingDefine = false;
  45     this->Defines.push_back(flag);
  46     return;
  47     }
  48
  49   // Look for known arguments.
  50   if(flag[0] == '-' || (this->AllowSlash && flag[0] == '/'))
  51     {
  52     // Look for preprocessor definitions.
  53     if(this->AllowDefine && flag[1] == 'D')
  54       {
  55       if(flag[2] == '\0')
  56         {
  57         // The next argument will have the definition.
  58         this->DoingDefine = true;
  59         }
  60       else
  61         {
  62         // Store this definition.
  63         this->Defines.push_back(flag+2);
  64         }
  65       return;
  66       }
  67
  68     // Look through the available flag tables.
  69     bool flag_handled = false;
  70     for(int i=0; i < FlagTableCount && this->FlagTable[i]; ++i)
  71       {
  72       if(this->CheckFlagTable(this->FlagTable[i], flag, flag_handled))
  73         {
  74         return;
  75         }
  76       }
  77
  78     // If any map entry handled the flag we are done.
  79     if(flag_handled)
  80       {
  81       return;
  82       }
  83     }
  84
  85   // This option is not known.  Store it in the output flags.
  86   this->StoreUnknownFlag(flag);
  87 }
  88
  89 //----------------------------------------------------------------------------
  90 bool cmIDEOptions::CheckFlagTable(cmIDEFlagTable const* table,
  91                                   const char* flag, bool& flag_handled)
  92 {
  93   // Look for an entry in the flag table matching this flag.
  94   for(cmIDEFlagTable const* entry = table; entry->IDEName; ++entry)
  95     {
  96     bool entry_found = false;
  97     if(entry->special & cmIDEFlagTable::UserValue)
  98       {
  99       // This flag table entry accepts a user-specified value.  If
 100       // the entry specifies UserRequired we must match only if a
 101       // non-empty value is given.
 102       int n = static_cast<int>(strlen(entry->commandFlag));
 103       if(strncmp(flag+1, entry->commandFlag, n) == 0 &&
 104          (!(entry->special & cmIDEFlagTable::UserRequired) ||
 105           static_cast<int>(strlen(flag+1)) > n))
 106         {
 107         if(entry->special & cmIDEFlagTable::UserIgnored)
 108           {
 109           // Ignore the user-specified value.
 110           this->FlagMap[entry->IDEName] = entry->value;
 111           }
 112         else if(entry->special & cmIDEFlagTable::SemicolonAppendable)
 113           {
 114           const char *new_value = flag+1+n;
 115
 116           std::map<cmStdString,cmStdString>::iterator itr;
 117           itr = this->FlagMap.find(entry->IDEName);
 118           if(itr != this->FlagMap.end())
 119             {
 120             // Append to old value (if present) with semicolons;
 121             itr->second += ";";
 122             itr->second += new_value;
 123             }
 124           else
 125             {
 126             this->FlagMap[entry->IDEName] = new_value;
 127             }
 128           }
 129         else
 130           {
 131           // Use the user-specified value.
 132           this->FlagMap[entry->IDEName] = flag+1+n;
 133           }
 134         entry_found = true;
 135         }
 136       }
 137     else if(strcmp(flag+1, entry->commandFlag) == 0)
 138       {
 139       // This flag table entry provides a fixed value.
 140       this->FlagMap[entry->IDEName] = entry->value;
 141       entry_found = true;
 142       }
 143
 144     // If the flag has been handled by an entry not requesting a
 145     // search continuation we are done.
 146     if(entry_found && !(entry->special & cmIDEFlagTable::Continue))
 147       {
 148       return true;
 149       }
 150
 151     // If the entry was found the flag has been handled.
 152     flag_handled = flag_handled || entry_found;
 153     }
 154
 155   return false;
 156 }
 157
 158 //----------------------------------------------------------------------------
 159 void cmIDEOptions::AddDefine(const std::string& def)
 160 {
 161   this->Defines.push_back(def);
 162 }
 163
 164 //----------------------------------------------------------------------------
 165 void cmIDEOptions::AddDefines(const char* defines)
 166 {
 167   if(defines)
 168     {
 169     // Expand the list of definitions.
 170     cmSystemTools::ExpandListArgument(defines, this->Defines);
 171     }
 172 }
 173
 174 //----------------------------------------------------------------------------
 175 void cmIDEOptions::AddFlag(const char* flag, const char* value)
 176 {
 177   this->FlagMap[flag] = value;
 178 }