tools/rbuild/backend/mingw/mstools_detection.cpp

   1 /*
   2  * Copyright (C) 2009 KJK::Hyperion
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along
  15  * with this program; if not, write to the Free Software Foundation, Inc.,
  16  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  17  */
  18
  19 #if defined(WIN32)
  20
  21 #define UNICODE
  22 #define _UNICODE
  23
  24 #define NOMINMAX
  25
  26 #include "../../pch.h"
  27
  28 #include "mingw.h"
  29
  30 #ifndef ARRAYSIZE
  31 #define ARRAYSIZE(X_) (sizeof(X_) / sizeof((X_)[0]))
  32 #endif
  33
  34 #include <ole2.h>
  35
  36 #include <assert.h>
  37 #include <stdlib.h>
  38 #include <tchar.h>
  39
  40 #include <string>
  41 #include <istream>
  42 #include <streambuf>
  43 #include <ios>
  44 #include <iostream>
  45 #include <iterator>
  46 #include <functional>
  47 #include <locale>
  48 #include <vector>
  49 #include <algorithm>
  50 #include <limits>
  51 #include <sstream>
  52
  53 #if defined(_CPPLIB_VER)
  54 #include <fstream>
  55 typedef std::filebuf stdio_filebuf;
  56 #elif defined(__GLIBCXX__)
  57 #include <ext/stdio_sync_filebuf.h>
  58 typedef __gnu_cxx::stdio_sync_filebuf<char> stdio_filebuf;
  59 #else
  60 #error Unknown or unsupported C++ standard library
  61 #endif
  62
  63
  64
  65 namespace
  66 {
  67
  68 #if 1
  69 HRESULT dispPropGet(IDispatch * object, DISPID dispid, VARIANTARG * args, UINT ccArgs, VARTYPE vt, VARIANT& result)
  70 {
  71         HRESULT hr;
  72
  73         DISPPARAMS params = {};
  74         params.rgvarg = args;
  75         params.cArgs = ccArgs;
  76
  77         hr = object->Invoke(dispid, IID_NULL, 0, DISPATCH_PROPERTYGET | (ccArgs ? DISPATCH_METHOD : 0), &params, &result, NULL, NULL);
  78
  79         if(SUCCEEDED(hr))
  80                 hr = VariantChangeType(&result, &result, 0, vt);
  81
  82         return hr;
  83 }
  84
  85 HRESULT dispPropGet(IDispatch * object, const OLECHAR * name, VARIANTARG * args, UINT ccArgs, VARTYPE vt, VARIANT& result)
  86 {
  87         HRESULT hr;
  88
  89         DISPID dispid;
  90         hr = object->GetIDsOfNames(IID_NULL, const_cast<OLECHAR **>(&name), 1, 0, &dispid);
  91
  92         if(SUCCEEDED(hr))
  93                 hr = dispPropGet(object, dispid, args, ccArgs, vt, result);
  94
  95         return hr;
  96 }
  97
  98 VARIANT dispPropGet(HRESULT& hr, IDispatch * object, DISPID dispid, VARTYPE vt)
  99 {
 100         VARIANT ret;
 101         VariantInit(&ret);
 102
 103         if(SUCCEEDED(hr))
 104                 hr = dispPropGet(object, dispid, 0, 0, vt, ret);
 105
 106         return ret;
 107 }
 108
 109 VARIANT dispPropGet(HRESULT& hr, IDispatch * object, const OLECHAR * name, VARTYPE vt)
 110 {
 111         VARIANT ret;
 112         VariantInit(&ret);
 113
 114         if(SUCCEEDED(hr))
 115                 hr = dispPropGet(object, name, 0, 0, vt, ret);
 116
 117         return ret;
 118 }
 119
 120 HRESULT dispInvoke(IDispatch * object, DISPID dispid, VARIANTARG * args, UINT ccArgs, VARTYPE vt, VARIANT& result)
 121 {
 122         HRESULT hr;
 123
 124         DISPPARAMS params = {};
 125         params.rgvarg = args;
 126         params.cArgs = ccArgs;
 127
 128         hr = object->Invoke(dispid, IID_NULL, 0, DISPATCH_METHOD, &params, &result, NULL, NULL);
 129
 130         if(SUCCEEDED(hr))
 131                 hr = VariantChangeType(&result, &result, 0, vt);
 132
 133         return hr;
 134 }
 135
 136 HRESULT dispInvoke(IDispatch * object, DISPID dispid, const VARIANTARG& arg, VARTYPE vt, VARIANT& result)
 137 {
 138         return dispInvoke(object, dispid, const_cast<VARIANTARG *>(&arg), 1, vt, result);
 139 }
 140
 141 HRESULT dispInvoke(IDispatch * object, DISPID dispid, VARTYPE vt, VARIANT& result)
 142 {
 143         return dispInvoke(object, dispid, NULL, 0, vt, result);
 144 }
 145
 146 HRESULT dispInvoke(IDispatch * object, VARIANTARG * args, UINT ccArgs, VARTYPE vt, VARIANT& result)
 147 {
 148         return dispInvoke(object, DISPID_VALUE, args, ccArgs, vt, result);
 149 }
 150
 151 HRESULT dispInvoke(IDispatch * object, VARTYPE vt, VARIANT& result)
 152 {
 153         return dispInvoke(object, DISPID_VALUE, NULL, 0, vt, result);
 154 }
 155
 156 HRESULT dispInvoke(IDispatch * object, const VARIANTARG& arg, VARTYPE vt, VARIANT& result)
 157 {
 158         return dispInvoke(object, DISPID_VALUE, const_cast<VARIANTARG *>(&arg), 1, vt, result);
 159 }
 160
 161 HRESULT dispInvoke(IDispatch * object, const OLECHAR * name, VARIANTARG * args, UINT ccArgs, VARTYPE vt, VARIANT& result)
 162 {
 163         HRESULT hr;
 164
 165         DISPID dispid;
 166         hr = object->GetIDsOfNames(IID_NULL, const_cast<OLECHAR **>(&name), 1, 0, &dispid);
 167
 168         if(SUCCEEDED(hr))
 169                 hr = dispInvoke(object, dispid, args, ccArgs, vt, result);
 170
 171         return hr;
 172 }
 173
 174 HRESULT dispInvoke(IDispatch * object, const OLECHAR * name, const VARIANTARG& arg, VARTYPE vt, VARIANT& result)
 175 {
 176         return dispInvoke(object, name, const_cast<VARIANTARG *>(&arg), 1, vt, result);
 177 }
 178
 179 HRESULT dispInvoke(IDispatch * object, const OLECHAR * name, VARTYPE vt, VARIANT& result)
 180 {
 181         return dispInvoke(object, name, NULL, 0, vt, result);
 182 }
 183
 184 VARIANT dispInvoke(HRESULT& hr, IDispatch * object, DISPID dispid, VARIANTARG * args, UINT ccArgs, VARTYPE vt)
 185 {
 186         VARIANT ret;
 187         VariantInit(&ret);
 188
 189         if(SUCCEEDED(hr))
 190                 hr = dispInvoke(object, dispid, args, ccArgs, vt, ret);
 191
 192         return ret;
 193 }
 194
 195 VARIANT dispInvoke(HRESULT& hr, IDispatch * object, const OLECHAR * name, VARIANTARG * args, UINT ccArgs, VARTYPE vt)
 196 {
 197         VARIANT ret;
 198         VariantInit(&ret);
 199
 200         if(SUCCEEDED(hr))
 201                 hr = dispInvoke(object, name, args, ccArgs, vt, ret);
 202
 203         return ret;
 204 }
 205
 206 VARIANT dispInvoke(HRESULT& hr, IDispatch * object, DISPID dispid, const VARIANTARG& arg, VARTYPE vt)
 207 {
 208         return dispInvoke(hr, object, dispid, const_cast<VARIANTARG *>(&arg), 1, vt);
 209 }
 210
 211 VARIANT dispInvoke(HRESULT& hr, IDispatch * object, DISPID dispid, VARTYPE vt)
 212 {
 213         return dispInvoke(hr, object, dispid, NULL, 0, vt);
 214 }
 215
 216 VARIANT dispInvoke(HRESULT& hr, IDispatch * object, VARIANTARG * args, UINT ccArgs, VARTYPE vt)
 217 {
 218         return dispInvoke(hr, object, DISPID(DISPID_VALUE), args, ccArgs, vt);
 219 }
 220
 221 VARIANT dispInvoke(HRESULT& hr, IDispatch * object, VARTYPE vt)
 222 {
 223         return dispInvoke(hr, object, DISPID(DISPID_VALUE), NULL, 0, vt);
 224 }
 225
 226 VARIANT dispInvoke(HRESULT& hr, IDispatch * object, const VARIANTARG& arg, VARTYPE vt)
 227 {
 228         return dispInvoke(hr, object, DISPID(DISPID_VALUE), const_cast<VARIANTARG *>(&arg), 1, vt);
 229 }
 230
 231 VARIANT dispInvoke(HRESULT& hr, IDispatch * object, const OLECHAR * name, const VARIANTARG& arg, VARTYPE vt)
 232 {
 233         return dispInvoke(hr, object, name, const_cast<VARIANTARG *>(&arg), 1, vt);
 234 }
 235
 236 VARIANT dispInvoke(HRESULT& hr, IDispatch * object, const OLECHAR * name, VARTYPE vt)
 237 {
 238         return dispInvoke(hr, object, name, NULL, 0, vt);
 239 }
 240
 241 VARIANT oleString(HRESULT& hr, const OLECHAR * sz)
 242 {
 243         VARIANT v;
 244         VariantInit(&v);
 245
 246         if(SUCCEEDED(hr))
 247         {
 248                 V_VT(&v) = VT_BSTR;
 249                 V_BSTR(&v) = SysAllocString(sz);
 250
 251                 if(!V_BSTR(&v))
 252                         hr = E_OUTOFMEMORY;
 253         }
 254
 255         if(FAILED(hr))
 256         {
 257                 V_VT(&v) = VT_ERROR;
 258                 V_ERROR(&v) = hr;
 259         }
 260
 261         return v;
 262 }
 263
 264 #endif
 265
 266 #if 1
 267 namespace knuth_morris_pratt
 268 {
 269
 270 namespace details
 271 {
 272
 273 template<class Iter>
 274 typename std::iterator_traits<Iter>::iterator_category iterator_category(const Iter&)
 275 {
 276         return typename std::iterator_traits<Iter>::iterator_category();
 277 }
 278
 279 template<typename TypeX, typename TypeY>
 280 struct type_equals
 281 {
 282         enum { value = 0 };
 283 };
 284
 285 template<typename TypeX>
 286 struct type_equals<TypeX, TypeX>
 287 {
 288         enum { value = 1 };
 289 };
 290
 291 template<class Iter, class diff_type>
 292 void advance_substr(Iter& pos, Iter, diff_type, diff_type rel, const std::bidirectional_iterator_tag&)
 293 {
 294         std::advance(pos, rel);
 295 }
 296
 297 template<class Iter, class diff_type>
 298 void advance_substr(Iter& pos, Iter begin, diff_type absol, diff_type rel, const std::forward_iterator_tag&)
 299 {
 300         if(rel > 0)
 301                 std::advance(pos, rel);
 302         else
 303         {
 304                 pos = begin;
 305                 std::advance(pos, absol);
 306         }
 307 }
 308
 309 template<class Iter, class diff_type>
 310 void advance_substr(Iter& pos, Iter begin, diff_type absol, diff_type rel)
 311 {
 312         advance_substr(pos, begin, absol, rel, iterator_category(pos));
 313 }
 314
 315 template<class T, size_t N>
 316 struct fixed_table
 317 {
 318 public:
 319         typedef typename std::iterator_traits<T *>::difference_type value_type;
 320         typedef value_type * pointer;
 321         typedef value_type& reference;
 322         typedef const value_type * const_pointer;
 323         typedef const value_type& const_reference;
 324         typedef typename std::allocator<value_type>::difference_type difference_type;
 325         typedef typename std::allocator<value_type>::size_type size_type;
 326
 327 private:
 328         value_type m_table[(N)];
 329
 330 public:
 331         static pointer address(reference r) { return &r; }
 332         static const_pointer address(const_reference r) { return &r; }
 333         static size_type max_size() { return (N); }
 334         static void construct(pointer p, const T& v) { p->T(v); }
 335         static void destroy(pointer p) { p->~T(); }
 336         template<class Other> struct rebind { typedef fixed_table<Other, N> other; };
 337
 338         template<class Other> pointer allocate(size_type n, const Other * hint)
 339         {
 340                 assert(n <= (N));
 341                 assert(hint == 0);
 342                 return m_table;
 343         }
 344
 345         pointer allocate(size_type n)
 346         {
 347                 assert(n <= (N));
 348                 return m_table;
 349         }
 350
 351         void deallocate(pointer p, size_type n) const
 352         {
 353                 assert(p == m_table);
 354                 assert(n <= (N));
 355         }
 356 };
 357
 358 void validate_range_iterator_category(const std::input_iterator_tag&) { }
 359 void validate_substr_iterator_category(const std::forward_iterator_tag&) { }
 360
 361 template<class RangeIter, class SubstrIter>
 362 RangeIter search_cornercase_neg(RangeIter, RangeIter end, SubstrIter)
 363 {
 364         return end;
 365 }
 366
 367 template<class RangeIter, class SubstrIter>
 368 RangeIter search_cornercase0(RangeIter begin, RangeIter, SubstrIter)
 369 {
 370         return begin;
 371 }
 372
 373 template<class RangeIter, class SubstrIter>
 374 RangeIter search_cornercase1(RangeIter begin, RangeIter end, SubstrIter substrBegin)
 375 {
 376         RangeIter pos = std::find(begin, end, *substrBegin);
 377
 378         if(type_equals<typename std::iterator_traits<RangeIter>::iterator_category, std::input_iterator_tag>::value && pos != end)
 379                 ++ pos;
 380
 381         return pos;
 382 }
 383
 384 template<class SubstrIter, class TableType, class TableSize>
 385 void search_createtable_dynamic
 386 (
 387         SubstrIter beginSubstr,
 388         typename std::iterator_traits<SubstrIter>::difference_type substrSize,
 389         TableType table,
 390         TableSize
 391 )
 392 {
 393         typedef typename std::iterator_traits<SubstrIter>::difference_type substr_diff_type;
 394         typedef typename TableType::pointer table_type;
 395         typedef TableSize table_size_type;
 396
 397         substr_diff_type i(2);
 398         SubstrIter pi = beginSubstr;
 399         std::advance(pi, substr_diff_type(1));
 400
 401         substr_diff_type j(0);
 402         SubstrIter pj = beginSubstr;
 403         std::advance(pj, substr_diff_type(0));
 404
 405         while(i < substrSize)
 406         {
 407                 if(*pi == *pj)
 408                 {
 409                         substr_diff_type new_j = j;
 410                         ++ new_j;
 411
 412                         table[static_cast<table_size_type>(i)] = new_j;
 413
 414                         ++ i; ++ pi;
 415                         ++ j; ++ pj;
 416                 }
 417                 else if(j > 0)
 418                 {
 419                         substr_diff_type new_j = table[i];
 420                         details::advance_substr(pj, beginSubstr, new_j, new_j - j);
 421                         j = new_j;
 422                 }
 423                 else
 424                 {
 425                         table[i] = 0;
 426                         ++ i; ++ pi;
 427                 }
 428         }
 429 }
 430
 431 template<class D, class S, size_t N>
 432 void search_createtable_static
 433 (
 434         const S (& substr)[N],
 435         D (& table)[N]
 436 )
 437 {
 438         typedef std::ptrdiff_t substr_diff_type;
 439
 440         table[0] = substr_diff_type(-1);
 441         table[1] = substr_diff_type(0);
 442
 443         substr_diff_type pos = 2;
 444         substr_diff_type cnd = 0;
 445
 446         while(pos < static_cast<substr_diff_type>(N))
 447         {
 448                 if(substr[pos - 1] == substr[cnd])
 449                 {
 450                         table[pos] = cnd + 1;
 451                         ++ pos;
 452                         ++ cnd;
 453                 }
 454                 else if(cnd > 0)
 455                         cnd = table[cnd];
 456                 else
 457                 {
 458                         table[pos] = 0;
 459                         ++ pos;
 460                 }
 461         }
 462 }
 463
 464 template<class RangeIter, class SubstrIter, class Table, class TableSize>
 465 RangeIter search
 466 (
 467         const RangeIter& begin,
 468         const RangeIter& end,
 469         const SubstrIter beginSubstr,
 470         typename std::iterator_traits<SubstrIter>::difference_type substrSize,
 471         Table table,
 472         TableSize
 473 )
 474 {
 475         details::validate_range_iterator_category(details::iterator_category(begin));
 476         details::validate_substr_iterator_category(details::iterator_category(beginSubstr));
 477
 478         typedef typename std::iterator_traits<SubstrIter>::difference_type substr_diff_type;
 479         typedef Table table_type;
 480         typedef TableSize table_size_type;
 481
 482         // Find the next match
 483         substr_diff_type iSubstr(0); // i
 484         RangeIter pCurMatch = begin; // m
 485         RangeIter pCurElem = begin; // m + i
 486         SubstrIter pCurSubstrElem = beginSubstr; // i
 487
 488         while(pCurElem != end)
 489         {
 490                 if(*pCurSubstrElem == *pCurElem)
 491                 {
 492                         ++ iSubstr; // ++ i
 493
 494                         if(iSubstr == substrSize)
 495                         {
 496                                 // For input iterators, we return the end of the match
 497                                 if(type_equals<typename std::iterator_traits<RangeIter>::iterator_category, std::input_iterator_tag>::value)
 498                                         ++ pCurElem; // return m + i + 1
 499                                 // For all other iterators, we return the beginning of the match
 500                                 else
 501                                         pCurElem = pCurMatch; // return m
 502
 503                                 break;
 504                         }
 505
 506                         ++ pCurElem; // ++ i
 507                         ++ pCurSubstrElem; // ++ i
 508                 }
 509                 else
 510                 {
 511                         substr_diff_type table_iSubstr = table[static_cast<table_size_type>(iSubstr)]; // T[i]
 512                         substr_diff_type iSubstr_backtracked = iSubstr - table_iSubstr; // i - T[i]
 513                         assert(iSubstr_backtracked >= substr_diff_type(0));
 514
 515                         if(!type_equals<typename std::iterator_traits<RangeIter>::iterator_category, std::input_iterator_tag>::value)
 516                                 std::advance(pCurMatch, iSubstr_backtracked); // m = m + i - T[i]
 517
 518                         if(iSubstr > substr_diff_type(0)) // i > 0
 519                         {
 520                                 iSubstr = table_iSubstr; // i = T[i]
 521                                 pCurSubstrElem = beginSubstr;
 522                                 std::advance(pCurSubstrElem, iSubstr); // i = T[i]
 523                         }
 524                         else
 525                                 std::advance(pCurElem, iSubstr_backtracked);
 526                 }
 527         }
 528
 529         return pCurElem;
 530 }
 531
 532 };
 533
 534 template<class RangeIter, class SubstrIter, class AllocTable>
 535 RangeIter search(RangeIter begin, RangeIter end, SubstrIter beginSubstr, SubstrIter endSubstr, AllocTable& allocTable)
 536 {
 537         typename std::iterator_traits<SubstrIter>::difference_type substrSize = std::distance(beginSubstr, endSubstr);
 538
 539         if(substrSize < 0)
 540                 return knuth_morris_pratt::details::search_cornercase_neg(begin, end, beginSubstr);
 541
 542         if(substrSize == 0)
 543                 return knuth_morris_pratt::details::search_cornercase0(begin, end, beginSubstr);
 544
 545         if(substrSize == 1)
 546                 return knuth_morris_pratt::details::search_cornercase1(begin, end, beginSubstr);
 547
 548         typedef typename AllocTable::size_type table_size;
 549         typedef typename AllocTable::pointer table_type;
 550
 551         table_size tableSize = static_cast<table_size>(substrSize);
 552         table_type table = allocTable.allocate(tableSize);
 553
 554         RangeIter pos = knuth_morris_pratt::details::search(begin, end, beginSubstr, substrSize, table, tableSize);
 555
 556         allocTable.deallocate(table, tableSize);
 557
 558         return pos;
 559 }
 560
 561 template<class RangeIter, class SubstrIter>
 562 RangeIter search(RangeIter begin, RangeIter end, SubstrIter beginSubstr, SubstrIter endSubstr)
 563 {
 564         std::allocator<typename std::iterator_traits<SubstrIter>::difference_type> allocTable;
 565         return knuth_morris_pratt::search(begin, end, beginSubstr, endSubstr, allocTable);
 566 }
 567
 568 template<class RangeIter, class SubstrElem, size_t N>
 569 RangeIter search(RangeIter begin, RangeIter end, const SubstrElem (& substr)[(N)])
 570 {
 571         if((N) == 0)
 572                 return knuth_morris_pratt::details::search_cornercase0(begin, end, substr);
 573
 574         if((N) == 1)
 575                 return knuth_morris_pratt::details::search_cornercase1(begin, end, substr);
 576
 577         if((N) * sizeof(SubstrElem) <= 4096)
 578         {
 579                 ptrdiff_t table[N];
 580                 knuth_morris_pratt::details::search_createtable_static(substr, table);
 581                 return knuth_morris_pratt::details::search(begin, end, substr, (N), table, sizeof(table));
 582         }
 583         else
 584                 return knuth_morris_pratt::search(begin, end, substr, substr + (N));
 585 }
 586
 587 }
 588 #endif
 589
 590 #if 1
 591 template<class CharT, class Traits, class Alloc, size_t N, class ReplIter>
 592 std::basic_string<CharT, Traits, Alloc> replace(const std::basic_string<CharT, Traits, Alloc>& str, const CharT (& substr)[(N)], ReplIter replBegin, ReplIter replEnd)
 593 {
 594         if((N) == 0)
 595                 return str;
 596
 597         std::basic_string<CharT, Traits, Alloc> newStr;
 598         typename std::basic_string<CharT, Traits, Alloc>::const_iterator cur = str.begin();
 599         typename std::basic_string<CharT, Traits, Alloc>::const_iterator end = str.end();
 600
 601         while(cur != end)
 602         {
 603                 typename std::basic_string<CharT, Traits, Alloc>::const_iterator found = knuth_morris_pratt::search(cur, end, *reinterpret_cast<const CharT (*)[(N) - 1]>(&substr));
 604
 605                 newStr.append(cur, found);
 606                 cur = found;
 607
 608                 if(found != end)
 609                 {
 610                         newStr.append(replBegin, replEnd);
 611                         advance(cur, (N) - 1);
 612                 }
 613         }
 614
 615         return newStr;
 616 }
 617
 618 template<class CharT, class Traits, class Alloc, size_t N, size_t M>
 619 std::basic_string<CharT, Traits, Alloc> replace(const std::basic_string<CharT, Traits, Alloc>& str, const CharT (& substr)[(N)], const CharT (& repl)[(M)])
 620 {
 621         return replace(str, substr, repl, repl + ((M) - 1));
 622 }
 623
 624 template<class CharT, class Traits, class Alloc, size_t N, class Traits2, class Alloc2>
 625 std::basic_string<CharT, Traits, Alloc> replace(const std::basic_string<CharT, Traits, Alloc>& str, const CharT (& substr)[(N)], const std::basic_string<CharT, Traits2, Alloc2>& repl)
 626 {
 627         return replace(str, substr, repl.begin(), repl.end());
 628 }
 629
 630 template<class CharT, class Traits, class Alloc, size_t M, class Traits2, class Alloc2>
 631 std::basic_string<CharT, Traits, Alloc> replace(const std::basic_string<CharT, Traits, Alloc>& str, const std::basic_string<CharT, Traits2, Alloc2>& substr, const CharT (& repl)[(M)])
 632 {
 633         return replace(str, substr.begin(), substr.end(), repl, repl + ((M) - 1));
 634 }
 635
 636 template<class CharT, class Traits, class Alloc, class Traits2, class Alloc2, class Traits3, class Alloc3>
 637 std::basic_string<CharT, Traits, Alloc> replace(const std::basic_string<CharT, Traits, Alloc>& str, const std::basic_string<CharT, Traits2, Alloc2>& substr, const std::basic_string<CharT, Traits3, Alloc3>& repl)
 638 {
 639         return replace(str, substr.begin(), substr.end(), repl.begin(), repl.end());
 640 }
 641
 642 template<typename TypeX, typename TypeY>
 643 struct type_equals
 644 {
 645         enum { value = 0 };
 646 };
 647
 648 template<typename TypeX>
 649 struct type_equals<TypeX, TypeX>
 650 {
 651         enum { value = 1 };
 652 };
 653
 654 template<class InIter, class Dist>
 655 bool advance_between_impl(InIter& cur, const InIter& begin, const InIter& end, Dist off, const std::input_iterator_tag&)
 656 {
 657         if(Dist(0) < off)
 658                 for(; off != Dist(0) && cur != end; -- off)
 659                         ++ cur;
 660
 661         return off == Dist(0);
 662 }
 663
 664 template<class InIter, class Dist>
 665 bool advance_between_impl(InIter& cur, const InIter& begin, const InIter& end, Dist off, const std::bidirectional_iterator_tag&)
 666 {
 667         if(Dist(0) < off)
 668                 for(; off != Dist(0) && cur != end; -- off)
 669                         ++ cur;
 670         else
 671                 for(; off != Dist(0) && cur != begin; ++ off)
 672                         ++ cur;
 673
 674         return off == Dist(0);
 675 }
 676
 677 template<class InIter, class Dist>
 678 bool advance_between_impl(InIter& cur, const InIter& begin, const InIter& end, Dist off, const std::random_access_iterator_tag&)
 679 {
 680         bool ret;
 681
 682         if(Dist(0) < off)
 683         {
 684                 Dist max = distance(cur, end);
 685                 ret = off == max || off < max;
 686         }
 687         else
 688         {
 689                 Dist max = distance(cur, end);
 690                 ret = abs(off) == max || abs(off) < max;
 691         }
 692
 693         if(ret)
 694                 advance(cur, off);
 695
 696         return ret;
 697 }
 698
 699 template<class InIter, class Dist>
 700 bool advance_between(InIter& cur, const InIter& begin, const InIter& end, Dist off)
 701 {
 702         return advance_between_impl(cur, begin, end, off, typename std::iterator_traits<InIter>::iterator_category());
 703 }
 704
 705 template<class InIter, class Elem, class Traits, class InIterTag>
 706 class range_streambuf_base: public std::basic_streambuf<Elem, Traits>
 707 {
 708 public:
 709         typedef typename std::basic_streambuf<Elem, Traits>::int_type int_type;
 710         typedef typename std::basic_streambuf<Elem, Traits>::pos_type pos_type;
 711         typedef typename std::basic_streambuf<Elem, Traits>::off_type off_type;
 712
 713 protected:
 714         InIter m_cur;
 715         InIter m_end;
 716         int_type m_ungetc;
 717         int_type m_putbackc;
 718
 719         int_type get_char()
 720         {
 721                 int_type c = m_ungetc;
 722
 723                 if(c == Traits::eof())
 724                 {
 725                         if(m_cur != m_end)
 726                         {
 727                                 c = *m_cur;
 728                                 ++ m_cur;
 729                         }
 730                 }
 731                 else
 732                         m_ungetc = Traits::eof();
 733
 734                 return c;
 735         }
 736
 737         int_type unget_char(int_type c)
 738         {
 739                 if(c == Traits::eof())
 740                         return c;
 741
 742                 if(m_ungetc == Traits::eof())
 743                         m_ungetc = c;
 744                 else
 745                         return Traits::eof();
 746
 747                 return c;
 748         }
 749
 750 protected:
 751         range_streambuf_base(const InIter& begin, const InIter& end):
 752                 m_cur(begin),
 753                 m_end(end),
 754                 m_ungetc(Traits::eof()),
 755                 m_putbackc(Traits::eof())
 756         {
 757         }
 758
 759 public:
 760         virtual int_type pbackfail(int_type c)
 761         {
 762                 int_type ret;
 763
 764                 if(Traits::eq_int_type(c, Traits::eof()))
 765                 {
 766                         if(!Traits::eq_int_type(m_putbackc, Traits::eof()))
 767                                 ret = unget_char(m_putbackc);
 768                         else
 769                                 ret = Traits::eof();
 770                 }
 771                 else
 772                         ret = unget_char(c);
 773
 774                 m_putbackc = Traits::eof();
 775                 return ret;
 776         }
 777
 778         virtual std::streamsize showmanyc() const
 779         {
 780                 return std::streamsize(-1);
 781         }
 782
 783         virtual int_type underflow()
 784         {
 785                 return unget_char(get_char());
 786         }
 787
 788         virtual int_type uflow()
 789         {
 790                 m_putbackc = get_char();
 791                 return m_putbackc;
 792         }
 793
 794         virtual std::streamsize xsgetn(Elem * p, std::streamsize n)
 795         {
 796                 return _Xsgetn_s(p, std::numeric_limits<size_t>::max(), n);
 797         }
 798
 799         virtual std::streamsize _Xsgetn_s(Elem * p, size_t cb, std::streamsize n)
 800         {
 801                 std::streamsize i;
 802                 size_t ib;
 803
 804                 for(i = 0, ib = 0; i < n && ib < cb; ++ i, ++ ib, ++ p)
 805                 {
 806                         int_type c = get_char();
 807
 808                         if(c == Traits::eof())
 809                                 break;
 810
 811                         *p = Traits::to_char_type(c);
 812                 }
 813
 814                 if(i > 0)
 815                         m_putbackc = p[-1];
 816                 else
 817                         m_putbackc = Traits::eof();
 818
 819                 return i;
 820         }
 821
 822         virtual pos_type seekoff(off_type off, std::ios_base::seekdir dir, std::ios_base::openmode mode)
 823         {
 824                 if(((off == 0 && dir == std::ios_base::end) || (off >= 0 && dir == std::ios_base::cur)) && !(mode & std::ios_base::out))
 825                 {
 826                         m_ungetc = Traits::eof();
 827
 828                         if(dir == std::ios_base::end)
 829                                 m_cur = m_end;
 830
 831                         advance_between(m_cur, m_cur, m_end, off);
 832                 }
 833
 834                 return pos_type(-1);
 835         }
 836 };
 837
 838 template<class InIter, class Elem, class Traits>
 839 class range_streambuf_base<InIter, Elem, Traits, std::forward_iterator_tag>:
 840         public range_streambuf_base<InIter, Elem, Traits, std::input_iterator_tag>
 841 {
 842 public:
 843         typedef typename range_streambuf_base<InIter, Elem, Traits, std::input_iterator_tag>::int_type int_type;
 844         typedef typename range_streambuf_base<InIter, Elem, Traits, std::input_iterator_tag>::pos_type pos_type;
 845         typedef typename range_streambuf_base<InIter, Elem, Traits, std::input_iterator_tag>::off_type off_type;
 846
 847 private:
 848         typedef range_streambuf_base<InIter, Elem, Traits, std::input_iterator_tag> super;
 849         InIter m_begin;
 850
 851 protected:
 852         range_streambuf_base(const InIter& begin, const InIter& end):
 853                 m_begin(begin),
 854                 range_streambuf_base<InIter, Elem, Traits, std::input_iterator_tag>(begin, end)
 855         {
 856         }
 857
 858 public:
 859         virtual pos_type seekoff(off_type off, std::ios_base::seekdir dir, std::ios_base::openmode mode)
 860         {
 861                 if(!(mode & std::ios_base::out) && off >= 0)
 862                 {
 863                         if(dir == std::ios_base::beg)
 864                                 super::m_cur = m_begin;
 865                         else if(dir != std::ios_base::cur)
 866                                 super::m_cur = super::m_end;
 867
 868                         advance_between(super::m_cur, m_begin, super::m_end, off);
 869                 }
 870
 871                 return pos_type(-1);
 872         }
 873 };
 874
 875 template<class InIter, class Elem, class Traits>
 876 class range_streambuf_base<InIter, Elem, Traits, std::bidirectional_iterator_tag>: public std::basic_streambuf<Elem, Traits>
 877 {
 878 public:
 879         typedef typename std::basic_streambuf<Elem, Traits>::int_type int_type;
 880         typedef typename std::basic_streambuf<Elem, Traits>::pos_type pos_type;
 881         typedef typename std::basic_streambuf<Elem, Traits>::off_type off_type;
 882
 883 protected:
 884         InIter m_begin;
 885         InIter m_cur;
 886         InIter m_end;
 887
 888 protected:
 889         range_streambuf_base(const InIter& begin, const InIter& end):
 890                 m_begin(begin),
 891                 m_cur(begin),
 892                 m_end(end)
 893         {
 894         }
 895
 896 public:
 897         virtual int_type pbackfail(int_type c)
 898         {
 899                 int_type ret = Traits::eof();
 900
 901                 if(m_cur != m_begin)
 902                 {
 903                         InIter prev = m_cur;
 904                         -- prev;
 905
 906                         if(Traits::eq_int_type(c, Traits::eof()) || Traits::eq_int_type(c, Traits::to_int_type(*prev)))
 907                         {
 908                                 -- m_cur;
 909                                 ret = Traits::to_int_type(*m_cur);
 910                         }
 911                 }
 912
 913                 return ret;
 914         }
 915
 916         virtual std::streamsize showmanyc() const
 917         {
 918                 return std::streamsize(-1);
 919         }
 920
 921         virtual int_type underflow()
 922         {
 923                 if(m_cur != m_end)
 924                         return *m_cur;
 925                 else
 926                         return Traits::eof();
 927         }
 928
 929         virtual int_type uflow()
 930         {
 931                 int_type c = Traits::eof();
 932
 933                 if(m_cur != m_end)
 934                 {
 935                         c = *m_cur;
 936                         ++ m_cur;
 937                 }
 938
 939                 return c;
 940         }
 941
 942         virtual std::streamsize xsgetn(Elem * p, std::streamsize n)
 943         {
 944                 return _Xsgetn_s(p, std::numeric_limits<size_t>::max(), n);
 945         }
 946
 947         virtual std::streamsize _Xsgetn_s(Elem * p, size_t cb, std::streamsize n)
 948         {
 949                 std::streamsize i;
 950                 size_t ib;
 951
 952                 for(i = 0, ib = 0; i < n && ib < cb && m_cur != m_end; ++ i, ++ ib, ++ p, ++ m_cur)
 953                         *p = Traits::to_char_type(*m_cur);
 954
 955                 return i;
 956         }
 957
 958         virtual pos_type seekoff(off_type off, std::ios_base::seekdir dir, std::ios_base::openmode mode)
 959         {
 960                 if(mode & std::ios_base::out)
 961                         return pos_type(-1);
 962
 963                 if(dir == std::ios_base::beg)
 964                         m_cur = m_begin;
 965                 else if(dir != std::ios_base::cur)
 966                         m_cur = m_end;
 967
 968                 if(!advance_between(m_cur, m_begin, m_end, off))
 969                         return pos_type(-1);
 970
 971                 return m_cur - m_begin;
 972         }
 973 };
 974
 975 template<class InIter, class Elem, class Traits>
 976 class range_streambuf_base<InIter, Elem, Traits, std::random_access_iterator_tag>:
 977         public range_streambuf_base<InIter, Elem, Traits, std::bidirectional_iterator_tag>
 978 {
 979 private:
 980         typedef range_streambuf_base<InIter, Elem, Traits, std::bidirectional_iterator_tag> super;
 981
 982 protected:
 983         range_streambuf_base(const InIter& begin, const InIter& end):
 984                 range_streambuf_base<InIter, Elem, Traits, std::bidirectional_iterator_tag>(begin, end)
 985         {
 986         }
 987
 988 public:
 989         virtual std::streamsize showmanyc() const
 990         {
 991                 return distance(super::m_cur, super::m_end);
 992         }
 993
 994         virtual std::streamsize _Xsgetn_s(Elem * p, size_t cb, std::streamsize n)
 995         {
 996                 std::streamsize maxn = showmanyc();
 997
 998                 if(n > maxn)
 999                         n = maxn;
1000
1001                 if(cb > static_cast<size_t>(n))
1002                         cb = static_cast<size_t>(n);
1003
1004                 std::copy(super::m_cur, super::m_cur + cb, p);
1005                 return cb;
1006         }
1007 };
1008
1009 template<class InIter, class Elem = typename std::iterator_traits<InIter>::value_type, class Traits = typename std::char_traits<Elem> >
1010 class range_streambuf:
1011         public range_streambuf_base<InIter, Elem, Traits, typename std::iterator_traits<InIter>::iterator_category>
1012 {
1013 public:
1014         range_streambuf(const InIter& begin, const InIter& end):
1015                 range_streambuf_base<InIter, Elem, Traits, typename std::iterator_traits<InIter>::iterator_category>(begin, end) { }
1016 };
1017
1018 #endif
1019
1020 struct version_tuple
1021 {
1022 private:
1023         unsigned short m_fields[4];
1024
1025 public:
1026         version_tuple(): m_fields() {}
1027
1028         version_tuple(unsigned short major, unsigned short minor, unsigned short build_major = 0, unsigned short build_minor = 0)
1029         {
1030                 m_fields[0] = major;
1031                 m_fields[1] = minor;
1032                 m_fields[2] = build_major;
1033                 m_fields[3] = build_minor;
1034         }
1035
1036         version_tuple(const version_tuple& That)
1037         {
1038                 m_fields[0] = That.m_fields[0];
1039                 m_fields[1] = That.m_fields[1];
1040                 m_fields[2] = That.m_fields[2];
1041                 m_fields[3] = That.m_fields[3];
1042         }
1043
1044         const version_tuple& operator=(const version_tuple& That)
1045         {
1046                 m_fields[0] = That.m_fields[0];
1047                 m_fields[1] = That.m_fields[1];
1048                 m_fields[2] = That.m_fields[2];
1049                 m_fields[3] = That.m_fields[3];
1050                 return *this;
1051         }
1052
1053         unsigned short get_major() const
1054         {
1055                 return m_fields[0];
1056         }
1057
1058         unsigned short get_minor() const
1059         {
1060                 return m_fields[1];
1061         }
1062
1063         unsigned short get_build_major() const
1064         {
1065                 return m_fields[2];
1066         }
1067
1068         unsigned short get_build_minor() const
1069         {
1070                 return m_fields[3];
1071         }
1072
1073         bool operator==(const version_tuple& That) const
1074         {
1075                 return memcmp(this->m_fields, That.m_fields, sizeof(this->m_fields)) == 0;
1076         }
1077
1078         bool operator<(const version_tuple& That) const
1079         {
1080                 return std::lexicographical_compare
1081                 (
1082                         &(this->m_fields[0]) + 0,
1083                         &(this->m_fields[0]) + ARRAYSIZE(this->m_fields),
1084                         &(That.m_fields[0]) + 0,
1085                         &(That.m_fields[0]) + ARRAYSIZE(That.m_fields)
1086                 );
1087         }
1088
1089         bool operator<=(const version_tuple& That) const
1090         {
1091                 return (*this == That) || (*this < That);
1092         }
1093
1094         bool operator>(const version_tuple& That) const
1095         {
1096                 return !(*this <= That);
1097         }
1098
1099         bool operator>=(const version_tuple& That) const
1100         {
1101                 return !(*this < That);
1102         }
1103 };
1104
1105 template<class Elem, class Tr> std::basic_ostream<Elem, Tr>& operator<<(std::basic_ostream<Elem, Tr>& ostr, const version_tuple& v)
1106 {
1107         std::ios_base::fmtflags flags = ostr.flags();
1108         ostr.flags(std::ios_base::dec);
1109         ostr << v.get_major();
1110         ostr << Tr::to_char_type('.');
1111         ostr << v.get_minor();
1112         ostr << Tr::to_char_type('.');
1113         ostr << v.get_build_major();
1114         ostr << Tr::to_char_type('.');
1115         ostr << v.get_build_minor();
1116         ostr.flags(flags);
1117         return ostr;
1118 }
1119
1120 template<class Elem, class Tr> std::basic_istream<Elem, Tr>& operator>>(std::basic_istream<Elem, Tr>& istr, version_tuple& v)
1121 {
1122         const std::ctype<Elem>& ct = std::use_facet<std::ctype<Elem> >(istr.getloc());
1123         unsigned short a = 0, b = 0, c = 0, d = 0;
1124         Elem ch;
1125
1126         std::ios_base::fmtflags flags = istr.setf(std::ios_base::dec);
1127
1128         if(istr >> a)
1129         {
1130                 istr >> ch;
1131
1132                 if(ch == ct.widen('.'))
1133                 {
1134                         if(istr >> b)
1135                         {
1136                                 istr >> ch;
1137
1138                                 if(ch == ct.widen('.'))
1139                                 {
1140                                         if(istr >> c)
1141                                         {
1142                                                 istr >> ch;
1143
1144                                                 if(ch == ct.widen('.'))
1145                                                         istr >> d;
1146                                                 else
1147                                                         istr.putback(ch);
1148                                         }
1149                                 }
1150                                 else
1151                                         istr.putback(ch);
1152
1153                                 if(istr)
1154                                 {
1155                                         v = version_tuple(a, b, c, d);
1156                                         istr.flags(flags);
1157                                         return istr;
1158                                 }
1159                         }
1160                 }
1161                 else
1162                         istr.putback(ch);
1163         }
1164
1165         istr.flags(flags);
1166         istr.setstate(std::ios_base::failbit);
1167         return istr;
1168 }
1169
1170 struct cl_version: public version_tuple
1171 {
1172 private:
1173         bool m_optimizing;
1174
1175 public:
1176         cl_version(): m_optimizing() {}
1177
1178         cl_version(const version_tuple& version_number, bool optimizing = false):
1179                 version_tuple(version_number), m_optimizing(optimizing) {}
1180
1181         cl_version
1182         (
1183                 unsigned short major,
1184                 unsigned short minor,
1185                 unsigned short build_major = 0,
1186                 unsigned short build_minor = 0,
1187                 bool optimizing = false,
1188                 bool analyze = false
1189         ):
1190                 version_tuple(major, minor, build_major, build_minor), m_optimizing(optimizing) {}
1191
1192         cl_version(const cl_version& That): version_tuple(That), m_optimizing(That.m_optimizing) {}
1193
1194         const cl_version& operator=(const cl_version& That)
1195         {
1196                 version_tuple::operator=(That);
1197                 m_optimizing = That.m_optimizing;
1198                 return *this;
1199         }
1200
1201         bool is_optimizing() const
1202         {
1203                 return m_optimizing;
1204         }
1205
1206         bool operator==(const cl_version& That) const
1207         {
1208                 return this->m_optimizing == That.m_optimizing && this->version_tuple::operator==(That);
1209         }
1210
1211         bool operator<(const cl_version& That) const
1212         {
1213                 return (!this->m_optimizing && That.m_optimizing) || this->version_tuple::operator<(That);
1214         }
1215
1216         bool operator<=(const cl_version& That) const
1217         {
1218                 return (*this == That) || (*this < That);
1219         }
1220
1221         bool operator>(const cl_version& That) const
1222         {
1223                 return !(*this <= That);
1224         }
1225
1226         bool operator>=(const cl_version& That) const
1227         {
1228                 return !(*this < That);
1229         }
1230
1231         operator bool() const
1232         {
1233                 return get_major() || get_minor() || get_build_major() || get_build_minor();
1234         }
1235 };
1236
1237 struct link_version: public version_tuple
1238 {
1239 public:
1240         link_version() {}
1241
1242         link_version(const version_tuple& version_number): version_tuple(version_number) {}
1243
1244         link_version
1245         (
1246                 unsigned short major,
1247                 unsigned short minor,
1248                 unsigned short build_major = 0,
1249                 unsigned short build_minor = 0
1250         ):
1251                 version_tuple(major, minor, build_major, build_minor) {}
1252
1253         link_version(const link_version& That): version_tuple(That) {}
1254
1255         const link_version& operator=(const link_version& That)
1256         {
1257                 version_tuple::operator=(That);
1258                 return *this;
1259         }
1260
1261         bool operator==(const cl_version& That) const
1262         {
1263                 return this->version_tuple::operator==(That);
1264         }
1265
1266         bool operator<(const cl_version& That) const
1267         {
1268                 return this->version_tuple::operator<(That);
1269         }
1270
1271         bool operator<=(const cl_version& That) const
1272         {
1273                 return (*this == That) || (*this < That);
1274         }
1275
1276         bool operator>(const cl_version& That) const
1277         {
1278                 return !(*this <= That);
1279         }
1280
1281         bool operator>=(const cl_version& That) const
1282         {
1283                 return !(*this < That);
1284         }
1285
1286         operator bool() const
1287         {
1288                 return get_major() || get_minor() || get_build_major() || get_build_minor();
1289         }
1290 };
1291
1292 template<typename T>
1293 struct type_holder
1294 {
1295         typedef T type;
1296 };
1297
1298 template<class Elem, class Traits, class Ax>
1299 std::basic_string<Elem, Traits, Ax> get_env(const Elem * name, const type_holder<Traits>&, const type_holder<Ax>&)
1300 {
1301         DWORD cchValue = 0;
1302         std::vector<Elem, Ax> value;
1303
1304         for(;;)
1305         {
1306                 value.resize(cchValue);
1307
1308                 if(type_equals<Elem, CHAR>::value)
1309                         cchValue = GetEnvironmentVariableA(reinterpret_cast<const CHAR *>(name), reinterpret_cast<CHAR *>(cchValue ? &(value[0]) : NULL), cchValue);
1310                 else if(type_equals<Elem, WCHAR>::value)
1311                         cchValue = GetEnvironmentVariableW(reinterpret_cast<const WCHAR *>(name), reinterpret_cast<WCHAR *>(cchValue ? &(value[0]) : NULL), cchValue);
1312
1313                 if(cchValue == 0)
1314                         return std::basic_string<Elem, Traits, Ax>();
1315
1316                 if(cchValue <= value.size())
1317                         break;
1318         }
1319
1320         value.resize(cchValue);
1321         return std::basic_string<Elem, Traits, Ax>(value.begin(), value.end());
1322 }
1323
1324 template<class Traits, class Ax, class Elem>
1325 std::basic_string<Elem, Traits, Ax> get_env(const Elem * name)
1326 {
1327         return get_env(name, type_holder<Traits>(), type_holder<Ax>());
1328 }
1329
1330 template<class Traits, class Elem>
1331 std::basic_string<Elem, Traits> get_env(const Elem * name)
1332 {
1333         return get_env(name, type_holder<Traits>(), type_holder<typename std::basic_string<Elem>::allocator_type>());
1334 }
1335
1336 template<class Elem>
1337 std::basic_string<Elem> get_env(const Elem * name)
1338 {
1339         return get_env(name, type_holder<typename std::basic_string<Elem>::traits_type>(), type_holder<typename std::basic_string<Elem>::allocator_type>());
1340 }
1341
1342 template<class Elem>
1343 void set_env(const Elem * name, const Elem * value)
1344 {
1345         if(type_equals<Elem, CHAR>::value)
1346                 SetEnvironmentVariableA(reinterpret_cast<const CHAR *>(name), reinterpret_cast<const CHAR *>(value));
1347         else if(type_equals<Elem, WCHAR>::value)
1348                 SetEnvironmentVariableW(reinterpret_cast<const WCHAR *>(name), reinterpret_cast<const WCHAR *>(value));
1349 }
1350
1351 template<class CharT>
1352 FILE * pipe_open(const CharT * commandLine, const CharT * mode)
1353 {
1354         if(type_equals<CharT, char>::value)
1355                 return _popen(reinterpret_cast<const char *>(commandLine), reinterpret_cast<const char *>(mode));
1356         else if(type_equals<CharT, wchar_t>::value)
1357                 return _wpopen(reinterpret_cast<const wchar_t *>(commandLine), reinterpret_cast<const wchar_t *>(mode));
1358         else
1359                 return NULL;
1360 }
1361
1362 template<class CharT, class CharT2>
1363 FILE * pipe_open_override_path(const CharT * commandLine, const CharT * mode, const CharT2 * newPath)
1364 {
1365         FILE * pipe = NULL;
1366         const CharT2 path[] = { 'P', 'A', 'T', 'H', 0 };
1367
1368         std::basic_string<CharT2> oldPath;
1369
1370         if(newPath)
1371         {
1372                 oldPath = get_env(path);
1373                 set_env(path, newPath);
1374         }
1375
1376         try
1377         {
1378                 pipe = pipe_open(commandLine, mode);
1379         }
1380         catch(...)
1381         {
1382                 if(pipe != NULL)
1383                         fclose(pipe);
1384
1385                 if(newPath)
1386                         set_env(path, oldPath.c_str());
1387
1388                 throw;
1389         }
1390
1391         if(newPath)
1392                 set_env(path, oldPath.c_str());
1393
1394         return pipe;
1395 }
1396
1397 template<class InIter, class IsSep>
1398 std::pair<InIter, InIter> tokenize(InIter begin, InIter end, IsSep isSeparator)
1399 {
1400         InIter beginToken = std::find_if(begin, end, std::not1(isSeparator));
1401         InIter endToken = std::find_if(beginToken, end, isSeparator);
1402         return std::make_pair(beginToken, endToken);
1403 }
1404
1405 std::locale clocale("C");
1406 const std::ctype<char>& cctype = std::use_facet<std::ctype<char> >(clocale);
1407
1408 template<const std::ctype_base::mask Mask>
1409 struct is_ctype_l: public std::binary_function<std::locale, char, bool>
1410 {
1411 public:
1412         result_type operator()(const first_argument_type& locale, second_argument_type c) const
1413         {
1414                 return std::use_facet<std::ctype<char> >(locale).is(Mask, c);
1415         }
1416 };
1417
1418 typedef is_ctype_l<std::ctype_base::space> is_space_l;
1419
1420 template<const std::ctype_base::mask Mask>
1421 struct is_ctype: public std::unary_function<char, bool>
1422 {
1423 private:
1424         const std::locale& m_locale;
1425         is_ctype_l<Mask> m_is_ctype_l;
1426
1427 public:
1428         is_ctype(const std::locale& locale): m_locale(locale) {}
1429
1430         result_type operator()(argument_type c) const
1431         {
1432                 return m_is_ctype_l(m_locale, c);
1433         }
1434 };
1435
1436 typedef is_ctype<std::ctype_base::space> is_space;
1437
1438 template<class Elem, size_t N>
1439 std::pair<const Elem *, const Elem *> string_literal_token(const Elem (& lit)[N])
1440 {
1441         return std::make_pair(lit, lit + ((N) - 1));
1442 }
1443
1444 template<class Iter, class Iter2>
1445 bool token_equals(const std::pair<Iter, Iter>& tokenX, const std::pair<Iter2, Iter2>& tokenY)
1446 {
1447         return std::distance(tokenX.first, tokenX.second) == std::distance(tokenY.first, tokenY.second) && std::equal(tokenX.first, tokenX.second, tokenY.first);
1448 }
1449
1450 std::pair<const char *, const char *> GetClArchToken(const std::string& arch)
1451 {
1452         if(arch == "i386")
1453                 return string_literal_token("80x86");
1454         else if(arch == "amd64")
1455                 return string_literal_token("x64");
1456         else if(arch == "arm")
1457                 return string_literal_token("ARM");
1458         else
1459                 return string_literal_token("");
1460 }
1461
1462 template<class Elem>
1463 cl_version CheckClVersion(const std::string& arch, const Elem * pathOverride)
1464 {
1465         stdio_filebuf clVersionInfoBuf(pipe_open_override_path(_T("cl /nologo- 2>&1 >nul <nul"), _T("rt"), pathOverride));
1466         std::istream clVersionInfo(&clVersionInfoBuf);
1467
1468         std::pair<const char *, const char *> archToken = GetClArchToken(arch);
1469
1470         version_tuple clVersionNumber;
1471         bool clOptimizing = false;
1472         bool clTargetArch = false;
1473
1474         std::string clVersionLine;
1475         getline(clVersionInfo, clVersionLine);
1476
1477         for
1478         (
1479                 std::pair<std::string::iterator, std::string::iterator> token = tokenize(clVersionLine.begin(), clVersionLine.end(), is_space(clocale));
1480                 token.first != token.second;
1481                 token = tokenize(token.second, clVersionLine.end(), is_space(clocale))
1482         )
1483         {
1484                 // Is the compiler optimizing?
1485                 if(token_equals(token, string_literal_token("Optimizing")))
1486                 {
1487                         clOptimizing = true;
1488                         continue;
1489                 }
1490
1491                 // Is this the version number?
1492                 range_streambuf<std::string::const_iterator> tokenBuf(token.first, token.second);
1493                 std::istream tokenStream(&tokenBuf);
1494
1495                 if(tokenStream >> clVersionNumber)
1496                         continue;
1497
1498                 // Does the compiler support the target architecture?
1499                 if(token_equals(token, archToken))
1500                 {
1501                         clTargetArch = true;
1502                         continue;
1503                 }
1504         }
1505
1506         if(clTargetArch)
1507                 return cl_version(clVersionNumber, clOptimizing);
1508         else
1509                 return cl_version();
1510 }
1511
1512 cl_version CheckClVersion(const std::string& arch)
1513 {
1514         return CheckClVersion(arch, (const char *)0);
1515 }
1516
1517 std::pair<const _TCHAR *, const _TCHAR *> GetLinkArchToken(const std::string& arch)
1518 {
1519         if(arch == "i386")
1520                 return string_literal_token(_T("X86"));
1521         else if(arch == "amd64")
1522                 return string_literal_token(_T("X64"));
1523         else if(arch == "arm")
1524                 return string_literal_token(_T("ARM"));
1525         else
1526                 return string_literal_token(_T(""));
1527 }
1528
1529 template<class Elem>
1530 link_version CheckLinkVersion(const std::string& arch, const Elem * pathOverride)
1531 {
1532         std::pair<const _TCHAR *, const _TCHAR *> archToken = GetLinkArchToken(arch);
1533
1534         std::basic_string<_TCHAR> linkCmdLine;
1535         linkCmdLine.append(_T("link /nologo- /machine:\""));
1536         linkCmdLine.append(archToken.first, archToken.second);
1537         linkCmdLine.append(_T("\" <nul 2>nul"));
1538
1539         stdio_filebuf linkOutputBuf(pipe_open_override_path(linkCmdLine.c_str(), _T("rt"), pathOverride));
1540         std::istream linkOutput(&linkOutputBuf);
1541
1542         link_version linkVersion;
1543
1544         std::string linkOutputLine;
1545
1546         if(getline(linkOutput, linkOutputLine))
1547         {
1548                 for
1549                 (
1550                         std::pair<std::string::iterator, std::string::iterator> token = tokenize(linkOutputLine.begin(), linkOutputLine.end(), is_space(clocale));
1551                         token.first != token.second;
1552                         token = tokenize(token.second, linkOutputLine.end(), is_space(clocale))
1553                 )
1554                 {
1555                         range_streambuf<std::string::const_iterator> tokenBuf(token.first, token.second);
1556                         std::istream tokenStream(&tokenBuf);
1557
1558                         version_tuple linkVersionNumber;
1559
1560                         if(tokenStream >> linkVersionNumber)
1561                         {
1562                                 linkVersion = linkVersionNumber;
1563                                 break;
1564                         }
1565                 }
1566         }
1567
1568         if(linkVersion)
1569         {
1570                 bool linkArchCheckFail = false;
1571
1572                 while(!linkArchCheckFail && getline(linkOutput, linkOutputLine))
1573                 {
1574                         linkArchCheckFail =
1575                                 knuth_morris_pratt::search(linkOutputLine.begin(), linkOutputLine.end(), "LNK4012") != linkOutputLine.end() ||
1576                                 knuth_morris_pratt::search(linkOutputLine.begin(), linkOutputLine.end(), "LNK1146") != linkOutputLine.end();
1577                 }
1578
1579                 if(linkArchCheckFail)
1580                         linkVersion = link_version();
1581         }
1582
1583         return linkVersion;
1584 }
1585
1586 link_version CheckLinkVersion(const std::string& arch)
1587 {
1588         return CheckLinkVersion(arch, (const char *)0);
1589 }
1590
1591 template<class Elem, class Traits, class Ax>
1592 void CharsToString(HRESULT& hr, std::basic_string<Elem, Traits, Ax>& str, const Elem * beginChars, const Elem * endChars)
1593 {
1594         if(SUCCEEDED(hr))
1595                 str = std::basic_string<Elem, Traits, Ax>(beginChars, endChars);
1596 }
1597
1598 template<class Traits, class Ax>
1599 void CharsToString(HRESULT& hr, std::basic_string<CHAR, Traits, Ax>& str, const WCHAR * beginChars, const WCHAR * endChars)
1600 {
1601         if(!SUCCEEDED(hr))
1602                 return;
1603
1604         UINT cchChars = endChars - beginChars;
1605         int cch = WideCharToMultiByte(CP_ACP, 0, beginChars, cchChars, NULL, 0, NULL, NULL);
1606
1607         if(cch <= 0)
1608         {
1609                 hr = HRESULT_FROM_WIN32(GetLastError());
1610                 return;
1611         }
1612
1613         CHAR * psz = new CHAR[cch];
1614
1615         if(psz == NULL)
1616         {
1617                 hr = E_OUTOFMEMORY;
1618                 return;
1619         }
1620
1621         cch = WideCharToMultiByte(CP_ACP, 0, beginChars, cchChars, psz, cch, NULL, NULL);
1622
1623         if(cch <= 0)
1624                 hr = HRESULT_FROM_WIN32(GetLastError());
1625         else
1626                 str = std::basic_string<CHAR, Traits, Ax>(psz, psz + cch);
1627
1628         delete[] psz;
1629 }
1630
1631 template<class Traits, class Ax>
1632 void CharsToString(HRESULT& hr, std::basic_string<WCHAR, Traits, Ax>& str, const CHAR * beginChars, const CHAR * endChars)
1633 {
1634         if(!SUCCEEDED(hr))
1635                 return;
1636
1637         UINT cchChars = endChars - beginChars;
1638         int cch = MultiByteToWideChar(CP_ACP, 0, beginChars, cchChars, NULL, 0);
1639
1640         if(cch <= 0)
1641         {
1642                 hr = HRESULT_FROM_WIN32(GetLastError());
1643                 return;
1644         }
1645
1646         WCHAR * psz = new WCHAR[cch];
1647
1648         if(psz == NULL)
1649         {
1650                 hr = E_OUTOFMEMORY;
1651                 return;
1652         }
1653
1654         cch = MultiByteToWideChar(CP_ACP, 0, beginChars, cchChars, psz, cch);
1655
1656         if(cch <= 0)
1657                 hr = HRESULT_FROM_WIN32(GetLastError());
1658         else
1659                 str = std::basic_string<WCHAR, Traits, Ax>(psz, psz + cch);
1660
1661         delete[] psz;
1662 }
1663
1664 template<class Elem, class Traits, class Ax>
1665 void BSTRToString(HRESULT& hr, std::basic_string<Elem, Traits, Ax>& str, BSTR bstr)
1666 {
1667         CharsToString(hr, str, bstr, bstr + SysStringLen(bstr));
1668 }
1669
1670 std::vector<std::string> SplitPath(const std::string& strPath)
1671 {
1672         std::vector<std::string> path;
1673         std::string::const_iterator cur = strPath.begin();
1674         std::string::const_iterator end = strPath.end();
1675
1676         while(!(cur == end))
1677         {
1678                 std::string::const_iterator itemBegin = cur;
1679                 std::string::const_iterator itemEnd = std::find(cur, end, ';');
1680
1681                 if(!(itemBegin == itemEnd))
1682                         path.push_back(std::string(itemBegin, itemEnd));
1683
1684                 cur = itemEnd;
1685
1686                 if(!(cur == end))
1687                         ++ cur;
1688         }
1689
1690         return path;
1691 }
1692
1693 std::vector<std::string> ParsePlatformPath(HRESULT& hr, IDispatch * pPlatform, BSTR bstrPath)
1694 {
1695         std::vector<std::string> path;
1696
1697         if(FAILED(hr))
1698                 return path;
1699
1700         VARIANT varPath;
1701         VariantInit(&varPath);
1702         V_VT(&varPath) = VT_BSTR;
1703         V_BSTR(&varPath) = bstrPath;
1704
1705         VARIANT varRet = dispInvoke(hr, pPlatform, OLESTR("Evaluate"), varPath, VT_BSTR);
1706
1707         std::string strPath;
1708         BSTRToString(hr, strPath, V_BSTR(&varRet));
1709
1710         VariantClear(&varRet);
1711
1712         path = SplitPath(strPath);
1713         return path;
1714 }
1715
1716 VARIANT GetDTEProjectEngine(HRESULT& hr, IDispatch * pDTE)
1717 {
1718         VARIANT varVCProjects = oleString(hr, OLESTR("VCProjects"));
1719         VARIANT varVCProjectEngine = oleString(hr, OLESTR("VCProjectEngine"));
1720         VARIANT varProjects = dispInvoke(hr, pDTE, OLESTR("GetObject"), varVCProjects, VT_DISPATCH);
1721         VARIANT varProjectsProperties = dispPropGet(hr, V_DISPATCH(&varProjects), OLESTR("Properties"), VT_DISPATCH);
1722         VARIANT varProjectEngineProperty = dispInvoke(hr, V_DISPATCH(&varProjectsProperties), varVCProjectEngine, VT_DISPATCH);
1723         VARIANT varRet = dispPropGet(hr, V_DISPATCH(&varProjectEngineProperty), OLESTR("Object"), VT_DISPATCH);
1724         VariantClear(&varProjectEngineProperty);
1725         VariantClear(&varProjectsProperties);
1726         VariantClear(&varProjects);
1727         VariantClear(&varVCProjectEngine);
1728         VariantClear(&varVCProjects);
1729         return varRet;
1730 }
1731
1732 VARIANT GetDTEPlatformPath(HRESULT& hr, IDispatch * pDTE, BSTR bstrPlatformName, const OLECHAR * pszPathName)
1733 {
1734         VARIANTARG argsProperties[2] = { oleString(hr, OLESTR("VCDirectories")), oleString(hr, OLESTR("Projects")) };
1735
1736         VARIANT varProperties;
1737         VariantInit(&varProperties);
1738
1739         if(SUCCEEDED(hr))
1740                 hr = dispPropGet(pDTE, OLESTR("Properties"), argsProperties, ARRAYSIZE(argsProperties), VT_DISPATCH, varProperties);
1741
1742         VARIANT varPathName = oleString(hr, pszPathName);
1743         VARIANT varPath = dispInvoke(hr, V_DISPATCH(&varProperties), varPathName, VT_BSTR);
1744
1745         VARIANT varRet;
1746         VariantInit(&varRet);
1747
1748         if(SUCCEEDED(hr))
1749         {
1750                 const OLECHAR * pCur = V_BSTR(&varPath);
1751                 const OLECHAR * pEnd = V_BSTR(&varPath) + SysStringLen(V_BSTR(&varPath));
1752
1753                 while(!(pCur == pEnd))
1754                 {
1755                         const OLECHAR * pBeginName = pCur;
1756                         const OLECHAR * pEndName = std::find(pBeginName, pEnd, OLESTR('|'));
1757                         const OLECHAR * pBeginValue = pEndName == pEnd ? pEndName : pEndName + 1;
1758                         const OLECHAR * pEndValue = std::find(pBeginValue, pEnd, OLESTR('|'));
1759
1760                         pCur = pEndValue;
1761
1762                         if(!(pCur == pEnd))
1763                                 ++ pCur;
1764
1765                         BSTR bstrName = SysAllocStringLen(pBeginName, pEndName - pBeginName);
1766
1767                         if(bstrName)
1768                         {
1769                                 hr = VarBstrCmp(bstrName, bstrPlatformName, 0, NORM_IGNORECASE);
1770
1771                                 if(hr == VARCMP_EQ)
1772                                 {
1773                                         BSTR bstrRet = SysAllocStringLen(pBeginValue, pEndValue - pBeginValue);
1774
1775                                         if(bstrRet)
1776                                         {
1777                                                 V_VT(&varRet) = VT_BSTR;
1778                                                 V_BSTR(&varRet) = bstrRet;
1779                                         }
1780                                         else
1781                                                 hr = E_OUTOFMEMORY;
1782                                 }
1783
1784                                 SysFreeString(bstrName);
1785
1786                                 if(FAILED(hr) || hr == VARCMP_EQ)
1787                                         break;
1788                         }
1789                         else
1790                         {
1791                                 hr = E_OUTOFMEMORY;
1792                                 break;
1793                         }
1794                 }
1795         }
1796
1797         VariantClear(&varPath);
1798         VariantClear(&varPathName);
1799         VariantClear(&varProperties);
1800         VariantClear(&argsProperties[1]);
1801         VariantClear(&argsProperties[0]);
1802
1803         if(SUCCEEDED(hr) && V_VT(&varRet) != VT_BSTR)
1804         {
1805                 VariantClear(&varRet);
1806                 varRet = oleString(hr, OLESTR(""));
1807         }
1808
1809         return varRet;
1810 }
1811
1812 cl_version msCompilerVersion;
1813 std::string msCompilerPath;
1814 std::vector<std::string> msCompilerIncludeDirs; // TODO: use this
1815 std::string msCompilerSource; // TODO: use this
1816
1817 link_version msLinkerVersion;
1818 std::string msLinkerPath;
1819 std::vector<std::string> msLinkerLibDirs; // TODO: use this
1820 std::string msLinkerSource; // TODO: use this
1821
1822 void ProcessVCPlatform(HRESULT& hr, const std::string& arch, bool wantCompiler, bool wantLinker, IDispatch * pVCProjectEngine, IDispatch * pPlatform, BSTR bstrPath, BSTR bstrInclude, BSTR bstrLib)
1823 {
1824         if(FAILED(hr))
1825                 return;
1826
1827         std::basic_string<OLECHAR> strPath = replace(std::basic_string<OLECHAR>(bstrPath, SysStringLen(bstrPath)), OLESTR("$(PATH)"), OLESTR("%PATH%"));
1828
1829         VARIANT varPath;
1830         VariantInit(&varPath);
1831         V_VT(&varPath) = VT_BSTR;
1832         V_BSTR(&varPath) = SysAllocStringLen(strPath.c_str(), strPath.size());
1833
1834         if(!V_BSTR(&varPath))
1835                 hr = E_OUTOFMEMORY;
1836
1837         VARIANT varRet = dispInvoke(hr, pPlatform, OLESTR("Evaluate"), varPath, VT_BSTR);
1838
1839         if(SUCCEEDED(hr))
1840         {
1841                 std::basic_string<OLECHAR> strPathOverride = replace
1842                 (
1843                         std::basic_string<OLECHAR>(V_BSTR(&varRet), V_BSTR(&varRet) + SysStringLen(V_BSTR(&varRet))),
1844                         OLESTR("%PATH%"),
1845                         get_env(OLESTR("PATH"))
1846                 );
1847
1848                 cl_version clVersion;
1849                 link_version linkVersion;
1850
1851                 if(wantCompiler)
1852                         clVersion = CheckClVersion(arch, strPathOverride.c_str());
1853
1854                 if(wantLinker)
1855                         linkVersion = CheckLinkVersion(arch, strPathOverride.c_str());
1856
1857                 // TODO: need a way to choose the desired tools and which version
1858                 // BUGBUG: for now, only set the new version if both tools are the highest version yet
1859                 if((!wantCompiler || (clVersion && clVersion > msCompilerVersion)) && (!wantLinker || (linkVersion && linkVersion > msLinkerVersion)))
1860                 {
1861                         std::string strPath;
1862                         BSTRToString(hr, strPath, V_BSTR(&varRet));
1863                         strPath = replace(strPath, "%PATH%", "$(PATH)");
1864
1865                         std::vector<std::string> include = ParsePlatformPath(hr, pPlatform, bstrInclude);
1866                         std::vector<std::string> lib = ParsePlatformPath(hr, pPlatform, bstrLib);
1867
1868                         if(SUCCEEDED(hr))
1869                         {
1870                                 if(wantCompiler)
1871                                 {
1872                                         msCompilerVersion = clVersion;
1873                                         msCompilerPath = strPath;
1874                                         msCompilerIncludeDirs = include;
1875                                         //msCompilerSource; // TODO: fill this in
1876                                 }
1877
1878                                 if(wantLinker)
1879                                 {
1880                                         msLinkerVersion = linkVersion;
1881                                         msLinkerPath = strPath;
1882                                         msLinkerLibDirs = lib;
1883                                         //msLinkerSource; // TODO: fill this in
1884                                 }
1885                         }
1886                 }
1887         }
1888
1889         VariantClear(&varPath);
1890         VariantClear(&varRet);
1891 }
1892
1893 bool IsVCPlatformSupported(HRESULT& hr, const std::string& arch, IDispatch * pPlatform)
1894 {
1895         bool ret = false;
1896
1897         VARIANT varPlatformName = dispPropGet(hr, pPlatform, OLESTR("Name"), VT_BSTR);
1898
1899         if(arch == "i386")
1900         {
1901                 VARIANT varWin32 = oleString(hr, OLESTR("Win32"));
1902
1903                 if(SUCCEEDED(hr))
1904                 {
1905                         hr = VarBstrCmp(V_BSTR(&varWin32), V_BSTR(&varPlatformName), 0, NORM_IGNORECASE);
1906                         ret = hr == VARCMP_EQ;
1907                 }
1908
1909                 VariantClear(&varWin32);
1910         }
1911         else if(arch == "amd64")
1912         {
1913                 VARIANT varX64 = oleString(hr, OLESTR("x64"));
1914
1915                 if(SUCCEEDED(hr))
1916                 {
1917                         hr = VarBstrCmp(V_BSTR(&varX64), V_BSTR(&varPlatformName), 0, NORM_IGNORECASE);
1918                         ret = hr == VARCMP_EQ;
1919                 }
1920
1921                 VariantClear(&varX64);
1922         }
1923         else if(arch == "arm")
1924         {
1925                 VARIANT varARM = oleString(hr, OLESTR("ARM"));
1926                 VARIANT varARCHFAM = oleString(hr, OLESTR("ARCHFAM"));
1927                 VARIANT varArchFamily = dispInvoke(hr, pPlatform, OLESTR("GetMacroValue"), varARCHFAM, VT_BSTR);
1928
1929                 if(SUCCEEDED(hr))
1930                 {
1931                         hr = VarBstrCmp(V_BSTR(&varARM), V_BSTR(&varArchFamily), 0, NORM_IGNORECASE);
1932                         ret = hr == VARCMP_EQ;
1933                 }
1934
1935                 VariantClear(&varArchFamily);
1936                 VariantClear(&varARCHFAM);
1937                 VariantClear(&varARM);
1938         }
1939
1940         VariantClear(&varPlatformName);
1941
1942         return SUCCEEDED(hr) && ret;
1943 }
1944
1945 void EnumerateVCTools(const std::string& arch, bool wantCompiler, bool wantLinker, const OLECHAR * szProductTag)
1946 {
1947         size_t cchProductTag = std::wcslen(szProductTag);
1948         HRESULT hr;
1949
1950         hr = OleInitialize(NULL);
1951
1952         if(SUCCEEDED(hr))
1953         {
1954                 std::basic_string<TCHAR> strProductKey;
1955                 CharsToString(hr, strProductKey, szProductTag, szProductTag + cchProductTag);
1956
1957                 if(SUCCEEDED(hr))
1958                 {
1959                         strProductKey = TEXT("SOFTWARE\\Microsoft\\") + strProductKey;
1960
1961                         HKEY hkVisualStudio;
1962                         hr = HRESULT_FROM_WIN32(RegOpenKeyEx(HKEY_LOCAL_MACHINE, strProductKey.c_str(), 0, KEY_ENUMERATE_SUB_KEYS, &hkVisualStudio));
1963
1964                         if(SUCCEEDED(hr))
1965                         {
1966                                 for(DWORD i = 0; ; ++ i)
1967                                 {
1968                                         TCHAR szProductVersion[255 + 1];
1969                                         DWORD cchProductVersion = ARRAYSIZE(szProductVersion);
1970
1971                                         hr = HRESULT_FROM_WIN32(RegEnumKeyEx(hkVisualStudio, i, szProductVersion, &cchProductVersion, NULL, NULL, NULL, NULL));
1972
1973                                         if(SUCCEEDED(hr))
1974                                         {
1975                                                 std::basic_string<OLECHAR> strProductVersion;
1976                                                 CharsToString(hr, strProductVersion, szProductVersion, szProductVersion + cchProductVersion);
1977
1978                                                 if(SUCCEEDED(hr))
1979                                                 {
1980                                                         std::basic_string<OLECHAR> strDTEProgId(szProductTag, szProductTag + cchProductTag);
1981                                                         strDTEProgId += OLESTR(".DTE.");
1982                                                         strDTEProgId += strProductVersion;
1983
1984                                                         CLSID clsidDTE;
1985                                                         hr = CLSIDFromProgID(strDTEProgId.c_str(), &clsidDTE);
1986
1987                                                         if(SUCCEEDED(hr))
1988                                                         {
1989                                                                 IDispatch * pDTE;
1990                                                                 hr = CoCreateInstance(clsidDTE, NULL, CLSCTX_ALL, IID_IDispatch, (void **)(void *)&pDTE);
1991
1992                                                                 if(SUCCEEDED(hr))
1993                                                                 {
1994                                                                         VARIANT varProjectEngine = GetDTEProjectEngine(hr, pDTE);
1995                                                                         VARIANT varPlatforms = dispPropGet(hr, V_DISPATCH(&varProjectEngine), OLESTR("Platforms"), VT_DISPATCH);
1996                                                                         VARIANT varCount = dispPropGet(hr, V_DISPATCH(&varPlatforms), OLESTR("Count"), VT_I4);
1997                                                                         VARIANT varI;
1998                                                                         VariantInit(&varI);
1999                                                                         V_VT(&varI) = VT_I4;
2000
2001                                                                         for(V_I4(&varI) = 1; V_I4(&varI) <= V_I4(&varCount); ++ V_I4(&varI))
2002                                                                         {
2003                                                                                 VARIANT varPlatform = dispInvoke(hr, V_DISPATCH(&varPlatforms), varI, VT_DISPATCH);
2004
2005                                                                                 if(IsVCPlatformSupported(hr, arch, V_DISPATCH(&varPlatform)))
2006                                                                                 {
2007                                                                                         VARIANT varPlatformName = dispPropGet(hr, V_DISPATCH(&varPlatform), OLESTR("Name"), VT_BSTR);
2008                                                                                         VARIANT varPath = GetDTEPlatformPath(hr, pDTE, V_BSTR(&varPlatformName), OLESTR("ExecutableDirectories"));
2009                                                                                         VARIANT varInclude = GetDTEPlatformPath(hr, pDTE, V_BSTR(&varPlatformName), OLESTR("IncludeDirectories"));
2010                                                                                         VARIANT varLib = GetDTEPlatformPath(hr, pDTE, V_BSTR(&varPlatformName), OLESTR("LibraryDirectories"));
2011
2012                                                                                         ProcessVCPlatform(hr, arch, wantCompiler, wantLinker, V_DISPATCH(&varProjectEngine), V_DISPATCH(&varPlatform), V_BSTR(&varPath), V_BSTR(&varInclude), V_BSTR(&varLib));
2013
2014                                                                                         VariantClear(&varLib);
2015                                                                                         VariantClear(&varInclude);
2016                                                                                         VariantClear(&varPath);
2017                                                                                         VariantClear(&varPlatformName);
2018                                                                                 }
2019
2020                                                                                 VariantClear(&varPlatform);
2021                                                                         }
2022
2023                                                                         VariantClear(&varI);
2024                                                                         VariantClear(&varCount);
2025                                                                         VariantClear(&varPlatforms);
2026                                                                         VariantClear(&varProjectEngine);
2027
2028                                                                         pDTE->Release();
2029                                                                 }
2030                                                         }
2031
2032                                                         // TODO: print an error message here
2033                                                 }
2034
2035                                                 hr = S_OK;
2036                                         }
2037                                         else if(hr == HRESULT_FROM_WIN32(ERROR_NO_MORE_ITEMS))
2038                                         {
2039                                                 hr = S_OK;
2040                                                 break;
2041                                         }
2042                                         else
2043                                                 break;
2044                                 }
2045                         }
2046                 }
2047
2048                 OleUninitialize();
2049         }
2050 }
2051
2052 const TCHAR * GetDDKArchPath(const std::string& arch)
2053 {
2054         if(arch == "i386")
2055                 return TEXT("x86");
2056         else if(arch == "amd64")
2057                 return TEXT("amd64");
2058         else
2059                 return NULL;
2060 }
2061
2062 void EnumerateDDKTools(const std::string& arch, bool wantCompiler, bool wantLinker)
2063 {
2064         const TCHAR * pszArchPath = GetDDKArchPath(arch);
2065
2066         if(pszArchPath == NULL)
2067                 return;
2068
2069         HRESULT hr;
2070
2071         HKEY hkDDK;
2072         hr = HRESULT_FROM_WIN32(RegOpenKeyEx(HKEY_LOCAL_MACHINE, TEXT("SOFTWARE\\Microsoft\\WINDDK"), 0, KEY_ENUMERATE_SUB_KEYS, &hkDDK));
2073
2074         if(SUCCEEDED(hr))
2075         {
2076                 for(DWORD i = 0; ; ++ i)
2077                 {
2078                         TCHAR szDDKVersion[255 + ARRAYSIZE(TEXT("\\Setup"))];
2079                         DWORD cchDDKVersion = ARRAYSIZE(szDDKVersion);
2080
2081                         hr = HRESULT_FROM_WIN32(RegEnumKeyEx(hkDDK, i, szDDKVersion, &cchDDKVersion, NULL, NULL, NULL, NULL));
2082
2083                         if(SUCCEEDED(hr))
2084                         {
2085                                 memcpy(szDDKVersion + cchDDKVersion, TEXT("\\Setup"), sizeof(TEXT("\\Setup")));
2086
2087                                 HKEY hkDDKVersion;
2088                                 hr = HRESULT_FROM_WIN32(RegOpenKeyEx(hkDDK, szDDKVersion, 0, KEY_QUERY_VALUE, &hkDDKVersion));
2089
2090                                 if(SUCCEEDED(hr))
2091                                 {
2092                                         TCHAR szDDKPath[MAX_PATH];
2093                                         DWORD cbDDKPath = sizeof(szDDKPath);
2094                                         DWORD dwType = 0;
2095
2096                                         hr = HRESULT_FROM_WIN32(RegQueryValueEx(hkDDKVersion, TEXT("BUILD"), NULL, &dwType, reinterpret_cast<BYTE *>(szDDKPath), &cbDDKPath));
2097
2098                                         if(SUCCEEDED(hr) && dwType == REG_SZ)
2099                                         {
2100 #if defined(_X86_)
2101                                                 static const TCHAR * const a_szBinPaths[] = { TEXT("x86") };
2102 #elif defined(_AMD64_)
2103                                                 // Prefer native tools, fall back on x86 if necessary
2104                                                 static const TCHAR * const a_szBinPaths[] = { TEXT("amd64"), TEXT("x86") };
2105 #elif defined(_IA64_)
2106                                                 // Prefer native tools, fall back on x86 if necessary
2107                                                 static const TCHAR * const a_szBinPaths[] = { TEXT("ia64"), TEXT("x86") };
2108 #endif
2109                                                 szDDKPath[cbDDKPath / sizeof(TCHAR)] = 0;
2110                                                 std::basic_string<TCHAR> strDDKPath(szDDKPath);
2111                                                 strDDKPath += TEXT("\\bin\\");
2112
2113                                                 std::basic_string<TCHAR>::size_type cchCutoff = strDDKPath.length();
2114
2115                                                 for(unsigned i = 0; i < ARRAYSIZE(a_szBinPaths); ++ i)
2116                                                 {
2117                                                         strDDKPath.resize(cchCutoff);
2118                                                         strDDKPath += a_szBinPaths[i];
2119                                                         strDDKPath += TEXT("\\");
2120                                                         strDDKPath += pszArchPath;
2121
2122                                                         cl_version clVersion;
2123                                                         link_version linkVersion;
2124
2125                                                         if(wantCompiler)
2126                                                                 clVersion = CheckClVersion(arch, strDDKPath.c_str());
2127
2128                                                         if(wantLinker)
2129                                                                 linkVersion = CheckLinkVersion(arch, strDDKPath.c_str());
2130
2131                                                         if((!wantCompiler || (clVersion && clVersion > msCompilerVersion)) && (!wantLinker || (linkVersion && linkVersion > msLinkerVersion)))
2132                                                         {
2133                                                                 std::string strPath;
2134                                                                 CharsToString(hr, strPath, strDDKPath.c_str(), strDDKPath.c_str() + strDDKPath.length());
2135
2136                                                                 if(SUCCEEDED(hr))
2137                                                                 {
2138                                                                         if(wantCompiler)
2139                                                                         {
2140                                                                                 msCompilerVersion = clVersion;
2141                                                                                 msCompilerPath = strPath;
2142                                                                                 msCompilerIncludeDirs.clear();
2143                                                                                 //msCompilerSource; // TODO: fill this in
2144                                                                         }
2145
2146                                                                         if(wantLinker)
2147                                                                         {
2148                                                                                 msLinkerVersion = linkVersion;
2149                                                                                 msLinkerPath = strPath;
2150                                                                                 msLinkerLibDirs.clear();
2151                                                                                 //msLinkerSource; // TODO: fill this in
2152                                                                         }
2153                                                                 }
2154                                                                 else
2155                                                                         break;
2156                                                         }
2157                                                 }
2158                                         }
2159
2160                                         RegCloseKey(hkDDKVersion);
2161                                 }
2162                         }
2163                         else if(hr == HRESULT_FROM_WIN32(ERROR_NO_MORE_ITEMS))
2164                         {
2165                                 hr = S_OK;
2166                                 break;
2167                         }
2168
2169                         if(FAILED(hr))
2170                                 break;
2171                 }
2172
2173                 RegCloseKey(hkDDK);
2174         }
2175 }
2176
2177 void DetectEnvironmentVCTools(const std::string& arch, bool wantCompiler, bool wantLinker)
2178 {
2179         cl_version clVersion;
2180         link_version linkVersion;
2181
2182         if(wantCompiler)
2183                 clVersion = CheckClVersion(arch);
2184
2185         if(wantLinker)
2186                 linkVersion = CheckLinkVersion(arch);
2187
2188         if((!wantCompiler || (clVersion && clVersion > msCompilerVersion)) && (!wantLinker || (linkVersion && linkVersion > msLinkerVersion)))
2189         {
2190                 if(wantCompiler)
2191                 {
2192                         msCompilerVersion = clVersion;
2193                         msCompilerPath.clear();
2194                         msCompilerIncludeDirs = SplitPath(get_env("INCLUDE"));
2195                         msCompilerSource = "environment";
2196                 }
2197
2198                 if(wantLinker)
2199                 {
2200                         msLinkerVersion = linkVersion;
2201                         msLinkerPath.clear();
2202                         msLinkerLibDirs = SplitPath(get_env("LIB"));
2203                         msLinkerSource = "environment";
2204                 }
2205         }
2206 }
2207
2208 void EnumerateMicrosoftTools(const std::string& arch, bool wantCompiler, bool wantLinker)
2209 {
2210         DetectEnvironmentVCTools(arch, wantCompiler, wantLinker);
2211
2212         if(!msCompilerVersion || !msLinkerVersion)
2213         {
2214                 EnumerateVCTools(arch, wantCompiler, wantLinker, OLESTR("VisualStudio"));
2215                 EnumerateVCTools(arch, wantCompiler, wantLinker, OLESTR("VCExpress"));
2216                 EnumerateDDKTools(arch, wantCompiler, wantLinker);
2217         }
2218 }
2219
2220 }
2221
2222 bool
2223 MingwBackend::DetectMicrosoftCompiler ( std::string& version, std::string& path )
2224 {
2225         bool wantCompiler = ProjectNode.configuration.Compiler == MicrosoftC;
2226         bool wantLinker = ProjectNode.configuration.Linker == MicrosoftLink;
2227
2228         if ( wantCompiler && !msCompilerVersion )
2229                 EnumerateMicrosoftTools ( Environment::GetArch(), wantCompiler, wantLinker );
2230
2231         bool ret = wantCompiler && msCompilerVersion;
2232
2233         if ( ret )
2234         {
2235                 compilerNeedsHelper = true;
2236                 compilerCommand = "cl";
2237
2238                 std::ostringstream compilerVersion;
2239                 compilerVersion << msCompilerVersion;
2240                 version = compilerVersion.str();
2241                 path = msCompilerPath;
2242         }
2243
2244         return ret;
2245 }
2246
2247 bool
2248 MingwBackend::DetectMicrosoftLinker ( std::string& version, std::string& path )
2249 {
2250         bool wantCompiler = ProjectNode.configuration.Compiler == MicrosoftC;
2251         bool wantLinker = ProjectNode.configuration.Linker == MicrosoftLink;
2252
2253         if ( wantLinker && !msLinkerVersion )
2254                 EnumerateMicrosoftTools ( Environment::GetArch(), wantCompiler, wantLinker );
2255
2256         bool ret = wantLinker && msLinkerVersion;
2257
2258         if ( ret )
2259         {
2260                 binutilsNeedsHelper = msLinkerPath.length() != 0;
2261                 binutilsCommand = "link";
2262
2263                 std::ostringstream linkerVersion;
2264                 linkerVersion << msLinkerVersion;
2265                 version = linkerVersion.str();
2266                 path = msLinkerPath;
2267         }
2268
2269         return ret;
2270 }
2271
2272 #endif
2273
2274 // TODO? attempt to support Microsoft tools on non-Windows?
2275 #if !defined(WIN32)
2276
2277 #include "../../pch.h"
2278
2279 #include "mingw.h"
2280
2281 bool
2282 MingwBackend::DetectMicrosoftCompiler ( std::string&, std::string& )
2283 {
2284         return false;
2285 }
2286
2287 bool
2288 MingwBackend::DetectMicrosoftLinker ( std::string&, std::string& )
2289 {
2290         return false;
2291 }
2292
2293 #endif
2294
2295 // EOF