src/Utils/CmdLineParser.cpp

   1 // TortoiseGit - a Windows shell extension for easy version control
   2
   3 // Copyright (C) 2013, 2016-2017 - TortoiseGit
   4 // Copyright (C) 2003-2006,2012 - Stefan Kueng
   5
   6 // This program is free software; you can redistribute it and/or
   7 // modify it under the terms of the GNU General Public License
   8 // as published by the Free Software Foundation; either version 2
   9 // of the License, or (at your option) any later version.
  10
  11 // This program is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 // GNU General Public License for more details.
  15
  16 // You should have received a copy of the GNU General Public License
  17 // along with this program; if not, write to the Free Software Foundation,
  18 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  19 //
  20 #include "stdafx.h"
  21 #include "CmdLineParser.h"
  22 #include <locale>
  23 #include <algorithm>
  24
  25 const TCHAR CCmdLineParser::m_sDelims[] = L"-/";
  26 const TCHAR CCmdLineParser::m_sQuotes[] = L"\"";
  27 const TCHAR CCmdLineParser::m_sValueSep[] = L" :"; // don't forget space!!
  28
  29
  30 CCmdLineParser::CCmdLineParser(LPCTSTR sCmdLine)
  31 {
  32         if(sCmdLine)
  33                 Parse(sCmdLine);
  34 }
  35
  36 CCmdLineParser& CCmdLineParser::operator=(CCmdLineParser&& other)
  37 {
  38         m_sCmdLine = std::move(other.m_sCmdLine);
  39         m_valueMap = std::move(other.m_valueMap);
  40         return *this;
  41 }
  42
  43 BOOL CCmdLineParser::Parse(LPCTSTR sCmdLine)
  44 {
  45         const std::wstring sEmpty;                      //use this as a value if no actual value is given in commandline
  46
  47         if(!sCmdLine)
  48                 return false;
  49
  50         m_valueMap.clear();
  51         m_sCmdLine = sCmdLine;
  52
  53         tstring working = sCmdLine;
  54         auto sCurrent = working.data();
  55
  56         for(;;)
  57         {
  58                 //format is  -Key:"arg"
  59
  60                 if (!sCurrent[0])
  61                         break;          // no more data, leave loop
  62
  63                 LPCTSTR sArg = wcspbrk(sCurrent, m_sDelims);
  64                 if(!sArg)
  65                         break; // no (more) delimiters found
  66                 sArg = _wcsinc(sArg);
  67
  68                 if (!sArg[0])
  69                         break; // ends with delim
  70
  71                 LPCTSTR sVal = wcspbrk(sArg, m_sValueSep);
  72                 if (!sVal)
  73                 {
  74                         std::wstring Key(sArg);
  75                         std::transform(Key.begin(), Key.end(), Key.begin(), ::towlower);
  76                         m_valueMap.insert(CValsMap::value_type(Key, sEmpty));
  77                         break;
  78                 }
  79                 else
  80                 {
  81                         std::wstring Key(sArg, (int)(sVal - sArg));
  82                         std::transform(Key.begin(), Key.end(), Key.begin(), ::towlower);
  83
  84                         LPCTSTR sQuote(nullptr), sEndQuote(nullptr);
  85                         if (sVal[0])
  86                         {
  87                                 if (sVal[0] != L' ')
  88                                         sVal = _wcsinc(sVal);
  89                                 else
  90                                 {
  91                                         while (sVal[0] == L' ')
  92                                                 sVal = _wcsinc(sVal);
  93                                 }
  94
  95                                 LPCTSTR nextArg = wcspbrk(sVal, m_sDelims);
  96
  97                                 sQuote = wcspbrk(sVal, m_sQuotes);
  98
  99                                 if (nextArg == sVal)
 100                                 {
 101                                         // current key has no value, but a next key exist - so don't use next key as value of current one
 102                                         --sVal;
 103                                         sQuote = sVal;
 104                                         sEndQuote = sVal;
 105                                 }
 106                                 else if (nextArg && nextArg < sQuote)
 107                                 {
 108                                         // current key has a value w/o quotes, but next key one has value in quotes
 109                                         sQuote = sVal;
 110                                         sEndQuote = wcschr(sQuote, L' ');
 111                                 }
 112                                 else
 113                                 {
 114                                         if(sQuote == sVal)
 115                                         {
 116                                                 // string with quotes (defined in m_sQuotes, e.g. '")
 117                                                 sQuote = _wcsinc(sVal);
 118                                                 sEndQuote = wcspbrk(sQuote, m_sQuotes);
 119
 120                                                 // search for double quotes
 121                                                 while (sEndQuote)
 122                                                 {
 123                                                         auto nextQuote = _wcsinc(sEndQuote);
 124                                                         if (nextQuote[0] == L'"')
 125                                                         {
 126                                                                 working.erase(working.begin() + (sEndQuote - working.data()));
 127                                                                 sEndQuote = wcspbrk(nextQuote, m_sQuotes);
 128                                                                 continue;
 129                                                         }
 130                                                         break;
 131                                                 }
 132                                         }
 133                                         else
 134                                         {
 135                                                 sQuote = sVal;
 136                                                 sEndQuote = wcschr(sQuote, L' ');
 137                                         }
 138                                 }
 139                         }
 140
 141                         if (!sEndQuote)
 142                         {
 143                                 // no end quotes or terminating space, take the rest of the string to its end
 144                                 if (!Key.empty() && sQuote)
 145                                 {
 146                                         std::wstring csVal(sQuote);
 147                                         m_valueMap.insert(CValsMap::value_type(Key, csVal));
 148                                 }
 149                                 break;
 150                         }
 151                         else
 152                         {
 153                                 // end quote
 154                                 if(!Key.empty())
 155                                 {
 156                                         std::wstring csVal(sQuote, (int)(sEndQuote - sQuote));
 157                                         m_valueMap.insert(CValsMap::value_type(Key, csVal));
 158                                 }
 159                                 sCurrent = _wcsinc(sEndQuote);
 160                                 continue;
 161                         }
 162                 }
 163         }
 164
 165         return !m_valueMap.empty();             //TRUE if arguments were found
 166 }
 167
 168 CCmdLineParser::CValsMap::const_iterator CCmdLineParser::findKey(LPCTSTR sKey) const
 169 {
 170         std::wstring s(sKey);
 171         std::transform(s.begin(), s.end(), s.begin(), ::towlower);
 172         return m_valueMap.find(s);
 173 }
 174
 175 BOOL CCmdLineParser::HasKey(LPCTSTR sKey) const
 176 {
 177         CValsMap::const_iterator it = findKey(sKey);
 178         if (it == m_valueMap.cend())
 179                 return false;
 180         return true;
 181 }
 182
 183
 184 BOOL CCmdLineParser::HasVal(LPCTSTR sKey) const
 185 {
 186         CValsMap::const_iterator it = findKey(sKey);
 187         if (it == m_valueMap.cend())
 188                 return false;
 189         if(it->second.empty())
 190                 return false;
 191         return true;
 192 }
 193
 194 LPCTSTR CCmdLineParser::GetVal(LPCTSTR sKey) const
 195 {
 196         CValsMap::const_iterator it = findKey(sKey);
 197         if (it == m_valueMap.cend())
 198                 return 0;
 199         return it->second.c_str();
 200 }
 201
 202 LONG CCmdLineParser::GetLongVal(LPCTSTR sKey) const
 203 {
 204         CValsMap::const_iterator it = findKey(sKey);
 205         if (it == m_valueMap.cend())
 206                 return 0;
 207         return _wtol(it->second.c_str());
 208 }
 209
 210 __int64 CCmdLineParser::GetLongLongVal(LPCTSTR sKey) const
 211 {
 212         CValsMap::const_iterator it = findKey(sKey);
 213         if (it == m_valueMap.cend())
 214                 return 0;
 215         return _wtoi64(it->second.c_str());
 216 }
 217
 218 CCmdLineParser::ITERPOS CCmdLineParser::begin() const
 219 {
 220         return m_valueMap.cbegin();
 221 }
 222
 223 CCmdLineParser::ITERPOS CCmdLineParser::getNext(ITERPOS& pos, std::wstring& sKey, std::wstring& sValue) const
 224 {
 225         if (m_valueMap.cend() == pos)
 226         {
 227                 sKey.clear();
 228                 return pos;
 229         }
 230         else
 231         {
 232                 sKey = pos->first;
 233                 sValue = pos->second;
 234                 return ++pos;
 235         }
 236 }
 237
 238 BOOL CCmdLineParser::isLast(const ITERPOS& pos) const
 239 {
 240         return (pos == m_valueMap.cend());
 241 }